BP神经网络原理与实践：三层前馈网络结构详解与实现

1次阅读

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

BP 神经网络（Back Propagation Neural Network）是一种常见的人工神经网络，其核心思想是通过误差反向传播算法来训练网络权重。前馈神经网络（Feedforward Neural Network）是 BP 神经网络的一种典型结构，其特点是信息从输入层单向传递到输出层，没有反馈连接。

单向信息流动：数据从输入层经过隐含层最终到达输出层
全连接结构：相邻层的神经元之间全部相互连接
分层处理：每一层对输入数据进行非线性变换

BP 算法的核心是通过以下两个阶段不断迭代：

前向传播：计算网络输出
反向传播：根据输出误差调整网络权重

数学表达式为：

$$\Delta w_{ij} = -\eta \frac{\partial E}{\partial w_{ij}}$$

其中 $\eta$ 为学习率，$E$ 为损失函数。

一个标准的三层前馈神经网络包含：

输入层：接收原始数据
隐含层：进行特征提取和非线性变换
输出层：产生最终预测结果

输入层节点数：由输入数据维度决定
隐含层节点数：通常为输入层节点数的 1 / 2 到 2 /3
输出层节点数：由分类类别数决定（分类任务）

常用的激活函数包括：

Sigmoid：$\sigma(x) = \frac{1}{1+e^{-x}}$
ReLU：$f(x) = max(0,x)$
Tanh：$tanh(x) = \frac{e^x-e^{-x}}{e^x+e^{-x}}$

对于隐含层，ReLU 通常是首选；输出层根据任务类型选择：

二分类：Sigmoid
多分类：Softmax
回归：线性或恒等函数

下面我们使用 NumPy 实现一个完整的三层 BP 神经网络：

import numpy as np

class ThreeLayerBPNN:
    def __init__(self, input_size, hidden_size, output_size):
        # 初始化权重
        self.W1 = np.random.randn(input_size, hidden_size) * 0.01
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.01
        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, learning_rate):
        # 反向传播
        m = X.shape[0]

        # 输出层误差
        delta2 = (output - y) * self.sigmoid_derivative(output)
        dW2 = np.dot(self.a1.T, delta2) / m
        db2 = np.sum(delta2, axis=0, keepdims=True) / m

        # 隐含层误差
        delta1 = np.dot(delta2, self.W2.T) * self.sigmoid_derivative(self.a1)
        dW1 = np.dot(X.T, delta1) / m
        db1 = np.sum(delta1, axis=0, keepdims=True) / m

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

    def train(self, X, y, epochs, learning_rate):
        for i in range(epochs):
            output = self.forward(X)
            self.backward(X, y, output, learning_rate)

            if i % 100 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {i}, Loss: {loss:.4f}")

# MNIST 数据加载示例
from sklearn.datasets import load_digits
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

digits = load_digits()
X = digits.data
y = digits.target

# 数据预处理
scaler = MinMaxScaler()
X = scaler.fit_transform(X)

y_onehot = np.zeros((len(y), 10))
y_onehot[np.arange(len(y)), y] = 1

X_train, X_test, y_train, y_test = train_test_split(X, y_onehot, test_size=0.2)

# 训练模型
model = ThreeLayerBPNN(input_size=64, hidden_size=32, output_size=10)
model.train(X_train, y_train, epochs=1000, learning_rate=0.1)

梯度消失通常发生在深层网络中使用 Sigmoid 或 Tanh 激活函数时，因为它们的导数在饱和区接近于 0。解决方案：

使用 ReLU 及其变体激活函数
使用批归一化（Batch Normalization）
合理的权重初始化（如 He 初始化）

正则化：
L1/L2 权重衰减
Dropout
早停法（Early Stopping）
数据增强

固定学习率：适用于简单问题
学习率衰减：随训练轮次逐渐降低
自适应学习率方法：
Momentum
RMSprop
Adam

在每层激活函数前加入批归一化层：

class BatchNorm:
    def __init__(self, dim):
        self.gamma = np.ones((1, dim))
        self.beta = np.zeros((1, dim))
        self.eps = 1e-8

    def forward(self, x):
        self.mu = np.mean(x, axis=0)
        self.sigma = np.var(x, axis=0)

        x_hat = (x - self.mu) / np.sqrt(self.sigma + self.eps)
        out = self.gamma * x_hat + self.beta
        return out

SGD：简单但容易陷入局部最优
Momentum：加入动量项加速收敛
Adam：结合 Momentum 和 RMSprop 的优点

在验证集性能不再提升时停止训练：

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

for epoch in range(epochs):
    # 训练代码...

    val_loss = compute_validation_loss()

    if val_loss < best_loss:
        best_loss = val_loss
        counter = 0
    else:
        counter += 1
        if counter >= patience:
            print("Early stopping")
            break