BP神经网络优化实战：自适应学习率与动量因子的协同调参指南

1次阅读

没有评论

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

在传统 BP 神经网络训练中，最让人头疼的就是学习率的选择。固定学习率就像开一辆没有油门的车——上坡时（梯度大）容易冲过头，下坡时（梯度小）又慢得像蜗牛。这会导致两种典型问题：

震荡现象 ：损失函数在最小值附近反复横跳
收敛慢 ：平坦区域需要大量迭代才能前进

AdaGrad 的核心思想是：频繁更新的参数（如偏置项）应该减小步幅，稀少更新的参数（如某些权重）可以迈大步。其更新公式为：

$$\theta_{t+1} = \theta_t – \frac{\eta}{\sqrt{G_t + \epsilon}} \cdot g_t$$

其中 $G_t$ 是历史梯度平方的累加。但这也带来了新问题——随着训练进行，调整幅度会越来越小（分母不断增大）。

RMSProp 通过引入衰减系数 $\gamma$ 解决了这个问题：

$$E[g^2]t = \gamma E[g^2] + (1-\gamma)g_t^2$$

相当于给历史梯度加了 ” 遗忘机制 ”。

想象小球滚下山坡时：

当前梯度相当于即时受力
动量项模拟了物理惯性
更新方向是历史方向与当前方向的加权和

数学表达：

$$v_t = \beta v_{t-1} + (1-\beta)g_t$$
$$\theta_{t+1} = \theta_t – \eta v_t$$

经验表明 $\beta=0.9$ 在大多数情况下效果良好。

结合两者优势的 Adam 算法更新流程：

计算一阶矩估计（带动量的梯度均值）
计算二阶矩估计（自适应学习率的分母）
进行偏差校正（应对初始零值问题）
更新参数

import numpy as np
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

# 网络参数
input_dim = 784
hidden_dim = 256 
output_dim = 10
learning_rate = 0.001
beta1 = 0.9  # 动量系数
beta2 = 0.999  # RMSProp 系数
epsilon = 1e-8

# 初始化
W1 = np.random.randn(input_dim, hidden_dim) * 0.01
b1 = np.zeros(hidden_dim)
W2 = np.random.randn(hidden_dim, output_dim) * 0.01
b2 = np.zeros(output_dim)

# 训练循环
for epoch in range(50):
    # 前向传播
    z1 = X_train.dot(W1) + b1
    a1 = np.maximum(0, z1)  # ReLU
    scores = a1.dot(W2) + b2

    # 计算损失
    exp_scores = np.exp(scores - np.max(scores, axis=1, keepdims=True))
    probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
    loss = -np.log(probs[range(len(X_train)), y_train]).mean()

    # 反向传播
    dscores = probs
    dscores[range(len(X_train)), y_train] -= 1
    dscores /= len(X_train)

    dW2 = a1.T.dot(dscores)
    db2 = np.sum(dscores, axis=0)

    da1 = dscores.dot(W2.T)
    dz1 = da1 * (z1 > 0)  # ReLU 梯度
    dW1 = X_train.T.dot(dz1)
    db1 = np.sum(dz1, axis=0)

    # Adam 更新
    for param, grad, m, v in zip([W1, b1, W2, b2], 
                                [dW1, db1, dW2, db2],
                                [mW1, mb1, mW2, mb2],
                                [vW1, vb1, vW2, vb2]):
        m = beta1 * m + (1 - beta1) * grad  # 一阶矩估计
        v = beta2 * v + (1 - beta2) * (grad ** 2)  # 二阶矩估计
        m_hat = m / (1 - beta1 ** (epoch + 1))  # 偏差校正
        v_hat = v / (1 - beta2 ** (epoch + 1))
        param -= learning_rate * m_hat / (np.sqrt(v_hat) + epsilon)