自动微分：反向模式

可视化演示

展示反向模式自动微分三维度：前向-后向传播流程（前向按拓扑序执行运算记录值和梯度函数后向从输出出发反向遍历计算图逐节点用链式法则传播梯度）、向量-雅可比乘积VJP（每个节点梯度=上游梯度×局部雅可比转置VJP避免显式构造雅可比矩阵时间复杂度O(1）每节点)、前向vs反向模式对比（前向模式n个输入需n次pass适合少输入多输出反向模式m个输出需1次pass适合多输入少输出深度学习n远大于m反向模式最优）,三模式切换理解自动微分引擎核心机制。

计算图构建：先画一张快递转运图

小林接手第一天，先做了一件事：把园区所有线路画成一张图。仓库是起点，客户是终点，中间的每个分拣口都是一个圆圈；箭头表示包裹接下来往哪走。快递业务可以外包，但追责必须依赖这张图。自动微分也一样，第一步不是求导，而是把目标函数拆成一张计算图。

计算图用节点表示数值或运算，用有向边表示数据流向。比如 y = w·x + b 会被拆成乘法节点和加法节点。每一步运算的结果——中间激活值——都会被记录下来，因为反向模式倒查时需要它们作为“本地小票”。

在框架里，每个节点是一个基础算子，允许的运算只有加、乘、求幂等可微原语。前向求值就是从输入节点出发，按拓扑序逐个执行节点，算出输出并保存中间值。自动微分引擎不需要研究者手写梯度，只要图存在，梯度传播路径就存在。

画完图后，小林还特意在每条边上标了箭头方向。因为他知道，等会儿追责时必须逆着箭头走；图一旦画错，整条追责链都会断。

链式法则：一份追责令的拆分规则

客户投诉不是只由最后一个分拣口造成，而是整条线路逐级放大。小林手里的追责令写着一句话：每一站只能把上一站的改动放大或缩小；把沿途的放大倍数乘起来，就是源头应有的责任。这就是链式法则的直觉。

数学上，复合函数 y = f(g(x)) 对 x 的导数不是直接算出来的，而是先看 y 对 g 的敏感度，再看 g 对 x 的敏感度，两者相乘。反向模式把这条规则递归地用在计算图中，每个节点只需处理一个“责任系数”。

具体来说，设输出为 y，经过 n 个中间节点到达输入 x，则梯度是一串局部导数连乘。反向模式并不一次性展开整串式子，而是从后往前依次乘以局部导数，因此每个节点只做一次乘法、一次本地求导。

有了链式法则，小林不需要懂得每台机器的内部机械结构，只要每个分拣口能报告“货物数量变化时我放大了几倍”，追责令就能一路传回源头。

反向传播顺序：逆着箭头一站站往回走

小林明确了追责令的算法：先到离终点最近的环节，再逆着箭头向源头推进。如果先查源头，中间环节还没传出系数，查到也白查。所以，正确顺序是计算图的拓扑逆序。

反向模式的每一步都在回答：当前节点应该把多少梯度传给它的每个输入？设节点 j 是节点 i 的下游，节点 j 的梯度为 ∂L/∂a_j，那么节点 i 应从这条边收到 ∂L/∂a_j × ∂a_j/∂a_i。若 i 有多个下游，收到的梯度必须相加。

这里的加法不是可选项。一个变量可能被多个下游运算共同使用，例如在 y = u + v 中，u 可能同时参与了别的计算；反向传播必须把来自不同下游的贡献累加到一起，否则梯度就会漏算。

当追责令走到输入节点 x 时，\bar{x} 就是损失对 x 的全部偏导。小林把结果写在追责单最上方，交给对应仓库，整个反向模式就算完成了一次全链路倒查。

雅可比转置向量积：不展开整张矩阵的聪明账本

当输入和输出都是向量时，小林面对的就不是一张张单独的追责单，而是一沓投诉清单。理论上，每一站都要维护一张“放大倍数表”——雅可比矩阵。如果输入有一百万维，这张表就有百万行，根本记不下。

反向模式的聪明之处在于：它从来不需要把雅可比矩阵完整建出来。它只需要计算“雅可比矩阵的转置”乘上“下游传来的梯度向量”，即 VJP。这个操作可以用一次轻量级局部计算完成，复杂度与算子本身结构有关，而不是先拼出整个大矩阵再相乘。

设 L 是最终标量损失，y ∈ R^m 是某个节点的输出，x ∈ R^n 是该节点的输入，则当 \bar{y} 已知时，反向传播要算的就是 \bar{x} = J^T \bar{y}。每个基础算子都会提供一个 VJP 函数，反向模式沿图调用这些函数即可，完全不需要接触完整雅可比矩阵。

在小林眼里，VJP 就是站点只关心“进来的多张追责单该如何分摊到出去的几个变量上”，绝不在墙上贴满所有输入输出组合的表格。框架把这一笔聪明账内置在每个算子中，反向传播因此又快又省。

内存与开销：追责单不能凭空生成

小林很快发现，反向模式不是免费的。为了让追责令沿路传回，每一站都必须保留前向时收到的包裹记录；如果中途把中转货场清空，倒查时就没有数据可依据。因此，反向模式的内存开销往往与中间节点数量成正比。

训练神经网络时，前向传播保存的中间激活量占显存大头，反向传播需要这些值来求局部导数。假设有 N 个可微算子，前向和反向各扫描一次计算图，所以时间开销大约是正向计算的 2 到 3 倍；内存则与所有中间张量大小之和成正比。

这与前向模式形成对比。前向模式沿箭头方向传播方向导数，每个方向只需保存当前导数，内存占用通常较小，但计算次数随输入维度增长。反向模式适合“输入极多、输出极少”的场景，而深度学习损失函数恰好只输出一个标量，所以它成为训练引擎的默认选择。

理解了这笔账，小林不再抱怨显存不够。反向模式像一次需要完整台账的审计：账记得越细，倒查越方便，但仓库也越挤。后面所有优化，本质上都是在“记多少账”和“重新跑多少路”之间找平衡。

实践优化：让倒查更快更省

为了在显存有限的背景下训练大模型，小林学会了“检查点”：他不再每站都留记录，而是每隔几站存一份快照。倒查时如果发现某段没有台账，就从最近的快照重新跑一次前向，现场补齐这一段记录。这就是梯度检查点技术。

代价很明显：内存下降，但计算增多。实际工程中还常用算子融合来减少中间张量的落盘、用混合精度减少每个张量的占用、用梯度累积在通信瓶颈下保持有效批量大小。深度学习框架默认用反向模式实现 autograd，同时向开发者开放这些优化开关。

AI 编译器把反向模式视作一张可以变换的计算图：先由高层框架生成反向子图，再由编译器做算子融合、内存规划和并行调度。未来趋势是自动选择前向、反向或混合模式，甚至用动态规划寻找最优检查点位置，让倒查策略随硬件自动调整。

若干年后，小林把整套倒查机制做成了一个自动调度系统：开发者只描述业务，剩下怎么记台账、怎么选路线、怎么调存储，都由系统自动决定。这就是反向模式从算法走向工程后最有价值的样子。

AI 应用场景

Python 演示

class Var:    def __init__(self, value, parents=None, grad_fn=None):        self.value = value        self.grad = 0.0        self.parents = parents if parents is not None else []        self.grad_fn = grad_fn     def __add__(self, other):        other = _to_var(other)         def grad_fn(g):            return [(self, g), (other, g)]         return Var(self.value + other.value, [self, other], grad_fn)     def __mul__(self, other):        other = _to_var(other)         def grad_fn(g):            return [(self, other.value * g), (other, self.value * g)]         return Var(self.value * other.value, [self, other], grad_fn)     def relu(self):        def grad_fn(g):            return [(self, g if self.value > 0.0 else 0.0)]         return Var(self.value if self.value > 0.0 else 0.0, [self], grad_fn)     def backward(self, seed=1.0):        topo = []        seen = set()         def dfs(v):            if id(v) in seen:                return            seen.add(id(v))            for p in v.parents:                dfs(p)            topo.append(v)         dfs(self)        self.grad = seed        for v in reversed(topo):            if v.grad_fn is not None:                for parent, contrib in v.grad_fn(v.grad):                    parent.grad += contrib  def _to_var(x):    if isinstance(x, (int, float)):        return Var(float(x))    return x  def main():    x = Var(2.0)    w = Var(3.0)    b = Var(1.0)    y = (w * x + b).relu()    y.backward()    print("y =", y.value)    print("dx =", x.grad, "dw =", w.grad, "db =", b.grad)  if __name__ == "__main__":    main()

1. self.parents = parents if parents is not None else []记录当前节点的计算图父节点，相当于快递线路上的上游站点。
2. def grad_fn(g): return [(self, other.value * g), (other, self.value * g)]乘法算子的 VJP，把下游梯度乘以另一个输入值后回传。
3. dfs(self)` 配合 `topo.append(v)用深度优先搜索生成拓扑序，保证反向时先处理输出节点。
4. for v in reversed(topo)从输出开始按拓扑逆序回传，正是反向模式的核心顺序。
5. parent.grad += contrib把来自不同下游的贡献累加到父节点上，防止多路径梯度漏算。

常见误区

面试题