【PyTorch】张量超详细介绍（数据类型、生成、操作、计算）

主要内容

一、张量的数据类型、默认类型、类型转换。
二、张量的生成：torch.tensor()、torch.Tensor()、张量和NumPy数据互相转换、随机数生成张量、函数生成等。
三、张量操作：改变张量的形状、获取张量中的元素、拼接和拆分等。
四、张量计算：比较大小、基本运算、统计相关计算等。

---

一、简介

数学中
标量：单独的数
向量：一行或一列数组
矩阵：二维数组
张量：维度超过2的数组

PyTorch中
张量（Tensor）是一种数据结构，可以是一个标量、一个向量、一个矩阵，甚至是更高维度的数组。

所以PyTorch中的张量（Tensor）和Numpy中的数组（ndarray）非常相似。

二、张量的数据类型

2.1 数据类型

Torch定义了七种CPU tensor类型和八种GPU tensor类型：

Data type	CPU tensor	GPU tensor
32-bit floating point	torch.FloatTensor	torch.cuda.FloatTensor
64-bit floating point	torch.DoubleTensor	torch.cuda.DoubleTensor
16-bit floating point	N/A	torch.cuda.HalfTensor
8-bit integer (unsigned)	torch.ByteTensor	torch.cuda.ByteTensor
8-bit integer (signed)	torch.CharTensor	torch.cuda.CharTensor
16-bit integer (signed)	torch.ShortTensor	torch.cuda.ShortTensor
32-bit integer (signed)	torch.IntTensor	torch.cuda.IntTensor
64-bit integer (signed)	torch.LongTensor	torch.cuda.LongTensor

2.2 类型转换

在torch中默认的数据类型是32位浮点型（torch.FlaotTensor)

默认情况下，torch.Tensor就是torch.FlaotTensor。
设置默认的数据类型：torch.set_default_tensor_type()
查看和设置张量数据类型：torch.tensor([1.2, 3.4]).dtype

（1）张量的数据类型

print(torch.tensor([1.2, 3.4]).dtype)

>>>torch.float32

（2）设置默认类型

torch.set_default_tensor_type(torch.DoubleTensor)
print(torch.tensor([1.2, 3.4]).dtype)

>>>torch.float64

（3）数据类型转换

a = torch.tensor([1.2, 3.4])
print("a.dtype:", a.dtype)
print("a.long():", a.long().dtype)
print("a.int():", a.int().dtype)
print("a.float():", a.float().dtype)

>>>a.dtype: torch.float32
>>>a.long(): torch.int64
>>>a.int(): torch.int32
>>>a.float(): torch.float32

三、张量的生成

3.1 torch.tensor()生成

Python的列表或序列可以通过torch.tensor()函数构造张量。

（1）将Python的列表转化为张量

A = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
print(A)

>>>tensor([[1., 2.],
           [3., 4.]])

（2）查看维度和元素数量：

A = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
print(A)
print("A的维度:", A.shape)  # 查看维度
print("A的维度:", A.size())  # 查看维度
print("A的元素数量:", A.numel())  # 查看元素数量

>>>tensor([[1., 2.],
           [3., 4.]])
>>>A的维度: torch.Size([2, 2])
>>>A的维度: torch.Size([2, 2])
>>>A的元素数量: 4

（3）指定元素类型、是否计算梯度

B = torch.tensor((1, 2, 3), dtype=torch.float32, requires_grad=True)
print(B)

>>>tensor([1., 2., 3.], requires_grad=True)

（4）计算$sum(B^2)$在每个元素上的梯度

B = torch.tensor((1, 2, 3), dtype=torch.float32, requires_grad=True)
print(B)
Y = B.pow(2).sum()
print(Y)
Y.backward()
print(B.grad)

>>>tensor([1., 2., 3.], requires_grad=True)
>>>tensor(14., grad_fn=<SumBackward0>)
>>>tensor([2., 4., 6.])

输出结果为每个位置上的梯度——$2\times B$，注意：只有浮点型才能计算梯度，其他类型计算梯度时会报错。

3.2 torch.Tensor()生成

（1）将list转化为张量

将list转化为张量，与torch.tensor()相同：

C = torch.Tensor([1.0, 2.0])
print(C)

>>>tensor([1., 2.])

（2）根据维数生成特定尺寸张量

D = torch.Tensor(2,3)
print(D)

>>>tensor([[0.0000e+00, 0.0000e+00, 4.2039e-45],
           [0.0000e+00, 1.4013e-45, 0.0000e+00]])

（3）xxx_likes()——生成与指定张量维数相同、性质相似的张量

E = torch.Tensor([[1.0, 2.0], [3.0, 4.0]])
print(E)
print(torch.zeros_like(E))  # 零张量
print(torch.ones_like(E))  # 单位张量
print(torch.rand_like(E))  # 随机张量

>>>tensor([[1., 2.],
           [3., 4.]])
>>>tensor([[0., 0.],
           [0., 0.]])
>>>tensor([[1., 1.],
           [1., 1.]])
>>>tensor([[0.5060, 0.8078],
           [0.0232, 0.1987]])

（4）new_xxx()——生成与指定张量性质相似的张量

F = torch.tensor([2, 3], dtype=torch.float16, requires_grad=True)
print(F)
print(F.new_tensor([[1, 2], [3, 4]]))   # 新张量
print(F.new_full((3, 3), fill_value=1))   # 3*3使用fill_value填充张量
print(F.new_zeros((3, 3)))  # 3*3的全0张量
print(F.new_empty((3, 3)))  # 3*3的空张量
print(F.new_ones((3, 3)))  # 3*3的全1张量

>>>tensor([2., 3.], dtype=torch.float16, requires_grad=True)
>>>tensor([[1., 2.],
           [3., 4.]], dtype=torch.float16)
>>>tensor([[1., 1., 1.],
           [1., 1., 1.],
           [1., 1., 1.]], dtype=torch.float16)
>>>tensor([[0., 0., 0.],
           [0., 0., 0.],
           [0., 0., 0.]], dtype=torch.float16)
>>>tensor([[0., 0., 0.],
           [0., 0., 0.],
           [0., 0., 0.]], dtype=torch.float16)
>>>tensor([[1., 1., 1.],
           [1., 1., 1.],
           [1., 1., 1.]], dtype=torch.float16)

3.3 张量和NumPy数据互相转换

（1）利用NumPy数组生成tensor

Gnp = np.ones((3, 3))
GTensor1 = torch.as_tensor(Gnp)
GTensor2 = torch.from_numpy(Gnp)
print(GTensor1)
print(GTensor2)

>>>tensor([[1., 1., 1.],
           [1., 1., 1.],
           [1., 1., 1.]], dtype=torch.float64)
>>>tensor([[1., 1., 1.],
           [1., 1., 1.],
           [1., 1., 1.]], dtype=torch.float64)       

此时tensor的数据类型为float64，因为Numpy生成的数组默认就是64位浮点型数组。

（2）tensor转化为numpy数组

HTensor = torch.Tensor(2, 3)
Hnp = HTensor.numpy()
print(Hnp)

>>>[[7.826805e-03 7.826805e-03 1.261169e-44]
    [0.000000e+00 1.401298e-45 0.000000e+00]]

3.4 随机数生成张量

生成随机数前，可以使用torch.manual_seed()函数，指定随机数种子，保证生成的随机数可以重复出现。

（1）torch.normal——正太分布：

torch.manual_seed(111)
print(torch.normal(mean=0.0, std=torch.tensor(1.0)))  # 均值为0，标准差为1
print(torch.normal(mean=0.0, std=torch.arange(1, 5.0)))  # 均值为0，标准差分别为1、2、3、4

>>>tensor(-0.1222)
>>>tensor([-0.7573,  2.0832,  0.9908,  2.1260])

torch.manual_seed(111)
# 均值分别为1、2、3、4，标准差分别为1、2、3、4
print(torch.normal(mean=torch.arange(1, 5.0), std=torch.arange(1, 5.0)))  

>>>tensor([0.8778, 0.4855, 6.1248, 5.3211])

torch.manual_seed(111)
print(torch.rand(3, 4))  # 均值为0，标准差为1的3*4张量 

>>>tensor([[0.7156, 0.9140, 0.2819, 0.2581],
           [0.6311, 0.6001, 0.9312, 0.2153],
           [0.6033, 0.7328, 0.1857, 0.5101]])

（2）生成维度相同的随机张量

# 生成和其他张量尺寸相同的随机数张量
torch.manual_seed(111)
I = torch.ones(2, 3)
print(torch.rand_like(I))

>>>tensor([[0.7156, 0.9140, 0.2819],
           [0.2581, 0.6311, 0.6001]])

# 生成服从标准正太分布的随机数张量
J = torch.randn(3, 3)
print(J)
print(torch.rand_like(J))
>>>tensor([[-1.7776,  0.5832, -0.2682],
           [ 0.0241, -1.3542, -1.2677],
           [-2.7603, -0.3466,  0.5342]])
>>>tensor([[0.4177, 0.3047, 0.0382],
           [0.5805, 0.2089, 0.3964],
           [0.3527, 0.5514, 0.3021]])

3.5 其他函数

（1）torch.arange()

K = torch.arange(start=0, end=10, step=2)
print(K)

>>>tensor([0, 2, 4, 6, 8])

（2）torch.linspace()

torch.linspace()——生成固定数量等间隔张量：

L = torch.linspace(start=1, end=10, steps=5)
print(L)

>>>tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])

（3）torch.logspace()

torch.logspace()——生成以对数为间隔的张量：

M = torch.logspace(start=0.1, end=1.0, steps=5)
print(M)

>>>tensor([ 1.2589,  2.1135,  3.5481,  5.9566, 10.0000])

四、张量操作

改变张量的形状、获取或改变张量中的元素、将张量进行拼接和拆分等。

4.1 改变张量的形状

（1）tensor.reshape()

A = torch.arange(12.0).reshape(3,4)
print(A)

>>>tensor([[ 0.,  1.,  2.,  3.],
           [ 4.,  5.,  6.,  7.],
           [ 8.,  9., 10., 11.]])

改变输入的尺寸：

A = torch.arange(12.0).reshape(3, 4)
B = torch.reshape(input=A, shape=(2, -1))
print(B)

>>>tensor([[ 0.,  1.,  2.,  3.,  4.,  5.],
           [ 6.,  7.,  8.,  9., 10., 11.]])

（2）tensor.resize_()

A = torch.arange(12.0).reshape(3, 4)
C = A.resize_(2, 6)
print(C)

>>>tensor([[ 0.,  1.,  2.,  3.,  4.,  5.],
           [ 6.,  7.,  8.,  9., 10., 11.]])

（3）tensor.resize_as_()

A = torch.arange(12.0).reshape(3, 4)
D = torch.arange(10.0, 19.0).reshape(3, 3)
E = A.resize_as_(D)
print(E)

>>>tensor([[0., 1., 2.],
           [3., 4., 5.],
           [6., 7., 8.]])

（4）torch.unsqueeze()

torch.unsqueeze()——指定维度插入新的维度：

A = torch.arange(12.0).reshape(3, 4)
F = torch.unsqueeze(A, dim=0)
print(F)
print(F.size())

>>>tensor([[[ 0.,  1.,  2.,  3.],
            [ 4.,  5.,  6.,  7.],
            [ 8.,  9., 10., 11.]]])
>>>torch.Size([1, 3, 4])

（5）torch.squeeze()

torch.squeeze()——移除制定或维度大小为1的维度：

A = torch.arange(12.0).reshape(3, 4)
print(A.size())
print(torch.unsqueeze(A, dim=1).size())
print(torch.squeeze(A, dim=1).size())

>>>torch.Size([3, 1, 4])
>>>torch.Size([1, 3, 4])
>>>torch.Size([3, 4])

（6）.expand()

对张量的维度进行扩充：

A = torch.arange(3)
print(A)
print(A.expand(3, -1))

>>>tensor([[0, 1, 2],
           [0, 1, 2],
           [0, 1, 2]])

（7）.expand_as()

A = torch.arange(3)
C = torch.arange(6).reshape(2, 3)
print(A.expand_as(C))

>>>tensor([[0, 1, 2],
           [0, 1, 2]])

（8）.shape()

将张量看做一个整体，根据指定形状进行重复填充：

A = torch.tensor([1, 2, 3])
D = A.repeat(1, 2, 2)  # 三个参数分别代表三个维度repeat的次数
print(D)
print(D.size())

>>>tensor([[[1, 2, 3, 1, 2, 3],
            [1, 2, 3, 1, 2, 3]]])
>>>torch.Size([1, 2, 6])

4.2 获取张量中的元素

（1）索引法

A = torch.arange(12).reshape(1, 3, 4)
print(A)
print(A[0])
print(A[0][0])  # 获取零维度下的第一行矩阵
print(A[0, 0:2, :])  # 获取0维度下，前两行矩阵
print(A[0, -1, -4:-1])  # 获取0维度下，最后一行矩阵的-4~-1列

>>>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([0, 1, 2, 3])
>>>tensor([[0, 1, 2, 3],
           [4, 5, 6, 7]])
>>>tensor([ 8,  9, 10])

（2）torch.where()——条件筛选

当A>5是为True时返回A对应的值，为False时返回B对应的值：

A = torch.arange(12).reshape(1, 3, 4)
B = -A
print(torch.where(A > 5, A, B))

>>>tensor([[[ 0, -1, -2, -3],
            [-4, -5,  6,  7],
            [ 8,  9, 10, 11]]])

获取A中大于5的元素：

A = torch.arange(12).reshape(1, 3, 4)
print(A[A > 5])

>>>tensor([ 6,  7,  8,  9, 10, 11])

（3）tril()、triu()、diag()——上、下三角、对角矩阵获取

torch.tril()——获取下三角矩阵
torch.triu()——获取上三角矩阵

B = torch.arange(1, 10.0).reshape(1, 3, 3)
print(torch.tril(B, diagonal=0))  # diagonal控制对角线
print(torch.tril(B, diagonal=1))

>>>tensor([[[1., 0., 0.],
            [4., 5., 0.],
            [7., 8., 9.]]])
>>>tensor([[[1., 2., 0.],
            [4., 5., 6.],
            [7., 8., 9.]]])

torch.diag()——获取对角线元素

A = torch.arange(1, 13.0).reshape(3, 4)
print(A)
print(torch.diag(A, diagonal=0))
print(torch.diag(A, diagonal=1))

>>>tensor([[ 1.,  2.,  3.,  4.],
        [ 5.,  6.,  7.,  8.],
        [ 9., 10., 11., 12.]])
>>>tensor([ 1.,  6., 11.])
>>>tensor([ 2.,  7., 12.])

torch.diag()——提供对角线元素生成矩阵张量

print(torch.diag(torch.tensor([1, 2, 3])))

>>>tensor([[1, 0, 0],
           [0, 2, 0],
           [0, 0, 3]])

4.3 拼接和拆分

（1）torch.cat()——给定维度中张量拼接

在给定维度中连接给定的张量序列

A = torch.arange(6).reshape(2, 3)
B = torch.linspace(1, 10, 6).reshape(2, 3)
# 拼接过程要注意张量的尺寸可以进行拼接。
print(torch.cat((A, B), dim=0))
print(torch.cat((A, B), dim=1))

>>>tensor([[ 0.0000,  1.0000,  2.0000],
           [ 3.0000,  4.0000,  5.0000],
           [ 1.0000,  2.8000,  4.6000],
           [ 6.4000,  8.2000, 10.0000]])
>>>tensor([[ 0.0000,  1.0000,  2.0000,  1.0000,  2.8000,  4.6000],
           [ 3.0000,  4.0000,  5.0000,  6.4000,  8.2000, 10.0000]])

（2）torch.stack()——沿新维度连接张量

沿新维度连接张量

A = torch.arange(6).reshape(2, 3)
B = torch.linspace(1, 10, 6).reshape(2, 3)
print(torch.stack((A, B), dim=1))
print(torch.stack((A, B), dim=2))

>>>tensor([[[ 0.0000,  1.0000,  2.0000],
            [ 1.0000,  2.8000,  4.6000]],

           [[ 3.0000,  4.0000,  5.0000],
            [ 6.4000,  8.2000, 10.0000]]])
>>>tensor([[[ 0.0000,  1.0000],
            [ 1.0000,  2.8000],
            [ 2.0000,  4.6000]],

           [[ 3.0000,  6.4000],
            [ 4.0000,  8.2000],
            [ 5.0000, 10.0000]]])

（3）torch.chunk()——张量分块

沿着dim维度，分成2块。

A = torch.arange(12).reshape(2, 6)
B1, B2 = torch.chunk(A, 2, dim=0) 
print(B1, B2)

C1, C2 = torch.chunk(A, 2, dim=1)
print(C1)
print(C2)

>>>tensor([[0, 1, 2, 3, 4, 5]]) tensor([[ 6,  7,  8,  9, 10, 11]])
>>>tensor([[0, 1, 2],
           [6, 7, 8]])
>>>tensor([[ 3,  4,  5],
           [ 9, 10, 11]])

若不能整除时，则最后一块将最小

A = torch.arange(10).reshape(2, 5)
D1, D2, D3 = torch.chunk(A, 3, dim=1)
print(D1)
print(D2)
print(D3)

>>>tensor([[0, 1],
           [5, 6]])
>>>tensor([[2, 3],
           [7, 8]])
>>>tensor([[4],
           [9]])

（4）torch.split()——张量分块

将张量分块，可指定每一块的大小

A = torch.arange(12).reshape(2, 6)
D1, D2, D3 = torch.split(A, [1, 2, 3], dim=1)
print(D1)
print(D2)
print(D3)

>>>tensor([[0],
          [6]])
>>>tensor([[1, 2],
           [7, 8]])
>>>tensor([[ 3,  4,  5],
           [ 9, 10, 11]])

五、张量计算

5.1 比较大小

（1）torch.allclose()——比较两个元素是否相近

计算公式：$|A-B|\le atol+rtol\times |B|$

A = torch.tensor([10.0])
B = torch.tensor([10.1])

print(torch.allclose(A, B, rtol=1e-05, atol=1e-08, equal_nan=False))
print(torch.allclose(A, B, rtol=0.1, atol=0.01, equal_nan=False))

>>>False
>>>True

如果设置euqal_nan=True，那么缺失值可以判断为接近。

C = torch.tensor(float("nan"))
print(torch.allclose(C, C, equal_nan=False))
print(torch.allclose(C, C, equal_nan=True))

>>>False
>>>True

（2）torch.eq()——判断两个元素是否相等

A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torch.unsqueeze(B,dim=0)
print(torch.eq(A,B))
print(torch.eq(A,C))

>>>tensor([True, True, True, True, True, True])
>>>tensor([[True, True, True, True, True, True]])

（3）torch.equal()——判断两个张量形状和元素是否相同

A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torch.unsqueeze(B,dim=0)
print(torch.equal(A,B))
print(torch.equal(A,C))

>>>True
>>>False

（4）torch.ge()——逐元素比较大于等于

A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torc
h.unsqueeze(B,dim=0)
print(torch.ge(A, B))
print(torch.ge(A, C))

>>>tensor([True, True, True, True, True, True])
>>>tensor([[True, True, True, True, True, True]])

（5）torch.gt()——逐元素比较大于

A = torch.tensor([1,2,3,4,5,6])
B = torch.arange(1,7)
C = torch.unsqueeze(B,dim=0)
print(torch.gt(A, B))
print(torch.gt(A, C))

>>>tensor([False, False, False, False, False, False])
>>>tensor([[False, False, False, False, False, False]])

（6）torch.le()——逐元素比较大于等于

print(torch.le(A, B))

（7）torch.lt()——逐元素比较大小

print(torch.lt(A, B))

（8）torch.ne()——逐元素比较不等于

print(torch.ne(A, B))

（9）torch.isnan()——判断是否为缺失值

print(torch.isnan(torch.tensor([0,1,float("nan"),2])))

>>>tensor([False, False,  True, False])

5.2 基本运算

（1）矩阵逐元素加、减、乘、除

A = torch.arange(6.0).reshape(2, 3)
B = torch.linspace(10, 20, steps=6).reshape(2, 3)
print(A)
print(B)
print(A + B)
print(A - B)
print(A * B)
print(A / B)

>>>tensor([[0., 1., 2.],
           [3., 4., 5.]])
>>>tensor([[10., 12., 14.],
           [16., 18., 20.]])
>>>tensor([[10., 13., 16.],
           [19., 22., 25.]])
>>>tensor([[-10., -11., -12.],
           [-13., -14., -15.]])
>>>tensor([[  0.,  12.,  28.],
           [ 48.,  72., 100.]])
>>>tensor([[0.0000, 0.0833, 0.1429],
           [0.1875, 0.2222, 0.2500]])

（2）torch.sum()——矩阵元素和

x = torch.tensor([[1.0, 2], [3, 4]])
print(x)
print(sum(x))
print(torch.sum(x))

>>>tensor([[1., 2.],
           [3., 4.]])
>>>tensor([4., 6.])
>>>tensor(10.)

（3）torch.pow()——张量的幂

两种方法均可：

A = torch.arange(6.0).reshape(2, 3)
print(torch.pow(A, 3))
print(A ** 3)

>>>tensor([[  0.,   1.,   8.],
           [ 27.,  64., 125.]])
>>>tensor([[  0.,   1.,   8.],
           [ 27.,  64., 125.]])

（4）torch.exp()——张量的指数

A = torch.arange(6.0).reshape(2, 3)
print(torch.exp(A))

>>>tensor([[  1.0000,   2.7183,   7.3891],
           [ 20.0855,  54.5981, 148.4132]])

（5）torch.log()——张量的对数

A = torch.arange(6.0).reshape(2, 3)
print(torch.log(A))

>>>tensor([[  -inf, 0.0000, 0.6931],
           [1.0986, 1.3863, 1.6094]])

（6）torch.sqrt()——张量的平方根

与求幂函数相类似，可以采用两种方式。

A = torch.arange(6.0).reshape(2, 3)
print(torch.sqrt(A))
print(A ** 0.5)

>>>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]])

（7）torch.rsqrt()——张量的平方根倒数

与求幂函数相类似，可以采用两种方式。

A = torch.arange(6.0).reshape(2, 3)
print(torch.rsqrt(A))
print(1 / (A ** 0.5))

>>>tensor([[   inf, 1.0000, 0.7071],
           [0.5774, 0.5000, 0.4472]])
>>>tensor([[   inf, 1.0000, 0.7071],
           [0.5774, 0.5000, 0.4472]])

（8）torch.clamp_max()——根据最大值裁剪

大于最大值的元素将变为最大值。

A = torch.arange(6.0).reshape(2, 3)
print(torch.clamp_max(A, 3))

>>>tensor([[0., 1., 2.],
           [3., 3., 3.]])

（9）torch.clamp_min()——根据最小值裁剪

小于最大值的元素将变为最小值。

A = torch.arange(6.0).reshape(2, 3)
print(torch.clamp_min(A, 3))

>>>tensor([[3., 3., 3.],
           [3., 4., 5.]])

（10）torch.clamp()——根据范围裁剪

将torch.clamp_max()和torch.clamp_min()相结合。

A = torch.arange(6.0).reshape(2, 3)
print(torch.clamp(A, 2, 4))

>>>tensor([[2., 2., 2.],
           [3., 4., 4.]])

（11）torch.t()——矩阵转置

A = torch.arange(6.0).reshape(2, 3)
print(torch.t(A))

>>>tensor([[0., 3.],
           [1., 4.],
           [2., 5.]])

（12）torch.matmul()——矩阵乘法

计算矩阵乘法时注意条件，A的行数要等于B的列数。

A = torch.arange(6.0).reshape(2, 3)
B = torch.t(A)
print(torch.matmul(A, B))

>>>tensor([[ 5., 14.],
           [14., 50.]])

（13）torch.inverse()——计算逆矩阵

A = torch.arange(1, 10.0).reshape(3, 3)
print(torch.inverse(A))

>>>tensor([[ -2796203.0000,   5592406.0000,  -2796203.0000],
           [  5592404.5000, -11184812.0000,   5592406.5000],
           [ -2796201.7500,   5592406.0000,  -2796203.2500]])

5.3 统计相关计算

（1）.max()&.argmax()——最大值及索引

A = torch.tensor([12, 1, 3, 5, 15, 999])
print(A.max())
print(A.argmax())

>>>tensor(999)
>>>tensor(5)

A = torch.tensor([12, 1, 3, 5, 15, 999]).reshape(2, 3)
print(A)
print(A.max(dim=0))  # 列向量最大值，返回值和索引
print(A.max(dim=1))  # 行向量最大值，返回值和索引

>>>tensor([[ 12,   1,   3],
           [  5,  15, 999]])
>>>torch.return_types.max(
   values=tensor([ 12,  15, 999]),
   indices=tensor([0, 1, 1]))
>>>torch.return_types.max(
   values=tensor([ 12, 999]),
   indices=tensor([0, 2]))

（2）.min()&.argmin()——最小值及索引

A = torch.tensor([12, 1, 3, 5, 15, 999])
print(A.min())
print(A.argmin())

>>>tensor(1)
>>>tensor(1)

A = torch.tensor([12, 1, 3, 5, 15, 999]).reshape(2, 3)
print(A)
print(A.min(dim=0))  # 列向量最小值，返回值和索引
print(A.min(dim=1))  # 行向量最小值，返回值和索引

>>>tensor([[ 12,   1,   3],
           [  5,  15, 999]])
>>>torch.return_types.min(
   values=tensor([5, 1, 3]),
   indices=tensor([1, 0, 0]))
>>>torch.return_types.min(
   values=tensor([1, 5]),
   indices=tensor([1, 0]))

（3）torch.sort()——张量排序

一维张量排序，返回值和索引。

A = torch.tensor([12, 1, 3, 5, 15, 999])
print(torch.sort(A))  # 升序
print(torch.sort(A, descending=True))  # 降序

>>>torch.return_types.sort(
   values=tensor([  1,   3,   5,  12,  15, 999]),
   indices=tensor([1, 2, 3, 0, 4, 5]))
>>>torch.return_types.sort(
   values=tensor([999,  15,  12,   5,   3,   1]),
   indices=tensor([5, 4, 0, 3, 2, 1]))

二维张量排序，返回值和索引。

A = torch.tensor([12, 1, 3, 5, 15, 999]).reshape(2, 3)
print(torch.sort(A)) 

>>>torch.return_types.sort(
   values=tensor([[  1,   3,  12],
           [  5,  15, 999]]),
>>>indices=tensor([[1, 2, 0],
           [0, 1, 2]]))

（4）torch.topk()——最大的k个数及其索引

A = torch.tensor([12, 1, 3, 5, 15, 999])
print(torch.topk(A, 3))

>>>torch.return_types.topk(
   values=tensor([999,  15,  12]),
   indices=tensor([5, 4, 0]))

（5）torch.kthvalue()——第k小的值及其索引

获取张量取值大小为第k小的数值及其所在位置。

A = torch.tensor([12, 1, 3, 5, 15, 999])
print(torch.kthvalue(A, 3))

>>>torch.return_types.kthvalue(
   values=tensor(5),
   indices=tensor(3))

（6）torch.mean()——指定维度求均值

计算每一行的均值。
keepdim=True：对应行输出
keepdim=False：转变为一维的tensor输出。

A = torch.tensor([12.0, 1, 3, 5, 15, 999]).reshape(2, 3)
print(A)
print(torch.mean(A, dim=1, keepdim=True))
print(torch.mean(A, dim=1, keepdim=False))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.]])
>>tensor([[  5.3333],
          [339.6667]])
>>>tensor([  5.3333, 339.6667])

计算每一列的均值。
keepdim=True：对应列输出
keepdim=False：转变为一维的tensor输出。（此时无变化）

A = torch.tensor([12.0, 1, 3, 5, 15, 999]).reshape(2, 3)
print(A)
print(torch.mean(A, dim=0, keepdim=True))
print(torch.mean(A, dim=0, keepdim=False))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.]])
>>>tensor([[  8.5000,   8.0000, 501.0000]])
>>>tensor([  8.5000,   8.0000, 501.0000])

（7）torch.sum()——指定维度求和

计算每一行的和。
keepdim=True：对应行输出
keepdim=False：转变为一维的tensor输出。

A = torch.tensor([12.0, 1, 3, 5, 15, 999]).reshape(2, 3)
print(A)
print(torch.sum(A, dim=1, keepdim=True))
print(torch.sum(A, dim=1, keepdim=False))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.]])
>>>tensor([[  16.],
           [1019.]])
>>>tensor([  16., 1019.])

计算每一列的和。
keepdim=True：对应列输出
keepdim=False：转变为一维的tensor输出。（此时无变化）

A = torch.tensor([12.0, 1, 3, 5, 15, 999]).reshape(2, 3)
print(A)
print(torch.sum(A, dim=0, keepdim=True))
print(torch.sum(A, dim=0, keepdim=False))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.]])
>>>tensor([[  17.,   16., 1002.]])
>>>tensor([  17.,   16., 1002.])

（8）torch.cumsum()——指定维度累加和

A = torch.tensor([12.0, 1, 3, 5, 15, 999]).reshape(2, 3)
print(A)
print(torch.cumsum(A, dim=0))  # 列累加
print(torch.cumsum(A, dim=1))  # 行累加

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.]])
>>>tensor([[1.2000e+01, 1.0000e+00, 3.0000e+00],
           [1.7000e+01, 1.6000e+01, 1.0020e+03]])
>>>tensor([[  12.,   13.,   16.],
           [   5.,   20., 1019.]])

（9）torch.median()——指定维度求中位数

输出每一行中位数及其索引。
keepdim=True：输出张量的维度与原先一致。
keepdim=False：转变为一维的张量输出。

A = torch.tensor([12.0, 1, 3, 5, 15, 999, 4, 6, 8]).reshape(3, 3)
print(A)
print(torch.median(A, dim=1, keepdim=True))
print(torch.median(A, dim=1, keepdim=False))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.],
           [  4.,   6.,   8.]])
>>>torch.return_types.median(
>>>values=tensor([[ 3.],
           [15.],
           [ 6.]]),
>>>indices=tensor([[2],
           [1],
           [1]]))
>>>torch.return_types.median(
   values=tensor([ 3., 15.,  6.]),
   indices=tensor([2, 1, 1]))

输出每一列中位数及其索引。
keepdim=True：输出张量的维度与原先一致。
keepdim=False：转变为一维的张量输出。（无变化）

A = torch.tensor([12.0, 1, 3, 5, 15, 999, 4, 6, 8]).reshape(3, 3)
print(A)
print(torch.median(A, dim=0, keepdim=True))
print(torch.median(A, dim=0, keepdim=False))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.],
           [  4.,   6.,   8.]])
>>>torch.return_types.median(
   values=tensor([[5., 6., 8.]]),
   indices=tensor([[1, 2, 2]]))
>>>torch.return_types.median(
   values=tensor([5., 6., 8.]),
   indices=tensor([1, 2, 2]))

（10）torch.prod()——指定维度求乘积

A = torch.tensor([12.0, 1, 3, 5, 15, 999, 4, 6, 8]).reshape(3, 3)
print(A)
print(torch.prod(A, dim=0, keepdim=True))
print(torch.prod(A, dim=1, keepdim=True))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.],
           [  4.,   6.,   8.]])
>>>tensor([[  240.,    90., 23976.]])
>>>tensor([[3.6000e+01],
           [7.4925e+04],
           [1.9200e+02]])

（10）torch.cumprod()——指定为累乘积

A = torch.tensor([12.0, 1, 3, 5, 15, 999, 4, 6, 8]).reshape(3, 3)
print(A)
print(torch.cumprod(A, dim=0))
print(torch.cumprod(A, dim=1))

>>>tensor([[ 12.,   1.,   3.],
           [  5.,  15., 999.],
           [  4.,   6.,   8.]])
>>>tensor([[1.2000e+01, 1.0000e+00, 3.0000e+00],
           [6.0000e+01, 1.5000e+01, 2.9970e+03],
           [2.4000e+02, 9.0000e+01, 2.3976e+04]])
>>>tensor([[1.2000e+01, 1.2000e+01, 3.6000e+01],
           [5.0000e+00, 7.5000e+01, 7.4925e+04],
           [4.0000e+00, 2.4000e+01, 1.9200e+02]])

（11）torch.std()——计算标准差

A = torch.tensor([12.0, 1, 3, 5, 15, 999, 4, 6, 8]).reshape(3, 3)
print(torch.std(A))

>>>tensor(330.7794)