深入解析BP神经网络原理：三层前馈网络结构的设计与实现

1次阅读

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

BP 神经网络（Backpropagation Neural Network）是一种通过误差反向传播算法训练的多层前馈网络。它在模式识别、函数逼近、数据分类等领域有广泛应用。三层前馈网络是最常见的结构，包含输入层、隐藏层和输出层。这种结构简单但功能强大，能够解决许多非线性问题。

输入层的神经元数量取决于输入数据的特征维度。例如，在 MNIST 手写数字识别中，每个图像是 28×28 像素，因此输入层通常有 784 个神经元（28*28）。

隐藏层是网络的核心，负责特征的提取和转换。隐藏层神经元数量的选择没有固定规则，但可以通过以下经验公式估算：

介于输入层和输出层大小之间
可以是输入层大小的 2 / 3 加上输出层大小
通过交叉验证确定最优数量

输出层的神经元数量由任务类型决定。对于分类问题，通常使用 softmax 激活函数，神经元数量等于类别数。对于回归问题，通常使用线性激活函数，神经元数量等于输出维度。

输入层到隐藏层：

$$h = f(W_1x + b_1)$$

其中 $W_1$ 是输入层到隐藏层的权重矩阵，$b_1$ 是偏置，$f$ 是激活函数（如 sigmoid 或 ReLU）。

隐藏层到输出层：

$$y = g(W_2h + b_2)$$

其中 $W_2$ 是隐藏层到输出层的权重矩阵，$b_2$ 是偏置，$g$ 是输出层激活函数。

计算输出层误差：

$$\delta^L = (y – t) \odot g'(z^L)$$

其中 $t$ 是真实标签，$z^L$ 是输出层的加权输入。

计算隐藏层误差：

$$\delta^l = ((W^{l+1})^T\delta^{l+1}) \odot f'(z^l)$$

权重更新：

$$W^l \leftarrow W^l – \eta \delta^l (a^{l-1})^T$$

$$b^l \leftarrow b^l – \eta \delta^l$$

其中 $\eta$ 是学习率。

import numpy as np
from sklearn.datasets import fetch_openml
from sklearn.preprocessing import LabelBinarizer

# 加载 MNIST 数据集
mnist = fetch_openml('mnist_784')
X = mnist.data / 255.0  # 归一化
y = LabelBinarizer().fit_transform(mnist.target)

# 网络参数
input_size = 784
hidden_size = 128
output_size = 10
learning_rate = 0.1
epochs = 50

# 初始化权重
W1 = np.random.randn(input_size, hidden_size) * 0.01
b1 = np.zeros(hidden_size)
W2 = np.random.randn(hidden_size, output_size) * 0.01
b2 = np.zeros(output_size)

# 激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

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

# 训练过程
for epoch in range(epochs):
    # 前向传播
    hidden = sigmoid(np.dot(X, W1) + b1)
    output = sigmoid(np.dot(hidden, W2) + b2)

    # 计算损失
    loss = np.mean((output - y) ** 2)

    # 反向传播
    output_error = (output - y) * sigmoid_derivative(output)
    hidden_error = np.dot(output_error, W2.T) * sigmoid_derivative(hidden)

    # 更新权重
    W2 -= learning_rate * np.dot(hidden.T, output_error) / len(X)
    b2 -= learning_rate * np.mean(output_error, axis=0)
    W1 -= learning_rate * np.dot(X.T, hidden_error) / len(X)
    b1 -= learning_rate * np.mean(hidden_error, axis=0)

    if epoch % 10 == 0:
        print(f'Epoch {epoch}, Loss: {loss:.4f}')