BP神经网络概述

BP(Back Propagation)神经网络是一种按照误差逆向传播算法训练的多层前馈神经网络。其核心思想是通过梯度下降法调整网络中的权重和阈值，使网络输出与期望值的误差最小化（这里面有个很重要的概念，叫损失函数，作用是利用梯度去更新权重和偏置）。BP网络由输入层、隐藏层（可单层或多层）和输出层构成，层间通过带权值的连接传递信号，并采用非线性激活函数实现复杂映射。

基本结构

BP神经网络通常包含：

输入层：接收外部输入
隐藏层：一层或多层，用于提取特征
输出层：产生最终结果

算法原理

BP算法的运作分为两个关键阶段，前向传播和反向传播。假设一个简单的三层BP神经网络（输入层2节点，隐藏层3节点，输出层2节点），初始参数如下：
初始参数如下：

输入样本：$x = [5,10]$
真实输出：$y = [0.01,0.99]$
权重与偏置（随机初始化）：
- 输入层到隐藏层权重：$W_1 = \begin{bmatrix} 0.1 & 0.15 & 0.2 \ 0.25 & 0.3 & 0.35 \end{bmatrix}$
- 隐藏层偏置：$b_1 = 0.35$
- 隐藏层到输出层权重：$W_2 = \begin{bmatrix} 0.4 & 0.45 \ 0.5 & 0.55 \ 0.6 & 0.65 \end{bmatrix}$
- 输出层偏置：$b_2 = 0.65$

前向传播

输入信号从输入层经隐藏层逐层传递至输出层，每层神经元通过加权和计算后，应用激活函数（如Sigmoid、Tanh、ReLU）生成输出。

详细步骤：

步骤1：计算隐藏层输入与输出
隐藏层每个神经元的输入为加权和加偏置：
$$
\begin{aligned}
h_1=(0.1×5)+(0.15×10)+0.35=2.35 \\
h_2=(0.2×5)+(0.25×10)+0.35=3.85 \\
h_3=(0.3×5)+(0.35×10)+0.35=5.35
\end{aligned}
$$

应用Sigmoid激活函数后，隐藏层输出为：
$$
\text{隐藏层输出} = \begin{bmatrix} \frac{1}{1+e^{-2.35}}, \frac{1}{1+e^{-3.85}}, \frac{1}{1+e^{-5.35}} \end{bmatrix} \approx [0.912, 0.979, 0.995]
$$

步骤2：计算输出层输入与输出
输出层输入为隐藏层输出的加权和加偏置：
$$
\begin{aligned}
o_1=(0.912×0.4)+(0.979×0.5)+(0.995×0.6)+0.65=2.10192 \\
o_2=(0.912×0.45)+(0.979×0.55)+(0.995×0.65)+0.65=2.24629
\end{aligned}
$$

输出层应用Sigmoid后的最终输出：
$$
\text{实际输出} = \begin{bmatrix} \frac{1}{1+e^{-2.10192}}, \frac{1}{1+e^{-2.24629}} \end{bmatrix} \approx [0.891, 0.904]
$$

步骤3：计算误差
使用均方误差(MSE)计算损失：
$$
E = \frac{1}{2}[(0.891-0.01)^2+(0.904-0.99)^2] \approx 0.283
$$

反向传播

误差通过输出层到隐藏层逐层反向传播，根据误差调整网络参数。
步骤1：计算输出层误差项
误差项 = 输出误差 × Sigmoid导数：
$$
\begin{aligned}
\delta_1 = (0.891 - 0.01) \times 0.891 \times (1 - 0.891) \approx 0.079 \\
\delta_2 = (0.904 - 0.99) \times 0.904 \times (1 - 0.904) \approx -0.008
\end{aligned}
$$
步骤2：计算隐藏层误差项
通过链式法则反向传播误差：
$$
\delta_{\text{隐藏}} = \delta_1 \times W_2[:, 1] + \delta_2 \times W_2[:, 2] \times \text{Sigmoid导数}(h)
$$
例如隐藏层第一个神经元：
$$
\delta_{h_1} = (0.079 \times 0.4 + (-0.008) \times 0.45) \times 0.912 \times (1 - 0.912) \approx 0.002
$$
步骤3：更新权重与偏置
以学习率 $\eta = 0.5$ 更新参数：

输出层权重更新：
$$
W_2[1, 1] = 0.4 - 0.5 \times \delta_1 \times 0.912 \approx 0.4 - 0.036 = 0.364
$$
隐藏层偏置更新：
$$
b_1 = 0.35 - 0.5 \times \delta_{h_1} \approx 0.35 - 0.00115 = 0.34885
$$

激活函数

BP网络常用的激活函数有：
$$
\begin{aligned}
\text{sigmoid}(x) = \frac{1}{1 + e^{-x}} \\
\text{ReLU}(x) = \max(0, x) \\
\text{tanh}(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}
\end{aligned}
$$

误差函数

常用的误差函数：
$$
\begin{aligned}
\text{MSE} = \frac{1}{2}\sum_{k=1}^{m}(y_k - t_k)^2 \\
\text{交叉熵} = -\sum_{k=1}^{m} t_k \log(y_k) \\
\text{MAE} = \frac{1}{m}\sum_{k=1}^{m}|y_k - t_k|
\end{aligned}
$$

权值更新

根据链式法则，权值更新公式为：
$$
\Delta w_{ij} = -\eta \frac{\partial E}{\partial w_{ij}}
$$

算法流程

BP算法的完整流程如下：

初始化网络参数（权重和偏置）
前向传播：
- 输入层接收数据
- 每层计算加权和：
  $$
  net_j = \sum_{i=1}^{n} w_{ij} x_i + b_j
  $$
- 应用激活函数：
  $$
  out_j = f(net_j)
  $$
- 重复直到输出层
计算误差：
$$
E = \frac{1}{2}\sum_{k=1}^{m}(y_k - t_k)^2
$$
反向传播误差：
- 从输出层开始计算误差梯度
- 根据链式法则更新每个权重
更新权重和偏置
重复直到误差小于阈值（如 E<0.02）。经过多次迭代后，输出逐渐逼近真实值

优化算法

BP网络常用的优化算法有：

梯度下降法（Gradient Descent）
$$
\Delta w_{ij} = -\eta \frac{\partial E}{\partial w_{ij}}
$$
动量法（Momentum）
$$
\Delta w_{ij} = -\eta \frac{\partial E}{\partial w_{ij}} + \alpha \Delta w_{ij}^{(t-1)}
$$
自适应学习率（Adaptive Learning Rate）
$$
\eta = \eta_0 \times \frac{1}{1 + \frac{t}{\tau}}
$$

实践建议

初始化权重时，使用较小的随机值
选择合适的激活函数
设置合理的学习率
使用适当的优化算法
添加正则化项防止过拟合
使用批量训练提高效率

代码实现

class BPNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size)
        # 初始化偏置
        self.b1 = np.zeros((1, hidden_size))
        self.b2 = np.zeros((1, output_size))

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    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):
        # 反向传播
        self.output_error = y - output
        self.output_delta = self.output_error * self.sigmoid_derivative(output)

        self.z2_error = self.output_delta.dot(self.W2.T)
        self.z2_delta = self.z2_error * self.sigmoid_derivative(self.a1)

        # 更新权重和偏置
        self.W2 += self.a1.T.dot(self.output_delta)
        self.b2 += np.sum(self.output_delta, axis=0, keepdims=True)
        self.W1 += X.T.dot(self.z2_delta)
        self.b1 += np.sum(self.z2_delta, axis=0, keepdims=True)

    def train(self, X, y, epochs=10000, learning_rate=0.1):
        for epoch in range(epochs):
            output = self.forward(X)
            self.backward(X, y, output)
            error = np.mean(np.abs(self.output_error))
            if epoch % 1000 == 0:
                print(f"Epoch {epoch}, Error: {error}")

    def predict(self, X):
        return self.forward(X)

应用案例

手写数字识别

# 使用MNIST数据集
from tensorflow.keras.datasets import mnist

(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 数据预处理
X_train = X_train.reshape(X_train.shape[0], -1) / 255.0
X_test = X_test.reshape(X_test.shape[0], -1) / 255.0

# 创建BP网络
network = BPNetwork(784, 128, 10)

# 训练网络
network.train(X_train, y_train)

# 测试网络
predictions = network.predict(X_test)
accuracy = np.mean(np.argmax(predictions, axis=1) == y_test)
print(f"Test Accuracy: {accuracy * 100}%")