链式法则与计算图

上一课我们用雅可比 Jacobian 和海森 Hessian 描述了多元函数局部如何弯曲；这一课要回答一个更具体、也更"机械"的问题：当一个值经过层层运算最终变成损失 \(L\) 时，每个输入的微小改动对 \(L\) 的影响是怎样一步步传回来的。答案是链式法则 chain rule，而把它图形化、自动化的工具叫计算图 computational graph。这正是反向传播 backpropagation 的全部秘密。

一、一元链式法则：先把"嵌套"拆开

如果 \(y\) 依赖 \(u\)，\(u\) 又依赖 \(x\)，即 \(y=g(u),\ u=h(x)\)，那么

直觉很物理：\(x\) 动一点 \(\Delta x\)，它先把 \(u\) 推动 \(\frac{du}{dx}\,\Delta x\)，这个 \(\Delta u\) 再把 \(y\) 推动 \(\frac{dy}{du}\,\Delta u\)。两级"放大率"相乘，就是总放大率。链条更长时继续连乘：

二、多元链式法则：对所有路径求和

当中间变量不止一个，\(x\) 通往输出可能有多条路径。例如 \(z\) 依赖 \(u\) 和 \(v\)，而 \(u,v\) 都依赖 \(x\)：

一般地，把每条"从 \(x\) 到 \(z\)"的路径上各边的偏导相乘，再把所有路径相加：

这里 \(\dfrac{\partial j}{\partial i}\) 表示沿边 \(i\to j\) 的局部偏导——即节点 \(j\) 对它的直接输入 \(i\) 求导（\(i,j\) 是节点名，不是下标）。

"沿路径相乘、跨路径相加"——这就是多元链式法则的全部内容。为什么相加？因为 \(x\) 同时通过多条途径影响 \(z\)，这些影响是线性叠加的（一阶近似下，总扰动等于各路径扰动之和）。更具体地：\(x\) 变 \(\Delta x\)，它通过 \(u\) 给 \(z\) 带来 \(\frac{\partial z}{\partial u}\frac{\partial u}{\partial x}\Delta x\)，通过 \(v\) 带来 \(\frac{\partial z}{\partial v}\frac{\partial v}{\partial x}\Delta x\)；两份扰动同时发生、彼此独立，所以 \(\Delta z\) 是两者之和——这正是全微分 \(dz=\frac{\partial z}{\partial u}\,du+\frac{\partial z}{\partial v}\,dv\) 的来源。

三、计算图：节点是运算，边是依赖

任何一个由初等运算搭起来的表达式，都能画成一张有向无环图 DAG（directed acyclic graph）：

• 节点 node = 一次运算的结果（一个中间变量）；
• 边 edge = 数据依赖（箭头从被用到的量指向用它算出的量）。

"无环 acyclic" = 没有循环依赖，所以所有节点能排成一个先后顺序（拓扑序）：前向按序计算、反向逆序回传，每个量只算一次。正因为无环，整套"一趟前向 + 一趟反向"才成立。

以本课主例 \(f=\sigma(wx+b)\)（\(\sigma\) 是 sigmoid 函数，\(\sigma(t)=\frac{1}{1+e^{-t}}\)）为例，拆成最小运算：

前向传播 forward pass = 从输入沿边求值，把每个节点的数值算出来并缓存（反向时要用）。给定 \(w=2,\ x=-1,\ b=0.5\)：

四、反向传播：从输出沿边回传梯度

我们想要的是输出对每个输入的梯度。反向传播的做法是给每个节点配一个"梯度信号"——通常记 \(\bar v \equiv \dfrac{\partial f}{\partial v}\)（读作"\(v\) 的伴随 adjoint"），表示输出对该节点的敏感度。（再次提醒：这里的输出 \(f\) 就是上文说的"终点节点"；训练时把它换成损失 \(L\)，记号同理。）规则只有两条：

1. 起点：输出节点对自己的梯度是 1，即 \(\bar f=\dfrac{\partial f}{\partial f}=1\)。
2. 沿边回传：若有边 \(i\to j\)（即 \(j\) 用到了 \(i\)），则 \(i\) 从这条边收到的贡献是 \[ \underbrace{\bar j}_{\text{上游梯度}}\times\underbrace{\frac{\partial j}{\partial i}}_{\text{局部梯度 local gradient}}. \] 一个节点把它所有出边收到的贡献相加，就得到自己的 \(\bar i\)（这正是"多路径求和"在图上的体现）。

给本例标注每条边的局部导数（用前向缓存的值）：

五、扇出节点：被多处使用，梯度要相加

如果一个变量被多个下游用到，它在图上有多条出边，这叫扇出 fan-out。规则第 2 条说得很清楚：把所有出边收到的梯度相加。这其实就是"多路径求和"最常见的来源。

看一个最小例子 \(g=x^2+xy\)，这里 \(x\) 同时进了 \(p=x^2\) 和 \(q=xy\) 两个节点（扇出度为 2，指 \(x\) 有两条出边 \(x\to p\) 和 \(x\to q\)）：

在 \(x=3,\ y=2\) 处：\(\partial g/\partial x=2\cdot3+2=8\)，\(\partial g/\partial y=x=3\)。

六、前向模式 vs 反向模式：为什么深度学习选反向

自动微分 automatic differentiation（autodiff）有两种走法，区别在于"沿图传播的是什么"：

• 正向模式 forward-mode：和前向求值同方向。固定一个输入，沿图往前推它的导数（携带"切向量"）。一趟前向能得到所有输出对这一个输入的导数，即雅可比的一列。
• 反向模式 reverse-mode（即反向传播）：先完整前向一遍并缓存，再从一个输出沿图往回推。一趟反向能得到这一个输出对所有输入的梯度，即雅可比的一行。

设函数 \(f:\mathbb{R}^n\to\mathbb{R}^m\)，雅可比是 \(m\times n\) 矩阵。要拼出整个雅可比：

• 正向模式：需 \(n\) 趟（每趟一列），共约 \(n\) 趟、每趟≈一次前向的工作量。
• 反向模式：需 \(m\) 趟（每趟一行）。注意每趟反向 = 一次前向 + 一次反向回传，而回传代价与前向同量级，所以单趟约 2~3 次前向的工作量——总之是与输入维 \(n\) 无关的常数倍。

向量-雅可比积 VJP 视角

反向传播的每一步，本质都是一个向量-雅可比积 vector-Jacobian product（VJP）。设某节点运算 \(y=\phi(x)\)（\(x\in\mathbb{R}^n,\ y\in\mathbb{R}^m\)），上游传来的梯度（伴随）是行向量 \(\bar y\)（\(1\times m\)，因为它是标量输出对向量 \(y\) 的偏导）。这一步把它变成 \(\bar x\)：

（维度核对：行向量 \(1\times m\) 乘 \(m\times n\) 矩阵 = 行向量 \(1\times n\)，正是 \(\bar x\)。）

关键在于：我们从不显式构造大矩阵 \(J_\phi\)，只实现"给定 \(\bar y\) 直接算出 \(\bar y\,J_\phi\)"的函数。对加法、乘法、sigmoid 这些运算，VJP 都有简单闭式（比如 sigmoid 的 VJP 就是 \(\bar y\odot f\odot(1-f)\)）。整个反向传播 = 把这些 VJP 沿图从输出到输入串起来。

七、detach / stop-gradient：截断梯度流

有时我们希望某个量在前向照常参与计算，但反向时不让梯度穿过它。这就是 detach()（PyTorch）/ stop_gradient()（JAX/TF）。在计算图里，它相当于把那条边的局部梯度强制设成 0：值照传，梯度到此为止。

• 把 \(s=\text{detach}(u)\) 视作"一个数值等于 \(u\)、但与 \(u\) 断开的常数"：前向 \(s=u\)，反向 \(\bar u\) 不收来自 \(s\) 的任何贡献。
• 常见用途：目标网络/教师网络的输出当作常数、把某分支当固定标签、阻断不希望被训练的路径。

八、代码：numpy 手写计算图 + 有限差分校验

下面用纯 numpy 实现 \(f=\sigma(wx+b)\) 的前向与反向，并用中心差分 central difference \(\frac{F(\theta+h)-F(\theta-h)}{2h}\) 作为"数值真值"对照，打印相对误差。

import numpy as np

def sigmoid(t):
    return 1.0 / (1.0 + np.exp(-t))

def forward(w, x, b):
    # 前向：逐节点求值并缓存
    u = w * x          # 节点 u
    z = u + b          # 节点 z
    f = sigmoid(z)     # 节点 f（输出）
    cache = (w, x, b, u, z, f)
    return f, cache

def backward(cache):
    w, x, b, u, z, f = cache
    fbar = 1.0                       # d f / d f = 1
    zbar = fbar * (f * (1.0 - f))    # 经过 sigmoid：局部导数 f(1-f)
    ubar = zbar * 1.0                # z = u + b
    bbar = zbar * 1.0                # b 的出边
    wbar = ubar * x                  # u = w*x，对 w 局部导数是 x
    xbar = ubar * w                  # 对 x 局部导数是 w
    return dict(w=wbar, x=xbar, b=bbar)

# 取一组具体输入
w, x, b = 2.0, -1.0, 0.5
f, cache = forward(w, x, b)
grads = backward(cache)
print("forward: u=%.4f z=%.4f f=%.6f" % (cache[3], cache[4], f))
print("analytic grads:", {k: round(v, 6) for k, v in grads.items()})

# 有限差分校验（中心差分）
def F_only(w, x, b):
    return sigmoid(w * x + b)

h = 1e-6
num = {}
num["w"] = (F_only(w+h, x, b) - F_only(w-h, x, b)) / (2*h)
num["x"] = (F_only(w, x+h, b) - F_only(w, x-h, b)) / (2*h)
num["b"] = (F_only(w, x, b+h) - F_only(w, x, b-h)) / (2*h)

print("numeric  grads:", {k: round(v, 6) for k, v in num.items()})
for k in ["w", "x", "b"]:
    a, n = grads[k], num[k]
    rel = abs(a - n) / (abs(n) + 1e-12)
    print("relative error %s: %.2e" % (k, rel))

运行后会看到解析梯度 \(\{w:-0.1491,\ x:0.2983,\ b:0.1491\}\) 与数值梯度几乎相同，三个相对误差都在 \(10^{-8}\) 量级——这就是"反向传播算对了"的标准自检方法（gradient check 梯度检验）。

调一调，观察现象

下面三个微改都基于本课已验证的主例，改一个数、跑几秒，就能把"梯度怎么流"看成可复现的现象。

import numpy as np
def sigmoid(t): return 1.0/(1.0+np.exp(-t))
for z in [0.0, 1.5, 3.0, 6.0, 10.0]:
    f = sigmoid(z)
    print("z=%5.1f  f=%.6f  sigma'(z)=f(1-f)=%.6f" % (z, f, f*(1-f)))

import numpy as np
for (x, y) in [(3.0, 2.0), (1.0, 5.0), (-2.0, 4.0)]:
    pbar, qbar = 1.0, 1.0          # g = p + q, p=x^2, q=x*y
    accumulate = pbar*(2*x) + qbar*y   # 累加（正确）
    overwrite  = qbar*y                # 只取第二条出边（错误）
    print("x=%.1f y=%.1f  累加=%.1f (2x+y=%.1f)  覆盖=%.1f" %
          (x, y, accumulate, 2*x+y, overwrite))

import numpy as np
def sigmoid(t): return 1.0/(1.0+np.exp(-t))
w, x, b = 2.0, -1.0, 0.5
u = w*x; z = u + b; f = sigmoid(z)
zbar = 1.0*(f*(1-f))               # 反向到 z
print("前向 f=%.6f（detach 不改前向）" % f)
print("正常: df/dw=%.4f  df/dx=%.4f" % (zbar*x, zbar*w))
print("detach x: df/dw=%.4f  df/dx=%.4f" % (zbar*x, zbar*0.0))

动手练习

1. 线性回归损失。 设 \(L=(wx-y)^2\)，给定 \(w=1.5,\ x=2,\ y=1\)。先画计算图（节点：\(p=wx,\ r=p-y,\ L=r^2\)），手算 \(\partial L/\partial w,\ \partial L/\partial x\)，再用下面骨架的反向与有限差分对照。

   import numpy as np
   w, x, y = 1.5, 2.0, 1.0
   def forward(w, x, y):
       p = w * x
       r = p - y
       L = r * r
       return L, (w, x, y, p, r)
   def backward(c):
       w, x, y, p, r = c
       Lbar = 1.0
       rbar = Lbar * (2 * r)     # dL/dr = 2r
       pbar = rbar * 1.0         # r = p - y
       wbar = pbar * x           # TODO: 确认局部导数
       xbar = pbar * w
       return dict(w=wbar, x=xbar)
   L, c = forward(w, x, y)
   print("L=", L, "grads=", backward(c))
   # TODO: 加中心差分校验 w 和 x
   

2. 扇出累加。 实现 \(g=x^2+xy\) 的反向，要求 \(x\) 的梯度用 += 从两条出边累加（节点 \(p=x^2,\ q=xy\)）。在 \(x=3,y=2\) 验证得到 \(\partial g/\partial x=8,\ \partial g/\partial y=3\)；故意把累加改成赋值，观察 \(x\) 的梯度变成多少、错在哪。
3. detach 实验。 在第 1 题里把 \(x\) "detach"：反向时令来自 \(x\) 那条边的梯度为 0（即 xbar = 0.0），其余不变。验证 \(\partial L/\partial w\) 不受影响而 \(\partial L/\partial x=0\)，体会"值照传、梯度截断"。
4. 正向 vs 反向的代价。 对 \(f=\sigma(wx+b)\)，用分别对 \(w,x,b\) 各做一次单边扰动来"模拟正向模式"（3 趟），数一数你做了几次 sigmoid 求值；再对比一次反向传播只算了 1 次 sigmoid。写一句话总结：输入越多，反向模式省得越多。
5. （挑战）两层链。 设 \(a=\sigma(w_1 x),\ f=\sigma(w_2 a)\)，求 \(\partial f/\partial w_1,\ \partial f/\partial w_2,\ \partial f/\partial x\)，并用有限差分校验。建议节点拆分： \(t_1=w_1\cdot x,\ a=\sigma(t_1)\)；\(t_2=w_2\cdot a,\ f=\sigma(t_2)\)。注意 \(t_2\) 经 \(a\) 同时依赖 \(w_1\) 和 \(x\)，所以回到 \(a\) 的梯度要继续往 \(t_1\) 这一路回传——确认梯度路径没漏。

掌握自检

• 我能说清"沿路径相乘、跨路径相加"，并解释扇出节点为什么用累加。
• 给定一个小表达式，我能画出计算图、标注每条边的局部导数，手工跑一次前向 + 一次反向，并和闭式/有限差分对上数值。
• 我能解释"上游梯度 × 局部梯度"这一条规则如何等价于多元链式法则。
• 我能讲清正向模式与反向模式的区别，并说出为什么标量损失 + 海量参数必须用反向模式（一趟反向、总代价≈一次前向的常数倍）。
• 我理解反向传播每步都是一个 VJP \(\bar x=\bar y\,J\)，且从不显式构造雅可比。
• 我知道 detach/stop_gradient 只截断梯度、不改前向值，并能预测它对各参数 .grad 的影响，也能区分它和 no_grad。

下一课，我们把这套"节点—边—局部梯度"的机制升级成矩阵形式（矩阵求导）：当节点不再是标量而是向量、矩阵时，每个运算的 VJP 怎么写成干净的矩阵公式，从而一次性给整层网络求出梯度。届时会正式声明分母布局 denominator layout（\(\partial L/\partial W\) 与 \(W\) 同形）这一深度学习惯例，并把本课 VJP 的行/列向量与转置约定彻底敲定。