深度学习--爱因斯坦求和einsum--85-编程知识

深度学习--爱因斯坦求和einsum--85

news/2025/3/13 3:33:52/文章来源:https://www.cnblogs.com/cavalier-chen/p/18236361

1. 爱因斯坦求和的来源
2. 求和表达式的规范
3. 规则1：外部重复做乘积
4. 规则2 内部重复把数取
5. 规则3 从有到无要求和
6. 规则4 重复默认要丢弃
7. 把这个实现一下加深理解

1. 爱因斯坦求和的来源

https://zhuanlan.zhihu.com/p/672346603
爱因斯坦在研究相对论时，曾经对冗余的求和公式做了一个简化版的约定，并且发表在了一些关于相对论的书籍，比如《The Meaning of Relativity》中。
看完后你就与爱因斯坦有过碰撞了！！
原始的约定其实很简单：

省略求和符号，简化书写。。。

意思就是下标出现两次的求和公式可以将求和符号省略：

对于这个求和约定，爱因斯坦曾经这么评价：
这是数学史上的一大发现，若不信的话，可以试着返回那不使用这方法的古板日子。
这就是爱因斯坦求和约定最原始的出处，简称为 einsum。

后来各个领域比如数学，物理，AI 等领域都对求和约定进行了一些规范化。
最近很多代码实现都基于einsum，用一种最好理解的方式讲一下爱因斯坦求和约定。

注意：
下面讲的主要是针对 AI 领域的，也就是 np.einsum 或者 torch.einsum，tf.sinsum,物理等其他领域的可能有其他的约定。

einsum，4句口诀：
外部重复做乘积,
内部重复把数取,
从有到无要求和,
重复默认要丢弃.

2. 求和表达式的规范

首先理解一下求和标记。np.einsum 或者 torch.einsum 的第一个参数是求和标记，它表明了 einsum 的输入下标和输出下标，我们举个例子。

np.einsum('ij,jk->ijk', A, B)  # 得到的是一个新的矩阵 维度是(i,j,k)

看下图更直观：

解释：
-> 符号左边是输入下标，右侧是输出下标
, 对输入的下标进行分割，分割后第n段代表第n个输入
下标用'a-z'的小写字母表示，代表了输入的第几维。
比如上例中逗号左侧的i是输入A的第1维， j是输入A的第2维。
逗号右侧的j是输入B的第1维， k是输入B的第二维。

内部重复与外部重复
求和标记的下标有时候会重复，比如 ij,jk->ijk 中，输入坐标j就重复了。
注意：
重复只针对输入下标，输出下标是没有重复的。
重复的下标做对应输入维度的长度肯定是相同的。

举例：
比如 A.shape 为 (2,3,2)，B.shape 为 (2,3,4), 此时 'iji,ijk' 是合法的。
但是：
'iii,ijk' 非法，因为 A 的第一维长度为2，第二维长度为3，不匹配。
'iji,iji' 非法，因为 B 的最后一维长度为4，i 所在维度都是2，不匹配。
'ija,ijk' 合法，长度相同的可以不重复，但是重复的一定长度相同。

对于例子 'ij,jk->ijk'来说，可以看到重复的 j 分别属于两个输入，中间用逗号隔开，我们称这种为外部重复。
如果重复的下标出现在了同一个输入中，则称为内部重复。比如 iji,jk->ijk, 此时 i 为内部重复， j 为外部重复。
下标可以同时为内部重复和外部重复，比如 iji,ijk->ijk。此时 i 在第一个输入中内部重复，同时在第一个和第二个输入中外部重复。

先把上面的约定理解了

3. 规则1：外部重复做乘积

在 np.einsum('ij,jk->ijk', A, B) 这个例子中，j 属于外部重复
einsum 会对外部重复的下标进行相乘操作，一个方便理解但是并不高效的实现方法如下：

for i in range(A.shape[0]):for j in range(A.shape[1]):for k in range(B.shape[1]):C[i, j, k] = A[i, j] * B[j, k]

高维没法画图：

A4D = np.random.randint(20, size=(3, 4, 5, 2))
B3D = np.random.randint(20, size=(2, 4, 5))
x = np.einsum('ipqk,jpq->ijkpq', A4D, B3D)
# x的shape (3,2,2,4,5)y = np.zeros((3,2,2,4,5))
# equals below
for i in range(A4D.shape[0]):for j in range(B3D.shape[0]):for k in range(A4D.shape[3]):for p in range(A4D.shape[1]):for q in range(A4D.shape[2]):y[i,j,k,p,q] = A4D[i,p,q,k] * B3D[j,p,q]
y

4. 规则2 内部重复把数取

对于前一个例子来说，可以看到输入对每个维度都遍历了一遍，那可以思考一下，如果一个下标内部重复了，在遍历时是个什么情况？
A 是一个 3x3 的矩阵，求和标记为 'ii->i', 如果仿照上面类似的方法进行运算

C = np.einsum('ii->i', A)for i in range(A.shape[0]):for i in range(A.shape[1]):C[i] = A[i, i]

如果这么写，你会发现 C[i] 的值会被改写，这在 einsum 中是不允许的，所以同一下标只能迭代一次才能保证输出的稳定性。
正确的写法：

for i in range(A.shape[0]):C[i] = A[i, i]

可以看到，输入中只有部分参与了运算，所以对于内部重复的下标，其实是一个取数的操作。
上面的例子就是取数，而且正好是取了矩阵的对角线，相当于 diag 操作。

5. 规则3 从有到无要求和

上面的例子有个特点，那就是输入的下标全部都在输出中都出现了。那假设输出中某些下标没有了，对于这些消失的下标要进行求和操作。
还是以第一个举例，假设求和标记从 ij,jk->ijk 变成了 ij,jk->ik。也就是下标 j 消失了，这个时候要对 j 维进行求和，相当于 np.sum(y, axis=j)

这不就是矩阵的乘法

A = np.random.randint(20, size=(2,3))
B = np.random.randint(20, size=(3,4))
print(A)
print(B)
C = np.zeros((2,4))
for i in range(A.shape[0]):for k in range(B.shape[1]):for j in range(A.shape[1]):C[i, k] += A[i, j] * B[j, k]
print(C)            C = np.ones((2,4))
for i in range(A.shape[0]):for k in range(B.shape[1]):C[i, k] = (A[i, :] * B[:, k]).sum()  # 取A的第i行 与B的k列相乘相加结果放入C[i,k]
print(C)

6. 规则4 重复默认要丢弃

在使用中，有时候你会看到只有输入下标。没有 -> 和输出下标。
这个时候就触发了默认求和标记，此时输出默认为：重复下标都去掉，不重复的下标按字母序保留。

A = np.random.randint(0, 20, size=(2, 3, 2))
B = np.random.randint(0, 20, (3, 4))
print(A) # (2,3, 2)
print(B) # (3,4)

A = np.random.randint(20, size=(2,3))
B = np.random.randint(20, size=(3,4))
print(A)
print(B)np.einsum('ij,jk', A, B)
np.einsum('ij,jk->ik', A, B)
# 这两等价