框架里只需要一行 loss.backward(),所有参数的梯度就都算好了。这行代码背后到底做了什么,很多人在调模型时并不清楚。结果就是:梯度变成 NaN,不知道该查哪一层;某个层不更新,只能反复猜;自己写了一个自定义层,梯度怎么都不对。

反向传播不是一种新的学习算法,它只是求梯度的一种高效方式。给定一个由许多小运算组成的网络,它从输出开始,按链式法则把「损失对每一层的敏感度」一层层往回传。每一层只需要知道两件事:自己的局部导数,以及从后面传回来的梯度。两者相乘,就是这一层参数的梯度。

这篇用一个两层小网络把整条链路走一遍:两个输入、两个 ReLU 隐藏神经元、一个线性输出。先做前向,把中间值存下来;再反向,手写每个参数的梯度;然后用有限差分逐个校验;最后真的训练两百步,看损失降到零。数学上会用到的链式法则和矩阵求导,在数学方向有更细的推导,这里只讲它们在网络里怎么用。

前向:先把账记下来

网络结构是这样的:输入 x1、x2,第一层两个神经元,每个先算一个加权和 z,再过 ReLU 得到 h;第二层把两个 h 加权求和,加偏置,得到预测 yhat;损失用均方误差。

前向计算除了得到 yhat,还要把 z1、z2、h1、h2 存下来。为什么?因为反向时需要用到它们:ReLU 的局部导数取决于 z 是否大于零,输出层的梯度取决于 h 的值。不存这些中间结果,反向时就得重新算一遍,浪费计算。

这也是训练比推理更吃显存的原因。推理只需要保留当前层的输入输出,训练要把每一层的中间激活都留着,等反向用完才能释放。层数越多、batch 越大,这部分缓存越大。显存不够时,常见做法是减小 batch,或者用梯度检查点,牺牲计算换内存。

用计算图的视角看,前向是在搭一张有向图:每个节点是一个运算,每条边是数据流。反向就是沿着这张图倒着走,把每个节点的局部导数乘起来。框架的自动求导,本质上就是在记录这张图,并在 backward 时按拓扑逆序执行。

举个具体的数。取样本 (1, 0),初始参数下 z1 = 0.8,ReLU 后 h1 = 0.8;z2 = -0.7,ReLU 后 h2 = 0。输出 yhat = 0.9 * 0.8 + 1.1 * 0 + 0.2 = 0.92。反向时要知道 z1 是正的,所以 ReLU 的开关是开的;z2 是负的,开关是关的。这两个信息都来自前向缓存,重新算一遍也能得到,但没必要。

缓存也不是越多越好。如果一个操作在前向里只出现一次,它的输出本来就要传给下一层,顺手保留几乎不增加成本。真正占空间的是大矩阵的中间结果,比如卷积的输出、注意力的权重矩阵。训练大模型时,显存的主要开销往往就在这些缓存上,而不是参数本身。

反向:局部梯度逐层相乘

先从损失开始。均方误差对预测的导数是 2 * (yhat - y),对一批样本再取平均。这个值表示「预测每变化一点,损失变化多少」,记作 d。

输出层的参数是 v1、v2、bo。预测是 v1 * h1 + v2 * h2 + bo,所以 v1 的梯度是 d * h1,v2 的梯度是 d * h2,bo 的梯度是 d。这一步没有链式法则的花哨,就是线性层的局部导数。

接着把梯度传回隐藏层。损失对 h1 的敏感度是 d * v1,因为 h1 每增加一点,预测增加 v1,损失随之变化 d * v1。然后要穿过 ReLU:ReLU 在 z1 大于零时导数为 1,否则为 0。所以 z1 的梯度是「h1 的梯度乘以 ReLU 的开关」。

最后到第一层的权重。 z1 = w11 * x1 + w12 * x2 + b1,所以 w11 的梯度是 z1 的梯度乘以 x1,w12 是 z1 的梯度乘以 x2,b1 就是 z1 的梯度。第二层隐藏神经元同理。把每个样本的梯度累加,再除以样本数,就得到整批的平均梯度。

整个过程中,没有哪个参数需要单独做数值扰动。所有梯度都是通过「后面传回来的梯度乘以本地导数」得到的,一次反向就能算出全部参数。这就是反向传播比数值求导快得多的原因:数值求导要为每个参数跑一遍前向,参数上百万时根本不可行。

把上面的推导套到具体数字上,会更直观。以 (1, 0) 这条样本为例,假设输出误差项 d 是 -0.08。那么 v1 的梯度贡献是 -0.08 * 0.8 = -0.064,v2 的梯度贡献是 -0.08 * 0 = 0,因为 h2 是零,这条路径完全没有贡献。梯度传到 h1 是 -0.08 * 0.9 = -0.072,再穿过开着的 ReLU,到 z1 仍是 -0.072。最后到 w11 是 -0.072 * 1 = -0.072,到 w12 是 -0.072 * 0 = 0。

这组数字说明两件事。第一,梯度是逐路径乘出来的,某条路径上的某一环是零,后面的梯度就全为零。第二,ReLU 关闭的神经元不会收到任何梯度,这就是「死神经元」在反向层面的表现。排查时如果发现某个神经元的权重长期不变,先看它的 z 是不是一直为负。

手写一遍完整反向传播

下面这段代码把上面的推导全部写出来。数据是 XOR 的四个点,参数从一组接近答案但并不精确的值开始,这样梯度不为零,便于观察。

X = [(0, 0), (0, 1), (1, 0), (1, 1)]
Y = [0, 1, 1, 0]

def forward(params):
    w11, w12, b1, w21, w22, b2, v1, v2, bo = params
    outputs, cache = [], []
    for x1, x2 in X:
        z1 = w11 * x1 + w12 * x2 + b1
        h1 = max(0.0, z1)
        z2 = w21 * x1 + w22 * x2 + b2
        h2 = max(0.0, z2)
        yhat = v1 * h1 + v2 * h2 + bo
        outputs.append(yhat)
        cache.append((x1, x2, z1, z2, h1, h2))
    return outputs, cache

def loss(params):
    outputs, _ = forward(params)
    return sum((a - b) ** 2 for a, b in zip(outputs, Y)) / len(Y)

def gradients(params):
    w11, w12, b1, w21, w22, b2, v1, v2, bo = params
    outputs, cache = forward(params)
    g = [0.0] * 9
    for (x1, x2, z1, z2, h1, h2), yhat, y in zip(cache, outputs, Y):
        d = 2 * (yhat - y) / len(Y)          # 损失对预测的导数
        g[6] += d * h1                       # v1
        g[7] += d * h2                       # v2
        g[8] += d                            # bo
        dh1, dh2 = d * v1, d * v2            # 梯度传回隐藏层
        dz1 = dh1 * (1 if z1 > 0 else 0)     # 穿过 ReLU
        dz2 = dh2 * (1 if z2 > 0 else 0)
        g[0] += dz1 * x1                     # w11
        g[1] += dz1 * x2                     # w12
        g[2] += dz1                          # b1
        g[3] += dz2 * x1                     # w21
        g[4] += dz2 * x2                     # w22
        g[5] += dz2                          # b2
    return g

params = [0.8, -0.6, 0.1, -0.7, 0.9, -0.1, 0.9, 1.1, 0.2]
print("初始 loss:", round(loss(params), 4))
print("解析梯度:", [round(v, 4) for v in gradients(params)])

本机实际输出:

初始 loss: 0.1068
解析梯度: [0.2655, 0.261, 0.396, 0.319, 0.363, 0.363, 0.106, 0.061, 0.48]

九个参数,九个梯度,每个都对应一个具体的偏导。注意 b1 和 b2 的梯度都是 0.363,这不是巧合:在当前参数下,两个隐藏神经元的开关状态和误差贡献恰好对称。换成别的初始值,它们就会不同。

梯度校验:用数值方法验一遍

手写的梯度很容易出错,尤其是符号和下标。一个可靠的检查方法是有限差分:把某个参数增大一个极小的量,再减小同一个量,用两次损失的差除以两倍的步长,近似这个参数的偏导。它慢,但足够准,适合在小模型上做一次全面校验。

eps = 1e-5
numeric = []
for i in range(len(params)):
    plus, minus = params[:], params[:]
    plus[i] += eps
    minus[i] -= eps
    numeric.append((loss(plus) - loss(minus)) / (2 * eps))

print("数值梯度:", [round(v, 4) for v in numeric])
print("最大偏差:", round(max(abs(a - b) for a, b in
      zip(gradients(params), numeric)), 6))

本机实际输出:

数值梯度: [0.2655, 0.261, 0.396, 0.319, 0.363, 0.363, 0.106, 0.061, 0.48]
最大偏差: 0.0

最大偏差为零,说明手写梯度和数值近似完全一致。真实项目里,偏差不一定正好为零,通常在万分之一到千分之一之间。如果某个参数的偏差明显大于其他参数,先检查那个参数的链式推导,而不是怀疑整个实现。

校验时要注意两点。第一,关掉 dropout 和随机增强,否则两次前向的结果不同,差分会被噪声淹没。第二,参数不要落在 ReLU 的折点上,z 正好为零时导数不唯一,数值差分会给出一个模棱两可的结果。把参数稍微挪开再测,是常见的处理方式。

有限差分本身也有误差。步长太大,一阶近似不准;步长太小,浮点数的舍入误差会放大。常用的步长在 1e-5 到 1e-7 之间,双精度下比较稳。如果模型用半精度训练,数值校验的结果会更粗糙,最好切回双精度做一次专门的检查,而不是在半精度下纠结小数点后的差异。

训练两百步,看它真的在学

梯度对了,剩下的就是沿负梯度方向更新。学习率取 0.5,跑两百步:

lr = 0.5
for step in range(200):
    g = gradients(params)
    params = [p - lr * v for p, v in zip(params, g)]

print("训练后 loss:", round(loss(params), 6))
outputs, _ = forward(params)
print("训练后预测:", [round(v, 3) for v in outputs])

本机实际输出:

训练后 loss: 0.0
训练后预测: [0.0, 1.0, 1.0, 0.0]

损失降到零,四个预测完全正确。这个网络只有九个参数,数据只有四个点,能拟合到零并不奇怪。真正值得注意的是,整个过程没有用到任何框架,也没有做数值求导,所有梯度都来自一次反向传播。这就是 backward() 背后的全部逻辑。

如果把学习率改成 5,训练会不稳定,损失可能来回跳甚至变大;改成 0.001,两百步后损失还降不到零。梯度本身没错,错的是步长。这也说明反向传播只负责「方向」,走多远由优化器决定。

真实训练里,一次反向通常对应一个 batch,而不是一条样本。代码里的循环是「每条样本累加梯度,最后除以样本数」,这就是 batch 平均梯度的做法。batch 越大,梯度估计越稳,但内存占用越高;batch 越小,梯度噪声越大,反而可能帮助模型跳出不好的区域。批量大小的选择和反向传播本身无关,但会直接影响训练曲线的形状。

几个常见误解

第一个误解是「反向传播让模型学习」。严格说,反向传播只计算梯度,不更新参数。更新是优化器做的事,比如 SGD、动量、Adam。把这两件事分开,排查问题时就不会混:梯度为零时,换优化器没用;梯度正常但损失震荡,才该看学习率。

第二个误解是「梯度必须从最后一层开始算」。反向传播确实是倒序执行的,但顺序是由计算图决定的,不是由层号决定的。一个有分支的网络,梯度会在分支处分别累加,再一起往回传。手写时按变量依赖顺序写,比按层号写更可靠。

第三个误解是「梯度越大越好」。梯度过大意味着更新步子可能过大,损失反而上升;梯度过小意味着学习停滞。健康的状态是梯度在一个合理范围内,随训练逐渐变小,而不是突然爆炸或归零。

第四个误解是「反向传播需要可导的激活」。ReLU 在零点不可导,但实际实现里用一个次梯度代替,训练仍然能工作。严格数学意义上的不可导,不妨碍工程上的可用。这也是为什么框架里 ReLU 的反向实现是「大于零传梯度,否则传零」,而不是抛错。

框架的自动求导还分两种模式。前向模式从输入出发,同时算函数值和导数,适合输入少、输出多的场景;反向模式从输出出发,适合输出少、输入多的场景。神经网络正好是「一个损失,几百万个参数」,所以反向模式是默认选择。这也是为什么必须先把损失算成一个标量,再调用 backward:如果损失是一个向量,反向传播就不知道该从哪个分量开始累加。

梯度不对,按这张表查

反向传播的问题通常表现为「参数不更新」或「更新方向不对」。下面按现象倒查:

现象真实原因第一步查什么
所有梯度都是零激活进入饱和区,或损失对输出没有梯度打印每层梯度范数,找出从哪一层开始变成零
只有最后一层有梯度前面的激活不可导,或链式乘法断掉逐层检查局部导数是否被正确乘进去
梯度方向与数值校验相反链式法则里漏了负号,或转置用错用有限差分对照单个参数,确认符号
梯度数值巨大学习率过大,或深层连乘放大看梯度范数随层数的变化,考虑梯度裁剪
训练 loss 变 NaN梯度爆炸,权重更新到无穷降低学习率,检查是否有除零或 log(0)
校验偏差只在某个参数上很大该参数的链式推导写错单独打印该参数的局部导数,逐步对照公式
训练和推理结果不一致dropout 或归一化在推理时没有切换模式确认模型处于训练还是评估状态

边界与代价

反向传播要求每个运算都可导,或者至少能定义一个可用的次梯度。遇到不可导的操作,比如取整、排序、采样,梯度要么断掉,要么需要额外的估计方法。这不是实现细节,而是模型设计时要考虑的限制。

内存是另一条硬边界。训练要保存每一层的中间激活,层数和 batch 越大,占用越高。显存不足时,可以减小 batch、用梯度累积、或者用检查点重算。后者的思路是只保存少数关键层的激活,反向时把中间结果重新算出来,用计算换内存。

检查点不是无代价的。它把一次前向变成接近两次前向的计算量,训练速度会下降。选哪些层做检查点,要在内存和速度之间权衡。另一个办法是混合精度训练,用半精度存激活、用单精度做累积,既省内存又提速,但对数值稳定性有要求,不是所有模型都能直接套用。

深网络还会遇到梯度消失和爆炸。每一层的局部导数乘在一起,如果都小于一,梯度会指数衰减;都大于一,会指数增长。sigmoid 和 tanh 在大输入时导数接近零,是梯度消失的常见来源;权重初始化过大或学习率过高,则容易造成爆炸。残差连接、合适的初始化、归一化和梯度裁剪,都是针对这些问题的工程手段。

梯度裁剪是最简单的一种保护措施:先算整个梯度的范数,如果超过一个阈值,就按比例把梯度缩小,再交给优化器。它不改变梯度的方向,只限制长度,能防止一次异常的大梯度把参数推到很远。阈值设得太小会让训练变慢,设得太大等于没设,通常先在常见量级上试一个值,再看损失曲线是否还会突然爆炸。

最后,反向传播本身不保证找到好解。它只保证在当前点给出正确的下降方向。损失曲面有平坦区、鞍点、尖锐低谷,梯度下降可能停住或震荡。优化器的作用就是在这种情况下调整步长和方向,下一篇会具体讲。

当天能自验的五个练习

  1. 把隐藏层的 ReLU 改成 Sigmoid,重写反向传播里的局部导数,重跑梯度校验,确认偏差仍然接近零。
  2. 把损失从均方误差改成平均绝对误差,推导对应的输出层梯度,重跑训练,观察收敛过程的变化。
  3. 把学习率改成 5 和 0.001,各跑两百步,记录最终损失,解释两种失败方式的区别。
  4. 在梯度校验里把 eps 改成 1e-2 和 1e-8,观察最大偏差怎么变。理解步长太大和太小分别带来什么误差。
  5. 给网络加第三个隐藏神经元,手写它的前向和反向,跑一次校验,确认九个梯度变成十二个后仍然对得上。

小结

反向传播从输出开始,按链式法则逐层回传梯度。每一层只需要把「后面传回来的梯度」和「自己的局部导数」相乘,就能得到参数的梯度。前向要缓存中间激活,反向要用到它们;梯度可以用有限差分校验;更新方向由梯度决定,步长由优化器决定。

还有一个常见误解是把反向传播和梯度下降当成同一件事。前者只负责算梯度,后者负责拿梯度去更新参数,两者可以分开替换:换损失函数、换层结构会改前者,换学习率策略、换优化器只改后者。分清这一点,读框架源码时就不会把两类代码混在一起。

到这里,模型能算出往哪走,但还没决定走多远、要不要利用历史方向。下一篇讲优化器:SGD、动量、Adam 分别改了什么,为什么同样的梯度在不同优化器下会走出完全不同的路径。