链式法则与反向传播

链式法则 dy/dx = (dy/du)·(du/dx) 是微积分中的基础公式，但在深度学习中，它是反向传播算法（Backpropagation）的唯一数学原理。一个 100 层的 ResNet 从 loss 到第 1 层的梯度，就是 100 次链式法则的连乘；Transformer 中 attention→FFN→LayerNorm 的梯度回传同样依赖链式法则逐层展开。梯度消失——Sigmoid 导数最大 0.25，100 层连乘后梯度衰减到 0.25¹⁰⁰ ≈ 10^-60，使早期层无法学习——正是链式法则连乘的直接后果；ReLU 激活函数的导数为 0 或 1，解决了这一问题。梯度爆炸在 RNN 中尤为突出，梯度裁剪（gradient clipping）是直接应对手段。框架的 autograd 引擎所做的事情就是在计算图上自动应用链式法则。本节从最简单的两层复合出发，一步步推导到真实 2 层神经网络的反向传播全过程，并演示梯度消失现象。

一、链式法则的数学定义

二、简单链式法则逐步计算

三、计算图——反向传播的核心思想

把复杂的计算公式拆成一系列简单的基本操作，画成有向无环图（DAG）。前向传播沿图计算输出，反向传播则从输出往回走，逐节点用链式法则传递梯度。

四、真实神经网络的反向传播（完整数值演示）

五、基本运算节点的反向传播规则

六、梯度消失与梯度爆炸

七、代码验证（C# / Rust）

C#（.NET 10）

// dotnet run 即可执行（顶级语句）
double Sigmoid(double v) => 1.0 / (1.0 + Math.Exp(-v));

double w1 = 0.5, b1 = 0.1, w2 = 0.3, b2 = 0.2;
double x = 1.0, y = 2.0, lr = 0.5;

// ===== 前向传播 =====
double z1 = w1 * x + b1;
double a1 = Sigmoid(z1);
double z2 = w2 * a1 + b2;
double yHat = z2;
double loss = Math.Pow(y - yHat, 2);
Console.WriteLine($"前向: z1={z1:F4}, a1={a1:F4}, yHat={yHat:F4}, loss={loss:F4}");

// ===== 反向传播 =====
double dL_dy = -2.0 * (y - yHat);
double dL_dz2 = dL_dy;
double dL_dw2 = dL_dz2 * a1;
double dL_db2 = dL_dz2;
double dL_da1 = dL_dz2 * w2;
double sigGrad = a1 * (1.0 - a1);
double dL_dz1 = dL_da1 * sigGrad;
double dL_dw1 = dL_dz1 * x;
double dL_db1 = dL_dz1;
Console.WriteLine($"梯度: dw1={dL_dw1:F4}, db1={dL_db1:F4}, dw2={dL_dw2:F4}, db2={dL_db2:F4}");

// ===== 参数更新 =====
w1 -= lr * dL_dw1; b1 -= lr * dL_db1;
w2 -= lr * dL_dw2; b2 -= lr * dL_db2;
Console.WriteLine($"更新后: w1={w1:F4}, b1={b1:F4}, w2={w2:F4}, b2={b2:F4}");

// 验证：更新后损失减小
z1 = w1 * x + b1; a1 = Sigmoid(z1);
yHat = w2 * a1 + b2;
double lossNew = Math.Pow(y - yHat, 2);
Console.WriteLine($"更新后 loss: {lossNew:F4} (< {loss:F4})");

// ===== 梯度消失演示 =====
Console.WriteLine("\n梯度消失演示 (Sigmoid):");
foreach (int n in new[] { 5, 10, 20, 50 })
    Console.WriteLine($"  {n}层: 梯度衰减到 {Math.Pow(0.25, n):E2}");

Console.WriteLine("\nReLU (全部激活):");
foreach (int n in new[] { 5, 10, 20, 50 })
    Console.WriteLine($"  {n}层: 梯度 = 1.0");

Rust

// cargo run 即可执行
fn sigmoid(x: f64) -> f64 { 1.0 / (1.0 + (-x).exp()) }

fn main() {
    let (mut w1, mut b1, mut w2, mut b2) = (0.5_f64, 0.1, 0.3, 0.2);
    let (x, y, lr) = (1.0_f64, 2.0, 0.5);

    // ===== 前向传播 (mul_add = fused multiply-add, 单指令更高精度) =====
    let mut z1 = w1.mul_add(x, b1);
    let mut a1 = sigmoid(z1);
    let z2 = w2.mul_add(a1, b2);
    let mut y_hat = z2;
    let loss = (y - y_hat).powi(2);
    println!("前向: z1={z1:.4}, a1={a1:.4}, yHat={y_hat:.4}, loss={loss:.4}");

    // ===== 反向传播 =====
    let dl_dy = -2.0 * (y - y_hat);
    let dl_dz2 = dl_dy;
    let dl_dw2 = dl_dz2 * a1;
    let dl_db2 = dl_dz2;
    let dl_da1 = dl_dz2 * w2;
    let sig_grad = a1 * (1.0 - a1);
    let dl_dz1 = dl_da1 * sig_grad;
    let dl_dw1 = dl_dz1 * x;
    let dl_db1 = dl_dz1;
    println!("梯度: dw1={dl_dw1:.4}, db1={dl_db1:.4}, dw2={dl_dw2:.4}, db2={dl_db2:.4}");

    // ===== 参数更新 =====
    w1 -= lr * dl_dw1; b1 -= lr * dl_db1;
    w2 -= lr * dl_dw2; b2 -= lr * dl_db2;
    println!("更新后: w1={w1:.4}, b1={b1:.4}, w2={w2:.4}, b2={b2:.4}");

    // 验证：更新后损失减小
    z1 = w1.mul_add(x, b1); a1 = sigmoid(z1);
    y_hat = w2.mul_add(a1, b2);
    let loss_new = (y - y_hat).powi(2);
    println!("更新后 loss: {loss_new:.4} (< {loss:.4})");

    // ===== 梯度消失演示 =====
    println!("\n梯度消失演示 (Sigmoid):");
    for n in [5, 10, 20, 50] {
        println!("  {n}层: 梯度衰减到 {:.2e}", 0.25_f64.powi(n));
    }
    println!("\nReLU (全部激活):");
    for n in [5, 10, 20, 50] { println!("  {n}层: 梯度 = 1.0"); }
}