手写反向传播的人,大多遇到过一个说不清的倍数问题。同一组初始化、同一个学习率、同一份数据,框架跑出来的 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。齿轮不会把两个传动比加起来。

两级齿轮的传动比
输入轴转 1 圈,经过第一级齿轮,倍率 3。
中间轴转 3 圈,经过第二级齿轮,倍率 2。
输出轴转 6 圈。总倍率是 3 乘 2,不是 3 加 2。

拿一个具体函数试一下: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 的机器就能做。做完再回头看前面的推导,会顺很多。

  1. 手算 σ'(z) 在 z = 0、1、−2 三个点的值,先用 σ(z)(1 − σ(z)) 算一遍,再用中心差分算一遍,比较两者的小数位。
  2. 用 Python 对 f(z) = log(1 + e−z) 在 z = 0.5 处做中心差分,和解析式 −1/(1 + ez) 对比;再把 z 改成 −3 和 3,观察误差和数值范围的变化。
  3. 算 0.9n 与 1.1n 在 n = 20、50、100 时的值,列出表格,说明梯度消失和梯度爆炸分别从哪个量级开始变得危险。
  4. 把本文的两层网络改成三个隐藏单元,或者把 tanh 换成 ReLU,重新做一次数值梯度检查,记录最大相对误差;如果误差变大,先检查 ReLU 在 0 点附近的取值约定。
  5. 故意把内层导数删掉,比如把 dz = d * w2[i] * (1 − h[i]2) 改成 dz = d * w2[i],再跑一次检查,记录最大相对误差和训练曲线,解释为什么隐藏层几乎不更新。

从单变量到多变量

这篇讲的都是单输入、单输出的复合。一个 x 进去,一个 y 出来,中间套多少层都只有一条路径,所以梯度就是把这条路径上的局部导数从头乘到尾。这个画面很清楚,但它只是特例。

当参数变成向量,一个输出可能同时依赖很多输入,每个输入到输出都有自己的路径。链式法则没有消失,只是从「一条路径连乘」变成「多条路径连乘再相加」:每条路径上的局部导数相乘,不同路径的贡献相加。这个「相乘再相加」的结构,就是反向传播在任意计算图上的全部内容。下一篇把这些路径拆开,逐个输入方向看变化率,得到偏导与梯度:多维空间里,到底哪边是下坡。