Pytorch入门4-Pytorch张量的计算

第二节：张量的计算

张量的计算，包括基本的四则运算、乘法运算和统计运算等。

一、基本计算

1加减乘除

要对张量进行加减乘除，可以使用运算符号：+、-、*、/，也可以使用对应的方法：add、sub、mul、div，以上这些方法是不会修改原张量的，如果想要原地修改原张量的值，那么可以使用对应下划线的版本：add_、sub_、mul_、div_。示例代码如下：

# 1. 加号  
tensor = torch.tensor([[1,2], [3,4]])  
# 张量与标量相加  
print(tensor+10)  
tensor([[11, 12],
        [13, 14]])


# 两个相同形状的张量相加  
print(tensor + torch.tensor([[5,6],[7,8]]))  
tensor([[ 6,  8],
        [10, 12]])


# 2. add方法  
tensor.add(10)  

# 3. add_方法  
tensor.add_(2)  
print(tensor)  

# 4. Hadamard积  对应元素相乘
print(tensor \* torch.tensor([[5,6],[7,8]]))  
# 或  
print(tensor.mul(torch.tensor([[5,6],[7,8]])))  

PyTorch中的点积，也就是dot操作，只能针对一维的张量：

t1 = torch.tensor([1,2])  
t2 = torch.tensor([3,4])  

t3 = t1.dot(t2)  
print(t3)  

# tensor(11)   1x3+2x4

如果想要对多维张量实现点积（内积），则需要先将多维张量拉平成一维张量，示例代码如下：

t1 = torch.tensor([[1,2], [3,4]])  
t2 = torch.tensor([[5,6],[7,8]])  

t3 = t1.flatten().dot(t2.flatten())  
print(t3)  

2异号

通过-号、neg以及neg_方法，可以将张量中的每个元素取异号。示例代码如下：

# 1. 用负号  
-tensor  

# 2. 用neg方法  
tensor.neg()  

# 3. 用neg_方法，会修改自身的值  
tensor.neg_()  
print(tensor)  

3幂运算

通过**、pow以及pow_方法让张量中的每个元素都进行幂运算。示例代码如下：

# 1. 使用\*\*  
tensor\*\*2  

# 2. 使用pow方法  
tensor.pow(2)  

# 3. 使用pow_方法  
tensor.pow_(2)  
print(tensor)  

4求平方根

通过sqrt或sqrt_方法可以对张量中的每个元素求平方根。示例代码如下：

# 1. 使用sqrt方法  
tensor.sqrt()  

# 2. 使用sqrt_方法  
tensor.sqrt_()  
print(tensor)  

5以e为底求幂

使用exp、exp_可以求以e为底的幂。示例代码如下：

# 1. 使用exp方法  
tensor = torch.tensor([1,2,3])  
tensor.exp()  

# 2. 使用exp_方法  
tensor = torch.tensor([1.0,2,3])  
tensor.exp_()  
print(tensor)  

6求对数

通过log、log_可以求以e为底的对数。示例代码如下：

tensor = torch.tensor([1,2,3], dtype=torch.float)  
tensor.log()  

另外pytorch还封装了以2为底的log2方法，以及以10为低的log10方法。如果想要以其他数为底，那么可以采用换底公式。

二、统计运算

统计运算，包括求最大值、最小值、平均值等。

1求最大（小）值

通过tensor.max或tensor.min()可以求出整个张量中的最大或最小的值。示例代码如下：

tensor = torch.tensor([[1,20,3], [5,10,39]])  

# 1. 求整个张量的   
tensor.max()  
#tensor(39)

# 2. 求第0个维度的最大值（二维张量为求每列的最大值）  
tensor.max(dim=0)  
# torch.return_types.max(
# values=tensor([ 5, 20, 39]),
# indices=tensor([1, 0, 1]))

# 3. 求第1个维度的最大值（二维张量为求每行的最大值）  
tensor.max(dim=1)  
#torch.return_types.max(
#values=tensor([20, 39]),
#indices=tensor([1, 2]))

# 2. 求最小值  
tensor.min()  
# 后面的与求最大值类似  
tensor(1)

2求和

通过tensor.sum可以求得整个张量的和。示例代码如下：

tensor = torch.tensor([[1.0,20,3], [5,10,39]])
# 1. 求所有张量值的和  
tensor.sum()  
#tensor(78.)

# 2. 求维度为0 
tensor.sum(dim=0)  
#tensor([ 6, 30, 42])

# 3. 求维度为1 
tensor.sum(dim=1)  
#tensor([24, 54])

3求平均值

通过tensor.mean可以求得整个张量的平均值。示例代码如下：

tensor = torch.tensor([[1.0,20,3], [5,10,39]])
# 1. 求所有元素的平均值  
tensor.mean()  
#tensor(13.)
  
tensor.mean(dim=0)  
#tensor([ 3., 15., 21.])

tensor.mean(dim=1)  
#tensor([ 8., 18.])

张量类型必须是浮点类型或复数类型才能够求平均值，所以如果张量是其他类型，比如整形，那么需要先转换为浮点型后再求平均值。示例代码如下：

t1 = torch.tensor([[1,2], [3,4]])  
t1.float().mean()  

4求最大（小）值索引

通过tensor.argmax和tensor.argmin可以求得最大值和最小值的索引。示例代码如下：

tensor = torch.tensor([[1.0,20,3], [5,10,39]])
# 1. 求列的最大值的索引  
tensor.argmax(dim=0)  
# 相当于是：tensor.max(dim=0).indices  
#tensor([1, 0, 1])

# 2. 求行的最大值的索引  
tensor.argmax(dim=1)  
# 相当于是：tensor.max(dim=1).indices  
#tensor([1, 2])

5求标准差

通过tensor.std可以求得张量中的标准差。示例代码如下：

# 1. 求张量中所有元素的标准差  
tensor.std()  
# tensor(14.4361)

tensor.std(dim=0)  
# tensor([ 2.8284,  7.0711, 25.4558])

tensor.std(dim=1)  
# tensor([10.4403, 18.3576])

只有浮点类型或复数类型的张量才能够求标准差，否则会报错。示例代码如下：

t1 = torch.tensor([[1,2], [3,4]])  
t1.float().std()  

6去重

通过tensor.unique可以对张量的元素去重。示例代码如下：

tensor = torch.tensor([[1, 1], [2, 2]])

# 去重，全局去重后，原来的张量会被扁平化为一维张量。  
# 输出结果：torch.tensor([1,2])  
tensor.unique()  
#tensor([1, 2])

# 按维度去重，依然会保持原来的维度  
# 输出结果：torch.tensor([[1], [2]])  
tensor.unique(dim=1)  
#tensor([[1],  [2]])

7排序

通过tensor.sort方法可以对张量元素进行排序。示例代码如下：

tensor = torch.tensor([[1.0,20,3], [5,10,39]])
# 1. 默认按照最后一个维度的元素排序  
tensor.sort()  
#torch.return_types.sort(
#values=tensor([[ 1.,  3., 20.],
#        [ 5., 10., 39.]]),
#indices=tensor([[0, 2, 1],
#        [0, 1, 2]]))


# 2. 按照第0个维度排序  
tensor.sort(dim=0)  
#torch.return_types.sort(
#values=tensor([[ 1., 10.,  3.],
#        [ 5., 20., 39.]]),
#indices=tensor([[0, 1, 0],
#        [1, 0, 1]]))



# 3. 按照第1个维度排序,默认最后一个维度  
tensor.sort(dim=1)  

三、矩阵乘法

由于在PyTorch开发中，大部分的计算都是二维矩阵的计算。所以这里我们分二维矩阵和多维矩阵运算来讲解矩阵的乘法。可以使用tensor.mm、@符号或matmul来进行矩阵相乘，其中mm方法是只能用于二维矩阵的相乘，而@、matmul可以用于多维矩阵相乘。

1二维矩阵相乘

二维矩阵乘法示例代码如下：

tensor1 = torch.tensor([[1,2,3], [4,5,6]])  
tensor2 = torch.tensor([[1,2], [3,4], [5,6]])  

# 采用mm方法  
tensor1.mm(tensor2)  
# 采用@符号  
tensor1 @ tensor2  
# 采用matmul方法  
tensor1.matmul(tensor2)  

#结果都为
#tensor([[22, 28],
#        [49, 64]])

2多维矩阵相乘

多维矩阵相乘，需要满足以下两个条件：
●末尾两个维度需要满足相乘的条件，比如A矩阵末尾两个维度为：m x s，B矩阵末尾两个维度为：s x n，那么就可以相乘。
●除了末尾两个维度，其余维度必须相同，或其中有一个矩阵的维度值为1，或少一个维度。比如以下三种情况：
○A矩阵(2,3,2)，B矩阵(2,2,3)，可以相乘，结果形状为(2,3,3)。
○A矩阵(2,3,2)，B矩阵(1,2,3)，可以相乘，结果形状为(2,3,3)。
○A矩阵(2,3,2)，B矩阵(2,3)，可以相乘，结果形状为(2,3,3)。
○A矩阵(2,3,2)，B矩阵(3,2,3)，不可以相乘。
相乘的规则为：末尾两个维度的矩阵按照二维矩阵进行相乘，其余维度进行广播（上述第二种情况，B矩阵的第0维为1，这时候A @ B会进行广播操作）。示例代码如下：

# 第一个矩阵  
tensor1 = torch.tensor([[[1,2,3], [4,5,6]], [[7,8,9], [1,2,3]]])  
print(tensor1)  
print(tensor1.shape)  

# 第二个矩阵  
tensor2 = torch.tensor([[[1,2], [3,4], [0,1]], [[1,1], [2,2], [3,2]]])  
print(tensor2)  
print(tensor2.shape)  

# 相乘后的矩阵  
tensor = tensor1.matmul(tensor2)  
print(tensor)  
print(tensor.shape)  

#结果
tensor([[[1, 2, 3],
         [4, 5, 6]],

        [[7, 8, 9],
         [1, 2, 3]]])
torch.Size([2, 2, 3])
tensor([[[1, 2],
         [3, 4],
         [0, 1]],

        [[1, 1],
         [2, 2],
         [3, 2]]])
torch.Size([2, 3, 2])
tensor([[[ 7, 13],
         [19, 34]],

        [[50, 41],
         [14, 11]]])
torch.Size([2, 2, 2])