Run this notebook online:\ |Binder| or Colab: |Colab|
.. |Binder| image:: https://mybinder.org/badge_logo.svg
:target: https://mybinder.org/v2/gh/deepjavalibrary/d2l-java/master?filepath=chapter_optimization/rmsprop.ipynb
.. |Colab| image:: https://colab.research.google.com/assets/colab-badge.svg
:target: https://colab.research.google.com/github/deepjavalibrary/d2l-java/blob/colab/chapter_optimization/rmsprop.ipynb
.. _sec_rmsprop:
RMSProp算法
===========
:numref:`sec_adagrad`\ 中的关键问题之一，是学习率按预定时间表\ :math:`\mathcal{O}(t^{-\frac{1}{2}})`\ 显著降低。
虽然这通常适用于凸问题，但对于深度学习中遇到的非凸问题，可能并不理想。
但是，作为一个预处理器，Adagrad算法按坐标顺序的适应性是非常可取的。
:cite:`Tieleman.Hinton.2012`\ 建议以RMSProp算法作为将速率调度与坐标自适应学习率分离的简单修复方法。
问题在于，Adagrad算法将梯度\ :math:`\mathbf{g}_t`\ 的平方累加成状态矢量\ :math:`\mathbf{s}_t = \mathbf{s}_{t-1} + \mathbf{g}_t^2`\ 。
因此，由于缺乏规范化，没有约束力，\ :math:`\mathbf{s}_t`\ 持续增长，几乎上是在算法收敛时呈线性递增。
解决此问题的一种方法是使用\ :math:`\mathbf{s}_t / t`\ 。
对于\ :math:`\mathbf{g}_t`\ 的合理分布来说，它将收敛。
遗憾的是，限制行为生效可能需要很长时间，因为该流程记住了价值的完整轨迹。
另一种方法是按动量法中的方式使用泄漏平均值，即\ :math:`\mathbf{s}_t \leftarrow \gamma \mathbf{s}_{t-1} + (1-\gamma) \mathbf{g}_t^2`\ ，其中参数\ :math:`\gamma > 0`\ 。
保持其他部所有分不变就产生了RMSProp算法。
算法
----
让我们详细写出这些方程式。
.. math::
\begin{aligned}
\mathbf{s}_t & \leftarrow \gamma \mathbf{s}_{t-1} + (1 - \gamma) \mathbf{g}_t^2, \\
\mathbf{x}_t & \leftarrow \mathbf{x}_{t-1} - \frac{\eta}{\sqrt{\mathbf{s}_t + \epsilon}} \odot \mathbf{g}_t.
\end{aligned}
常数\ :math:`\epsilon > 0`\ 通常设置为\ :math:`10^{-6}`\ ，以确保我们不会因除以零或步长过大而受到影响。
鉴于这种扩展，我们现在可以自由控制学习率\ :math:`\eta`\ ，而不考虑基于每个坐标应用的缩放。
就泄漏平均值而言，我们可以采用与之前在动量法中适用的相同推理。
扩展\ :math:`\mathbf{s}_t`\ 定义可获得
.. math::
\begin{aligned}
\mathbf{s}_t & = (1 - \gamma) \mathbf{g}_t^2 + \gamma \mathbf{s}_{t-1} \\
& = (1 - \gamma) \left(\mathbf{g}_t^2 + \gamma \mathbf{g}_{t-1}^2 + \gamma^2 \mathbf{g}_{t-2} + \ldots, \right).
\end{aligned}
同之前在
:numref:`sec_momentum`\ 小节一样，我们使用\ :math:`1 + \gamma + \gamma^2 + \ldots, = \frac{1}{1-\gamma}`\ 。
因此，权重总和标准化为\ :math:`1`\ 且观测值的半衰期为\ :math:`\gamma^{-1}`\ 。
让我们图像化各种数值的\ :math:`\gamma`\ 在过去40个时间步长的权重。
.. code:: java
%load ../utils/djl-imports
%load ../utils/plot-utils
%load ../utils/Functions.java
%load ../utils/GradDescUtils.java
%load ../utils/Accumulator.java
%load ../utils/StopWatch.java
%load ../utils/Training.java
%load ../utils/TrainingChapter11.java
.. code:: java
NDManager manager = NDManager.newBaseManager();
float[] gammas = new float[]{0.95f, 0.9f, 0.8f, 0.7f};
NDArray timesND = manager.arange(40f);
float[] times = timesND.toFloatArray();
display(GradDescUtils.plotGammas(times, gammas, 600, 400));
.. raw:: html
![]()
.. parsed-literal::
:class: output
8938a0f7-03fe-437b-9460-de94ee623be8
从零开始实现
------------
和之前一样，我们使用二次函数\ :math:`f(\mathbf{x})=0.1x_1^2+2x_2^2`\ 来观察RMSProp算法的轨迹。
回想在
:numref:`sec_adagrad`\ 一节中，当我们使用学习率为0.4的Adagrad算法时，变量在算法的后期阶段移动非常缓慢，因为学习率衰减太快。
RMSProp算法中不会发生这种情况，因为\ :math:`\eta`\ 是单独控制的。
.. code:: java
float eta = 0.4f;
float gamma = 0.9f;
Function rmsProp2d = (state) -> {
Float x1 = state[0], x2 = state[1], s1 = state[2], s2 = state[3];
float g1 = 0.2f * x1;
float g2 = 4 * x2;
float eps = (float) 1e-6;
s1 = gamma * s1 + (1 - gamma) * g1 * g1;
s2 = gamma * s2 + (1 - gamma) * g2 * g2;
x1 -= eta / (float) Math.sqrt(s1 + eps) * g1;
x2 -= eta / (float) Math.sqrt(s2 + eps) * g2;
return new Float[]{x1, x2, s1, s2};
};
BiFunction f2d = (x1, x2) -> {
return 0.1f * x1 * x1 + 2 * x2 * x2;
};
GradDescUtils.showTrace2d(f2d, GradDescUtils.train2d(rmsProp2d, 20));
.. parsed-literal::
:class: output
Tablesaw not supporting for contour and meshgrids, will update soon
.. figure:: https://d2l-java-resources.s3.amazonaws.com/img/chapter_optim-rmsprop-gd2d.svg
RmsProp Gradient Descent 2D.
接下来，我们在深度网络中实现RMSProp算法。
.. code:: java
NDList initRmsPropStates(int featureDimension) {
NDManager manager = NDManager.newBaseManager();
NDArray sW = manager.zeros(new Shape(featureDimension, 1));
NDArray sB = manager.zeros(new Shape(1));
return new NDList(sW, sB);
}
public class Optimization {
public static void rmsProp(NDList params, NDList states, Map hyperparams) {
float gamma = hyperparams.get("gamma");
float eps = (float) 1e-6;
for (int i = 0; i < params.size(); i++) {
NDArray param = params.get(i);
NDArray state = states.get(i);
// Update parameter and state
// state = gamma * state + (1 - gamma) * param.gradient^(1/2)
state.muli(gamma).addi(param.getGradient().square().mul(1 - gamma));
// param -= lr * param.gradient / sqrt(s + eps)
param.subi(param.getGradient().mul(hyperparams.get("lr")).div(state.add(eps).sqrt()));
}
}
}
我们将初始学习率设置为0.01，加权项\ :math:`\gamma`\ 设置为0.9。
也就是说，\ :math:`\mathbf{s}`\ 累加了过去的\ :math:`1/(1-\gamma) = 10`\ 次平方梯度观测值的平均值。
.. code:: java
AirfoilRandomAccess airfoil = TrainingChapter11.getDataCh11(10, 1500);
public TrainingChapter11.LossTime trainRmsProp(float lr, float gamma, int numEpochs)
throws IOException, TranslateException {
int featureDimension = airfoil.getColumnNames().size();
Map hyperparams = new HashMap<>();
hyperparams.put("lr", lr);
hyperparams.put("gamma", gamma);
return TrainingChapter11.trainCh11(Optimization::rmsProp,
initRmsPropStates(featureDimension),
hyperparams, airfoil,
featureDimension, numEpochs);
}
trainRmsProp(0.01f, 0.9f, 2);
.. parsed-literal::
:class: output
loss: 0.244, 0.090 sec/epoch
.. parsed-literal::
:class: output
REPL.$JShell$154B$TrainingChapter11$LossTime@564dfe28
简洁实现
--------
我们可直接使用DJL中提供的RMSProp算法来训练模型。
.. code:: java
Tracker lrt = Tracker.fixed(0.01f);
Optimizer rmsProp = Optimizer.rmsprop().optLearningRateTracker(lrt).optRho(0.9f).build();
TrainingChapter11.trainConciseCh11(rmsProp, airfoil, 2);
.. parsed-literal::
:class: output
INFO Training on: 1 GPUs.
INFO Load MXNet Engine Version 1.9.0 in 0.063 ms.
.. parsed-literal::
:class: output
Training: 100% |████████████████████████████████████████| Accuracy: 1.00, L2Loss: 0.28
loss: 0.244, 0.141 sec/epoch
小结
----
- RMSProp算法与Adagrad算法非常相似，因为两者都使用梯度的平方来缩放系数。
- RMSProp算法与动量法都使用泄漏平均值。但是，RMSProp算法使用该技术来调整按系数顺序的预处理器。
- 在实验中，学习率需要由实验者调度。
- 系数\ :math:`\gamma`\ 决定了在调整每坐标比例时历史记录的时长。
练习
----
1. 如果我们设置\ :math:`\gamma = 1`\ ，实验会发生什么？为什么？
2. 旋转优化问题以最小化\ :math:`f(\mathbf{x}) = 0.1 (x_1 + x_2)^2 + 2 (x_1 - x_2)^2`\ 。收敛会发生什么？
3. 试试在真正的机器学习问题上应用RMSProp算法会发生什么，例如在Fashion-MNIST上的训练。试验不同的取值来调整学习率。
4. 随着优化的进展，需要调整\ :math:`\gamma`\ 吗？RMSProp算法对此有多敏感？