第 6 章 · 学习是怎么发生的

反向传播

第 5 章我们知道了“朝梯度反方向走”就能降低损失。可网络动辄成千上万个参数, 这么多梯度怎么算?反向传播(backpropagation)就是那个高效算法。 它常被传得很神秘,但其实只是一个东西:链式法则,加一点耐心。

1. 链式法则:一段段地追责任

先看最简单的情形:一个参数 w,它影响 z,z 影响激活值 a, a 最终影响损失 L。这是一条“影响链”:

要知道“w 动一点,L 会变多少”,链式法则说:把这条链上每一段的局部导数乘起来:

偏置 b 更省事。一个神经元里 z = Σ w·a + b, 对 b 求导时那些带 w 的项都是常数、导数为 0,只剩 b 自己,系数是 1——也就是 ∂z/∂b = 1。 于是同一条链走到最后一段换成 1,偏置的梯度就直接等于 ∂L/∂z(也就是下一节要反复出现的 δ),连输入都不用再乘:

2. 反向传播的三步

把上面的思路推广到整张多层网络,就是干净利落的三步。我们引入一个中间量 δ(delta),表示“某个神经元对最终损失的责任”。

第一步:从输出层的误差开始

反向传播的起点是最后一层。它的 δ 由“损失对输出的导数”乘上“激活函数的导数”得到:

还记得第 4 章那个美妙巧合吗?如果用 softmax + 交叉熵,这一步直接简化成 δ = p − t。

第二步:把误差一层层往回传

有了后一层的 δ,前一层的 δ 就能算出来:把后一层的责任,按连接它们的权重“分摊”回来,再乘上本层激活的导数:

第三步:用 δ 算出每个参数的梯度

一旦每个神经元都有了自己的 δ,梯度就唾手可得——权重的梯度,是“它两端的 δ 和输入”的乘积;偏置的梯度,就是 δ 本身(还记得吗?偏置那段局部导数是 1):

3. 跟着速查图,按真实计算顺序推一遍

链式法则(第 1 节)和三步框架(第 2 节)都到手了,现在拿它们去啃一张真实的速查图:把抽象公式落到具体下标上。 这张图乍看是一堵“公式墙”,分成 struct / base / neuron / formula / example 五块。 但这五块只是速查时的分区,不是计算顺序——base 把零件摊在那儿,formula 写通用模板,example 才代入具体下标。 真要看懂,得按一次训练真正发生的顺序走:前向逐个神经元算 → 到输出算损失 → 从末层往回推每个梯度 → 最后才更新参数。 下面就按这个顺序,用刚学的链式法则,把图里的公式一条条现场推出来——每冒出一条,都先说清“这一步为什么需要它”。

别按区块顺序读;跟着下面第 1~5 步走,在图上找到对应位置即可。

读图约定:先认下标(struct 区)

图左上 struct 是一张缩小版 MLP,和仓库里 MNIST 的 784→128→64→10 同类,只是画小了方便手算:

• 第 0 层(输入):2 个输入,值记作 out₀₀、out₀₁。
• 第 1、2 层(隐藏):各 2 个神经元 b₁₀/b₁₁、b₂₀/b₂₁。
• 第 3 层(输出):1 个神经元 b₃₀,输出 out₃₀,拿去和 target 比。

权重 w 的三位下标 = 连到第几层 / 本层第几个神经元 / 上一层第几个输入。 例:w₁₀₀ 是“输入 0 → 第 1 层 0 号”那根线;w₂₁₀ 是“第 1 层 0 号 → 第 2 层 1 号”。 out₂₀ 则是第 2 层 0 号神经元的输出。认准这套记法,后面每条公式都能在图上指出来。

第 1 步 · 前向:一个神经元怎么算(neuron 区 + base 前两行)

前向时数据从左往右流。以第 1 层 0 号神经元为例,它只干两件事——先把连进来的输入加权求和,再过一次激活函数:

每个神经元都这么算:第 1 层算完喂给第 2 层,第 2 层喂给第 3 层,一路到 out₃₀。 一个要记住的细节:算 net 时顺手把它存下来(代码里的 neuron_preact_,见第 3 章),第 3、4 步反向求导还要回头用它。

第 2 步 · 前向到头,量一下错得多离谱(base 的 E_total)

数据流到输出层,out₃₀ 就是这次的预测。拿它和 target 比,用均方误差(MSE)压成一个数:

这个标量就是“错得多离谱”。想让它变小,就得知道每个权重该往哪调、调多少——也就是对每个 w 求 ∂E∂w。正是这一问,才逼出下面的反向传播。

(图 base 区还列了 Softmax:本图单输出配 MSE,用不到它;多分类如 MNIST 10 类才用 softmax 把多个 net 变成概率分布,见第 23 章。)

第 3 步 · 反向第一站:输出层的 w₃₀₀ 和 b₃₀(base 的 ∂E/∂out、S′ → example A)

损失有了,现在要梯度。先挑最靠近损失的一根权重 w₃₀₀——它只经一条路影响损失:w300 → net30 → out30 → E。链式法则把这条路上三段局部导数连乘:

三段挨个算,零件全在 base 区现成:

1. ∂E/∂out₃₀ = −(target − out₃₀) —— 对第 2 步的 MSE 求导,得 base 里的 −1n(target−out),n=1 就是它。预测比目标大时为正,提示“该往下调”。
2. ∂out₃₀/∂net₃₀ = out₃₀(1 − out₃₀) —— 因为 out₃₀=sigmoid(net₃₀),直接套 base 里的 S′(x)=S(x)(1−S(x))。
3. ∂net₃₀/∂w₃₀₀ = out₂₀ —— 因为 net₃₀ = out₂₀·w₃₀₀ + out₂₁·w₃₀₁ + b₃₀,对 w₃₀₀ 求导只剩它的系数 out₂₀。

把前两段(只跟这个神经元自己有关、后面反复要用)打包起个名字叫 δ₃₀,连乘就收成一行:

那 b₃₀ 的梯度怎么来的? 一模一样的链子,只是最后一段换成偏置: b30 → net30 → out30 → E。前两段和 w₃₀₀ 共用,正是 δ₃₀; 最后一段回到第 1 步那个式子 net₃₀ = … + b₃₀,对 b₃₀ 求导 = 1。所以 ∂E/∂b₃₀ = δ₃₀ · 1 = δ₃₀——偏置梯度就等于它自己神经元的 δ,连 out 都不用乘。

图 formula 区那句 δ_last = ∂E/∂out_last · ∂out_last/∂net_last,不过是给“前两段乘积”起的通用名而已。

第 4 步 · 反向往里走:隐藏层的 w₁₀₀ 和 b₁₀(formula 的 δ 递推 → example B)

再挑一根深处的 w₁₀₀。它离损失远,而且 out₁₀ 同时连去第 2 层两个神经元(b₂₀、b₂₁), 所以它对损失的影响要把两条路加起来。整条链照样连乘:

难点只在第一段 ∂E/∂out₁₀:out₁₀ 要经 b₂₀、b₂₁ 才影响到 E,于是把这两条路求和:

另外两段照旧:∂out₁₀/∂net₁₀ = out₁₀(1−out₁₀),∂net₁₀/∂w₁₀₀ = out₀₀。三段合起来,同样打包出 δ₁₀:

b₁₀ 的梯度也一并说清(这根最容易被跳过):偏置走的链子是 b10 → net10 → out10 → …… → E, 和 w₁₀₀ 共用后面全部路段,唯一不同还是最后一段——回到第 1 步 net₁₀ = out₀₀·w₁₀₀ + out₀₁·w₁₀₁ + b₁₀, 对 b₁₀ 求导,带 w 的项全变 0,只剩系数 1,即 ∂net₁₀/∂b₁₀ = 1。 于是 ∂E/∂b₁₀ = δ₁₀ · 1 = δ₁₀。 规律一句话:任何一根偏置的梯度,都等于它所在神经元的 δ;权重才要再乘一个“上一层输入”。

第 5 步 · 梯度全到手,最后才更新(base 的 w⁺)

把每一层都这么从后往前扫一遍,网络里每个 w、每个 b 都拿到了自己的梯度。到这一步,也只有到这一步,才轮到更新参数:

注意 w⁺ 虽然写在 base 区里,却是整个流程最后才发生的一步。“反传求梯度”和“更新参数”是两码事——具体怎么挪,见第 5 章的梯度下降和第 8 章的各种优化器。

退一步:w 其实是矩阵,一层前向就是一次矩阵乘法

第 1 步我们盯着一个神经元算 net₁₀ = out₀₀·w₁₀₀ + out₀₁·w₁₀₁ + b₁₀。 现在退一步,把同一层的所有神经元一起看——你会发现刚才那一堆加权求和,其实是一次矩阵乘法, 而 w 根本不是零散的一根根线,而是一整块矩阵。

还是用速查图那个小网络。第 1 层有两个神经元(b₁₀、b₁₁), 上一层是两个输入(out₀₀、out₀₁)。第 1 步我们只写了 0 号神经元的 net₁₀, 现在把 1 号神经元 net₁₁ = out₀₀·w₁₁₀ + out₀₁·w₁₁₁ + b₁₁ 也并排写下来:

把这两行“打包”:所有 w 排成一块 2×2 的矩阵 W₁(第 o 行 = 第 o 号神经元的两根权重), 输入排成竖着的一列 [2×1],偏置也是一列。于是两行加权求和收成一个矩阵 × 向量:

验证一下矩阵第 1 行:[w₁₀₀ w₁₀₁] · [out₀₀; out₀₁] = w₁₀₀·out₀₀ + w₁₀₁·out₀₁,再加 b₁₀—— 正是上面 net₁₀ 那一行。矩阵乘法没算任何新东西,只是把“逐个神经元的加权求和”一次性摆平。 所以那块 W₁ 就是仓库代码里的 neuron_weight_[1],neuron_weight_[1][o][i] 就是它第 o 行第 i 列。写成通用形式:

光看一层还不够。把这个小网络从输入一路乘到输出走一遍,你就能看清数据的“维度”是怎么被每层矩阵一步步改写的。 它的结构是 2 → 2 → 2 → 1:2 个输入,两个隐藏层各 2 个神经元,最后 1 个输出。每层都是“矩阵 × 上一层的列向量 + 偏置,再过激活”,前一层的输出正好插进后一层做输入:

把这四步接起来看,维度是一条被矩阵改写的流水线: [2×1] ──W₁──▸ [2×1] ──W₂──▸ [2×1] ──W₃──▸ [1×1]。 每层 W 的行数 = 本层要输出几维、列数 = 上一层进来几维; 相邻两层“列对行”严丝合缝(前一层输出 2 维,后一层 W 就得有 2 列),这正是第 1 章 4.3 的形状规则“中间对齐、两头留下”在整张网络上的连锁体现。

小网络里每个 W 只是 2×2 或 1×2,换成仓库那个 MNIST 网络 784→128→64→10,公式一字不改,只是每层的行列数换成真实维度——同一条“维度流水线”变长、变宽而已:

再把一整批样本(第 5 章的 minibatch)按行堆成一个矩阵 X [B×784], 那连“逐个样本”的循环都省了,一层前向直接是矩阵 × 矩阵:

4. 边看动画边回放一遍

公式一条条推完了,难免还是有点“只见树木”。再回过头看它整体动起来:还是那个动画(和第 3 章前向同一个),这次请点 “切到反向传播”,再一步步点 “下一步”。 刚才第 3 节逐个下标推的 δ,在这里就是那束从输出层反着流回输入层的暖色信号——它传的不是数据,而是“误差/责任”。 你还可以 hover 公式里的彩色项,看它对应网络里的哪个节点或哪条边,把“推导”和“流动”对上号。

5. 逐行读懂反向传播

真实代码就是上面三步的忠实翻译。第一步:末层的 δ。

if (use_softmax) {
  delta = softmax_function_->CalcDelta(output, target, loss_function_);  1
} else {
  double dL = loss_function_->DerivLoss(target, output) / out_dim;       2
  delta = dL * activate_function_->DerivActivate(preact, output);        3
}
neuron_delta_[last][b][o] = delta;                                       4

第二步:把 δ 一层层往回传。

for (int l = last - 1; l >= 1; l--) {            1
  for (int o = 0; o < layer_[l]; o++) {
    double sum = 0.0;
    for (int k = 0; k < layer_[l + 1]; k++)
      sum += neuron_weight_[l + 1][k][o]
             * neuron_delta_[l + 1][b][k];        2
    neuron_delta_[l][b][o] =
        sum * activate_function_->DerivActivate(
                  neuron_preact_[l][b][o],
                  neuron_output_[l][b][o]);        3
  }
}

第三步:用 δ 把梯度累加出来。

for (int l = 1; l < L; l++) {
  const auto &in_vec = neuron_output_[l - 1][b];
  for (int o = 0; o < layer_[l]; o++) {
    double d = neuron_delta_[l][b][o];
    grad_bias_[l][o] += d;                        1
    for (int i = 0; i < layer_[l - 1]; i++)
      grad_weight_[l][o][i] += d * in_vec[i];     2
  }
}

6. 从一个数到一整块:矩阵是怎么求导的

到这里你可能有个很实在的困惑:上面推的 δ·a 全是一个数对一个数求导(和 MNIST 里那个 double 一样)。 可到了第 18 章的 Transformer,一层就是 Y = X·W——X 是矩阵、W 是矩阵、输出还是矩阵。 那“矩阵对矩阵求导”是个什么怪物?导数难道是个四维的东西?这一节把它讲穿。(其中“梯度和参数同形状、Xᵀ·G 怎么来的”这套数学基础,第 1 章 §7 已经先垫过,这里落到反向传播上。)

从单个权重推起:还是那条链式法则

拿一层 Y = X·W。先只盯一个权重 W_kj(纯 MNIST 式,一个 double)。前向时,输出矩阵的某个元素是一次点积:

现在问:W_kj 这一个数动一点,loss 变多少?套链式法则(和 MNIST 一字不差), 只是要把它影响到的所有输出位置 Y_ij 的责任都加起来:

关键在最右边那个 Σ_i X_ik·G_ij——它正好就是矩阵乘法 Xᵀ·G 的第 [k][j] 个元素! 于是把所有 k、j 一起写,一整块 W 的梯度就是:

落到那个小网络:反向每一步的矩阵长什么样

抽象的 Xᵀ·G 你可能还是没画面。我们把它落到第 3 节那个小网络——同样是 2→2→2→1、同样的下标。前向时我们已看到每层是 net_l = W_l·out_l−1;现在反向,把每一步的矩阵形状摆出来看(单个样本,所以“批”那一维是 1)。

先看输出层 W₃(形状 [1×2])。 末层只有 1 个神经元,它的责任就是一个数 δ₃₀(第 3 步已算过);上一层输出 out₂ = [out₂₀, out₂₁]。梯度 = δ 这一列 × 输入那一行(外积),形状自然凑成和 W₃ 一样的 [1×2]:

往前一层要先拿到第 2 层的责任 δ₂ = [δ₂₀, δ₂₁]。它由“把末层责任经 W₃ 分回来、再乘本层激活导数”得到——这正是三步框架第二步的 δ_l = (W_l+1^T·δ_l+1) ⊙ f′,把形状摆出来:

再看第 1 层 W₁(形状 [2×2]),它离损失最远,但公式一模一样:本层责任 δ₁ = [δ₁₀, δ₁₁](竖列),输入 out₀ = [out₀₀, out₀₁](横行),外积出 [2×2]:

对上号了吗?你在第 3 节逐个下标手推的每个 ∂E/∂w,就是这些矩阵里的一个格子。 把这一层所有格子一起写,就是一次“δ 列 × 输入行”的外积;而当有一整批 B 个样本时,这个外积对每个样本累加,正好合并成 Xᵀ·G 那一次矩阵乘——所以下面的通用公式,和你手推的小网络是同一件事,只是把批和维度铺开了。

线性层的“反向三件套”与形状对齐

于是 Y = X·W 这一层,反向时收到上游 G = ∂L/∂Y,本地只需算两样(偏置略):

怎么记住谁转置、谁乘谁?一个特别好用的窍门:梯度必须和它对应的东西同形状,反过来用形状凑就行。 设 X 是 [n×d]、W 是 [d×d],那 G 和 Y 同形状也是 [n×d]:

整个几十层的大模型,反向传播就是把这套“收到上游 G → 本地算 Xᵀ·G 和 G·Wᵀ → 把 G·Wᵀ 往前传”在每一层接力一遍。 从 loss 出发倒着扫一遍,所有层、所有参数的梯度就都齐了——代价大约只等于 2 次前向传播(注意这是相对前向的倍数:模型越大、序列越长,前向和反向的绝对计算量都会跟着涨,但反向始终只是前向的常数倍,不会额外多出一层指数级膨胀)。 真实框架里这套“记住前向每一步、反向自动套用局部公式”的机制叫 自动微分(autograd),所以工程师只写前向,从不手推几十亿参数的梯度。 (第 20 章那个 FLOPs ≈ 6 × 参数 × token 的“6”,拆开就是前向 2 + 反向 4——反向按算力算比前向再贵一点,但仍是常数倍,不随参数量膨胀。)

动手与思考

反向传播搞定,“学习”的完整闭环就通了。但同一条链路里,用哪种激活函数会直接影响梯度好不好传。 下一章我们就把 Sigmoid、ReLU、GELU 这些激活函数摆到一起,看它们的曲线、导数和各自的脾气。