pytorch----矩阵乘法
理论:
向量:
一行乘以一列: 内积: 结果一个数
一列乘以一行: 外积: 结果一个矩阵
矩阵:
点乘: *, mul: 对应元素相乘
叉乘: dot, matmul: 矩阵乘法 (而矩阵乘法又可以理解为向量内积, 外积的结合体)
-
传统的矩阵乘法可以看成: 行向量组成一列, 列向量组成一行
关于广播机制的补充说明:
-
广播机制是用在对应元素的: 加, 减, 乘, 除
-
能够进行广播机制的条件:
- 有一维为1
- 少了一个维度
-
广播机制的法则:
高维矩阵乘法:
-
保证前n-2个维度是相等的
-
最后两个维度用来做, 普通二维矩阵乘法
爱因斯坦求和约定:
tf说明了爱因斯坦求和约定的各种操作: https://blog.csdn.net/bqw18744018044/article/details/103648093
1.矩阵转置
A = tf.random.uniform((3,4))
B = tf.einsum("ij->ji",A)
print(A.shape)
print(B.shape)
(3, 4)
(4, 3)
2.求和
A = tf.random.uniform((3,4))
print(tf.einsum("ij->",A)) # 所有元素求和
print(tf.einsum("ij->j",A).shape) # 列求和
print(tf.einsum("ij->i",A).shape) # 行求和
tf.Tensor(6.1462874, shape=(), dtype=float32)
(4,)
(3,)
3.乘积
A = tf.random.uniform((2,3))
B = tf.random.uniform((3,4))
print(tf.einsum("ik,kj->ij",A,B).shape) # 矩阵乘法
a = tf.random.uniform((3,))
b = tf.random.uniform((3,))
print(tf.einsum("i,i->",a,b).shape) # 内积
print(tf.einsum("i,j->ij",a,b).shape) # 外积
(2, 4)
()
(3, 3)
4.batch乘法
在深度学习中样本通常是成批次的送到模型中，因此往往需要对每个样本对应的矩阵进行乘法，而由于整个tensor的第1个维度为batch size，因此要实现batch乘法会比较复杂，而使用einsum就非常的简洁。
A = tf.random.uniform((32,128,100))
B = tf.random.uniform((32,100,50))
print(tf.einsum("bsd,bdi->bsi",A,B).shape)
(32, 128, 50)
5.张量缩约
将两个高维张量在某些维度相乘，并在这些维度上求和
A = tf.random.uniform((3,5,7,2,8))
B = tf.random.uniform((4,7,2,3,5))
print(tf.einsum("pqrst,urspq->pqrstu",A,B).shape)
(3, 5, 7, 2, 8, 4)
代码:
torch中的乘法:
一.矩阵乘
-
torch.matmul
- 有各个维度的操作, 看官方文档就可以解决:
- 向量的乘法:
- 矩阵的乘法:
- 如果维度对应(batch矩阵乘法): n-2维不管(因为一样), 最后两维矩阵乘法
- 如果维度不对应(广播矩阵乘法): n-2维需要满足广播机制, 最后两维矩阵乘法
二.对应元素相乘
-
torch.mul
-
和普通标量也是对应元素相乘:
#输入张量和标量相乘
torch.mul(input, value, out=None)
例：
>>> a = torch.randn(3)
>>> a
-0.9374
-0.5254
-0.6069
[torch.FloatTensor of size 3]
>>> torch.mul(a, 100)
-93.7411
-52.5374
-60.6908
[torch.FloatTensor of size 3]-
即便, 张量的形状不一样, 只要对应元素个数相同也是一样:
#两个张量相乘
torch.mul(input, other, out=None)
>>> a = torch.randn(4,4)
>>> a
-0.7280 0.0598 -1.4327 -0.5825
-0.1427 -0.0690 0.0821 -0.3270
-0.9241 0.5110 0.4070 -1.1188
-0.8308 0.7426 -0.6240 -1.1582
[torch.FloatTensor of size 4x4]
>>> b = torch.randn(2, 8)
>>> b
0.0430 -1.0775 0.6015 1.1647 -0.6549 0.0308 -0.1670 1.0742
-1.2593 0.0292 -0.0849 0.4530 1.2404 -0.4659 -0.1840 0.5974
[torch.FloatTensor of size 2x8]
>>> torch.mul(a, b)
-0.0313 -0.0645 -0.8618 -0.6784
0.0934 -0.0021 -0.0137 -0.3513
1.1638 0.0149 -0.0346 -0.5068
-1.0304 -0.3460 0.1148 -0.6919
[torch.FloatTensor of size 4x4]
numpy中的矩阵乘法:
-
np.dot()和torch.matmul()----矩阵乘法, 对应元素相乘相加:
- (reduce_sum其实和这里也有一定关系)
a=[[1,1,1],
[2,2,2]]
at=torch.tensor(a)
c=[[3,3],
[3,3],
[3,3]]
ct=torch.tensor(c)
y1=np.dot(a,c)
y2=torch.matmul(at,ct)
- 数组类型或者list类型：内积
In [2]:a = np.array([1,1,1])
In [3]:b = np.array([2,2,2])
In [4]:np.dot(a,b)
Out[4]: 6- 矩阵：矢量积，叉乘
- 列表和矩阵不一样, 大小不合适会报错:
In [5]:c = np.array([[3,3,3],[4,4,4]])
In [6]:d = np.array([[5],[5],[5]])
In [7]:np.dot(c,d)
Out[7]:
array([[45],
[60]])In [11]:g = np.mat([1,1,1])
In [12]:h = np.mat([2,2,2])
In [13]:np.dot(g,h)
Out[13]:报错
-
multiply和*----对应元素相乘(哈达码积):
In [2]:a = np.array([1,1,1])
In [3]:b = np.array([2,2,2])
In [14]:np.multiply(a,b)
Out[14]:array([2, 2, 2])In [3]:b = np.array([2,2,2])
In [5]:c = np.array([[3,3,3],[4,4,4]])
In [15]:np.multiply(b,c)
Out[15]:
array([[6, 6, 6],
[8, 8, 8]])-
multiply():
- 作用在任何类型（数组类型，矩阵类型，list类型），都为数量积|点积（即，矩阵对应元素相乘）
In [2]:a = np.array([1,1,1])
In [3]:b = np.array([2,2,2])
In [14]:np.multiply(a,b)
Out[14]:array([2, 2, 2])In [3]:b = np.array([2,2,2])
In [5]:c = np.array([[3,3,3],[4,4,4]])
In [15]:np.multiply(b,c)
Out[15]:
array([[6, 6, 6],
[8, 8, 8]])
-
-
*
-
作用在数组类型时为点乘
In [2]:a = np.array([1,1,1])
In [3]:b = np.array([2,2,2])
In [16]:a*b
Out[16]:array([2, 2, 2])-
- 不能作用在list类型（会报错）
In [17]:[1,1,1]*[2,2,2]
Out[17]:报错
- 点乘元素不对应（会报错）
In [5]:c = np.array([[3,3,3],[4,4,4]])
In [6]:d = np.array([[5],[5],[5]])
In [17]:c*d
Out[17]:报错-
- 作用在矩阵类型时为叉乘
-
In [8]:e = np.mat([[3,3,3],[4,4,4]]) In [9]:f = np.mat([[5],[5],[5]]) In [7]:e*f Out[7]: matrix([[45], [60]])
乘法的交换率: 元素乘积 和 矩阵乘法 不能交换先后顺序:
- ans1: norm(e*e)w
- ans2: (norm e)*e w
- 结论: 先算元素乘积,后算矩阵乘法 和 先算矩阵乘法,后算元素乘积的结果 截然不同
import numpy as np
normalization=np.array([[3,3,3],[3,3,3],[3,3,3]])
embedding=np.array([[0,0],[1,1],[2,2]])
w=np.array([[2,2],[2,2]])
e_e=np.multiply(embedding, embedding)
print("\n e_e:\n", ans1)
norm_e_e1=np.dot(normalization, e_e)
print("\n norm_e_e1:\n", ans1)
ans1=np.dot(norm_e_e0, w)
print("\n ans1:\n", ans1)
print("\n")
norm_e=np.dot(normalization,embedding)
print("\n norm_e:\n", ans1)
norm_e_e2=np.multiply(norm_e, embedding)
print("\n norm_e_e2:\n", ans1)
ans2=np.dot(norm_e_e, w)
print("\n ans2:\n", ans2)