深度学习中的bp反向传播计算：从数学原理到高效实现

1次阅读

没有评论

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

反向传播（Backpropagation）是神经网络训练的核心算法，其本质是链式法则的递归应用。考虑一个简单全连接层的前向计算：

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

其中 $\sigma$ 为激活函数。定义损失函数 $L$ 对第 $l$ 层参数的梯度为：

输出层梯度（以 MSE 损失为例）：
$$ \frac{\partial L}{\partial a^{(L)}} = 2(a^{(L)} – y) $$
反向递归计算：
$$ \delta^{(l)} = (W^{(l+1)T}\delta^{(l+1)}) \odot \sigma'(z^{(l)}) $$
$$ \frac{\partial L}{\partial W^{(l)}} = \delta^{(l)}a^{(l-1)T} $$
$$ \frac{\partial L}{\partial b^{(l)}} = \delta^{(l)} $$

在深层网络中，传统按层计算的方式容易遇到：

梯度消失：当使用 sigmoid 激活函数时，$\sigma'(z)\in(0,0.25]$，多层连乘导致梯度指数衰减
计算冗余：逐元素操作无法利用现代 CPU/GPU 的并行计算能力
内存瓶颈：中间变量存储占用大量显存

import numpy as np

class NeuralNetwork:
    def __init__(self, layers, lr=0.01):
        self.weights = [np.random.randn(y, x)*0.1 
                        for x, y in zip(layers[:-1], layers[1:])]
        self.biases = [np.zeros((y, 1)) for y in layers[1:]]
        self.lr = lr

    def forward(self, x):
        """矩阵化前向传播"""
        self.activations = [x.T]
        self.zs = []
        for w, b in zip(self.weights, self.biases):
            z = w @ self.activations[-1] + b
            self.zs.append(z)
            self.activations.append(self._sigmoid(z))
        return self.activations[-1]

    def backward(self, x, y):
        """矩阵化反向传播"""
        m = x.shape[0]
        # 输出层误差
        delta = (self.activations[-1] - y.T) * \
                self._sigmoid_deriv(self.zs[-1])

        # 反向传播误差
        for l in range(len(self.weights)-1, 0, -1):
            # 梯度裁剪（防止爆炸）delta = np.clip(delta, -1, 1)
            # 参数更新
            self.weights[l] -= self.lr * delta @ self.activations[l].T / m
            self.biases[l] -= self.lr * np.mean(delta, axis=1, keepdims=True)

            # 计算上一层的 delta
            delta = (self.weights[l].T @ delta) * \
                    self._sigmoid_deriv(self.zs[l-1])

        # 更新第一层
        self.weights[0] -= self.lr * delta @ self.activations[0].T / m
        self.biases[0] -= self.lr * np.mean(delta, axis=1, keepdims=True)

    def _sigmoid(self, z):
        return 1/(1+np.exp(-z))

    def _sigmoid_deriv(self, z):
        s = self._sigmoid(z)
        return s * (1-s)

关键优化点：

使用 @ 运算符实现矩阵乘法，避免 for 循环
批量处理样本（x.shape[0]为 batch_size）
梯度裁剪防止数值不稳定

在 MNIST 数据集上对比不同策略的效果（3 层网络，hidden_size=64）：

策略	训练时间(s)	测试准确率
基础实现	142	92.3%
矩阵优化	63	93.1%
+ 学习率衰减	68	94.7%
+ 梯度裁剪	65	95.2%
Adam 优化器	58	96.8%

学习率策略：
初始值设为 0.1~0.001 范围
采用 cosine 衰减：$\eta_t = \eta_{min} + \frac{1}{2}(\eta_{max}-\eta_{min})(1+\cos(\frac{t\pi}{T}))$
梯度处理：
全局裁剪阈值设为 1.0~5.0
对 embedding 层单独设置较小裁剪阈值
数值稳定：
使用 log_softmax 代替原始 softmax
对交叉熵损失添加 epsilon=1e-8
并行计算：
使用 torch.nn.DataParallel 进行多 GPU 训练
采用混合精度训练（AMP）