BP反向传播神经网络训练：从数学原理到Python实现

1次阅读

没有评论

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

反向传播（Backpropagation，BP）是神经网络训练的核心算法，但初学者往往会在理解和实现过程中遇到各种困难。

核心难点 ：BP 算法需要同时处理前向传播的预测计算和反向传播的误差传递，涉及大量矩阵运算和梯度计算。任何一个小错误都可能导致整个网络无法收敛。
常见误区 ：
对链式法则理解不足，导致梯度计算错误
忽略权重矩阵的维度匹配问题
未实现梯度检查（Gradient Checking），直接进入训练
学习率设置不合理，导致训练不稳定

对于一个简单的神经元，前向传播可以表示为：

$$
z = w^T x + b\
a = \sigma(z)
$$

其中：
– $w$ 是权重向量
– $x$ 是输入向量
– $b$ 是偏置项
– $\sigma$ 是激活函数

权重更新需要通过损失函数 $L$ 对权重 $w$ 的梯度来计算：

$$
\frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w}
$$

这就是 BP 算法的核心：通过链式法则将误差从输出层逐层反向传播到输入层。

以下是双层神经网络的完整实现：

import numpy as np

class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size):
        # 权重初始化（注意维度）self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        self.b2 = np.zeros(output_size)

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def forward(self, X):
        # 前向传播
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2

    def backward(self, X, y, learning_rate=0.1):
        # 反向传播
        m = X.shape[0]  # 样本数量

        # 输出层误差
        delta2 = (self.a2 - y) * self.sigmoid_derivative(self.a2)
        dW2 = np.dot(self.a1.T, delta2) / m
        db2 = np.sum(delta2, axis=0) / m

        # 隐藏层误差
        delta1 = np.dot(delta2, self.W2.T) * self.sigmoid_derivative(self.a1)
        dW1 = np.dot(X.T, delta1) / m
        db1 = np.sum(delta1, axis=0) / m

        # 更新权重
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

识别方法 ：训练过程中损失值突然变为 NaN 或变得极大
解决方案 ：
使用梯度裁剪（Gradient Clipping）
尝试不同的权重初始化方法（如 Xavier 初始化）
使用 ReLU 等非饱和激活函数

推荐初始范围：0.001 到 0.1
实现学习率衰减：

learning_rate = initial_lr * (1. / (1. + decay_rate * epoch))

在正式训练前，务必进行梯度检查：

def gradient_check(network, X, y, epsilon=1e-7):
    # 计算数值梯度
    params = network.get_parameters()
    num_grad = np.zeros_like(params)

    for i in range(len(params)):
        param_plus = np.copy(params)
        param_plus[i] += epsilon
        network.set_parameters(param_plus)
        loss_plus = network.compute_loss(X, y)

        param_minus = np.copy(params)
        param_minus[i] -= epsilon
        network.set_parameters(param_minus)
        loss_minus = network.compute_loss(X, y)

        num_grad[i] = (loss_plus - loss_minus) / (2 * epsilon)

    # 比较数值梯度和解析梯度
    analytic_grad = network.compute_gradients(X, y)
    difference = np.linalg.norm(num_grad - analytic_grad) / \
                (np.linalg.norm(num_grad) + np.linalg.norm(analytic_grad))

    if difference > 1e-7:
        print("梯度检查失败！差异：", difference)
    else:
        print("梯度检查通过！")

在 MNIST 数据集上测试我们的实现：