自动微分：反向模式 Reverse Mode

可视化演示

展示反向模式Reverse Mode全流程：正向传播计算节点值、反向传播梯度从输出流向输入、链式法则逐层累积梯度，通过交互理解反向模式自动微分原理。

计算图与反向思维

小林走进后厨，墙上贴着一张巨大的“菜谱流程图”：牛肉切成片，片和酱汁拌成牛排，牛排与沙拉拼成套餐，套餐加上甜品凑成晚宴。每一步都有箭头指向下一步，从最底层的食材一直连到最顶层的晚宴。这张图就是这顿饭的“总账底稿”——任何一步的价格变了，最终账单都会跟着变。在 AI 里，这张图有个正式名字：计算图（Computational Graph）。一个深度模型，无非就是由加法、乘法、矩阵运算、激活函数这些“食材加工步骤”串起来的大网。

计算图的节点是数值或运算，边是数据流动的方向。比如画一个最简单的模型 z = x * y + x：先做乘法得到中间值 m，再加 x 得 z。正向传播就是顺着箭头方向，从输入开始逐步算出每个节点值——就像厨师按流程一道道菜做出来。而反向模式的直觉恰恰相反：收银员不看怎么做菜，只看最终账单，逆着箭头往回走，问每一步：“这一步对最终价格的影响有多大？”

为了量化“影响有多大”，反向模式为每个节点定义一个伴随值（adjoint），记作 $\bar{v}_i$，表示输出对它的偏导数。核心递推公式是：

有了这张共享的菜谱流程图，大家不用重新点菜。收银员只要顺着图倒推一遍，就能把每个人的分摊金额算得清清楚楚。这个“顺着图倒推”的思维方式，是整个反向模式的灵魂。

链式法则基石

现在问题来了：总账单对“牛肉价格”的敏感度，怎么算？答案藏在菜谱的分层结构里。牛肉只影响牛排，牛排只影响套餐，套餐影响晚宴。所以“总账单对牛肉的敏感度”可以拆成三段相乘：总账单对套餐的敏感度 × 套餐对牛排的敏感度 × 牛排对牛肉的敏感度。这个连锁反应，在数学上叫链式法则（Chain Rule），是反向模式最底层的乘法口诀。

想象一根接力棒从输出端出发，向后传递“敏感度”。每一段只需要知道两件事：从上一棒接到的敏感度，以及自己这一段的局部导数，两者相乘传给下一棒。每个步骤都不用关心整张网络，只需处理眼前这一段“食材加工关系”——这正是链式法则最优雅的地方：局部计算，全局传递。

对于复合函数 $y = g(u)$ 且 $u = f(x)$，链式法则写成：

在反向模式中，链式法则被反复使用。每经过一个节点，就把接到的伴随值乘以该节点的局部导数，再继续往回传。餐厅后厨的任何一步加工，都可以用这根“敏感度接力棒”连接到总账单，于是每个食材的贡献率都清晰可见。

反向模式算法

现在我们把整套流程写下来，就像后厨的三步标准作业：先上菜，后收碗，再擦桌。第一步“上菜”是前向求值——按拓扑序从输入算到输出，同时把每个中间节点的值都存进“抽屉”，这些值是后面算局部导数时要用的“小票”。第二步“收碗”是反向遍历——从输出节点开始，沿逆拓扑序往输入方向走。第三步“擦桌”是整理梯度——每个节点把收到的伴随值汇总，就是它最终的梯度。

为什么一定要逆拓扑序？因为前向求值时，数据有严格先后依赖；反向传梯度时，必须保证一个节点在被处理时，它所有后继节点的伴随值都已经算完了。这就像收碗必须从最靠外的餐桌往回收，不能跳着收。

算法核心分三步：

整套操作下来，正向一遍求值、反向一遍传梯度，两个方向各扫一次计算图，所有参数的梯度就齐了。就像收银员只顺着流程图走一个来回，三十个人的分摊金额全部算清，谁也不用重新点菜。

前向模式对比

聚餐算账有两种方案。方案一叫前向模式（Forward Mode）：让每个人轮流“假装重新点一遍菜”，模拟出总价变化——这等价于对每个输入分别求一次导数。方案二叫反向模式：从总账单倒推，一次算出所有人对总价的敏感度。如果聚餐有 n 个人，方案一要模拟 n 遍；方案二只需要 1 遍倒推。

在数学上，前向模式计算的是雅可比向量积（Jacobian-vector product, JVP），每次运行对一个方向向量求方向导数；反向模式计算的是向量雅可比积（vector-Jacobian product, VJP）。两者的复杂度差异，完全由输入输出维度决定：

这就引出了深度学习里的“鸡生蛋问题”：大模型有几十亿参数（n），却只有一个损失值（m）。如果使用前向模式，每算一轮梯度就要跑几十亿遍网络，训练一次要等几百年；反向模式把代价压缩到“一遍前向 + 一遍反向”，训练才成为可能。所以深度学习框架清一色采用反向模式，这就是它成为“训练引擎标配”的根本原因。

内存与Checkpointing

反向模式有一个“甜蜜的代价”——它必须保存前向传播过程中的中间结果。为什么？因为反向传播梯度时，每个节点要计算局部导数 $\frac{\partial v_j}{\partial v_i}$，这需要用到前向时那个节点的输入值。想想后厨收碗：如果洗碗员想知道“这盘菜用了多少牛肉”，他必须保留做菜时的配料单。配料单越多，追溯越方便，但后厨空间也越紧张。

深度网络的层数动辄几十上百，每一层都要保存激活值；如果同时训练大批量数据，显存立刻告急。这时就要用到Checkpointing（检查点策略）：不在每一层都存“小票”，而是每隔几层存一张“汇总票据”。反向传播走到中间缺数据时，从最近的检查点重新做一遍前向，把缺的那几段“菜谱步骤”重跑出来。

如果计算图有 $T$ 层，每隔 $k$ 层设一个检查点，内存占用与时间开销的关系是：

这就像聪明的后厨只保留“每周采购汇总单”而不是每天的每张收据，需要细节时再去翻进货记录重算一遍。用时间换空间，是训练超大模型时常用的内存优化手段。PyTorch 的 activation checkpointing、DeepSpeed 的优化器状态切分，背后都是这个思路。

雅可比向量积VJP

如果想把整本账单的“价格联动关系”完整记录下来，可以画一张巨大的表：行是每道菜，列是每种食材，每个格子写着“某食材涨一块钱，这道菜涨多少钱”。这张表在数学上叫雅可比矩阵（Jacobian Matrix）。可惜，食材种类和菜品数量都是海量的，完整展开这张表根本存不下。

反向模式的高明之处在于：它从不展开雅可比矩阵，而是直接用雅可比向量积（VJP）来高效计算。想象你手里有一个“伴随向量” $v$，它记录了输出端每个分量的初始敏感度；把它左乘雅可比矩阵 $J$，得到的就是所有输入的梯度向量。一次矩阵向量乘法，所有答案全部得到：

回到聚餐比喻：雅可比矩阵是那本“全食材价格联动账本”，但没人会真的打印出来。VJP 就像只带着“当前最关心的几道菜”，沿着菜谱图逐层问“这道菜对周围的联动影响”，走过一遍就全算清楚了。这也是为什么现代自动微分库（如 PyTorch 的 autograd）都按 VJP 方式来组织反向实现。

实践与调试

收银员算完账，发现总额对不上——怎么办？最可靠的办法是对账：用另一种独立的方式估算账单，比如拿计算器把每道菜的价格重新加一遍，与系统账单对比。梯度校验（Gradient Checking）干的就是这件事：用数值差分近似计算梯度，再和反向模式算出的梯度对比，误差很小就说明反向实现正确。

数值差分的原理来自导数的定义：给输入 $x_i$ 一个很小的扰动 $\varepsilon$，观察输出变化量，用差分近似导数。把它与反向模式的解析梯度做差，如果误差小于阈值，就认为计算图实现无误：

实战中，梯度校验发现的大部分问题都来自三类：梯度累积未清零——相当于上一桌的账单没擦干净就记到下一桌；计算图被复用——同一份菜谱被改了配方，旧梯度和新梯度混在一起；数值溢出——中间值太大或太小，比如计算 $\exp$ 时上溢。工程上还常用算子融合、剔除零梯度分支等技巧，让反向模式在编译器层面跑得更快。对账通过，账单无误，大家才能安心开席。

AI 应用场景

Python 演示

class Var:    def __init__(self, value, children=(), grad_fn=''):        self.value = value        self.children = children        self.grad = 0.0        self.grad_fn = grad_fn     def __add__(self, other):        other = other if isinstance(other, Var) else Var(other)        return Var(self.value + other.value,                   children=[(self, 1.0), (other, 1.0)],                   grad_fn='add')     def __mul__(self, other):        other = other if isinstance(other, Var) else Var(other)        return Var(self.value * other.value,                   children=[(self, other.value), (other, self.value)],                   grad_fn='mul')     def backward(self, seed=1.0):        topo = []        visited = set()         def build(v):            if v not in visited:                visited.add(v)                for child, _ in v.children:                    build(child)                topo.append(v)         build(self)        self.grad = seed        for node in reversed(topo):            for child, local_grad in node.children:                child.grad += node.grad * local_grad  if __name__ == '__main__':    x = Var(2.0)    y = Var(3.0)    z = x * y + x  # z = x*y + x    z.backward()    print('z =', z.value)    print('dz/dx =', x.grad)    print('dz/dy =', y.grad)

1. children=[(self, 1.0), (other, 1.0)]加法节点记录两个子节点及各自的局部导数（1.0），就像菜谱上写着“这两步对总价的敏感度是 1”
2. def build(v)递归后序遍历生成拓扑序，保证反向时每个节点处理前其后继已处理完毕
3. self.grad = seed输出节点的伴随值初始化为 1，对应“总账单对自己的敏感度是 1”
4. for node in reversed(topo)逆拓扑序从输出向输入遍历，正是“收碗从最外层往回收”
5. child.grad += node.grad * local_grad链式法则接力 + 多路径梯度累加，一个 += 同时实现两件事

常见误区

面试题