想象你经营一家「配方工厂」：多种原料经过若干道工序，最终变成一种产品。老板想知道，如果某种原料多放 1%，最终产品会多变化多少？这种「变化的敏感度」就是数学里的导数。传统学徒要么靠一次次试错（数值微分），要么靠纸笔硬推公式（符号微分），既慢又容易出错。而自动微分就像在工厂流水线上安装了高精度传感器——机器运转的同时，就能实时、精确地记录每一道工序对原料的敏感度。不过，安装传感器有两种完全不同的策略：一种是从每个原料出发，派「信使」顺着流水线一路测量；另一种是先走一遍全程记住路线，再从成品那边倒推回来。这就是今天的主角：前向模式与反向模式。读懂它们，你就掌握了深度学习梯度计算的核心密码。

岗位关联

对于 AI 从业者，理解前向与反向模式能让你看穿 PyTorch、TensorFlow 底层的梯度引擎，知道为什么深度学习非反向模式不可，以及何时反向模式反而吃亏，从而在模型训练、推理优化中做出正确的决策。

目录
  1. 可视化演示
  2. 自动微分概述
  3. 链式法则基础
  4. 雅可比矩阵
  5. 前向模式
  6. 反向模式
  7. 模式对比
  8. 深度学习选型
  9. 实战选择
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

动态演示自动微分模式的核心机制，通过采集/分析/决策/反馈四种模式展示关键概念与交互流程。

本节配有交互动效（进入视口后自动加载，约 3KB）。

自动微分模式：自动微分 自动微分（前向/反向模式）概述 自动微分（前向/反向模式）原理 核心机制可视化 自动微分模式整体架构与关键组件

自动微分概述

在配方工厂最初的日子里，老师傅们想要知道原料变化对产品的影响，只能靠「试错法」：把某一种原料多加一点点，看看产品变化多少。这就像数值微分——用一个小增量 h 去近似导数，总有截断误差，就像量杯刻度不够精细，读出来的数字永远差一截。后来有了符号微分，相当于请一位数学家把整个配方公式抄在纸上，一步一步手动化简求导，但配方一复杂，纸上的公式就会爆炸成一座「符号山」，根本看不完。

自动微分换了一种思路：它不追求拿到一张庞大的公式纸条，而是在配方实际运转的过程中，沿着从原料到成品的每一步工序，把「局部变化率」一个接一个精确地乘起来。工厂里每一道工序都被理解成计算图上的一个节点——原料是输入节点，半成品是中间节点，成品是输出节点。自动微分做的，就是在这张图上传播敏感度，既不需要近似，也不需要展开公式。

数学上，自动微分直接依托链式法则来计算复合函数的导数。设想一条最简单的流水线：原料 x 先变成半成品 u，再由 u 变成最终产品 y，那么整条流水线的敏感度就是两段工序局部敏感度的乘积：

有了这个基础，自动微分就像给工厂安装了一套「万能传感器」：你永远不需要手推公式，也不需要做近似，只需要沿着计算图把局部导数乘下去。

dydx=dydu⋅dudx\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}
整体变化率 = 第二道工序对半成品的敏感度 × 第一道工序对原料的敏感度，这就是链式法则的乘法本质。
  1. 拆解复合关系先明确 y 是 u 的函数，u 是 x 的函数，这样整条链才能用乘法连接。
    dydx=dydu⋅dudx\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}
  2. 取局部导数分别计算每一段工序的局部导数，即 dy/du 和 du/dx，它们只关心自己这一步的输入输出。
    dudx=u′(x),dydu=y′(u)\frac{du}{dx} = u'(x), \quad \frac{dy}{du} = y'(u)
  3. 相乘得到整体把两个局部敏感度乘起来，得到原料到成品的总敏感度。
    y′(x)=y′(u(x))⋅u′(x)y'(x) = y'(u(x)) \cdot u'(x)

链式法则基础

现在我们把工厂流水线画成一张地图：原料罐是起点，成品仓是终点，每个阀门和搅拌器都是地图上的节点。链式法则告诉我们，一条路径上最终的变化率，等于经过的每一个节点的「局部变化率」的乘积。就像物流信使每穿过一道关卡，都要盖一个「敏感度戳」，盖完全部的章，乘积就是整条路的总敏感度。

在计算图中，每个节点都代表一次运算：加法、乘法、激活函数等。节点只知道自己的输入和输出，于是它可以计算一个「局部导数」——输出对自己输入的偏导。比如一个乘法节点 u = x1 * x2，它对 x1 的局部导数是 x2，对 x2 的局部导数是 x1。这种局部信息完全独立，不需要关心上游或下游长什么样。

自动微分巧妙地把这些局部导数按路径组合起来：从输入到输出的每条路径上，把所有局部导数相乘，如果有多条路径，再把各路径的贡献相加。这就是链式法则在计算图上的完整形态。以 y = f(g(x)) 为例，计算图上只有 x → u → y 一条路径，所以只需要做一次乘法。

回到工厂比喻：只要每个工序都愿意交出「局部敏感度」，自动微分就能像拼乐高一样，把整个流水线的总敏感度精确拼出来。这就是它既不吃近似误差、又不被符号爆炸困扰的秘密。

∂y∂x=∑路径 p(∏边 e∈p∂后继∂前驱)\frac{\partial y}{\partial x} = \sum_{\text{路径 } p} \left( \prod_{\text{边 } e \in p} \frac{\partial \text{后继}}{\partial \text{前驱}} \right)
多路径求和，单路径求积——链式法则在计算图上就是「路径的乘积之和」。
  1. 标记计算图把复合函数拆成节点和边，每条边代表一次基本运算。
    x→u→yx \rightarrow u \rightarrow y
  2. 计算每一条边的局部导数对每条边 a → b，求 b 对 a 的偏导数。
    ∂u∂x,∂y∂u\frac{\partial u}{\partial x}, \quad \frac{\partial y}{\partial u}
  3. 组合路径路径上的局部导数相乘；若存在多条路径通向同一节点，则求和。
    ∂y∂x=∂y∂u⋅∂u∂x\frac{\partial y}{\partial x} = \frac{\partial y}{\partial u} \cdot \frac{\partial u}{\partial x}

雅可比矩阵

配方工厂可能同时生产多种产品，比如同时产出洗发水和护发素。这时老板想知道每一种原料对每一种产品的影响，光靠一个数就不够了，需要一张「敏感性台账」——所有产品变化率对原料变化率的全表。这张表在数学上就是雅可比矩阵。

假设有 m 种原料（输入向量 x ∈ R^m）和 n 种产品（输出向量 y ∈ R^n），那么雅可比矩阵 J 是一个 n × m 的矩阵，第 i 行第 j 列的元素就是第 i 种产品对第 j 种原料的偏导数。每一列回答「某一种原料对所有产品的影响」，每一行回答「某一种产品受所有原料的影响」。雅可比矩阵是自动微分两种模式的分水岭：前向模式一次算一列，反向模式一次算一行。

这张「台账」本身可能非常庞大，但自动微分的聪明之处在于：它从不显式构造整个矩阵，而是根据需要计算「矩阵 × 向量」或「向量 × 矩阵」，这正是前向与反向模式各自的高效之处。

Jij=∂yi∂xj,J=[∂y1∂x1⋯∂y1∂xm⋮⋱⋮∂yn∂x1⋯∂yn∂xm]J_{ij} = \frac{\partial y_i}{\partial x_j}, \quad J = \begin{bmatrix} \frac{\partial y_1}{\partial x_1} & \cdots & \frac{\partial y_1}{\partial x_m} \\ \vdots & \ddots & \vdots \\ \frac{\partial y_n}{\partial x_1} & \cdots & \frac{\partial y_n}{\partial x_m} \end{bmatrix}
雅可比矩阵把「多个输出对多个输入」的全部敏感度装进一张表，行是输出、列是输入。
  1. 确定矩阵形状输出维度 n 决定行数，输入维度 m 决定列数。
    J∈Rn×mJ \in \mathbb{R}^{n \times m}
  2. 填写每个元素逐个求输出分量对输入分量的偏导，填入对应行列。
    Jij=∂yi∂xjJ_{ij} = \frac{\partial y_i}{\partial x_j}
  3. 特例——标量输出当输出只有一个（如深度学习损失函数），n = 1，雅可比矩阵退化为一个行向量，即梯度。
    ∇xf=[∂f∂x1,…,∂f∂xm]\nabla_x f = \left[ \frac{\partial f}{\partial x_1}, \ldots, \frac{\partial f}{\partial x_m} \right]

前向模式

前向模式像工厂里的一组「源头信使」：如果老板想知道第 j 种原料的影响，就派一名信使从第 j 个原料罐出发，手里拿一个初始的「敏感度种子」（值为 1），每穿过一道工序，就把种子乘以该工序的局部导数，最后到达成品仓时，信使口袋里装的就是这份原料对所有产品的敏感度。

数学上，前向模式计算的是雅可比矩阵与方向向量乘积（Jacobian-vector product, JVP）：给定一个种子向量 ẋ（表示输入方向），自动微分沿着计算图同时传播函数值 x 和导数方向 ẋ。每经过一个节点，导数方向就按链式法则更新。因为一次运行只对应一个种子，也就是雅可比矩阵的一列，所以如果想算全部 m 列，就要运行 m 次。

前向模式的优势在于它不需要存储整张计算图，信使一路走一路算，内存开销小，但如果输入维度 m 很大，就得派 m 个信使分别跑一遍，总成本为 O(m × 单次函数计算成本)。所以前向模式适合「输入少、输出多」的场景。

y˙=J⋅x˙\dot{y} = J \cdot \dot{x}
给定输入方向 ẋ，前向模式一次就能算出输出方向 ẏ——恰好是雅可比矩阵右乘一个方向向量。
  1. 初始化种子选择要追踪的输入方向 ẋ，通常取第 j 个基向量（第 j 位为 1，其余为 0）。
    x˙j=1,x˙k≠j=0\dot{x}_j = 1, \quad \dot{x}_{k \neq j} = 0
  2. 逐节点前向传播对计算图中每个节点同时计算函数值和导数方向，导数用局部导数的乘法规则更新。
    v˙i=∑父节点 p∂vi∂vp⋅v˙p\dot{v}_i = \sum_{\text{父节点 } p} \frac{\partial v_i}{\partial v_p} \cdot \dot{v}_p
  3. 取输出分量传播到输出节点，得到的 ẏ 就是雅可比矩阵的第 j 列。
    y˙=J⋅x˙\dot{y} = J \cdot \dot{x}

反向模式

反向模式则是「终点回溯」：先派一辆勘测车从原料罐出发，把整条流水线的路线和每道工序的局部导数都记录在册（这就是前向记录），然后从成品仓倒着往回走，每到一道工序，就把从后面传来的「贡献率」乘以局部导数，累加到前面各个相关节点上。这样走一趟，所有原料的敏感度就都齐了。

数学上，反向模式计算的是向量与雅可比矩阵乘积（Vector-Jacobian product, VJP）：给定一个输出侧的伴随向量 ȳ（表示输出方向的权重），反向传播把 ȳ 沿着计算图的边向后累积更新，一次运行就能得到雅可比矩阵的一行（即一个输出对所有输入的梯度）。对于标量输出，这个 ȳ 为 1，算出来的就是损失函数对所有参数的梯度。

反向模式只需要一次前向和一次反向，就能算出所有输入的敏感度，总成本约 O(n × 单次函数计算成本)，其中 n 是输出维度。代价是必须记录中间结果，内存开销更大。这就像回溯时需要一份完整的地图——地图越详尽，倒推越省力，但画地图也要占地方。

xˉ=JT⋅yˉ\bar{x} = J^T \cdot \bar{y}
输出侧给出权重 ȳ，反向模式把它映射回输入侧 x̄——相当于雅可比矩阵转置左乘向量。
  1. 前向记录先按原始方向做一次前向计算，把所有中间节点的值和局部导数存下来。
    v1,v2,…,vn及∂vi∂vpa(i)v_1, v_2, \ldots, v_n \quad \text{及} \quad \frac{\partial v_i}{\partial v_{pa(i)}}
  2. 初始化伴随值在输出节点设 ȳ（标量输出时设为 1）。
    yˉ=1\bar{y} = 1
  3. 反向累积从后往前，对每个节点计算它对其父节点的贡献，并累加。
    vˉpa=vˉpa+vˉchild⋅∂vchild∂vpa\bar{v}_{pa} = \bar{v}_{pa} + \bar{v}_{child} \cdot \frac{\partial v_{child}}{\partial v_{pa}}

模式对比

老板现在要决定工厂用哪种信使策略。这就像天平的两端：如果原料种类少（输入维度 m 小），派几个源头信使跑前向模式很划算；如果产品种类少（输出维度 n 小），倒推策略的反向模式最合适。深度学习之所以一面倒偏向后向，正是因为它的「产品」（损失函数）只有一个，而「原料」（模型参数）数以百万计。

时间成本可以近似写成：前向模式需要运行 m 次函数计算，反向模式需要运行 n 次函数计算。这里 m 是输入维度，n 是输出维度，单次计算的成本记为 C_f。当 n ≪ m 时反向占优，当 m ≪ n 时前向占优。内存方面，前向模式可以边算边丢，几乎不需要额外存储；反向模式必须保存前向传播的中间结果，内存开销随计算图深度线性增长。

所以「哪个模式更快」没有绝对答案，关键看输入与输出的维度比例。工厂老板如果既想省时又想省地，还可以考虑混合策略：在计算图的不同部分分别使用前向或反向，这正是现代框架内部调优的手段。

Tforward=m⋅Cf,Treverse=n⋅CfT_{\text{forward}} = m \cdot C_f, \quad T_{\text{reverse}} = n \cdot C_f
前向的代价由输入维度决定，反向的代价由输出维度决定——天平向维度小的一侧倾斜。
  1. 定义计算成本设单次沿着计算图计算函数值的时间为 C_f。
    Cf=cost(f(x))C_f = \text{cost}(f(x))
  2. 前向总成本前向模式对每个输入维度都要运行一次，总次数等于输入个数 m。
    Tforward=m⋅CfT_{\text{forward}} = m \cdot C_f
  3. 反向总成本反向模式只需要一次前向记录加一次反向累积，常数倍于一次函数计算，通常记为 n = 1（标量输出）时成本约为 C_f 的常数倍，因此通用式为 n · C_f。
    Treverse=n⋅CfT_{\text{reverse}} = n \cdot C_f

深度学习选型

深度学习训练的场景非常特殊：网络就像一个超级复杂的配方工厂，输入是海量参数（可能上亿），输出只是一个数值——损失函数。损失标量告诉你模型目前「有多差」。训练的目标是调整参数让损失变小，而这需要损失对每个参数的偏导数，也就是梯度。用前向模式的话，参数有上亿个，就得派上亿个信使，完全不可行；反向模式只需要一次反向回溯，就能同时算出所有参数梯度。

反向传播正是反向模式自动微分在神经网络中的具体应用。训练时，先做一次前向传播，记录每层的激活值和局部导数；然后从损失出发反向传播，利用链式法则把梯度逐层传回每一层的参数。这就是 PyTorch 和 TensorFlow 中 backward() 方法背后的核心机制。

这就像一个质检员只给一个「最终得分」，但能从得分倒推出每一个配料该加还是该减。正因如此，深度学习框架几乎无一例外地采用反向模式作为默认梯度引擎。

∇θL=JT⋅yˉ,yˉ=1\nabla_\theta L = J^T \cdot \bar{y}, \quad \bar{y} = 1
当损失 L 是标量时，反向模式的伴随值设为 1，得到的 ∇θL 就是损失对所有参数的梯度向量。
  1. 定义网络与损失设网络输出为 y = f(θ)，损失函数为标量 L = ℓ(y)。
    L=ℓ(f(θ))L = \ell(f(\theta))
  2. 设置输出伴随值因为 L 是标量，输出侧伴随值 ȳ = dL/dy，是一个普通数值。
    yˉ=∂L∂y\bar{y} = \frac{\partial L}{\partial y}
  3. 传播回参数反向模式把 ȳ 乘到雅可比矩阵的转置上，得到所有参数梯度。
    ∇θL=∂L∂y⋅∂y∂θ\nabla_\theta L = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial \theta}

实战选择

并不是所有 AI 任务都在做「多参数到单分数」的训练。有些场景输入很少、输出很多：比如机器人逆运动学，要由少量关节角度预测末端执行器的大量位姿；再比如金融衍生品定价，少量市场参数要输出的却是几百个不同期限的价格。这些场景里，前向模式一次能算出一整列雅可比，成本与输入维度成正比，反而比反向模式更高效。

资源受限的部署场景也值得权衡。反向模式要存储中间激活值，在内存紧张的边缘设备上可能爆掉；前向模式占用的内存更少，更适合对延迟和显存都敏感的推理任务。实践中还可以用混合模式：把计算图划分为多个子图，在输出多的子图用前向、输出少的子图用反向，以达到时间与内存的平衡。框架层面，JAX 等现代工具已经同时提供 jvp（前向）和 vjp（反向）接口，让开发者按需选择。

选择信使策略最终要看工厂的「形状」：原料少、产品多，派源头信使；产品少、原料多，用终点回溯。理解这个原理，你就能像老练的工程师一样，在框架自动选择之外找到更优的梯度计算方案。

m≪n⇒Tforward≪Treverse,n≪m⇒Treverse≪Tforwardm \ll n \Rightarrow T_{\text{forward}} \ll T_{\text{reverse}}, \quad n \ll m \Rightarrow T_{\text{reverse}} \ll T_{\text{forward}}
输入维度远小于输出时选前向，输出维度远小于输入时选反向——这就是工程师的「维度判据」。
  1. 评估输入输出维度先数清计算图的输入数 m 和输出数 n。
    m=dim⁡(x),n=dim⁡(y)m = \dim(x), \quad n = \dim(y)
  2. 比较两种成本前向成本约 m · C_f，反向成本约 n · C_f。
    m⋅Cfvsn⋅Cfm \cdot C_f \quad \text{vs} \quad n \cdot C_f
  3. 选择更小者哪边计算量小就选哪种模式；若相差不大，再考虑内存约束。
    mode=arg⁡min⁡(Tforward,Treverse)\text{mode} = \arg\min(T_{\text{forward}}, T_{\text{reverse}})

AI 应用场景

深度学习框架的梯度引擎

阶段：模型训练

解决的问题：神经网络动辄上亿参数，但损失函数只有一个标量。如果使用前向模式，需要对每个参数跑一次传播才能得到梯度，训练将慢到无法接受。反向模式自动微分（反向传播）通过一次前向记录、一次反向累积，直接得到全部参数的梯度，使大规模训练成为可能。

具体案例：在 PyTorch 中调用 loss.backward() 时，框架内部沿着计算图反向传播梯度；TensorFlow 的 GradientTape 同样记录前向操作后计算梯度。工程师通过查看每个参数的 .grad 属性，即可获得损失对该参数的偏导，配合优化器完成一轮更新。

科学计算中的参数敏感性分析

阶段：模型推理 / 仿真分析

解决的问题：在天气预报、飞机翼型设计等数值模拟中，通常输入只有风速、温度等几个参数，但输出是成千上万个网格点的物理量。传统符号微分无法处理复杂数值程序，数值微分又有误差。前向模式自动微分一次计算「一个输入对所有输出」的敏感度，成本与输入个数成正比，完美匹配这类场景。

具体案例：在计算流体力学中，用 JAX 的 jvp 接口对翼型设计参数求导，得到升力系数对每个设计变量的敏感度，从而指导外形优化；在金融领域，用前向模式快速计算期权价格对少数市场参数（利率、波动率）的所有期限敏感度，也就是「希腊字母」。

边缘设备上的资源受限部署

阶段：模型推理优化

解决的问题：反向模式虽然训练高效，但需要在内存中保存大量中间激活值，这对于手机、嵌入式设备非常不友好。如果推理时只需要计算「输入变化对输出变化」的方向导数（例如对输入噪声做鲁棒性分析），前向模式可以边算边丢，显著降低峰值内存。

具体案例：在智能摄像头检测系统中，需要实时评估输入图像的微小扰动对检测框的影响，以判断模型鲁棒性。工程师选择前向模式计算雅可比向量积，内存占用仅为反向模式的十分之一，推理延迟也满足实时要求。

Python 演示

python72 行
import math class Var:    """一个小型自动微分标量变量，同时支持前向模式与反向模式。"""    def __init__(self, value, grad=0.0, children=()):        self.value = value        self.grad = grad  # 反向模式中存储梯度        self.children = children  # (child, local_derivative) 列表        self.tangent = 0.0  # 前向模式中存储方向导数     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)])     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)])     def sin(self):        return Var(math.sin(self.value), children=[(self, math.cos(self.value))])     def forward_mode(self, seed):        """设置本变量为前向种子，然后递归传播方向导数。"""        self.tangent = seed        result = self        return result     def _forward_propagate(self):        if self.tangent == 0.0 and self.value != 0.0:            for child, local_deriv in self.children:                child._forward_propagate()                self.tangent += local_deriv * child.tangent     def backward(self):        """反向模式：从当前节点出发，向叶子节点累积梯度。"""        self.grad = 1.0        topo = []        visited = set()         def build_topo(v):            if v in visited:                return            visited.add(v)            for child, _ in v.children:                build_topo(child)            topo.append(v)         build_topo(self)        for v in reversed(topo):            for child, local_deriv in v.children:                child.grad += v.grad * local_deriv def demo():    # 计算 f = x1 * x2 + sin(x1)    x1 = Var(2.0)    x2 = Var(3.0)    f = x1 * x2 + x1.sin()     # 前向模式：种子指向 x1，求 df/dx1    x1.forward_mode(1.0)    f._forward_propagate()    print("前向模式 df/dx1 =", x1.tangent)     # 反向模式：从 f 开始 backward，得到所有叶子梯度    f.backward()    print("反向模式 df/dx1 =", x1.grad)    print("反向模式 df/dx2 =", x2.grad) if __name__ == "__main__":    demo()
目的：实现一个微型自动微分引擎，演示同一函数两种模式的求导结果一致，帮助理解前向与反向模式的机制差异。
  1. def __init__(self, value, grad=0.0, children=())每个变量既保存值，也保存反向梯度与前向方向导数；children 记录计算图上的父子关系。
  2. children=[(self, 1.0), (other, 1.0)]加法节点对两个输入的局部导数都是 1，写入子女列表供反向/前向使用。
  3. children=[(self, other.value), (other, self.value)]乘法节点对第一个输入的局部导数是另一个输入的值，反之亦然。
  4. def _forward_propagate(self)前向传播的核心：先递归让子节点更新方向导数，再把局部导数乘以子方向导数累加到自己头上。
  5. if self.tangent == 0.0 and self.value != 0.0避免重复传播，同时用值非零排除真正导数为零的情况。
  6. def build_topo(v)反向模式前先把计算图按拓扑序排好，保证从输出向输入回溯时不会遗漏。
  7. child.grad += v.grad * local_deriv反向累积的通用公式：父梯度乘以边的局部导数，累加到子节点。

常见误区

误区我总觉得深度学习用反向模式，是因为反向模式在任何情况下都比前向模式快，选它准没错。

正解反向模式快的前提是「输出维度远小于输入维度」。如果反过来，输入只有几个、输出有几百上千个，前向模式每次运行能算一整列雅可比，而反向模式得跑几百次才能收集全所有输出方向的梯度，反而更慢。选择模式要看计算图两端的维度比值，不能一概而论。

为何常见：因为深度学习默认使用反向模式，大家天天接触 backward()，很容易形成「反向最优」的惯性思维。

误区自动微分是不是就是像数值微分那样，给变量加个很小的增量 `h`，然后算差分？精度可能不太行吧？

正解自动微分不是差分近似。它基于链式法则，沿着计算图对每个基本运算精确求导，结果是机器精度下的精确值，没有截断误差。数值微分才需要 h 且存在精度问题。自动微分与数值微分的区别，就像用精确的税率表计算税收 vs 用抽查抽样估算税收。

为何常见：因为自动微分的高层 API 看起来只是「得到梯度」，底层细节和「有限差分」工具混在一起，初学者容易混淆。

误区每次前向模式计算导数，肯定要和反向模式一样把每一步的中间值都存下来，不然后面怎么算？

正解前向模式是「边算边传」的：在计算函数值的同时，方向导数跟着同步更新，不需要等待后续节点，所以它不需要保存整张计算图，内存占用通常远低于反向模式。反向模式才必须先完整走一遍前向并记录中间结果，才能从后往前回溯。

为何常见：把「反向模式需要保存中间激活」的直觉错误推广到了所有模式，忽略了两种模式的信息流向不同。

误区要求一个函数多个输出对多个输入的导数，就得先算出整个雅可比矩阵，一行一行填满，再拿去用。

正解自动微分一般只计算雅可比矩阵与向量的乘积（JVP 或 VJP），并不显式构建完整矩阵。深度学习里的梯度本质是 J^T · 1，只是一次向量-矩阵乘积的结果。显式构造 n×m 矩阵在输入输出维度很大时内存根本装不下，而矩阵-向量乘积的开销与单次函数计算同数量级。

为何常见：线性代数课上习惯先把矩阵写出来再做乘法，忽略了工程中「隐式矩阵」的高效性。

面试题

Q1. 自动微分相比于数值微分最核心的优点是？

单选题 · easy

  • A.不需要建立计算图
  • B.结果精确且无截断误差← 正确答案
  • C.可以处理任意复杂函数
  • D.内存占用更少

答案：B。自动微分基于链式法则逐点精确求导，不引入步长 h，因此没有截断误差。A 错，自动微分恰恰需要计算图；C 是符号微分与自动微分共同优点，不是相对数值微分的最核心优势；D 不一定是优点，反向模式内存占用可能更大。

Q2. 前向模式自动微分一次计算能获得雅可比矩阵的（）。

单选题 · medium

  • A.一行
  • B.一列← 正确答案
  • C.全部元素
  • D.对角线

答案：B。给定一个种子向量（方向），前向模式计算雅可比矩阵与该向量的乘积，结果代表矩阵的一列。每一列对应一个输入方向，所以要得到整个矩阵需要运行 m 次前向传播。

Q3. 设某函数输入维度 m=100，输出维度 n=1，单次函数计算成本为 C，则反向模式的时间复杂度约为（）？

单选题 · medium

  • A.100C
  • B.2C（常数倍）← 正确答案
  • C.C²
  • D.无法估算

答案：B。反向模式需要一次前向记录加一次反向累积，总成本约为一次函数计算 C 的常数倍（通常 2~3 倍），与输入维度无关。选 A 是把反向与前向混淆，前向才是 m·C。

Q4. 深度学习训练普遍使用反向模式，主要因为（）？

单选题 · easy

  • A.前向模式不支持神经网络
  • B.损失函数是标量而参数巨大← 正确答案
  • C.反向模式不消耗内存
  • D.反向模式不需要计算图

答案：B。损失函数是一个标量（输出维度 1），参数数量极其庞大（输入维度高），反向模式一次传播即可得到所有参数梯度，复杂度主要取决于输出维度，因此在深度学习中效率最高。A、C、D 均不符合事实。

Q5. 关于前向模式与反向模式的比较，下列说法正确的有（）。

多选题 · hard

  • A.输入少输出多时，前向模式可能更快← 正确答案
  • B.反向模式总需要记录前向传播的中间结果← 正确答案
  • C.前向模式不需要计算图也能求导
  • D.反向模式一次计算雅可比矩阵的一行← 正确答案

答案：ABD。前向模式复杂度 O(m·C)，输入 m 小时占优；反向模式复杂度 O(n·C)，需要记录前向中间结果；反向模式一次输出一个输出方向对应的雅可比行。C 错误，前向模式同样需要计算图结构。

Q6. 雅可比矩阵 J 中，元素 J[i][j] 表示（）。

单选题 · medium

  • A.第 i 个输入对第 j 个输出的影响
  • B.第 j 个输入对第 i 个输出的影响
  • C.第 i 个输出对第 j 个输入的影响← 正确答案
  • D.第 j 个输出对第 i 个输入的影响

答案：C。雅可比矩阵 J 是输出向量对输入向量的偏导矩阵，J[i][j] = ∂y_i / ∂x_j，即第 i 个输出对第 j 个输入的变化率，因此是「第 i 个输出对第 j 个输入的影响」。

Q7. 以下哪种情况最适合使用前向模式自动微分？

单选题 · easy

  • A.训练拥有千万参数的图像分类模型
  • B.输入 3 个参数，输出 1000 个网格物理量的仿真← 正确答案
  • C.计算标量损失函数对每个网络层权重的梯度
  • D.需要一次性得到所有参数梯度的推荐系统

答案：B。前向模式适合输入维度远小于输出维度的场景。B 中 m=3、n=1000，前向跑 3 次即可，反向反而要跑 1000 次。A、C、D 都是典型的「多输入少输出」，应使用反向模式。

Q8. 反向模式自动微分计算过程中包含以下哪些阶段？

多选题 · medium

  • A.前向记录，保存中间节点值和局部导数← 正确答案
  • B.初始化输出伴随值← 正确答案
  • C.从前往后逐层更新方向导数
  • D.从输出到输入反向累积伴随值← 正确答案

答案：ABD。反向模式先做一次前向记录（A），在输出节点设置伴随值（B），然后从输出反向累积到输入（D）。C 描述的是前向模式的「从前往后更新方向导数」，不是反向模式的特征。

Q9. 某计算图输入维度 m=50，输出维度 n=200，单次函数计算成本为 C，估算前向模式与反向模式总成本之比为（）。

单选题 · hard

  • A.50:200← 正确答案
  • B.200:50
  • C.1:1
  • D.250:200

答案：A。前向模式成本≈m·C=50C，反向模式成本≈n·C=200C，因此比值是 50:200，即前向模式在这类「少输入多输出」场景下比反向模式快 4 倍。选 B 是把输入输出搞反了。

Q10. 在 JAX 中，jvp 和 vjp 分别对应自动微分的哪种模式？

单选题 · medium

  • A.前向模式、反向模式← 正确答案
  • B.反向模式、前向模式
  • C.都是前向模式
  • D.都是反向模式

答案：A。JVP（Jacobian-vector product）是雅可比矩阵与方向向量相乘，对应前向模式；VJP（Vector-Jacobian product）是伴随向量与雅可比矩阵相乘，对应反向模式。JAX 的 jvp 和 vjp 名称即源自这两个数学操作。