手写反向传播的人,大多遇到过一个说不清的倍数问题。同一组初始化、同一个学习率、同一份数据,框架跑出来的 loss 从 2.31 降到 0.08,自己写的版本降到 0.51 就卡住了。把两边每个参数的梯度打印出来,输出层偏置一模一样,隐藏层到输出层的权重恰好差 2 倍,第一层权重的梯度只有对方的四分之一。
最初怀疑初始化、数据顺序,甚至怀疑框架偷偷做了梯度裁剪。逐层对下来,问题出在两处。一处是 loss 写成 (y − t)2,反向却按 0.5(y − t)2 推的,所有梯度整体差 2 倍;另一处对隐藏层求导时只乘了输出层权重,没乘 tanh 的局部导数 1 − h2,隐藏层的梯度被压到接近 0,那几层几乎学不动。
这两处不是框架玄学,都落在同一条规则上:复合函数的导数要把各层的局部倍率乘起来。这篇就从齿轮组开始,把链式法则讲清楚,再用一个纯 Python 的两层网络做数值核对,最后说明反向传播为什么一次就能拿到所有参数的梯度。
复合就是套娃:动一点,先放大一次,再放大一次
复合函数(composition)就是把一个函数的输出直接喂给另一个函数。写成 y = f(g(x)),内层是 u = g(x),外层是 y = f(u)。x 是真正的输入,u 只是中间产物,y 是最终输出。套娃可以只有两层,也可以有几十层,神经网络就是后者。
考虑 x 动一点点,记作 Δx。这个变化先经过内层,被放大 g'(x) 倍,变成 Δu;Δu 再经过外层,被放大 f'(u) 倍,变成 Δy。总放大倍率不是 g'(x) + f'(u),而是两者的乘积。这就像两级齿轮:第一级传动比是 3,第二级是 2,输入转 1 圈,中间轴转 3 圈,输出轴转 6 圈。每一级只负责自己的倍率,总倍率是 3 × 2 = 6。齿轮不会把两个传动比加起来。
拿一个具体函数试一下:y = (2x + 1)3。内层 u = 2x + 1 的导数是 2,外层 u3 的导数是 3u2,乘起来就是 6(2x + 1)2。把 (2x + 1)3 展开成 8x3 + 12x2 + 6x + 1 再逐项求导,得到 24x2 + 24x + 6,提取公因式正好是 6(2x + 1)2。两条路必须一致,这不是巧合,是链式法则在多项式上的具体表现。
外层不知道 u 是怎么来的,内层也不知道 y 要拿 u 做什么。每一层只看见自己入口的变量,所以只提供自己的局部导数,链式法则就是把这份局部信息逐级拼接起来。
差商推导:为什么可以相乘
把刚才的直觉写成式子。设 u = g(x),y = f(u)。x 从 x 变到 x + Δx,u 相应变化 Δu = g(x + Δx) − g(x),y 变化 Δy = f(u + Δu) − f(u)。只要 Δu 不为 0,就可以把差商拆开:
Δy Δy Δu
---- = ---- · ----
Δx Δu Δx
这一步不是新的数学,只是分数的乘法。让 Δx 趋于 0,如果内层在 x 处连续,Δu 也跟着趋于 0;两个差商分别趋于 f'(u) 和 g'(x),乘积就趋于 f'(g(x)) · g'(x)。这就是链式法则(chain rule)最直接的来源。
但「只要 Δu 不为 0」这句话留了一个洞。如果对某些任意接近 0 的 Δx,Δu 恰好等于 0,上面的除法就没有定义。内层在某一段是常数时,这种情况会成片出现。严格证明不能靠「把 Δu 约掉」,而要用可微的定义:Δy = f'(u)Δu + r(Δu),其中余项满足 r(Δu)/Δu 趋于 0;再把 Δu = g'(x)Δx + o(Δx) 代进去,展开后的主项就是 f'(u)g'(x)Δx,剩下的项比 Δx 高阶。这样即使 Δu 偶尔为 0,结论仍然成立。
标准写法有两种,意思完全一样:
(f ∘ g)'(x) = f'(g(x)) · g'(x)
dy dy du
---- = ---- · ----
dx du dx
第二种是莱布尼茨的记号,看起来像分数,记起来也方便,但 dy/du 和 du/dx 是导数记号,不是可以随便约分的分式。把 du 当成一个能消掉的量,是初学者最常见的误解。
成立条件也要说清楚:外层在 g(x) 处可导,内层在 x 处可导。少一个条件,公式就可能没有意义。比如 f(u) = |u|,g(x) = x2,在 x = 0 处 g(0) = 0,而 |u| 在 0 不可导;复合函数 |x2| = x2 却处处可导。这说明「内层可导」还不够,外层的可导点必须对上内层的输出值。反过来,公式失效也不代表复合函数一定不可导,只是不能直接用这条乘法公式,得回到定义或者换一条路。
三个最常遇到的复合函数
工程里出现频率最高的三个复合函数,值得把每一步都写一遍。写的时候不要背结论,注意局部倍率是从哪来的,以及最后为什么能化简成只依赖前向输出的形式。
sigmoid。定义是 σ(z) = 1 / (1 + e−z)。把它看成 u = 1 + e−z 的倒数,先用幂函数求导,再用指数求导:
u = 1 + e^(-z)
σ(z) = u^(-1)
du/dz = -e^(-z)
σ'(z) = -u^(-2) · (-e^(-z))
= e^(-z) / (1 + e^(-z))^2
σ(z)(1 - σ(z))
= [1/(1+e^(-z))] · [e^(-z)/(1+e^(-z))]
= e^(-z) / (1 + e^(-z))^2
两个结果完全相同,所以 σ'(z) = σ(z)(1 − σ(z))。这个形式的好处是反向时不需要再算一次指数,前向已经存了 σ(z),直接拿来用。
tanh。定义是 tanh(z) = (ez − e−z) / (ez + e−z)。直接用商法则,注意分子求导后会出现交叉项:
tanh'(z)
= [(e^z + e^(-z))^2 - (e^z - e^(-z))^2] / (e^z + e^(-z))^2
= 4 / (e^z + e^(-z))^2
1 - tanh^2(z)
= [(e^z + e^(-z))^2 - (e^z - e^(-z))^2] / (e^z + e^(-z))^2
= 4 / (e^z + e^(-z))^2
分子展开后交叉项全部抵消,只剩 4,正好等于 1 − tanh2。所以 tanh'(z) = 1 − tanh2(z),同样只依赖前向输出。tanh 的导数最大是 1,比 sigmoid 好一点,但在两端饱和时仍然会趋近 0。
softplus 的负号版本。定义是 f(z) = log(1 + e−z),二分类的 log-loss 里常见。令 u = 1 + e−z,先对外层 log 求导,再对内层求导:
f(z) = log(1 + e^(-z))
u = 1 + e^(-z)
f'(z) = (1/u) · (-e^(-z))
= -e^(-z) / (1 + e^(-z))
= -1 / (1 + e^z)
最后一步是分子分母同乘 ez。注意符号:如果写成 log(1 + ez),导数是 σ(z),是正的;这里多了一个负号,导数是负的。两种写法只差 z 的符号,混用会让梯度方向整体反掉,而且 loss 看起来还在下降,很难查。
用 Python 在 z = 0.5 处把三个结果算出来:
import math
z = 0.5
s = 1 / (1 + math.exp(-z))
print(s * (1 - s))
print(1 - math.tanh(z) ** 2)
print(-1 / (1 + math.exp(z)))
输出是:
0.2350037122015945
0.7864477329659274
-0.3775406687981454
三个值分别对应 sigmoid、tanh、softplus 在 0.5 处的导数。可以用中心差分再核一遍,结果会在这个精度上一致;如果差得明显,多半是把某一步的符号或者内层倍率漏了。
多层嵌套:梯度是连乘
神经网络把套娃重复很多次。前向可以写成 a0 = x,ai = fi(ai−1),最后 y = aL。对 x 求导,就是把每一层的局部导数按顺序乘起来:
dy/dx = f_L'(a_(L-1)) · f_(L-1)'(a_(L-2)) · ... · f_1'(a_0)
这个式子说明,深度带来的不是加法,而是指数级的乘法。如果每一层的局部倍率都接近 0.9,梯度会随着层数增加迅速变小;如果都接近 1.1,又会迅速变大。用 Python 把几个幂算出来:
for n in (20, 50, 100):
print(n, 0.9 ** n, 1.1 ** n)
真实输出是:
20 0.12157665459056935 6.727499949325611
50 0.00515377520732012 117.39085287969579
100 2.6561398887587544e-05 13780.61233982238
读法很直接。每层乘 0.9,20 层后梯度只剩原来的 12.16%;50 层后只剩 0.5%。每层乘 1.1,50 层后放大到 117 倍;100 层后是 13,780 倍。反向传播时,靠近输入的那几层拿到的梯度就是这些倍数。梯度消失和梯度爆炸不是两种神秘故障,而是同一个连乘在小于 1 和大于 1 两个方向上的结果。
实际每一层的倍率不是单纯的激活导数,而是权重和激活导数的乘积,比如 w · σ'(z)。sigmoid 的导数最大只有 0.25,权重初始化偏小,乘几次就掉到 10−3 以下;权重偏大或者初始化不合适,又会把连乘推过 1。这就是为什么初始化方案、归一化层和残差连接都和梯度的量级直接相关。
数值核对:手写梯度交卷前的检查
手写梯度最便宜也最有效的验收方式,是拿中心差分对一遍。下面这个两层网络只用标准库:输入二维,隐藏层两个 tanh 单元,输出一个标量,损失是平方误差,一共 9 个参数。前向和解析梯度都手写,然后用数值梯度逐个比较。
import math
X = [0.7, -1.3]
T = 0.4
def unpack(p):
W1 = [[p[0], p[1]], [p[2], p[3]]]
b1 = [p[4], p[5]]
w2 = [p[6], p[7]]
b2 = p[8]
return W1, b1, w2, b2
def forward(p):
W1, b1, w2, b2 = unpack(p)
z = [W1[i][0] * X[0] + W1[i][1] * X[1] + b1[i] for i in range(2)]
h = [math.tanh(v) for v in z]
y = w2[0] * h[0] + w2[1] * h[1] + b2
return y, z, h
def loss(p):
y, _, _ = forward(p)
return 0.5 * (y - T) ** 2
def analytic(p):
W1, b1, w2, b2 = unpack(p)
y, z, h = forward(p)
d = y - T
g = [0.0] * 9
g[6] = d * h[0]
g[7] = d * h[1]
g[8] = d
dz = [d * w2[i] * (1 - h[i] ** 2) for i in range(2)]
g[0] = dz[0] * X[0]
g[1] = dz[0] * X[1]
g[2] = dz[1] * X[0]
g[3] = dz[1] * X[1]
g[4] = dz[0]
g[5] = dz[1]
return g
p = [-0.310876, 0.465679, 0.115207,
-0.466265, 0.484314, 0.147676,
0.287159, -0.389251, 0.321784]
g = analytic(p)
eps = 1e-6
num = []
for i in range(9):
q1 = p[:]
q2 = p[:]
q1[i] += eps
q2[i] -= eps
num.append((loss(q1) - loss(q2)) / (2 * eps))
worst = 0.0
for a, n in zip(g, num):
rel = abs(a - n) / max(1e-12, abs(a) + abs(n))
worst = max(worst, rel)
print("loss", loss(p))
print("analytic", [round(v, 8) for v in g])
print("numeric ", [round(v, 8) for v in num])
print("max rel", worst)
在本机 Python 3.15 上跑,输出是:
loss 0.09580047811136717
analytic [-0.07861901, 0.14600674, 0.06365294, -0.1182126, -0.11231287, 0.09093277, 0.1428289, -0.29890598, -0.43772246]
numeric [-0.07861901, 0.14600674, 0.06365294, -0.1182126, -0.11231287, 0.09093277, 0.1428289, -0.29890598, -0.43772246]
max rel 3.526953679504625e-11
9 个参数的解析梯度和数值梯度在 8 位小数上完全一致,最大相对误差是 3.5 × 10−11。中心差分的截断误差是 O(h2),h = 10−6 时理论量级在 10−12 附近,再加上浮点舍入,10−11 属于正常。验收线通常定在 10−6:超过这个数,基本可以断定某一层的局部导数漏了、乘反了,或者参数在计算图里被覆盖了。
这项检查应该成为每个新算子和自定义损失函数的固定动作,尤其是手写 softmax、LayerNorm、注意力这类多步复合模块时。它不保证模型效果好,但至少能保证梯度这一层没有写错。
计算图:为什么一次反向就够
把前向计算画成一张图,每个节点是一次运算,每条边是一个张量的依赖关系。前向时,每个节点算出自己的输出,并把输出存下来;反向时,从 loss 出发,每个节点收到上游传来的梯度,乘上自己的局部导数,再传给它的输入。计算图(computational graph)就是让链式法则可以自动执行的数据结构。
一个节点如果被多个下游节点使用,它的梯度要把各条路径的贡献相加。这也是手写反向传播最常见的 bug 之一:同一个变量在图上出现两次,代码里只保留了最后一次的梯度,结果正好差一个整数倍数。开头那个「差 2 倍」的现象,很可能就是共享变量被覆盖了一次。
为什么反向走一遍就够?因为每个参数对 loss 的影响,都可以由它到输出的一条或多条路径上的局部导数相乘再相加得到。反向模式按拓扑逆序走一遍,把所有路径的贡献一次性汇总。逐个参数做数值微分则要 O(n) 次前向,n 是参数个数;中心差分还要乘 2。
sizes = [784, 128, 64, 10]
params = sum(sizes[i] * sizes[i + 1] + sizes[i + 1] for i in range(len(sizes) - 1))
print(params)
print(2 * params)
输出是:
109386
218772
一个 784−128−64−10 的全连接网络有 109,386 个参数;中心差分要 218,772 次前向才能得到一整组梯度。按每次前向 1 毫秒算,接近 3.7 分钟,而一次反向通常只是前向的两三倍时间。参数上到十亿,数值微分就完全不可行。反向传播的价值不在于它「更聪明」,而在于它只需要一遍反向,遍数和参数个数无关。
代价是内存。前向的中间激活都要留着给反向用,层数越深、批量越大,占用越高。梯度检查点(checkpointing)就是拿计算换内存:少存一些激活,反向时重算。控制流、动态形状、原地操作也会让计算图变复杂,调试时先冻结结构更省事。
还要分清:反向传播是求梯度的算法,不是优化算法。它只负责算出每个参数的方向,真正怎么调、调多大,是梯度下降那一篇的事。
一张现象对照表
下面这些现象在训练和手写反向传播时都出现过。原因各不相同,但大多数都能回到「局部导数乘错了」或者「连乘的量级失控」这两类问题上。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 手写梯度和 autograd 差固定倍数 | 漏乘或多乘了一个局部导数,常见于损失系数、输出层权重或共享变量被覆盖 | 逐层打印梯度比值,再对单层做数值梯度检查 |
| 梯度消失,靠近输入的层几乎不动 | 多层小于 1 的因子连乘,或者激活进入饱和区,导数为 0 | 看各层梯度范数和激活值分布,确认是否落在饱和区 |
| 梯度爆炸,loss 变成 NaN | 多层大于 1 的因子连乘,权重初始化过大或学习率过高 | 看梯度范数是否逐层指数增长,先做梯度裁剪 |
| 只有最后一层在学 | 上游梯度传到隐藏层前已经被乘到接近 0,或者计算图被 detach 断开 | 查隐藏层梯度是否为 0,确认张量是否还在计算图里 |
| 更新方向完全反了 | 梯度符号写反,更新式写成了加号,或 loss 定义与求导不一致 | 检查参数更新式是不是 p − lr · g,再用单步 loss 验证 |
| loss 正常但参数不动 | 梯度为 0、学习率过小、参数被冻结,或者优化器没有 step | 查梯度范数、参数是否可训练、优化器状态是否更新 |
| 同一层梯度总是另一层的固定倍数 | 共享参数在多条路径上被使用,梯度应该累加却只保留了一份 | 检查计算图里同一节点是否被多次使用,梯度是否求和 |
最后一行最容易被忽略。共享权重在循环网络、孪生网络和注意力里很常见,梯度本来就应该把各条路径的贡献加起来。写成赋值后,现象是「梯度很有规律地差一个倍数」,而且倍数会随序列长度变化,靠调学习率永远调不回来。
边界与代价
第一,链式法则要求可导。ReLU 在 0 点不可导,绝对值在 0 点不可导,max pooling 在最大值并列时也不可导。框架并没有证明这些点可导,而是选了一个约定,比如 ReLU 在 0 点取 0 或 1 作为次梯度。这个约定在绝大多数训练里够用,但它不是数学上的导数,遇到对抗样本、精确的梯度检查或者二阶优化时,要记得这个前提。
第二,连乘会数值下溢或上溢。浮点数的指数范围有限,几百层之后,梯度可能小到变成 0,也可能大到变成 inf。softmax 和交叉熵是最典型的例子:logits 一大,exp 直接溢出。先减去最大值再取指数,结果不变,数值就稳了。下面这段在 Python 里会先抛出溢出错误,再做平移:
import math
z = [1000.0, 1001.0, 1002.0]
try:
print([math.exp(v) for v in z])
except OverflowError as e:
print("overflow:", e)
m = max(z)
shifted = [v - m for v in z]
print("shifted", shifted)
print("exp", [math.exp(v) for v in shifted])
print("sum", sum(math.exp(v) for v in shifted))
输出是:
overflow: math range error
shifted [-2.0, -1.0, 0.0]
exp [0.1353352832366127, 0.36787944117144233, 1.0]
sum 1.5032147244080551
第三,计算图要存中间激活,内存随层数和批量增长。训练一个大模型时,激活占用往往比参数本身还大。梯度检查点、混合精度、更小的批量,都是在拿计算或精度换内存。反向传播省下了「按参数个数做前向」的时间,但没有省下「保存中间结果」的空间。
第四,输出是向量时,链式法则要升级成雅可比矩阵的乘法。反向模式一次算的是「向量乘雅可比」,也就是一个标量 loss 对全部输入的梯度;如果想拿到完整的雅可比矩阵,就要对每个输出维度各反向一次。分类 logits 有一千类,想拿完整雅可比就要一千次反向,通常没人这么做,大家只要标量 loss 的梯度。
第五,离散操作没有导数。argmax、采样、量化、硬注意力都不满足可导条件。工程上要么换一条可导的近似路径,要么用直通估计器(straight-through estimator)人为定义一个梯度,要么用强化学习里的得分函数估计。这些技巧不是链式法则的推论,而是人为加的近似,正确性要靠实验验证。
第六,数值微分的步长本身有取舍。h 太大,截断误差 O(h2) 明显;h 太小,两个相近的数相减会把舍入误差放大。双精度下常用的范围是 10−5 到 10−7,单精度要更保守。梯度检查通过,只说明在当前步长和当前参数点上自洽,不说明整个参数空间都正确。
五条当天能做的练习
这几条都不需要装框架,有一台装了 Python 的机器就能做。做完再回头看前面的推导,会顺很多。
- 手算
σ'(z)在 z = 0、1、−2 三个点的值,先用σ(z)(1 − σ(z))算一遍,再用中心差分算一遍,比较两者的小数位。 - 用 Python 对
f(z) = log(1 + e−z)在 z = 0.5 处做中心差分,和解析式−1/(1 + ez)对比;再把 z 改成 −3 和 3,观察误差和数值范围的变化。 - 算
0.9n与1.1n在 n = 20、50、100 时的值,列出表格,说明梯度消失和梯度爆炸分别从哪个量级开始变得危险。 - 把本文的两层网络改成三个隐藏单元,或者把 tanh 换成 ReLU,重新做一次数值梯度检查,记录最大相对误差;如果误差变大,先检查 ReLU 在 0 点附近的取值约定。
- 故意把内层导数删掉,比如把
dz = d * w2[i] * (1 − h[i]2)改成dz = d * w2[i],再跑一次检查,记录最大相对误差和训练曲线,解释为什么隐藏层几乎不更新。
从单变量到多变量
这篇讲的都是单输入、单输出的复合。一个 x 进去,一个 y 出来,中间套多少层都只有一条路径,所以梯度就是把这条路径上的局部导数从头乘到尾。这个画面很清楚,但它只是特例。
当参数变成向量,一个输出可能同时依赖很多输入,每个输入到输出都有自己的路径。链式法则没有消失,只是从「一条路径连乘」变成「多条路径连乘再相加」:每条路径上的局部导数相乘,不同路径的贡献相加。这个「相乘再相加」的结构,就是反向传播在任意计算图上的全部内容。下一篇把这些路径拆开,逐个输入方向看变化率,得到偏导与梯度:多维空间里,到底哪边是下坡。