现在看一个对角线外的元素。它的符号告诉你:另一个分数变大时, 往哪个方向走。
跳过这一关的小测
独立做出这 6 道题。 全部答对,这一关就算三星通关。看过答案的不算。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
热身前面关卡的 2 道题
开始前快速复习一下。可选,不会锁住这一关。
这一关要用到支线 U3 的反向规则和支线 U2 的数字格式。 如果你跳过了它们,先快速读一遍。
整个模型的训练只要一行:loss.backward()。在支线 U3 里,你为单个数字亲手搭出了这一行:
每个运算都知道自己的反向规则,链式法则把这些规则连起来。
注意力还需要两条 U3 里没有的规则:一条给 softmax,一条给矩阵乘积。
这一关先写出这两条规则,再手算一个注意力头的反向传播,然后用数值斜率检验结果。 最后算一算反向传播的代价:反向规则要用的每个值,都必须从前向传播开始一直留在 GPU 显存里, 直到反向传播用到它。
这一关的 demo.py 会打印本页的每一个数。要运行它,把它下载到一个单独的文件夹里,
在那里运行 python demo.py(环境配置)。
1. softmax 的反向传播
softmax 把分数 变成概率 :
反向传播收到 ,也就是损失对每个 的梯度,它要返回 。 新的地方在于:每个分数都会影响每一个概率,因为它们共用同一个分母 (分数线下面的那个和)。如果 变大, 变大, 和 就变小,总和保持为 1。
所以这些斜率组成一张表。第 行第 列放的是 : 变动时, 变得有多快。 这张装着所有斜率的表就是雅可比矩阵(Jacobian)。softmax 的雅可比矩阵有个简短的公式:
- 在对角线上,;
- 在对角线外,。
两行合起来:。这里 是对角线上放 、其他地方都是 0 的表,
(np.outer(p, p))是所有乘积 组成的表。这门课里向量是行,所以 是
(n, 1) @ (1, n) → (n, n)。
取 。那么 ,和是 4,。
softmax 的反向传播:一个雅可比矩阵,或一个简短公式
输入新的分数 z,或新的传入梯度 dp。两种算 dz 的方法给出的数总是一样。
| 0.50 | 0.25 | 0.25 |
| z0 | z1 | z2 | |
|---|---|---|---|
| p0 | 0.2500 | ? | ? |
| p1 | ? | ? | -0.0625 |
| p2 | ? | -0.0625 | ? |
| ? |
| ? |
| ? |
| ? | ? | ? |
| ? | ? | ? |
深入一点 这两个公式是怎么来的
记 ,于是 。 变动时, 和 都会变,而且变化率一样,都是 。 用分式的求导法则得到
另一个分数 变动时,只有 会变:。
关于 softmax 还有一个事实:给每个分数都加上同一个数 ,什么都不会变。 ,因子 既出现在分子里,也出现在分母的每一项里,所以被约掉了。
从 dp 到 dz
每个分数 都会影响每一个 ,所以 要从每个 那里收一份:。
这就是支线 U3 里的 +=:一个值在好几个地方被用到,它的梯度就是所有份额之和。
把 的公式代进这个和,它就变短了。 就是 ,而 是 ,其中 是整行共用的一个数。所以
其中 表示逐元素相乘(NumPy 里的 *)。先从 的每个元素里减去同一个数 ,再乘以 。
用 和 ,两种算法都验证一下:
- 长的算法: 的第 0 列是 ,所以 ;
- 短的算法:,所以 。
我卡在这里了 为什么不直接把 J 建出来再相乘?
结果一样,但计算量大得多。有 个分数时, 有 个元素,而简短形式只要大约 次乘法。在注意力里,每一行分数对每个 token 都有一个元素:有 1000 个 token 时,一行的 就有一百万个元素, 而每个头有 1000 行。简短形式从来不建 。
用 NumPy 写,并检验
在注意力里,softmax 沿着表的每一行做,所以每一行都要算一次 dp·p:沿最后一个轴求和。
沿一个轴求和通常会去掉这个轴:对一个 (2, 3) 的表,.sum(axis=-1) 得到形状 (2,)。
参数 keepdims=True 会把这个轴保留下来,大小为 1,于是结果是 (2, 1),每行一个数。
这样广播就能把它从它所在那一行的每个元素里减掉。
怎么知道反向传播写对了?和数值斜率 比一比,就像第 6 关和支线 U5 里那样。 有一个损失让检验特别方便:,它在 处的梯度正好是 。模板会替你做这个检验。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
在实验台里,把分数设成 。这时 , 几乎每个元素都是 0。 随便改 : 始终接近 0。一个几乎确定的 softmax 几乎不往回传梯度。 这正是第 14 关把分数除以 的原因之一:它让分数保持较小,这样训练刚开始时 softmax 不会这么确定。
2. 一个注意力头的反向传播
一个头的前向传播(第 14 关)只有三行。下面是它们的形状,共 个 token:
| 前向传播 | 形状 |
|---|---|
S = Q @ K.T / √dₖ | (L, dₖ) @ (dₖ, L) → (L, L) |
A = softmax(S),每一行 | (L, L) |
O = A @ V | (L, L) @ (L, dᵥ) → (L, dᵥ) |
反向传播按相反的顺序处理这几行,从最后一行开始。它从 dO 出发,dO 的形状和 O 一样。
所有的活只靠两条规则:
- 矩阵乘积 (第 6 关):
dX = dY @ W.T,dW = X.T @ dY。 - softmax,每一行:第 1 节的公式,把 换成 。
下图给出顺序。每个梯度的形状都和它对应的值一样,所以转置很容易检查:
| 梯度 | 来自 | 形状 |
|---|---|---|
dV | O = A @ V | (L, dᵥ) |
dA | O = A @ V | (L, L) |
dS | A = softmax(S) | (L, L) |
dQ | S = Q @ K.T / √dₖ | (L, dₖ) |
dK | S = Q @ K.T / √dₖ | (L, dₖ) |
手算一个例子
两个 token,(所以 ),。查询和键特意选得让每个分数都是 0:
的每一行和 的每一行的点积都是 0,所以 全是 0, 里每个权重都是 0.5。 每一行输出都是 各行的平均:。 从上面各层传来的梯度是 。
乘积 还给出 :。 的第 0 行说的是:token 0 给每个 token 多分一点权重时, 损失会怎么变。接下来是 softmax 这一步,一次一行。
完整的分数梯度是 。每一行加起来都是 0,和雅可比矩阵的行一样。 最后一步是 的反向传播。 前向传播把分数除以了 ,所以 和 也都要除以 。
现在看键。 每个查询占一行,每个键占一列: 是查询 1 对键 0。 看一看键 出现在 的什么位置。
我卡在这里了 为什么 dK 用 dS.T,而 dQ 用 dS?
。查询 只出现在 的第 行,所以 收集 的第 行,每个元素乘上它对应的键:
也就是 dS @ K / √dₖ。键 只出现在 的第 列,所以 收集 的第 列。dS.T 把列变成
行,dS.T @ Q / √dₖ 就对键做了同样的求和。
形状能快速检查你写的任何一行。用各不相同的大小试一试。
深入一点 加上批、多个头和掩码
真实的模型会把 个序列、 个头一起算。张量在前面多出两个轴:
S 和 A 的形状是 (B, h, L, L)。每一行代码都不变。只有 .T 要换成 .swapaxes(-1, -2),这样批的轴和头的轴才能留在原位。
因果掩码不需要额外的反向代码。被挡住的分数变成了 −∞,所以它在 里的权重是 0。
dS = A * (…) 的每个元素都要乘上它的权重,所以被挡住的位置得到的梯度正好是 0。
完整的一个头
现在用 NumPy 写出反向传播:五行,按第二张表的顺序,用你刚才手算时用过的规则。模板先在上面的例子上运行它, 然后在随机数上(3 个 token,,)把每个梯度和数值斜率比对。
Enter 保持缩进 · Tab 缩进 · 先按 Esc 再按 Tab 离开编辑框 · ⌘/Ctrl + Enter 运行
3. 反向传播必须在 GPU 显存里留下什么
再看一遍那五行反向代码。每一行都用到了前向传播的值:A、V、K、Q。
反向传播走到它们时,这些值必须还在,所以前向传播要把它们留下来。这些留下来的值叫作
保存的激活值(saved activations)。在你的代码里,它们就是元组 saved。
所以一个头会保存 Q、K、V 和 A,其他层也保存各自反向规则需要的东西(比如每个
矩阵乘积的输入)。训练从两个方面占用 GPU 显存。
按参数算:固定的开销
大模型用混合精度训练(支线 U2)。前向和反向传播用 16 位的数,bfloat16(简称 bf16)。 更新则在一份 32 位的 float32 副本(简称 fp32)上做,这样微小的变化不会被舍入吃掉。用 Adam(第 7 关)时,每个参数需要:
| 每个参数都要保存 | 格式 | 字节 |
|---|---|---|
| 前向和反向传播用的权重 | bf16 | 2 |
| 它的梯度 | bf16 | 2 |
| 权重的主副本 | fp32 | 4 |
| Adam 的 m | fp32 | 4 |
| Adam 的 v | fp32 | 4 |
每个参数一共 16 字节,和批大小、序列长度都无关。
按 token 算:激活值
保存的激活值随批里的数据增长。它们大多每个 token 一行,形状是 (B, L, d_model):当 ,,
d_model = 1000,每个数 2 字节时,一个这样的张量是 8 MB。一层会保存好几个这样的张量,比如
它的各个矩阵乘积的输入。注意力权重 A 不一样:每个头里,每一对
token 都有一个数。它的形状是 (B, h, L, L)。
一层会保存多少个 (B, L, ·) 张量?下面是一个 pre-norm 块(第 16 关),FFN 宽度是 4 × d_model。
表里一步一步列出了在朴素实现中,它的反向规则需要什么:
| 为反向传播保存 | 宽度 |
|---|---|
| 第一个 LayerNorm 的输入 | d_model |
| Q、K、V 乘积的输入(LayerNorm 的输出) | d_model |
| Q、K 和 V | 各 d_model |
| 各个头的输出,也就是输出乘积的输入 | d_model |
| 第二个 LayerNorm 的输入 | d_model |
| FFN 第一个乘积的输入 | d_model |
| FFN 隐藏层在 ReLU 之前 | 4 × d_model |
| FFN 隐藏层在 ReLU 之后,也就是它第二个乘积的输入 | 4 × d_model |
d_model) 张量为单位来数:宽度为 4 × d_model 的张量算 4 个单位。一共多少个单位?现在把序列变长,其他都不变。
实验台把训练保存的所有东西加起来,针对一个模型。拖动 ,看看哪一部分增长得最快。
训练在显存里保存什么,哪些随 L 增长
拖动 B 和 L,或者打开重计算。模型不变:24 层,宽度 1000,8 个头,3 亿个参数。刻度上每一格都是前一格的 10 倍。
| 权重、梯度、Adam16 字节 × 3 亿 | 16 字节 × 3 亿 | 4.8 GB | 51% |
| token 激活值16 × (B, L, d_model) × 24 层 | 16 × (B, L, d_model) × 24 层 | 3.1 GB | 33% |
| 注意力权重(B, h, L, L) × 24 层 | (B, h, L, L) × 24 层 | 1.5 GB | 16% |
token 激活值:就是你在上面数出的每层 16 个张量。在刻度上,条的每条分界线都是到那里为止的累计总量:灰色部分总是在 4.8 GB 结束。
深入一点 重计算:多算一些,少占显存
前向传播不必什么都保存。用重计算(recomputation),每一层只保存自己的输入。反向传播 走到这一层时,从输入出发把这一层的前向传播再跑一遍,拿回那些值,马上用掉。
在上面的例子里,一层只需保存一个 (4, 1000, 1000) 的输入,8 MB;否则光是 A 就要 64 MB,还有其他所有东西。
反向传播在某一层里时,这一层的值会重新出现,所以峰值是保存的各层输入,再加上一层的值。
代价是多跑一次前向传播。一次反向传播的计算量大约是前向的两倍。所以一个训练步从 1 + 2 = 3 份
计算变成 3 + 1 = 4 份:计算量多了约 33%,显存却省了很多。
这里的 kernel(算子)是在 GPU 上运行的一个程序。融合算子在一个程序里做好几步。
融合注意力算子比重计算还要省显存。它们保存 Q、K、V、O 和每行一个数(来自 softmax 的那个和),但不保存 A。
它们在反向传播时分成小块重新算出 A,所以不保存任何 大小的东西。课程后面会搭出这个。
softmax 这一步仍然需要每一行的 ,而它只用 O 和 dO 就能得到:
,所以 。
在第 2 节的例子里,第 0 行给出 ,而 。
小结
通关后的总结
通关后,这里会显示关键公式和常见错误。
你现在会了
- 写出 softmax 的雅可比矩阵,并且不把它建出来,用简短形式 p ⊙ (dp − dp·p) 算出 dz。
- 把一个注意力头从 dO 反向传播到 dQ、dK 和 dV,说出每一步的形状,并用数值斜率检验。
- 估算训练占用的 GPU 显存:每个参数 16 字节,再加上保存的激活值,它们随 B × L × d<sub>model</sub> 和 B × h × L² 增长。
要记住
- , 的每一行加起来都是 0
s = (dp * p).sum(-1, keepdims=True),然后dz = p * (dp - s)- 矩阵乘积 的反向传播是
dX = dY @ W.T和dW = X.T @ dY;每个梯度的形状都和它对应的值一样 - 查询 在分数的第 行,键 在第 列:dK 要用 dS 的转置,dQ 不用,两者都保留
- 混合精度的 Adam:每个参数 2 + 2 + 4 + 4 + 4 = 16 字节
- 一个 pre-norm 块为反向传播保存大约 16 个形状为 (B, L, d<sub>model</sub>) 的张量,A 另算
- 保存的注意力权重:每层 B × h × L × L 个数(朴素实现如此;融合算子一个都不保存)
常见错误
- 在 dQ 和 dK 里忘了 1/√dₖ,或者把 dS 的行和列弄混。
- 训练时只算 bf16 权重(每个 2 字节):梯度、主副本和 Adam 的 m、v 加起来,一共是 16 字节。
按 ? 查看快捷键