链式法则：复合函数求导的核心

可视化演示

展示复合函数链式法则公式、计算图前向反向传播、多层嵌套逐层求导及反向传播梯度消失，通过多模式交互理解核心数学原理。

复合函数辨识

糖果流水线的第一步不是开动机器，而是看清这条线到底有几道工序、每道工序的输入输出是什么。剥糖纸的机器吃进去的是糖块，吐出来的是裸糖；裹巧克力的机器吃进去的是裸糖，吐出来的是脆皮糖。它们是前后串联的，后一道机器的输入，恰好是前一道机器的输出。两个机器叠在一起，就形成了“嵌套”的完整生产线。

数学里的复合函数，就是这种嵌套的流水线。设内层工序为 \(u = g(x)\)，外层工序为 \(y = f(u)\)，那么从原料 \(x\) 到成品 \(y\) 的直接描述是 \(y = f(g(x))\)。学习链式法则的第一课，就是学会辨认这种结构：看到一个复杂函数，先问自己——哪部分是“先发生的操作”，哪部分是“后发生的操作”？剥掉外层，剩下的就是内层；层层剥开，结构就清楚了。

$$\displaystyle y = f(g(x)) = (f \circ g)(x)$$

1. 内层函数：\(g(x)\) 先作用于输入 \(x\)，如同流水线第一站处理原料。

$$u = g(x)$$

2. 外层函数：\(f\) 再作用于中间量 \(u\)，如同第二站处理半成品。

$$y = f(u)$$

3. 嵌套表示：将两步合并，写成 \(f \circ g\)，读作“\(f\) 复合 \(g\)”。

$$(f \circ g)(x) = f(g(x))$$

看清水流线的工序结构，就成功了一半。很多同学一上来就套公式求导，结果把内层当外层，求出来的导数自然是错的。先花十秒钟把“哪层在内、哪层在外”标出来，后面的计算就顺畅了。就像车间主任拿到新糖型，先是画工序图，而不是急着调机器。

法则核心公式

现在质检员要求：改变原料糖的甜度 \(x\)，让成品甜度 \(y\) 变化得更多。于是你要到每一道工序去问同样一个问题：“我的输入变一点点，你的输出跟着变多少？”这个比例，数学上就叫导数。剥糖纸这一站，输出 \(u\) 对输入 \(x\) 的变化率是 \(\frac{du}{dx}\)；裹巧克力这一站，输出 \(y\) 对输入 \(u\) 的变化率是 \(\frac{dy}{du}\)。

如果两站串联，原料小幅变化 \(\mathrm{d}x\)，先被第一站放大成 \(\mathrm{d}u = \frac{du}{dx}\mathrm{d}x\)，再被第二站放大成 \(\mathrm{d}y = \frac{dy}{du}\mathrm{d}u\)。把两个放大倍数乘起来，就是整条流水线的总放大率。这就是链式法则的核心直觉：变化率沿着流水线逐站相乘。

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

1. 中间变量：\(u = g(x)\) 是内外层之间的桥梁，相当于第一站的输出。

$$u = g(x)$$

2. 外层求导：\(y\) 对 \(u\) 求导，得到第二站的局部变化率。

$$\frac{dy}{du} = f'(u)$$

3. 内层求导：\(u\) 对 \(x\) 求导，得到第一站的局部变化率。

$$\frac{du}{dx} = g'(x)$$

4. 相乘合并：两个局部变化率相乘，得到总变化率。

$$\frac{dy}{dx} = f'(g(x)) \cdot g'(x)$$

这个式子的莱布尼茨记号特别优雅：左边是终点 \(y\) 对起点 \(x\) 的导数，右边把中间变量 \(u\) 的微分在分子分母各出现一次，像约分一样“消掉”了。它暗示我们，无论中间有几站，都可以一层层写下去、乘起来。这套记号本身就是为流水线设计的，读它就像读一张车间布局图。

单层嵌套求导

光看公式还不够，直接上手干一道最简单的活：求 \(y = (3x+1)^5\) 的导数。这就像流水线上只有两道工序——第一站把糖块称重成 \(u = 3x+1\)，第二站把糖块放入模具压成五次方。现在要问：原料 \(x\) 变化一丁点，成品 \(y\) 变化多少？

先找内外层：外层是“五次方”机器，内层是“乘三加一”机器。外层机器对输入的局部变化率是“五次方”的导数，即 \(5u^4\)；内层机器对原料的局部变化率是“乘三加一”的导数，即 \(3\)。按照流水线法则，把两个放大倍数相乘，就得到总变化率。

$$\displaystyle \frac{dy}{dx} = 5(3x+1)^4 \times 3 = 15(3x+1)^4$$

1. 设中间变量：令 \(u = 3x+1\)，内层是线性变换，如同第一站机器。

$$u = 3x + 1$$

2. 外层求导：\(y = u^5\) 对 \(u\) 求导，幂函数求导规则生效。

$$\frac{dy}{du} = 5u^4$$

3. 内层求导：\(u = 3x+1\) 对 \(x\) 求导，常数项消失，系数留下。

$$\frac{du}{dx} = 3$$

4. 结果还原：把中间变量换回 \(3x+1\)，两部分相乘。

$$\frac{dy}{dx} = 5(3x+1)^4 \times 3$$

这里最容易犯的错是只写 \(5(3x+1)^4\)，把内层的系数 \(3\) 弄丢了。想象一下：如果第一站机器每转一周能处理三颗糖，而你只算了压模机的放大率，那整条线的产能就低估了三分之二。在流水线上，每一站的放大率都不能漏；在链式法则里，每一层的导数都不能缺。

多层嵌套求导

当流水线从两站变成四站、五站时，链式法则的威力才真正显现。比如求 \(y = \sin\left((x^2+1)^2\right)\) 的导数。这条流水线的工序是：第一站做 \(x^2+1\)，第二站把它平方，第三站取正弦。仿佛一个多层洋葱，剥开一层还有一层。

处理这种多层嵌套的秘诀是“由外向内逐层剥”：先把最外层的“正弦”当成一个函数，把里面整块 \((x^2+1)^2\) 视为它的输入，求导得到 \(\cos\left((x^2+1)^2\right)\)；接着进入下一层，对 \((x^2+1)^2\) 求导，用链式法则得 \(2(x^2+1) \cdot 2x\)；最后把每一层的结果乘起来。每剥一层，就多乘一个因子。

$$\displaystyle \frac{dy}{dx} = \cos\left((x^2+1)^2\right) \times 2(x^2+1) \times 2x$$

1. 剥最外层：外层是 \(\sin(\cdot)\)，求导后变 \(\cos(\cdot)\)，内部保持不动。

$$\frac{dy}{d(u^2)} = \cos\left((x^2+1)^2\right)$$

2. 剥第二层：对 \((x^2+1)^2\) 求导，幂函数规则加内层再导。

$$\frac{d(u^2)}{du} = 2(x^2+1)$$

3. 剥第三层：对 \(x^2+1\) 求导，只剩 \(2x\)。

$$\frac{du}{dx} = 2x$$

4. 累乘全部因子：三层的局部导数依次相乘，得到最终答案。

$$\frac{dy}{dx} = \cos(u^2) \times 2u \times 2x$$

洋葱剥到最里层时，手上已经积了一串因子。只要每层都问一句“我的输入是什么、怎么变”，然后认真相乘，再复杂的嵌套也能拆干净。要特别提醒的是，千万别认为剥到第二层就结束了，最里面的 \(2x\) 是这条流水线的源头，漏掉它，整条线的产能就又算错了一截。

计算图直观

面对五层甚至十层的流水线，靠脑子记住每道工序的关系太累了。工程师的做法是画一张车间流程图：每个圆代表一台机器（一个数学函数），每条箭头代表半成品流向（数据传递）。这张图在深度学习里有个正式名字——计算图。

在计算图上，导数的传播变得非常直观。每个节点对它直接输入的导数，叫局部梯度；反向传播时，上游传来的梯度乘以当前节点的局部梯度，就是继续往前传的梯度。这就好比质检员在流水线末端给出一个“误差量级”，它逆着箭头流动，每经过一台机器就乘以这台机器的放大率，越往源头走，数值就越能反映“该调整哪台机器、调多少”。

$$\displaystyle \frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} \times \frac{\partial y}{\partial x}$$

1. 上游梯度：\(\frac{\partial L}{\partial y}\) 是损失 \(L\) 对节点输出 \(y\) 的梯度，由下游传回。

$$\text{上游梯度} = \frac{\partial L}{\partial y}$$

2. 局部梯度：\(\frac{\partial y}{\partial x}\) 是节点输出对输入的导数，只由当前机器的表达式决定。

$$\text{局部梯度} = \frac{\partial y}{\partial x}$$

3. 梯度合成：上游梯度乘局部梯度，得到继续往上游传的梯度。

$$\frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} \times \frac{\partial y}{\partial x}$$

看，这张图上的每个节点只需要关心自己“输入怎么变、输出怎么变”，不需要知道整条线的全局细节，然后靠着相邻节点之间的接力，梯度就能一路传到最前端。这种“各管一段、全局联通”的思想，正是现代深度学习框架自动求导的底层设计。可以说，链式法则给了工程师一张可以照着施工的流水线图纸。

反向传播应用

现在把流水线放大到极致——一个神经网络。输入是数据，隐藏层的每个神经元是一道工序，输出是预测值，损失函数是最终的质检报告。训练网络的基本目标就是：让质检报告的误差尽量小，于是要沿着流水线逆流而上，算每个旋钮（权重参数）该往哪个方向拧、拧多大。这个逆流而上的算法，就是反向传播，它本质上是链式法则的工程化应用。

假设某条通路是：输入 \(x\) 经过权重 \(w\) 得到 \(z = wx + b\)，再经过激活函数得到 \(a\)，最后参与损失 \(L\) 的计算。我们要问的是：权重 \(w\) 变一点，损失 \(L\) 变多少？答案是沿着通路把三段变化率乘起来。这跟糖果流水线里问“第一站机器调一下，成品变化多少”是同一个问题，只是工序变成了矩阵乘法和激活函数。

$$\displaystyle \frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \times \frac{\partial a}{\partial z} \times \frac{\partial z}{\partial w}$$

1. 损失对激活输出求导：算出最终质检误差对激活值的敏感度。

$$\frac{\partial L}{\partial a}$$

2. 激活函数局部梯度：激活输出 \(a\) 对加权和 \(z\) 的导数，如 Sigmoid 或 ReLU 的导数。

$$\frac{\partial a}{\partial z}$$

3. 加权和对权重求导：\(z = wx + b\) 对 \(w\) 的导数正好是输入 \(x\)。

$$\frac{\partial z}{\partial w} = x$$

4. 三项相乘：三段局部变化率相乘，得到权重 \(w\) 的最终梯度。

$$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \times f'(z) \times x$$

得到梯度后，优化器让权重沿着梯度的反方向迈一小步：\(w \leftarrow w - \eta \frac{\partial L}{\partial w}\)，其中 \(\eta\) 是学习率。整条流水线每周转一次，就是一轮训练。所以，链式法则不仅是一道考试题，它根本就是深度学习引擎的燃油管道——每一滴梯度信号，都是沿着这条链条从最终误差倒灌回每个权重旋钮的。

AI 应用场景

Python 演示

def forward(x):    u = 3 * x + 1          # 内层工序    y = u ** 5             # 外层工序    return y  def chain_rule(x):    u = 3 * x + 1    dy_du = 5 * (u ** 4)   # 外层局部梯度    du_dx = 3              # 内层局部梯度    dy_dx = dy_du * du_dx  # 链式法则相乘    return dy_dx  def numerical_derivative(f, x, h=1e-6):    # 中心差分做数值验证    return (f(x + h) - f(x - h)) / (2 * h)  def backward_demo(x, target):    w = 2.0                # 初始权重    b = 1.0                # 初始偏置    pred = w * x + b       # 前向传播    loss = (pred - target) ** 2    dloss_dpred = 2 * (pred - target)  # 损失局部梯度    dpred_dw = x           # 加权和对权重的梯度    dw = dloss_dpred * dpred_dw        # 链式法则求权重梯度    return loss, dw, pred  if __name__ == "__main__":    x = 2.0    analytic = chain_rule(x)    numeric = numerical_derivative(forward, x)    print("解析链式法则:", analytic)    print("数值微分验证:", numeric)     loss, dw, pred = backward_demo(x=2.0, target=100.0)    print("预测值:", pred)    print("损失:", loss)    print("权重梯度:", dw)

1. u = 3 * x + 1定义内层工序，等价于流水线的第一站。
2. dy_du = 5 * (u ** 4)外层求导，得到第二站的局部放大率。
3. dy_dx = dy_du * du_dx两个局部梯度相乘，正是链式法则的核心。
4. (f(x + h) - f(x - h)) / (2 * h)中心差分，用数值方式近似导数，用来验证解析解。
5. dloss_dpred = 2 * (pred - target)损失函数对预测输出的局部梯度。
6. dw = dloss_dpred * dpred_dw把损失梯度与输入信号相乘，就是权重梯度。

常见误区

面试题