反向传播算法详解

反向传播（Backpropagation）是训练深度神经网络的核心算法，是链式法则在计算图中的高效应用。¹

1. 概述

1.1 问题定义

给定：

• 神经网络结构（层数、每层神经元数）
• 损失函数 $\mathcal{L}(\mathbf{y},\hat{\mathbf{y}})$
• 训练数据集 $\{({\mathbf{x}}^{(i)},{\mathbf{y}}^{(i)})\}$

目标：计算 $\frac{\partial \mathcal{L}}{\partial w_{ij}^{(l)}}$ 对所有权重

1.2 核心思想

反向传播通过两次计算图遍历实现高效梯度计算：

1. 前向传播：从输入到输出，计算预测值和损失
2. 反向传播：从输出到输入，利用链式法则计算梯度

时间复杂度：$O(|\text{参数}|)$，而非暴力差分的 $O(|\text{参数}|\times \text{前向代价})$

2. 数学基础

2.1 链式法则

一元链式法则：

$$\frac{d}{dx}f(g(x))=f^{\prime }(g(x))\cdot g^{\prime }(x)$$

多元链式法则：

$$\frac{\partial z}{\partial x}=\sum _{k=1}^K\frac{\partial z}{\partial y_k}\cdot \frac{\partial y_k}{\partial x}$$

2.2 梯度定义

对于标量函数 $f:{\mathbb{R}}^n\to \mathbb{R}$，梯度定义为：

$$\nabla f={\left[\frac{\partial f}{\partial x_1},\frac{\partial f}{\partial x_2},\dots ,\frac{\partial f}{\partial x_n}\right]}^T$$

对于向量函数 $\mathbf{f}:{\mathbb{R}}^n\to {\mathbb{R}}^m$，Jacobian矩阵：

$$J=\frac{\partial \mathbf{f}}{\partial \mathbf{x}}=\left[\begin{array}{ccc}\frac{\partial f_1}{\partial x_1}& \cdots & \frac{\partial f_1}{\partial x_n}\\ ⋮& \ddots & ⋮\\ \frac{\partial f_m}{\partial x_1}& \cdots & \frac{\partial f_m}{\partial x_n}\end{array}\right]$$

3. 神经网络前向传播

3.1 单层计算

考虑第 $l$ 层：

$${\mathbf{z}}^{(l)}=W^{(l)}{\mathbf{a}}^{(l-1)}+{\mathbf{b}}^{(l)}$$ $${\mathbf{a}}^{(l)}=\sigma ({\mathbf{z}}^{(l)})$$

其中：

• $W^{(l)}\in {\mathbb{R}}^{d_l\times d_{l-1}}$ 是权重矩阵
• ${\mathbf{b}}^{(l)}\in {\mathbb{R}}^{d_l}$ 是偏置向量
• ${\mathbf{a}}^{(l)}\in {\mathbb{R}}^{d_l}$ 是激活输出
• $\sigma (\cdot )$ 是逐元素激活函数

3.2 损失函数

均方误差（MSE）：

$$\mathcal{L}=\frac{1}{2}\Vert \mathbf{y}-\hat{\mathbf{y}}{\Vert }^2=\frac{1}{2}\sum _{i=1}^K(y_i-{\hat{y}}_i{)}^2$$

交叉熵损失（多分类）：

$$\mathcal{L}=-\sum _{i=1}^K{y}_i\log {\hat{y}}_i$$

4. 反向传播四方程

令 ${\delta }_j^{(l)}=\frac{\partial \mathcal{L}}{\partial z_j^{(l)}}$ 表示第 $l$ 层第 $j$ 个神经元的误差。

4.1 输出层误差（方程1）

$${\delta }_j^{(L)}=\frac{\partial \mathcal{L}}{\partial a_j^{(L)}}\cdot {\sigma }^{\prime }(z_j^{(L)})$$

向量形式：

$${\mathbf{\delta }}^{(L)}={\nabla }_a\mathcal{L}\odot {\sigma }^{\prime }({\mathbf{z}}^{(L)})$$

其中 $\odot$ 是Hadamard积（逐元素乘积）。

MSE损失：

$${\delta }_j^{(L)}=(a_j^{(L)}-y_j)\cdot {\sigma }^{\prime }(z_j^{(L)})$$

交叉熵 + Softmax（组合使用）：

$${\delta }_j^{(L)}=a_j^{(L)}-y_j$$

（此时 ${\sigma }^{\prime }(z)$ 恰好约掉）

4.2 隐藏层误差传递（方程2）

已知第 $(l+1)$ 层误差，计算第 $l$ 层误差：

$${\delta }_j^{(l)}=\sum _{k=1}^{d_{l+1}}{\delta }_k^{(l+1)}\cdot W_{kj}^{(l+1)}\cdot {\sigma }^{\prime }(z_j^{(l)})$$

向量形式：

$${\mathbf{\delta }}^{(l)}=(W^{(l+1)}{)}^T{\mathbf{\delta }}^{(l+1)}\odot {\sigma }^{\prime }({\mathbf{z}}^{(l)})$$

4.3 权重梯度（方程3）

$$\frac{\partial \mathcal{L}}{\partial W_{ij}^{(l)}}=a_i^{(l-1)}\cdot {\delta }_j^{(l)}$$

矩阵形式：

$$\frac{\partial \mathcal{L}}{\partial W^{(l)}}={\mathbf{\delta }}^{(l)}({\mathbf{a}}^{(l-1)}{)}^T$$

4.4 偏置梯度（方程4）

$$\frac{\partial \mathcal{L}}{\partial b_j^{(l)}}={\delta }_j^{(l)}$$

向量形式：

$$\frac{\partial \mathcal{L}}{\partial {\mathbf{b}}^{(l)}}={\mathbf{\delta }}^{(l)}$$

5. 具体示例

5.1 两层网络推导

考虑简单网络：

• 输入 $\mathbf{x}\in {\mathbb{R}}^2$
• 隐藏层：${\mathbf{z}}^{(1)}=W^{(1)}\mathbf{x}+{\mathbf{b}}^{(1)}$，${\mathbf{a}}^{(1)}=\sigma ({\mathbf{z}}^{(1)})$
• 输出层：${\mathbf{z}}^{(2)}=W^{(2)}{\mathbf{a}}^{(1)}+{\mathbf{b}}^{(2)}$，$\hat{y}=\sigma (z^{(2)})$
• 损失：$\mathcal{L}=\frac{1}{2}(y-\hat{y}{)}^2$

Step 1：前向传播

$$z_1^{(1)}=W_{11}^{(1)}{x}_1+W_{12}^{(1)}{x}_2+b_1^{(1)}$$ $$a_1^{(1)}=\sigma (z_1^{(1)})$$ $$\hat{y}=\sigma (W_1^{(2)}{a}_1^{(1)}+b^{(2)})$$

Step 2：计算输出层误差

$${\delta }^{(2)}=(a^{(2)}-y)\cdot {\sigma }^{\prime }(z^{(2)})=(a^{(2)}-y)\cdot a^{(2)}(1-a^{(2)})$$

Step 3：隐藏层误差反向传播

$${\delta }_1^{(1)}={\delta }^{(2)}\cdot W_1^{(2)}\cdot {\sigma }^{\prime }(z_1^{(1)})$$

Step 4：计算梯度

对 $W^{(2)}$：

$$\frac{\partial \mathcal{L}}{\partial W_1^{(2)}}={\delta }^{(2)}\cdot a_1^{(1)}$$

对 $W^{(1)}$：

$$\frac{\partial \mathcal{L}}{\partial W_{11}^{(1)}}={\delta }_1^{(1)}\cdot x_1$$ $$\frac{\partial \mathcal{L}}{\partial W_{12}^{(1)}}={\delta }_1^{(1)}\cdot x_2$$

5.2 矩阵形式完整推导

import numpy as np
 
def backpropagation_example(X, Y, W1, b1, W2, b2, lr=0.01):
    """
    简化的两层神经网络反向传播示例
    """
    m = X.shape[1]  # 样本数
    
    # ============ 前向传播 ============
    # 隐藏层
    Z1 = W1 @ X + b1
    A1 = np.tanh(Z1)  # 激活函数
    
    # 输出层
    Z2 = W2 @ A1 + b2
    A2 = 1 / (1 + np.exp(-Z2))  # Sigmoid
    
    # 损失 (MSE)
    loss = np.sum((A2 - Y) ** 2) / m
    
    # ============ 反向传播 ============
    # 输出层误差 (δ²)
    dZ2 = (A2 - Y) * A2 * (1 - A2)  # dL/dZ²
    
    # 权重梯度
    dW2 = (1/m) * dZ2 @ A1.T
    db2 = (1/m) * np.sum(dZ2, axis=1, keepdims=True)
    
    # 隐藏层误差 (δ¹)
    dZ1 = (W2.T @ dZ2) * (1 - A1**2)  # tanh的导数
    
    # 权重梯度
    dW1 = (1/m) * dZ1 @ X.T
    db1 = (1/m) * np.sum(dZ1, axis=1, keepdims=True)
    
    # ============ 梯度下降 ============
    W1 -= lr * dW1
    b1 -= lr * db1
    W2 -= lr * dW2
    b2 -= lr * db2
    
    return loss

6. 常见激活函数导数

激活函数	函数	导数
Sigmoid	$\sigma (x)=\frac{1}{1+e^{-x}}$	$\sigma (x)(1-\sigma (x))$
Tanh	$\tanh (x)$	$1-{\tanh }^2(x)$
ReLU	$\max (0,x)$	$\{\begin{array}{ll}1& x>0\\ 0& x\le 0\end{array}$
Leaky ReLU	$\max (\alpha x,x)$	$\{\begin{array}{ll}1& x>0\\ \alpha & x\le 0\end{array}$
Softmax	$\frac{e^{x_i}}{{\sum }_j{e}^{x_j}}$	$p_i({\delta }_{ij}-p_j)$

7. 向量化实现

7.1 Mini-batch梯度计算

实际应用中，梯度按mini-batch计算：

$$\frac{\partial \mathcal{L}}{\partial W^{(l)}}=\frac{1}{m_{batch}}\sum _{i=1}^{m_{batch}}{\delta }^{(l)(i)}({\mathbf{a}}^{(l-1)(i)}{)}^T$$

矩阵形式：

# 误差: (n_l, batch_size)
# 激活: (n_{l-1}, batch_size)
# 梯度: (n_l, n_{l-1})
dW = delta @ a_prev.T / batch_size

7.2 PyTorch自动微分

现代框架使用计算图和自动微分：

import torch
import torch.nn as nn
 
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()
    
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x
 
# 使用示例
model = SimpleNet(784, 256, 10)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
 
# 前向传播
x = torch.randn(32, 784)  # batch_size=32
y = torch.randint(0, 10, (32,))
output = model(x)
loss = criterion(output, y)
 
# 反向传播（自动计算梯度）
loss.backward()
 
# 查看梯度
print(model.fc1.weight.grad.shape)  # torch.Size([256, 784])

8. 梯度检查（Gradient Checking）

数值梯度近似作为验证：

$$\frac{\partial \mathcal{L}}{\partial {\theta }_i}\approx \frac{\mathcal{L}({\theta }_1,\dots ,{\theta }_i+ϵ,\dots )-\mathcal{L}({\theta }_1,\dots ,{\theta }_i-ϵ,\dots )}{2ϵ}$$

相对误差：

$$r=\frac{|d_i-g_i|}{\max (|d_i|,|g_i|)}$$

检查标准：

• $r<10^{-7}$：非常好
• $r<10^{-5}$：可能有bug
• $r>10^{-3}$：几乎肯定有bug

def gradient_check(model, X, Y, epsilon=1e-7):
    """梯度检查实现"""
    for name, param in model.named_parameters():
        if param.grad is None:
            continue
        
        # 解析梯度
        analytical_grad = param.grad.data.numpy()
        
        # 数值梯度
        numerical_grad = np.zeros_like(analytical_grad)
        param_flat = param.data.numpy().flatten()
        
        for i in range(len(param_flat)):
            # f(θ + ε)
            param.data.flatten()[i] += epsilon
            loss_plus = compute_loss(model, X, Y)
            
            # f(θ - ε)
            param.data.flatten()[i] -= 2*epsilon
            loss_minus = compute_loss(model, X, Y)
            
            # 恢复
            param.data.flatten()[i] += epsilon
            
            numerical_grad.flatten()[i] = (loss_plus - loss_minus) / (2*epsilon)
        
        # 计算相对误差
        diff = np.linalg.norm(numerical_grad - analytical_grad)
        norm = np.linalg.norm(numerical_grad) + np.linalg.norm(analytical_grad)
        relative_error = diff / norm
        
        if relative_error > 1e-5:
            print(f"Warning: {name}, error={relative_error}")
    
    return True

9. 计算复杂度分析

9.1 前向传播

每层计算量：$O(d_{l-1}\times d_l)$

总计算量：$O({\sum }_{l=1}^L{d}_{l-1}\cdot d_l)$

9.2 反向传播

反向传播计算量约为前向传播的两倍：

• 误差反向传播：$O({\sum }_{l=1}^L{d}_{l-1}\cdot d_l)$
• 梯度计算：$O({\sum }_{l=1}^L{d}_{l-1}\cdot d_l)$

9.3 内存复杂度

存储内容：

• 前向激活值：$O({\sum }_{l=0}^L{d}_l)$（训练时需要）
• 梯度：$O({\sum }_{l=1}^L{d}_{l-1}\cdot d_l)$

10. 常见问题与解决方案

10.1 梯度消失/爆炸

问题：深层网络中梯度可能指数级衰减或增长

解决方案：

• 合适的权重初始化（Xavier, He）
• Batch Normalization
• 残差连接（ResNet）
• LSTM/GRU的门控机制

10.2 鞍点问题

问题：在高维空间中，鞍点比局部最小值更常见

解决方案：

• 动量法
• Adam等自适应学习率优化器
• 学习率调度

10.3 数值稳定性

# Sigmoid数值稳定实现
def stable_sigmoid(x):
    return np.where(x >= 0,
                    1 / (1 + np.exp(-x)),
                    np.exp(x) / (1 + np.exp(x)))
 
# Softmax数值稳定实现
def stable_softmax(x):
    x_max = np.max(x, axis=-1, keepdims=True)
    x_exp = np.exp(x - x_max)
    return x_exp / np.sum(x_exp, axis=-1, keepdims=True)

11. 总结

反向传播的核心要点：

1. 链式法则：梯度的反向传播本质
2. 四方程框架：系统化梯度计算
3. 计算效率：$O(|\text{参数}|)$ 而非暴力差分
4. 计算图：现代框架自动微分的基础
5. 数值稳定：工程实现的关键考虑

理解反向传播的数学原理，对于：

• 调试梯度计算问题
• 设计新架构/层
• 理解优化器行为
• 进行理论研究

都至关重要。

参考文献

Footnotes

1. Rumelhart, D. E., Hinton, G. E., & Williams, R. J. (1986). Learning representations by back-propagating errors. Nature. ↩