159

文章目录

  1. 简介
  2. 现存问题
    1. 收敛性定义
    2. 通用适应性算法
      1. SGD
      2. AdaGrad
      3. 基于指数滑动平均的适应性方法 (RMSProp, Adam, NAdam, AdaDelta)
    3. Adam 收敛问题实例
  3. AMSGrad
    1. 延伸算法:ADAMNC
  4. 实验对比
    1. MNIST 数据集
    2. CIFAR-10数据集
  5. 补充说明
  6. 引用

简介

现在训练深度学习网络的主要方法就是使用SGD优化器及其变体。一些SGD的变体比如:Adam, AdaDelta, Nadam等优化器利用了历史梯度的指数滑动平均的平方根信息,用于调整学习率,以提升优化器的性能。但是,根据经验来看,在许多应用中,这些优化器无法让模型收敛到最优解。本文的分析指出,导致该问题的一个原因就是这些优化器中使用了历史梯度的指数滑动平均信息。文中通过一个简单的例子展示了Adam优化器是如何收敛到一个非常差的结果的。为了解决此问题,文章提出了一个新的改进的优化器算法AMSGrad。该优化器不仅可以解决前面提到的收敛性问题,而且根据实验来看,还可以在一定程度上改善Adam的性能。

如果对优化器的一些基本知识不了解,可以参考一篇大佬的博客(综述) [2]。

现存问题

2011年,Duchi等人提出了AdaGrad算法,算法中使用了历史梯度信息的平方的均值信息来调整学习率,该方法在梯度比较稀疏或者小的时候可以在很大程度上改善SGD的性能。但是AdaGrad在loss函数为非凸或者梯度为非稀疏的时候,其性能会恶化。这是由于Adagrad在更新梯度的时候使用了所有历史梯度信息,这会导致学习率在非凸或非稀疏的设定下很快衰减。为了解决此问题,一些AdaGrad变体,比如RMSProp, Adam, AdaDelta, NAdam等等被提出来,以解决学习率过快衰减的问题。这些算法在很多场景下性能表现都不错,但是在某些情况下也出现了无法收敛到最优解的问题。特别是当某些mini-batch计算得到的梯度非常大的时候,虽然这些大梯度对于优化模型非常重要,但是这些大梯度的影响由于指数平均的存在会急速衰减,因此性能堪忧。

收敛性定义

定义第t步训练后,loss函数为$f_t(\theta_t)$,$\theta_t$为模型参数,定义如下指标(regret):

$$ \begin{align} regret & = R_T \\ & = \sum_{t=1}^T f_t(\theta_t) - min_{\theta \in \scr{F}}\sum_{t=1}^Tf_t(\theta) \end{align} $$

$\scr{F}$为参数的取值空间,$min_{\theta \in \scr{F}}\sum_{t=1}^Tf_t(\theta)$为在空间$\scr{F}$中能得到的最优的loss值,$regret$就是经优化器优化得到的模型与最优解之间的累积差距。

那么好的优化器应该可以保证:

$$ \lim_{T\to \infty} \frac{R_T}{T} = 0 $$

也就是说,优化器可以保证模型收敛到最优解。本文主要说明Adam在一些特定的条件下,无法保证在$T\to \infty$时,$\frac{R_T}{T}$趋于零,而新提出的AMSGrad可以。

通用适应性算法

本小节介绍我们上述提到的优化器的通用的适应性算法框架,以便比较它们。

算法1: 通用适应性算法

算法输入:

  • $\theta_1$: 表示模型初始参数, (原文中符号用的是$x$,不太符合我的使用习惯,这里换成$\theta$)
  • $\{ \alpha_t \}_{t=1}^T$: 第$t$步学习率的初始值 (原文用的是 step size,这里用学习率比较好理解)
  • $\{ \phi_t \}_{t=1}^T$: 计算平均 的函数,用于调整动量(Momentum)
  • $\{ \psi_t \}_{t=1}^T$: 计算平均 的函数,用于调整学习率

算法本体:

$$ \begin{align*} \bf{for}& \ t=1\ \bf{to}\ \it{T}\ \bf{do}\\ & g_t = \nabla f_t(\theta_t) \tag 1\\ & m_t = \phi(g_1, \ldots, g_t)\qquad \tag 2\\ & V_t = \psi(g_1, \ldots, g_t)\qquad \tag 3\\ & x_{t+1} = x_t - \alpha_tm_t/\sqrt{V_t}\qquad \tag 4\\ \bf{en}&\bf{dfor} \end{align*} $$

算法1的提供了当前适应性优化器算法的一个通用框架,它可以涵盖很多流行的优化算法。上述第四步中,$\alpha_t/\sqrt{V_t}$可以看作是实际的学习率。

SGD

如果将SGD算法套入到算法1中,那么有:

$$ \begin{align} \phi_t(g_1, \ldots, g_t) &= g_t\\ \psi_t(t_1, \ldots, g_t) &= \mathbb{I}\\ \alpha_t &=\alpha / \sqrt{t}, \forall t \in [T] \end{align} $$

SGD中$\alpha_t$的这种激进的衰减策略在实际使用时可能会导致性能问题。

AdaGrad

AdaGrad是首个适应性优化算法,它使用了如下的均值函数与学习率初始值:

$$ \begin{align} \phi_t(g_1, \ldots, g_t) &= g_t\\ \psi_t(g_1, \ldots, g_t) &= \frac{diag(\sum_{i=1}^t g_i^2)}{t}\\ \alpha_t &=\alpha / \sqrt{t}, \forall t \in [T] \end{align} $$

相比于SGD, AdaGrad将实际的学习率变为:

$$ \begin{align} lr &= \frac{\alpha_t}{\sqrt{V_t}} \\ &= \frac{\alpha/\sqrt{t}}{\sqrt{diag(\sum_{i=1}^tg_i^2)}/\sqrt{t}}\\ &= \frac{\alpha}{\sqrt{diag(\sum_{i=1}^tg_i^2)}} \end{align} $$

也就是:我们模型参数共有$d$维,那么第$j \in [1, d]$维的学习率为$\alpha / \sqrt{\sum_i g_{i,j}^2}$。相比于SGD的学习率以$\sqrt{t}$衰减,而AdaGrad以$\sqrt{\sum_i g_{i,j}^2}$衰减。当梯度比较稀疏的时候,$\sum_i g_{i,j}^2 < t$,此时AdaGrad学习率衰减要比SGD慢很多。因此,AdaGrad在很多梯度稀疏的场景下,性能表现良好。

基于指数滑动平均的适应性方法 (RMSProp, Adam, NAdam, AdaDelta)

此类方法与AdaGrad的重要区别就是引入了指数滑动平均。此处我们使用Adam作为典型来介绍此类方法,相比于AdaGrad来讲,Adam改进点在于:

  1. 引入动量: 基于动量的方法,当前轮的梯度更新会依赖于历史梯度信息
  2. 使用指数滑动平均而非简单的平均

动量方法:$m_{t}$的表达式为(此处我们使用迭代的表达形式):

$$ m_t = \beta_1m_{t-1} + (1-\beta_1)g_{t} $$

指数滑动平均:$v_t$的表达式为(此处我们使用迭代的表达形式):

$$ v_t = \beta_2v_{t-1} + (1-\beta_2)g_t^2 $$

其中$m_0 = 0, v_0 = 0$,在实际使用Adam时,$\beta_1, \beta_2$的典型值为$\beta_1=0.9, \beta_2=0.999$。

Adam 收敛问题实例

考虑一个简单的优化问题,loss函数为:

$$ f_t(\theta) = \begin{cases} C\theta, & \text{如果 t % 3 == 1}\\ -\theta, & \text{否则} \end{cases} $$

其中,$\theta \in [-1, 1], C \gt 2$。那么$t=1, 2, 3, \ldots$时的loss为

$$ C\theta, -\theta, -\theta, C\theta, -\theta, -\theta, \ldots $$

那么我们有累积loss:

$$ \begin{align} \sum_{t=1}^{3n}f_t(\theta) & = n * (C\theta - \theta - \theta)\\ & = n * (C-2) * \theta \end{align} $$

由于$C\gt2$,有$n*(C-2)\gt 0$,故为了最小化累计loss值,显然取$\theta$的最小值$=-1$时,我们有最小的累积loss为:

$$ -n*(C-2) $$

为了得到Adam无法收敛到最优值的一个实例,此处取$\beta_1 = 0, \beta_2=1/(1+C^2)$,此时Adam会将$\theta$收敛到$1$,而非最优值$-1$。

论文中给出了详细的证明,此处我们直观理解一下:

$f_t(\theta)$的梯度为:

$$ \nabla f_t(\theta) = \begin{cases} C, & \text{如果 t % 3 == 1}\\ -1, & \text{否则} \end{cases} $$

那么$t=1, 2, 3, \ldots$时,梯度为:

$$ C, -1, -1, C, -1, -1, \ldots $$

可以看出$t=3n+1$时,梯度为$C$,此时优化器可以将$\theta$往正确的方向(-1方向)移动;其它情况下梯度为-1, 此时$\theta$会往错误的方向移动。如果不存在衰减系数,由于$C$很大($C\gt 2$),最终$\theta$会收敛到最优值$-1$。但是,Adam中引入了衰减系数$\beta_2 = 1/(1+C^2)$,我们将$\beta_2$带入$v_t$计算公式可以得到$v_t \approx g_t^2$,此时$C$由于学习率的调整,实际梯度被缩小了约$g_t=C$倍,因此梯度$C$的影响被大大缩小。梯度为$C$带来的参数往正确方向的移动远远无法消除两个梯度为$-1$带来的参数往反方向的移动,这最终导致了Adam将$\theta$收敛到了一个最差的点 $\theta=1$。

这个例子也给了我们在实际使用Adam时使用较大的$\beta_2$的一个直观解释。

大家可能会想实际使用时,我们$\beta_2$显然不会取那么小的值,因此不会遇到这个问题。在此例子后,文中给出了一个定理,该定理说明只要超参数$\beta_1, \beta_2$满足$\beta_1 < \sqrt{\beta_2}, (\beta_{1,2} \in[0, 1))$,就可以举出一个Adam无法收敛到最优解的例子。满足此条件的超参数在实际中使用还是比较常见的。

论文附录有超超级超超超超级长证明,感兴趣的可以去看看。

AMSGrad

AMSGrad的设计目标是在保持Adam/RMSProp等优化器算法优点的同时可以保证良好的收敛性。

首先,引入如下变量:

$$ \Gamma_t = \left( \frac{\sqrt{V_{t+1}}}{\alpha_{t+1}} - \frac{\sqrt{V_{t}}}{\alpha_{t}} \right) $$

该变量反映了学习率倒数的变化。对于SGD来说,$\Gamma_t = \frac{1}{\alpha}(\sqrt{t+1} - \sqrt{t}) \gt 0$,显然对于AdaGrad算法来说$\Gamma_t \gt 0$,也就是SGD/AdaGrad中学习率是非增的。而对于Adam/RMSProp来说,$\Gamma_t$是可能小于零的,这在理论上就给Adam带来了问题(在Adam论文中的收敛性证明,是假设$\Gamma_t$为非负的)。

AMSGrad为了满足$\Gamma_t \ge 0$,将算法调整如下:

算法2: AMSGrad:

算法输入

  • $\theta_1$:初始参数
  • $\{ \alpha_t \}_{t=1}^T$: 第$t$步学习率的初始值
  • $\{ \beta_{1t} \}_{t=1}^T$: 第$t$步$\beta_1$值
  • $\beta_2$
  • 设置初始值: $m_0=0, v_0=0, \hat{v}_0=0$

算法本体

$$ \begin{align*} \bf{for}& \ t=1\ \bf{to}\ \it{T}\ \bf{do}\\ & g_t = \nabla f_t(\theta_t) \tag 1\\ & m_t = \beta_{1t}m_{t-1} + (1-\beta_{1t})g_t \tag 2\\ & v_t = \beta_2 v_{t-1} + (1-\beta_2)g_t^2 \tag 3\\ & \hat{v}_t = max(\hat{v}_{t-1}, v_t) \tag 4\\ & \theta_{t+1} = \theta_t - \alpha_tm_t/\sqrt{\hat{v}_t} \tag 5\\ \bf{en}&\bf{dfor} \end{align*} $$

AMSGrad和Adam的核心区别是 AMSGrad 算法中的第 (4) 步,也就是$v_t$维持了历史最大值。增加了这个步骤后,就可以保AMSGrad有一个非增的学习率。另外一个区别就是AMSGrad中的使用了$\beta_{1t}$,在证明AMSGrad的收敛性的时候,需要$\beta_{1t}$逐渐减小,但在实际使用的时候可以使用一个常量的$\beta_1$。

AMSGrad 可以保证其regret指标$R_T$比SGD的$O(\sqrt{dT})$好很多(在一定合理的条件下)。当取$\beta_{1t} = \beta_1/t$时,$R_{T}^{AMSGrad} = O(\sqrt{T})$,从此上界来看,AMSGrad理论上要比SGD的收敛速度快非常多。

根据$R_t$的上界,对于AMSGrad显然有$\lim_{T\to \infty} \frac{R_T}{T} = 0$,及可收敛到最优解。

延伸算法:ADAMNC

在不改变Adam算法结构的前提下,可以根据训练步数来调整$\beta_1, \beta_2$来保证$\Gamma_t \ge 0$。此时不再使用常量$\beta_1, \beta_2$,而改为使用变量$\beta_{1t}, \beta_{2t}$。算法如下:

$$ \begin{align*} \bf{for}& \ t=1\ \bf{to}\ \it{T}\ \bf{do}\\ & g_t = \nabla f_t(\theta_t) \tag 1\\ & m_t = \beta_{1t}m_{t-1} + (1-\beta_{1t})g_t \tag 2\\ & v_t = \beta_{2t} v_{t-1} + (1-\beta_{2t})g_t^2 \tag 3\\ & \theta_{t+1} = \theta_t - \alpha_tm_t/\sqrt{v_t} \tag 4\\ \bf{en}&\bf{dfor} \end{align*} $$

上述算法与Adam的形式上一致。在选用合适的$\beta_{1t}, \beta_{2t}$的情况下,可以保证$\Gamma_t \ge 0$,论文中给出了一个复杂的条件,大家随便看看就好。

实验对比

MNIST 数据集

实验中Adam和AMSGrad中使用的参数:

  • $\alpha_t = \alpha/\sqrt{t}$
  • batch size: 128
  • $\beta_1 = 0.9$
  • $\beta_2$从0.99/0.999中选择
  • $\alpha, \beta_2$的选择使用网格搜索确定

性能对比图图下图所示:

Adam和AMSGrad对比-MNIST数据集

可以看出AMSGrad的收敛性比较好。

CIFAR-10数据集

设定与之前实验相似,实验结果如下:

Adam和AMSGrad对比-CIFAR数据集

可以看到AMSGrad的优势还是比较明显的。

补充说明

论文中给出的Adam的反例没有说服力,实际上同样可以举出让SGD无法收敛到一个最优解的例子:

$$ f_t(\theta) = \begin{cases} -\theta, & \text{如果 t % 2 == 1}\\ -\frac{1}{2}\theta^2, & \text{否则} \end{cases} $$

其中$\theta \in [-a, 1], a\in[1, \sqrt{2})$。最优解为$\theta=1$,而如果我们使用SGD算法去训练,设置初始参数$\theta_0 \le -1$时,SGD会收敛到$\theta=-a$。

此部分说明摘自[3]最后的Critique小节,大家可自行验证此例正确性

引用

[1] Reddi, Sashank J., Satyen Kale, and Sanjiv Kumar. "On the convergence of adam and beyond." arXiv preprint arXiv:1904.09237 (2019).

[2] An overview of gradient descent optimization algorithms, https://ruder.io/optimizing-gradient-descent/index.html

[3] Blog