自动微分：前向模式Forward Mode

可视化演示

前向模式初探

回到分拣中心。包裹从入口上线时被贴上一张跟单，上面最初只有一行字：“入口每多推一厘米，我现在的位置偏一厘米”——也就是导数值 1。包裹每经过一段传送带，操作员按照这段传送带的动作更新跟单：遇到“翻转方向”就换号乘系数，遇到“两条线合并”就把两路影响加起来。重点在于：包裹本身（值）和跟单（导数）从不分开，一起走完全程。这就是前向模式最朴素的定义——从输入端出发，沿计算方向同步求函数值和导数值。

技术上说，我们不再把“求导”当成一个独立的后处理步骤，而是把每个参与计算的变量扩展成一对数字：(值, 导数)。从输入变量开始，导数的初始值由“你想对谁求导”决定（想对哪个输入求偏导，就把它的导数分量设为1，其余为0），这个初始值称为种子。此后每执行一次运算，值按普通规则算，导数按微积分法则同步更新，直到输出端。

$$\dot{v}_i = \sum_{j < i} \frac{\partial v_i}{\partial v_j} \cdot \dot{v}_j$$

1. 灵敏度符号：$\dot{v}_i$ 表示节点 $v_i$ 对输入 $x$ 的导数。在流水线里，它就是跟单上“入口每多推一厘米，我在当前节点偏移多少”。

$$\dot{v}_i$$

2. 前驱集合：$j < i$ 表示所有直接参与计算出 $v_i$ 的上一级节点。如同传送带上紧挨着的前一段操作。

$$j < i$$

3. 局部导数：$\dfrac{\partial v_i}{\partial v_j}$ 是当前节点算子对它的某个输入的偏导。比如节点是乘法器 $v_i = v_j \cdot v_k$，对 $v_j$ 的局部导数就是另一个因子 $v_k$。

$$\frac{\partial v_i}{\partial v_j}$$

4. 相乘累加：把“局部导数 × 前驱跟单值”对每个前驱算一遍再加总，得到当前节点的总灵敏度。

$$\sum_{j < i} \frac{\partial v_i}{\partial v_j} \cdot \dot{v}_j$$

跟单从入口一路贴上出口，没有回头路，也没有重复劳动。这正是前向模式的优雅之处：一遍遍历，值和导数同时到站。

计算图基石

分拣中心不会把传送带随便接，主管手里有一张流水线图纸：每个圆圈代表一段操作（翻转、分流、合并），每条箭头代表包裹从一个操作流向另一个操作。这张图纸就是计算图——用有向无环图（DAG）描述“先算什么、再算什么”。节点是加减乘除等基本算子，边是数据依赖。

在计算图中，包裹的流动路径由拓扑顺序决定。所谓拓扑顺序，就是保证计算某个节点之前，它的所有前驱都已经算完。这就像流水线安装规则：前面的传送带不会依赖后面的机器。前向模式恰好沿这个拓扑顺序走一遍：走到哪个节点，就算这个节点的值和跟单，然后继续向后。整个过程不需要跳来跳去，也不需要反复扫描。

$$\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}$$

1. 中间变量：$\dfrac{du}{dx}$ 是中间变量 $u$ 对输入 $x$ 的导数，即跟单传进当前段之前的值。

$$\frac{du}{dx}$$

2. 输出对中间量：$\dfrac{dy}{du}$ 是本段算子对输入的局部导数，如同翻转机把 $u$ 的变化放大或缩小的系数。

$$\frac{dy}{du}$$

3. 乘积合成：两段相乘得到 $\dfrac{dy}{dx}$。它说明：整条线的总敏感度 = 每一段传送带敏感度的乘积。

$$\frac{dy}{du} \cdot \frac{du}{dx}$$

有了计算图这张“图纸”，前向模式就变成一个确定性流程：按拓扑顺序遍历节点，每处只更新一次跟单。图纸越清晰，遍历就越省力。

导数传播机制

跟单是如何在一段传送带上被更新的？假设当前段是一个乘法器：两个输入分别是 $a$ 和 $b$，输出是 $a \times b$。如果 $a$ 的跟单是“入口每推1厘米，$a$ 偏 $da$”，$b$ 的跟单是“入口每推1厘米，$b$ 偏 $db$”，那么输出值的偏移量按乘法法则就是 $a \cdot db + b \cdot da$。本质上，每一段都在做同一件事：用局部导数乘以前驱传来的灵敏度，再按节点规则相加。

这个机制在数学上有一个非常漂亮的载体——对偶数。对偶数写成 $a + b\varepsilon$ 的形式，其中 $a$ 是普通值，$b$ 是导数，$\varepsilon$ 是一个特殊记号，满足 $\varepsilon^2 = 0$。你只需要把普通运算的规则原样搬到对偶数上，导数就会像变魔术一样自动出现。

$$(a + b\varepsilon) \cdot (c + d\varepsilon) = ac + (ad + bc)\varepsilon$$

1. 值相乘：普通部分 $a \times c$ 作为结果的值，对应包裹在新位置的坐标。

$$a \cdot c$$

2. 交叉项：$a \cdot d\varepsilon + b \cdot c\varepsilon$ 是导数部分的贡献，来自“左值变动×右值”和“右值变动×左值”两条路径。这正是乘法法则 $f'g + fg'$。

$$(ad + bc)\varepsilon$$

3. 高阶项消失：$b\varepsilon \cdot d\varepsilon = bd \cdot \varepsilon^2 = 0$，因为 $\varepsilon^2 = 0$。这保证导数是精确的一阶结果，不含近似项。

$$bd\varepsilon^2 = 0$$

正因 $\varepsilon^2 = 0$，对偶数能在一次运算中同时携带“位置”与“灵敏度”，且不会有噪声。可以说，跟单不是额外派的人工，而是包裹自带的一张“芯片”。

前向反向对比

现在请出另一种求导思路——反向模式。如果说前向模式是“跟单随包裹走”，反向模式就是“事后追责专员”：货物在出口出了偏差，专员倒着走回流水线，逐段询问“你在哪一步受到过影响”。反向模式从输出出发，把误差信号（梯度）沿计算图倒推回每个输入。

两种模式各有代价。前向模式每播一次只服务“一个输入方向”：想求 $m$ 个输入各自的导数，就要播 $m$ 次。反向模式每播一次只服务“一个输出方向”：想求 $n$ 个输出对输入的完整导数，就要播 $n$ 次。于是有了著名的取舍法则：

$$T_{\text{forward}} = m \cdot O(|E|), \qquad T_{\text{backward}} = n \cdot O(|E|)$$

1. 边数成本：$O(|E|)$ 表示一次传播的成本约等于计算图的边数，即传送带段数。

$$O(|E|)$$

2. 输入维数：$m$ 是输入变量个数。前向模式需要 $m$ 次遍历，每次对应对一个输入方向的种子。

$$m \cdot O(|E|)$$

3. 输出维数：$n$ 是输出变量个数。反向模式需要 $n$ 次遍历，每次对应一个输出的梯度回传。

$$n \cdot O(|E|)$$

所以训练神经网络时，参数 $m$ 动辄上亿，而损失函数只有一个输出（$n=1$），反向模式完胜；反过来，当你要算“少数几个关键输入对成百上千个输出的影响”，前向模式反而更划算。跟单和追责，各有各的主场。

雅可比矩阵

现实中一个流水线往往有多条输入线、多个出货口。主管想系统性地回答：每个入口推一厘米，每个出口各偏多少？把答案排成一张表——行是出口，列是入口——就得到了雅可比矩阵。

前向模式天然是“填列”高手：播一次种（把某个入口的种子设为1，其余输入为0），跟单会传到所有出口，于是雅可比矩阵的一整列全部填好。重复 $m$ 次，矩阵就完整了。反向模式则相反，一次回传填一行（某个出口对所有输入的偏导）。这就是“前向填列、反向填行”的直觉记忆。

$$J_{\ast, i} = \begin{bmatrix} \dfrac{\partial f_1}{\partial x_i} \\ \dfrac{\partial f_2}{\partial x_i} \\ \vdots \\ \dfrac{\partial f_n}{\partial x_i} \end{bmatrix}$$

1. 第 $i$ 个输入：$x_i$ 是播种对象，种子导数设为1，代表“让这个入口以单位速度变化”。

$$x_i$$

2. 所有输出求偏导：$f_1, f_2, \ldots, f_n$ 是 $n$ 个出口的取值函数，跟单把灵敏度传到每一个出口。

$$\frac{\partial f_k}{\partial x_i}, \quad k = 1, \ldots, n$$

3. 列向量：把它们纵向排列就是矩阵第 $i$ 列。$m$ 次传播后，$m$ 列拼成完整雅可比矩阵。

$$\begin{bmatrix} \dfrac{\partial f_1}{\partial x_i} \\ \vdots \\ \dfrac{\partial f_n}{\partial x_i} \end{bmatrix}$$

如果雅可比矩阵是稀疏的——大部分入口对大部分出口没有影响——还可以结合图结构跳过无关路径。选对填表方式，比埋头硬算重要得多。

敏感性分析

分拣主管最关心风险管理：如果某个入口的推力波动了，哪些出货口的配送时效会大受影响？这本质上是敏感性分析——用导数衡量输出对输入的响应程度。由于通常只有少数几个关键参数（如温度、湿度、机器速度），却有大量监控指标，这正是前向模式的高光舞台：播种少量输入，一口气读出所有输出端的灵敏度。

直接读导数还不够直观，因为量纲不同：“温度每升1度，产出下降3件”和“速度每加1档，产出上升200件”很难直接比较。工程上常用弹性系数做归一化：

$$S = \frac{x}{y} \cdot \frac{\partial y}{\partial x}$$

1. 原始灵敏度：$\dfrac{\partial y}{\partial x}$ 是输出对输入的绝对变化率，也就是跟单上的原始数字。

$$\frac{\partial y}{\partial x}$$

2. 放大效应：乘上 $x$，强调取值较大的参数即便导数不大，也可能带来更大的绝对波动。

$$x \cdot \frac{\partial y}{\partial x}$$

3. 归一化：除以 $y$，得到“输入变动1%，输出变动百分之几”，使不同量纲的参数可以直接排序。

$$\frac{x}{y} \cdot \frac{\partial y}{\partial x}$$

把各参数的弹性系数排序，主管就能把有限的检修资源投给影响最大的环节。跟单不只是给工程师看的，更是给决策者看的报表。

工程实现

如何把“贴跟单”变成自动化的流水线？答案是对操作符重载：把浮点数替换成对偶数类型 Dual，加减乘除等运算符在内部同时更新值部分和导数部分。业务代码几乎不用改，只是把变量类型换一下，前面写的所有公式便自动生效。

在AI编译器和科学计算框架中，前向模式通常作为计算图的一种 切线模式 实现：对算子做 JVP（Jacobian-vector product，雅可比向量积）变换，把一个“扰动方向”从输入传到输出。编译器会做常量折叠和内联优化——跟单数字是0的变量在编译期就被剔除，减少运行时开销。

$$\frac{\partial y}{\partial x} = \frac{\partial f_k}{\partial v_{k-1}} \cdot \frac{\partial v_{k-1}}{\partial v_{k-2}} \cdots \frac{\partial v_1}{\partial x}$$

1. 路径展开：$v_1 \to v_2 \to \cdots \to v_k$ 是计算图上从输入到输出的一条路径。

$$v_1, v_2, \ldots, v_k$$

2. 逐段局部导数：每个 $\dfrac{\partial v_i}{\partial v_{i-1}}$ 是段内算子对输入的偏导，由重载运算符自动算出。

$$\frac{\partial v_i}{\partial v_{i-1}}$$

3. 连乘：所有局部导数连乘成总导数，这就是跟单一路累乘到底的数学形态。

$$\prod_{i=1}^{k} \frac{\partial v_i}{\partial v_{i-1}}$$

流水线一旦装上“自动贴单机”，工程师只需关心业务逻辑，求导变成数据类型的天然属性。这正是前向模式工程化的魅力：把数学藏进类型系统，让复杂机制对用户隐身。

AI 应用场景

Python 演示

class Dual:    """对偶数：值为 value，导数为 derivative。"""     def __init__(self, value=0.0, derivative=1.0):        self.value = value        self.derivative = derivative     def __add__(self, other):        if isinstance(other, Dual):            return Dual(self.value + other.value,                        self.derivative + other.derivative)        return Dual(self.value + other, self.derivative)     def __radd__(self, other):        return self.__add__(other)     def __sub__(self, other):        if isinstance(other, Dual):            return Dual(self.value - other.value,                        self.derivative - other.derivative)        return Dual(self.value - other, self.derivative)     def __mul__(self, other):        if isinstance(other, Dual):            return Dual(self.value * other.value,                        self.derivative * other.value +                        self.value * other.derivative)        return Dual(self.value * other, self.derivative * other)     def __rmul__(self, other):        return self.__mul__(other)     def __pow__(self, n):        return Dual(self.value ** n,                    n * self.value ** (n - 1) * self.derivative)  def f(x):    """示例函数：f(x) = (x + 2)^2 * 3 - 5，导数应为 6*(x+2)。"""    return (x + 2) ** 2 * 3 - 5  def f_vec(x0, x1):    """向量函数：f = [x0^2 + 3*x1, x0*x1]。"""    return [x0 * x0 + 3 * x1, x0 * x1]  if __name__ == "__main__":    x = Dual(2.0, 1.0)  # 种子：对 x 求导    y = f(x)    print("f(2) =", y.value)    print("f'(2) =", y.derivative)  # 应为 24     # 计算雅可比矩阵第 1 列：对 x0 求偏导    a = Dual(2.0, 1.0)    b = Dual(1.0, 0.0)    out = f_vec(a, b)    print("Jacobian 第1列:", [o.derivative for o in out])     # 第 2 列：对 x1 求偏导    a = Dual(2.0, 0.0)    b = Dual(1.0, 1.0)    out = f_vec(a, b)    print("Jacobian 第2列:", [o.derivative for o in out])

1. class Dual:定义对偶数类型，每个数自带 value 和 derivative 两个字段，相当于“包裹 + 跟单”。
2. __add__重载加法：值相加，导数也相加（和的导数等于导数之和）。
3. __mul__乘法法则：f'g + fg'，对应跟单在两个输入相乘时的交叉更新规则。
4. __pow__幂运算 x^n 的导数为 n*x^(n-1)，自动乘上已有的导数。
5. Dual(2.0, 1.0)播种：把输入值设为2，种子导数设为1，表示“就对这个变量求导”。
6. y.derivative取最终跟单数字，即想要的导数值。

常见误区

面试题