目录
2.1 比较大小
2.2基本运算
2.3 统计相关的计算
2.4 张量的自动微分
张量计算 张量的计算内容主要包括：张量之间的大小比较，张量的基本运算，如元素之间的运算和矩阵之间的运算等，张量与统计相关的运算，如排序，最大值，最小值，最大值的位置等内容。
2.1 比较大小
对于torch.allclose()函数，比较的是两个元素是否接近，比较A和B是否接近的公式为： ∣A − B∣<= atol + rtol ×∣B∣
import torch
# 比较两个数是否接近
A = torch.tensor([10.0])
B = torch.tensor([10.1])
torch.allclose(A,B,rtol=1e-05,atol=1e-08,equal_nan=False)
torch.allclose(A, B, rtol=0.1, atol=0.01, equal_nan=False)
# 在不同的判断条件下，得出的结果也是不同的
# 如果equal_nan=True，那么缺失值可以判断为接近
A = torch.tensor(float("nan"))
print(torch.allclose(A, A, equal_nan=False))
print(torch.allclose(A, A, equal_nan=True))
A = torch.tensor([1, 2, 3, 4, 5, 6])
B = torch.arange(1, 7)
C = torch.unsqueeze(B, dim=0)
# torch.eq()函数用来判断两个元素是否相等
print(torch.eq(A, B))
print(torch.eq(A, C))
# torch.equal()函数可以判断两个张量是否具有相同的形状和元素
print(torch.equal(A, B))
print(torch.equal(A, C))
# torch.ge()函数是逐元素比较是否大于等于(>=)
print(torch.ge(A, B))
print(torch.ge(A, C))
# torch.gt()函数是逐元素比较大于
print(torch.gt(A, B))
print(torch.gt(A, C))
# torch.le()函数是逐元素比较是否小于等于(<=)
print(torch.le(A, B))
print(torch.le(A, C))
# torch.lt()函数是逐元素比较大于
print(torch.lt(A, B))
print(torch.lt(A, C))
# torch.ne()函数是逐元素比较不等于
print(torch.ne(A, B))
print(torch.ne(A, C))
# torch.isnan()函数用来判断是否为缺失值
# 缺失值是值：NULL，也包括表示数值确实的特殊数值（如，在系统中用-999来表示的数值不存在）
print(torch.isnan(torch.tensor([0, 1, float("nan"), 2])))输出：
False
True
tensor([True, True, True, True, True, True])
tensor([[True, True, True, True, True, True]])
True
False
tensor([True, True, True, True, True, True])
tensor([[True, True, True, True, True, True]])
tensor([False, False, False, False, False, False])
tensor([[False, False, False, False, False, False]])
tensor([True, True, True, True, True, True])
tensor([[True, True, True, True, True, True]])
tensor([False, False, False, False, False, False])
tensor([[False, False, False, False, False, False]])
tensor([False, False, False, False, False, False])
tensor([[False, False, False, False, False, False]])
tensor([False, False, True, False])2.2基本运算
# 矩阵逐元素相乘
a = torch.arange(6.0).reshape(2,3)
b = torch.linspace(10, 20, steps=6).reshape(2, 3)
print("a", a)
print("b", b)
print(a * b)
# 逐元素相除
print(a / b)
# 逐元素相加
print(a + b)
# 逐元素相减
print(a - b)
# 逐元素整除
print(b // a)
# 计算张量的幂可以使用torch.pow()函数，或者使用**
print(torch.pow(a, 3))
print(a ** 3)
# 计算张量的指数可以使用torch.exp()函数
print(torch.exp(a))
# 计算张量的对数可以使用torch.log()函数
print(torch.log(a))
# 计算张量的平方根可以使用torch.sqrt()函数
print(torch.sqrt(a))
print(a ** 0.5)
# 计算张量的平方根倒数可以使用torch.rsqrt()函数
print(torch.rsqrt(a))
print(1 / (a**0.5))
# 对张量的数据裁剪，有根据最大值裁剪torch.clamp_max()函数
# 将大于x的数值都替换为x
print(a, "\n", torch.clamp_max(a, 4))
# 有根据最小值裁剪torch.clamp_min()函数
# 将小于x的数值都替换为x
print(torch.clamp_min(a, 3))
# 有根据范围裁剪torch.clamp()函数
# 按照范围剪裁张量，小于边界的数值都替换为下界值，大于上界的数值都替换为上界
print(torch.clamp(a, 2.5, 4))
# torch.t()计算矩阵的转置
c = torch.t(a)
print(c)
# torch.matmul()输出两个矩阵的乘积
print(a.matmul(c))
# 矩阵相乘只计算最后面的两个维度的乘法
a = torch.arange(12.0).reshape(2, 2, 3)
b = torch.arange(12.0).reshape(2, 3, 2)
print(a, b)
ab = torch.matmul(a, b)
print(ab)
print(ab[0].eq(torch.matmul(a[0], b[0])))
print(ab[0].eq(torch.matmul(a[1], b[0])))
# 计算矩阵的逆
c = torch.rand(3, 3)
d = torch.inverse(c)
print(torch.mm(c, d))
# 计算张量矩阵的迹，对角线元素的和
print(torch.trace(torch.arange(9.0).reshape(3, 3)))a tensor([[0., 1., 2.],
[3., 4., 5.]])
b tensor([[10., 12., 14.],
[16., 18., 20.]])
tensor([[ 0., 12., 28.],
[ 48., 72., 100.]])
tensor([[0.0000, 0.0833, 0.1429],
[0.1875, 0.2222, 0.2500]])
tensor([[10., 13., 16.],
[19., 22., 25.]])
tensor([[-10., -11., -12.],
[-13., -14., -15.]])
tensor([[inf, 12., 7.],
[ 5., 4., 4.]])
tensor([[ 0., 1., 8.],
[ 27., 64., 125.]])
tensor([[ 0., 1., 8.],
[ 27., 64., 125.]])
tensor([[ 1.0000, 2.7183, 7.3891],
[ 20.0855, 54.5981, 148.4132]])
tensor([[ -inf, 0.0000, 0.6931],
[1.0986, 1.3863, 1.6094]])
tensor([[0.0000, 1.0000, 1.4142],
[1.7321, 2.0000, 2.2361]])
tensor([[0.0000, 1.0000, 1.4142],
[1.7321, 2.0000, 2.2361]])
tensor([[ inf, 1.0000, 0.7071],
[0.5774, 0.5000, 0.4472]])
tensor([[ inf, 1.0000, 0.7071],
[0.5774, 0.5000, 0.4472]])
tensor([[0., 1., 2.],
[3., 4., 5.]])
tensor([[0., 1., 2.],
[3., 4., 4.]])
tensor([[3., 3., 3.],
[3., 4., 5.]])
tensor([[2.5000, 2.5000, 2.5000],
[3.0000, 4.0000, 4.0000]])
tensor([[0., 3.],
[1., 4.],
[2., 5.]])
tensor([[ 5., 14.],
[14., 50.]])
tensor([[[ 0., 1., 2.],
[ 3., 4., 5.]],
[[ 6., 7., 8.],
[ 9., 10., 11.]]]) tensor([[[ 0., 1.],
[ 2., 3.],
[ 4., 5.]],
[[ 6., 7.],
[ 8., 9.],
[10., 11.]]])
tensor([[[ 10., 13.],
[ 28., 40.]],
[[172., 193.],
[244., 274.]]])
tensor([[True, True],
[True, True]])
tensor([[False, False],
[False, False]])
tensor([[ 1.0000e+00, 5.9605e-08, -2.9057e-07],
[ 5.9605e-08, 1.0000e+00, -1.7881e-07],
[ 5.9605e-08, -5.9605e-08, 1.0000e+00]])
tensor(12.)API方式的写法
# 此外，加减乘除还可以使用API
A = torch.tensor([1.,2.,3.,4.,5.,6.])
A = A.reshape(2,3)
print(A+3)
B = torch.ones(2,3)
print(B)
print(A+B) #广播原则 不会改变原有的结果
A.add(B) #不会改变原有的结果
print(A)
A.add_(B) #会改变原有的结果 很多后面加上_会就地改变原值
print(A)
print(torch.abs(A)) #它们不仅有这种静态方法
print(A.abs_()) #也是有实例方法的tensor([[4., 5., 6.], [7., 8., 9.]]) tensor([[1., 1., 1.], [1., 1., 1.]]) tensor([[2., 3., 4.], [5., 6., 7.]]) tensor([[1., 2., 3.], [4., 5., 6.]]) tensor([[2., 3., 4.], [5., 6., 7.]]) tensor([[2., 3., 4.], [5., 6., 7.]]) tensor([[2., 3., 4.], [5., 6., 7.]])
注意 abs,mean,cumsum,multiply,divide 都有这些性质
t = torch.rand(2,3)
print(t)
print(t.T) #转置 shape (3,2)
print(t.matmul(t.T))
#矩阵乘法的简化写法
print(t@(t.T))
print(t.sum())
print(t.sum().item()) #将其转为python的数据类型
result = t.mean()
print(result.item())tensor([[0.5961, 0.0197, 0.8739],
[0.8200, 0.0368, 0.2758]])
tensor([[0.5961, 0.8200],
[0.0197, 0.0368],
[0.8739, 0.2758]])
tensor([[1.1194, 0.7305],
[0.7305, 0.7498]])
tensor([[1.1194, 0.7305],
[0.7305, 0.7498]])
tensor(2.6223)
2.6223182678222656
0.437053054571151732.3 统计相关的计算
# 一维张量的最大值和最小值
a = torch.tensor([12., 34, 25, 11, 67, 32, 29, 30, 99, 55, 23, 44])
print("最大值：", a.max())
print("最大值位置：", a.argmax())
print("最小值", a.min())
print("最小值位置", a.argmin())
b = a.reshape(3, 4)
print("2-D张量：", b)
# 最大值及位置（每行）
print("最大值：", b.max(dim=1))
print("最大值位置：", b.argmax(dim=1))
# 最小值及位置（每列）
print("最小值", b.min(dim=0))
print("最小值位置", b.argmin(dim=0))
# torch.sort()可以对一维张量进行排序，或者对高维张量在指定的维度进行排序，输出排序结果，还会输出对应的值在原始位置的索引
print(torch.sort(a))
# 按照降序排序
print(torch.sort(a, descending=True))
# 对二维张量进行排序
bsort, bsort_id = torch.sort(b)
print("b sort", bsort)
print("b sort_id", bsort_id)
print("b argsort:", torch.argsort(b))
# torch.topk()根据指定的k值，计算出张量中取值大小为第k大的数值与数值所在的位置
# torch.kthvalue()根据指定的数值k，计算出张量中取值大小为第k小的数值与数值所在的位置
# 获取张量前几大的数值
print(torch.topk(a, 4))
# 获取2-D张量每列前几大的数值
btop2, btop2_id = torch.topk(b, 2, dim=0)
print("b 每列 top2", btop2)
print("b 每列 top2 位置", btop2_id)
# 获取张量第k小的数值和位置
print(torch.kthvalue(a, 3))
# 获取2-D张量第k小的数值和位置
print(torch.kthvalue(b, 3, dim=1))
# 获取2-D张量第k小的数值和位置
bkth, bkth_id = torch.kthvalue(b, 3, dim=1, keepdim=True)
print(bkth)
# torch.mean()根据指定的维度计算均值
# 计算每行的平均值
print(torch.mean(b, dim=1, keepdim=True))
# 计算每列的均值
print(torch.mean(b, dim=0, keepdim=True))
# torch.sum()根据指定的维度求和
# 计算每行的和
print(torch.sum(b, dim=1, keepdim=True))
# 计算每列的和
print(torch.sum(b, dim=0, keepdim=True))
# torch.cumsum()根据指定的维度计算累加和
# 按照行计算累加和
print(torch.cumsum(b, dim=1))
# 按照列计算累加和
print(torch.cumsum(b, dim=0))
# torch.median()根据指定的维度计算中位数
# 计算每行的中位数
print(torch.median(b, dim=1, keepdim=True))
# 计算每列的中位数
print(torch.median(b, dim=0, keepdim=True))
# 按照行计算乘积
print(torch.prod(b, dim=1, keepdim=True))
# 按照列计算乘积
print(torch.prod(b, dim=1, keepdim=True))
# 按照行计算累乘积
print(torch.cumprod(b, dim=1))
# 按照列计算累乘积
print(torch.cumprod(b, dim=0))
# torch.std()计算张量的标准差
print(torch.std(a))最大值： tensor(99.)
最大值位置： tensor(8)
最小值 tensor(11.)
最小值位置 tensor(3)
2-D张量： tensor([[12., 34., 25., 11.],
[67., 32., 29., 30.],
[99., 55., 23., 44.]])
最大值： torch.return_types.max(
values=tensor([34., 67., 99.]),
indices=tensor([1, 0, 0]))
最大值位置： tensor([1, 0, 0])
最小值 torch.return_types.min(
values=tensor([12., 32., 23., 11.]),
indices=tensor([0, 1, 2, 0]))
最小值位置 tensor([0, 1, 2, 0])
torch.return_types.sort(
values=tensor([11., 12., 23., 25., 29., 30., 32., 34., 44., 55., 67., 99.]),
indices=tensor([ 3, 0, 10, 2, 6, 7, 5, 1, 11, 9, 4, 8]))
torch.return_types.sort(
values=tensor([99., 67., 55., 44., 34., 32., 30., 29., 25., 23., 12., 11.]),
indices=tensor([ 8, 4, 9, 11, 1, 5, 7, 6, 2, 10, 0, 3]))
b sort tensor([[11., 12., 25., 34.],
[29., 30., 32., 67.],
[23., 44., 55., 99.]])
b sort_id tensor([[3, 0, 2, 1],
[2, 3, 1, 0],
[2, 3, 1, 0]])
b argsort: tensor([[3, 0, 2, 1],
[2, 3, 1, 0],
[2, 3, 1, 0]])
torch.return_types.topk(
values=tensor([99., 67., 55., 44.]),
indices=tensor([ 8, 4, 9, 11]))
b 每列 top2 tensor([[99., 55., 29., 44.],
[67., 34., 25., 30.]])
b 每列 top2 位置 tensor([[2, 2, 1, 2],
[1, 0, 0, 1]])
torch.return_types.kthvalue(
values=tensor(23.),
indices=tensor(10))
torch.return_types.kthvalue(
values=tensor([25., 32., 55.]),
indices=tensor([2, 1, 1]))
tensor([[25.],
[32.],
[55.]])
tensor([[20.5000],
[39.5000],
[55.2500]])
tensor([[59.3333, 40.3333, 25.6667, 28.3333]])
tensor([[ 82.],
[158.],
[221.]])
tensor([[178., 121., 77., 85.]])
tensor([[ 12., 46., 71., 82.],
[ 67., 99., 128., 158.],
[ 99., 154., 177., 221.]])
tensor([[ 12., 34., 25., 11.],
[ 79., 66., 54., 41.],
[178., 121., 77., 85.]])
torch.return_types.median(
values=tensor([[12.],
[30.],
[44.]]),
indices=tensor([[0],
[3],
[3]]))
torch.return_types.median(
values=tensor([[67., 34., 25., 30.]]),
indices=tensor([[1, 0, 0, 1]]))
tensor([[ 112200.],
[1865280.],
[5510340.]])
tensor([[ 112200.],
[1865280.],
[5510340.]])
tensor([[1.2000e+01, 4.0800e+02, 1.0200e+04, 1.1220e+05],
[6.7000e+01, 2.1440e+03, 6.2176e+04, 1.8653e+06],
[9.9000e+01, 5.4450e+03, 1.2524e+05, 5.5103e+06]])
tensor([[1.2000e+01, 3.4000e+01, 2.5000e+01, 1.1000e+01],
[8.0400e+02, 1.0880e+03, 7.2500e+02, 3.3000e+02],
[7.9596e+04, 5.9840e+04, 1.6675e+04, 1.4520e+04]])
tensor(25.0108)2.4 张量的自动微分
在torch中的torch.autograd模块，提供了实现任意标量值函数自动求导的类和函数。针对一个张量只需要设置参数requires_grad = True，通过相关计算即可输出其在传播过程中的梯度（导数）信息。 如在PyTorch中生成一个矩阵张量x，并且y=sum(x2+2x+1)。计算出y在x上的导数，实现过程如下：
import torch
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)# requires_grad pytorch是否自动跟踪计算它的梯度计算
# 默认requires_grad=False
y = torch.sum(x**2+2*x+1)
print("x是否可导:", x.requires_grad)
print("y是否可导:", y.requires_grad)
print("x:", x)
print("y:", y)
## 计算y在x上的梯度
y.backward()
print("y在x的每个元素上的导数为:",x.grad) #打印x的梯度，d(y)/d(x)
with torch.no_grad(): #pytorch不要跟踪运算 上下文管理器，用于测试。 有些时候，我们不想一些层参与运算，那么就让requires_grad变为false或者使用上下文管理器
y = x + 2
print(y.requires_grad)
result = x.detach() #截断梯度运算
print(result.requires_grad)
x.datax是否可导: True
y是否可导: True
x: tensor([[1., 2.],
[3., 4.]], requires_grad=True)
y: tensor(54., grad_fn=<SumBackward0>)
y在x的每个元素上的导数为: tensor([[ 4., 6.],
[ 8., 10.]])
False
False
Out[24]:
tensor([[1., 2.],
[3., 4.]])本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
