12.8. RMSProp¶ 在 SageMaker Studio Lab 中打开 Notebook
12.7节中的一个关键问题是，学习率按预定时间表 \(\mathcal{O}(t^{-\frac{1}{2}})\) 的速率降低。虽然这通常适用于凸问题，但对于深度学习中遇到的非凸问题，它可能并不理想。然而，Adagrad的坐标自适应性作为预处理器是非常可取的。
Tieleman和Hinton（2012）提出了RMSProp算法，作为将速率调度与坐标自适应学习率分离的简单修复方法。问题在于，Adagrad将梯度 \(\mathbf{g}_t\) 的平方累加到状态矢量 \(\mathbf{s}_t = \mathbf{s}_{t-1} + \mathbf{g}_t^2\) 中。因此，由于缺乏规范化，\(\mathbf{s}_t\) 随着算法的收敛，会以线性方式持续增长且没有边界。
解决此问题的一种方法是使用 \(\mathbf{s}_t / t\)。对于 \(\mathbf{g}_t\) 的合理分布，它将收敛。不幸的是，可能需要很长时间才能发挥极限行为，因为该过程会记住值的完整轨迹。另一种方法是像在动量法中使用的方式一样使用泄漏平均值，即 \(\mathbf{s}_t \leftarrow \gamma \mathbf{s}_{t-1} + (1-\gamma) \mathbf{g}_t^2\)，其中参数 \(\gamma > 0\)。保持所有其他部分不变，就产生了RMSProp。
12.8.1. 算法¶
让我们详细写出这些方程式。
常量 \(\epsilon > 0\) 通常设置为 \(10^{-6}\)，以确保我们不会因除以零或步长过大而遇到问题。有了这个扩展，我们现在可以自由地控制学习率 \(\eta\)，而不受应用于每个坐标的缩放的影响。就泄漏平均值而言，我们可以应用与之前在动量法案例中应用的相同推理。展开 \(\mathbf{s}_t\) 的定义可得
和12.6节中一样，我们使用 \(1 + \gamma + \gamma^2 + \ldots, = \frac{1}{1-\gamma}\)。因此，权重总和被规范化为 \(1\)，观测值的半衰期为 \(\gamma^{-1}\)。让我们可视化过去40个时间步长中，各种 \(\gamma\) 选择的权重。
import math
import torch
from d2l import torch as d2l
d2l.set_figsize()
gammas = [0.95, 0.9, 0.8, 0.7]
for gamma in gammas:
x = torch.arange(40).detach().numpy()
d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')
d2l.plt.xlabel('time');
%matplotlib inline
import math
from mxnet import np, npx
from d2l import mxnet as d2l
npx.set_np()
d2l.set_figsize()
gammas = [0.95, 0.9, 0.8, 0.7]
for gamma in gammas:
x = np.arange(40).asnumpy()
d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')
d2l.plt.xlabel('time');
[22:04:19] ../src/storage/storage.cc:196: Using Pooled (Naive) StorageManager for CPU
import math
import tensorflow as tf
from d2l import tensorflow as d2l
d2l.set_figsize()
gammas = [0.95, 0.9, 0.8, 0.7]
for gamma in gammas:
x = tf.range(40).numpy()
d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')
d2l.plt.xlabel('time');
12.8.2. 从零开始实现¶
和之前一样，我们使用二次函数 \(f(\mathbf{x})=0.1x_1^2+2x_2^2\) 来观察RMSProp的轨迹。回想一下，在12.7节中，当我们使用学习率为0.4的Adagrad时，变量在算法的后期阶段移动非常缓慢，因为学习率下降得太快了。由于 \(\eta\) 是单独控制的，RMSProp不会发生这种情况。
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
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
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
接下来，我们实现RMSProp以用于深度网络。这同样简单直接。
def init_rmsprop_states(feature_dim):
s_w = torch.zeros((feature_dim, 1))
s_b = torch.zeros(1)
return (s_w, s_b)
def rmsprop(params, states, hyperparams):
gamma, eps = hyperparams['gamma'], 1e-6
for p, s in zip(params, states):
with torch.no_grad():
s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)
p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)
p.grad.data.zero_()
def init_rmsprop_states(feature_dim):
s_w = np.zeros((feature_dim, 1))
s_b = np.zeros(1)
return (s_w, s_b)
def rmsprop(params, states, hyperparams):
gamma, eps = hyperparams['gamma'], 1e-6
for p, s in zip(params, states):
s[:] = gamma * s + (1 - gamma) * np.square(p.grad)
p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)
def init_rmsprop_states(feature_dim):
s_w = tf.Variable(tf.zeros((feature_dim, 1)))
s_b = tf.Variable(tf.zeros(1))
return (s_w, s_b)
def rmsprop(params, grads, states, hyperparams):
gamma, eps = hyperparams['gamma'], 1e-6
for p, s, g in zip(params, states, grads):
s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))
p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))
我们将初始学习率设置为0.01，权重项 \(\gamma\) 设置为0.9。也就是说，\(\mathbf{s}\) 在过去 \(1/(1-\gamma) = 10\) 次观测的平方梯度上进行平均。
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(rmsprop, init_rmsprop_states(feature_dim),
{'lr': 0.01, 'gamma': 0.9}, data_iter, feature_dim);
loss: 0.245, 0.245 sec/epoch
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(rmsprop, init_rmsprop_states(feature_dim),
{'lr': 0.01, 'gamma': 0.9}, data_iter, feature_dim);
loss: 0.242, 0.659 sec/epoch
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(rmsprop, init_rmsprop_states(feature_dim),
{'lr': 0.01, 'gamma': 0.9}, data_iter, feature_dim);
loss: 0.244, 1.251 sec/epoch
12.8.3. 简洁实现¶
由于RMSProp是一种相当流行的算法，它在 Trainer 实例中也可用。我们所需要做的就是使用名为 rmsprop 的算法来实例化它，并将 \(\gamma\) 赋给参数 gamma1。
trainer = torch.optim.RMSprop
d2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9},
data_iter)
loss: 0.246, 0.129 sec/epoch
d2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9},
data_iter)
loss: 0.245, 0.381 sec/epoch
trainer = tf.keras.optimizers.RMSprop
d2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9},
data_iter)
loss: 0.245, 1.269 sec/epoch
12.8.4. 总结¶
RMSProp与Adagrad非常相似，因为两者都使用梯度的平方来缩放系数。
RMSProp与动量法共享泄漏平均。然而，RMSProp使用该技术来调整系数级别的预处理器。
在实践中，学习率需要由实验者进行调度。
系数 \(\gamma\) 决定了在调整每个坐标的缩放比例时历史记录的长度。