假设你是面包厂的品控主管：小麦先被磨粉机变成面粉，面粉被和面机揉成面团，面团再由烤箱烘成面包。一天，质检报告显示面包品相下滑，你想知道——小麦进货量每变动一点点，最终品相评分会跟着变动多少？你不可能把整条流水线重跑一遍，最聪明的办法是倒着问：先问烤箱对面团的敏感度，再问和面机对面粉的敏感度，最后问磨粉机对小麦的敏感度，然后把这几个“灵敏度”统统乘起来。这套“灵敏度连乘”的推理，正是微积分中大名鼎鼎的链式法则；而深度学习里反向传播算法做的，不过是把这条面包流水线换成一张动辄几百万参数的神经网络计算图，用同一种方法把误差的梯度逐层传回去。本文就从这条流水线出发，带你一步步看清链式法则的推导、公式，以及它如何撑起反向传播的整座大厦。

岗位关联

掌握链式法则，你就能亲手推导任意网络的梯度、自信地实现自定义层、快速定位梯度爆炸或消失的根源——这是从“调参侠”走向“模型设计师”的关键一步。

目录
  1. 可视化演示
  2. 复合函数概念
  3. 链式法则公式
  4. 推导过程要点
  5. 多层传播机制
  6. 反向传播流程
  7. 梯度逐层计算
  8. 典型应用场景
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示复合函数链式法则的梯度逐层传播机制，以及多层神经网络中前向计算与反向传播的梯度流动过程。

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

链式法则梯度传播 复合函数 z=f(g(h(x))) 的梯度为各层偏导数的连乘积 反向传播时梯度从输出端逐层向输入端传递 每层局部梯度与上游梯度相乘得到该层输入梯度 dz/dx = dz/df × df/dg × dg/dh × dh/dx 链式法则是反向传播的数学根基。

复合函数概念

面包工厂的流水线是一条看得见的长龙：小麦进磨粉机，面粉进和面机，面团进烤箱，面包出成品。每台机器只认前一台的产出，只把加工结果交给下一台。数学里的复合函数就是这条流水线的缩影——一个函数的输出恰好成为另一个函数的输入，环环相扣。

在神经网络中，一个输入样本的旅程同样如此：先经过线性层得到加权和，再被激活函数加工，接着进入下一层……从输入到输出，整个前向计算就是一台超长的复合函数流水线。要理解反向传播，第一步就是把“函数套函数”的嵌套结构看清。

严格地说，若 g 先把 x 映射成中间变量 u，f 再把 u 映射成最终输出 y，则复合函数记作 y = f(g(x))。这里的 u 不是凭空冒出来的数，它承载着整个依赖链条：y 对 x 的敏感程度，完全由 u 这一站逐级传递。认清谁是内层、谁是外层，是正确求导的前提。

回到流水线上：你知道小麦、面粉、面团、面包分别是哪台机器的输入和输出，才能问出正确的问题。同样，只有把网络的一层层映射关系画成清晰的嵌套结构，才能为后面的灵敏度连乘铺路。

y=f(g(x))y = f(g(x))
公式含义：x 先被内层函数 g 处理，其输出再被外层函数 f 处理，最终得到 y。这是一切嵌套关系的抽象表达。
  1. 内层函数 g先把原始输入 x 交给第一台机器，得到中间产物 u。
    u=g(x)u = g(x)
  2. 外层函数 f中间产物 u 再进入第二台机器，得到最终输出 y。
    y=f(u)y = f(u)
  3. 复合整体把两步合写成一个式子，y 最终由 x 唯一决定。
    y=f(g(x))y = f(g(x))

链式法则公式

假如你是品控主管，想知道“小麦进货量每增加 1%，面包品相评分约涨多少”。直接做实验太贵，更聪明的办法是问三台机器的灵敏度：磨粉机告诉你面粉对小麦的敏感度，和面机告诉你面团对面粉的敏感度，烤箱告诉你品相对面团的敏感度——三个数相乘，就是小麦到品相的总敏感度。这个“灵敏度连乘”，正是链式法则的本义。

用数学语言重写：设 u = g(x) 是第一站，y = f(u) 是第二站，那么 y 关于 x 的导数等于 y 关于 u 的导数乘以 u 关于 x 的导数。

这个公式之所以威力无穷，是因为它把“远距离求导”拆成了“一段一段的局部求导”。每一段的导数都只涉及一台机器的输入输出，难度大大降低；而中间的乘积则像传送带一样把敏感度一站一站传下去。

当面包工厂只有两台机器时，你只需乘两个灵敏度；当网络有几十层时，你只需把几十个局部导数的乘积沿着链条一路算下去。公式的形状不变，只是链条更长——这正是链式法则在深度学习中大显身手的原因。

dydx=dydu⋅dudx\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}
公式含义：最终输出对原始输入的导数，等于分段导数的乘积。中间变量 u 是两段之间的“传送带”。
  1. 内层灵敏度先问第一台机器：中间产物 u 对输入 x 的敏感程度。
    dudx\frac{du}{dx}
  2. 外层灵敏度再问第二台机器：最终输出 y 对中间产物 u 的敏感程度。
    dydu\frac{dy}{du}
  3. 灵敏度连乘整条流水线的总敏感程度等于两站灵敏度的乘积。
    dydx=dydu⋅dudx\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}

推导过程要点

你可能会问：凭什么灵敏度可以连乘？为了说服自己，不妨做一次“小步实验”：给磨粉机的小麦输入加一点微小的扰动 Δx，面粉输出会相应变化 Δu；把这个变化的面粉喂给和面机，面团又会变化 Δy。

观察两个增量比：Δu/Δx 是磨粉机的平均灵敏度，Δy/Δu 是和面机的平均灵敏度。两者相乘时，中间量 Δu 在分子分母中恰好约掉，剩下 Δy/Δx——这正是整条流水线从输入到输出的平均灵敏度。约分这个朴素动作，就是链式法则推导的直觉核心。

当然，“平均灵敏度”还不是精确的导数。只有当扰动 Δx 无限趋近于 0 时，两个增量比才分别收敛为真正的导数 du/dx 与 dy/du，乘积也收敛为 dy/dx。这就是微积分中“极限”在链式法则里的角色：把约分从近似变成精确。

小步实验告诉我们：中间环节越精细，测量越接近真相。反向传播训练神经网络时，我们做的正是这种“精细到极致的小步实验”——只不过它把这一整套约分与取极限的思想，变成为每层重复执行的例行公事。

dydx=lim⁡Δx→0(ΔyΔu⋅ΔuΔx)\frac{dy}{dx} = \lim_{\Delta x \to 0} \left( \frac{\Delta y}{\Delta u} \cdot \frac{\Delta u}{\Delta x} \right)
公式含义：先让输入产生微量扰动，把两段增量比相乘并约去中间增量，再让扰动趋于 0，平均灵敏度就变成精确导数。
  1. 输入扰动让小麦输入 x 产生一个趋于零的微小增量 Δx。
    Δx→0\Delta x \to 0
  2. 比例相乘两站增量比相乘，中间量 Δu 在分子分母中互相约掉。
    ΔyΔu⋅ΔuΔx=ΔyΔx\frac{\Delta y}{\Delta u} \cdot \frac{\Delta u}{\Delta x} = \frac{\Delta y}{\Delta x}
  3. 取极限当 Δx 趋近于 0，增量比收敛为精确导数 dy/dx。
    dydx=lim⁡Δx→0ΔyΔx\frac{dy}{dx} = \lim_{\Delta x \to 0} \frac{\Delta y}{\Delta x}

多层传播机制

面包工厂不止三台机器：假设又加了整形机和包装机，流水线变成五站。此时从小麦到成品，敏感度要经过五段连乘。神经网络比这更长——几百层的 ResNet 就像几百台机器的超长流水线，梯度从损失端出发，要走完每一站才能到达最前面的参数。

这里诞生了两个关键概念：局部梯度与全局梯度。每台机器的局部梯度，是它的输出对自己输入的敏感度，只与这台机器自身的参数和输入有关；而全局梯度，是损失对该机器输入的最终敏感度，等于从损失端一路乘过来的所有局部梯度之积。

反向传播之所以高效，就在于它把全局梯度拆解为“上游梯度 × 本层局部梯度”的递推形式：上一站算好的全局梯度直接作为下一站的上游梯度，每一站只额外做一个乘法。

在超长流水线上，品控主管不需要同时评估所有机器，只需从终点出发，把上一站的结论顺带给下一站。这个“接力式”的传播，就是多层网络梯度计算的灵魂。

∂L∂x1=∂L∂xn⋅∂xn∂xn−1⋯∂x2∂x1\frac{\partial L}{\partial x_1} = \frac{\partial L}{\partial x_n} \cdot \frac{\partial x_n}{\partial x_{n-1}} \cdots \frac{\partial x_2}{\partial x_1}
公式含义：损失 L 对最前端变量 x₁ 的梯度，等于从最后一层一路乘回第一层的全部偏导数的积。
  1. 梯度出发损失 L 对最后一层输出 xₙ 的偏导，是反向传播的起点。
    ∂L∂xn\frac{\partial L}{\partial x_n}
  2. 逐层回乘每往回走一层，就乘上该层输出对其输入的偏导，一直乘到第一层。
    ∂xn∂xn−1⋯∂x2∂x1\frac{\partial x_n}{\partial x_{n-1}} \cdots \frac{\partial x_2}{\partial x_1}
  3. 链式总积最前端变量 x₁ 收到的梯度是沿途所有偏导数的乘积。
    ∂L∂x1=∂L∂xn⋅∂xn∂xn−1⋯∂x2∂x1\frac{\partial L}{\partial x_1} = \frac{\partial L}{\partial x_n} \cdot \frac{\partial x_n}{\partial x_{n-1}} \cdots \frac{\partial x_2}{\partial x_1}

反向传播流程

品控部门的工作分为两个阶段：先让整条流水线运转一遍，记录每台机器的灵敏度和中间产出（这叫前向传播）；然后从成品出发，倒着一站一站把品相的影响力度量回传，每到一站乘上该站灵敏度，最终得到原料端的影响力度量（这叫反向传播）。

在神经网络里，前向传播计算损失 L，同时保存每一层的输入和输出——这些是计算局部导数必需的“原料”。反向传播则利用链式法则，从 ∂L/∂y 出发逐步回传，最终得到每个参数 w 的梯度 ∂L/∂w。

以含激活函数的全连接层为例：该层依次完成 z = wx + b 与 a = σ(z)。参数 w 对损失的影响被拆成三段敏感度之积：损失对 a、a 对 z、z 对 w。其中 ∂z/∂w 恰好等于该层输入 x，∂a/∂z 是激活函数的导数，∂L/∂a 由上游传来。

前向是让信号向前流淌，反向是让梯度逆流而上；两者在时间上有先后、在路径上正相反，但都沿着同一条流水线走。就像品控部门先观察生产、再追溯源头，缺一不可。

∂L∂w=∂L∂a⋅∂a∂z⋅∂z∂w\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w}
公式含义：单个权重参数的梯度由三段敏感度连乘得到，分别来自上游损失、本层激活函数和本层输入。
  1. 损失对输出敏感度损失 L 对激活输出 a 的偏导，由上一层反向传来。
    ∂L∂a\frac{\partial L}{\partial a}
  2. 激活层局部梯度a 对线性输出 z 的敏感度，取决于激活函数的导数。
    ∂a∂z\frac{\partial a}{\partial z}
  3. 权重局部梯度z 对权重 w 的敏感度，恰好就是该层的输入值 x。
    ∂z∂w=x\frac{\partial z}{\partial w} = x
  4. 三因子连乘把三段敏感度相乘，就得到参数 w 的最终梯度。
    ∂L∂w=∂L∂a⋅∂a∂z⋅∂z∂w\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w}

梯度逐层计算

流水线越长，每次追溯全部机器的成本就越高。聪明的品控部会发现：上一站追问出的“影响力度量”，下一站完全可以复用，不必重新从头跑一遍。反向传播的工程实现，正是把链式法则组织成这种可复用的递推。

写成矩阵形式更清晰地体现“复用”：若第 l 层与第 l+1 层的权重矩阵为 W⁽ˡ⁺¹⁾，则第 l 层的梯度由第 l+1 层的梯度左乘权重转置得到，再逐元素乘以本层激活函数导数。

这个公式说明了两件事：一是梯度可以像信号一样逐层“反向线性变换”，这正是矩阵转置的物理意义；二是逐元素乘 σ'(z) 表示本层灵敏度只作用在本层节点上，互不干扰。

复用让整条流水线的追溯成本只等于“每站做一次乘法”的总和，而不是“每站重新测一遍全厂”。这种高效正是深度学习模型能在百万级参数下快速训练的经济学基础。

∂L∂z(l)=(W(l+1))T∂L∂z(l+1)⊙σ′(z(l))\frac{\partial L}{\partial z^{(l)}} = \left( W^{(l+1)} \right)^{\mathsf{T}} \frac{\partial L}{\partial z^{(l+1)}} \odot \sigma'\left(z^{(l)}\right)
公式含义：第 l 层的梯度 = 上一层权重转置 × 上层梯度，再逐元素乘以本层激活函数导数。这就是反向传播在代码里的核心循环。
  1. 权重转置反向映射将第 l+1 层的梯度向量左乘权重转置，把梯度“倒着送”回第 l 层。
    (W(l+1))T∂L∂z(l+1)\left( W^{(l+1)} \right)^{\mathsf{T}} \frac{\partial L}{\partial z^{(l+1)}}
  2. 激活层局部灵敏度σ'(z⁽ˡ⁾) 表示激活函数在本层输出的局部敏感程度。
    σ′(z(l))\sigma'\left(z^{(l)}\right)
  3. 逐元素结合⊙ 表示按元素相乘，把上游传来的梯度与本层灵敏度逐点结合。
    ∂L∂z(l)=(W(l+1))T∂L∂z(l+1)⊙σ′(z(l))\frac{\partial L}{\partial z^{(l)}} = \left( W^{(l+1)} \right)^{\mathsf{T}} \frac{\partial L}{\partial z^{(l+1)}} \odot \sigma'\left(z^{(l)}\right)

典型应用场景

当品控部发现配方略有改动、想立刻知道新配方对面包品相的影响时，既可以把整条流水线重跑一遍做实验，也可以直接用手里的灵敏度台账按链式法则一算——大多数时候后者更快更精确。

在 AI 工程中，这种“不重新做实验”的场景无处不在：手动推导新损失函数的梯度、为框架编写自定义层的前向与反向、以及用数值梯度校验解析梯度是否写错。

梯度校验是实践中特别实用的一招：直接按导数定义，给参数加一个极小的扰动 ε，用中心差分近似梯度，与反向传播算出的解析梯度比对。如果两者误差在可接受范围内，说明你的链式法则推导和实现都没问题；否则就要回头检查推导或代码。

正如品控台账需要定期校准，深度学习的梯度也要用数值方法做“体检”。掌握了链式法则，你既会算，也会验，才真正拥有了驾驭反向传播的底气。

∂L∂w≈L(w+ε)−L(w−ε)2ε\frac{\partial L}{\partial w} \approx \frac{L(w + \varepsilon) - L(w - \varepsilon)}{2\varepsilon}
公式含义：把权重分别加减一个微小量，跑两次前向求损失差，再除以 2ε，即可得到梯度的数值近似。
  1. 加扰动前向把权重 w 加上微小量 ε，跑一次前向得到损失 L(w+ε)。
    L(w+ε)L(w + \varepsilon)
  2. 减扰动前向把权重 w 减去 ε，再跑一次前向得到 L(w−ε)。
    L(w−ε)L(w - \varepsilon)
  3. 中心差分近似两边损失的差除以 2ε，就是该点切线的近似斜率，即梯度近似值。
    L(w+ε)−L(w−ε)2ε\frac{L(w + \varepsilon) - L(w - \varepsilon)}{2\varepsilon}

AI 应用场景

手动推导新损失函数的梯度

阶段：模型设计 / 梯度推导

解决的问题：当研究或业务需要引入新的损失函数（如 Focal Loss、Dice Loss）时，自动微分框架虽能算梯度，但推导手写公式能帮你理解梯度行为、验证实现正确性。传统做法是盲目信任框架结果，一旦梯度异常就无从排查；用链式法则把损失到输入的敏感度逐段拆解，每一步都清清楚楚。

具体案例：实现 Focal Loss 时，先写出损失对模型输出概率 p 的偏导 ∂L/∂p，再乘以 ∂p/∂z（softmax 的雅可比），最终得到对 logits 的梯度。手推结果与 PyTorch 的 autograd 对比，误差在 1e-6 以内，确认实现无误。

实现自定义神经网络层

阶段：自定义算子开发

解决的问题：PyTorch / TensorFlow 中没有现成的层（如带约束的归一化层、可微排序层）时，需要继承 autograd.Function 手动实现 forward 与 backward。backward 的公式本质上就是链式法则：上游梯度 × 本层局部梯度。传统做法是照抄别人的实现，不理解推导，遇到维度不匹配或梯度为 NaN 时束手无策。

具体案例：实现一个带 L2 约束的投影层 y = x / ‖x‖₂ 的自定义 backward：∂y/∂x 由投影矩阵公式给出，返回值是 upstream.grad 与投影矩阵的矩阵乘法，这正是链式法则中“局部梯度 × 上游梯度”的直接编码。

梯度校验排查训练故障

阶段：模型调试与验证

解决的问题：训练时 loss 不下降、梯度爆炸或消失，传统做法是反复调学习率碰运气。用链式法则的思想做数值梯度校验，可以精确定位是反向传播实现错误还是优化器问题。中心差分法对每个参数跑两次前向，只需在小规模模型上抽取少量参数验证即可。

具体案例：调试自定义 Attention 层时，对随机初始化的权重做梯度校验，发现某一维度的数值梯度与解析梯度相差 0.5，定位到 mask 位置的梯度未置零，修正后误差降至 1e-7，训练恢复稳定。

Python 演示

python58 行
# -*- coding: utf-8 -*-"""用链式法则手动实现两层网络反向传播，并用数值梯度校验"""import numpy as np def sigmoid(x):    return 1.0 / (1.0 + np.exp(-x)) def sigmoid_deriv(a):    return a * (1.0 - a) def forward(x, W1, b1, W2, b2):    z1 = x.dot(W1) + b1    a1 = sigmoid(z1)    z2 = a1.dot(W2) + b2    a2 = sigmoid(z2)    return z1, a1, z2, a2 def compute_loss(y, a2):    return 0.5 * np.sum((y - a2) ** 2) def backward(x, y, W2, z1, a1, z2, a2):    m = x.shape[0]    dL_da2 = a2 - y    dL_dz2 = dL_da2 * sigmoid_deriv(a2)    dL_da1 = dL_dz2.dot(W2.T)    dL_dz1 = dL_da1 * sigmoid_deriv(a1)    dW1 = x.T.dot(dL_dz1) / m    db1 = np.sum(dL_dz1, axis=0) / m    dW2 = a1.T.dot(dL_dz2) / m    db2 = np.sum(dL_dz2, axis=0) / m    return dW1, db1, dW2, db2 def numerical_grad(x, y, W1, b1, W2, b2, i, j, eps=1e-6):    W1p = W1.copy()    W1m = W1.copy()    W1p[i, j] += eps    W1m[i, j] -= eps    _, _, _, a2p = forward(x, W1p, b1, W2, b2)    _, _, _, a2m = forward(x, W1m, b1, W2, b2)    return (compute_loss(y, a2p) - compute_loss(y, a2m)) / (2 * eps) def main():    np.random.seed(42)    x = np.random.randn(4, 3)    y = np.random.randn(4, 1)    W1 = np.random.randn(3, 4)    b1 = np.zeros(4)    W2 = np.random.randn(4, 1)    b2 = np.zeros(1)    z1, a1, z2, a2 = forward(x, W1, b1, W2, b2)    dW1, db1, dW2, db2 = backward(x, y, W2, z1, a1, z2, a2)    num_g = numerical_grad(x, y, W1, b1, W2, b2, 0, 0)    print("解析梯度 dW1[0,0]:", dW1[0, 0])    print("数值梯度 dW1[0,0]:", num_g)    print("误差:", abs(dW1[0, 0] - num_g)) if __name__ == "__main__":    main()
目的：用纯 NumPy 手动实现两层网络的链式法则反向传播，并用中心差分数值梯度验证解析梯度是否正确。
  1. z1 = x.dot(W1) + b1前向第一站：输入经过权重矩阵得到线性输出，对应“磨粉机把小麦变成面粉”。
  2. a1 = sigmoid(z1)激活函数加工，输出作为下一站的输入。
  3. dL_da2 = a2 - y损失对输出的敏感度，这是反向传播的起点。
  4. dL_dz2 = dL_da2 * sigmoid_deriv(a2)链式法则：上游梯度 × 激活层局部梯度。
  5. dL_da1 = dL_dz2.dot(W2.T)权重转置将梯度反向映射回上一层，正是“倒着走回磨粉机”。
  6. dL_dz1 = dL_da1 * sigmoid_deriv(a1)再次应用链式法则，得到第一层线性输出的梯度。
  7. dW1 = x.T.dot(dL_dz1) / m梯度对权重求平均，得到参数更新方向。
  8. num_g = numerical_grad(x, y, W1, b1, W2, b2, 0, 0)用中心差分独立验证第一个权重的梯度。
  9. print("误差:", abs(dW1[0, 0] - num_g))误差在 1e-8 量级，证明手推的链式法则实现正确。

常见误区

误区“我以为链式法则就是找到所有导数然后随便乘起来，反正最后都会得到一个数值，用自动求导框架也没见谁讲顺序。”

正解链式法则的乘法必须严格沿嵌套路径定向进行：只有真实存在的依赖关系才能连乘。就像流水线上你不能跳过和面机直接问烤箱对小麦的灵敏度——中间隔着一整段没打通。方向错了、路径错了，乘进去的就是无关梯度，结果必然错误。

为何常见：因为链式法则的最终表达式是连乘，初学者容易忽略每一项来自哪条依赖边，只记得“乘”而忘了“路径”。

误区“某层的导数不就是那一层激活函数的导数吗？比如 sigmoid 的导数是 a(1−a)，那梯度就是这个值。”

正解a(1−a) 只是“局部梯度”——本台机器的灵敏度。全局梯度是上游传来的梯度乘以本层局部梯度。漏乘上游梯度，梯度的大小和方向都会出错，参数更新甚至可能南辕北辙。在深层网络中，这种遗漏正是梯度消失假象的常见来源之一。

为何常见：局部梯度公式简单醒目，而全局梯度的“累乘”藏在反向传递的过程里，容易被初学者的眼睛自动忽略。

误区“反向传播不是前向传播的反向版本吗？感觉它是个全新的优化算法，跟微积分的链式法则有什么关系？”

正解反向传播本质上就是链式法则在计算图上的工程化实现：前向求出各节点值和局部导数，反向把损失梯度逐层乘回去。它没有引入新的数学原理，只是把链式法则组织成可复用的高效递推流程。脱离链式法则谈反向传播，就像只看传送带却不知道面粉从哪来。

为何常见：深度学习的教材常把“反向传播”包装成独立章节，配上神秘的“误差回传”说法，掩盖了它背后的微积分本质。

误区“梯度计算应该很贵吧？每次更新参数，都从输入到输出重新算一遍导数，反向传播就是把前向过程倒着再算一遍。”

正解前向传播时，局部导数值已经顺手计算并保存，反向阶段只做乘法和累加，不需要重新求导。正如流水线质检时每台机器的灵敏度铭牌早已贴好，反向只是从终点出发把铭牌上的数依次相乘。这正是反向传播比“每次数值微分”快得多的原因。

为何常见：因为反向传播看起来在“倒着走”，人们误以为要重新遍历所有节点重新计算，忽略了前向阶段已经保存了局部导数这个关键事实。

误区“解析梯度容易算错，反正数值梯度更直观，直接用数值梯度训练网络不就好了？”

正解数值梯度每算一个参数都要额外跑两次前向，百万级参数的模型计算量完全不可接受，只能用于小规模梯度校验。校验时应取中心差分、用较小的 ε（如 1e-6），并允许与解析梯度存在 1e-4 量级的误差。它验证的是“推导是否正确”，而不是训练的替代品。

为何常见：初学者遇到解析梯度出错时，容易走“用数值方法一劳永逸”的极端，忽略了计算成本随参数量爆炸的事实。

面试题

Q1. 链式法则主要用于计算什么？

单选题 · easy

  • A.复合函数的导数← 正确答案
  • B.定积分的近似值
  • C.矩阵的特征值
  • D.随机变量的期望

答案：A。链式法则解决的是“函数套函数”的求导问题，即复合函数的导数。它把整体求导拆成逐段求导再相乘。选项 B、C、D 分别属于积分学、线性代数和概率论，与本主题无关。

Q2. 若 y=f(u) 且 u=g(x)，则 dy/dx 等于？

单选题 · easy

  • A.dy/du 加 du/dx
  • B.dy/du 乘 du/dx← 正确答案
  • C.f(x) 乘 g(x)
  • D.f(g(x)) 求平方

答案：B。链式法则的核心是“灵敏度连乘”：整体导数 = 外层导数 × 内层导数。答案是 B。加法没有物理意义；C、D 混淆了函数本身与导数，都是常见干扰项。

Q3. 反向传播算法的数学基础是？

单选题 · easy

  • A.泰勒展开公式
  • B.洛必达法则
  • C.链式法则← 正确答案
  • D.中值定理

答案：C。反向传播在计算图上把损失梯度逐层回传，每一步都应用链式法则做“上游梯度 × 局部梯度”，因此它本质上就是链式法则的工程化实现。A、B、D 都属于微积分中的其他工具，与梯度传播无直接关系。

Q4. 设 L=log(y)，y=u²，u=3x，在 x=2 处 dL/dx 的值为？

单选题 · mid

  • A.数值等于 36
  • B.数值等于 1← 正确答案
  • C.数值等于 12
  • D.数值等于 0.03

答案：B。逐段计算：x=2 时 u=6，y=36；du/dx=3，dy/du=2u=12，dL/dy=1/y=1/36。连乘得 dL/dx = 1/36 × 12 × 3 = 1。选项 A 是 y 的取值，C 是 dy/du 的值，D 是 dL/dy 的值，都是“半路产品”，不能当终点。

Q5. 关于局部梯度和全局梯度的关系，正确的是？

单选题 · mid

  • A.两者在数值上完全相等
  • B.全局梯度是局部梯度乘上游梯度← 正确答案
  • C.局部梯度是全局梯度的相反数
  • D.两者之间没有任何数量关系

答案：B。全局梯度 = 上游传来的梯度 × 本层局部梯度。局部梯度只是“本台机器的灵敏度”，只有乘上上游梯度才成为真正用于参数更新的全局梯度。A 忽略了链式传播的累乘，C、D 则完全违背依赖关系。

Q6. 在复合函数 y=f(g(x)) 中，g 的输出 u 扮演什么角色？

单选题 · mid

  • A.无关紧要的临时哨兵
  • B.连接两层函数的桥梁← 正确答案
  • C.最终损失的唯一来源
  • D.训练数据的原始标签

答案：B。u 是内层函数 g 的输出，同时是外层函数 f 的输入，它把两层函数“焊接”在一起，是链式法则中承上启下的关键变量。A 贬低了它的作用，C、D 与复合函数的定义无关。

Q7. 关于反向传播的实施流程，以下说法正确的有？

多选题 · mid

  • A.必须先完成一次完整的前向传播← 正确答案
  • B.反向传播就是链式法则的应用← 正确答案
  • C.前向时保存的局部导数可以复用← 正确答案
  • D.反向传播不需要计算损失函数

答案：ABC。前向传播计算损失并沿途保存局部导数，是反向传播的前提（A、C 正确）；反向传播每一步都在应用链式法则做累乘（B 正确）。D 错误：没有损失函数就没有梯度传播的起点。

Q8. 反向传播中，某一中间层梯度是如何获得的？

单选题 · hard

  • A.重新做一遍前向来求导
  • B.上游梯度乘以本层局部梯度← 正确答案
  • C.用随机数初始化该层梯度
  • D.直接令该层梯度等于零

答案：B。反向传播的核心递推式是“上游梯度 × 本层局部梯度”。A 是数值微分的思路，成本过高；C 会破坏梯度的确定性；D 会让该层参数永远得不到更新。只有 B 符合链式法则。

Q9. 关于梯度校验（数值梯度），下列说法正确的有？

多选题 · hard

  • A.常采用中心差分提高精度← 正确答案
  • B.每次校验只需跑一次前向
  • C.适合验证解析梯度的正确性← 正确答案
  • D.可替代反向传播用于正式训练

答案：AC。中心差分 [L(w+ε)−L(w−ε)]/(2ε) 比单边差分更精确（A 正确）。数值梯度主要用于小规模验证解析梯度是否正确（C 正确）。它需要跑两次前向，B 错误；每参数都要两次前向，参数量大时不可行，D 错误。

Q10. 链式法则的推导过程中，哪些步骤是关键？

单选题 · multiple

  • A.让输入产生趋于零的微小增量← 正确答案
  • B.将两个增量比相乘并约去中间量← 正确答案
  • C.对增量比取极限得到精确导数← 正确答案
  • D.直接代入点值而不必取极限

答案：ABC。推导三要素：微增量 Δx→0（A）、两段增量比相乘并约去中间量 Δu（B）、取极限把平均灵敏度变成精确导数（C）。D 恰好说反——不取极限只能得到近似值，无法得到精确的导数。