BP算法反向传播实战：从数学推导到高效实现

1次阅读

共计 2231 个字符，预计需要花费 6 分钟才能阅读完成。

在神经网络训练过程中，反向传播 (BP) 算法是核心的优化手段。但传统实现方式存在几个明显痛点：

计算冗余：逐样本计算梯度导致大量重复运算，尤其在深层网络中表现更明显
梯度不稳定：随着网络深度增加，梯度可能指数级增大（爆炸）或减小（消失）
收敛困难：固定学习率难以适应不同参数层的更新需求

反向传播本质是链式法则的递归应用。以三层网络为例：

前向传播：
$$\mathbf{h} = \sigma(\mathbf{W}_1\mathbf{x} + \mathbf{b}_1)$$
$$\mathbf{\hat{y}} = \text{softmax}(\mathbf{W}_2\mathbf{h} + \mathbf{b}_2)$$
损失函数（交叉熵）：
$$L = -\sum y_i\log\hat{y}_i$$
反向传播 关键推导：
输出层梯度：
$$\frac{\partial L}{\partial \mathbf{W}_2} = (\mathbf{\hat{y}} – \mathbf{y})\mathbf{h}^T$$
隐藏层梯度：
$$\frac{\partial L}{\partial \mathbf{W}_1} = (\mathbf{W}_2^T(\mathbf{\hat{y}} – \mathbf{y})) \odot \sigma'(\mathbf{z}_1) \mathbf{x}^T$$

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # He 初始化避免梯度消失
        self.W1 = np.random.randn(hidden_size, input_size) * np.sqrt(2/input_size)
        self.b1 = np.zeros((hidden_size, 1))
        self.W2 = np.random.randn(output_size, hidden_size) * np.sqrt(2/hidden_size)
        self.b2 = np.zeros((output_size, 1))

    def forward(self, X):
        # 批量处理（矩阵转置保证维度一致）self.z1 = self.W1 @ X.T + self.b1
        self.h = relu(self.z1)
        self.z2 = self.W2 @ self.h + self.b2
        return softmax(self.z2)

    def backward(self, X, y, lr=0.01):
        m = X.shape[0]  # 样本数量

        # 输出层梯度
        dz2 = self.probs - y.T
        dW2 = dz2 @ self.h.T / m
        db2 = np.sum(dz2, axis=1, keepdims=True) / m

        # 隐藏层梯度
        dh = self.W2.T @ dz2
        dz1 = dh * relu_derivative(self.z1)
        dW1 = dz1 @ X / m
        db1 = np.sum(dz1, axis=1, keepdims=True) / m

        # 梯度裁剪（防止爆炸）for grad in [dW1, db1, dW2, db2]:
            np.clip(grad, -1, 1, out=grad)

        # 参数更新（带 Momentum）self.W1 -= lr * dW1
        self.b1 -= lr * db1
        self.W2 -= lr * dW2
        self.b2 -= lr * db2

Momentum：
$$v_{t} = \beta v_{t-1} + (1-\beta)\nabla_\theta$$
$$\theta = \theta – \alpha v_{t}$$
Adam（推荐默认参数）：
一阶矩估计：$m_t = \beta_1 m_{t-1} + (1-\beta_1)g_t$
二阶矩估计：$v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2$
偏差修正：$\hat{m}_t = m_t/(1-\beta_1^t)$

grad_norm = np.linalg.norm(grad)
if grad_norm > threshold:
    grad = grad * threshold / grad_norm

激活函数选择：
ReLU 家族（LeakyReLU/PReLU）适合隐藏层
输出层根据任务选择（softmax 分类 /sigmoid 二分类 / 线性回归）
权重初始化：
使用 Xavier/Glorot 初始化（tanh 激活）
使用 He 初始化（ReLU 激活）
避免全零初始化

批量归一化：

# 在激活函数前插入
batch_mean = np.mean(z, axis=1, keepdims=True)
batch_var = np.var(z, axis=1, keepdims=True)
z_hat = (z - batch_mean) / np.sqrt(batch_var + eps)
out = gamma * z_hat + beta