深度学习中常用的优化算法(SGD, Nesterov,Adagrad,RMSProp,Adam)总结

本是古典何须时尚 2023-05-30 12:00 24阅读 0赞

# 深度学习中常用的优化算法(SGD, Nesterov,Adagrad,RMSProp,Adam)总结 #

## 1. 引言 ##

在深度学习中我们定义了损失函数以后，会采取各种各样的方法来降低损失函数的数值，从而使模型参数不断的逼近于真实数据的表达。不过损失函数的数值只是我们用来优化模型中参数的一个参考量，我们是通过优化损失函数来间接地优化模型参数，并提高模型的度量指标。而优化算法的作用就是加快模型的收敛，取得最优值。

优化算法可以分为两大类，一类是基于 Momentum 的优化算法， 另一类是自适应的优化算法。

#### 基于 Momentum 的优化算法 ####

*  SGD
 *  SGD + Mementum
 *  Nesterov

#### 自适应的优化算法 ####

*  Adagrad
 *  RMSProp
 *  Adam

## 2. Momentum Based ##

### 2.1 SGD ###

SGD (stochastic gradient descent) 随机梯度下降。随机梯度下降系列可以分为

*  SGD
 *  full-batch SGD
 *  mini-batch SGD
 *  mini-batch SGD + Momentum

值得注意的是，通常我们在说随机梯度下降算法的时候， 实际上都是说的 mini-batch SGD + Momentum， 因为它运用的最多。

SGD 是每次随机选择一个数据，喂给模型，然后更新参数。显然这种方式的缺点是由于每次喂入的数据量太少，模型学不到什么东西。

显然 full-batch SGD 是另一个极端， 上面的 SGD 是一条数据一条数据的喂，而 full-batch SGD 则是每一次迭代都将所有数据都喂进去，显然这将是非常大的计算量。所以现实中常常采用的是 mini-batch SGD， 其从训练集中少量采样一些数据拿来计算。这里有一个问题是为什么可以用 mini-batch 来替代 full-batch？

*  第一，n个样本的均值的标准差是  σ n \\frac\{\\sigma\} \{\\sqrt\{n\}\} nσ ，其中  σ \\sigma σ 是样本值真实的标准差。分母  n \\sqrt\{n\} n 说明样本数量的贡献是低于线性的，可以算一下，我们用100个样本和用10000个样本来计算均值标准差，多用了100倍的数据，却只降低了10倍的标准差。如果能够迅速求出估计值，而不是缓慢计算准确值，会加快算法的收敛速度。
 *  第二，训练集中经常会存在冗余的情况，完全有可能出现相同数据，如果重复了  m m m 次，那么用小批量算法就可以少花  m m m 倍的时间。

mini-batch SGD 的过程大致如下：

<table> 
 <thead> 
 <tr> 
 <th align="left">mini-batch SGD</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">输入：学习率 ϵ k \epsilon_k ϵk ，初始参数 θ \theta θ</td> 
 </tr> 
 <tr> 
 <td align="left">while 未满足停止条件 do</td> 
 </tr> 
 <tr> 
 <td align="left">   从训练集中采集包含 m m m 个样本 { x ( 1 ) ， x ( 2 ) ， . . . ， x ( m ) } \{x^{(1)}，x^{(2)}，...，x^{(m)}\} { x(1)，x(2)，...，x(m)} 的小批量，其中数据 x i {x^{i}} xi 和对应目标 y ( i ) y^{(i)} y(i)</td> 
 </tr> 
 <tr> 
 <td align="left">   计算梯度估计： ∇ θ k − 1 J ( θ k − 1 ) ← 1 m ∇ θ k − 1 L ( f ( x ( i ) , θ k − 1 ) , y ( i ) ) \nabla_{\theta_{k-1}} J(\theta_{k-1}) \leftarrow\frac{1}{m}\nabla_{\theta_{k-1}} L(f(x^{(i)}, \theta_{k-1}),y^{(i)}) ∇θk−1J(θk−1)←m1∇θk−1L(f(x(i),θk−1),y(i))</td> 
 </tr> 
 <tr> 
 <td align="left">   更新参数： θ k ← θ k − 1 − ϵ k ∇ θ k − 1 J ( θ k − 1 ) \theta_k \leftarrow\theta_{k-1}-\epsilon_k\nabla_{\theta_{k-1}} J(\theta_{k-1}) θk←θk−1−ϵk∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">end while</td> 
 </tr> 
 </tbody> 
</table>

上面的学习率  ϵ \\epsilon ϵ 是需要学习的超参数。因为仅仅用一个 case 或者一个小的 batch 的 case 来计算梯度，所以仅仅是对训练数据集梯度的一个估计。

总的来说上面的三种 SGD 算法所面临的问题是

*  Zigzag
 *  容易陷入 local optimize

针对上面问题，SGD + Momentum 被提了出来，SGD + Momentum 主要有了以下提升:

*  缓解 Zigzag
 *  比 SGD， 对于局部最优有改善

首先对比下单纯的 SGD 和 SGD + Momentum 的更新方式的区别。

<table> 
 <thead> 
 <tr> 
 <th align="left">名字</th> 
 <th align="left">更新方式</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">单纯 SGD：</td> 
 <td align="left"> θ ← θ − ϵ ∇ θ J ( θ ) \theta \leftarrow\theta-\epsilon \nabla_\theta J(\theta) θ←θ−ϵ∇θJ(θ)</td> 
 </tr> 
 <tr> 
 <td align="left">SGD + Momentum：</td> 
 <td align="left"> v t ← α v t − 1 − ϵ ∇ θ J ( θ ) v_t \leftarrow\alpha v_{t-1}-\epsilon \nabla_\theta J(\theta) vt←αvt−1−ϵ∇θJ(θ); θ ← θ + v t \theta \leftarrow\theta+v_t θ←θ+vt</td> 
 </tr> 
 </tbody> 
</table>

上面的  v v v 我们称为速度， α \\alpha α 是动量参数，  ∇ θ J ( θ ) \\nabla\_\\theta J(\\theta) ∇θJ(θ) 是当前轮次计算得到的梯度。

从公式可以看出，  v v v 会记录上一次的梯度信息，通过动量参数  α \\alpha α 来控制上一次的更新量对本次更新量的影响，注意它是一个非负项，所以它起到了“惯性”的作用。

*  下降初期时，引入上一次参数更新，使得下降方向趋近于上次的方向，乘上较大的  α \\alpha α 能够进行很好的加速
 *  下降中后期时，在局部最小值来回震荡的时候，也就是  ∇ θ J ( θ ) → 0 \\nabla\_\\theta J(\\theta)\\rightarrow0 ∇θJ(θ)→0， α \\alpha α 使得更新幅度增大，跳出局部最优
 *  在梯度改变方向的时候，momentum 能够减少更新，从而缓解 Zigzag 问题。

<table> 
 <thead> 
 <tr> 
 <th align="left">SGD + Momentum</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">输入：学习率 ϵ k \epsilon_k ϵk ，初始参数 θ \theta θ，动量参数 α \alpha α ，初始速度 v v v</td> 
 </tr> 
 <tr> 
 <td align="left">while 未满足停止条件 do</td> 
 </tr> 
 <tr> 
 <td align="left">   从训练集中采集包含 m m m 个样本 { x ( 1 ) ， x ( 2 ) ， . . . ， x ( m ) } \{x^{(1)}，x^{(2)}，...，x^{(m)}\} { x(1)，x(2)，...，x(m)} 的小批量，其中数据 x i {x^{i}} xi 和对应目标 y ( i ) y^{(i)} y(i)</td> 
 </tr> 
 <tr> 
 <td align="left">   计算梯度估计： ∇ θ k − 1 J ( θ k − 1 ) ← 1 m ∇ θ k − 1 L ( f ( x ( i ) , θ k − 1 ) , y ( i ) ) \nabla_{\theta_{k-1}} J(\theta_{k-1}) \leftarrow\frac{1}{m}\nabla_{\theta_{k-1}} L(f(x^{(i)}, \theta_{k-1}),y^{(i)}) ∇θk−1J(θk−1)←m1∇θk−1L(f(x(i),θk−1),y(i))</td> 
 </tr> 
 <tr> 
 <td align="left">   更新速度： v k ← α v k − 1 − ϵ k ∇ θ k − 1 J ( θ k − 1 ) v_k \leftarrow \alpha v_{k-1}-\epsilon_k\nabla_{\theta_{k-1}} J(\theta_{k-1}) vk←αvk−1−ϵk∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">   更新参数： θ k ← θ k − 1 + v k \theta_k \leftarrow\theta_{k-1} + v_k θk←θk−1+vk</td> 
 </tr> 
 <tr> 
 <td align="left">end while</td> 
 </tr> 
 </tbody> 
</table>

其中：

v k = α v k − 1 − ϵ k ( 1 − α ) ∇ θ k − 1 J ( θ k − 1 ) = α v k − 1 − ϵ k ∇ θ k − 1 J ( θ k − 1 ) v\_k = \\alpha v\_\{k-1\}-\\epsilon\_k(1-\\alpha)\\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) = \\alpha v\_\{k-1\}-\\epsilon\_k\\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) vk=αvk−1−ϵk(1−α)∇θk−1J(θk−1)=αvk−1−ϵk∇θk−1J(θk−1)  
上面的学习率  ϵ \\epsilon ϵ 和  α \\alpha α 是需要学习的超参数。

### 2.2 Nesterov ###

Nesterov 首先（试探性地）在之前积累的梯度方向（棕色向量）前进一大步，再根据当前地情况修正，以得到最终的前进方向（绿色向量）。这种基于预测的更新方法，使我们避免过快地前进，并提高了算法地响应能力。  
![在这里插入图片描述][20191110151040650.png]

具体来说，Nesterov 是先基于当前的参数和 momentum，预测得到一个新的参数  θ ~ \\tilde\{\\theta\} θ~ ，然后基于这个新的参数来计算梯度。其数学表达式如下：

θ ~ = θ k − 1 + α v k − 1 \\tilde\{\\theta\} = \\theta\_\{k-1\} + \\alpha v\_\{k-1\} θ~=θk−1\+αvk−1  
 v k = α v k − 1 − ϵ k ∇ θ k − 1 J ( θ ~ ) v\_k = \\alpha v\_\{k-1\}-\\epsilon\_k\\nabla\_\{\\theta\_\{k-1\}\} J(\\tilde\{\\theta\}) vk=αvk−1−ϵk∇θk−1J(θ~)  
 θ k = θ k − 1 + v k \\theta\_k = \\theta\_\{k-1\} + v\_k θk=θk−1\+vk

本来 Nesterov 通过预测的方式可以起到加速收敛的作用，但是上面的公式在实际使用中却比较烦琐，因此对上面的公式进行了修改，使得在实际使用中比较简洁。修改后的公式如下：

v k = α v k − 1 − ϵ k ∇ θ k − 1 J ( θ k − 1 ) v\_k = \\alpha v\_\{k-1\}-\\epsilon\_k\\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) vk=αvk−1−ϵk∇θk−1J(θk−1)  
 θ k = θ k − 1 + v k − α J ( θ k − 1 ) \\theta\_k = \\theta\_\{k-1\} + v\_k - \\alpha J(\\theta\_\{k-1\}) θk=θk−1\+vk−αJ(θk−1)  
上面已经说了为什么要做这个修改，还有一个问题是为什么能这样修改？其实通过简单的迭代计算可以发现两种表达方式是等价的。

<table> 
 <thead> 
 <tr> 
 <th align="left">Nesterov</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">输入：学习率 ϵ k \epsilon_k ϵk ，初始参数 θ \theta θ，动量参数 α \alpha α ，初始速度 v v v</td> 
 </tr> 
 <tr> 
 <td align="left">while 未满足停止条件 do</td> 
 </tr> 
 <tr> 
 <td align="left">   从训练集中采集包含 m m m 个样本 { x ( 1 ) ， x ( 2 ) ， . . . ， x ( m ) } \{x^{(1)}，x^{(2)}，...，x^{(m)}\} { x(1)，x(2)，...，x(m)} 的小批量，其中数据 x i {x^{i}} xi 和对应目标 y ( i ) y^{(i)} y(i)</td> 
 </tr> 
 <tr> 
 <td align="left">  计算预测参数： θ ~ = θ k − 1 + α v k − 1 \tilde{\theta} = \theta_{k-1} + \alpha v_{k-1} θ~=θk−1+αvk−1</td> 
 </tr> 
 <tr> 
 <td align="left">   计算梯度估计： ∇ θ k − 1 J ( θ k − 1 ) ← 1 m ∇ θ k − 1 L ( f ( x ( i ) , θ ~ ) , y ( i ) ) \nabla_{\theta_{k-1}} J(\theta_{k-1}) \leftarrow\frac{1}{m}\nabla_{\theta_{k-1}} L(f(x^{(i)}, \tilde{\theta}),y^{(i)}) ∇θk−1J(θk−1)←m1∇θk−1L(f(x(i),θ~),y(i))</td> 
 </tr> 
 <tr> 
 <td align="left">   更新速度： v k ← α v k − 1 − ϵ k ∇ θ k − 1 J ( θ k − 1 ) v_k \leftarrow \alpha v_{k-1}-\epsilon_k\nabla_{\theta_{k-1}} J(\theta_{k-1}) vk←αvk−1−ϵk∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">   更新参数： θ k ← θ k − 1 + α v k − ϵ k ∇ θ k − 1 J ( θ k − 1 ) \theta_k \leftarrow\theta_{k-1} + \alpha v_k - \epsilon_{k}\nabla_{\theta_{k-1}} J(\theta_{k-1}) θk←θk−1+αvk−ϵk∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">end while</td> 
 </tr> 
 </tbody> 
</table>

## 3 Adaptive Methods ##

学习率作为一个超参数，就会有调参的困扰，这是工业界公认的事情。动量算法只能在一定程度上缓解调参的压力，但代价是又多引入了一个超参数。而下面讲的方法都是学习率自适应的优化方式，比如对不同的 feature 有不同的 learning rate。

### 3.1 Adagrad ###

Adagrad算法是一个比较新的优化算法，由 John Duchi 等人在 2011 年于 [Adaptive Subgradient Methods for  
Online Learning and Stochastic Optimization][Adaptive Subgradient Methods for Online Learning and Stochastic Optimization] 提出。 这种优化算法的优点是对不同的参数调整学习率，具体而言，对梯度比较小参数进行大的更新，对梯度比较大的参数进行小的更新。

先来看看它的数学表达式。

r k = r k − 1 + ∇ θ k − 1 J ( θ k − 1 ) ⨀ ∇ θ k − 1 J ( θ k − 1 ) r\_\{k\} = r\_\{k-1\} + \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) \\bigodot \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) rk=rk−1\+∇θk−1J(θk−1)⨀∇θk−1J(θk−1)  
 θ k = θ t − 1 − ϵ r k + σ ⨀ ∇ θ k − 1 J ( θ k − 1 ) \\theta\_k = \\theta\_\{t-1\} - \\frac\{\\epsilon\}\{\\sqrt\{r\_k + \\sigma\}\} \\bigodot \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) θk=θt−1−rk\+σϵ⨀∇θk−1J(θk−1)  
其中  ⨀ \\bigodot ⨀ 表示矩阵按位相乘，上面的式子也可以理解为平方。具体的计算过程如下表。

<table> 
 <thead> 
 <tr> 
 <th align="left">Adagrad</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">输入：全局学习率 ϵ \epsilon ϵ ，初始参数 θ \theta θ，小常数 σ \sigma σ（一般取值为 1 0 − 7 10^{-7} 10−7） ，初始化梯度累计量 r = 0 r = 0 r=0</td> 
 </tr> 
 <tr> 
 <td align="left">while 未满足停止条件 do</td> 
 </tr> 
 <tr> 
 <td align="left">   从训练集中采集包含 m m m 个样本 { x ( 1 ) ， x ( 2 ) ， . . . ， x ( m ) } \{x^{(1)}，x^{(2)}，...，x^{(m)}\} { x(1)，x(2)，...，x(m)} 的小批量，其中数据 x i {x^{i}} xi 和对应目标 y ( i ) y^{(i)} y(i)</td> 
 </tr> 
 <tr> 
 <td align="left">   计算梯度估计： ∇ θ k − 1 J ( θ k − 1 ) ← 1 m ∇ θ k − 1 L ( f ( x ( i ) , θ k − 1 ) , y ( i ) ) \nabla_{\theta_{k-1}} J(\theta_{k-1}) \leftarrow\frac{1}{m}\nabla_{\theta_{k-1}} L(f(x^{(i)}, \theta_{k-1}),y^{(i)}) ∇θk−1J(θk−1)←m1∇θk−1L(f(x(i),θk−1),y(i))</td> 
 </tr> 
 <tr> 
 <td align="left">   累积平方梯度： r k ← r k − 1 + ∇ θ k − 1 J ( θ k − 1 ) ⨀ ∇ θ k − 1 J ( θ k − 1 ) r_k \leftarrow r_{k-1}+\nabla_{\theta_{k-1}} J(\theta_{k-1}) \bigodot \nabla_{\theta_{k-1}} J(\theta_{k-1}) rk←rk−1+∇θk−1J(θk−1)⨀∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">   计算参数更新量： Δ θ ← − ϵ r k + σ ⨀ Δ θ k − 1 J ( θ k − 1 ) \Delta \theta \leftarrow- \frac{\epsilon}{\sqrt{r_k + \sigma}} \bigodot \Delta_{\theta_{k-1}} J(\theta_{k-1}) Δθ←−rk+σ ϵ⨀Δθk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">   更新参数： θ k ← θ k − 1 + ∇ θ \theta_k \leftarrow\theta_{k-1} + \nabla \theta θk←θk−1+∇θ</td> 
 </tr> 
 <tr> 
 <td align="left">end while</td> 
 </tr> 
 </tbody> 
</table>

从公式我们可以看出， r r r 会一直积累，越来越大，就会导致上面参数更新量的公式的分母部分越来越大，那么更新量会越来越小，最后趋近于零。所以在实际使用中 Adagrad 应用的比较少，但是 Adagrad 的思想却是开创了新的时代。

### 3.2 RMSProp ###

RMSProp 是 Hinton 大神于 2012 年在一门叫 [Neural Networks for Machine Learning][] 的在线课程中提出（并未正式发表，要不怎么叫大神呢）。  
RMSProp 实际上是 Adagrad + Momentum。它的数学表达式如下。

r k = β r k − 1 + ( 1 − β ) ∇ θ k − 1 J ( θ k − 1 ) ⨀ ∇ θ k − 1 J ( θ k − 1 ) r\_\{k\} = \\beta r\_\{k-1\} + (1-\\beta)\\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) \\bigodot \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) rk=βrk−1\+(1−β)∇θk−1J(θk−1)⨀∇θk−1J(θk−1)  
 θ k = θ t − 1 − ϵ r k + σ ⨀ ∇ θ k − 1 J ( θ k − 1 ) \\theta\_k = \\theta\_\{t-1\} - \\frac\{\\epsilon\}\{\\sqrt\{r\_k + \\sigma\}\} \\bigodot \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) θk=θt−1−rk\+σϵ⨀∇θk−1J(θk−1)

由于RMSProp的计算过程和 Adagrad 的相似，这里就不再赘述了。  
RMSProp 运用的并是很多，主要在 WGAN，MobileNet 中比较常见。

### 3.3 Adadelta ###

前面提到 Adagrad 的学习率是单调递减的，而 Adadelta 的提出就是为了解决这个问题。另外 Adadelta 不再依赖全局学习率 [ADADELTA: AN ADAPTIVE LEARNING RATE METHOD][ADADELTA_ AN ADAPTIVE LEARNING RATE METHOD]。

Adagrad会累加之前所有的梯度平方，而Adadelta只累加固定大小的项，并且也不直接存储这些项，仅仅是近似计算对应的平均值。其计算过程如下。

<table> 
 <thead> 
 <tr> 
 <th align="left">Adadelta</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">输入：初始参数 θ \theta θ，小常数 σ \sigma σ ，初始化梯度累计量 E [ g 2 ] 0 = 0 , E [ ∇ θ 2 ] 0 = 0 E[g^2]_0=0, E[\nabla\theta^2]_0=0 E[g2]0=0,E[∇θ2]0=0</td> 
 </tr> 
 <tr> 
 <td align="left">while 未满足停止条件 do</td> 
 </tr> 
 <tr> 
 <td align="left">   从训练集中采集包含 m m m 个样本 { x ( 1 ) ， x ( 2 ) ， . . . ， x ( m ) } \{x^{(1)}，x^{(2)}，...，x^{(m)}\} { x(1)，x(2)，...，x(m)} 的小批量，其中数据 x i {x^{i}} xi 和对应目标 y ( i ) y^{(i)} y(i)</td> 
 </tr> 
 <tr> 
 <td align="left">   计算梯度估计： g k = ∇ θ k − 1 J ( θ k − 1 ) ← 1 m ∇ θ k − 1 L ( f ( x ( i ) , θ k − 1 ) , y ( i ) ) g_{k} = \nabla_{\theta_{k-1}} J(\theta_{k-1}) \leftarrow\frac{1}{m}\nabla_{\theta_{k-1}} L(f(x^{(i)}, \theta_{k-1}),y^{(i)}) gk=∇θk−1J(θk−1)←m1∇θk−1L(f(x(i),θk−1),y(i))</td> 
 </tr> 
 <tr> 
 <td align="left">   累积平方梯度期望： E [ g 2 ] k ← ρ E [ g 2 ] k + ( 1 − ρ ) g k 2 E[g^2]_k \leftarrow \rho E[g^2]_k+(1-\rho)g_{k}^{2} E[g2]k←ρE[g2]k+(1−ρ)gk2</td> 
 </tr> 
 <tr> 
 <td align="left">   计算参数更新量： Δ θ ← − E [ Δ θ 2 ] k − 1 + σ E [ g 2 ] k + σ ∇ θ k − 1 J ( θ k − 1 ) \Delta \theta \leftarrow- \frac{\sqrt{E[\Delta \theta^2]_{k-1}+\sigma}}{\sqrt{E[g^2]_k + \sigma}} \nabla_{\theta_{k-1}} J(\theta_{k-1}) Δθ←−E[g2]k+σ E[Δθ2]k−1+σ ∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">   缓存累积更新： E [ Δ θ 2 ] k ← ρ E [ Δ θ 2 ] k − 1 + ( 1 − ρ ) Δ θ 2 E[\Delta \theta^2]_{k} \leftarrow \rho E[\Delta \theta^2]_{k-1} + (1 - \rho)\Delta \theta^2 E[Δθ2]k←ρE[Δθ2]k−1+(1−ρ)Δθ2</td> 
 </tr> 
 <tr> 
 <td align="left">   更新参数： θ k ← θ k − 1 + Δ θ \theta_k \leftarrow\theta_{k-1} + \Delta \theta θk←θk−1+Δθ</td> 
 </tr> 
 <tr> 
 <td align="left">end while</td> 
 </tr> 
 </tbody> 
</table>

### 3.4 Adam ###

Adam 是 Diederik P. Kingma 等人在 2014 年于 [Adam: A Method for Stochastic Optimization][Adam_ A Method for Stochastic Optimization] 中提出的优化算法。Adam 是目前运用的比较广泛的一种优化算法。另外 Adam 也有多种改进版本，比如 AdaMax， Nadam等。Adam 的优点主要有：

*  收敛快，少调参，但是需要注意的是它的效果有时候不如 SGD + Momentum。
 *  结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点
 *  对内存需求较小
 *  为不同的参数计算不同的自适应学习率
 *  也适用于大多非凸优化
 *  适用于大数据集和高维空间

Adam 利用梯度的一阶矩估计和二阶矩估计动态调整每个参数的学习率，使学习率在每一次更新的时候都有一个固定范围的步长，让参数更新时保持稳定。其计算公式如下：

m t = β 1 m t − 1 + ( 1 − β 1 ) ∇ θ k − 1 J ( θ k − 1 ) m\_t = \\beta\_1 m\_\{t-1\} + (1-\\beta\_1) \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) mt=β1mt−1\+(1−β1)∇θk−1J(θk−1)  
 v θ t = β 2 v θ t − 1 + ( 1 − β 2 ) ∇ θ k − 1 J ( θ k − 1 ) ⊙ ∇ θ k − 1 J ( θ k − 1 ) v\_\{\\theta\_t\} = \\beta\_2 v\_\{\\theta\_\{t-1\}\} + (1-\\beta\_2) \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) \\odot \\nabla\_\{\\theta\_\{k-1\}\} J(\\theta\_\{k-1\}) vθt=β2vθt−1\+(1−β2)∇θk−1J(θk−1)⊙∇θk−1J(θk−1)  
 m t ^ = m t 1 − β 1 t \\hat\{m\_t\} = \\frac \{m\_t\} \{1- \\beta\_\{1\}^\{t\}\} mt^=1−β1tmt  
 v θ t ^ = v θ t 1 − β 2 t \\hat\{v\_\{\\theta\_t\}\} = \\frac \{v\_\{\\theta\_t\}\} \{1- \\beta\_\{2\}^\{t\}\} vθt^=1−β2tvθt  
 θ t = θ t − 1 − m t ^ v θ t ^ + σ ϵ \\theta\_t = \\theta\_\{t-1\} - \\frac \{\\hat\{m\_t\}\}\{\\sqrt\{\\hat\{v\_\{\\theta\_t\}\}+\\sigma\}\} \\epsilon θt=θt−1−vθt^\+σmt^ϵ  
其中一般的  β 1 = 0.9 \\beta\_1 = 0.9 β1=0.9， β 2 = 0.999 \\beta\_2 = 0.999 β2=0.999,  ϵ = 0.001 \\epsilon = 0.001 ϵ=0.001,  σ = 1 0 − 7 \\sigma = 10^\{-7\} σ=10−7。从公式可以看出，因为  1 − β t 1-\\beta^t 1−βt 是一个小于 1 的值，刚开始时 t 很小， 1 − β t 1-\\beta^t 1−βt 的取值也很小，这样一阶矩估计和二阶矩估计更新的幅度会比较大， 但是当 t 较大时， 1 − β t 1-\\beta^t 1−βt 将会趋近于 1 ，一阶矩估计和二阶矩估计开始趋于稳定。

其具体的计算过程如下。

<table> 
 <thead> 
 <tr> 
 <th align="left">Adam</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">输入：全局学习率 ϵ \epsilon ϵ，初始参数 θ \theta θ，小常数 σ \sigma σ ，矩估计的指数衰减率 β 1 , β 2 \beta_1, \beta_2 β1,β2，初始化一阶和二阶矩变量 m = 0 , v = 0 m=0, v=0 m=0,v=0，初始化时间步长 t = 0 t=0 t=0。</td> 
 </tr> 
 <tr> 
 <td align="left">while 未满足停止条件 do</td> 
 </tr> 
 <tr> 
 <td align="left">   从训练集中采集包含 m m m 个样本 { x ( 1 ) ， x ( 2 ) ， . . . ， x ( m ) } \{x^{(1)}，x^{(2)}，...，x^{(m)}\} { x(1)，x(2)，...，x(m)} 的小批量，其中数据 x i {x^{i}} xi 和对应目标 y ( i ) y^{(i)} y(i)</td> 
 </tr> 
 <tr> 
 <td align="left">   计算梯度估计： ∇ θ k − 1 J ( θ k − 1 ) ← 1 m ∇ θ k − 1 L ( f ( x ( i ) , θ k − 1 ) , y ( i ) ) \nabla_{\theta_{k-1}} J(\theta_{k-1}) \leftarrow\frac{1}{m}\nabla_{\theta_{k-1}} L(f(x^{(i)}, \theta_{k-1}),y^{(i)}) ∇θk−1J(θk−1)←m1∇θk−1L(f(x(i),θk−1),y(i))</td> 
 </tr> 
 <tr> 
 <td align="left">   t ← t + 1 t \leftarrow t+1 t←t+1</td> 
 </tr> 
 <tr> 
 <td align="left">   更新有偏一阶矩估计： m t = β 1 m t − 1 + ( 1 − β 1 ) ∇ θ k − 1 J ( θ k − 1 ) m_t = \beta_1 m_{t-1} + (1-\beta_1) \nabla_{\theta_{k-1}} J(\theta_{k-1}) mt=β1mt−1+(1−β1)∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">   更新有偏二阶矩估计： v θ t = β 2 v θ t − 1 + ( 1 − β 2 ) ∇ θ k − 1 J ( θ k − 1 ) ⊙ ∇ θ k − 1 J ( θ k − 1 ) v_{\theta_t} = \beta_2 v_{\theta_{t-1}} + (1-\beta_2) \nabla_{\theta_{k-1}} J(\theta_{k-1}) \odot \nabla_{\theta_{k-1}} J(\theta_{k-1}) vθt=β2vθt−1+(1−β2)∇θk−1J(θk−1)⊙∇θk−1J(θk−1)</td> 
 </tr> 
 <tr> 
 <td align="left">   修正一阶矩的偏差： m t ^ = m t 1 − β 1 t \hat{m_t} = \frac {m_t} {1- \beta_{1}^{t}} mt^=1−β1tmt</td> 
 </tr> 
 <tr> 
 <td align="left">   修正二阶矩的偏差： v θ t ^ = v θ t 1 − β 2 t \hat{v_{\theta_t}} = \frac {v_{\theta_t}} {1- \beta_{2}^{t}} vθt^=1−β2tvθt</td> 
 </tr> 
 <tr> 
 <td align="left">   计算参数更新量： Δ θ ← − m t ^ v θ t ^ + σ ϵ \Delta \theta \leftarrow- \frac {\hat{m_t}}{\sqrt{\hat{v_{\theta_t}}+\sigma}}\epsilon Δθ←−vθt^+σ mt^ϵ</td> 
 </tr> 
 <tr> 
 <td align="left">   更新参数： θ t ← θ t − 1 + Δ θ \theta_t \leftarrow\theta_{t-1} + \Delta \theta θt←θt−1+Δθ</td> 
 </tr> 
 <tr> 
 <td align="left">end while</td> 
 </tr> 
 </tbody> 
</table>

值得一提的是，虽然 Adam 会自动调整学习率，但是实践证明，在训练的时候采用学习率衰减的策略依然有效。更多可以参考 [Adam和学习率衰减（learning rate decay）][Adam_learning rate decay] 。

前面我们提到了 Adam 收敛快，但是 momentum based 的方法精度更好，所以现在有一个发展趋势是一开始用 Adam ，提升速度，后期采用 momentum based 的方法，取得好的精度，但是仅仅是一个发展方向，还并没有提出较好的方法来融合这两中优化方法。

## 参考 ##

*  [深度学习里的一些优化算法][Link 1]
 *  [Stochastic gradient descent][]
 *  [深度学习总结(五)——各优化算法][Link 2]
 *  [深度学习最全优化方法总结比较（SGD，Adagrad，Adadelta，Adam，Adamax，Nadam）][SGD_Adagrad_Adadelta_Adam_Adamax_Nadam]
 *  [Neural Networks for Machine Learning][]

[20191110151040650.png]: https://img-blog.csdnimg.cn/20191110151040650.png
[Adaptive Subgradient Methods for Online Learning and Stochastic Optimization]: http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf
[Neural Networks for Machine Learning]: https://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf
[ADADELTA_ AN ADAPTIVE LEARNING RATE METHOD]: https://www.jianshu.com/p/2527f470f530
[Adam_ A Method for Stochastic Optimization]: https://arxiv.org/abs/1412.6980
[Adam_learning rate decay]: https://www.cnblogs.com/wuliytTaotao/p/11101652.html
[Link 1]: https://www.jianshu.com/p/33eed2e1d357
[Stochastic gradient descent]: https://en.wikipedia.org/wiki/Stochastic_gradient_descent
[Link 2]: https://blog.csdn.net/manong_wxd/article/details/78735439
[SGD_Adagrad_Adadelta_Adam_Adamax_Nadam]: https://blog.csdn.net/u012759136/article/details/52302426