三层前馈神经网络实战：从bp神经网络原理到高效实现

1次阅读

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

BP 神经网络是深度学习的基础架构之一，通过误差反向传播算法实现了多层网络的训练能力。这种网络结构简单但功能强大，特别适合解决分类和回归问题。在实际应用中，三层前馈网络（输入层、单隐藏层、输出层）往往就能取得不错的效果，是理解更复杂神经网络的重要起点。

输入层负责接收原始数据，其神经元数量由特征维度决定。例如处理 28×28 的 MNIST 图像时，需要 784 个输入神经元（展平后的像素值）。

隐藏层是网络的核心计算部分：

通常使用 sigmoid 或 ReLU 等非线性激活函数
神经元数量需要权衡模型容量和计算成本
单隐藏层已能拟合任意连续函数（通用近似定理）

根据任务类型设计：

二分类：1 个神经元 +sigmoid
多分类：神经元数 = 类别数 +softmax
回归：1 个神经元 + 线性输出

import numpy as np

class ThreeLayerNet:
    def __init__(self, input_size, hidden_size, output_size):
        # He 初始化
        self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2/input_size)
        self.b1 = np.zeros(hidden_size)
        self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2/hidden_size)
        self.b2 = np.zeros(output_size)

    def forward(self, x):
        # 隐藏层计算
        self.z1 = np.dot(x, self.W1) + self.b1
        self.a1 = self.relu(self.z1)

        # 输出层计算
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = self.softmax(self.z2)
        return self.a2

    def backward(self, x, y, output):
        m = x.shape[0]  # 样本数量

        # 输出层梯度
        dz2 = output - y
        dw2 = np.dot(self.a1.T, dz2) / m
        db2 = np.sum(dz2, axis=0) / m

        # 隐藏层梯度
        da1 = np.dot(dz2, self.W2.T)
        dz1 = da1 * self.relu_derivative(self.z1)
        dw1 = np.dot(x.T, dz1) / m
        db1 = np.sum(dz1, axis=0) / m

        return dw1, db1, dw2, db2

    def update_params(self, dw1, db1, dw2, db2, lr):
        self.W1 -= lr * dw1
        self.b1 -= lr * db1
        self.W2 -= lr * dw2
        self.b2 -= lr * db2

from tensorflow.keras.datasets import mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(-1, 784)/255.0  # 归一化
x_test = x_test.reshape(-1, 784)/255.0

y_train_onehot = np.eye(10)[y_train]  # one-hot 编码
y_test_onehot = np.eye(10)[y_test]

net = ThreeLayerNet(784, 256, 10)
for epoch in range(20):
    # 前向传播
    output = net.forward(x_train)

    # 计算损失
    loss = -np.mean(y_train_onehot * np.log(output + 1e-8))

    # 反向传播
    dw1, db1, dw2, db2 = net.backward(x_train, y_train_onehot, output)

    # 参数更新
    net.update_params(dw1, db1, dw2, db2, lr=0.01)

    # 验证集准确率
    test_output = net.forward(x_test)
    test_pred = np.argmax(test_output, axis=1)
    acc = np.mean(test_pred == y_test)
    print(f"Epoch {epoch}: loss={loss:.4f}, acc={acc:.4f}")

常用经验公式：输入输出层神经元数量的平均值
可以通过交叉验证确定最佳值
MNIST 示例中 256 个神经元效果较好

初始尝试 0.01，观察训练曲线
学习率过大导致震荡，过小收敛慢
可以实现学习率衰减策略

使用 ReLU 代替 sigmoid
采用批归一化 (BatchNorm)
残差连接 (ResNet 思想)

模型量化 ：将 float64 转换为 float32 甚至 int8，减少内存占用
批处理优化 ：合理设置 batch_size，充分利用 GPU 并行计算
持久化存储 ：使用 HDF5 格式保存模型结构和参数

如何改进网络结构使其在 CIFAR-10 数据集上获得更好表现？
当训练数据量达到百万级时，需要对当前实现做哪些优化？

import matplotlib.pyplot as plt

plt.figure(figsize=(8,5))
plt.title("3-Layer Feedforward Network")
plt.scatter([0]*784, range(784), label='Input Layer')
plt.scatter([1]*256, range(256), label='Hidden Layer')
plt.scatter([2]*10, range(10), label='Output Layer')

for i in range(10):  # 部分连接线
    for j in range(30):
        plt.plot([0,1], [j*26, i*25], 'gray', alpha=0.1)
        plt.plot([1,2], [i*25, j], 'gray', alpha=0.1)

plt.legend()
plt.axis('off')
plt.show()