12.9. Adadelta¶ 在 SageMaker Studio Lab 中打开 Notebook
Adadelta是AdaGrad的另一种变体（参见 12.7节），主要区别在于它减少了学习率适应坐标的数量。另外，传统上Adadelta被称为没有学习率，因为它使用变化量本身作为未来变化的校准。该算法由 Zeiler (2012) 提出。鉴于我们目前对其他算法的讨论，Adadelta的实现相当简单。
12.9.1. 算法¶
简而言之，Adadelta使用两个状态变量，\(\mathbf{s}_t\) 用于存储梯度二阶导数的泄露平均值，\(\Delta\mathbf{x}_t\) 用于存储模型本身参数变化二阶导数的泄露平均值。请注意，为了与其他出版物和实现兼容，我们使用了作者的原始符号和命名（没有其他真正的原因，为什么要在动量法、Adagrad、RMSProp和Adadelta中，对功能相同的参数使用不同的希腊字母）。
以下是Adadelta的技术细节。给定参数 \(\rho\)，我们得到以下泄漏更新，这与 12.8节 类似：
与 12.8节 的不同之处在于，我们使用重新缩放的梯度 \(\mathbf{g}_t'\) 执行更新，即：
那么，重新缩放的梯度 \(\mathbf{g}_t'\) 是什么？我们可以如下计算它：
其中 \(\Delta \mathbf{x}_{t-1}\) 是重新缩放梯度 \(\mathbf{g}_t'\) 的平方的泄漏平均值。我们将 \(\Delta \mathbf{x}_{0}\) 初始化为 \(0\)，并在每一步用 \(\mathbf{g}_t'\) 更新它，即：
并且 \(\epsilon\)（一个很小的数值，例如 \(10^{-5}\)）被添加进来以保持数值稳定性。
12.9.2. 实现¶
Adadelta需要为每个变量维护两个状态变量，即 \(\mathbf{s}_t\) 和 \(\Delta\mathbf{x}_t\)。这产生了以下实现。
%matplotlib inline
import torch
from d2l import torch as d2l
def init_adadelta_states(feature_dim):
s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)
delta_w, delta_b = torch.zeros((feature_dim, 1)), torch.zeros(1)
return ((s_w, delta_w), (s_b, delta_b))
def adadelta(params, states, hyperparams):
rho, eps = hyperparams['rho'], 1e-5
for p, (s, delta) in zip(params, states):
with torch.no_grad():
# In-place updates via [:]
s[:] = rho * s + (1 - rho) * torch.square(p.grad)
g = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad
p[:] -= g
delta[:] = rho * delta + (1 - rho) * g * g
p.grad.data.zero_()
%matplotlib inline
from mxnet import np, npx
from d2l import mxnet as d2l
npx.set_np()
def init_adadelta_states(feature_dim):
s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)
delta_w, delta_b = np.zeros((feature_dim, 1)), np.zeros(1)
return ((s_w, delta_w), (s_b, delta_b))
def adadelta(params, states, hyperparams):
rho, eps = hyperparams['rho'], 1e-5
for p, (s, delta) in zip(params, states):
# In-place updates via [:]
s[:] = rho * s + (1 - rho) * np.square(p.grad)
g = (np.sqrt(delta + eps) / np.sqrt(s + eps)) * p.grad
p[:] -= g
delta[:] = rho * delta + (1 - rho) * g * g
%matplotlib inline
import tensorflow as tf
from d2l import tensorflow as d2l
def init_adadelta_states(feature_dim):
s_w = tf.Variable(tf.zeros((feature_dim, 1)))
s_b = tf.Variable(tf.zeros(1))
delta_w = tf.Variable(tf.zeros((feature_dim, 1)))
delta_b = tf.Variable(tf.zeros(1))
return ((s_w, delta_w), (s_b, delta_b))
def adadelta(params, grads, states, hyperparams):
rho, eps = hyperparams['rho'], 1e-5
for p, (s, delta), grad in zip(params, states, grads):
s[:].assign(rho * s + (1 - rho) * tf.math.square(grad))
g = (tf.math.sqrt(delta + eps) / tf.math.sqrt(s + eps)) * grad
p[:].assign(p - g)
delta[:].assign(rho * delta + (1 - rho) * g * g)
选择 \(\rho = 0.9\) 相当于每个参数更新的半衰期为10。这通常效果很好。我们得到以下行为。
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(adadelta, init_adadelta_states(feature_dim),
{'rho': 0.9}, data_iter, feature_dim);
loss: 0.245, 0.160 sec/epoch
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(adadelta, init_adadelta_states(feature_dim),
{'rho': 0.9}, data_iter, feature_dim);
loss: 0.243, 0.813 sec/epoch
data_iter, feature_dim = d2l.get_data_ch11(batch_size=10)
d2l.train_ch11(adadelta, init_adadelta_states(feature_dim),
{'rho': 0.9}, data_iter, feature_dim);
loss: 0.243, 1.599 sec/epoch
对于简洁的实现，我们只需使用高级API中的Adadelta算法。这只需一行代码即可更紧凑地调用。
trainer = torch.optim.Adadelta
d2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)
loss: 0.243, 0.119 sec/epoch
d2l.train_concise_ch11('adadelta', {'rho': 0.9}, data_iter)
loss: 0.248, 0.886 sec/epoch
# adadelta is not converging at default learning rate
# but it is converging at lr = 5.0
trainer = tf.keras.optimizers.Adadelta
d2l.train_concise_ch11(trainer, {'learning_rate':5.0, 'rho': 0.9}, data_iter)
loss: 0.246, 1.551 sec/epoch
12.9.3. 小结¶
Adadelta没有学习率参数。相反，它使用参数本身的变化率来调整学习率。
Adadelta需要两个状态变量来存储梯度的二阶矩和参数的变化。
Adadelta使用泄漏平均值来保持对适当统计数据的运行估计。