BP神经网络架构入门指南：从数学原理到Python实现

1次阅读

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

BP（Backpropagation）神经网络是深度学习的基础架构，在图像识别、自然语言处理等领域有广泛应用。比如 MNIST 手写数字识别任务中，一个简单的 BP 网络就能达到 90% 以上的准确率。它的核心优势在于通过误差反向传播自动调整权重，避免了传统机器学习中繁琐的特征工程。

对于一个单隐层网络，前向传播过程可表示为：

$$ h = \sigma(W_1 x + b_1) $$
$$ \hat{y} = \sigma(W_2 h + b_2) $$

其中 $\sigma$ 是激活函数（如 Sigmoid）：

$$ \sigma(z) = \frac{1}{1+e^{-z}} $$

以均方误差损失函数为例：

$$ L = \frac{1}{2}(y – \hat{y})^2 $$

输出层权重梯度：

$$ \frac{\partial L}{\partial W_2} = (\hat{y} – y) \cdot \sigma'(z_2) \cdot h^T $$

隐层权重梯度（链式法则）：

$$ \frac{\partial L}{\partial W_1} = W_2^T \cdot [(\hat{y} – y) \odot \sigma'(z_2)] \odot \sigma'(z_1) \cdot x^T $$

其中 $\odot$ 表示逐元素乘法，$\sigma’$ 是激活函数的导数。

import numpy as np

class BPNetwork:
    def __init__(self, input_size, hidden_size, lr=0.1):
        # He 初始化（针对 ReLU 优化）self.W1 = np.random.randn(hidden_size, input_size) * np.sqrt(2/input_size)
        self.b1 = np.zeros((hidden_size, 1))
        self.W2 = np.random.randn(1, hidden_size) * np.sqrt(2/hidden_size)
        self.b2 = np.zeros((1, 1))
        self.lr = lr

    def relu(self, z):
        return np.maximum(0, z)

    def relu_deriv(self, z):
        return (z > 0).astype(float)

    def forward(self, x):
        self.z1 = self.W1 @ x + self.b1
        self.h = self.relu(self.z1)
        self.z2 = self.W2 @ self.h + self.b2
        return 1 / (1 + np.exp(-self.z2))  # 输出层用 Sigmoid

    def train(self, x, y, epochs=1000):
        for epoch in range(epochs):
            # 学习率衰减
            current_lr = self.lr * (1 - epoch/epochs)

            # 前向传播
            y_pred = self.forward(x)

            # 反向传播
            error = y_pred - y
            dW2 = error * y_pred * (1 - y_pred) @ self.h.T
            db2 = np.sum(error * y_pred * (1 - y_pred), axis=1, keepdims=True)

            dh = self.W2.T @ (error * y_pred * (1 - y_pred))
            dW1 = (dh * self.relu_deriv(self.z1)) @ x.T
            db1 = np.sum(dh * self.relu_deriv(self.z1), axis=1, keepdims=True)

            # 参数更新
            self.W2 -= current_lr * dW2
            self.b2 -= current_lr * db2
            self.W1 -= current_lr * dW1
            self.b1 -= current_lr * db1