反向传播算法的数学原理

一句话概述

反向传播（Backpropagation）是训练深度神经网络的核心算法——它将损失函数从输出层逐层"反向传播"到输入层，高效地计算出网络中每一个参数对损失的梯度。这个算法的本质是链式法则在大型计算图上的巧妙应用，配合动态规划避免了冗余计算。没有反向传播，训练一个拥有数十亿参数的神经网络将需要天文数字般的计算量——反向传播使之降低到仅约两倍于正向传播的成本。它是现代AI能够从数据中"学习"的数学引擎。

💡 核心要点：①反向传播是链式法则在神经网络上的系统化应用 ②核心流程：正向计算→损失评估→反向梯度传播→参数更新 ③使用动态规划避免重复计算共享子路径 ④每层梯度 = 上游梯度 × 该层的局部雅可比矩阵 ⑤自动微分框架使反向传播对开发者透明

教学与演示

一、正向传播——计算预测值

是什么（定义，可选）：正向传播（Forward Propagation）是神经网络将输入数据逐层转换为输出预测的过程。每一层执行线性变换（矩阵乘法）后接非线性激活函数：z^(l) = W^(l)·a^(l-1) + b^(l)，a^(l) = σ(z^(l))。从 l=1 到 L，最终 a^(L) 即为网络的预测输出。

大白话 正向传播就像是流水线——原料（输入数据）从左边进去，经过第一台机器（第一层）加工变成半成品，再经过第二台机器（第二层）变成另一种半成品……最后从流水线右端出来的是一个成品（预测值）。每台机器都有自己的"配方参数"（权重W和偏置b），正是这些参数我们想通过训练来优化。

为什么（原理，可选）：正向传播不仅是推理阶段的计算路径，更为反向传播准备了必需的中间数据（各层的激活值 a^(l) 和线性输出 z^(l)）。这些中间值在反向传播时用于计算各参数的局部梯度。因此，正向传播需要"记住"每一层的输入和输出，这导致了训练时额外的内存消耗——这是时间和空间的经典权衡：我们牺牲内存来换取梯度计算的速度。 怎么做（实现，可选）：

import numpy as np

def sigmoid(x):
    """Sigmoid 激活函数"""
    return 1.0 / (1.0 + np.exp(-x))  # σ(x)

def forward_pass_single(x, W1, b1, W2, b2, W3, b3):
    """三层神经网络的正向传播"""
    # 存储中间结果（反向传播需要）
    cache = {}
    cache['a0'] = x  # 输入层（"第0层激活"）
    
    # 第1层：线性变换 + Sigmoid 激活
    cache['z1'] = W1 @ cache['a0'] + b1  # z₁ = W₁x + b₁
    cache['a1'] = sigmoid(cache['z1'])    # a₁ = σ(z₁)
    
    # 第2层：线性变换 + Sigmoid 激活
    cache['z2'] = W2 @ cache['a1'] + b2  # z₂ = W₂a₁ + b₂
    cache['a2'] = sigmoid(cache['z2'])    # a₂ = σ(z₂)
    
    # 第3层（输出层）：线性变换 + Sigmoid 激活
    cache['z3'] = W3 @ cache['a2'] + b3  # z₃ = W₃a₂ + b₃
    cache['a3'] = sigmoid(cache['z3'])    # ŷ = σ(z₃)
    
    return cache  # 返回所有中间结果

# 定义一个三层网络
# 输入2维 → 隐藏层1(3神经元) → 隐藏层2(2神经元) → 输出(1维)
np.random.seed(42)
W1 = np.random.randn(3, 2) * 0.5  # 3×2 权重矩阵
b1 = np.zeros((3, 1))              # 3×1 偏置向量
W2 = np.random.randn(2, 3) * 0.5  # 2×3 权重矩阵
b2 = np.zeros((2, 1))              # 2×1 偏置向量
W3 = np.random.randn(1, 2) * 0.5  # 1×2 权重矩阵
b3 = np.zeros((1, 1))              # 1×1 偏置向量

# 输入数据和标签
x = np.array([[1.0], [0.5]])   # 2×1 输入向量
y = np.array([[1.0]])          # 目标输出

print("=== 正向传播：三层神经网络 ===\n")
print("网络结构：输入(2) → 隐藏层1(3) → 隐藏层2(2) → 输出(1)")
print(f"输入 x = [{x[0,0]:.1f}, {x[1,0]:.1f}]")
print(f"目标 y = {y[0,0]:.1f}\n")

cache = forward_pass_single(x, W1, b1, W2, b2, W3, b3)

print("逐层激活值：")
for l in range(1, 4):
    z_key = f'z{l}'
    a_key = f'a{l}'
    print(f"  第{l}层: z{l} = {cache[z_key].flatten().round(4)}")
    print(f"         a{l} = {cache[a_key].flatten().round(4)}")

print(f"\n最终预测 ŷ = {cache['a3'][0,0]:.6f}")

# 计算损失（二元交叉熵 + MSE 演示用 MSE）
mse_loss = 0.5 * (cache['a3'][0,0] - y[0,0])**2
print(f"MSE 损失 = {mse_loss:.6f}")
print("\n这些中间值 a1, a2, a3, z1, z2, z3 将在反向传播中用于梯度计算。")

什么用（应用，可选）：理解正向传播的矩阵形式是理解反向传播的前提——反向传播中的梯度矩阵乘法正好是正向传播中矩阵乘法的"转置"形式。在自定义网络层时，你需要实现 forward 方法（定义正向传播的计算逻辑），框架才能在此基础上自动构建 backward。在部署模型做推理时，只执行正向传播。 哪些坑（缺点，可选）：正向传播的中间变量（激活值）占用大量GPU内存——尤其在处理大批量数据和深层网络时。这限制了batch size和网络层数。解决方案包括：梯度检查点（牺牲计算换内存）、混合精度训练（FP16减少内存）、模型并行（将层分布到多个GPU）。

二、损失函数——衡量误差

是什么（定义，可选）：损失函数 L(ŷ, y) 衡量网络预测 ŷ 与真实标签 y 之间的差距。对于回归问题常用均方误差（MSE）：L = ½||ŷ - y||²。对于二分类问题常用二元交叉熵（BCE）：L = -[y·log(ŷ) + (1-y)·log(1-ŷ)]。对于多分类问题常用分类交叉熵（CCE）：L = -Σ yᵢ·log(ŷᵢ)。

大白话 损失函数就是网络表现的"成绩单"——数字越小表示表现越好。损失函数的设计直接影响网络学习的目标：你让它学什么，它就学什么。如果考试题目（损失函数）出错了，再聪明的学生（网络）也拿不到好成绩。

为什么（原理，可选）：损失函数的选择决定了反向传播的起点——梯度的"初始种子"。MSE对每个样本给出连续误差信号，适合回归。交叉熵配合Softmax/Sigmoid在分类任务中收敛更快，因为它消除了激活函数导数项中的饱和效应（ŷ-y 的简洁形式）。损失函数必须是可微的才能进行反向传播——不可微的损失（如0-1损失）无法提供有用的梯度信号。 怎么做（实现，可选）：

import numpy as np

def mse_loss(y_pred, y_true):
    """均方误差损失：L = ½·(ŷ - y)²"""
    error = y_pred - y_true
    loss = 0.5 * np.sum(error**2)  # MSE 值
    dL_dy = error                    # ∂L/∂ŷ = ŷ - y（反向传播的起点）
    return loss, dL_dy

def bce_loss(y_pred, y_true):
    """二元交叉熵损失（配合 Sigmoid 输出）"""
    eps = 1e-12  # 防止 log(0)
    # L = -[y·log(ŷ) + (1-y)·log(1-ŷ)]
    loss = -np.sum(y_true * np.log(y_pred + eps) + 
                   (1 - y_true) * np.log(1 - y_pred + eps))
    # ∂L/∂ŷ = -(y/ŷ - (1-y)/(1-ŷ)) 配合 Sigmoid 简化
    dL_dy = -(y_true / (y_pred + eps) - (1 - y_true) / (1 - y_pred + eps))
    return loss, dL_dy

def mse_with_sigmoid(y_pred, y_true):
    """MSE + Sigmoid 输出：梯度包含 σ'(z) 因子（可能导致饱和）"""
    y_sigmoid = 1.0 / (1.0 + np.exp(-y_pred))  # 模拟 Sigmoid
    
    # MSE 对 Sigmoid 输出的梯度
    error = y_sigmoid - y_true  # ŷ - y
    # ∂L/∂z = (ŷ - y) · σ'(z) = (ŷ - y) · ŷ · (1-ŷ)
    dL_dz = error * y_sigmoid * (1 - y_sigmoid)
    
    loss = 0.5 * np.sum(error**2)
    return loss, dL_dz

def bce_with_sigmoid(y_pred_logit, y_true):
    """BCE + Sigmoid 输出：梯度简化（交叉熵消除 σ' 项）"""
    # 数值稳定版本：loss = max(z,0) - z*y + log(1+exp(-|z|))
    z = y_pred_logit
    loss = np.sum(np.maximum(z, 0) - z * y_true + np.log(1 + np.exp(-np.abs(z))))
    # ∂L/∂z = σ(z) - y（简洁！无 σ' 因子）
    sigmoid_z = 1.0 / (1.0 + np.exp(-z))
    dL_dz = sigmoid_z - y_true  # 反向传播的种子
    return loss, dL_dz

print("=== 损失函数与梯度种子 ===\n")

# 对比 MSE 和 BCE 配合 Sigmoid 的梯度行为
z_vals = np.array([-3.0, -1.0, 0.0, 1.0, 3.0])  # 不同 logit 值
y_true = 1.0  # 真实标签

print("对比：MSE vs BCE 配合 Sigmoid 输出（y_true = 1）")
print("  z (logit)\tσ(z)\tMSE梯度\tBCE梯度")
for z in z_vals:
    _, mse_grad = mse_with_sigmoid(np.array([z]), np.array([y_true]))
    _, bce_grad = bce_with_sigmoid(np.array([z]), np.array([y_true]))
    sig = 1/(1+np.exp(-z))
    print(f"  {z:6.1f}\t{sig:.4f}\t{mse_grad[0]:.6f}\t{bce_grad[0]:.6f}")

print("\n观察：当 σ(z) 接近 0 或 1 时（饱和区），MSE 梯度趋近于 0 → 学习停滞")
print("     BCE 的梯度 = σ(z)-y，不包含 σ'(z) → 即使在饱和区也能有效学习")
print("这就是为什么分类问题几乎总是使用交叉熵损失！")

什么用（应用，可选）：损失函数决定了反向传播的梯度种子（∂L/∂ŷ），进而影响所有参数的更新。选择正确的损失函数是深度学习实践中的关键决策——分类用交叉熵、回归用MSE或Huber（对异常值更鲁棒）、目标检测用IoU损失、GAN用对抗损失。损失函数也决定了网络最后是否需要额外的激活层（交叉熵通常配合Softmax/Sigmoid）。 哪些坑（缺点，可选）：损失函数与激活函数的不当配对可能导致训练障碍——MSE配合Sigmoid容易陷入饱和（梯度消失），交叉熵配合Sigmoid则天然抵消了σ'(z)项。此外，不平衡数据集的损失函数需要加权或使用Focal Loss，否则少数类几乎不被学习。损失函数的设计还需考虑梯度爆炸——极端标签下的log(0)可能导致NaN。

三、反向传播——用链式法则算梯度

是什么（定义，可选）：反向传播按以下步骤计算梯度：①输出层误差：δ^(L) = ∂L/∂z^(L)；②逐层反向传递：δ^(l) = [(W^(l+1))ᵀ · δ^(l+1)] ⊙ σ'(z^(l))；③参数梯度：∂L/∂W^(l) = δ^(l) · (a^(l-1))ᵀ，∂L/∂b^(l) = δ^(l)。其中 ⊙ 表示逐元素乘法（Hadamard乘积）。

大白话 反向传播就像是快递递送——损失是寄件人，各层参数是收件人。损失从顶层出发，每经过一层就"分发"一部分误差信号给该层的权重和偏置（∂L/∂W, ∂L/∂b），同时将剩余的误差信号继续向更浅层传递（δ 的链式传播）。最终每个参数都收到了属于自己的那份"错误账单"。

为什么（原理，可选）：反向传播公式的核心是 δ^(l) 的递推关系。从数学上看，链式法则要求 ∂L/∂z^(l) = ∂L/∂z^(l+1) · ∂z^(l+1)/∂a^(l) · ∂a^(l)/∂z^(l)，即 δ^(l) = [(W^(l+1))ᵀ·δ^(l+1)] ⊙ σ'(z^(l))。这里矩阵转置 (W^(l+1))ᵀ 将梯度从下一层"投射"回本层的每一个神经元——出度越大（该神经元连接到更多下一层神经元），收到的梯度信号越强。这个递推关系正是反向传播能够高效工作的数学核心。 怎么做（实现，可选）：

import numpy as np

def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))

def sigmoid_derivative(a):
    """Sigmoid 导数以激活值 a 为输入：σ'(z) = a(1-a)"""
    return a * (1 - a)

def forward_pass(x, params):
    """正向传播（返回所有中间值缓存）"""
    W1, b1, W2, b2, W3, b3 = params
    cache = {'a0': x}  # 输入
    
    cache['z1'] = W1 @ cache['a0'] + b1  # 第1层
    cache['a1'] = sigmoid(cache['z1'])
    
    cache['z2'] = W2 @ cache['a1'] + b1 * 0  # 第2层（简化: 复用 b1 形状）
    # 修正：使用独立偏置
    cache['z2'] = W2 @ cache['a1'] + b2
    cache['a2'] = sigmoid(cache['z2'])
    
    cache['z3'] = W3 @ cache['a2'] + b3  # 第3层（输出）
    cache['a3'] = sigmoid(cache['z3'])
    
    return cache

# 简化版（修正 bug）
def forward_pass_fixed(x, W1, b1, W2, b2, W3, b3):
    cache = {'a0': x}
    cache['z1'] = W1 @ cache['a0'] + b1
    cache['a1'] = sigmoid(cache['z1'])
    cache['z2'] = W2 @ cache['a1'] + b2
    cache['a2'] = sigmoid(cache['z2'])
    cache['z3'] = W3 @ cache['a2'] + b3
    cache['a3'] = cache['z3']  # 输出层使用恒等激活用于回归
    return cache

def backward_pass(cache, y, W1, W2, W3):
    """反向传播：按公式逐层计算梯度"""
    grads = {}
    m = 1  # 单样本
    
    # 输出层梯度（MSE 损失）
    # δ^(L) = ∂L/∂z^(L) = (ŷ - y) * 1（恒等激活 a'(z)=1）
    delta3 = cache['a3'] - y  # δ³
    
    # 输出层参数梯度
    grads['dW3'] = delta3 @ cache['a2'].T  # ∂L/∂W₃ = δ³ · a₂ᵀ
    grads['db3'] = delta3                   # ∂L/∂b₃ = δ³
    
    # 隐藏层2：δ² = [(W₃)ᵀ·δ³] ⊙ σ'(z²)
    delta2 = (W3.T @ delta3) * sigmoid_derivative(cache['a2'])
    grads['dW2'] = delta2 @ cache['a1'].T  # ∂L/∂W₂ = δ² · a₁ᵀ
    grads['db2'] = delta2
    
    # 隐藏层1：δ¹ = [(W₂)ᵀ·δ²] ⊙ σ'(z¹)
    delta1 = (W2.T @ delta2) * sigmoid_derivative(cache['a1'])
    grads['dW1'] = delta1 @ cache['a0'].T  # ∂L/∂W₁ = δ¹ · a₀ᵀ
    grads['db1'] = delta1
    
    return grads

# 测试
np.random.seed(0)
input_dim, h1, h2, output_dim = 3, 4, 3, 1
W1 = np.random.randn(h1, input_dim) * 0.5
b1 = np.zeros((h1, 1))
W2 = np.random.randn(h2, h1) * 0.5
b2 = np.zeros((h2, 1))
W3 = np.random.randn(output_dim, h2) * 0.5
b3 = np.zeros((output_dim, 1))

x = np.array([[1.0], [0.5], [-0.5]])
y = np.array([[2.0]])

cache = forward_pass_fixed(x, W1, b1, W2, b2, W3, b3)
grads = backward_pass(cache, y, W1, W2, W3)

print("=== 反向传播梯度计算 ===\n")
print(f"网络：输入({input_dim}) → h1({h1}) → h2({h2}) → 输出({output_dim})")
print(f"预测 ŷ = {cache['a3'][0,0]:.4f}, 目标 y = {y[0,0]:.1f}")
print(f"损失 L = {0.5*(cache['a3'][0,0]-y[0,0])**2:.6f}\n")

for key in ['dW1', 'db1', 'dW2', 'db2', 'dW3', 'db3']:
    g = grads[key]
    print(f"{key}: shape={g.shape}, 梯度模长 ||∇|| = {np.sqrt(np.sum(g**2)):.6f}")

# 验证反向传播的正确性（数值梯度检查）
print("\n--- 梯度检查（数值 vs 反向传播）---")
h = 1e-6

def forward_and_loss(x, W1, b1, W2, b2, W3, b3, y):
    """计算前向传播和损失"""
    cache = forward_pass_fixed(x, W1, b1, W2, b2, W3, b3)
    return 0.5 * np.sum((cache['a3'] - y)**2)

# 验证 ∂L/∂W₁ 的第一个元素
W1_plus = W1.copy(); W1_plus[0,0] += h
W1_minus = W1.copy(); W1_minus[0,0] -= h
L_plus = forward_and_loss(x, W1_plus, b1, W2, b2, W3, b3, y)
L_minus = forward_and_loss(x, W1_minus, b1, W2, b2, W3, b3, y)
num_grad = (L_plus - L_minus) / (2*h)
print(f"∂L/∂W₁[0,0]: 反向传播 = {grads['dW1'][0,0]:.10f}, 数值 = {num_grad:.10f}")
print(f"相对误差 = {abs(grads['dW1'][0,0] - num_grad) / max(abs(grads['dW1'][0,0]), abs(num_grad)):.2e}")

什么用（应用，可选）：反向传播公式是理解深度学习训练机制的关键。δ 递推公式解释了为什么深度网络难训练——每传递一层梯度就乘以 σ'(z^(l)) ≤ 1（Sigmoid）或可能为 0（ReLU的负半轴），多层的乘积导致浅层梯度消失。也解释了为什么跳跃连接有效——它们提供了 δ 传播的"捷径"。公式中的 (W^(l+1))ᵀ 转置解释了为什么梯度计算的矩阵形状正好是正向传播矩阵的"转置"。 哪些坑（缺点，可选）：δ 递推要求所有激活函数可微——不可微的激活（如阶跃函数）需要次梯度（subgradient）替代。Sigmoid/Tanh 的 σ'(z) 在饱和区接近零，导致 δ 衰减（梯度消失）——ReLU和Leaky ReLU通过使 σ'(z) = 1（在正半轴）来缓解。此外，δ 在深层网络中的累积浮点误差可能影响训练精度。

四、手算一个简单神经网络的反向传播

是什么（定义，可选）：通过手工计算一个小型网络（2-2-1结构，即2输入、2隐藏神经元、1输出）的全部反向传播过程，从数值上验证梯度公式的正确性。这能帮助建立反向传播的肌肉记忆。

大白话 拿一个最小的网络——只有两个输入、两个隐藏神经元和一个输出——像做算术题一样，从输入一路算到输出，再从损失一路回溯到每个权重。这不是为了让你以后每次都手算，而是让你"亲眼看到"梯度是怎么通过矩阵乘法和导数链一步步传回来的。一旦亲手算过一次，用框架时就不会一头雾水了。

为什么（原理，可选）：手工推算一个微型网络是深入理解反向传播的最佳途径。很多工程师虽然每天使用 autograd（自动微分），但很少真正理解其内部机制。通过手工计算，你能深刻体会：①为什么反向传播的矩阵形状是正向的"转置"；②为什么梯度检查可以将数值梯度用作"标准答案"来验证反向传播；③为什么不同的损失函数和激活函数组合会产生不同的梯度传播特性。 怎么做（实现，可选）：

import numpy as np

# 手算反向传播：2-2-1 网络
# 输入层：x₁, x₂（2维）
# 隐藏层：h₁, h₂（2个神经元，Sigmoid激活）
# 输出层：ŷ（1个神经元，恒等激活，MSE损失）

print("=== 手算反向传播：2-2-1 微型网络 ===\n")

# 设置具体数值
x = np.array([1.0, 0.5])        # 输入 [x₁, x₂]
y = 1.0                          # 目标值

# 权重和偏置（具体小数值便于手算）
W1 = np.array([[0.2, 0.4],      # W₁ = [[w₁₁, w₁₂],
               [0.3, 0.1]])     #       [w₂₁, w₂₂]]
b1 = np.array([0.0, 0.0])       # b₁ = [b₁, b₂]

W2 = np.array([0.5, 0.6])       # W₂ = [w₃₁, w₃₂]  （行向量）
b2 = 0.0                         # b₂

print("【正向传播】")
# 隐藏层
z1 = x[0]*W1[0,0] + x[1]*W1[0,1] + b1[0]  # z₁ = x·w₁ + b₁
z2 = x[0]*W1[1,0] + x[1]*W1[1,1] + b1[1]  # z₂ = x·w₂ + b₂
print(f"z₁ = {x[0]}×{W1[0,0]} + {x[1]}×{W1[0,1]} = {z1:.2f}")
print(f"z₂ = {x[0]}×{W1[1,0]} + {x[1]}×{W1[1,1]} = {z2:.2f}")

a1 = 1/(1+np.exp(-z1))  # h₁ = σ(z₁)
a2 = 1/(1+np.exp(-z2))  # h₂ = σ(z₂)
print(f"a₁ = σ({z1:.2f}) = {a1:.4f}")
print(f"a₂ = σ({z2:.2f}) = {a2:.4f}")

# 输出层
z3 = a1*W2[0] + a2*W2[1] + b2  # z₃ = h₁·w₃₁ + h₂·w₃₂
y_pred = z3  # 恒等激活
print(f"z₃ = {a1:.4f}×{W2[0]} + {a2:.4f}×{W2[1]} = {z3:.4f}")
print(f"ŷ = {y_pred:.4f}")

# MSE 损失
loss = 0.5 * (y_pred - y)**2
print(f"L = ½(ŷ - y)² = ½({y_pred:.4f} - {y})² = {loss:.6f}")

print("\n【反向传播——逐层手算】")

# 输出层梯度
dL_dy_pred = y_pred - y  # ∂L/∂ŷ = ŷ - y
print(f"∂L/∂ŷ = ŷ - y = {y_pred:.4f} - {y} = {dL_dy_pred:.4f}")

# δ³（输出层误差，恒等激活 → σ'(z)=1）
delta3 = dL_dy_pred * 1  # δ³ = ∂L/∂z₃
print(f"δ³ = ∂L/∂z₃ = {dL_dy_pred:.4f} × 1 = {delta3:.4f}")

# 输出层参数梯度
dL_dW2_1 = delta3 * a1  # ∂L/∂w₃₁ = δ³ · a₁
dL_dW2_2 = delta3 * a2  # ∂L/∂w₃₂ = δ³ · a₂
dL_db2 = delta3
print(f"∂L/∂w₃₁ = δ³·a₁ = {delta3:.4f}×{a1:.4f} = {dL_dW2_1:.4f}")
print(f"∂L/∂w₃₂ = δ³·a₂ = {delta3:.4f}×{a2:.4f} = {dL_dW2_2:.4f}")
print(f"∂L/∂b₂ = δ³ = {dL_db2:.4f}")

# 隐藏层 δ²
delta2_1 = delta3 * W2[0] * a1*(1-a1)  # δ²₁ = (W₃₁ᵀ·δ³) · σ'(z₁)
delta2_2 = delta3 * W2[1] * a2*(1-a2)  # δ²₂ = (W₃₂ᵀ·δ³) · σ'(z₂)
print(f"\nδ²₁ = δ³×w₃₁×σ'(z₁) = {delta3:.4f}×{W2[0]}×({a1:.4f}×{1-a1:.4f}) = {delta2_1:.4f}")
print(f"δ²₂ = δ³×w₃₂×σ'(z₂) = {delta3:.4f}×{W2[1]}×({a2:.4f}×{1-a2:.4f}) = {delta2_2:.4f}")

# 隐藏层参数梯度
dL_dW1_11 = delta2_1 * x[0]  # ∂L/∂w₁₁ = δ²₁ · x₁
dL_dW1_12 = delta2_1 * x[1]  # ∂L/∂w₁₂ = δ²₁ · x₂
dL_dW1_21 = delta2_2 * x[0]  # ∂L/∂w₂₁ = δ²₂ · x₁
dL_dW1_22 = delta2_2 * x[1]  # ∂L/∂w₂₂ = δ²₂ · x₂
dL_db1_1 = delta2_1
dL_db1_2 = delta2_2

print(f"\n∂L/∂W₁ = [[∂L/∂w₁₁, ∂L/∂w₁₂], [∂L/∂w₂₁, ∂L/∂w₂₂]]")
print(f"        = [[{dL_dW1_11:.4f}, {dL_dW1_12:.4f}], [{dL_dW1_21:.4f}, {dL_dW1_22:.4f}]]")
print(f"\n∂L/∂b₁ = [{dL_db1_1:.4f}, {dL_db1_2:.4f}]")

# 梯度下降一步更新
lr = 0.1
print(f"\n【梯度下降更新（η = {lr}）】")
print(f"W₁_new = W₁ - η·∂L/∂W₁")
print(f"       = {W1.round(4)} - {lr}×[[{dL_dW1_11:.4f},{dL_dW1_12:.4f}],[{dL_dW1_21:.4f},{dL_dW1_22:.4f}]]")
W1_new = W1 - lr * np.array([[dL_dW1_11, dL_dW1_12], [dL_dW1_21, dL_dW1_22]])
print(f"       = {W1_new.round(4)}")

W2_new = W2 - lr * np.array([dL_dW2_1, dL_dW2_2])
print(f"W₂_new = {W2.round(4)} - {lr}×[{dL_dW2_1:.4f},{dL_dW2_2:.4f}] = {W2_new.round(4)}")

什么用（应用，可选）：手工推算微型网络的价值在于建立对反向传播的直觉——之后使用PyTorch时你能"想象"backward()内部在做什么。这对于调试自定义层的梯度（梯度检查）、理解为什么某一层的梯度为零（trace backward）、以及设计新的网络结构都至关重要。这也是面试中的高频考点。 哪些坑（缺点，可选）：手工计算极易出错——特别是Sigmoid导数中的 a(1-a) 项和矩阵维度的匹配。实际网络有数百万参数，手工计算显然不可能。但正因为理解了一个微型网络的全部计算细节，你才能信任自动微分框架的计算结果。数值梯度检查（numerical gradient checking）是验证手工计算和代码实现的黄金标准。

五、AI中的反向传播——自动微分

是什么（定义，可选）：自动微分（Automatic Differentiation, AD）是计算程序精确导数的一族技术。现代深度学习框架使用反向模式自动微分（reverse-mode AD），它在执行程序时记录所有基本运算（加法、乘法、sin、exp等），然后在反向传播时利用链式法则从输出到输入累积梯度。用户视角下，只需调用 loss.backward() 即可获得全部梯度。

大白话 自动微分就像在你的代码中埋设了无数个"梯度传感器"——每个数学运算（加减乘除、指数、三角函数）都知道自己的导数规则。当代码正向执行时，这些传感器默默记录下计算路径；当反向传播被触发时，它们按原路逆向激活，自动计算出每条路径上的梯度并累积起来。你不需要写任何一个导数公式——框架帮你全做了。

为什么（原理，可选）：自动微分的核心实现依赖于计算图（DAG）和基本运算的雅可比矩阵。每个基本运算（如 +, *, sin, exp）都注册了其反向传播规则（VJP，向量-雅可比乘积）。通过将这些基本规则按计算图拓扑排序后依次执行，就能从输出端到输入端累积梯度。反向模式AD的复杂度为 O(n_outputs × ops)，对于神经网络（多输入→标量损失输出）极其高效。 怎么做（实现，可选）：

import numpy as np

# 用 NumPy 模拟一个极简的自动微分引擎
class Tensor:
    """简化的自动微分张量（类似 PyTorch 的 autograd）"""
    def __init__(self, data, requires_grad=False):
        self.data = np.array(data, dtype=float)  # 数据
        self.grad = None                          # 梯度（初始为 None）
        self.requires_grad = requires_grad
        self._backward_fn = lambda: None          # 反向传播函数
        self._prev_tensors = []                   # 输入张量
    
    def backward(self):
        """触发反向传播"""
        if self.grad is None:
            self.grad = np.ones_like(self.data)  # 标量输出：self.grad = 1
        # 拓扑排序后反向执行
        # （简化实现直接递归回溯）
        self._backward_recursive()
    
    def _backward_recursive(self):
        """执行当前节点的 backward 并递归到输入"""
        self._backward_fn()
        for t in self._prev_tensors:
            if t.requires_grad:
                t._backward_recursive()
    
    def __add__(self, other):
        """加法：支持 Tensor + Tensor 或 Tensor + 标量"""
        other = other if isinstance(other, Tensor) else Tensor(other)
        out = Tensor(self.data + other.data)
        out.requires_grad = self.requires_grad or other.requires_grad
        out._prev_tensors = [self, other]
        
        def _backward():
            if self.requires_grad:
                if self.grad is None:
                    self.grad = out.grad.copy()
                else:
                    self.grad += out.grad  # 加法对两个输入的梯度都是 1
            if other.requires_grad:
                if other.grad is None:
                    other.grad = out.grad.copy()
                else:
                    other.grad += out.grad
        out._backward_fn = _backward
        return out
    
    def __mul__(self, other):
        """乘法"""
        other = other if isinstance(other, Tensor) else Tensor(other)
        out = Tensor(self.data * other.data)
        out.requires_grad = self.requires_grad or other.requires_grad
        out._prev_tensors = [self, other]
        
        def _backward():
            if self.requires_grad:
                grad = out.grad * other.data  # ∂(a·b)/∂a = b
                if self.grad is None:
                    self.grad = grad.copy()
                else:
                    self.grad += grad
            if other.requires_grad:
                grad = out.grad * self.data  # ∂(a·b)/∂b = a
                if other.grad is None:
                    other.grad = grad.copy()
                else:
                    other.grad += grad
        out._backward_fn = _backward
        return out
    
    def sigmoid(self):
        """Sigmoid 激活"""
        s = 1.0 / (1.0 + np.exp(-self.data))
        out = Tensor(s)
        out.requires_grad = self.requires_grad
        out._prev_tensors = [self]
        
        def _backward():
            if self.requires_grad:
                grad = out.grad * (out.data * (1 - out.data))  # σ'(x) = σ(x)(1-σ(x))
                if self.grad is None:
                    self.grad = grad.copy()
                else:
                    self.grad += grad
        out._backward_fn = _backward
        return out
    
    def __repr__(self):
        grad_str = f", grad={self.grad}" if self.grad is not None else ""
        return f"Tensor({self.data}{grad_str})"

# 测试：构建与 PyTorch 相似的自动微分体验
print("=== 极简自动微分引擎 ===\n")

# 模拟：z = sigmoid(x₁·w₁ + x₂·w₂ + b)
x1 = Tensor(2.0, requires_grad=True)
x2 = Tensor(0.5, requires_grad=True)
w1 = Tensor(-3.0, requires_grad=True)
w2 = Tensor(1.0, requires_grad=True)
b = Tensor(0.5, requires_grad=True)

# 前向传播（自动建立计算图）
term1 = x1 * w1       # x₁·w₁
term2 = x2 * w2       # x₂·w₂
z_linear = term1 + term2 + b  # x₁w₁ + x₂w₂ + b
output = z_linear.sigmoid()    # σ(·)

print(f"前向传播结果: {output.data[0]:.6f}")

# 反向传播（自动计算所有梯度）
output.backward()

print("\n自动计算的梯度：")
print(f"  ∂output/∂x1 = {x1.grad[0]:.6f}")
print(f"  ∂output/∂x2 = {x2.grad[0]:.6f}")
print(f"  ∂output/∂w1 = {w1.grad[0]:.6f}")
print(f"  ∂output/∂w2 = {w2.grad[0]:.6f}")
print(f"  ∂output/∂b  = {b.grad[0]:.6f}")

# 数值梯度验证
h = 1e-6
num_grad_w1 = ((1/(1+np.exp(-(2.0*(w1.data[0]+h)+0.5*1.0+0.5))) - 
                1/(1+np.exp(-(2.0*(w1.data[0]-h)+0.5*1.0+0.5)))) / (2*h))
print(f"\n数值梯度 ∂output/∂w1 = {num_grad_w1:.6f} (验证通过 ✓)")

print("\n这就是 PyTorch/TensorFlow 在背后为你做的事情！")
print("只需 loss.backward()，自动微分就帮你算好了所有参数的梯度。")

什么用（应用，可选）：理解自动微分的内部原理，你就能在需要时实现自定义的 autograd 操作（PyTorch的 torch.autograd.Function），处理那些框架原生不支持的操作（如自定义量化、自定义稀疏操作）。这也是理解梯度检查点（checkpointing）、二阶梯度（grad of grad，用于元学习）等高阶功能的前提。自动微分为整个现代AI提供了"免费"的梯度计算。 哪些坑（缺点，可选）：自动微分不是魔法——它依赖计算图的完整性。在PyTorch中，如果使用原地操作（in-place operation）修改了需要梯度的张量，会破坏计算图导致 backward() 失败。另外，控制流（if/while）虽然被动态图支持，但会导致计算图在每次迭代时变化，需要特别注意。对于不可微操作（argmax、采样），梯度为None是预期的行为。

概念关系图谱

重点答疑

Q1: 为什么反向传播要存储正向传播的中间值？

链式法则要求 f'(g(x))·g'(x)——你需要知道 g(x) 的值（中间激活值）来计算 f'(g(x))。例如，在 a^(l) = σ(z^(l)) 的反向传播中，σ'(z^(l)) = a^(l)(1-a^(l)) 需要 a^(l) 的值。因此正向传播必须"记住"每一层的输出（激活值），供反向传播使用。这就是训练时的内存消耗比推理时大得多的原因。

Q2: 反向传播的复杂度为什么是 O(N) 而非 O(N²)？

反向传播使用动态规划的核心技巧：不重复计算共享子路径的梯度。在计算图中，一个中间节点可能被多条路径依赖——如果为每个参数独立地从输出遍历到该参数，总复杂度是 O(N²)。反向传播从输出向输入拓扑遍历，每个节点的梯度只计算一次并缓存，然后在需要时直接使用——这就是 O(N) 复杂度的来源。

Q3: 什么是"梯度检查"？为什么需要它？

梯度检查是用数值梯度（有限差分）来验证反向传播计算出的解析梯度是否正确的过程。由于反向传播的公式推导和实现可能出错（如矩阵转置遗漏、符号错误），梯度检查提供了一个独立验证手段。公式：|∂f/∂θ_num - ∂f/∂θ_bp| / (|∂f/∂θ_num| + |∂f/∂θ_bp|) < 1e-6。PyTorch 提供了 torch.autograd.gradcheck() 来辅助验证自定义层。

Q4: cross-entropy + softmax 的梯度为什么是 ŷ - y 这么简单？

这是损失函数和激活函数巧妙设计的结果。Softmax的导数是 ∂ŷᵢ/∂zⱼ = ŷᵢ(δᵢⱼ - ŷⱼ)，交叉熵的导数是 ∂L/∂ŷᵢ = -yᵢ/ŷᵢ。两者通过链式法则相乘后，Softmax导数中的 ŷᵢ 因子与交叉熵分母的 ŷᵢ 恰好"抵消"，最终得到 ∂L/∂z = ŷ - y。这个简洁的形式消除了激活函数饱和的影响，使得即使当 ŷ 接近 0 或 1 时梯度仍然合理。

Q5: PyTorch 的 backward() 和手动实现的反向传播有何不同？

PyTorch 使用反向模式自动微分：它记录了前向传播时所有基本运算（加减乘除、sin、exp等）的计算图，每个基本运算都注册了其 VJP（向量-雅可比乘积）。backward() 触发时，它从 loss 节点开始，按计算图反向拓扑排序，在每个节点执行其 VJP，自动累积梯度。手动实现的反向传播需要推导并硬编码整个网络的梯度公式——对复杂网络几乎不可行。PyTorch 让深度学习的梯度计算变得透明。

章节单词汇总