框架里只需要一行 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 在大输入时导数接近零,是梯度消失的常见来源;权重初始化过大或学习率过高,则容易造成爆炸。残差连接、合适的初始化、归一化和梯度裁剪,都是针对这些问题的工程手段。
梯度裁剪是最简单的一种保护措施:先算整个梯度的范数,如果超过一个阈值,就按比例把梯度缩小,再交给优化器。它不改变梯度的方向,只限制长度,能防止一次异常的大梯度把参数推到很远。阈值设得太小会让训练变慢,设得太大等于没设,通常先在常见量级上试一个值,再看损失曲线是否还会突然爆炸。
最后,反向传播本身不保证找到好解。它只保证在当前点给出正确的下降方向。损失曲面有平坦区、鞍点、尖锐低谷,梯度下降可能停住或震荡。优化器的作用就是在这种情况下调整步长和方向,下一篇会具体讲。
当天能自验的五个练习
- 把隐藏层的 ReLU 改成 Sigmoid,重写反向传播里的局部导数,重跑梯度校验,确认偏差仍然接近零。
- 把损失从均方误差改成平均绝对误差,推导对应的输出层梯度,重跑训练,观察收敛过程的变化。
- 把学习率改成 5 和 0.001,各跑两百步,记录最终损失,解释两种失败方式的区别。
- 在梯度校验里把
eps改成 1e-2 和 1e-8,观察最大偏差怎么变。理解步长太大和太小分别带来什么误差。 - 给网络加第三个隐藏神经元,手写它的前向和反向,跑一次校验,确认九个梯度变成十二个后仍然对得上。
小结
反向传播从输出开始,按链式法则逐层回传梯度。每一层只需要把「后面传回来的梯度」和「自己的局部导数」相乘,就能得到参数的梯度。前向要缓存中间激活,反向要用到它们;梯度可以用有限差分校验;更新方向由梯度决定,步长由优化器决定。
还有一个常见误解是把反向传播和梯度下降当成同一件事。前者只负责算梯度,后者负责拿梯度去更新参数,两者可以分开替换:换损失函数、换层结构会改前者,换学习率策略、换优化器只改后者。分清这一点,读框架源码时就不会把两类代码混在一起。
到这里,模型能算出往哪走,但还没决定走多远、要不要利用历史方向。下一篇讲优化器:SGD、动量、Adam 分别改了什么,为什么同样的梯度在不同优化器下会走出完全不同的路径。