BP神经网络训练中的误差反向传播算法：从数学原理到Python实现

1次阅读

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

误差反向传播（Backpropagation，简称 BP）算法是神经网络训练的基石，它通过高效计算梯度来优化网络参数。无论是简单的全连接网络还是复杂的深度模型，BP 算法都是实现端到端学习的关键。理解 BP 不仅有助于掌握深度学习核心机制，更能帮助开发者诊断和解决训练过程中的各类问题。

以单隐藏层网络为例，输入 $X$ 经过权重矩阵 $W^{[1]}$ 和激活函数 $g$ 得到隐藏层输出：
$$Z^{[1]} = W^{[1]}X + b^{[1]}$$
$$A^{[1]} = g(Z^{[1]})$$
最终输出层结果为：
$$\hat{Y} = g(Z^{[2]}) = g(W^{[2]}A^{[1]} + b^{[2]})$$

定义交叉熵损失 $L = -\frac{1}{m}\sum(y\log\hat{y}+(1-y)\log(1-\hat{y}))$，反向传播时首先计算输出层梯度：
$$\frac{\partial L}{\partial Z^{[2]}} = \hat{Y} – Y$$

隐藏层权重梯度计算（推导关键步骤）：
$$\frac{\partial L}{\partial W^{[2]}} = \frac{\partial L}{\partial Z^{[2]}}\frac{\partial Z^{[2]}}{\partial W^{[2]}} = (\hat{Y}-Y)A^{[1]T}$$
$$\frac{\partial L}{\partial W^{[1]}} = (W^{[2]T}(\hat{Y}-Y)) \odot g'(Z^{[1]}) X^T$$
其中 $\odot$ 表示逐元素乘法，$g’$ 为激活函数导数。

import numpy as np

class NeuralNetwork:
    def __init__(self, layer_dims):
        # 初始化参数（He 初始化适合 ReLU）self.parameters = {}
        for l in range(1, len(layer_dims)):
            self.parameters[f'W{l}'] = np.random.randn(layer_dims[l], layer_dims[l-1]) * np.sqrt(2/layer_dims[l-1])
            self.parameters[f'b{l}'] = np.zeros((layer_dims[l], 1))

    def relu(self, Z):
        return np.maximum(0, Z)

    def relu_derivative(self, dA, Z):
        # 解决死亡神经元问题：leaky ReLU 替代方案
        dZ = np.array(dA, copy=True)
        dZ[Z <= 0] = 0.01  # leaky 系数
        return dZ

    def forward_prop(self, X):
        # 带批量归一化的前向传播
        caches = []
        A = X
        L = len(self.parameters) // 2

        for l in range(1, L):
            W = self.parameters[f'W{l}']
            b = self.parameters[f'b{l}']
            Z = np.dot(W, A) + b
            # 批量归一化应在此处插入
            A = self.relu(Z)
            caches.append((Z, A))

        # 输出层使用 sigmoid
        Z = np.dot(self.parameters[f'W{L}'], A) + self.parameters[f'b{L}']
        AL = 1/(1+np.exp(-Z))
        return AL, caches

    def backward_prop(self, AL, Y, caches):
        grads = {}
        L = len(caches) + 1
        m = AL.shape[1]

        # 初始化反向传播
        dZL = AL - Y
        grads[f'dW{L}'] = np.dot(dZL, caches[-1][1].T) / m
        grads[f'db{L}'] = np.sum(dZL, axis=1, keepdims=True) / m

        # 隐藏层反向传播
        for l in reversed(range(L-1)):
            dA_prev = np.dot(self.parameters[f'W{l+2}'].T, dZL)
            dZ = self.relu_derivative(dA_prev, caches[l][0])
            grads[f'dW{l+1}'] = np.dot(dZ, (caches[l-1][1] if l>0 else X).T) / m
            grads[f'db{l+1}'] = np.sum(dZ, axis=1, keepdims=True) / m
            dZL = dZ

        # 梯度裁剪（防止爆炸）for grad in grads.values():
            np.clip(grad, -5, 5, out=grad)

        return grads

    def update_params(self, grads, learning_rate):
        # 带学习率衰减的参数更新
        for key in self.parameters:
            self.parameters[key] -= learning_rate * grads[f'd{key}']

现象：某些神经元永远输出 0 且无法恢复
解决方案：
使用 Leaky ReLU（代码已实现）
初始化时采用 He 初始化
设置较小的学习率

实施位置：全连接层之后、激活函数之前
测试阶段需使用移动平均的统计量
与 dropout 同时使用时注意顺序

def gradient_check(parameters, grads, X, Y, epsilon=1e-7):
    # 将参数展平
    params = np.concatenate([v.flatten() for v in parameters.values()])
    grad_approx = np.zeros_like(params)

    for i in range(len(params)):
        # 计算 J_plus
        params_plus = np.copy(params)
        params_plus[i] += epsilon
        AL, _ = forward_prop(X, vector_to_dict(params_plus))
        J_plus = compute_cost(AL, Y)

        # 计算 J_minus
        params_minus = np.copy(params)
        params_minus[i] -= epsilon
        AL, _ = forward_prop(X, vector_to_dict(params_minus))
        J_minus = compute_cost(AL, Y)

        grad_approx[i] = (J_plus - J_minus) / (2*epsilon)

    # 与反向传播结果比较
    grad = np.concatenate([v.flatten() for v in grads.values()])
    difference = np.linalg.norm(grad - grad_approx) / (np.linalg.norm(grad) + np.linalg.norm(grad_approx))

    if difference > 1e-7:
        print("可能存在梯度计算错误！差异度：", difference)