【优化算法】3. 学习率优化算法

概论

学习率(learning rate)决定目标函数能否收敛到最小值，和何时收敛到最小值。如果直接设定一个学习率η，是一个很棘手的问题。学习率η设定太小，算法就会进展缓慢，设定太大，就会震荡或者发散。针对这样的问题，就产生了学习率自适应算法。

基础

牛顿法

函数$f:{\mathbb{R}}^d\to \mathbb{R}$的泰勒展开式，事实上我们可以把它写成

$$f(\mathbf{x}+\mathbf{ϵ})=f(\mathbf{x})+{\mathbf{ϵ}}^{\top }\nabla f(\mathbf{x})+\frac{1}{2}{\mathbf{ϵ}}^{\top }{\nabla }^{2}f(\mathbf{x})\mathbf{ϵ}+\mathcal{O}(\Vert \mathbf{ϵ}{\Vert }^3).$$

为了避免繁琐的符号，我们将$\mathbf{H}\stackrel{\mathrm{def}}{=}{\nabla }^{2}f(\mathbf{x})$定义为$f$的Hessian，是$d\times d$矩阵。当$d$的值很小且问题很简单时，$\mathbf{H}$很容易计算。但是对于深度神经网络而言，考虑到$\mathbf{H}$可能非常大，$\mathcal{O}(d^2)$个条目的存储代价会很高，
此外通过反向传播进行计算可能雪上加霜。然而，我们姑且先忽略这些考量，看看会得到什么算法。

毕竟，$f$的最小值满足$\nabla f=0$。遵循的微积分规则，通过取$\mathbf{ϵ}$对$f$的导数，再忽略不重要的高阶项，我们便得到

$$\nabla f(\mathbf{x})+\mathbf{H}\mathbf{ϵ}=0\text{ and hence }\mathbf{ϵ}=-{\mathbf{H}}^{-1}\nabla f(\mathbf{x}).$$

也就是说，作为优化问题的一部分，我们需要将Hessian矩阵$\mathbf{H}$求逆。

举一个简单的例子，对于$f(x)=\frac{1}{2}{x}^2$，我们有$\nabla f(x)=x$和$\mathbf{H}=1$。因此，对于任何$x$，我们可以获得$ϵ=-x$。换言之，单单一步就足以完美地收敛，而无须任何调整。我们在这里比较幸运：泰勒展开式是确切的，因为$f(x+ϵ)=\frac{1}{2}{x}^2+ϵx+\frac{1}{2}{ϵ}^2$。

稀疏特征的学习率

在深度学习训练中，为了获得良好的准确性，我们希望在训练过程中降低学习率，速度通常是为$\mathcal{O}(t^{-\frac{1}{2}})$或更低。这种情况下，我们在训练过程中就会遇到以下情况：

• 常用特征的参数迅速收敛的最佳值，学习率相对来说降低太慢。
• 稀疏特征因为缺乏足够的观测数据收敛很慢，学习率对其来说降低太快。

为了解决这个问题，我们可以通过记录特征次数来调整对应的学习率。我们使用${\eta }_i=\frac{{\eta }_0}{\sqrt{s(i,t)+c}}$的学习率，而不是$\eta =\frac{{\eta }_0}{\sqrt{t+c}}$。$s(i,t)$计下了我们截至$t$时观察到功能$i$的次数。

AdaGrad

AdaGrad算法使用先前所得梯度平方和$s(i,t+1)=s(i,t)+{\left({\partial }_{i}f(\mathbf{x})\right)}^2$来替代$s(i,t)$来调整学习率。算法有两个优点：

• 不需要决定梯度何时算足够大。
• 学习率会随着梯度大小自动变化。梯度较大时学习率会显著缩小，梯度较小时学习率会平滑处理。

我们使用$s_t$来累加过去的梯度方差：
$$\begin{gathered} {\mathbf{g}}_t={\partial }_{\mathbf{w}}l(y_t,f({\mathbf{x}}_t,\mathbf{w})) \\ {\mathbf{s}}_t={\mathbf{s}}_{t-1}+{\mathbf{g}}_t^2 \\ {\mathbf{w}}_t={\mathbf{w}}_{t-1}-\frac{\eta }{\sqrt{{\mathbf{s}}_t+ϵ}}\cdot {\mathbf{g}}_t \end{gathered}$$
随着算法不断迭代，$\mathbf{s}$不断变大，学习率就越来越小。

Adadelta

Adadelta算法是AdaGrad算法的变体。主要的不同是Adadelta算法减少了学习率适应坐标的数量，简单说就是计算大小为w的时间区间内的梯度值的累积和，代替使用所有梯度值的平方和。而且，adadelta也被称为没有学习率，因为它使用变化量本身作为未来变化的校准。

Adadelta使用两个状态变量${\mathbf{s}}_t$和$\Delta {\mathbf{x}}_t$，其中${\mathbf{s}}_t$存储梯度二阶导数的泄漏平均值，$\Delta {\mathbf{x}}_t$存储的是模型本身中参数变化二阶导数的泄漏平均值。

梯度泄漏更新：${\mathbf{s}}_t=\rho {\mathbf{s}}_{t-1}+(1-\rho ){\mathbf{g}}_t^2.$

使用重新缩放的梯度${\mathbf{g}}_t^{\prime }$执行更新：${\mathbf{x}}_t={\mathbf{x}}_{t-1}-{\mathbf{g}}_t^{\prime }$

其中：${\mathbf{g}}_t^{\prime }=\frac{\sqrt{\Delta {\mathbf{x}}_{t-1}+ϵ}}{\sqrt{s_t+ϵ}}\odot {\mathbf{g}}_t$

$\Delta {\mathbf{x}}_{t-1}$是重新缩放梯度的平方${\mathbf{g}}_t^{\prime }$​的泄漏平均值。我们将$\Delta {\mathbf{x}}_0$初始化为$0$，然后在每个步骤中使用${\mathbf{g}}_t^{\prime }$更新它，即：

$\Delta {\mathbf{x}}_t=\rho \Delta {\mathbf{x}}_{t-1}+(1-\rho ）{{\mathbf{g}}_t^{\prime }}^2$ 。

RMSProp算法

Root mean Square Prop算法，算法将速率调度与坐标自适应学习率分离进行简单修复。AdaGrad算法将梯度${\mathbf{g}}_t$的平方累加成状态矢量${\mathbf{s}}_t={\mathbf{s}}_{t-1}+{\mathbf{g}}_t^2$，因此学习率是不断缩减的。

要解决这个问题可以用以下两种方法

• 使用${\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算法。

算法详情：

$$\begin{array}{rl}{\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+ϵ}}\odot {\mathbf{g}}_t.\end{array}$$

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

我们使用$1+\gamma +{\gamma }^2+\dots ,=\frac{1}{1-\gamma }$。因此，权重总和标准化为$1$且观测值的半衰期为${\gamma }^{-1}$。

Adam

Adam算法的关键组成部分之一是：它使用指数加权移动平均值来估算梯度的动量和二次矩，即它使用状态变量

$$\begin{array}{rl}{\mathbf{v}}_t& \leftarrow {\beta }_1{\mathbf{v}}_{t-1}+(1-{\beta }_1){\mathbf{g}}_t,\\ {\mathbf{s}}_t& \leftarrow {\beta }_2{\mathbf{s}}_{t-1}+(1-{\beta }_2){\mathbf{g}}_t^2.\end{array}$$

这里${\beta }_1$和${\beta }_2$是非负加权参数。常将它们设置为${\beta }_1=0.9$和${\beta }_2=0.999$​。也就是说，方差估计的移动远远慢于动量估计的移动。注意，如果我们初始化${\mathbf{v}}_0={\mathbf{s}}_0=0$，就会获得一个相当大的初始偏差。我们可以通过使用${\sum }_{i=0}^t{\beta }^i=\frac{1-{\beta }^t}{1-\beta }$来解决这个问题。相应地，标准化状态变量由下式获得

$${\hat{\mathbf{v}}}_t=\frac{{\mathbf{v}}_t}{1-{\beta }_1^t}\text{ and }{\hat{\mathbf{s}}}_t=\frac{{\mathbf{s}}_t}{1-{\beta }_2^t}.$$

有了正确的估计，我们现在可以写出更新方程。首先，我们以非常类似于RMSProp算法的方式重新缩放梯度以获得

$${\mathbf{g}}_t^{\prime }=\frac{\eta {\hat{\mathbf{v}}}_t}{\sqrt{{\hat{\mathbf{s}}}_t}+ϵ}.$$

与RMSProp不同，我们的更新使用动量${\hat{\mathbf{v}}}_t$而不是梯度本身。此外，由于使用$\frac{1}{\sqrt{{\hat{\mathbf{s}}}_t}+ϵ}$而不是$\frac{1}{\sqrt{{\hat{\mathbf{s}}}_t+ϵ}}$进行缩放，两者会略有差异。前者在实践中效果略好一些，因此与RMSProp算法有所区分。通常，我们选择$ϵ=10^{-6}$，这是为了在数值稳定性和逼真度之间取得良好的平衡。最后，我们简单更新：

$${\mathbf{x}}_t\leftarrow {\mathbf{x}}_{t-1}-{\mathbf{g}}_t^{\prime }.$$

回顾Adam算法，它的设计灵感很清楚：首先，动量和规模在状态变量中清晰可见，它们相当独特的定义使我们移除偏项（这可以通过稍微不同的初始化和更新条件来修正）。其次，RMSProp算法中两项的组合都非常简单。最后，明确的学习率$\eta$使我们能够控制步长来解决收敛问题。

Yogi

Adam算法也存在一些问题：即使在凸环境下，当${\mathbf{s}}_t$的二次矩估计值爆炸时，它可能无法收敛。针对${\mathbf{s}}_t$提出了的改进更新和参数初始化。重写Adam算法更新如下：

$${\mathbf{s}}_t\leftarrow {\mathbf{s}}_{t-1}+(1-{\beta }_2)\left({\mathbf{g}}_t^2-{\mathbf{s}}_{t-1}\right).$$

每当${\mathbf{g}}_t^2$具有值很大的变量或更新很稀疏时，${\mathbf{s}}_t$可能会太快地“忘记”过去的值。一个有效的解决方法是将${\mathbf{g}}_t^2-{\mathbf{s}}_{t-1}$替换为${\mathbf{g}}_t^2\odot \mathrm{sgn}({\mathbf{g}}_t^2-{\mathbf{s}}_{t-1})$。这就是Yogi更新，现在更新的规模不再取决于偏差的量。

$${\mathbf{s}}_t\leftarrow {\mathbf{s}}_{t-1}+(1-{\beta }_2){\mathbf{g}}_t^2\odot \mathrm{sgn}({\mathbf{g}}_t^2-{\mathbf{s}}_{t-1}).$$

优缺点

这些学习率优化算法都是用于深度学习训练中的梯度下降法。梯度下降法的目标是找到损失函数的最小值。这里，我们将简单通俗地解释这些算法的区别和各自的特点。

AdaGrad (Adaptive Gradient):
AdaGrad 是一种自适应学习率的优化算法，它可以为每个参数分配一个单独的学习率。特点是对于稀疏参数，学习率下降得较快，而对于常见参数，学习率下降得较慢。但AdaGrad的一个问题是，随着训练的进行，学习率可能会下降得过快，导致模型在训练后期学不到有效的信息。

Adadelta:
Adadelta 是对 AdaGrad 的一种改进，它解决了 AdaGrad 学习率过快下降的问题。Adadelta 不直接依赖于所有历史梯度的累积，而是使用一个固定窗口大小的梯度平方的移动平均来调整学习率。这使得学习率下降得更为平稳。

RMSProp (Root Mean Square Propagation):
RMSProp 同样是对 AdaGrad 的改进。它引入了一个衰减系数，只考虑最近一段时间内的梯度变化，而非全部历史梯度。这使得 RMSProp 能够应对非稳态问题，同时避免了学习率过快下降的问题。

Adam (Adaptive Moment Estimation):
Adam 算法结合了 AdaGrad 和 RMSProp 的优点，同时引入了动量（Momentum）的概念。Adam 通过计算梯度的一阶矩（均值）和二阶矩（未中心化的方差）的指数移动平均来调整学习率。这使得 Adam 具有更快的收敛速度和更高的稳定性。

Yogi:
Yogi 是对 Adam 算法的改进。它在计算梯度的二阶矩时，引入了一种自适应的方法，可以在不同的情况下自动调整梯度的更新方向。这使得 Yogi 在某些任务上比 Adam 更加稳定。