深入解析BP神经网络原理：从数学基础到Python实现

1次阅读

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

BP 神经网络是深度学习的基础架构，它的反向传播算法奠定了现代神经网络的训练范式。作为多层感知机的核心训练方法，BP 网络能够通过梯度下降自动学习特征层级表示。理解其数学本质对掌握 CNN、RNN 等复杂模型至关重要。

设三层网络结构（输入层 $L_1$，隐藏层 $L_2$，输出层 $L_3$），其矩阵运算为：
$$\begin{aligned}
Z_2 &= W_1 X + b_1 \
A_2 &= \sigma(Z_2) \
Z_3 &= W_2 A_2 + b_2 \
A_3 &= \text{softmax}(Z_3)
\end{aligned}$$
其中 $\sigma$ 为 Sigmoid 函数：$\sigma(z)=\frac{1}{1+e^{-z}}$

使用交叉熵损失函数 $J$，输出层误差项：
$$\delta_3 = A_3 – Y$$
隐藏层误差通过链式法则传递：
$$\delta_2 = (W_2^T \delta_3) \odot \sigma'(Z_2)$$
最终得到权重梯度：
$$\begin{aligned}
\frac{\partial J}{\partial W_2} &= \delta_3 A_2^T \
\frac{\partial J}{\partial b_2} &= \delta_3 \
\frac{\partial J}{\partial W_1} &= \delta_2 X^T \
\frac{\partial J}{\partial b_1} &= \delta_2
\end{aligned}$$

采用梯度下降法（学习率 $\eta$）：
$$W \leftarrow W – \eta \frac{\partial J}{\partial W}$$

import numpy as np
from sklearn.datasets import fetch_openml

# 数据预处理
def load_mnist():
    mnist = fetch_openml('mnist_784', version=1)
    X = mnist.data / 255.0  # 归一化
    y = np.eye(10)[mnist.target.astype(int)]  # one-hot
    return X[:60000], y[:60000]  # 训练集

# 激活函数
class Sigmoid:
    @staticmethod
    def forward(z):
        return 1 / (1 + np.exp(-z))

    @staticmethod
    def derivative(a):
        return a * (1 - a)

# 网络实现
class BPNetwork:
    def __init__(self, input_size, hidden_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, 10) * np.sqrt(1/hidden_size)
        self.b2 = np.zeros(10)

    def forward(self, X):
        self.Z1 = X @ self.W1 + self.b1
        self.A1 = Sigmoid.forward(self.Z1)
        self.Z2 = self.A1 @ self.W2 + self.b2
        return np.exp(self.Z2) / np.sum(np.exp(self.Z2), axis=1, keepdims=True)

    def backward(self, X, y, lr=0.1):
        m = X.shape[0]
        # 输出层误差
        delta2 = self.forward(X) - y
        # 隐藏层误差
        delta1 = (delta2 @ self.W2.T) * Sigmoid.derivative(self.A1)

        # 参数更新
        self.W2 -= lr * (self.A1.T @ delta2) / m
        self.b2 -= lr * np.mean(delta2, axis=0)
        self.W1 -= lr * (X.T @ delta1) / m
        self.b1 -= lr * np.mean(delta1, axis=0)

# 随机初始化 vs Xavier
plt.figure(figsize=(10,4))
plt.subplot(121)
plt.hist(np.random.randn(10000)*0.01, bins=50)  # 小随机数
plt.title('Random Init')

plt.subplot(122)
plt.hist(np.random.randn(10000)*np.sqrt(1/784), bins=50)  # Xavier
plt.title('Xavier Init')

# 余弦退火学习率
def cosine_annealing(epoch, max_lr=0.1, min_lr=0.001):
    return min_lr + 0.5*(max_lr-min_lr)*(1+np.cos(epoch/10*np.pi))

class BatchNorm:
    def __init__(self, dim):
        self.gamma = np.ones(dim)
        self.beta = np.zeros(dim)

    def forward(self, X, eps=1e-5):
        self.mu = np.mean(X, axis=0)
        self.sigma2 = np.var(X, axis=0)
        X_norm = (X - self.mu) / np.sqrt(self.sigma2 + eps)
        return self.gamma * X_norm + self.beta