Learn PyTorch

Appearance

7.6 RMSProp 算法 ​

我们在 7.5 节 (AdaGrad 算法) 中提到，因为调整学习率时分母上的变量 st\boldsymbol{s}_t 一直在累加按元素平方的小批量随机梯度，所以目标函数自变量每个元素的学习率在迭代过程中一直在降低 (或不变)。因此，当学习率在迭代早期降得较快且当前解依然不佳时，AdaGrad 算法在迭代后期由于学习率过小，可能较难找到一个有用的解。为了解决这一问题，RMSProp 算法对 AdaGrad 算法做了一点小小的修改。该算法源自 Coursera 上的一门课程，即“机器学习的神经网络” [1]。

7.6.1 算法 ​

我们在 7.4 节 (动量法) 里介绍过指数加权移动平均。不同于 AdaGrad 算法里状态变量 st\boldsymbol{s}_t 是截至时间步 tt 所有小批量随机梯度 gt\boldsymbol{g}_t 按元素平方和，RMSProp 算法将这些梯度按元素平方做指数加权移动平均。具体来说，给定超参数 0≤γ<10 \leq \gamma < 1，RMSProp 算法在时间步 t>0t>0 计算

st←γst−1+(1−γ)gt⊙gt.\boldsymbol{s}_t \leftarrow \gamma \boldsymbol{s}_{t-1} + (1 - \gamma) \boldsymbol{g}_t \odot \boldsymbol{g}_t.

和 AdaGrad 算法一样，RMSProp 算法将目标函数自变量中每个元素的学习率通过按元素运算重新调整，然后更新自变量

xt←xt−1−ηst+ϵ⊙gt,\boldsymbol{x}_t \leftarrow \boldsymbol{x}_{t-1} - \frac{\eta}{\sqrt{\boldsymbol{s}_t + \epsilon}} \odot \boldsymbol{g}_t,

其中 η\eta 是学习率，ϵ\epsilon 是为了维持数值稳定性而添加的常数，如 10−610^{-6}。因为 RMSProp 算法的状态变量 st\boldsymbol{s}_t 是对平方项 gt⊙gt\boldsymbol{g}_t \odot \boldsymbol{g}_t 的指数加权移动平均，所以可以看作是最近 1/(1−γ)1/(1-\gamma) 个时间步的小批量随机梯度平方项的加权平均。如此一来，自变量每个元素的学习率在迭代过程中就不再一直降低 (或不变)。

照例，让我们先观察 RMSProp 算法对目标函数 f(x)=0.1x12+2x22f(\boldsymbol{x})=0.1x_1^2+2x_2^2 中自变量的迭代轨迹。回忆在 7.5 节 (AdaGrad 算法) 使用的学习率为 0.4 的 AdaGrad 算法，自变量在迭代后期的移动幅度较小。但在同样的学习率下，RMSProp 算法可以更快逼近最优解。

python
%matplotlib inline
import math
import torch
import sys
sys.path.append("..")
import d2lzh_pytorch as d2l

def rmsprop_2d(x1, x2, s1, s2):
    g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6
    s1 = gamma * s1 + (1 - gamma) * g1 ** 2
    s2 = gamma * s2 + (1 - gamma) * g2 ** 2
    x1 -= eta / math.sqrt(s1 + eps) * g1
    x2 -= eta / math.sqrt(s2 + eps) * g2
    return x1, x2, s1, s2

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

eta, gamma = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))

输出：

epoch 20, x1 -0.010599, x2 0.000000

7.6.2 从零开始实现 ​

接下来按照 RMSProp 算法中的公式实现该算法。

python
features, labels = d2l.get_data_ch7()

def init_rmsprop_states():
    s_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
    s_b = torch.zeros(1, dtype=torch.float32)
    return (s_w, s_b)

def rmsprop(params, states, hyperparams):
    gamma, eps = hyperparams['gamma'], 1e-6
    for p, s in zip(params, states):
        s.data = gamma * s.data + (1 - gamma) * (p.grad.data)**2
        p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)

我们将初始学习率设为 0.01，并将超参数 γ\gamma 设为 0.9。此时，变量 st\boldsymbol{s}_t 可看作是最近 1/(1−0.9)=101/(1-0.9) = 10 个时间步的平方项 gt⊙gt\boldsymbol{g}_t \odot \boldsymbol{g}_t 的加权平均。

python
d2l.train_ch7(rmsprop, init_rmsprop_states(), {'lr': 0.01, 'gamma': 0.9},
              features, labels)

输出：

loss: 0.243452, 0.049984 sec per epoch

7.6.3 简洁实现 ​

通过名称为 RMSprop 的优化器方法，我们便可使用 PyTorch 提供的 RMSProp 算法来训练模型。注意，超参数 γ\gamma 通过 alpha 指定。

python
d2l.train_pytorch_ch7(torch.optim.RMSprop, {'lr': 0.01, 'alpha': 0.9},
                    features, labels)

输出：

loss: 0.243676, 0.043637 sec per epoch

小结 ​

  • RMSProp 算法和 AdaGrad 算法的不同在于，RMSProp 算法使用了小批量随机梯度按元素平方的指数加权移动平均来调整学习率。

参考文献 ​

[1] Tieleman, T., & Hinton, G. (2012). Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2), 26-31.

注：除代码外本节与原书此节基本相同，原书传送门