Run this notebook online:Binder or Colab: Colab

11.8. RMSProp算法

Section 11.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算法。

11.8.1. 算法

让我们详细写出这些方程式。

(11.8.1)\[\begin{split}\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}\end{split}\]

常数\(\epsilon > 0\)通常设置为\(10^{-6}\),以确保我们不会因除以零或步长过大而受到影响。 鉴于这种扩展,我们现在可以自由控制学习率\(\eta\),而不考虑基于每个坐标应用的缩放。 就泄漏平均值而言,我们可以采用与之前在动量法中适用的相同推理。 扩展\(\mathbf{s}_t\)定义可获得

(11.8.2)\[\begin{split}\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}\end{split}\]

同之前在 Section 11.6小节一样,我们使用\(1 + \gamma + \gamma^2 + \ldots, = \frac{1}{1-\gamma}\)。 因此,权重总和标准化为\(1\)且观测值的半衰期为\(\gamma^{-1}\)。 让我们图像化各种数值的\(\gamma\)在过去40个时间步长的权重。

%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
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));
7a32cd4d-dd59-48d0-9853-cfa6cd7d6263

11.8.2. 从零开始实现

和之前一样,我们使用二次函数\(f(\mathbf{x})=0.1x_1^2+2x_2^2\)来观察RMSProp算法的轨迹。 回想在 Section 11.7一节中,当我们使用学习率为0.4的Adagrad算法时,变量在算法的后期阶段移动非常缓慢,因为学习率衰减太快。 RMSProp算法中不会发生这种情况,因为\(\eta\)是单独控制的。

float eta = 0.4f;
float gamma = 0.9f;

Function<Float[], Float[]> 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<Float, Float, Float> f2d = (x1, x2) -> {
    return 0.1f * x1 * x1 + 2 * x2 * x2;
};

GradDescUtils.showTrace2d(f2d, GradDescUtils.train2d(rmsProp2d, 20));
Tablesaw not supporting for contour and meshgrids, will update soon
https://d2l-java-resources.s3.amazonaws.com/img/chapter_optim-rmsprop-gd2d.svg

Fig. 11.8.1 RmsProp Gradient Descent 2D.

接下来,我们在深度网络中实现RMSProp算法。

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<String, Float> 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,加权项\(\gamma\)设置为0.9。 也就是说,\(\mathbf{s}\)累加了过去的\(1/(1-\gamma) = 10\)次平方梯度观测值的平均值。

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<String, Float> 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);
loss: 0.249, 0.090 sec/epoch
REPL.$JShell$158B$TrainingChapter11$LossTime@44b13f8b

11.8.3. 简洁实现

我们可直接使用DJL中提供的RMSProp算法来训练模型。

Tracker lrt = Tracker.fixed(0.01f);
Optimizer rmsProp = Optimizer.rmsprop().optLearningRateTracker(lrt).optRho(0.9f).build();

TrainingChapter11.trainConciseCh11(rmsProp, airfoil, 2);
INFO Training on: 1 GPUs.
INFO Load MXNet Engine Version 1.8.0 in 0.074 ms.
Training:    100% |████████████████████████████████████████| Accuracy: 0.67, L2Loss: 0.29
loss: 0.250, 0.144 sec/epoch

11.8.4. 小结

  • RMSProp算法与Adagrad算法非常相似,因为两者都使用梯度的平方来缩放系数。

  • RMSProp算法与动量法都使用泄漏平均值。但是,RMSProp算法使用该技术来调整按系数顺序的预处理器。

  • 在实验中,学习率需要由实验者调度。

  • 系数\(\gamma\)决定了在调整每坐标比例时历史记录的时长。

11.8.5. 练习

  1. 如果我们设置\(\gamma = 1\),实验会发生什么?为什么?

  2. 旋转优化问题以最小化\(f(\mathbf{x}) = 0.1 (x_1 + x_2)^2 + 2 (x_1 - x_2)^2\)。收敛会发生什么?

  3. 试试在真正的机器学习问题上应用RMSProp算法会发生什么,例如在Fashion-MNIST上的训练。试验不同的取值来调整学习率。

  4. 随着优化的进展,需要调整\(\gamma\)吗?RMSProp算法对此有多敏感?