7.5. AdaGrad算法

在之前介绍过的优化算法中，目标函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。举个例子，假设目标函数为

7.5. AdaGrad算法 - 图1 ，自变量为一个二维向量 7.5. AdaGrad算法 - 图2 ，该向量中每一个元素在迭代时都使用相同的学习率。例如，在学习率为 7.5. AdaGrad算法 - 图3 的梯度下降中，元素 7.5. AdaGrad算法 - 图4 和 7.5. AdaGrad算法 - 图5 都使用相同的学习率 7.5. AdaGrad算法 - 图6 来自我迭代：

7.5. AdaGrad算法 - 图7

在“动量法”一节里我们看到当

7.5. AdaGrad算法 - 图8 和 7.5. AdaGrad算法 - 图9 的梯度值有较大差别时，需要选择足够小的学习率使得自变量在梯度值较大的维度上不发散。但这样会导致自变量在梯度值较小的维度上迭代过慢。动量法依赖指数加权移动平均使得自变量的更新方向更加一致，从而降低发散的可能。本节我们介绍AdaGrad算法，它根据自变量在每个维度的梯度值的大小来调整各个维度上的学习率，从而避免统一的学习率难以适应所有维度的问题[1]。

7.5.1. 算法

AdaGrad算法会使用一个小批量随机梯度

7.5. AdaGrad算法 - 图10 按元素平方的累加变量 7.5. AdaGrad算法 - 图11 。在时间步0，AdaGrad将 7.5. AdaGrad算法 - 图12 中每个元素初始化为0。在时间步 7.5. AdaGrad算法 - 图13 ，首先将小批量随机梯度 7.5. AdaGrad算法 - 图14 按元素平方后累加到变量 7.5. AdaGrad算法 - 图15 ：

7.5. AdaGrad算法 - 图16

其中

7.5. AdaGrad算法 - 图17 是按元素相乘。接着，我们将目标函数自变量中每个元素的学习率通过按元素运算重新调整一下：

7.5. AdaGrad算法 - 图18

其中

7.5. AdaGrad算法 - 图19 是学习率， 7.5. AdaGrad算法 - 图20 是为了维持数值稳定性而添加的常数，如 7.5. AdaGrad算法 - 图21 。这里开方、除法和乘法的运算都是按元素运算的。这些按元素运算使得目标函数自变量中每个元素都分别拥有自己的学习率。

7.5.2. 特点

需要强调的是，小批量随机梯度按元素平方的累加变量

7.5. AdaGrad算法 - 图22 出现在学习率的分母项中。因此，如果目标函数有关自变量中某个元素的偏导数一直都较大，那么该元素的学习率将下降较快；反之，如果目标函数有关自变量中某个元素的偏导数一直都较小，那么该元素的学习率将下降较慢。然而，由于 7.5. AdaGrad算法 - 图23 一直在累加按元素平方的梯度，自变量中每个元素的学习率在迭代过程中一直在降低（或不变）。所以，当学习率在迭代早期降得较快且当前解依然不佳时，AdaGrad算法在迭代后期由于学习率过小，可能较难找到一个有用的解。

下面我们仍然以目标函数

7.5. AdaGrad算法 - 图24 为例观察AdaGrad算法对自变量的迭代轨迹。我们实现AdaGrad算法并使用和上一节实验中相同的学习率0.4。可以看到，自变量的迭代轨迹较平滑。但由于 7.5. AdaGrad算法 - 图25 的累加效果使学习率不断衰减，自变量在迭代后期的移动幅度较小。

  1. In [1]:
  1. %matplotlib inline
  2. import d2lzh as d2l
  3. import math
  4. from mxnet import nd
  5.  
  6. def adagrad_2d(x1, x2, s1, s2):
  7.     g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6  # 前两项为自变量梯度
  8.     s1 += g1 ** 2
  9.     s2 += g2 ** 2
  10.     x1 -= eta / math.sqrt(s1 + eps) * g1
  11.     x2 -= eta / math.sqrt(s2 + eps) * g2
  12.     return x1, x2, s1, s2
  13.  
  14. def f_2d(x1, x2):
  15.     return 0.1 * x1 ** 2 + 2 * x2 ** 2
  16.  
  17. eta = 0.4
  18. d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))
  1. epoch 20, x1 -2.382563, x2 -0.158591

../_images/chapter_optimization_adagrad_1_1.svg

下面将学习率增大到2。可以看到自变量更为迅速地逼近了最优解。

  1. In [2]:
  1. eta = 2
  2. d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))
  1. epoch 20, x1 -0.002295, x2 -0.000000

../_images/chapter_optimization_adagrad_3_1.svg

7.5.3. 从零开始实现

同动量法一样，AdaGrad算法需要对每个自变量维护同它一样形状的状态变量。我们根据AdaGrad算法中的公式实现该算法。

  1. In [3]:
  1. features, labels = d2l.get_data_ch7()
  2.  
  3. def init_adagrad_states():
  4.     s_w = nd.zeros((features.shape[1], 1))
  5.     s_b = nd.zeros(1)
  6.     return (s_w, s_b)
  7.  
  8. def adagrad(params, states, hyperparams):
  9.     eps = 1e-6
  10.     for p, s in zip(params, states):
  11.         s[:] += p.grad.square()
  12.         p[:] -= hyperparams['lr'] * p.grad / (s + eps).sqrt()

与“小批量随机梯度下降”一节中的实验相比，这里使用更大的学习率来训练模型。

  1. In [4]:
  1. d2l.train_ch7(adagrad, init_adagrad_states(), {'lr': 0.1}, features, labels)
  1. loss: 0.243168, 0.342836 sec per epoch

../_images/chapter_optimization_adagrad_7_1.svg

7.5.4. 简洁实现

通过名称为“adagrad”的Trainer实例，我们便可使用Gluon提供的AdaGrad算法来训练模型。

  1. In [5]:
  1. d2l.train_gluon_ch7('adagrad', {'learning_rate': 0.1}, features, labels)
  1. loss: 0.244961, 0.310884 sec per epoch

../_images/chapter_optimization_adagrad_9_1.svg

7.5.5. 小结

  • AdaGrad算法在迭代过程中不断调整学习率，并让目标函数自变量中每个元素都分别拥有自己的学习率。
  • 使用AdaGrad算法时，自变量中每个元素的学习率在迭代过程中一直在降低（或不变）。

7.5.6. 练习

  • 在介绍AdaGrad算法的特点时，我们提到了它可能存在的问题。你能想到什么办法来解决这个问题？
  • 在实验中尝试使用其他的初始学习率，结果有什么变化？

7.5.7. 参考文献

[1] Duchi, J., Hazan, E., & Singer, Y. (2011). Adaptive subgradientmethods for online learning and stochastic optimization. Journal ofMachine Learning Research, 12(Jul), 2121-2159.