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

1次阅读

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

神经网络是一种模仿生物神经元工作方式的计算模型。前馈神经网络（Feedforward Neural Network）是最基础的网络结构，数据只能单向流动：从输入层→隐含层→输出层。BP（Back Propagation）算法通过误差反向传播来调整网络权重，是神经网络训练的基石。

输入层设计
节点数量等于输入特征维度
MNIST 案例中为 784（28×28 像素）
不需要激活函数，仅作数据分发
隐含层设计
节点数量经验公式：$\sqrt{输入节点×输出节点}$ 到 $2/ 3 输入节点 $
常用 ReLU 激活函数：$f(x)=max(0,x)$
解决线性不可分问题
输出层设计
分类任务节点数 = 类别数（MNIST 为 10）
多分类使用 Softmax：$\sigma(z)j=\frac{e^{z_j}}{\sum$}^Ke^{z_k}
二分类可用 Sigmoid

import numpy as np

class ThreeLayerBP:
    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 relu(self, x):
        return np.maximum(0, x)

    def softmax(self, x):
        exps = np.exp(x - np.max(x, axis=1, keepdims=True))
        return exps / np.sum(exps, axis=1, keepdims=True)

    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
        return self.softmax(self.z2)

    def backward(self, X, y, output, lr=0.01):
        # 反向传播
        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.a1 > 0)
        dW1 = np.dot(X.T, dz1) / m
        db1 = np.sum(dz1, axis=0) / m

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

梯度消失 / 爆炸
使用 ReLU 替代 Sigmoid
权重初始化采用 He/Xavier 方法
梯度裁剪（clipnorm）
过拟合对策
L2 正则化：$loss += \lambda\sum{w^2}$
Dropout 层随机失活
数据增强扩充样本
学习率调整
指数衰减：$lr = lr_0*e^{-kt}$
余弦退火策略
自适应优化器（Adam）

批量归一化实现

def batchnorm_forward(x, gamma, beta, eps=1e-5):
    mu = np.mean(x, axis=0)
    var = np.var(x, axis=0)
    x_hat = (x - mu) / np.sqrt(var + eps)
    out = gamma * x_hat + beta
    cache = (x, x_hat, mu, var, gamma, beta, eps)
    return out, cache