BP神经网络Python实现：梯度下降算法优化与避坑指南

1次阅读

没有评论

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

在手动实现 BP 神经网络时，开发者常会遇到以下几个典型问题：

梯度消失 ：当网络层数较深时，反向传播的梯度会逐层衰减，导致底层权重几乎不更新。例如使用 sigmoid 激活函数时，其导数最大值为 0.25，经过多层连乘后梯度会指数级缩小。
学习率选择困难 ：固定学习率要么导致收敛缓慢（学习率过小），要么引发震荡（学习率过大）。实践中需要反复调参才能找到合适值。
局部最优陷阱 ：标准梯度下降容易陷入局部最优解，特别是在非凸损失函数中，模型可能卡在次优位置无法继续优化。

原理：计算整个训练集的平均梯度后更新权重
优点：更新方向稳定
缺点：计算开销大，内存要求高

公式表示：
$$\theta_{t+1} = \theta_t – \eta \cdot \frac{1}{m}\sum_{i=1}^m \nabla_\theta J(\theta; x^{(i)}, y^{(i)})$$

原理：每次随机选择一个样本计算梯度
优点：计算速度快，可在线学习
缺点：更新波动大，收敛不稳定

原理：引入动量项积累历史梯度方向
优点：加速收敛，减少震荡
公式：
$$v_t = \gamma v_{t-1} + \eta \nabla_\theta J(\theta)$$
$$\theta_{t+1} = \theta_t – v_t$$

import numpy as np
from tqdm import tqdm

class NeuralNetwork:
    def __init__(self, layer_sizes, learning_rate=0.01, momentum=0.9):
        """
        初始化网络结构
        :param layer_sizes: 各层神经元数量，如 [784, 256, 10]
        :param learning_rate: 初始学习率
        :param momentum: 动量系数
        """
        self.layer_sizes = layer_sizes
        self.learning_rate = learning_rate
        self.momentum = momentum

        # He 初始化权重
        self.weights = [np.random.randn(y, x) * np.sqrt(2/x) 
                        for x, y in zip(layer_sizes[:-1], layer_sizes[1:])]
        self.biases = [np.zeros((y, 1)) for y in layer_sizes[1:]]

        # 动量项初始化
        self.v_w = [np.zeros_like(w) for w in self.weights]
        self.v_b = [np.zeros_like(b) for b in self.biases]

def forward(self, x):
    """前向传播计算输出"""
    a = x.T  # 转置为列向量
    activations = [a]
    zs = []

    for w, b in zip(self.weights, self.biases):
        z = np.dot(w, a) + b
        a = self.relu(z)  # 隐藏层使用 ReLU
        zs.append(z)
        activations.append(a)

    # 输出层使用 softmax
    activations[-1] = self.softmax(zs[-1])
    return activations, zs

def backward(self, x, y, activations, zs):
    """反向传播计算梯度"""
    # 初始化梯度
    grad_w = [np.zeros_like(w) for w in self.weights]
    grad_b = [np.zeros_like(b) for b in self.biases]

    # 输出层误差
    delta = (activations[-1] - y.T)  # 交叉熵损失 +softmax 的导数
    grad_b[-1] = np.sum(delta, axis=1, keepdims=True)
    grad_w[-1] = np.dot(delta, activations[-2].T)

    # 隐藏层误差传播
    for l in range(2, len(self.layer_sizes)):
        z = zs[-l]
        delta = np.dot(self.weights[-l+1].T, delta) * self.relu_derivative(z)
        grad_b[-l] = np.sum(delta, axis=1, keepdims=True)
        grad_w[-l] = np.dot(delta, activations[-l-1].T)

    return grad_w, grad_b

def update_params(self, grad_w, grad_b, batch_size):
    """带动量的权重更新"""
    for i in range(len(self.weights)):
        # 计算动量项
        self.v_w[i] = self.momentum * self.v_w[i] + self.learning_rate * grad_w[i]/batch_size
        self.v_b[i] = self.momentum * self.v_b[i] + self.learning_rate * grad_b[i]/batch_size

        # 应用更新
        self.weights[i] -= self.v_w[i]
        self.biases[i] -= self.v_b[i]

    # 学习率衰减
    self.learning_rate *= 0.999

问题：全零初始化会导致所有神经元学习相同的特征
解决：使用 Xavier 或 He 初始化，根据输入维度调整初始权重范围

# 在反向传播后添加
grad_w = [np.clip(gw, -1, 1) for gw in grad_w]
grad_b = [np.clip(gb, -1, 1) for gb in grad_b]

def train(self, X_train, y_train, X_val, y_val, epochs=100, batch_size=32):
    best_val_loss = float('inf')
    patience = 5
    wait = 0

    for epoch in tqdm(range(epochs)):
        # ... 训练过程...

        # 验证集评估
        val_loss = self.compute_loss(X_val, y_val)
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            wait = 0
        else:
            wait += 1
            if wait >= patience:
                print(f'Early stopping at epoch {epoch}')
                break

# 网络结构: [784, 256, 128, 10]
# 参数: learning_rate=0.01, momentum=0.9

Epoch 50/50 | Train Acc: 98.2% | Val Acc: 97.5%

import matplotlib.pyplot as plt

plt.plot(train_losses, label='Train')
plt.plot(val_losses, label='Validation')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()