自动微分：让框架替你算梯度

可视化演示

动态演示自动微分的核心机制，通过入门/进阶/实战/优化四种模式展示关键概念与交互流程。

计算图构建

甜品老师傅在教你做蛋糕时，第一步不是动手，而是把整个流程画成一张图：面粉 → 混合 → 打发 → 水浴 → 烘烤 → 成品。每一步谁先谁后、谁需要哪个中间产物，一目了然。深度学习里的“烘焙流程”同样复杂：输入经过线性变换、激活、归一化、卷积……层与层之间互相依赖。自动微分要做的第一件事，就是把这套流程画成一张计算图。

计算图是一种有向无环图（DAG）：节点代表一个张量（中间计算结果），边代表一次运算（加、乘、卷积等）。比如函数 $y = x^2 + 1$，可以拆成三个节点——输入 $x$、中间结果 $x^2$、最终输出 $y$，中间用“平方”和“加一”两条运算边连接。框架执行前向计算时，会先对图做拓扑排序，保证每个节点计算时，它的所有输入都已经算好。

$$\displaystyle y = f_3\big(f_2(f_1(x))\big)$$

1. 最内层函数 $f_1$：输入 $x$ 首先经过第一个变换，得到中间量 $a$。

$$\displaystyle a = f_1(x)$$

2. 中间层函数 $f_2$：上一步的中间量 $a$ 继续作为输入，得到新的中间量 $b$。

$$\displaystyle b = f_2(a) = f_2(f_1(x))$$

3. 最外层函数 $f_3$：最后输出 $y$ 等于第三层函数作用于 $b$。

$$\displaystyle y = f_3(b) = f_3(f_2(f_1(x)))$$

有了这张“配方流程图”，烘焙助理才能知道：从成品倒推回去时，每一步该走哪条路、该找哪个中间值。计算图，就是自动微分的地图——有了地图，导航（求导）才成为可能。

链式法则

蛋糕的甜度变化像玩“悄悄话”游戏：你给第一个人递一张纸条，他按自己的理解加工后传给下一个，每传一环，内容都会被“放大”或“缩小”一点点。最终蛋糕的口感变化，等于每一环变化率的乘积。数学上，这就是复合函数求导的核心——链式法则。

假设口感分数 $z$ 由焦糖层质量 $y$ 决定，而 $y$ 由白砂糖用量 $x$ 决定。你想知道“多加一勺糖，口感分数变多少”，不能只看 $x \to y$ 这一段，还得乘上 $y \to z$ 这一段。中间的每一环影响都要乘进去，就像传话游戏的每一环折扣都要叠乘。

$$\displaystyle \frac{dz}{dx} = \frac{dz}{dy} \cdot \frac{dy}{dx}$$

1. 先求“输出对中间量”的导数：衡量 $y$ 变化一个单位时，$z$ 变化多少。

$$\displaystyle \frac{dz}{dy}$$

2. 再求“中间量对输入”的导数：衡量 $x$ 变化一个单位时，$y$ 变化多少。

$$\displaystyle \frac{dy}{dx}$$

3. 两者相乘：把两段影响串联起来，就得到 $x$ 对最终输出 $z$ 的总影响。

$$\displaystyle \frac{dz}{dx} = \frac{dz}{dy} \times \frac{dy}{dx}$$

链式法则像是传话游戏里的“传递系数”：每一环的放大或缩小比例相乘，最后得到总效应。自动微分之所以能处理几百层的网络，就是靠这条规则把每层的局部导数逐环串起来。

前向模式

如果配方里只有一种原料不确定，你会怎么做？最笨但可靠的办法是：每次只改这一种原料，重新做一遍蛋糕，观察分数变化。自动微分里的前向模式就像这个“一次只盯一个变量”的做法——它给某一个输入$x_i$带上一个“导数种子”，然后沿着计算图从输入往输出正向传播，每经过一个运算，就同步更新这个导数。

前向模式的核心是“原始-对偶”思想：每个值不只记本身，还额外记一个“对某个输入的导数”。比如对 $v = x^2$，它不仅算出结果 $v$，还同时算出 $\dot{v} = 2x\dot{x}$，这个 $\dot{x}$ 就是种子（初始设为 1）。这样一路走完，就得到了所有中间量对 $x$ 的导数。

$$\displaystyle \dot{v} = 2x \cdot \dot{x} \quad \text{（$v=x^2$ 时的前向导数）}$$

1. 设置种子：令 $\dot{x}=1$，表示我们正在对输入 $x$ 求导。

$$\displaystyle \dot{x} = 1$$

2. 逐运算传播：每个中间节点 $v=x^2$ 的导数由数学求导规则得到。

$$\displaystyle \dot{v} = 2x \cdot \dot{x}$$

3. 替换并计算：把当前的 $x$ 值和 $\dot{x}$ 值代入，即可得到 $\dot{v}$ 的数值。

$$\displaystyle \dot{v} = 2 \times 2 \times 1 = 4$$

前向模式“每改一个输入就要重走一遍图”，所以它适合输入维度很小的场景。如果你的模型只有几个输入、却有成千上万的输出，前向模式反而高效。但反过来说，深度学习里输入通常是百万级参数，前向模式就力不从心了。

反向模式

真正高明的烘焙师不会一次次重做蛋糕。他等蛋糕出炉、试味打分之后，从成品口感一路往回倒推：口感偏甜了？那问题可能出在糖量；糖量没问题？再往前查焦糖时间……每一环只需要查一次，所有原料的影响就都能算清楚。这就是反向模式——也是深度学习里大名鼎鼎的“反向传播”。

反向模式分两步走：第一步，正向执行计算图，算出每个中间值并缓存；第二步，从输出出发，利用链式法则把“损失 $L$ 对每个节点”的偏导从后往前逐层回传。无论中间有多少个节点，整个过程只需一次正向 + 一次反向，就能得到损失对所有参数的梯度。

$$\displaystyle \frac{\partial L}{\partial x} = \frac{\partial L}{\partial v} \cdot \frac{\partial v}{\partial x}$$

1. 正向缓存：先走一遍计算图，保存每个中间值 $v$，以备反向使用。

$$\displaystyle v = x^2,\quad L = v + 1$$

2. 反向起步：令输出对自身的导数为 $1$，即 $\bar{L}=1$，作为回传的起点。

$$\displaystyle \bar{L} = \frac{\partial L}{\partial L} = 1$$

3. 逐层回传：用链式法则把梯度乘到上游节点的局部导数上，例如对 $v$ 传回 $\bar{v} = \bar{L}\cdot\frac{\partial L}{\partial v}$，再对 $x$ 传回 $\bar{x} = \bar{v}\cdot\frac{\partial v}{\partial x}$。

$$\displaystyle \bar{x} = \bar{L}\cdot\frac{\partial L}{\partial v}\cdot\frac{\partial v}{\partial x}$$

反向模式的高明之处在于“一次倒推，全部算清”。训练神经网络时，损失 $L$ 是一个标量（单个数值），输出维度为 1——完美契合反向模式“输出少、输入多”的长处。这也是 PyTorch 中 loss.backward() 一次调用就能算出全部参数梯度的秘密。

雅可比矩阵

当配方变得复杂——比如同时改变面粉、糖、黄油三种原料（三个输入），又要同时观察蛋糕的甜度、硬度、湿润度（三个输出）——单条链式法则就不够用了。这时你需要一张大表：行是每个输出，列是每个输入，表格里每一格填“这个输入变化一点点，那个输出变化多少”。这张表在数学上就叫雅可比矩阵。

雅可比矩阵把前向和反向模式统一了起来。前向模式一次遍历，相当于“矩阵乘以一个向量”——得到的是某一列（某个输入对所有输出的影响）；反向模式一次遍历，相当于“一个向量乘以矩阵”——得到的是某一行（所有输入对某个输出的影响）。因此，选哪种模式，本质上是看你想填充矩阵的列还是行。

$$\displaystyle J = \frac{\partial(y_1,\dots,y_m)}{\partial(x_1,\dots,x_n)} = \begin{pmatrix} \frac{\partial y_1}{\partial x_1} & \cdots & \frac{\partial y_1}{\partial x_n} \\ \vdots & \ddots & \vdots \\ \frac{\partial y_m}{\partial x_1} & \cdots & \frac{\partial y_m}{\partial x_n} \end{pmatrix}$$

1. 确定维度：有 $n$ 个输入、$m$ 个输出，矩阵规模就是 $m$ 行 $n$ 列。

$$\displaystyle J \in \mathbb{R}^{m\times n}$$

2. 填充每个偏导：第 $i$ 行第 $j$ 列元素是偏导数 $\partial y_i / \partial x_j$，描述单点影响。

$$\displaystyle J_{ij} = \frac{\partial y_i}{\partial x_j}$$

3. 与模式对应：前向模式是 $J$ 右乘向量（求一列），反向模式是向量左乘 $J$（求一行）。

$$\displaystyle J \cdot \mathbf{v} \quad \text{vs} \quad \mathbf{u}^{\top} J$$

这张“影响大表”点明了自动微分的关键权衡：存整张表很贵，但大多数场景我们只需要一行——损失对每个参数的梯度。所以反向模式成为深度学习的默认选择，而雅可比矩阵则是理解两种模式如何分工的数学透镜。

梯度检查点

如果蛋糕配方长达几千步，烘焙助理每走一步都把半成品拍照存档，仓库很快就会塞满。聪明的做法是：只在大步骤（比如每 10 步）设置一个“驿站快照”，中间过程不存档；需要回溯时，从最近的驿站重新走一遍到目标步骤。这就是梯度检查点（Checkpointing）的核心思想——用一点重算时间，换取大量内存。

训练深层神经网络时，反向传播需要所有中间激活值来计算梯度。如果网络有 1000 层，正向时把每一层的激活都存下来，显存直接爆满。梯度检查点策略只保存一部分层（检查点）的激活，其余层在反向时重新正向计算一次，从而大幅降低显存占用。

$$\displaystyle M_{\text{checkpoint}} = O(\sqrt{L}) \quad \text{vs} \quad M_{\text{full}} = O(L)$$

1. 全程存储的代价：反向需要每一层的中间激活，内存与层数 $L$ 成正比。

$$\displaystyle M_{\text{full}} = O(L)$$

2. 分段存储省内存：每 $\sqrt{L}$ 层设一个检查点，内存约为检查点数量乘以每段存储量。

$$\displaystyle M_{\text{checkpoint}} = O(\sqrt{L})$$

3. 用时间换空间：反向时检查点之间的层需要重新计算，总时间约增加一倍，但显存大幅下降。

$$\displaystyle T_{\text{total}} \approx T_{\text{forward}} + T_{\text{recompute}}$$

训练超大模型时，显存往往比算力更稀缺。梯度检查点就像长途运输中的“周转仓库”——不全程囤货，只在关键节点中转，需要时再回头补货。从检查点到重算，就是典型的时空权衡。

框架实现

终于轮到你的“智能烘焙助理”登场了。在 PyTorch 中，一切求导魔法都围绕 Tensor 展开：当你设置 requires_grad=True 时，框架就开始自动记账——每次运算都在背后偷偷建立计算图节点；当你调用 loss.backward() 时，助理从成品（损失）出发，沿着记账本反向走一遍，把梯度填到每个 Tensor 的 .grad 属性里。

自动微分的框架实现高度模块化：Tensor 层负责记录数据和追踪运算；autograd 引擎负责维护计算图和调度反向；每个算子都注册了自己的“局部反向函数”，反向时逐层调用。框架还会做梯度累积——如果一个节点被多条路径使用，它的梯度会把所有路径传来的梯度加起来，因为链式法则对多元路径求和。

$$\displaystyle \frac{\partial L}{\partial v} = \sum_{u \in \operatorname{succ}(v)} \frac{\partial L}{\partial u} \cdot \frac{\partial u}{\partial v}$$

1. 找下游节点：枚举所有直接使用 $v$ 的后继节点 $u$。

$$\displaystyle u \in \operatorname{succ}(v)$$

2. 算每条路径贡献：对每个 $u$，梯度贡献等于 $L$ 对 $u$ 的梯度乘以 $u$ 对 $v$ 的局部导数。

$$\displaystyle \frac{\partial L}{\partial u} \cdot \frac{\partial u}{\partial v}$$

3. 汇总求和：把所有路径的贡献相加，得到 $v$ 的总梯度。

$$\displaystyle \frac{\partial L}{\partial v} = \sum_{u} \frac{\partial L}{\partial u} \cdot \frac{\partial u}{\partial v}$$

理解了框架的记账逻辑，你就明白了为什么每次训练要调用 optimizer.zero_grad()——因为框架只负责累加梯度，不会自动清零上一轮的旧账。也明白了为什么自定义算子时要实现“前向 + 反向”两个函数：前向供计算图记录，反向供引擎回传。自动化程度再高，原理始终是那条链式法则。

三种微分对比

市面上的“求导方案”有三种，可以类比成三种做蛋糕的方式。数值微分：每次试吃微调，用“多加一勺和少加一勺的分数差”来估算影响，简单但粗糙，还有截断误差。符号微分：把整个配方的数学公式完整写出来，再对公式做符号化简求导，思路清晰但公式会随步骤增多爆炸式膨胀。自动微分：像记账员一样按流程图逐步记录每个运算的导数，既不写大公式，也不算近似值——精确又高效。

$$\displaystyle f'(x) \approx \frac{f(x+h) - f(x-h)}{2h}$$

1. 选一个小步长：$h$ 是一个很小的增量，比如 $10^{-6}$。

$$\displaystyle h = 10^{-6}$$

2. 算两侧函数值：分别计算 $f(x+h)$ 和 $f(x-h)$。

$$\displaystyle f(x+h), \quad f(x-h)$$

3. 做差分取平均：两值之差除以 $2h$，近似得到 $f'(x)$。

$$\displaystyle f'(x) \approx \frac{f(x+h) - f(x-h)}{2h}$$

三种方式各有千秋，但深度学习选择了自动微分：数值微分只能用来“验证梯度是否正确”，符号微分不适合复杂计算图，而自动微分既有解析的精确度，又有数值的高效性。它不去写整本菜谱，只是默默记好每一笔账——这就是现代深度学习框架统一的求导方案。

AI 应用场景

Python 演示

class Value:    """自动微分标量节点：记录数据、梯度与局部反向函数"""     def __init__(self, data, children=(), op=''):        self.data = data        self.grad = 0.0        self._children = set(children)        self._op = op        self._backward = lambda: None     def __add__(self, other):        other = other if isinstance(other, Value) else Value(other)        out = Value(self.data + other.data, (self, other), '+')         def _backward():            self.grad += out.grad            other.grad += out.grad        out._backward = _backward        return out     def __mul__(self, other):        other = other if isinstance(other, Value) else Value(other)        out = Value(self.data * other.data, (self, other), '*')         def _backward():            self.grad += other.data * out.grad            other.grad += self.data * out.grad        out._backward = _backward        return out     def relu(self):        out = Value(max(0.0, self.data), (self,), 'relu')         def _backward():            self.grad += (out.data > 0) * out.grad        out._backward = _backward        return out     def backward(self):        topo = []        visited = set()         def build_topo(v):            if v not in visited:                visited.add(v)                for child in v._children:                    build_topo(child)                topo.append(v)        build_topo(self)        self.grad = 1.0        for node in reversed(topo):            node._backward()  if __name__ == '__main__':    x = Value(2.0)    y = x * x + 1          # y = x^2 + 1    y.backward()    print('y =', y.data)    print('dy/dx =', x.grad)   # 期望 4.0

1. self.data = data存张量的数值；self.grad = 0.0 — 存累积梯度，对应框架里 Tensor 的 .grad 属性。
2. self._backward = lambda: None每个节点默认没有反向函数，运算时会替换为真正的局部反向逻辑。
3. def __add__重载 + 运算符：前向算出 out.data，同时把两个子节点登记到 _children，相当于给计算图加了一条“加法边”。
4. out._backward = _backward注册反向函数：加法把输出梯度原样传给两个输入，实现 $\bar{x}=\bar{y}$。
5. def __mul__乘法反向按链式法则：self.grad += other.data * out.grad，对应 $\bar{x}=\bar{v}\cdot y$。
6. build_topo(self)深度优先遍历子节点完成拓扑排序，确保反向时每个节点的梯度都已就绪。
7. self.grad = 1.0反向起点：输出对自身的导数为 1，就像反向模式从损失函数出发。
8. for node in reversed(topo): node._backward()按拓扑逆序逐节点回传梯度，这就是框架 loss.backward() 的本质。

常见误区

面试题