梯度下降法（Gradient Descent）优化算法，越来越受欢迎，通常用作black-box优化器，但是实践证明他们的优点和缺点都很难克服。本文旨在提供不同算法的表现，主要是梯度下降法的变体，总结了解决问题的挑战，介绍了常见的优化算法，而且调查了优化梯度下降方法的策略。

梯度下降法是处理优化最受欢迎的算法，而且是目前优化神经网络常见的方法。同时，每个最新的深度学习包都包含了优化梯度下降的不同算法的实现（lasagne，caffe，Keras），这些算法通常作为black-box优化器。

本文主要对不同优化梯度下降的算法进行介绍：

section 2：了解梯度下降的不同变体；

section 3：总结训练时的挑战；

section 4：介绍最常见的优化算法和如何处理这些挑战及算法的流程，更新的规则；

section 5：并行和分布式的方法如何优化梯度下降法；

section 6：介绍优化梯度下降的其他策略。

梯度下降法最下化目标函数 J ( θ ) J(\theta) J(θ)，参数是 θ ∈ R d \theta \in {\Bbb R}^d θ∈Rd，通过目标函数 ∇ θ J ( θ ) {\nabla}_{\theta}J(\theta) ∇θ​J(θ)。学习速率 η \eta η决定到达（局部）最小值的步数，换句话说，在目标函数的图上，随着表面坡度一直下降，直到山谷。

有三种梯度下降法的变体，差别在于用多少数据来计算目标函数的梯度。根据数据的大小，在参数更新的准确率和进行更新所需的时间上进行trade-off。

Vanilla gradient descent 和 aka batch gradient descent计算关于整个数据集的参数 θ \theta θ的损失函数的梯度：

(1) θ = θ − η ⋅ ∇ θ J ( θ ) \theta = \theta-\eta\cdot{\nabla}_{\theta}J(\theta) \tag{1} θ=θ−η⋅∇θ​J(θ)(1)

一次更新就要计算整个数据集的梯度，batch gradient descent非常慢，而且当数据无法全部加载到内存时无法处理。批梯度下降法无法在线更新模型，比如如果有新的样本。

for i in range ( nb_epochs ):
    params_grad = evaluate_gradient ( loss_function , data , params )
    params = params - learning_rate * params_grad
    

对于预先定义好的迭代次数，首先计算整个数据集的损失函数的梯度向量params_grad，现在一些深度学习包提供了自动微分的算法计算梯度。根据梯度的方向计算参数，然后决定学习速率的大小。batch gradient descent在凸优化问题上可以收敛到全局最优，非凸问题可以收敛到局部最优。

Stochastic gradient descent (SGD)对每个训练样本 ( x ( i ) , y ( i ) ) (x^{(i)},y^{(i)}) (x(i),y(i))进行参数更新:
(2) θ = θ − η ⋅ ∇ θ J ( θ ; x ( i ) , y ( i ) ) \theta = \theta-\eta\cdot{\nabla}_{\theta}J(\theta;x^{(i)}, y^{(i)}) \tag{2} θ=θ−η⋅∇θ​J(θ;x(i),y(i))(2)

Batch gradient descent对于大数据集进行的多余的计算，因为在进行参数更新时，相似的样本也要重新计算。SGD通过更新一次计算一次处理这个问题。SGD通常比较快，而且可以处理在线问题，由于SGD频繁更新导致高方差，这就导致目标函数振荡严重，如图所示。

当batch gradient descent收敛到参数空间的最优点时，SGD的振荡却可以跳到新的可能局部最优点，另外，SGD的过度调整使最小点变得复杂。但是，当逐渐降低学习速率，SGD和batch gradient descent有相同的收敛方式，通常肯定会收敛到局部最优（non-convex）或全局最优（convex），代码只是在训练样本上添加一个循环，并且分别估计每个样本的梯度，代码如下：

for i in range ( nb_epochs ):
    np. random . shuffle ( data )
    for example in data :
    params_grad = evaluate_gradient ( loss_function , example , params )
    params = params - learning_rate * params_grad

Mini-batch gradient descent 有以上两个的优点，对一个mini-batch的 n n n个训练样本进行更新，公式如下：
(3) θ = θ − η ⋅ ∇ θ J ( θ ; x ( i : i + n ) , y ( i : i + n ) ) \theta=\theta-\eta\cdot{\nabla}_{\theta}J(\theta;x^{(i:i+n)}, y^{(i:i+n)}) \tag{3} θ=θ−η⋅∇θ​J(θ;x(i:i+n),y(i:i+n))(3)

这种方法，a）降低了参数更新的方差，可以获得更稳定的收敛；b）可以充分使用优化矩阵算法，和关于mini-batch的梯度的深度学习包相似。和大小在50-256之间的mini-batch相似，但不同的应用不同。mini-batch梯度下降法只是训练神经网络时的一种选择，使用mini-batch时使用SGD。
在代码中，不是循环训练样本，假设mini-batches=50

for i in range ( nb_epochs ):
    np. random . shuffle ( data )
    for batch in get_batches (data , batch_size =50):
    params_grad = evaluate_gradient ( loss_function , batch , params )
    params = params - learning_rate * params_grad

Vanilla mini-batch gradient descent不能保证很好的收敛，但提供了一些需要处理的挑战：

• 选择恰当的学习速率很难。小的学习速率导致慢的收敛速度，大的学习速率会阻碍收敛，导致损失函数在最小值附近动荡，甚至发散。
• Learning rate schedules通过退火算法调整学习速率，比如通过预先定义好的日程降低学习速率或是两个epoch之间的降低低于某个阈值。这些日程和阈值，必须先定义好并且无法根据数据的特性进行调整。
• 另外，所有的参数更新使用相同的学习速率。如果数据集是稀疏的，并且特征有不同的频率，我们可能不想使用相同的程度更新他们，但对于较少出现的特征更新更大。
• 最小化神经网络的高维非凸误差函数的主要挑战是如何避免陷入大量的局部最优点中。Dauphin et al认为导致困难的不是局部最优点而是鞍点，比如点的某一维斜率上升而另一维下降。这些鞍点通常由同一错误包围，SGD很难处理这些，因为每一维的梯度都接近零。

接下来介绍处理之前的挑战的算法，不介绍无法处理高维数据的算法，比如二阶方法，牛顿方法。

SGD有navigating ravines（沟壑），比如在表面曲线更陡的维度，而另一维不会，通常在局部最优点上。这种情况下，SGD在沟壑的陡峭处振荡，导致往低处的速度很慢。

Momentum在相关方向帮助SGD和降低动荡的危害。通过增加一个摩擦系数 γ \gamma γ来更新向量
v t = γ v t − 1 + η ∇ θ J ( θ ) v_t = {\gamma}v_{t-1}+ {\eta}{\nabla}_{\theta}J(\theta) vt​=γvt−1​+η∇θ​J(θ)
θ = θ − v t \theta=\theta-v_t θ=θ−vt​
momentum项 g a m m a gamma gamma通常设为0.9或相似的值。

使用momentum时，相当于在斜坡推一个球，这个球在往下滚时积累了momentum，变得越来越快（直到到达最终的速度）。参数更新也是相似的：momentum项在梯度相同的方向增加，在梯度改变方向时减少。因此，获得更快的收敛速度和降低振荡。

球在斜坡下滚时是没有目的的，我们需要一个更聪明的球，知道如何走。

Nesterov accelerated gradient (NAG)使momentum有这个认知。我们要把momentum项 γ v t − 1 {\gamma}v_{t-1} γvt−1​移到参数 θ \theta θ处，计算 θ − γ v t − 1 \theta-{\gamma}v_{t-1} θ−γvt−1​可得参数的下个大概位置，大体上我们的参数如何修改。现在我们可以有效计算梯度，不是关于当前的参数 θ \theta θ，而是参数未来的大概位置：
v t = γ v t − 1 + η ∇ θ J ( θ − γ v t − 1 ) v_t={\gamma}v_{t-1}+\eta\nabla_{\theta}J(\theta-{\gamma}v_{t-1}) vt​=γvt−1​+η∇θ​J(θ−γvt−1​)
θ = θ − v t \theta=\theta-v_t θ=θ−vt​

另外momentum项设置为 γ \gamma γ设置为0.9，第一个momentum计算当前的梯度，然后在更新了的积累梯度的方向上跳一大步，NAG在首先在之前积累的梯度上跳一步，测量梯度，然后获得正确的。这个预想更新可以防止更新太快，并且快反应，在RNNs的许多任务上提高了性能。

现在我们可以根据误差函数的斜率更新参数，并且加速SGD，而且可以根据每个参数进行更新，就是根据参数的重要性进行小的或大的更新。

Adagrad是基于梯度的算法，使学习速率的更新是根据参数的，出现频繁的参数更新小，不频繁的参数更新大。基于这个原因，处理稀疏数据比较好。Dean et al发现adagrad可以提高SGD的鲁棒性，并且用来训练大的神经网络，比如识别YouTube的猫的视频。另外，Pennington 使用Adagrad来训练GloVe词向量，因为频率少的词比其他词需要更大的更新系数。

之前，所有参数 θ \theta θ的更新使用相同的学习速率 η \eta η，Adagrad中，不同的参数 θ i \theta_i θi​使用不同的学习速率，在每个time step t t t，首先是adagrad的每个参数的更新，为了简化，假设 g ( t , i ) g_(t,i) g(​t,i)是关于参数 θ i \theta_i θi​在time step t t t时的目标函数的梯度：
g t , i = ∇ θ t J ( θ t , i ) g_{t, i}=\nabla_{\theta_t}J(\theta_{t, i}) gt,i​=∇θt​​J(θt,i​)

SGD在每个time step t t t上更新每个参数 θ i \theta_i θi​：
θ t + 1 , i = θ t , i − η ⋅ g t , i \theta_{t+1, i}=\theta_{t, i}-\eta{\cdot}g_{t, i} θt+1,i​=θt,i​−η⋅gt,i​

在更新规则中，adagrad在每个time step t t t修改每个参数 θ i \theta_i θi​的学习速率 η \eta η：
(8) θ t + 1 , i = θ t , i − η G ( t , i i ) + ε ⋅ g t , i \theta_{t+1, i}=\theta_{t, i}- \frac{\eta}{\sqrt{G_(t, ii)+\varepsilon}} \cdot g_{t, i} \tag{8} θt+1,i​=θt,i​−G(​t,ii)+ε ​η​⋅gt,i​(8)

G t ∈ R d × d G_t \in {\Bbb R}^{d \times d} Gt​∈Rd×d 是一个对角矩阵，每个对角元素 i , i i, i i,i，在time step t t t时，关于参数 θ i \theta_i θi​的梯度的平方和。 ε \varepsilon ε是平滑项，避免除数为零，通常是 ε = 1 e − 8 \varepsilon=1e-8 ε=1e−8。若是没有求根操作，算法的性能更差。

由于 G t G_t Gt​包含了关于所有参数 θ \theta θ的过去所有梯度的平方和，通过element-wise ⊙ \odot ⊙乘法向量化 G t G_t Gt​和 g t g_t gt​，即：
θ t + 1 = θ − η G t + ε ⊙ g t \theta_{t+1}=\theta-\frac{\eta}{\sqrt{G_t+\varepsilon}}\odot{g_t} θt+1​=θ−Gt​+ε ​η​⊙gt​

adagrad的一个好处是避免手工调整学习速率，默认值大多采用0.01。

adagrad的缺点是在分母积累梯度平方。这导致学习速率降低，最终变得无限小，这时算法无法再获得更多的知识。

adadelta是adagrad的扩展，避免学习速率不断单一下降，不要积累过去所有梯度的平方和，adadelta把过去积累梯度的个数都限制在 w w w内。

不是无效率地存储前 w w w个梯度的平方，梯度的和递归的定义为所有过去梯度的平方和的衰减平均值。每个time step t t t的平均 E [ g 2 ] t E{[g^2]}_t E[g2]t​取决于之前的平均和当前的梯度：
(10) E [ g 2 ] t = γ E [ g 2 ] t − 1 + ( 1 − γ ) g t 2 E{[g^2]}_t=\gamma E{[g^2]}_{t-1}+(1-\gamma)g^2_t \tag{10} E[g2]t​=γE[g2]t−1​+(1−γ)gt2​(10)

γ \gamma γ的设置和momentum相似，大概0.9。为了简化，在参数更新向量 Δ θ t \Delta \theta_t Δθt​重写vanilla SGD的更新，如下：
(11) Δ θ t = − η ⋅ g t , i θ t + 1 = θ t + Δ θ t \Delta \theta_t = -\eta\cdot g_{t, i} \\ \theta_{t+1} = \theta_t +\Delta\theta_t \tag{11} Δθt​=−η⋅gt,i​θt+1​=θt​+Δθt​(11)

adagrad的参数更新向量的形式如下：
Δ θ t = − η G t + ε ⊙ g t \Delta \theta_t=-\frac{\eta}{\sqrt{G_t+\varepsilon}}\odot g_t Δθt​=−Gt​+ε ​η​⊙gt​

现在把对角矩阵 G t G_t Gt​用衰减平均值替换，即过去梯度平方 E [ g 2 ] t E{[g^2]}_t E[g2]t​：
(13) Δ θ t = − η E [ g 2 ] t + ε ⊙ g t \Delta \theta_t=-\frac{\eta}{\sqrt{E{[g^2]}_t+\varepsilon}}\odot g_t \tag{13} Δθt​=−E[g2]t​+ε ​η​⊙gt​(13)

分母是梯度的平方和的平均的根（RMS），公式换为：
Δ θ t = − η R M S g t g t \Delta \theta_t=-\frac{\eta}{RMS{g}_t}g_t Δθt​=−RMSgt​η​gt​

作者发现这个更新并不匹配，为了处理这个，首先定义另一个exponentially decaying average，不是梯度平方而是参数的平方：
E [ Δ θ 2 ] t = γ E [ Δ θ 2 ] t − 1 + ( 1 − γ ) Δ θ t 2 E{[\Delta\theta^2]}_t = \gamma E{[\Delta\theta^2]}_{t-1} + (1-\gamma)\Delta{\theta}^2_t E[Δθ2]t​=γE[Δθ2]t−1​+(1−γ)Δθt2​

参数的root mean squared error的更新如下：
R M S [ Δ θ ] t = E [ Δ θ 2 ] t + ε RMS{[\Delta\theta]}_t=\sqrt{E{[\Delta\theta^2]_t+\varepsilon}} RMS[Δθ]t​=E[Δθ2]t​+ε ​

R M S [ Δ θ ] t RMS{[\Delta\theta]}_t RMS[Δθ]t​是未知的，根据RMS的参数估计。用 R M S [ Δ θ ] t RMS{[\Delta\theta]}_t RMS[Δθ]t​替换学习速率 η \eta η，获得adadelta的更细腻公式：
Δ θ t = − R M S [ Δ θ ] t − 1 R M S [ g ] t g t θ t + 1 = θ t + Δ θ t \Delta\theta_t = -\frac{RMS{[\Delta\theta]}_{t-1}}{RMS{[g]}_t} g_t\\ \theta_{t+1} = \theta_t+\Delta\theta_t Δθt​=−RMS[g]t​RMS[Δθ]t−1​​gt​θt+1​=θt​+Δθt​

有了adadelta，连设置学习速率的默认值都不需要，因为从更新规则去除了。

RMSprop没有发表出来，是Hiton在Coursera上的课提出来。

RMSprop 和 Adadelta几乎同时提出来，处理adagrad的学习速率下降问题。RMSprop的第一个向量的更新和adadelta相似，即：
E [ g 2 ] t = 0.9 E [ g 2 ] t − 1 + 0.1 g t 2 θ t + 1 = θ t − η E [ g 2 ] t + ε g t E{[g^2]}_t = 0.9E{[g^2]}_{t-1} + 0.1g^2_t \\ \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{E{[g^2]}_t+\varepsilon}}g_t E[g2]t​=0.9E[g2]t−1​+0.1gt2​θt+1​=θt​−E[g2]t​+ε ​η​gt​

RMSprop把学习概率除以梯度的平方的exponentially decaying average。Hinton表示 γ \gamma γ设为0.9，learning rate的默认值为0.001。

Adaptive Moment Estimation (Adam)给每个参数计算自适应的学习概率，除了和adadelta和RMSprop一样，存储过去梯度的平方 v t v_t vt​的exponentially decaying average，Adam还保存了过去梯度 m t m_t mt​的exponentially decaying average，和momentum相似：
m t = β 1 m t − 1 + ( 1 − β 1 ) g t v t = β 2 v t − 1 + ( 1 − β 2 ) g t 2 m_t = \beta_1 m_{t-1} + (1-\beta_1) g_t \\ v_t = \beta_2 v_{t-1} + (1-\beta_2) g^2_t mt​=β1​mt−1​+(1−β1​)gt​vt​=β2​vt−1​+(1−β2​)gt2​

m t m_t mt​和 v t v_t vt​分别是梯度的一阶矩量（均值）和二阶矩量（方差）， m t m_t mt​和 v t v_t vt​通常由零向量初始化，作者发现他们偏向于零，特别是初始时的time step和decay rates比较小（ β 1 \beta_1 β1​和 β 2 \beta_2 β2​接近1）。

通过计算第一和第二矩量的误差修正修改这些偏差：
m ^ t = m t 1 − β 1 t v ^ t = v t 1 − β 2 t \hat{m}_t=\frac{m_t}{1-\beta^t_1} \\ \hat{v}_t=\frac{v_t}{1-\beta^t_2} m^t​=1−β1t​mt​​v^t​=1−β2t​vt​​

然后用来更新参数，Adam的更新规则如下：
θ t + 1 = θ t − η v ^ t + ε m ^ t \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t}+\varepsilon}{\hat{m}_t} θt+1​=θt​−v^t​ ​+εη​m^t​

作者建议 β 1 \beta_1 β1​=0.9， β 2 \beta_2 β2​=0.999， ε = 1 0 − 8 \varepsilon=10^{-8} ε=10−8，实验表示Adam表现比其他自适应的学习算法好。

在Adam更新规则中的因子 v t v_t vt​缩放梯度，是 v t − 1 v_{t-1} vt−1​和当前梯度 g t 2 {g_t}^2 gt​2的倍数，即：
v t = β 2 v t − 1 + ( 1 − β 2 ) ∣ g t ∣ p v_t = \beta_2 v_{t-1} + (1-\beta_2){|g_t|}^p vt​=β2​vt−1​+(1−β2​)∣gt​∣p

将这个更新规则泛化到 l p { l}_p lp​范数，把 β 2 \beta_2 β2​参数化为：
v t = β 2 p v t − 1 + ( 1 − β 2 p ) ∣ g t ∣ p v_t=\beta^p_2 v_{t-1} + (1-\beta^p_2){|g_t|}^p vt​=β2p​vt−1​+(1−β2p​)∣gt​∣p

p p p的大范数通常不稳定，这是为什么 l 1 { l}_1 l1​和 l 2 { l}_2 l2​最常用。然而 l ∞ { l}{\infty} l∞通常表现稳定。由于这个原因，作者提出adamax，实验表示使用 l ∞ { l}{\infty} l∞的 v t v_t vt​收敛到更稳定的值，为了避免和Adam混淆，用 u t u_t ut​表示无限的范数约束 v t v_t vt​：
u t = β 2 ∞ v t − 1 + ( 1 − β 2 ∞ ) ∣ g t ∣ ∞ = m a x ( β 2 ⋅ v t − 1 , ∣ g t ∣ ) u_t = \beta^{\infty}_{2} v_{t-1} + (1-\beta^{\infty}_2){|g_t|}^{\infty} \\ =max(\beta_2\cdot v_{t-1}, |g_t|) ut​=β2∞​vt−1​+(1−β2∞​)∣gt​∣∞=max(β2​⋅vt−1​,∣gt​∣)

把这个加入Adam更新规则，用 v ^ t + ε \sqrt{\hat{v}_t}+\varepsilon v^t​ ​+ε替换 u t u_t ut​，adamax的更新规则如下：
θ t + 1 = θ t − η u t m ^ t \theta_{t+1} = \theta_t-\frac{\eta}{u_t}\hat{m}_t θt+1​=θt​−ut​η​m^t​

u t u_t ut​依赖于max操作，默认值是 η = 0.002 \eta=0.002 η=0.002， β 1 = 0.9 \beta_1=0.9 β1​=0.9， β 2 = 0.999 \beta_2=0.999 β2​=0.999。

如之前所示，Adam可以看做RMSprop和momentum的结合：RMSprop贡献了过去梯度的平方的exponentially decaying average v t v_t vt​，momentum计算了过去梯度的 exponentially decaying average m t m_t mt​，而且 Nesterov accelerated gradient (NAG)也比vanilla momentum好。

Nadam (Nesterov-accelerated Adaptive Moment Estimation)结合了Adam和NAG，为了把NAG融合到Adam，需要修改momentum 项 m t m_t mt​。

首先，momentum的更新规则如下：
g t = ∇ θ t J ( θ t ) m t = γ m t − 1 + η g t θ t + 1 = θ − m t g_t = \nabla_{\theta_t}J(\theta_t) \\ m_t = \gamma m_{t-1} + \eta g_t \\ \theta_{t+1} = \theta - m_t gt​=∇θt​​J(θt​)mt​=γmt−1​+ηgt​θt+1​=θ−mt​

J J J是目标函数， γ \gamma γ是momentum decay项， η \eta η是步骤大小，第三个公式扩展为
θ t + 1 = θ t − ( γ m t − 1 + η g t ) \theta_{t+1} = \theta_t - (\gamma m_{t-1} + \eta g_t) θt+1​=θt​−(γmt−1​+ηgt​)

这个重新证明了momentum引进了之前momentum向量的方向和当前梯度的向量。

NAG可以获得更精确的梯度方向，在计算梯度之前用momentum step来更新参数，修改NAG的梯度 g t g_t gt​可以获得：
g t = ∇ θ t J ( θ t − γ m t − 1 ) m t = γ m t − 1 + η g t θ t + 1 = θ t + m t g_t = \nabla_{\theta_t}J(\theta_t-\gamma m_{t-1}) \\ m_t = \gamma m_{t-1} + \eta g_t \\ \theta_{t+1} = \theta_t + m_t gt​=∇θt​​J(θt​−γmt−1​)mt​=γmt−1​+ηgt​θt+1​=θt​+mt​

Dozat 提出使用以下方法修改NAG，不是每步使用momentum两次，而是一次更新梯度 g t g_t gt​，第二次更新参数 θ t + 1 \theta_{t+1} θt+1​，使用之前的momentum向量更新当前的参数：
g t = ∇ θ t J ( θ t ) m t = γ m t − 1 + η g t θ t + 1 = θ 1 − ( γ m t + η g t ) g_t = \nabla_{\theta_t}J(\theta_t) \\ m_t = \gamma m_{t-1} + \eta g_t \\ \theta_{t+1} = \theta_1 - (\gamma m_t + \eta g_t) gt​=∇θt​​J(θt​)mt​=γmt−1​+ηgt​θt+1​=θ1​−(γmt​+ηgt​)

不是随机初始化之前公式27的momentum向量 m t − 1 m_{t-1} mt−1​，而是使用当前momentum向量 m t m_t mt​，为了把Nesterov momentum加到Adam中，用当前的momentum向量替换之前的momentum向量。首先，Adam的更新规则如下：
(30) m t = β 1 m t − 1 + ( 1 − β 1 ) g t m ^ t = m t 1 − β 1 t θ t + 1 = θ t − η v ^ t + ε m ^ t m_t = \beta_1 m_{t-1} + (1-\beta_1) g_t \\ \hat{m}_t = \frac{m_t}{1-\beta^t_1} \\ \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t+\varepsilon}}\hat{m}_t \tag{30} mt​=β1​mt−1​+(1−β1​)gt​m^t​=1−β1t​mt​​θt+1​=θt​−v^t​+ε ​η​m^t​(30)

扩展第二个公式，用 m ^ t \hat{m}_t m^t​和 m t m_t mt​的定义：
θ t + 1 = θ t − η v ^ t + ε ( β 1 m t − 1 1 − β 1 t + ( 1 − β 1 ) g t 1 − β 1 t ) \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t}+\varepsilon}(\frac{\beta_1 m_{t-1}}{1-\beta^t_1} + \frac{(1-\beta_1)g_t}{1-\beta^t_1}) θt+1​=θt​−v^t​ ​+εη​(1−β1t​β1​mt−1​​+1−β1t​(1−β1​)gt​​)

β 1 m t − 1 1 − β 1 t \frac{\beta_1 m_{t-1}}{1-\beta^t_1} 1−β1t​β1​mt−1​​是前一个time step的momentum向量的偏差修正估计，用 m ^ t − 1 \hat{m}_{t-1} m^t−1​代替：
θ t + 1 = θ t − η v ^ t ε ( β 1 m ^ t − 1 + ( 1 − β 1 ) g t 1 − β 1 t ) \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t}_\varepsilon}(\beta_1 \hat{m}_{t-1} + \frac{(1-\beta_1)g_t}{1-\beta^t_1}) θt+1​=θt​−v^t​ ​ε​η​(β1​m^t−1​+1−β1t​(1−β1​)gt​​)

这个公式和公式27相似，和公式27相似，把前一个time step m ^ t − 1 \hat{m}_{t-1} m^t−1​的momentum向量的修正偏差估计和当前的momentum向量 m ^ t \hat{m}_t m^t​的偏差修正估计替换，获得Nadam的更新的公式：
θ t + 1 = θ t − η v ^ t + ε ( β 1 m ^ t + ( 1 − β 1 ) g t 1 − β 1 t ) \theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t}+\varepsilon}(\beta_1 \hat{m}_t + \frac{(1-\beta_1)g_t}{1-\beta^t_1}) θt+1​=θt​−v^t​ ​+εη​(β1​m^t​+1−β1t​(1−β1​)gt​​)

下图表示了优化器的直观行为。

如何使用优化器？如果数据是稀疏，那么选择自适应学习速率的方法是最好的。另一个好处是不需要手动调参，使用默认值就可以获得最好的结果。

总之，RMSprop是adagrad的扩展，处理的问题是学习速率不断下降。和adadelta相似，除了adadelta使用RMS更新参数。最后，Adam增加了偏差修正和RMSprop增加了momentum。到目前为止，RMSprop、adadelta和Adam都是相似的算法，在相似的环境都可以获得很好的结果。Kingma et al表示偏差修正使Adam的性能比RMSprop好，就是在梯度变得稀疏时优化效果更好。目前为止，Adam是最好的选择。