Deep Learning模型中常见的optimizer优化器算法总结

1. 优化算法在DL中的挑战

1.1 优化算法定义

在一个深度学习问题中，我们首先会定义一个损失函数（loss function），一旦有了损失函数，我们就可以用优化算法去最小化这个损失函数的loss值。而深度学习中绝大多数目标函数都很复杂，是一个非凸函数。因此，很多优化问题并不存在解析解，而需要使用基于数值方法的优化算法找到近似解。

1.2 挑战：局部最小值与鞍点

若$x_0$是函数$f(x)$的局部最小值也就是说在$x_0$附近，$f(x_0)$是最小值，但相对于全局范围，$f(x_0)$并不是全局最小值。而深度学习模型的目标函数可能有若干局部最优值，当一个优化问题的数值解在局部最优解附近时，由于目标函数有关解的梯度接近或变为0，最终迭代求得的数值解可能只令目标函数局部最小化而非全局最小化。如下图所示：

除了局部最优解外，同时，还有一种情况会使得梯度接近或变成0，这个点叫鞍点（saddle point），例如函数$f(x)=x^3$，在$x=0$的时候，梯度为0，但该点是一个鞍点，如下图所示：

虽然在深度学习中，找到目标函数的全局最优解很难，但是一些常用的优化算法，在很多实际问题中都能够训练出有效的深度学习模型，接下来，会对这几种优化算法做一个介绍。

2. 常见的优化算法

2.1 梯度下降 (gradient descent)

2.1.1 梯度下降算法可以降低目标函数值原因

首先大多数人可能会有过这样的疑问：为什么梯度下降算法可以降低目标函数值？
让我们来做一个简单的推导，假设有一个连续可导函数$f(x)$，给定一个足够小的数$\epsilon$，根据泰勒展开式，得到以下近似等式：
$$f(x+\epsilon )\approx f(x)+\epsilon f^{{}^{\prime }}(x)(1)$$
这里$f^{{}^{\prime }}(x)$是函数在$x$处的梯度，一维函数的梯度是一个标量，也称导数。
令$\epsilon =-a{f}^{{}^{\prime }}(x)$，其中常数$a>0$，且使得$\left|\begin{array}{c}a{f}^{{}^{\prime }}(x)\end{array}\right|$足够小，则上述等式（1）变换形式如下：
$$f(x-a{f}^{{}^{\prime }}(x))\approx f(x)-a{f}^{{}^{\prime }}(x{)}^2(2)$$
如果导数$f^{{}^{\prime }}(x)\ne 0$，那么$a{f}^{{}^{\prime }}(x{)}^2>0$，则上述（2）等式变换形式如下：
$$f(x-a{f}^{{}^{\prime }}(x))\le f(x)$$
也就是说，通过$x\leftarrow x-a{f}^{{}^{\prime }}(x)$，来迭代$x$，函数$f(x)$的值可能会降低。因此在平时训练深度学习模型时，我们会初始化变量值$x$，然后设定一个学习率$a$来不断迭代$x$，直到到达停止条件，比如loss值足够小，或者试验指标已经不再提高等。
下面通过实现一个简单的函数来体验下梯度下降过程，假如我们的目标函数是$f(x)=x^2$，我们知道最小化$f(x)$的解是$x=0$，用梯度下降法，假设初始$x=10$，并设学习率$a=0.2$，则10次迭代后，$x$的值已经和最优解十分接近了，如下python代码演示：

# -*-coding:utf8 -*-
import sys

def gd(rate, epoch=10):
	'''
		y=x*x函数，梯度求解过程验证
	'''
	x = 10
	results = [x]
	for i in range(epoch):
		x -= rate*2*x
		results.append(x)
	print('epoch %d, x: %f:'%(epoch,x))
	return results

如下图为自变量$x$的迭代过程图：

2.1.2 学习率设定

学习率是一个超参数，需要人工设定，如果使用过小的学习率，学习过程较缓慢，需要更多次迭代，$x$才能够得到较好的解。函数$f(x)=x^2$，若设置学习率$a=0.05$，则10次迭代后，x的值和最优解还存在较大的差距，这是10次后的结果值：

自变量$x$的迭代过程图形如下：

相反，如果学习率$a$设置过大，那么会出现什么现象呢？如果学习率过大，上述的假设$\left|\begin{array}{c}a{f}^{{}^{\prime }}(x)\end{array}\right|$很小不成立，则最开始的一阶泰勒展开公式不再成立，则无法保证迭代$x$会降低$f(x)$的值，还是以上面的例子为例，假设设置学习率$a=1.1$，则$x$不断越过最优解$x=0$并逐渐发散。

$x$的迭代变化过程如下图所示：

2.2 随机梯度下降 (stochastic gradient descent)

2.2.1 方法

在深度学习中，目标函数通常是训练样本数据集中所有样本的损失函数的平均。假设$f_i(x)$是第$i$个训练样本的损失函数，$n$是总样本数，$x$是模型的参数向量，那么目标函数定义为：
$$f(x)=\frac{1}{n}\sum _{i=1}^n{f}_i(x)$$
目标函数在$x$处的梯度计算为：
$$\nabla f(x)=\frac{1}{n}\sum _{i=1}^n\nabla f_i(x)$$
如果使用梯度下降，每次自变量迭代的计算开销为$O(n)$，若样本量$n$很大时，每次迭代开销很大。
而随机梯度下降就是为了减少每次迭代的计算开销，在随机梯度下降的每次迭代中，我们随机均匀采样一个样本索引$i\in 1,2,...,n$，并计算梯度$\nabla f_i(x)$来迭代$x$:
$$x\leftarrow x-a\nabla f_i(x)$$
所以每次迭代的计算开销从$O(n)$降低到$O(1)$。

2.2.2 总结

总结两点：

• 学习率过大或过小都是不合理的，平时可以根据经验和试验设定一个较合理的值
• 使用适当的学习率，沿着梯度反方向更新自变量可能降低目标函数值

2.3 批量随机梯度下降 ( batch gradient descent)

Batch Renormalization: Towards Reducing Minibatch Dependence in Batch-Normalized Models

2.3.1 方法

梯度下降和随机梯度下降一个计算完整数据集梯度，再进行参数变量的更新，一个随机采样一个样本计算梯度，再进行参数变量的更新。梯度下降每次更新参数变量计算开销代价太大，而随机梯度每次更新参数变量容易受单样本影响，使得学习过程变得困难，不够平滑。所以，批量梯度下降是这两者方法的折中，开销代价既没有梯度下降大，学习过程也比随机梯度方法更加平滑。
从名字可知，批量随机梯度每次随机采样一个批量，也就是平时在训练深度学习模型过程中的一个batch样本来计算梯度。

2.4 Momentum

On the importance of initialization and momentum in deep learning

2.4.1 方法

假设我们有一个二维向量输入的目标函数$$f(x)=0.1x_1^2+2x_2^2$$，实现这个目标函数的梯度下降，代码如下所示：

def function(x1,x2):
	return 0.1 * x1 ** 2 + 2 * x2 ** 2

def gd_f(x1, x2, a):
	return (x1 - a * 0.2 * x1, x2 - a * 4 * x2)

假设我们令学习率$a=0.4$， 参数更新迭代的图形变化如下：

由于目标函数在$x_2$方向比在$x_1$方向的斜率更大，从图中也可以看出，梯度下降迭代自变量在$x_2$方向比在$x_1$方向移动幅度更大，为了避免自变量$x_2$方向上目标函数越过最优解，需要调小学习率，但是，在$x_1$方向上，朝最优解移动会变慢。若将学习率再调大一些$a=0.6$，在$x_2$方向上发散，越过最优解，如下图所示：

而动量（momentum）方法就是解决上述梯度下降问题。数学公式定义为如下：
$$v_t=\beta v_{t-1}+g_t$$
其中 $\beta \in (0,1)$。$v$叫做 momentum，让我们对$v$进行循环展开得到如下表达式：
$$v_t={\beta }^2{v}_{t-2}+\beta g_{t-1}+g_t=...,=\sum _{i=0}^{t-1}{\beta }^i{g}_{t-i}$$
而当时间$t$达到极限的时候，有如下公式：
$$\sum _{i=0}^{\infty }{\beta }^i=\frac{1}{1-\beta }$$
而基于momentum方法的梯度更新公式如下：
$$v_t\leftarrow \beta v_{t-1}+g_t$$
$$x_t\leftarrow x_{t-1}-\eta v_t$$
当$\beta =0$时，就是最初的梯度下降算法了，基于momentum方法，更新的梯度不再是当前最近一个step $t$计算的梯度，而是根据历史前时间$t$步数的梯度加权之后，但离当前时间$t$越前的时间，$i$越大，由于${\beta }^i$指数形式，对当前会产生很小甚至不产生作用，也就是说与当前时间$t$越近，$i$越大,由于$\beta \in (0,1)$, 则${\beta }^{t-i}$越大，所以越近的梯度产生较大的比重。上述函数$f(x)=0.1x_1^2+2x_2^2$，momentum方法梯度更新代码如下：

def momentum(beta, a, x1, x2, v1, v2):
	v1 = beta * v1 + 0.2 * v1
	v2 = beta * v2 + 4 * v2
	return x1 - eta * v1, x2 - eta * v2, v1, v2

我们还是设学习率$\eta =0.6$，$\beta =0.5$，则基于momentum方法的参数更新过程如下图所示：

我们可以看到，和上述我们使用过的梯度下降算法一样的学习率$\eta =0.6$，momentum方法也能够较好的收敛。

2.4.2 总结

总结三点：

• 动量法使用了指数加权移动平均的思想，它将过去的梯度做了加权平均，且权重按照时间步指数进行删减，离当前越近步的梯度权重越大
• 动量法使得相邻的自变量更新在方向上更加一致
• 动量法依赖指数加权移动平均使得自变量的更新方向更加一致，从而降低发散的可能
• 在动量法中，自变量在各个方向上的移动幅度不仅取决于当前梯度，还取决于过去的各个梯度在各个方向上是否一致

2.5 Adagrad

Adaptive Subgradient Methods for
Online Learning and Stochastic Optimization∗

2.5.1 方法

上述的几个优化算法在相同的时间步里，目标函数对变量的每个元素都使用相同的学习率进行更新迭代。但是，实际情况中，可能会有很多稀疏特征，训练模型过程中，出现频率高的特征，学习率可能需要慢慢减少，但是一些比较低频率出现的特征，可能需要大一点的学习率。所以，Adagrad根据自变量在每个维度的梯度值的大小来调整各个维度上的学习率，从而避免统一的学习率难以适应所有维度的问题 。
从Adagrad算法的核心思想出发，在计算各自变量值的时候，我们可以基于批量随机梯度方法调整如下：

$$g_t={\partial }_{w}l(y_t,f(x_t,w))$$
$$s_t=s_{t-1}+g_t^2$$
$$w_t=w_{t-1}-\frac{\eta }{\sqrt{s_t+\epsilon }}{g}_t$$
其中$\eta$是学习率，$\epsilon$是一个很小的常量，比如$10^{-6}$，为了维持数值稳定性，从上面三个公式可以看出，每个自变量的学习率$\frac{\eta }{\sqrt{s_t+\epsilon }}$会根据历史累计梯度的平方进行变化，若之前的历史累积梯度较大，则学习率会慢慢变小，相反，则会慢慢变大，初始$s_0=0$。
接下来，让我们仍然以目标函数$f(x)=0.1x^2+2x_2^2$为例，看Adagrad算法是怎样对自变量进行迭代的，梯度更新代码如下：

import math
eta = 0.4
def adagrad(x1, x2, s1, s2):
	g1, g2, eps = 0.2*x1, 4*x2, 1e-6
	s1 += g1 ** 2
	s2 += g2 ** 2
	x1 -= eta / math.sqrt(s1 + eps) * g1
	x2 -= eta / math.sqrt(s2 + eps) * g2
	return x1, x2, s1, s2

我们还是按照学习率为0.4，adagrad优化算法图形如下：

可以看出，由于$s_t$的累加效果，自变量随着时间步拉长，变化幅度越来越小。如果调大学习率为2，自变量更为迅速地逼近了最优解，如下图所示：

2.5.2 总结

• Adagrad算法会根据每个变量的历史累计梯度，不断降低（不变）学习率的大小
• 历史梯度累积越大，则学习率下降的越快
• Adagrad算法对稀疏特征较有效，当频率出现较低的特征在学习过程中需要较大的学习率
• Adagrad算法对于学习率降低有点过于极端，如果一开始某个变量的学习率很大，但是一直没学好，则后面学习率降低很小，很有可能不会再找到最优解

2.6 RMSProp

divide the gradient by a running average of its recent magnitude. COURSERA

2.6.1 方法

由于在Adagrad算法中，我们是通过对之前时间步$t$的梯度平方累加而不断降低学习率。如果学习率在一开始早期迭代没有到达最佳值，到后面由于学习率太小，可能很难再找到合适的解。
为了解决Adagrad算法后期迭代学习率过小，而还没有达到最优解的这种问题，从上述Adagrad公式可以看出，一种方法是最后的$s_t$可以求个时间$t$的平均，$s_t/t$，这样$s_t$不会因为时间$t$的累积，一直在变大，而导致学习率一直在下降。但是这种求平均方式学习过程很缓慢。可以用一个类似的平均方法取代，在前面讲解的momentum方法中使用过的指数加权移动平均。RMSProp更新迭代的数学公式如下：
$$s_t\leftarrow \gamma s_{t-1}+(1-\gamma )g_t^2$$
$$x_t\leftarrow x_{t-1}-\frac{\eta }{\sqrt{s_t+\epsilon }}\odot g_t$$
常量$\epsilon >0$，用来保证除数不为0或者不会除以很小的数，维持数值稳定。让我们对$s_t$展开，得到如下形式:
$$s_t=(1-\gamma )g_t^2+\gamma s_{t-1}=(1-\gamma )(g_t^2+\gamma g_{t-1}^2+{\gamma }^2{g}_{t-2}^2+...,)$$
而$1+\gamma +{\gamma }^2+...,=\frac{1}{1-\gamma }$，因此并不是随着时间增加，$s_t$一直增加，因为随着时间增加，梯度按照最近的指数加权平均，可以看做最近时间步$\frac{1}{1-\gamma }$的梯度指数加权平均。
还是以函数$f(x)=0.1x_1^2+2x_2^2$为例，迭代代码如下：

import math
eta, gamma = 0.4, 0.9
def Rmsprop(x1, x2, s1, s2):
	g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6
	s1 = gamma * s1 + (1 - gamma) * g1 **2
	s2 = gamma * s2 + (1 - gamma) * g2 **2
	x1 -= eta / math.sqrt(s1 + eps) * g1
	x2 -= eta / math.sqrt(s2 + eps) * g2
	return x1, x2, s1, s2

我们还是用学习率为0.4，在Adagrad迭代方法中，后期自变量移动幅度较小，而下图是RMSProp优化迭代过程，相同的迭代条件下，收敛速度更快。

2.6.2 总结

• RMSProp算法和Adagrad算法十分相近，不同点在于，RMSProp算法使用指数加权移动平均来调整学习率，保证了学习率并不会一直单调降低
• 系数$\gamma$决定了累积历史多久时间步的梯度值更新参数$s_t$

2.7 AdaDelta

ADADELTA: AN ADAPTIVE LEARNING RATE METHOD

2.7.1 方法

Adadelta是AdaGrad算法的一种变体，类似RMSProp算法，主要针对AdaGrad后期迭代因为学习率降低的太小，可能较难找到最优解问题而做的改进，同时Adadelta没有学习率这个超参数。
Adadelta保留了两个状态变量，$s_t$存储了历史梯度变化情况，$\Delta x_t$存储的是历史自变量变化情况。所以具体数学公式如下：
$$s_t=\rho s_{t-1}+(1-\rho )g_t^2$$

$$g_t^{{}^{\prime }}=\frac{\sqrt{\Delta x_{t-1}+\epsilon }}{\sqrt{s_t+\epsilon }}$$
$$\Delta x_t=\epsilon \Delta x_{t-1}+(1-\epsilon )g_t^{{{}^{\prime }}^2}$$
$$x_t=x_{t-1}-g_t^{{}^{\prime }}$$
其中$\epsilon$是一个很小的数值，比如$10^{-5}$，为了维持计算的稳定性。从上面公式可以看出，AdaDelta算法相比RMSProp算法的主要区别是用$\Delta x$这个变量来替换RMSProp的超参数学习率$\eta$。其中$\Delta x_0$和$s_0$初始化都是0。

2.7.2 总结

• Adadelta算法没有学习率这个超参数，通过计算自变量的指数加权平均来替代学习率
• Adadelta使用两个变量来存储梯度的变化和自变量本身的变化

2.8 Adam

ADAM: A METHOD FOR STOCHASTIC OPTIMIZATIONfang’f

2.8.1 方法

Adam是一个综合了上述所有优化算法的一个有效的算法。目前为止，Adam是在深度学习模型里使用较多，也是教鲁棒的优化器之一。不过Adam算法也有一些问题，具体可以参考以下两篇论文：
On the Convergence of Adam and Beyond

Adaptive Methods for Nonconvex Optimization

Adam算法的使用了动量变量$v_t$和RMSProp算法中的批量随机梯度平方的指数加权移动平均变量$s_t$。数学公式如下：
$$v_t\leftarrow {\beta }_1{v}_{t-1}+(1-{\beta }_1)g_t$$
$$s_t\leftarrow {\beta }_2{s}_{t-1}+(1-{\beta }_2)g_t^2$$
其中${\beta }_1$和${\beta }_2$是一个小于1的正数，一般设置是${\beta }_1=0.9$ ${\beta }_2=0.999$，初始值$v_0=s_0=0$。
$v_t=(1-{\beta }_1){\sum }_{i=1}^t{\beta }_1^{t-i}{g}_i$，将过去各时间步批量随机梯度权值相加，得到$(1-{\beta }_1){\sum }_{i=1}^t{\beta }_1^{t-i}=1-{\beta }_1^t$，当时间$t$很小时。过去各时间步批量梯度权值之和很小，例如当${\beta }_1=0.9$，$v_1=0.1g_1$，为了避免这样的影响，除以$1-{\beta }_1^t$归一化因子，修正后如下：
$$\widehat{v_t}=\frac{v_t}{1-{\beta }_1^t}$$
$$\widehat{s_t}=\frac{s_t}{1-{\beta }_2^t}$$
Adam算法用$v_t$和$s_t$来调整每个参数的学习率，如下公式：
$$g_t^{{}^{\prime }}\leftarrow \frac{\eta \widehat{v_t}}{\sqrt{\widehat{s_t}}+\epsilon }$$
$$x_t\leftarrow x_{t-1}-g_t^{{}^{\prime }}$$
$\eta$是学习率，$\epsilon$是为了维持数值计算稳定的一个很小的常量，如$10^{-8}$，和AdaGrad、RMSProp以及AdaDelta算法一样，每个自变量都有自己的学习率。

2.8.2 总结

• Adam算法集合了许多优化算法的特性，是一个较鲁棒的优化算法
• Adam相对于RMSPro算法，在时间$t$步上，用历史所有时间$t$步的批量随机梯度指数加权移动平均来替代当前时间$t$的梯度$g_t$
• Adam算法y也使用了偏差修正，保证了在刚开始，时间步$t$很小的时候，指数加权权重之和较小问题

3. 参考资料

Optimization and Deep Learning