一个两层网络的练习:输入 784 维,隐藏层 128,输出 10。手写反向传播跑完,和框架的自动求导(autograd)逐元素比,dW₁、dW₂ 的比值全都是 2.0000,一个不差。梯度方向完全一致,只是整体大了一倍,于是同一个学习率下参数一步跨过头,loss 先降后炸。

另一个更安静的现场:dW 的形状写成了 (输入维度, 输出维度)。代码照常跑完,没有异常,没有警告,loss 也真的在降,只是慢得离谱,训练三轮还不如别人一轮。把形状打印出来才看见,权重是 128×784,梯度却是 784×128;两者元素个数相同,有些框架会直接接受,用广播或按位置更新,结果等于在更新另一组参数。

这两个坑的共同点,不是不会链式法则。第一个是损失少了 ½,或者 batch 的 sum 与 mean 没对齐;第二个是外积写反了。链式法则只有一条,难的是把它落到矩阵上时,每一步的形状和转置有没有对齐。这篇就把这件事拆开:先看反向扫描在做什么,再逐层推 δ、dW、dx,用数值梯度核对,最后解释 Wᵀ 为什么必然出现。

计算图与反向模式

计算图(computational graph)把一次前向计算拆成节点和边。节点是一个值或一个运算,边表示依赖关系:谁的输出喂给了谁。前向时除了算出 loss,还要把每个中间结果留在内存里,因为反向时局部导数要用到它们。

反向模式(reverse mode)从 loss 出发,先令 ∂L/∂L = 1,再按拓扑序的逆序走。每个节点收到「上游传回来的梯度」,乘上自己的局部导数,分给它的输入。这个上游梯度有个名字叫余切(cotangent),记作 v̄ = ∂L/∂v。一个节点如果有多个下游消费者,就把各条路径传回来的贡献加起来,这是多元链式法则的要求,不是额外规则。

为什么一次反向就能拿到所有参数的梯度?因为每个参数到 loss 的所有路径,在反向扫描里都会被走到一次,贡献在参数节点上累加。整张图的每条边只经过一次,代价和前向同阶,实践中的经验值是前向的两到三倍。对比一下前向模式:参数有多少维,就要跑多少遍;百万参数的网络根本没法这么算。

反向模式占这个便宜,根本原因是输出是标量。一个种子(seed)就能覆盖所有输入方向,剩下的工作只是把同一个余切沿着图分发下去。这也是为什么训练时 loss 必须是标量:输出多维时得先加权求和成一个数,或者给每一维配一个种子。

一次反向扫描
前向:算值并留下激活
从 loss 起步,种子为 1
逐节点乘局部导数
在参数上累加梯度

标量链式法则,到向量情形

标量链式法则只有一句:复合函数的导数,等于外函数的导数乘内函数的导数。写成 L = f(g(x)),就是 dL/dx = f'(g(x))·g'(x)。多元情形多一条:如果中间变量被多条路径用到,要把每条路径的贡献相加。

转到向量。设一层线性变换把 n 维输入 x 映成 m 维输出 z:z = Wx + b,W 是 m×n,b 是 m×1。上标 ᵀ 表示转置,把矩阵的行和列互换:m×n 的 W 转置后是 n×m 的 Wᵀ,原来第 i 行第 j 列的元素跑到第 j 行第 i 列。设 δ = ∂L/∂z,按列向量约定它是 m×1。于是:

δ      = ∂L/∂z                 m×1
∂L/∂W = δ xᵀ                   (m×1)(1×n) = m×n
∂L/∂b = δ                      m×1
∂L/∂x = Wᵀ δ                   (n×m)(m×1) = n×1

再逐项验证。zi = ∑j Wij xj + bi,所以 zi 对 Wij 的偏导是 xj,对 xj 的偏导是 Wij。而 Wij 只影响第 i 个输出,不会影响别的输出,所以对 Wij 求和时只剩一项:

∂L/∂W_ij = δ_i · ∂z_i/∂W_ij = δ_i x_j
∂L/∂x_j  = ∑_i δ_i · ∂z_i/∂x_j = ∑_i W_ij δ_i = (Wᵀδ)_j

这两个式子把外积和内积分得很清楚。δxᵀ 是外积:m 个输出的梯度,每个都乘上整条输入向量,铺成一张 m×n 的表,和 W 同形,所以每个权重都有自己的梯度。Wᵀδ 是内积:W 的每一行和 δ 做点积,汇总成 n 个数,和 x 同形。

记法可以压成一句:对权重用外积,对输入用内积;外积铺开,内积汇总。之所以不能写 δx,是因为 m 和 n 一般不等,两个列向量根本乘不起来;能乘的只有 δxᵀ(m×n)和 δᵀx(1×1 的标量)。选哪一个,由结果该长什么样决定,而不是由喜好决定。

单层线性加均方损失,完整推一遍

取最小完整例子:m=2,n=3,损失用均方误差的一半。这个 ½ 不是装饰,它让求导之后不冒出因子 2。

z = W x + b
L = ½‖z − y‖² = ½ ∑_i (z_i − y_i)²

对 z 求偏导,δi = zi − yi。代进上一节,dW = δxᵀ,db = δ,dx = Wᵀδ。推导到此结束,剩下的是写成代码并核对。

W = [[0.5, -0.2, 0.1], [0.3, 0.4, -0.6]]
b = [0.1, -0.2]
x = [1.0, -2.0, 0.5]
y = [0.3, 0.8]

def forward(W, b, x):
    return [sum(W[i][j] * x[j] for j in range(len(x))) + b[i]
            for i in range(len(b))]

def loss(W, b, x, y):
    z = forward(W, b, x)
    return 0.5 * sum((zi - yi) ** 2 for zi, yi in zip(z, y))

z = forward(W, b, x)
delta = [zi - yi for zi, yi in zip(z, y)]
dW = [[delta[i] * x[j] for j in range(len(x))] for i in range(len(b))]
db = delta
dx = [sum(W[i][j] * delta[i] for i in range(len(b))) for j in range(len(x))]

在本机 Python 3.15 上跑,输出是:

L = 1.901250
z = [   1.0500    -1.0000]
delta = z - y = [   0.7500    -1.8000]
dW = delta * x^T =
  [   0.7500    -1.5000     0.3750]
  [  -1.8000     3.6000    -0.9000]
db = delta = [   0.7500    -1.8000]
dx = W^T * delta = [  -0.1650    -0.8700     1.1550]
max relative error over W, b, x = 6.946e-10

手算两格。dW 第 0 行第 0 列 = δ₀x₀ = 0.75×1 = 0.75;第 1 行第 2 列 = δ₁x₂ = (−1.8)×0.5 = −0.9。dx 第 0 个分量 = W 第 0 列与 δ 的点积 = 0.5×0.75 + 0.3×(−1.8) = −0.165。三格都对得上。

数值核对用中心差分:对每个参数单独加 eps 再减 eps,用两次 loss 的差除以 2eps。它是二阶精度,误差来自截断和浮点舍入两部分;eps 取 1e-6 时,结果通常落在 1e-10 附近。输出里的 6.946e-10 就是这个量级,说明解析梯度和数值梯度在双精度范围内一致。换成单侧差分,误差会退到 1e-6 左右,仍能用,但不够干净。

现在回头看开头的 2 倍。如果损失写成 L = ‖z−y‖² 而不是 ½‖z−y‖²,那么 δ = 2(z−y),dW、db、dx 全部翻倍。方向没错,尺度错了,配正常学习率就会震荡。同理,batch 那边用 sum 还是 mean,也会让梯度整体差 B 倍。对不上框架时,先查这两个缩放,比从第一行重推有效得多。

两层加 ReLU,逐层反传

加一层 ReLU,网络才有非线性。取 n=2,隐藏层 3 个单元,输出 m=2。

a  = W₁ x + b₁        W₁: 3×2,  b₁: 3×1
h  = ReLU(a)          逐元素取 max(0, a)
z  = W₂ h + b₂        W₂: 2×3,  b₂: 2×1
L  = ½‖z − y‖²

ReLU 的定义很简单:max(0, a),负的截成 0,正的照原样。反向从 loss 开始,逐层往前:

δ₂  = z − y                      2×1
dW₂ = δ₂ hᵀ                      (2×1)(1×3) = 2×3
db₂ = δ₂                         2×1
δ₁  = (W₂ᵀ δ₂) ⊙ g               3×1
dW₁ = δ₁ xᵀ                      (3×1)(1×2) = 3×2
db₁ = δ₁                         3×1

g_j = 1 (a_j > 0) 或 0 (a_j ≤ 0)

最后一行里的 g 是门控:aj 为正时取 1,否则取 0。ReLU 在 0 点的导数不唯一,工程上统一取 0,这是次梯度的一种选择,后面还会说。

把门写成对角矩阵 G = diag(g),δ₁ = G W₂ᵀ δ₂。于是整个反向就是一串矩阵乘法:

∂L/∂x = W₁ᵀ G W₂ᵀ δ₂    (n×h)(h×h)(h×m)(m×1) = n×1

顺序是前向的逆序。前向先 W₁ 再 W₂,反向先 W₂ᵀ、再 G、再 W₁ᵀ。每层拿出自己的转置,乘上游余切,遇到非线性就插入它的局部导数。链式法则没有变形,只是每个标量因子升级成了矩阵,顺序要反过来。

W1 = [[0.4, -0.3], [0.2, 0.5], [-0.1, 0.6]]
b1 = [0.05, 0.1, 0.3]
W2 = [[0.7, -0.4, 0.2], [-0.3, 0.5, 0.1]]
b2 = [0.0, 0.1]
x = [1.2, -0.5]
y = [0.6, -0.2]

a = [sum(W1[i][j] * x[j] for j in range(2)) + b1[i] for i in range(3)]
h = [max(0.0, v) for v in a]
z = [sum(W2[i][j] * h[j] for j in range(3)) + b2[i] for i in range(2)]
d2 = [z[i] - y[i] for i in range(2)]
dW2 = [[d2[i] * h[j] for j in range(3)] for i in range(2)]
d1 = [sum(W2[i][j] * d2[i] for i in range(2)) * (h[j] > 0) for j in range(3)]
dW1 = [[d1[i] * x[j] for j in range(2)] for i in range(3)]

在本机 Python 3.15 上跑,输出是:

L2 = 0.022740
a = W1 x + b1 = [   0.6800     0.0900    -0.1200]
h = ReLU(a) = [   0.6800     0.0900     0.0000]
delta2 = z - y = [  -0.1600     0.1410]
dW2 = delta2 * h^T =
  [  -0.1088    -0.0144    -0.0000]
  [   0.0959     0.0127     0.0000]
delta1 = (W2^T delta2) * gate = [  -0.1543     0.1345    -0.0000]
dW1 = delta1 * x^T =
  [  -0.1852     0.0771]
  [   0.1614    -0.0672]
  [  -0.0000     0.0000]
db1 = delta1 = [  -0.1543     0.1345    -0.0000]
db2 = delta2 = [  -0.1600     0.1410]
two-layer max relative error = 1.409e-10

读一下输出。a 的第三个分量是 −0.12,被 ReLU 截成 0,所以 h₃ = 0;它的门 g₃ = 0,于是 δ₁ 的第三项是 0,dW₁ 的第三行整行为 0,b₁ 的第三个分量也拿不到梯度。一个单元一旦落进负区间,这一整条通道当天就不再更新,这不是写错了,是 ReLU 的定义决定的。

前两个单元是通的。δ₂ = [−0.16, 0.141],dW₂ 的第一行 = δ₂₀hᵀ = −0.16×[0.68, 0.09, 0] = [−0.1088, −0.0144, 0];第二个隐藏单元虽然只有 0.09,仍然分到了梯度。数值核对的最大相对误差是 1.409e-10,和单层同样的量级。

为什么一定出现转置

现在正面回答:为什么一定出现转置?

前向里 W 把 n 维 x 映成 m 维 z,W 是 m×n。反向要把 m 维的 δ 映回 n 维,放到 x 的位置上。这个映射必须是一个 n×m 的矩阵。W 是 m×n,W⁻¹ 通常不存在,长方形矩阵没有逆;唯一自然能拿出来的同源对象就是 Wᵀ,它正好是 n×m。

「自然」不只是形状凑巧。转置满足一条内积等式:

⟨Wᵀδ, x⟩ = ⟨δ, W x⟩    对任意 x ∈ Rⁿ, δ ∈ Rᵐ

证明是一行下标运算:左边 = ∑j (∑i Wij δi) xj,右边 = ∑i δi (∑j Wij xj),两个都是 ∑i ∑j Wij δi xj,只是求和次序不同。数值上也验证一遍:

<W^T d, x> = 2.152500
<d, W x>   = 2.152500
difference = 0.0e+00

这条等式说明 Wᵀ 是 W 的伴随(adjoint):它把输出空间里的梯度测量和输入空间里的位移测量对齐。梯度不是普通向量,它是线性泛函,喂进一个方向就吐出那个方向的方向导数;把泛函从输出空间拉回输入空间,用的就是伴随,而在欧氏空间里伴随恰好是转置。

唯一性也补一句。如果另一个 n×m 矩阵 A 也满足 ⟨Aδ, x⟩ = ⟨δ, Wx⟩ 对所有 x、δ 成立,那么 ⟨(Wᵀ−A)δ, x⟩ 恒为 0。内积非退化,只能 (Wᵀ−A)δ = 0 对所有 δ 成立,于是 A = Wᵀ。转置不是记号偏好,是这条等式逼出来的唯一答案。

还要把转置和逆分开。旋转矩阵的转置刚好等于逆,这容易让人以为反传就是乘逆矩阵。一般的长方形矩阵没有逆,但转置永远存在,而且不用付求逆的代价。实现里也不会真的构造 Wᵀ,只是把下标的读写顺序换一下,用的是同一块内存。

布局约定会改变公式的长相,但改变不了形状匹配。上一篇讲过,若把 ∂L/∂x 写成行向量,公式变成 δᵀW,形状是 1×n;如果坚持列向量,就是 Wᵀδ,n×1。两种写法都对,前提是整篇统一。真正不能错的是结果必须能放在 x 的位置上。

顺便说一句方阵的陷阱。W 是 n×n 时,Wᵀ 和 W 形状一样,外积写反了也照样能算,甚至能更新,只是更新的是转置后的那一组数。非方阵会立刻暴露问题,所以单元测试里最好故意用一个 2×3 的权重。

batch:一次算一批,等价于逐样本求和

实际训练一次算一批。把 B 个样本按行堆起来:X 是 B×n,每行一个样本;输出 Z = XWᵀ + 1bᵀ 是 B×m;Δ 是 B×m,每行一个 δiᵀ。

dW = ∑_i δᵢ xᵢᵀ = Δᵀ X        (m×B)(B×n) = m×n
db = ∑_i δᵢ   = Δᵀ 1         (m×B)(B×1) = m×1
dX = Δ W                     (B×m)(m×n) = B×n

如果按另一套约定把 Δ 写成 m×B,每一列是一个样本的 δ,同一个式子写成 ΔXᵀ,形状是 (m×B)(B×n) = m×n。两种写法只差一次转置,乘出来是同一张表。不要背字母顺序,检查三件事:三个因子的相邻维度是否相等、结果是否和 W 同形。

代码上,批量不是「循环 B 次」的语法糖。把 B 个外积合成一次矩阵乘法,BLAS(基础线性代数子程序库)可以做分块、向量化和多线程,单位时间吞吐高出一个量级;数学上和逐样本求和完全等价。下面用两个样本验证这个等价。

X = [[1.0, -2.0, 0.5], [-0.5, 1.0, 2.0]]
Y = [[0.3, 0.8], [1.0, 0.1]]
Delta = []
for s in range(2):
    zs = [sum(W[i][j] * X[s][j] for j in range(3)) + b[i] for i in range(2)]
    Delta.append([zs[i] - Y[s][i] for i in range(2)])

dW_sum = [[0.0] * 3 for _ in range(2)]
for s in range(2):
    for i in range(2):
        for j in range(3):
            dW_sum[i][j] += Delta[s][i] * X[s][j]

dW_batch = [[sum(Delta[s][i] * X[s][j] for s in range(2)) for j in range(3)]
            for i in range(2)]

在本机 Python 3.15 上跑,输出是:

dW sample 1 =
  [   0.7500    -1.5000     0.3750]
  [  -1.8000     3.6000    -0.9000]
dW sample 2 =
  [   0.5750    -1.1500    -2.3000]
  [   0.6250    -1.2500    -2.5000]
dW sample 1 + sample 2 =
  [   1.3250    -2.6500    -1.9250]
  [  -1.1750     2.3500    -3.4000]
dW batch = Delta^T X =
  [   1.3250    -2.6500    -1.9250]
  [  -1.1750     2.3500    -3.4000]
max abs diff batch vs sum = 0.0e+00

两路算法一个按样本累加,一个按矩阵乘,浮点加法的顺序不同,理论上可能有 1e-16 级别的差;这个例子里恰好是 0.0。若损失取平均而不是求和,所有梯度再除以 B,梯度量级不随 B 增长,这也是下一节表里「batch 变大梯度没变」的原因。

一张现象对照表

遇到梯度不对,先按现象定位,不要从公式第一行重推。下面这张表把常见现场和第一步该查的东西对上。

现象真实原因第一步查什么
梯度与参考实现差固定倍数,比值恒为 2 或 4损失少了 ½,或一边用 sum、一边用 mean打印 loss 表达式和归约方式,先对单样本比一次
dW 形状是 (输入, 输出),不是 (输出, 输入)外积写反,把 δxᵀ 写成了 xδᵀ断言 dW 的形状等于 W 的形状,再核对乘法顺序
只有偏置在更新,权重几乎不动dW 恒为 0:输入被 detach、上游梯度乘了 0,或参数没进计算图打印 dW 与输入 x 的范数,确认权重参与了前向
loss 突然变成 NaN,或梯度爆炸连乘的谱半径过大、学习率过高、缺少归一化逐层打印梯度范数,检查激活值和权重的量级
batch 从 32 加到 256,梯度数值几乎没变损失对 batch 取了平均,梯度本来就是样本梯度的均值查归约方式;要更大步长就调学习率,或改成求和
某一层梯度恒为 0,后期整层不动ReLU 全落在负区间,单元死掉,偏置被推到负区统计该层激活的非零比例,看 a 的分布
方阵网络能跑但收敛很慢,没有任何报错dW 转置了,但方阵形状合法,错误被藏住用非方阵做单元测试,或对一小批参数做 gradcheck

边界与代价

第一,显存。反向必须保留前向的中间激活,不能算完就扔。占用大致是 batch 大小乘层数乘每层宽度,卷积和注意力还要额外存索引或注意力矩阵。层数深、batch 大时,激活比参数本身大得多。显存不够可以用激活检查点(checkpointing):只存少数几层的输出,反向时把中间段重算一遍,用计算换显存。

第二,非可导点。ReLU 在 0、max 在相等处、排序在交换处、量化在边界,都没有唯一导数。框架给的是次梯度(subgradient)的一种选法,比如 ReLU 取 0、max 取第一个。它不是「正确导数」,只是一个让训练能继续的约定;换框架可能选另一边,梯度在个别点上会不一样,但测度为零,通常不影响结果。

第三,数值精度。float32 下做中心差分不可靠,舍入误差会盖过真实斜率;数值梯度检查(gradcheck)要用 float64,网络要小,eps 要选在 1e-6 附近。softmax 和交叉熵要先做 log-sum-exp 再求导,否则 exp 溢出会把梯度变成 NaN。这些都不是链式法则的问题,是浮点数的问题。

第四,静默失败。转置写错不会抛异常:方阵能算,广播能算,元素个数相同的 reshape 也能算,只是训练变慢、效果变差。这类错误只能靠断言形状和小规模 gradcheck 抓,不能靠 loss 曲线猜。养成在反向入口打印每个梯度形状的习惯,比事后调参省时间。

第五,反向不是免费的。一次反向约等于两到三次前向的计算量,外加一份激活显存;输出是多维向量时,反向模式一次只给一个种子的向量雅可比积,要完整雅可比得跑多次。还有一条容易忘:如果一层接一层全是线性的,没有非线性夹在中间,多层等价于一个矩阵,反向也就退化成一次转置乘法,深度完全白给。

小结与练习

把这篇的主线压成三句。反向传播是在计算图上做一次逆序扫描,每个节点拿上游余切乘局部导数;线性层的局部导数落到矩阵上就是 δxᵀ 与 Wᵀδ,一个外积铺开权重,一个内积汇总输入;转置不是记号习惯,是维度与内积等式共同逼出来的唯一选择。

当天可以自己验证的练习:

  1. 取 W = [[1,2],[3,4]]、x = [1,−1]、b = [0,1]、y = [2,0],损失用 ½‖z−y‖²,手推 δ、dW、dx,再写代码逐格核对。
  2. 在单层例子里把 eps 从 1e-3 逐步调到 1e-8,记录最大相对误差,画出误差随 eps 变化的趋势,解释为什么太小反而变差。
  3. 改两层例子的 b₁,让第三个单元从负区间回到正区间,确认 dW₁ 的第三行从全 0 变回非 0,并用数值梯度核对新值。
  4. 随机生成 W、δ、x,验证 ⟨Wᵀδ, x⟩ 与 ⟨δ, Wx⟩ 相等;再取一个 2×2 的 W,分别算 Wᵀ 和 W⁻¹,确认它们一般不相等。
  5. 把 batch 例子的损失从 sum 改成 mean,确认 dW 缩小为原来的 1/B,再和逐样本梯度的平均值对照。

收尾:这一组留下的是形状感

本组到此结束。回头看这条线:向量和矩阵先解决「数据怎么摆」,一列是一个样本、一行是一个特征;线性变换把矩阵乘向量解释成空间到空间的映射;秩与可逆回答信息有没有被压丢;特征值回答哪些方向只被拉伸、不被转向;雅可比把非线性函数在一点附近线性化;矩阵求导把梯度写成形状正确的对象;反向传播则把这些串成一次从 loss 到参数的扫描。

真正留下来的不该是公式,而是形状感。看到一个矩阵乘法,先问两边维度接不接得上;看到一个梯度,先问它和谁同形;看到一个转置,先问它是伴随还是逆。把这三个问题问顺了,autograd 的源码就不再神秘,手写反向也只是体力活。

下一组进入拓扑学,从「连续」和「附近」讲起。那里没有矩阵和转置,但这一组养成的习惯仍然有用:先把对象和映射分清楚,再谈性质。