BP神经网络训练入门指南：从数学原理到Python实战

1次阅读

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

BP 神经网络通过模拟人脑神经元连接方式，在图像识别、语音处理等领域展现出强大的特征学习能力。其核心价值在于能够自动提取数据的高阶特征，并通过误差反向传播不断优化网络参数。相比传统算法，BP 网络对非线性关系的建模能力使其成为现代 AI 的基础组件。

设第 $l$ 层神经元的输入为 $z^l$，输出为 $a^l=\sigma(z^l)$，则损失函数 $L$ 对权重 $W^l$ 的梯度为：

$$\frac{\partial L}{\partial W^l} = \frac{\partial L}{\partial z^{l+1}} \cdot \frac{\partial z^{l+1}}{\partial W^l} = \delta^{l+1} \cdot (a^l)^T$$

其中误差项 $\delta^l$ 的递推公式为：

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

当使用 Sigmoid 函数 $\sigma(z)=\frac{1}{1+e^{-z}}$ 时，其导数最大值仅 0.25，多层连乘会导致梯度指数级衰减：

$$\sigma'(z) = \sigma(z)(1-\sigma(z)) \leq 0.25$$

def initialize_parameters(layer_dims):
    """
    采用 He 初始化缓解梯度消失
    layer_dims: 各层神经元数量列表，如 [784, 256, 10]
    """
    parameters = {}
    for l in range(1, len(layer_dims)):
        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) * np.sqrt(2./layer_dims[l-1])
        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))
    return parameters

def forward_prop(X, parameters):
    """
    实现带 ReLU 激活的全连接前向传播
    输出层使用 Softmax 计算概率分布
    """
    caches = []
    A = X
    L = len(parameters) // 2

    for l in range(1, L):
        Z = np.dot(parameters['W'+str(l)], A) + parameters['b'+str(l)]
        A = np.maximum(0, Z)  # ReLU 激活
        caches.append((Z, A))

    # 输出层 Softmax
    ZL = np.dot(parameters['W'+str(L)], A) + parameters['b'+str(L)]
    AL = np.exp(ZL) / np.sum(np.exp(ZL), axis=0)
    return AL, caches

def backward_prop(AL, Y, caches, parameters, beta=0.9):
    """
    实现带动量优化的反向传播
    beta: 动量系数，默认 0.9
    """
    grads = {}
    L = len(caches) + 1
    Y = Y.reshape(AL.shape)

    # 初始化动量
    if not hasattr(backward_prop, 'v'):
        backward_prop.v = {}
        for l in range(1, L+1):
            backward_prop.v['dW'+str(l)] = 0
            backward_prop.v['db'+str(l)] = 0

    # 输出层梯度
    dZL = AL - Y
    grads['dW'+str(L)] = np.dot(dZL, caches[-1][1].T)
    grads['db'+str(L)] = np.sum(dZL, axis=1, keepdims=True)

    # 隐藏层梯度
    for l in reversed(range(1, L)):
        dA = np.dot(parameters['W'+str(l+1)].T, dZL)
        dZ = dA * (caches[l-1][1] > 0).astype(float)  # ReLU 导数
        grads['dW'+str(l)] = np.dot(dZ, caches[l-1][0].T)
        grads['db'+str(l)] = np.sum(dZ, axis=1, keepdims=True)
        dZL = dZ

    # 应用动量
    for l in range(1, L+1):
        backward_prop.v['dW'+str(l)] = beta*backward_prop.v['dW'+str(l)] + (1-beta)*grads['dW'+str(l)]
        backward_prop.v['db'+str(l)] = beta*backward_prop.v['db'+str(l)] + (1-beta)*grads['db'+str(l)]
        grads['dW'+str(l)] = backward_prop.v['dW'+str(l)]
        grads['db'+str(l)] = backward_prop.v['db'+str(l)]

    return grads

学习率：从 0.001 开始尝试，每 10 个 epoch 乘以 0.8
Batch Size：GPU 显存允许时建议 128-256，小样本可用 32-64
梯度裁剪阈值：通常设为 1.0 或 5.0

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

for epoch in range(epochs):
    train_loss = compute_loss(...)

    if train_loss < best_loss - 0.001:  # 最小改善阈值
        best_loss = train_loss
        no_improve = 0
    else:
        no_improve += 1

    if no_improve >= patience:
        print(f'Early stopping at epoch {epoch}')
        break