第 1 关 · 基础 · 在浏览器里运行
English

矩阵与形状

两张数字表怎么相乘?结果是什么形状?

打开一个 Transformer 看看,几乎每个部件都是矩阵乘法。把这一种运算练到觉得轻松为止。 做到这一点,课程后面的内容会容易得多。

矩阵(matrix)就是一张数字表。它的形状(shape)说明这张表有多大:形状 (2, 3) 表示 2 行 3 列。 C[0][1] 表示矩阵 C 第 0 行、第 1 列的那个数。

1. 一次算一格

只有一条规则:结果第 i 行、第 j 列的那一格 = 左边矩阵的第 i 行 · 右边矩阵的第 j 列。 这里的“·”(点积,dot product)意思是:把两个列表逐个数相乘,再全部加起来。行和列都从 0 开始数, 所以“第 0 行”是最上面一行,“第 1 列”是第二列,从上往下读。把鼠标指向 C 的某一格(手机上点一下)就能看到。

两个矩阵相乘,一次算一格

指向或点一下 C 的某一格,看它是怎么算出来的。A 和 B 里的每个数都可以改。

A
@
B
=
C
4?
01
(2, 3) @ (3, 2) → (2, 2)
A 的行数 2 内侧大小 3 B 的列数 2
选 C 的一格。
数字 A = [[1, 2, 3], [0, 1, 0]],B = [[1, 0], [0, 1], [1, 1]]。C[0][1] 是多少?

2. 形状规则

形状规则就来自那一条规则。要把 A 的一行和 B 的一列逐个数相乘, 这一行和这一列的长度必须相同。在 NumPy 里,以及在整个课程里,@ 都表示矩阵乘法。所以:

(n,k)  @  (k,m)  →  (n,m)(n, k) \; @ \; (k, m) \;\to\; (n, m)

内侧的两个数必须相等,并且会消失。剩下的是外侧的两个数。内侧的数相等时,我们说这两个形状对得上。

形状 (3, 4) @ (4, 2) 的形状是什么?
选择A 是 (3, 2),B 是 (3, 2)。A @ B 会怎样?

答案里的那次翻转有个名字:转置(transpose),写作 B.T。B 的第 i 行变成 B.T 的第 i 列, 所以 (3, 2) 的矩阵变成 (2, 3)。你会在第 6 关用到它,在注意力里还会再用到。

我卡在这里了 为什么不直接逐格相乘,就像两个矩阵相加那样?

这种运算也有。在 NumPy 里它是 A * B。它要求两个矩阵形状相同, 在掩码之类的地方会用到。但它从不在不同位置之间混合信息: (0,0) 这一格永远只看到 (0,0) 这一格。

矩阵乘法会混合。每个输出格都把一整行和一整列结合起来。 神经网络的一层需要的正是这种混合。每个输出都是所有输入的加权和。

3. 自己写一遍

用三层循环写出乘法,不用 @,也不用 np.dot。最内层的循环遍历内侧的大小, 也就是会消失的那个维度。

代码用三层循环写出矩阵乘法,不用 @,也不用 np.dot(a 和 b 是列表的列表)。分别遍历输出的行、输出的列和内侧的大小,每一轮把一个乘积加到某个输出格上。需要写好几行。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

4. 你会见到上百次的形状

真实的模型不会一次只乘一个句子。它把几个句子叠成一个批(batch),所以输入 有三个维度:(batch, length, features)。乘一个权重矩阵只会动到最后一个维度。 规则不变:内侧的数必须相等,并且会消失。

形状 X 是 (2, 5, 4):2 个句子,每句 5 个词,每个词 4 个数。W 是 (4, 8)。X @ W 是什么形状?

下面把这次乘法画成方块。拖动可以旋转:batch 轴指向远离你的方向。

一批数据经过同一个权重矩阵

只有最后一个轴变了:每个词的 4 个数变成 8 个。在 3D 视图里拖动可以转动这些方块。

第一句的一个词:进来 4 个数,出去 8 个W:每一句的每一个词都用同一个
深入一点 为什么一层是 (batch, length, d_in) @ (d_in, d_out)

把左边的矩阵看成“每个词一行”。每个词是一个有 d_in 个数的列表。 把右边的矩阵看成“每个新特征一列”。每一列说明每个输入数有多少 进入这个新特征。

所以 X @ W 把每个词的 d_in 个数变成 d_out 个新数,而且每个词用的是同一个 W。 W 里没有任何关于批大小或句子长度的东西。这就是为什么同一层 既能处理 2 个句子的批,也能处理 2000 个的;既能处理 5 个词的句子,也能处理 500 个词的。

在第 14 关你会看到 X @ W_Q、X @ W_K、X @ W_V:三个这样的乘法,一个接一个。

动手试试

在实验台里,给 A 加一列。结果消失了,因为形状对不上了。 现在给 B 加一行。结果又回来了。你必须改的是哪个数?为什么?

5. 广播:把形状不同的数组相加

两个形状相同的矩阵相加很简单:逐格相加。但模型经常要加上更小的东西: 给每个样本加同一行偏置,给每个词加同一行掩码。NumPy 为此有一条规则,叫 广播(broadcasting):大小为 1 的维度会被拉伸(复制),直到和另一个数组对上。

一列 (4, 1) 加一行 (1, 5):这一列被横向复制 5 次,这一行被纵向复制 4 次, 然后逐格相加。

形状 一列形状 (4, 1) 加一行形状 (1, 5)。结果是什么形状?

刚才两个数组里各有一个 1。如果其中一个数组根本没有 1 呢?

先猜一猜A 是 (3, 2)。v 是一个普通的列表,有 3 个数,形状 (3,)。先猜再看:A + v 会怎样?

选一种情况,把鼠标指向结果的某一格(或点一下)。浅色的格子是拉伸出来的副本。NumPy 从不存储它们。 实验台用的是它自己的数(a = [0, 1, 2, 3]),所以它的表格不是下面这道题的答案。

广播:先拉伸,再相加

选一个例子,然后指向或点一下结果里的某一格。

A (4, 1) → (4, 5)
00000
11111
22222
33333
+
B (1, 5) → (4, 5)
010203040
010203040
010203040
010203040
=
结果 (4, 5)
010203040
111213141
212223242
313233343
A 向右拉伸,B 向下拉伸。
拉伸出来的副本,并没有存下来 你选的那一格,和算出它的两个数

规则是从右往左一次检查一个维度:

  1. 两个大小相等,没问题。
  2. 其中一个是 1,把它拉伸成另一个。
  3. 否则,报错。

左边缺少的维度当作 1,所以 (5,) 的数组和 (1, 5) 的表现一样。

数字 a = [[1], [2], [3], [4]] 的形状是 (4, 1)。b = [[10, 20, 30, 40, 50]] 的形状是 (1, 5)。(a + b)[2][3] 是多少?

6. 你会在哪里用到它

这一节是往后看。里面的词在第 10–15 关才会讲;这里只关心形状。 在第 14–15 关,一个批的注意力分数形状是 (batch, words, words):对每个句子, 每个词对其他每个词都有一个分数。有些句子比较短,末尾是填充词,所以每个句子 都带一个填充掩码:True 标出必须屏蔽的填充词(在 softmax 之前把它的分数设成 −∞, softmax 你会在第 10 关见到)。掩码每个句子只存一份,形状是 (batch, 1, words), 广播把它拉伸到每一行。

形状 这里只关心形状。一个批的注意力分数形状是 (2, 4, 4):2 个句子,每句 4 个词。填充掩码的形状是 (2, 1, 4)。把掩码用到分数上时,两者广播成什么形状?

同一件事的 3D 版本。每个句子只存一行掩码;广播让 4 行都读这一行。

存一行掩码,读四次

掩码每句只存一行。广播把它用到分数的每一行上。

每一句只存的那一行掩码广播读出来的副本,并没有存第一句
我卡在这里了 NumPy 真的把这一列复制了 5 次吗?这不浪费吗?

并没有复制。NumPy 只记住这个维度的大小是 1。每次读取拉伸后数组的某一格时, 它读的都是存着的同一个数。这就是实验台里那些格子是浅色的原因:它们不是真正的格子。 所以把一行 (1, 5) 和一百万行做广播,这一行不会多占任何内存。

深入一点 X @ W + b 里的偏置也是一次广播

一层计算的是 X @ W + b。X @ W 是 (N, d_out):每个样本一行。b 是 (d_out,),每个 输出一个数。按照规则,b 被当作 (1, d_out),向下拉伸成 N 行,所以每个样本加的都是 同一个偏置。没人去写这个复制;广播替你做了。从第 5 关开始,你在每一层都会用到它。

7. 沿一个轴求和

很多步骤都要沿表格的某一个方向把数加起来。在 NumPy 里用 axis 选方向。 取形状为 (3, 2) 的 A:

A = [[1, 2],
     [3, 4],
     [5, 6]]
A.sum(axis=0)  →  [9, 12]       # 沿行往下加:每列一个总和,形状 (2,)
A.sum(axis=1)  →  [3, 7, 11]    # 沿一行横着加:每行一个总和,形状 (3,)
A.mean(axis=0) →  [3, 4]        # 同上,再除以 3 行

axis=0 去掉行。axis=1 去掉列。你指定的那个轴就是消失的那个。

形状 X 的形状是 (4, 3)。X.sum(axis=0) 的形状是什么?

现在把两个想法放到一起。X.mean(axis=0) 的形状是 (d,):每列一个均值。从 X (形状 (N, d))里减去它就是一次广播:这一行均值被向下拉伸到全部 N 行。结果的每一列 都以 0 为中心。第 16 关的 LayerNorm 也用同样的方式居中,只不过是对每一行而不是每一列:它沿 最后一个轴取均值,每个词一个均值,再减去它。

代码从 X 里减去每一列的均值,让每一列的均值都是 0。用 .mean(axis=0) 和广播。

Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行

读懂一行数据代码

演示文件经常用一两行代码造一个小数据集。一个形状一个形状地读:

# 60 行叠在 60 行上面 → (120, 2)
pts = np.vstack([np.zeros((60, 2)), np.ones((60, 2))])
# 60 个 0,然后 60 个 1 → (120,)
labels = np.repeat([0, 1], 60)

np.vstack 把数组上下叠起来,所以行数相加:60 + 60 = 120。np.repeat 把每一项 重复若干次。演示代码里某一行让你看不懂时,在每一步之后打印 .shape。

可选支线:支线 U1 讲计算机怎样把这样的数组存成一行数字, 以及为什么有些 reshape 不花任何代价。第 2 关继续主线;你随时可以回来看 U1。

小结

通关后的总结

通关后,这里会显示关键公式和常见错误。

你现在会了

  • 手算 A @ B 的任意一格:A 的第 i 行乘 B 的第 j 列,再求和。
  • 运行之前就说出矩阵乘积的形状,或者说出它会报错。
  • 预测 NumPy 会把两个数组广播成什么形状,并沿某一个轴求和。

要记住

  • C[i][j] = A 的第 i 行乘 B 的第 j 列,逐个数相乘再加起来
  • (n, k) @ (k, m) → (n, m):内侧的两个数必须相等
  • (batch, length, d_in) @ (d_in, d_out) → (batch, length, d_out):同一个矩阵乘每个词的那一行
  • 广播从右往左比较各维的大小;大小为 1 的维会被重复,直到对上
  • 对 (4, 3) 做 X.sum(axis=0) → (3,):你指定的那个轴会消失

常见错误

  • 想算 A @ B,却写成了逐格相乘(A * B)。
  • 检查的是外侧的两个数,而不是内侧的:(3, 2) @ (3, 2) 会报错。
这一关之后可以去的支线可选;下一关用不到它们。

按 ? 查看快捷键

阅读模式 · 实验台数值全部显示,不计星