BP神经网络代码实现：从数学原理到Python实战

1次阅读

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

BP 神经网络是深度学习的基石，就像学数学要先掌握加减乘除一样。但新手在实现时经常遇到三个头疼的问题：

梯度消失 ：深层网络训练时梯度越来越小，就像声音在长管道里逐渐消失
训练震荡 ：损失函数值上下跳动，像坐过山车一样不稳定
收敛缓慢 ：看着进度条一点点移动，结果等了半天准确率还是没提升

今天我们就用 Python 代码，把这些痛点逐个击破。

神经网络的威力来自矩阵运算，用 NumPy 可以轻松实现：

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        # 初始化权重（后面会讲 Xavier 初始化技巧）self.weights = [np.random.randn(y, x) 
                        for x, y in zip(layers[:-1], layers[1:])]

    def forward(self, X):
        """前向传播就像流水线作业"""
        self.activations = [X]  # 存储各层激活值

        for w in self.weights:
            Z = np.dot(self.activations[-1], w.T)  # 矩阵乘法
            A = 1/(1+np.exp(-Z))  # sigmoid 激活
            self.activations.append(A)

        return self.activations[-1]

这是 BP 网络最核心的部分，我们拆解成三步：

输出层误差 ：
$$ \delta^L = \nabla_a C \odot \sigma'(z^L) $$
隐藏层误差传播 ：
$$ \delta^l = ((w^{l+1})^T \delta^{l+1}) \odot \sigma'(z^l) $$
权重梯度计算 ：
$$ \frac{\partial C}{\partial w^l_{jk}} = a_k^{l-1} \delta_j^l $$

对应代码实现：

def backward(self, X, y, learning_rate):
    """反向传播就像纠正错误的老师"""
    # 1. 计算输出层误差
    error = (self.activations[-1] - y) 
    * self.activations[-1] * (1 - self.activations[-1])  # sigmoid 导数

    # 2. 反向传播误差
    for i in range(len(self.weights)-1, 0, -1):
        grad = np.dot(error.T, self.activations[i])  # 计算梯度
        self.weights[i] -= learning_rate * grad  # 更新权重

        # 传播误差到前一层
        error = np.dot(error, self.weights[i]) 
        * self.activations[i] * (1 - self.activations[i])

    # 更新第一层权重
    grad = np.dot(error.T, X)
    self.weights[0] -= learning_rate * grad

别再用普通随机初始化了！Xavier 初始化才是正道：

# 在__init__中替换为：self.weights = [np.random.randn(y, x)/np.sqrt(x) 
                for x, y in zip(layers[:-1], layers[1:])]

训练后期要用小步长，就像微调收音机频率：

def train(self, X, y, epochs=1000, lr=0.1):
    for epoch in range(epochs):
        current_lr = lr * (0.9 ** (epoch//100))  # 每 100 轮衰减
        self.backward(X, y, current_lr)

这是调试的好帮手，就像用计算器验算数学题：

def gradient_check(self, X, y, epsilon=1e-7):
    # 数值计算梯度
    original = self.weights[0][0,0]
    self.weights[0][0,0] = original + epsilon
    loss1 = self.calculate_loss(X, y)

    self.weights[0][0,0] = original - epsilon
    loss2 = self.calculate_loss(X, y)

    numerical_grad = (loss1 - loss2)/(2*epsilon)

    # 与反向传播结果对比
    self.forward(X)
    self.backward(X, y, 0.1)
    backprop_grad = self.weights[0][0,0]

    return np.abs(numerical_grad - backprop_grad) < 1e-5

Adam 优化器通常表现更好，就像自动挡比手动挡省心：

# 在类中添加 Adam 优化
self.m = [np.zeros_like(w) for w in self.weights]  # 一阶矩
self.v = [np.zeros_like(w) for w in self.weights]  # 二阶矩

def adam_update(self, grad, layer, t):
    beta1, beta2 = 0.9, 0.999
    self.m[layer] = beta1*self.m[layer] + (1-beta1)*grad
    self.v[layer] = beta2*self.v[layer] + (1-beta2)*(grad**2)

    m_hat = self.m[layer]/(1-beta1**t)
    v_hat = self.v[layer]/(1-beta2**t)

    return m_hat/(np.sqrt(v_hat) + 1e-8)

用 tqdm 添加进度条，训练过程一目了然：

from tqdm import trange

def train(self, X, y, epochs=1000):
    for epoch in trange(epochs):  # 魔法进度条
        self.forward(X)
        self.backward(X, y)

        if epoch % 100 == 0:
            print(f"Epoch {epoch}: Loss {self.calculate_loss(X, y):.4f}")