BP神经网络Python实战：从数学推导到工业级实现

1次阅读

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

在实现 BP 神经网络时，开发者常会遇到三个棘手问题：梯度计算不稳定导致训练波动大、全量数据训练耗时过长、隐层节点数选择缺乏明确依据。这些问题直接影响模型效果和开发效率，需要我们系统性地解决。

首先定义网络结构，这里我们实现一个包含输入层、隐藏层和输出层的三明治结构。关键点在于权重矩阵的维度匹配：

import numpy as np

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 权重初始化采用 Xavier 方法
        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(1/input_size)
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(1/hidden_size)
        self.b2 = np.zeros(output_size)

通过矩阵运算替代循环，大幅提升计算效率：

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, output):
    m = X.shape[0]  # 样本数量

    # 输出层误差
    delta2 = (output - y) * self.sigmoid_derivative(self.z2)
    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.z1)
    dW1 = np.dot(X.T, delta1) / m
    db1 = np.sum(delta1, axis=0) / m

    return dW1, db1, dW2, db2

PyTorch 通过 nn.Module 提供了更优雅的封装方式：

import torch
import torch.nn as nn

class BPNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(BPNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return torch.sigmoid(x)

添加学习率调整和早停机制：

from torch.optim.lr_scheduler import ReduceLROnPlateau

model = BPNet(784, 128, 10)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
scheduler = ReduceLROnPlateau(optimizer, 'min', patience=3)

best_loss = float('inf')
patience = 5
counter = 0

for epoch in range(100):
    model.train()
    for batch in train_loader:
        # 训练代码...

    # 验证阶段
    model.eval()
    val_loss = validate(model, val_loader)
    scheduler.step(val_loss)

    # 早停判断
    if val_loss < best_loss:
        best_loss = val_loss
        counter = 0
    else:
        counter += 1
        if counter >= patience:
            break

在 MNIST 数据集上的测试结果显示：