这篇文章讲清楚多元函数的链式法则。你会学到复合多元函数怎么逐层求偏导、用计算图理解前向反向、雅可比矩阵相乘的形式，以及它就是神经网络反向传播的数学基础，还会推导一个简单网络的反向传播。适合想真正搞懂反向传播推导的同学，看完就能从数学上推出反向传播的每一步。每个概念都配详细推导步骤和例题演示，帮你把抽象理论变成可用的解题工具，课后练习也能轻松应对。

学习提示

需要学习链式法则多元，统计建模是商业分析的理论基础。本篇涵盖线性代数、概率统计、微积分、优化理论，帮助你建立数学建模与推导能力。

目录
  1. 可视化演示
  2. AI 应用场景
  3. Python 演示
  4. 常见误区
  5. 面试题

可视化演示

状态—

这篇文章讲清楚多元函数的链式法则。你会学到复合多元函数怎么逐层求偏导、用计算图理解前向反向、雅可比矩阵相乘的形式，以及它就是神经网络反向传播的数学基础，还会推导一个简单网络的反向传播。适合想真正搞懂反向传播推导的同学，看...

复合函数基础：层层加工的流水线

烘焙工厂的第一课：面粉和成面团，面团烤成蛋糕。蛋糕的质量依赖面团，面团的状态依赖面粉——一环扣一环。数学里，这种"另一个函数的输出直接作为我的输入"的结构叫作复合函数。比如 z = f(g(x))，内层 g 先把 x 变成 y，外层 f 再把 y 变成 z。你没法跳过 y 直接回答"面粉对蛋糕的影响"，因为 x 根本不直接接触 z。

要分析这种嵌套关系，必须把函数拆开：先看内层 y = g(x)，再看外层 z = f(y)。这就是"逐层求导"的思路——也是后面所有链式法则的起点。就像质检员想弄清蛋糕问题，得先看面团是否合格，再看哪一个环节出了问题，绝不可能越过面团直接断言面粉有问题。

这个公式说的是：复合函数由内外两层函数串联而成，内层输出是外层输入。

z=f(g(x)),y=g(x),z=f(y)\displaystyle z = f(g(x)), \quad y = g(x), \quad z = f(y)
  1. 内层函数最靠近自变量的那层变换，把 x 映射成中间变量 y。
    y=g(x) \displaystyle y = g(x)
  2. 外层函数把中间变量 y 映射成最终结果 z，它根本不直接看到 x。
    z=f(y) \displaystyle z = f(y)
  3. 复合关系将内层代入外层，得到 x 到 z 的完整映射。 回到工厂：你整理的"面粉 → 面团 → 蛋糕"的流程表，就是一张复合函数清单。每道工序都有一个名字（f 或 g），下一道工序只认上一道的产出，这就是嵌套。
    z=f(g(x)) \displaystyle z = f(g(x))

单变量链式法则：一道工序的敏感度乘积

现在工厂遇到一个问题：面粉每多加 1 克，面团会变软 0.5 个单位；而面团每软 1 个单位，蛋糕评分会下降 2 分。那么面粉每多加 1 克，蛋糕评分下降多少？直觉告诉你：0.5 × 2 = 1 分。没错，这就是链式法则的雏形——敏感度沿流水线相乘。

数学上，如果 z 是 y 的函数，y 是 x 的函数，那么 z 对 x 的导数等于 z 对 y 的导数乘以 y 对 x 的导数。中间变量 y 就像接力棒，导数信息从 x 传到 y，再从 y 传到 z。每一步都记录着"输入一变，输出变多少"，总变化率就是各段变化率的乘积。

这是一元链式法则：两个变化率相乘，消去中间的 y，得到从 x 到 z 的"总敏感度"。

dzdx=dzdy⋅dydx\displaystyle \frac{dz}{dx} = \frac{dz}{dy} \cdot \frac{dy}{dx}
  1. 内层变化率求 y 对 x 的导数，即内层工序的敏感度。
    dydx=g′(x) \displaystyle \frac{dy}{dx} = g'(x)
  2. 外层变化率求 z 对 y 的导数，即外层工序的敏感度。
    dzdy=f′(y) \displaystyle \frac{dz}{dy} = f'(y)
  3. 乘积合成两段敏感度相乘，中间变量 y 的痕迹在公式中对接消去。 工厂里这条流水线上每个环节的"影响系数"乘在一起，就是原料对成品的总影响系数。后面你会看到，反向传播里一组组相乘的导数，正是这条流水线敏感度乘积的翻版。
    dzdx=f′(g(x))⋅g′(x) \displaystyle \frac{dz}{dx} = f'(g(x)) \cdot g'(x)

多元偏导传导：多路汇合的求和规则

蛋糕的口味不只受面粉影响，还受糖、鸡蛋等多种原料影响。假设 z 是蛋糕品质，x 和 y 分别是面粉和糖的用量，而面粉和糖的价格都受市场行情 t 的波动影响。那么行情一变，蛋糕品质会怎样变？答案不是一条路走到底，而是两条路径的贡献相加——面粉涨价影响品质，糖涨价也影响品质，总影响等于两者之和。

这就是多元链式法则的核心：当一个变量 t 能通过多个中间变量（x 和 y）影响最终结果 z 时，先沿每条路径做"内部连乘"，再把所有路径的结果加起来。注意这里用的是偏导数记号 ∂，因为 z 对 x 或 y 的依赖是"局部且多元的"——固定其他变量，只观察其中一个的变化。

多元链式法则：每条路径内部相乘，路径之间相加。这是反向传播中"梯度累加"的数学源头。

∂z∂t=∂z∂x∂x∂t+∂z∂y∂y∂t\displaystyle \frac{\partial z}{\partial t} = \frac{\partial z}{\partial x}\frac{\partial x}{\partial t} + \frac{\partial z}{\partial y}\frac{\partial y}{\partial t}
  1. 对第一个中间变量求偏导固定 y，只看 x 对 z 的影响，再乘 x 对 t 的变化率。
    ∂z∂x⋅∂x∂t \displaystyle \frac{\partial z}{\partial x} \cdot \frac{\partial x}{\partial t}
  2. 对第二个中间变量求偏导固定 x，只看 y 对 z 的影响，再乘 y 对 t 的变化率。
    ∂z∂y⋅∂y∂t \displaystyle \frac{\partial z}{\partial y} \cdot \frac{\partial y}{\partial t}
  3. 求和两条路径的贡献相加，得到总变化率。 工厂调度室面前有两张送料单：面粉和糖分别从两条皮带送进搅拌桶。桶里的面糊增量必然是两条皮带送料之和，不可能只算一条。将来神经网络里一个节点收到多个上游回传梯度时，做的正是这个加法。
    ∂z∂t=∂z∂x∂x∂t+∂z∂y∂y∂t \displaystyle \frac{\partial z}{\partial t} = \frac{\partial z}{\partial x}\frac{\partial x}{\partial t} + \frac{\partial z}{\partial y}\frac{\partial y}{\partial t}

计算图可视化：一张流水线地图

工厂经理把每道工序画成节点，原料沿箭头流动——这就是一张工艺流程图。深度学习中，我们把复杂的复合函数也画成这样一张"计算图"：节点是基本运算，边是数据的流向。以 z = x·w + b 为例，它可以拆成两个节点：先做乘法 u = x·w，再做加法 z = u + b。前向传播就是顺着箭头逐节点算出中间值，而反向传播就是逆着箭头把梯度传回去。

为什么计算图如此重要？因为它把"整个函数"拆成了"很多简单局部"，每个节点只需要知道自己这一小段的导数，就能配合全局完成梯度计算。这就像大工厂里每个工人都只熟悉自己那道工序的机器，但整个流程依然高效运转。

计算图的核心思想：复杂函数拆成简单运算的拼装，前向逐节点算值，反向逐节点传梯度。

z=x⋅w+b⟹u=x⋅w,z=u+b\displaystyle z = x \cdot w + b \quad\Longrightarrow\quad u = x \cdot w, \quad z = u + b
  1. 拆解运算一条算式拆成一个或两个基本运算节点。
    u=x⋅w \displaystyle u = x \cdot w
  2. 节点串联前一个节点的输出作为后一个节点的输入。
    z=u+b \displaystyle z = u + b
  3. 反向局部导数每个节点只算自己的局部偏导，供反向传播取用。 把计算图贴在墙上，你一眼就能看出哪个节点是"瓶颈"、哪条边最"敏感"。前向传播像工厂按图纸生产，反向传播则像根据顾客投诉反向追溯——而追溯的路，就是链式法则给出的路。
    ∂z∂u=1,∂z∂b=1,∂u∂w=x \displaystyle \frac{\partial z}{\partial u} = 1, \quad \frac{\partial z}{\partial b} = 1, \quad \frac{\partial u}{\partial w} = x

雅可比矩阵：全厂敏感度总表

如果工厂产品线和原料都不止一种，经理会做一张大表：横列是各种原料，纵列是各种产品，每个格子填"某原料变动 1 单位对某产品的影响"。这张表在数学上就是雅可比矩阵：对于一个多维函数 f 将 n 维输入映射为 m 维输出，雅可比矩阵 J 的第 i 行第 j 列元素是 ∂fᵢ/∂xⱼ——第 j 个输入对第 i 个输出的偏导。

雅可比矩阵最漂亮的性质是：复合函数的雅可比等于各层雅可比矩阵相乘。这意味着链式法则可以被"矩阵化"——多层复合函数求导，就是一层层矩阵乘法。但实际工程里，参数规模动辄百万，显式构造矩阵不现实，所以反向传播用的是"向量-雅可比积"：把上游梯度向量直接乘以局部雅可比，一步得到下游梯度。

雅可比矩阵就是一张敏感度总表，行是输出分量，列是输入分量，矩阵乘法把各层敏感度串起来。

J=[∂y1∂x1∂y1∂x2∂y2∂x1∂y2∂x2]\displaystyle J = \begin{bmatrix} \dfrac{\partial y_1}{\partial x_1} & \dfrac{\partial y_1}{\partial x_2} \\ \dfrac{\partial y_2}{\partial x_1} & \dfrac{\partial y_2}{\partial x_2} \end{bmatrix}
  1. 矩阵定义行对应输出分量下标，列对应输入分量下标。
    Jij=∂yi∂xj \displaystyle J_{ij} = \frac{\partial y_i}{\partial x_j}
  2. 复合映射的雅可比复合函数的雅可比等于各层雅可比矩阵的乘积。
    J(f∘g)=Jf(g(x))⋅Jg(x) \displaystyle J_{(f \circ g)} = J_f(g(x)) \cdot J_g(x)
  3. 工程化替代反向传播只算"上游梯度向量 × 局部雅可比"，不显式构造完整矩阵。 经理看这张总表就能快速判断：原料 A 对产品 1 影响最大，那调整工艺时优先盯 A。神经网络里的梯度传播同样如此——只是规模大到没人会真把整张表铺开，大家只算需要的那几条路线。
    v下=v上⋅J局部 \displaystyle v_{\text{下}} = v_{\text{上}} \cdot J_{\text{局部}}

反向传播推导：从顾客投诉逆推到每道工序

蛋糕偏甜，顾客差评如潮，损失 L 很大。工厂现在要从成品一路往回查：甜度是谁造成的？是糖加多了，还是面粉少了让甜味更突出？反向传播做的就是这件事——从损失出发，沿着计算图反向走，用链式法则把梯度逐层传回每个参数。

以最简单的神经元为例：设损失 L = ½(ŷ − y)²，预测 ŷ = σ(z)，加权输入 z = wx + b。我们要问：权重 w 对损失 L 的敏感度是多少？这需要一条链：L 依赖 ŷ，ŷ 依赖 z，z 依赖 w。三个偏导连乘，正好是链式法则的标准形式。

反向传播的核心公式：损失对权重的梯度 = 三段偏导连乘，每一段都是局部敏感度。

∂L∂w=∂L∂y^⋅∂y^∂z⋅∂z∂w\displaystyle \frac{\partial L}{\partial w} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial z} \cdot \frac{\partial z}{\partial w}
  1. 损失对预测的偏导均方误差的导数，得到预测与真值的差距。
    ∂L∂y^=y^−y \displaystyle \frac{\partial L}{\partial \hat{y}} = \hat{y} - y
  2. 预测对加权和的偏导sigmoid 函数的导数，即激活函数的敏感度。
    ∂y^∂z=σ(z)(1−σ(z)) \displaystyle \frac{\partial \hat{y}}{\partial z} = \sigma(z)\bigl(1 - \sigma(z)\bigr)
  3. 加权和对权重的偏导z = wx + b 对 w 求偏导，剩下的就是 x 本身。
    ∂z∂w=x \displaystyle \frac{\partial z}{\partial w} = x
  4. 三路连乘把三段敏感度相乘，得到权重应得的梯度。 工厂追溯责任时，每条生产线认领自己那份"变化率"，层层相乘后，w 拿到了自己应得的修正量。反向传播的每一步都是这个模式的重复：上游梯度 × 局部导数 = 下游梯度。
    ∂L∂w=(y^−y)⋅σ(z)(1−σ(z))⋅x \displaystyle \frac{\partial L}{\partial w} = (\hat{y} - y) \cdot \sigma(z)\bigl(1 - \sigma(z)\bigr) \cdot x

网络应用实战：手推一个两层网络

真正的工厂不会只有两道工序。假设一个两层网络：输入 x 进入第一层 z₁ = w₁x + b₁，经激活函数 h = σ(z₁)，再进入第二层 z₂ = w₂h + b₂，输出预测 ŷ = z₂。我们要推导 ∂L/∂w₁——第一层权重对损失的敏感度。这条路径更长：L → ŷ → z₂ → h → z₁ → w₁。

仔细看这条链路，你会发现它复用了反向传播中已经算好的中间梯度：先算 ∂L/∂ŷ，再算 ∂L/∂z₂，然后传过 z₂ 对 h 的依赖，穿过激活函数，最后抵达 w₁。每走一步都只是"拿上游梯度乘上局部导数"，没有任何新魔法。这正是反向传播高效的原因——一次反向行走，所有参数梯度全部到手。

两层网络的链式推导：损失梯度穿过第二层权重、激活函数导数，最终到达第一层权重。

∂L∂w1=(y^−y)⋅w2⋅σ′(z1)⋅x\displaystyle \frac{\partial L}{\partial w_1} = (\hat{y} - y) \cdot w_2 \cdot \sigma'(z_1) \cdot x
  1. 完整路径拆解列出从 L 到 w₁ 所有要经过的中间节点。
    L→y^→z2→h→z1→w1 \displaystyle L \to \hat{y} \to z_2 \to h \to z_1 \to w_1
  2. 损失到 h 的梯度先算 ∂L/∂ŷ = ŷ − y，再乘 ∂ŷ/∂z₂ = 1 和 ∂z₂/∂h = w₂。
    ∂L∂h=(y^−y)⋅w2 \displaystyle \frac{\partial L}{\partial h} = (\hat{y} - y) \cdot w_2
  3. 穿过激活函数h = σ(z₁)，所以 ∂h/∂z₁ = σ′(z₁)。
    ∂L∂z1=(y^−y)⋅w2⋅σ′(z1) \displaystyle \frac{\partial L}{\partial z_1} = (\hat{y} - y) \cdot w_2 \cdot \sigma'(z_1)
  4. 抵达参数z₁ = w₁x + b₁，对 w₁ 求偏导得到 x，完成最后一段。 你会发现这套敏感度追踪术完全通用：无论网络多深，都是"路径内相乘、路径间相加"。有了它，手推任意简单网络的梯度都不再是难题。
    ∂L∂w1=(y^−y)⋅w2⋅σ′(z1)⋅x \displaystyle \frac{\partial L}{\partial w_1} = (\hat{y} - y) \cdot w_2 \cdot \sigma'(z_1) \cdot x

AI 应用场景

深度学习框架的自动求导引擎

阶段：模型训练中的梯度计算

解决的问题：手推梯度费时且极易出错，尤其网络深、分支多时。AI 框架用计算图记录前向运算，反向传播时自动应用多元链式法则，把每个参数的梯度一次算出。

具体案例：训练一个 ResNet 图像分类模型时，调用 loss.backward()，PyTorch 的 autograd 引擎沿着计算图反向逐节点计算梯度，等价于文章推导的链式法则工程化。随即 optimizer.step() 用梯度更新权重。

相关角色：算法工程师、深度学习平台工程师

金融风控中的多因子敏感度分析

阶段：风险模型的因子归因与敏感性分析

解决的问题：资产组合收益同时受利率、汇率、大宗商品等多个宏观因子影响，传统方法逐个因子重算成本高。将模型视作复合函数，用雅可比矩阵一次性得到收益对各因子的敏感度，再配合链式法则穿透中间环节找到风险源头。

具体案例：某量化团队构建了一个含两层子模型的投资组合收益预测器，第一层将宏观因子映射为行业景气度，第二层将景气度映射为组合收益。团队用雅可比矩阵计算出"利率每上升 1%，组合净值变动 X"的敏感度表，及时发现并降低了利率暴露。

相关角色：量化分析师、风控建模工程师

Python 演示

python51 行
import math def sigmoid(x):    return 1.0 / (1.0 + math.exp(-x)) def sigmoid_deriv(a):    return a * (1.0 - a) def forward(x, w1, b1, w2, b2):    z1 = w1 * x + b1    h = sigmoid(z1)    y_pred = w2 * h + b2    return y_pred, z1, h def backward(x, y_true, y_pred, z1, h, w1, b1, w2, b2):    dL_dy = y_pred - y_true    dy_dz2 = 1.0    dz2_dh = w2    dz2_dw2 = h    dz2_db2 = 1.0    dh_dz1 = sigmoid_deriv(h)    dz1_dw1 = x    dz1_db1 = 1.0     dL_dw2 = dL_dy  dy_dz2  dz2_dw2    dL_db2 = dL_dy  dy_dz2  dz2_db2    dL_dh = dL_dy  dy_dz2  dz2_dh    dL_dz1 = dL_dh * dh_dz1    dL_dw1 = dL_dz1 * dz1_dw1    dL_db1 = dL_dz1 * dz1_db1    return dL_dw1, dL_db1, dL_dw2, dL_db2 def train():    w1, b1 = 0.5, 0.0    w2, b2 = 0.8, 0.0    x, y_true = 2.0, 1.0    lr = 0.1    for epoch in range(20):        y_pred, z1, h = forward(x, w1, b1, w2, b2)        dL_dw1, dL_db1, dL_dw2, dL_db2 = backward(            x, y_true, y_pred, z1, h, w1, b1, w2, b2        )        w1 -= lr * dL_dw1        b1 -= lr * dL_db1        w2 -= lr * dL_dw2        b2 -= lr * dL_db2        loss = 0.5  (y_pred - y_true) * 2        print(f"epoch {epoch}: loss={loss:.4f} y_pred={y_pred:.4f}") if name == "main":    train()

常见误区

误区"z 同时依赖 x 和 y，那 dz/dt 就是把沿 x 的偏导乘完、再把沿 y 的偏导乘完，两个都算出来就行，不用加吧？"

正解每一路内部连乘得到的只是"这条路径的贡献"，而 z 的总变化必然是所有路径贡献的叠加。就像工厂里两条皮带同时往搅拌桶送料，桶里的面糊增量必然是两条皮带送料之和，而不是只算其中一条。这也是反向传播中"梯度累加"的直接来源——一个节点处汇总多条上游梯度时就是求和。

为何常见：单变量链式法则只有一条路，习惯了"只管连乘"，换成多变量时没有意识到路径之间是并联关系，需要求和。

误区"既然 ∂z/∂x 和 ∂x/∂t 里有同样的 ∂x，能不能直接约掉，得到 ∂z/∂t？"

正解不能。∂z/∂x 表示"固定其他变量时 z 对 x 的敏感度"，∂x/∂t 表示"t 变化时 x 自己的变化率"，两者成立的实验条件不同，不能当作分数约分。多元链式法则的正确形式是"各路偏导乘完再相加"，不是简单的符号相消。

为何常见：一元导数的莱布尼茨记号确实可以像分数那样可约，这个习惯深入人心，到了多元偏导就很容易踩坑。

误区"手推公式时用了雅可比矩阵，那 PyTorch 反向传播是不是也会先把每个节点的雅可比矩阵都建好，再做矩阵乘法？"

正解框架不会显式构造完整雅可比矩阵，而是用"向量-雅可比积"（VJP）直接计算。每个节点只需把上游梯度向量与局部雅可比相乘，输出一个下游梯度向量。模型参数动辄百万，显式矩阵根本存不下，这也正是反向传播高效的原因之一。

为何常见：教材为了讲清楚线性变换会推导完整个矩阵，学生误以为工程实现也必须如此，忽略了"只算需要的部分"这个工程智慧。

误区"我听说过反向传播，也知道链式法则，但它俩好像不是一回事？反向传播是不是一套只能死记硬背的流程？"

正解反向传播就是链式法则在计算图上的工程实现，没有任何超出的新数学。每个节点保存自己的局部导数，前向传播传值，反向传播把上游梯度乘上局部导数继续往回流。理解了链式法则，反向传播就是它的自然延伸。

为何常见：深度学习框架封装得太好，loss.backward() 一行调用就出结果，长期不接触底层推导，容易让人把数学原理和工程实现看成两回事。

面试题

Q1. 对于复合函数 z = f(g(x))，令 y = g(x)，则 dz/dx 等于

单选题 · easy

  • A.dy/dx 与 dz/dy 相乘← 正确答案
  • B.dy/dx 与 dz/dy 相加
  • C.dx/dt 与 dz/dx 相乘
  • D.dx/dt 与 dz/dy 相除

答案：A。链式法则要求沿路径内部相乘：z 对 y 的导数乘以 y 对 x 的导数，即 dz/dx = dz/dy · dy/dx。就像面粉影响面团、面团影响蛋糕，两段敏感度相乘才是总影响。

Q2. 已知 z = f(x, y)，且 x = x(t)，y = y(t)，则 dz/dt 的正确表达式是

单选题 · easy

  • A.直接求 z 的全微分
  • B.各路偏导与导数连乘
  • C.对应相乘后求和← 正确答案
  • D.只沿一条路径求导

答案：C。多元链式法则要求每条路径内部相乘、路径之间相加：∂z/∂x · dx/dt + ∂z/∂y · dy/dt。这就像两条皮带同时送料，桶里的增量是两条皮带贡献之和，不能只看一条。

Q3. 若 z = wx + b，则 ∂z/∂w 等于

单选题 · easy

  • A.等于权重 w
  • B.等于偏置 b
  • C.等于输入 x← 正确答案
  • D.等于常数 1

答案：C。对 w 求偏导时，把 x 和 b 视作常数，z 关于 w 是一次线性关系，所以偏导等于系数 x。这是反向传播中最常见的局部导数之一。

Q4. 雅可比矩阵第 i 行第 j 列元素的含义是

单选题 · mid

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

答案：B。雅可比矩阵定义 J[i][j] = ∂yᵢ/∂xⱼ，行对应输出分量下标，列对应输入分量下标。类比工厂的敏感度总表：横列原料、纵列产品，每格是"某原料对某产品的影响"。

Q5. 计算图中一条路径上串联了多个节点时，梯度沿路径传递的方式是

单选题 · mid

  • A.将路径上各段偏导相加
  • B.取路径上各段偏导最大值
  • C.取路径上各段偏导均值
  • D.将路径上各段偏导相乘← 正确答案

答案：D。一条路径上的多个节点是串联关系，如 x → y → z，dz/dx = dz/dy · dy/dx，必须连乘。就像一道流水线上三个环节各自的影响系数连乘，才得到原料对成品的总影响。

Q6. 某节点在计算图中收到多个下游分支传来的梯度，该节点汇总后的梯度应为

单选题 · mid

  • A.各分支传来的梯度相加← 正确答案
  • B.各分支传来的梯度相乘
  • C.取各分支梯度的最大值
  • D.取各分支梯度的平均值

答案：A。多个分支意味着该节点通过多条路径影响最终输出，多元链式法则要求各路贡献相加。这与工厂中多道工序共同影响最终品质、总影响等于各工序影响之和的直觉一致。

Q7. 神经网络训练时，反向传播相比"显式构造雅可比矩阵再相乘"的优势在于

单选题 · mid

  • A.数值精度更高更稳定
  • B.避免显式构造巨大的矩阵← 正确答案
  • C.完全不需要链式法则
  • D.只适用于线性激活函数

答案：B。模型参数动辄百万甚至更多，显式构造完整雅可比矩阵会消耗不可接受的内存。反向传播使用"向量-雅可比积"，只算上游向量与局部矩阵的乘积，一步得到下游梯度向量，这正是链式法则的工程化优势。

Q8. 关于多元链式法则，下列说法正确的是

多选题 · mid

  • A.每条路径内部导数相乘← 正确答案
  • B.不同路径之间的导数相加← 正确答案
  • C.只需要考虑一条主要路径
  • D.偏导数使用 ∂ 符号标记← 正确答案

答案：ABD。多元链式法则的核心是"路径内相乘、路径间相加"，因此 A 和 B 正确；使用偏导符号 ∂ 是因为固定其他变量只观察其一，D 正确。C 错误——只要存在多条依赖路径，就不能只取一条。

Q9. 关于反向传播与链式法则的关系，正确的说法是

多选题 · hard

  • A.是链式法则在计算图中的应用← 正确答案
  • B.每个节点保存局部导数用于回传← 正确答案
  • C.前向传播与反向传播顺序无关
  • D.梯度逐层回传并累加← 正确答案

答案：ABD。反向传播就是链式法则在计算图上的工程实现，A 正确；每个节点计算并保存局部导数（如 ∂z/∂w），B 正确；梯度从输出逐层回传，遇到多分支时累加，D 正确。前向传播必须先于反向传播执行，因为反向需要前向保存的中间值，C 错误。

Q10. 在两层网络 ∂L/∂w₁ 的手推过程中，哪些因数是必需的？

多选题 · hard

  • A.需要乘上损失对预测的偏导← 正确答案
  • B.路径包含激活函数的导数← 正确答案
  • C.结果包含输入 x 的身影← 正确答案
  • D.无需经过中间层权重

答案：ABC。链式法则要求沿着 L → ŷ → z₂ → h → z₁ → w₁ 路径连乘。∂L/∂ŷ 是源头，激活函数导数 σ′(z₁) 在穿过 h 时必须出现，最后 ∂z₁/∂w₁ = x 也必须有，所以 A、B、C 缺一不可。D 错误——梯度必须经过第二层权重 w₂（∂z₂/∂h = w₂）才能传回第一层。