第 U6 关 · 原理 · 深入底层 · 在浏览器里运行
English

注意力的反向传播

梯度怎样穿过注意力传回去?为此训练时必须在显存里留下什么?

支线 · 最好在之后学: 第 17 · 完整的 Transformer 关

这一关要用到支线 U3 的反向规则和支线 U2 的数字格式。 如果你跳过了它们,先快速读一遍。

整个模型的训练只要一行:loss.backward()。在支线 U3 里,你为单个数字亲手搭出了这一行: 每个运算都知道自己的反向规则,链式法则把这些规则连起来。 注意力还需要两条 U3 里没有的规则:一条给 softmax,一条给矩阵乘积。

这一关先写出这两条规则,再手算一个注意力头的反向传播,然后用数值斜率检验结果。 最后算一算反向传播的代价:反向规则要用的每个值,都必须从前向传播开始一直留在 GPU 显存里, 直到反向传播用到它。

这一关的 demo.py 会打印本页的每一个数。要运行它,把它下载到一个单独的文件夹里, 在那里运行 python demo.py(环境配置)。

1. softmax 的反向传播

softmax 把分数 zz 变成概率 pp:

pi=ezi∑jezjp_i = \frac{e^{z_i}}{\sum_j e^{z_j}}

反向传播收到 dpdp,也就是损失对每个 pip_i 的梯度,它要返回 dzdz。 新的地方在于:每个分数都会影响每一个概率,因为它们共用同一个分母 (分数线下面的那个和)。如果 z1z_1 变大,p1p_1 变大,p0p_0 和 p2p_2 就变小,总和保持为 1。

所以这些斜率组成一张表。第 ii 行第 jj 列放的是 ∂pi/∂zj\partial p_i / \partial z_j:zjz_j 变动时,pip_i 变得有多快。 这张装着所有斜率的表就是雅可比矩阵(Jacobian)JJ。softmax 的雅可比矩阵有个简短的公式:

  • 在对角线上,Jii=pi(1−pi)J_{ii} = p_i (1 - p_i);
  • 在对角线外,Jij=−pi pjJ_{ij} = -p_i \, p_j。

两行合起来:J=diag(p)−p⊤pJ = \text{diag}(p) - p^\top p。这里 diag(p)\text{diag}(p) 是对角线上放 pp、其他地方都是 0 的表, p⊤pp^\top p(np.outer(p, p))是所有乘积 pipjp_i p_j 组成的表。这门课里向量是行,所以 p⊤pp^\top p 是 (n, 1) @ (1, n) → (n, n)。

取 z=[ln⁡2,0,0]z = [\ln 2, 0, 0]。那么 ez=[2,1,1]e^z = [2, 1, 1],和是 4,p=[0.5,0.25,0.25]p = [0.5, 0.25, 0.25]。

softmax 的反向传播:一个雅可比矩阵,或一个简短公式

输入新的分数 z,或新的传入梯度 dp。两种算 dz 的方法给出的数总是一样。

分数 z
p = softmax(z)
0.500.250.25
dp(来自后一层)
J = diag(p) − pᵀp
z0z1z2
p00.2500??
p1??-0.0625
p2?-0.0625?
行和
?
?
?
dz = dp @ J
???
dz = p ⊙ (dp − dp·p)
???
dp · p = ?,所以每个 dzᵢ 都是 pᵢ × (dpᵢ − dp · p)。
J 的第 i 行:每个分数变动时,pᵢ 怎么变 ? 答对下面的题,就能看到这个数
数字 softmax 给出 p = [0.5, 0.25, 0.25]。它的雅可比矩阵是 J = diag(p) − pᵀp,所以 J[i][i] = pᵢ(1 − pᵢ)。J[1][1] 是多少?
深入一点 这两个公式是怎么来的

记 s=∑jezjs = \sum_j e^{z_j},于是 pi=ezi/sp_i = e^{z_i} / s。ziz_i 变动时,ezie^{z_i} 和 ss 都会变,而且变化率一样,都是 ezie^{z_i}。 用分式的求导法则得到

∂pi∂zi=ezis−eziezis2=pi−pi2=pi(1−pi).\frac{\partial p_i}{\partial z_i} = \frac{e^{z_i} s - e^{z_i} e^{z_i}}{s^2} = p_i - p_i^2 = p_i (1 - p_i).

另一个分数 zjz_j 变动时,只有 ss 会变:∂pi/∂zj=−eziezj/s2=−pi pj\partial p_i / \partial z_j = -e^{z_i} e^{z_j} / s^2 = -p_i \, p_j。

现在看一个对角线外的元素。它的符号告诉你:另一个分数变大时,p0p_0 往哪个方向走。

数字 softmax 给出 p = [0.5, 0.25, 0.25]。在对角线外,雅可比矩阵 J = diag(p) − pᵀp 的元素是 J[i][j] = −pᵢ·pⱼ。J[0][1] 是多少?

关于 softmax 还有一个事实:给每个分数都加上同一个数 cc,什么都不会变。 ezi+c=ec ezie^{z_i + c} = e^c \, e^{z_i},因子 ece^c 既出现在分子里,也出现在分母的每一项里,所以被约掉了。

选择对 p = [0.5, 0.25, 0.25],J = diag(p) − pᵀp,J[i][j] 表示 zⱼ 变动时 pᵢ 变得有多快。给每个分数都加上同一个数 c,p 不变。J 的每一行加起来是多少?

从 dp 到 dz

每个分数 zjz_j 都会影响每一个 pip_i,所以 dzjdz_j 要从每个 pip_i 那里收一份:dpi×Jijdp_i \times J_{ij}。 这就是支线 U3 里的 +=:一个值在好几个地方被用到,它的梯度就是所有份额之和。

dzj=∑idpi Jij,that is,dz=dp  Jdz_j = \sum_i dp_i \, J_{ij}, \quad \text{that is,} \quad dz = dp \; J

把 JJ 的公式代进这个和,它就变短了。dp  diag(p)dp \; \text{diag}(p) 就是 dpj pjdp_j \, p_j,而 dp  p⊤pdp \; p^\top p 是 (dp⋅p) pj(dp \cdot p) \, p_j,其中 dp⋅pdp \cdot p 是整行共用的一个数。所以

dz=p⊙(dp−dp⋅p)dz = p \odot (dp - dp \cdot p)

其中 ⊙\odot 表示逐元素相乘(NumPy 里的 *)。先从 dpdp 的每个元素里减去同一个数 dp⋅pdp \cdot p,再乘以 pp。

用 p=[0.5,0.25,0.25]p = [0.5, 0.25, 0.25] 和 dp=[1,1,0]dp = [1, 1, 0],两种算法都验证一下:

  • 长的算法:JJ 的第 0 列是 [0.25,−0.125,−0.125][0.25, -0.125, -0.125],所以 dz0=1×0.25+1×(−0.125)+0×(−0.125)=0.125dz_0 = 1 \times 0.25 + 1 \times (-0.125) + 0 \times (-0.125) = 0.125;
  • 短的算法:dp⋅p=0.5+0.25+0=0.75dp \cdot p = 0.5 + 0.25 + 0 = 0.75,所以 dz0=p0(dp0−0.75)=0.5×0.25=0.125dz_0 = p_0 (dp_0 - 0.75) = 0.5 \times 0.25 = 0.125。
数字 softmax 给出 p = [0.5, 0.25, 0.25],传到 p 的梯度是 dp = [1, 0, 2]。用上面 dz 的简短形式,不要建出 J。dz[2] 是多少?
我卡在这里了 为什么不直接把 J 建出来再相乘?

结果一样,但计算量大得多。有 nn 个分数时,JJ 有 n×nn \times n 个元素,而简短形式只要大约 2n2n 次乘法。在注意力里,每一行分数对每个 token 都有一个元素:有 1000 个 token 时,一行的 JJ 就有一百万个元素, 而每个头有 1000 行。简短形式从来不建 JJ。

用 NumPy 写,并检验

在注意力里,softmax 沿着表的每一行做,所以每一行都要算一次 dp·p:沿最后一个轴求和。 沿一个轴求和通常会去掉这个轴:对一个 (2, 3) 的表,.sum(axis=-1) 得到形状 (2,)。 参数 keepdims=True 会把这个轴保留下来,大小为 1,于是结果是 (2, 1),每行一个数。 这样广播就能把它从它所在那一行的每个元素里减掉。

怎么知道反向传播写对了?和数值斜率 (L(z+h)−L(z−h))/2h(L(z + h) - L(z - h)) / 2h 比一比,就像第 6 关和支线 U5 里那样。 有一个损失让检验特别方便:L=∑dp⊙softmax(z)L = \sum dp \odot \text{softmax}(z),它在 pp 处的梯度正好是 dpdp。模板会替你做这个检验。

代码写出一个沿每一行做的 softmax 的反向传播:返回 dz = p ⊙ (dp − dp·p),其中 dp·p 逐行计算。

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

动手试试

在实验台里,把分数设成 z=[10,0,0]z = [10, 0, 0]。这时 p≈[1,0,0]p \approx [1, 0, 0],JJ 几乎每个元素都是 0。 随便改 dpdp:dzdz 始终接近 0。一个几乎确定的 softmax 几乎不往回传梯度。 这正是第 14 关把分数除以 dk\sqrt{d_k} 的原因之一:它让分数保持较小,这样训练刚开始时 softmax 不会这么确定。

2. 一个注意力头的反向传播

一个头的前向传播(第 14 关)只有三行。下面是它们的形状,共 LL 个 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 一样。 所有的活只靠两条规则:

  • 矩阵乘积 Y=XWY = X W(第 6 关):dX = dY @ W.T,dW = X.T @ dY。
  • softmax,每一行:第 1 节的公式,把 pp 换成 AA。

下图给出顺序。每个梯度的形状都和它对应的值一样,所以转置很容易检查:

梯度来自形状
dVO = A @ V(L, dᵥ)
dAO = A @ V(L, L)
dSA = softmax(S)(L, L)
dQS = Q @ K.T / √dₖ(L, dₖ)
dKS = Q @ K.T / √dₖ(L, dₖ)
dQdKdSdVdAdOQKSQ @ K.T/ √dₖAsoftmaxOA @ VV
实线箭头:前向传播。虚线箭头:反向传播。它从右边的 dO 出发,每个箭头上标着它算出的梯度。先由 O = A @ V 给出 dV 和 dA,再由 softmax 给出 dS,最后由分数给出 dQ 和 dK。

手算一个例子

两个 token,dk=4d_k = 4(所以 dk=2\sqrt{d_k} = 2),dv=2d_v = 2。查询和键特意选得让每个分数都是 0:

Q=[11000011]K=[1−100001−1]V=[2011]Q = \begin{bmatrix} 1 & 1 & 0 & 0 \\ 0 & 0 & 1 & 1 \end{bmatrix} \quad K = \begin{bmatrix} 1 & -1 & 0 & 0 \\ 0 & 0 & 1 & -1 \end{bmatrix} \quad V = \begin{bmatrix} 2 & 0 \\ 1 & 1 \end{bmatrix}

QQ 的每一行和 KK 的每一行的点积都是 0,所以 SS 全是 0,AA 里每个权重都是 0.5。 每一行输出都是 VV 各行的平均:O=[[1.5,0.5],[1.5,0.5]]O = [[1.5, 0.5], [1.5, 0.5]]。 从上面各层传来的梯度是 dO=[[1,0],[0,2]]dO = [[1, 0], [0, 2]]。

数字 一个注意力头,2 个 token:权重是 A = [[0.5, 0.5], [0.5, 0.5]],传到输出 O = A @ V 的梯度是 dO = [[1, 0], [0, 2]]。用上面列表里的矩阵乘积规则。dV[0][1] 是多少?

乘积 O=AVO = A V 还给出 dAdA:dA=dO  V⊤=[[2,1],[0,2]]dA = dO \; V^\top = [[2, 1], [0, 2]]。dAdA 的第 0 行说的是:token 0 给每个 token 多分一点权重时, 损失会怎么变。接下来是 softmax 这一步,一次一行。

数字 两个 token。权重是 A = [[0.5, 0.5], [0.5, 0.5]],传到它们的梯度是 dA = [[2, 1], [0, 2]]。softmax 逐行反向传播:dS = A ⊙ (dA − 这一行的 dA·A)。dS[1][0] 是多少?

完整的分数梯度是 dS=[[0.25,−0.25],[−0.5,0.5]]dS = [[0.25, -0.25], [-0.5, 0.5]]。每一行加起来都是 0,和雅可比矩阵的行一样。 最后一步是 S=QK⊤/dkS = Q K^\top / \sqrt{d_k} 的反向传播。 前向传播把分数除以了 dk\sqrt{d_k},所以 dQdQ 和 dKdK 也都要除以 dk\sqrt{d_k}。

数字 两个 token,dₖ = 4。分数梯度是 dS = [[0.25, −0.25], [−0.5, 0.5]],键是 K = [[1, −1, 0, 0], [0, 0, 1, −1]]。分数是 S = Q @ K.T / √dₖ。dQ[1][0] 是多少?

现在看键。SS 每个查询占一行,每个键占一列:S[1][0]S[1][0] 是查询 1 对键 0。 看一看键 jj 出现在 S=QK⊤/dkS = Q K^\top / \sqrt{d_k} 的什么位置。

数字 还是同一个例子:Q = [[1, 1, 0, 0], [0, 0, 1, 1]],dₖ = 4,分数梯度是 dS = [[0.25, −0.25], [−0.5, 0.5]]。dK[0][2],也就是键 0 第 2 个元素处的梯度,是多少?
我卡在这里了 为什么 dK 用 dS.T,而 dQ 用 dS?

Sij=qi⋅kj/dkS_{ij} = q_i \cdot k_j / \sqrt{d_k}。查询 ii 只出现在 SS 的第 ii 行,所以 dqidq_i 收集 dSdS 的第 ii 行,每个元素乘上它对应的键: 也就是 dS @ K / √dₖ。键 jj 只出现在 SS 的第 jj 列,所以 dkjdk_j 收集 dSdS 的第 jj 列。dS.T 把列变成 行,dS.T @ Q / √dₖ 就对键做了同样的求和。

形状能快速检查你写的任何一行。用各不相同的大小试一试。

形状 一个注意力头:L = 5 个 token,dₖ = 3,dᵥ = 6。Q 和 K 是 (5, 3),V 是 (5, 6)。dK 的形状是什么?
深入一点 加上批、多个头和掩码

真实的模型会把 BB 个序列、hh 个头一起算。张量在前面多出两个轴: S 和 A 的形状是 (B, h, L, L)。每一行代码都不变。只有 .T 要换成 .swapaxes(-1, -2),这样批的轴和头的轴才能留在原位。

因果掩码不需要额外的反向代码。被挡住的分数变成了 −∞,所以它在 AA 里的权重是 0。 dS = A * (…) 的每个元素都要乘上它的权重,所以被挡住的位置得到的梯度正好是 0。

完整的一个头

现在用 NumPy 写出反向传播:五行,按第二张表的顺序,用你刚才手算时用过的规则。模板先在上面的例子上运行它, 然后在随机数上(3 个 token,dk=2d_k = 2,dv=4d_v = 4)把每个梯度和数值斜率比对。

代码写出一个注意力头的反向传播:从 dO 出发,算出 dV 和 dA,然后算 dS(softmax 逐行反向传播),再算 dQ 和 dK。要写好几行,缩进都一样。

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

3. 反向传播必须在 GPU 显存里留下什么

再看一遍那五行反向代码。每一行都用到了前向传播的值:A、V、K、Q。 反向传播走到它们时,这些值必须还在,所以前向传播要把它们留下来。这些留下来的值叫作 保存的激活值(saved activations)。在你的代码里,它们就是元组 saved。

选择softmax 的反向传播计算 dz = p ⊙ (dp − dp·p)。要对 A = softmax(S) 做这一步,训练必须保存前向传播的哪个值?

所以一个头会保存 Q、K、V 和 A,其他层也保存各自反向规则需要的东西(比如每个 矩阵乘积的输入)。训练从两个方面占用 GPU 显存。

按参数算:固定的开销

大模型用混合精度训练(支线 U2)。前向和反向传播用 16 位的数,bfloat16(简称 bf16)。 更新则在一份 32 位的 float32 副本(简称 fp32)上做,这样微小的变化不会被舍入吃掉。用 Adam(第 7 关)时,每个参数需要:

每个参数都要保存格式字节
前向和反向传播用的权重bf162
它的梯度bf162
权重的主副本fp324
Adam 的 mfp324
Adam 的 vfp324

每个参数一共 16 字节,和批大小、序列长度都无关。

数字 用混合精度和 Adam 训练时,每个参数要保存:bf16 的权重(2 字节)、bf16 的梯度(2 字节)、一份 fp32 的主副本(4 字节),还有 fp32 的 Adam 的 m 和 v(各 4 字节)。一个有 70 亿参数的模型,光这些就需要多少 GB?(1 GB = 10⁹ 字节)

按 token 算:激活值

保存的激活值随批里的数据增长。它们大多每个 token 一行,形状是 (B, L, d_model):当 B=4B = 4,L=1000L = 1000, d_model = 1000,每个数 2 字节时,一个这样的张量是 8 MB。一层会保存好几个这样的张量,比如 它的各个矩阵乘积的输入。注意力权重 A 不一样:每个头里,每一对 token 都有一个数。它的形状是 (B, h, L, L)。

数字 一个注意力层为反向传播保存它的权重 A,形状是 (B, h, L, L)。B = 4 个序列,h = 8 个头,L = 1000 个 token,每个数 2 字节。这是多少 MB?(1 MB = 10⁶ 字节)

一层会保存多少个 (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
数字 一个 pre-norm 块为反向传播保存上表里的张量。以一个 (B, L, d_model) 张量为单位来数:宽度为 4 × d_model 的张量算 4 个单位。一共多少个单位?

现在把序列变长,其他都不变。

选择每一层训练都要保存形状为 (B, L, 宽度) 的激活值和形状为 (B, h, L, L) 的注意力权重。你把 L 从 1000 翻倍到 2000,B、h 和宽度不变。激活值翻倍。保存的注意力权重会怎样?

实验台把训练保存的所有东西加起来,针对一个模型。拖动 LL,看看哪一部分增长得最快。

训练在显存里保存什么,哪些随 L 增长

拖动 B 和 L,或者打开重计算。模型不变:24 层,宽度 1000,8 个头,3 亿个参数。刻度上每一格都是前一格的 10 倍。

总共 9.4 GB,一块 80 GB GPU 放得下。 其中注意力权重占 16%。
权重、梯度、Adam16 字节 × 3 亿16 字节 × 3 亿4.8 GB51%
token 激活值16 × (B, L, d_model) × 24 层16 × (B, L, d_model) × 24 层3.1 GB33%
注意力权重(B, h, L, L) × 24 层(B, h, L, L) × 24 层1.5 GB16%

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,所以不保存任何 L×LL \times L 大小的东西。课程后面会搭出这个。 softmax 这一步仍然需要每一行的 dA⋅AdA \cdot A,而它只用 O 和 dO 就能得到: dA=dO V⊤dA = dO \, V^\top,所以 ∑jdAijAij=∑cdOic∑jAijVjc=∑cdOicOic\sum_j dA_{ij} A_{ij} = \sum_c dO_{ic} \sum_j A_{ij} V_{jc} = \sum_c dO_{ic} O_{ic}。 在第 2 节的例子里,第 0 行给出 dO⋅O=1×1.5+0×0.5=1.5dO \cdot O = 1 \times 1.5 + 0 \times 0.5 = 1.5,而 dA⋅A=2×0.5+1×0.5=1.5dA \cdot A = 2 \times 0.5 + 1 \times 0.5 = 1.5。

数字 第 2 节的例子:输出是 O = [[1.5, 0.5], [1.5, 0.5]],传到它们的梯度是 dO = [[1, 0], [0, 2]]。融合算子需要每一行的 dA·A,但不保存 A,所以它改用 dO·O。第 1 行的 dO·O 是多少?

小结

通关后的总结

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

你现在会了

  • 写出 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 字节。

按 ? 查看快捷键

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