BP神经网络反向传播过程详解：从数学推导到Python实现

1次阅读

没有评论

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

反向传播（Backpropagation）是训练 BP 神经网络的核心算法，通过计算损失函数对网络权重的梯度，指导权重更新以最小化误差。然而在实际应用中，开发者常面临以下挑战：

梯度消失 / 爆炸：深层网络中梯度可能指数级缩小或增大，导致训练停滞或数值溢出
计算效率低：全连接层的梯度计算涉及大量矩阵运算，未优化实现会显著拖慢训练速度
数值不稳定：激活函数选择不当可能导致梯度计算出现 NaN 或 inf 值

对于复合函数 $f(g(x))$，其导数计算遵循：
$$\frac{df}{dx} = \frac{df}{dg} \cdot \frac{dg}{dx}$$

考虑具有输入 $x$、权重 $w$、偏置 $b$ 和激活函数 $\sigma$ 的神经元：

前向传播：
$$z = w^Tx + b$$
$$a = \sigma(z)$$
损失函数 $L$ 对权重的梯度：
$$\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w} = \delta \cdot x$$
其中误差项 $\delta = \frac{\partial L}{\partial a} \sigma'(z)$

对于第 $l$ 层权重矩阵 $W^l$：

$$\frac{\partial L}{\partial W^l} = (\delta^l)^T \cdot a^{l-1}$$
$$\delta^l = (W^{l+1})^T \delta^{l+1} \odot \sigma'(z^l)$$

import numpy as np

class DenseLayer:
    def __init__(self, input_size, output_size, activation):
        self.W = np.random.randn(output_size, input_size) * 0.01
        self.b = np.zeros((output_size, 1))
        self.activation = activation

    def forward(self, X):
        self.X = X  # 缓存输入用于反向传播
        self.Z = np.dot(self.W, X) + self.b
        self.A = self._activate(self.Z)
        return self.A

    def backward(self, dA, reg_lambda=0.01):
        """
        :param dA: 上游传递的梯度 ∂L/∂A
        :param reg_lambda: L2 正则化系数
        :return: 传递给下层的梯度 ∂L/∂X
        """
        dZ = dA * self._activation_deriv(self.Z)  # 元素乘法
        dW = np.dot(dZ, self.X.T) + reg_lambda * self.W  # 加入 L2 正则项
        db = np.sum(dZ, axis=1, keepdims=True)
        dX = np.dot(self.W.T, dZ)
        return dX, dW, db

    def _activate(self, Z):
        if self.activation == 'sigmoid':
            return 1 / (1 + np.exp(-Z))
        elif self.activation == 'relu':
            return np.maximum(0, Z)

    def _activation_deriv(self, Z):
        if self.activation == 'sigmoid':
            s = 1 / (1 + np.exp(-Z))
            return s * (1 - s)
        elif self.activation == 'relu':
            return (Z > 0).astype(float)

指数衰减：
$$\eta_t = \eta_0 \cdot \gamma^{t}$$
自适应方法：
Adam 优化器结合动量与自适应学习率
RMSProp 根据梯度幅度调整学习率

ReLU：梯度为 0 或 1，缓解梯度消失但可能导致神经元死亡
LeakyReLU：负区间保留小梯度，避免神经元死亡
SELU：自归一化特性，适合深层网络

def clip_grads(grads, max_norm):
    total_norm = np.sqrt(sum(np.sum(g**2) for g in grads.values()))
    scale = max_norm / (total_norm + 1e-6)
    if scale < 1:
        return {k: g*scale for k,g in grads.items()}
    return grads

使用对数空间计算交叉熵损失
初始化权重遵循 Xavier/Glorot 规则：
$$W \sim \mathcal{N}(0, \sqrt{\frac{2}{n_{in} + n_{out}}})$$

实现矩阵化运算，避免循环处理单个样本
使用 keepdims=True 保持梯度维度一致

通过数值梯度检验解析梯度：

def numerical_grad(f, x, eps=1e-4):
    grad = np.zeros_like(x)
    it = np.nditer(x, flags=['multi_index'])
    while not it.finished:
        idx = it.multi_index
        tmp = x[idx]

        x[idx] = tmp + eps
        f1 = f(x)

        x[idx] = tmp - eps
        f2 = f(x)

        grad[idx] = (f1 - f2) / (2*eps)
        x[idx] = tmp
        it.iternext()
    return grad