【深度学习】优化器详解

优化器

深度学习模型通过引入损失函数,用来计算目标预测的错误程度。根据损失函数计算得到的误差结果,需要对模型参数(即权重和偏差)进行很小的更改,以期减少预测错误。但问题是如何知道何时应更改参数,如果要更改参数,应更改多少?这就是引入优化器的时候了。简单来说,优化器可以优化损失函数,优化器的工作是以使损失函数最小化的方式更改可训练参数,损失函数指导优化器朝正确的方向移动

优化器即优化算法是用来求取模型的最优解的,通过比较神经网络自己预测的输出与真实标签的差距,也就是Loss函数。

为了找到最小的loss(也就是在神经网络训练的反向传播中,求得局部的最优解),通常采用的是梯度下降(Gradient Descent)的方法,而梯度下降,便是优化算法中的一种。

1. SGD(梯度下降法)

1.1 原理

表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)
在这里插入图片描述

1.2 梯度下降法迭代步骤

梯度下降的一个直观的解释:
比如我们在一座大山上的某处位置,由于我们不知道怎么下山,于是决定走一步算一步,也就是在每走到一个位置的时候,求解当前位置的梯度,沿着梯度的负方向,也就是当前最陡峭的位置向下走一步,然后继续求解当前位置梯度,向这一步所在位置沿着最陡峭最易下山的位置走一步。 这样一步步的走下去,一直走到觉得我们已经到了山脚。当然这样走下去,有可能我们不能走到山脚,而是到了某一个局部的山峰低处。
img-KdzKWPp3-1661424408143)

以MSE为例:

J

(

θ

)

=

1

m

i

=

1

m

(

x

θ

y

)

2

J(theta)=frac 1msum^m_{i=1}(x*theta-y)^2

J(θ)=m1i=1m(xθy)2
目标是找到一组合适的θ(w1,w2,w3,…,wn)使得目标函数J(θ)值最小。(以最快得速度、最有效的方式来找到最优解)

1.3 三种不同的梯度下降方法

区别在于每次参数更新时计算的样本数据量不同

1.3.1 批梯度下降( Batch gradient descent)

批梯度下降法(Batch Gradient Descent)针对的是整个数据集,通过对所有的样本的计算来求解梯度的方向

θ

=

θ

η

θ

J

(

θ

)

theta = theta - eta nabla_{theta}J(theta )

θ=θηθJ(θ)

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

1.3.2 随机梯度下降(Stochastic gradient descent)

每进行1次参数更新,只需要计算1个随机数据样本

θ

=

θ

η

θ

J

(

x

(

i

)

,

y

(

i

)

;

θ

)

theta = theta - eta nabla_{theta}J( x^{(i)}, y^{(i)} ;theta)

θ=θηθJ(x(i),y(i);θ)

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

1.3.3 Mini-batch梯度下降方法(Mini-batch gradient descent)

每进行1次参数更新,需要计算1个mini-batch数据样本

θ

=

θ

η

θ

J

(

x

(

i

:

i

+

n

)

,

y

(

i

:

i

+

n

)

;

θ

)

theta = theta - eta nabla_{theta}J(x^{(i:i+n)}, y^{(i:i+n)}; theta )

θ=θηθJ(x(i:i+n),y(i:i+n);θ)

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

1.3.4 三种方法对比

  • Batch gradient descent的收敛速度太慢,而且会大量多余的计算(比如计算相似的样本)。
  • Stochastic gradient descent虽然大大加速了收敛速度,但是它的梯度下降的波动非常大(high variance)。
  • Mini-batch gradient descent中和了2者的优缺点,所以SGD算法通常也默认是Mini-batch gradient descent

1.3.5 Mini-batch梯度下降法的缺点

然而Mini-batch gradient descent也不能保证很好地收敛。主要有以下缺点:

  • 选择一个合适的learning rate是非常困难的 学习率太低会收敛缓慢,学习率过高会使收敛时的波动过大。

  • 所有参数都是用同样的learning rate 对于稀疏数据或特征,有时我们希望对于不经常出现的特征的参数更新快一些,对于常出现的特征更新慢一些。这个时候SGD就不能满足要求了。

  • sgd容易收敛到局部最优解,并且在某些情况可能被困在鞍点 在合适的初始化和step size的情况下,鞍点的影响没那么大。

1.3.6 调节 Batch_Size 对训练效果影响到底如何?

  • Batch_Size 太小,模型表现效果极其糟糕(error飙升)。
  • 随着 Batch_Size 增大,处理相同数据量的速度越快。
  • 随着 Batch_Size 增大,达到相同精度所需要的 epoch 数量越来越多。

由于上述两种因素的矛盾, Batch_Size 增大到某个时候,达到时间上的最优;由于最终收敛精度会陷入不同的局部极值,因此 Batch_Size 增大到某些时候,达到最终收敛精度上的最优。如果训练集较小(小于 2000 个样本),直接使用BGD法

正是因为SGD这些缺点,才有后续提出的各种算法。

1.4 pytorch中SGD:

torch.optim.SGD(params, lr=<required parameter>, momentum=0, dampening=0, weight_decay=0, nesterov=False, *, maximize=False, foreach=None)

参数:

  • params(iterable): 需要优化的参数
  • lr(float): 学习率
  • momentum (float, optional) : 动量因子 默认 0
  • weight_decay (float, optional) – 权值衰减 (L2 penalty) (default: 0)
  • dampening (float, optional) – 动量抑制 (default: 0)
  • nesterov (bool, optional) – 是否使用 Nesterov momentum (default: False)
  • maximize (bool, optional) – 根据目标最大化参数,而不是最小化 (default: False)
  • foreach (bool, optional) – 是否为每一个优化器实现 (default: None)

2. Momentum

momentum利用了物理学中动量的思想,通过积累之前的动量(mt−1)来加速当前的梯度。

m

t

=

μ

m

t

1

+

η

θ

J

(

θ

)

θ

t

=

θ

t

1

m

t

m_t = mu*m_{t-1}+eta nabla_{theta}J(theta) \ theta_{t} = theta_{t-1} - m_t

mt=μmt1+ηθJ(θ)θt=θt1mt
其中,μ是动量因子,通常被设置为0.9或近似值。

特点

  • 参数下降初期,加上前一次参数更新值;如果前后2次下降方向一致,乘上较大的μ能够很好的加速。
  • 参数下降中后期,在局部最小值附近来回震荡时,gradient→0,μ使得更新幅度增大,跳出陷阱。
  • 在梯度方向改变时,momentum能够降低参数更新速度,从而减少震荡;在梯度方向相同时,momentum可以加速参数更新, 从而加速收敛。
  • 总而言之,momentum能够加速SGD收敛,抑制震荡。

3. NAG

牛顿加速梯度动量优化方法(NAG, Nesterov accelerated gradient):用上一步的速度先走一小步,再看当前的梯度然后再走一步。

尝试这么去理解:在momentum中小球会盲目的跟从下坡的梯度,容易发生错误,所以需要一个更聪明的小球,能提前知道它要去哪,还有知道走到坡地的时候速度慢下来,而不是又崇尚另一坡。

  • 优点: 梯度下降的方向更加准确
  • 缺点: 对收敛率作用不是很大

NAG在梯度更新时做一个矫正,避免前进太快,同时提高灵敏度。

Momentum并没有直接影响当前的梯度

θ

J

(

θ

)

nabla_{theta}J(theta)

θJ(θ),所以NAG的改进就是用上一次的动量(−μ∗mt−1)当前的梯度

θ

J

(

θ

)

nabla_{theta}J(theta)

θJ(θ)做了一个矫正。

m

t

=

μ

m

t

1

+

η

θ

J

(

θ

μ

m

t

1

)

θ

t

=

θ

t

1

m

t

m_t = mu*m_{t-1}+eta nabla_{theta}J(theta-mu*m_{t-1})\theta_{t} = theta_{t-1} - m_t

mt=μmt1+ηθJ(θμmt1)θt=θt1mt

Momentum 与 NAG 的对比,如下图:
image_3

  • Momentum: 蓝色向量
    Momentum首先计算当前的梯度值(短的蓝色向量),然后加上之前累计的梯度/动量(长的蓝色向量)。
  • NAG: 绿色向量
    NAG 首先先计算之前累计的梯度/动量(长的棕色向量),然后加上当前梯度值进行矫正后(−μ∗mt−1)的梯度值(红色向量),得到的就是最终 NAG 的更新值(绿色向量)。

Momentum 和 NAG 都是为了使梯度更新更灵活。但是人工设计的学习率总是有些生硬,下面介绍几种自适应学习率的方法。


4. Adagrad

Adagrad是对学习率进行了一个约束,AdaGrad使⽤⼀个小批量随机梯度

g

t

g_t

gt 按元素平⽅的累加变量

n

t

n_t

nt 。在时间步0,将

n

0

n_0

n0中每个元素初始化为0。在时间步t,⾸先将小批量随机梯度

g

t

g_t

gt按元素平⽅后累加到变量

n

t

n_t

nt

g

t

=

θ

J

(

θ

)

n

t

=

n

t

1

+

(

g

t

)

2

θ

t

=

θ

t

1

η

n

t

+

ϵ

g

t

θ

t

=

θ

t

1

η

r

=

1

t

(

g

r

)

2

+

ϵ

g

t

g_t = nabla_{theta}J(theta)\ n_t = n_{t-1}+ (g_t)^2\ theta_{t} = theta_{t-1} - frac{eta}{sqrt{n_t+epsilon}} * g_t\ theta_{t} = theta_{t-1} - frac{eta}{sqrt{sum^t_{r=1}(g_r)^2+epsilon}} * g_t

gt=θJ(θ)nt=nt1+(gt)2θt=θt1nt+ϵ

ηgtθt=θt1r=1t(gr)2+ϵ

ηgt

特点

  • 前期

    n

    t

    n_t

    nt 较小的时候,regularizer较大,能够放大梯度

  • 后期

    n

    t

    n_t

    nt较大的时候,regularizer较小,能够缩小梯度

  • 中后期,分母上梯度平方的累加会越来越大,使gradient→0,使得训练提前结束。

缺点

  • 由公式可以看出,仍依赖于人工设置的一个全局学习率 η
  • η 设置过大的话,会使regularizer过于敏感,对梯度调节太大。
  • 最重要的是,中后期分母上的梯度平方累加会越来越大,使gradient → 0,使得训练提前结束,无法继续学习。

Adadelta主要就针对最后一个缺点做了改进。


5. Adadelta

Adadelta依然对学习率进行了约束,但是在计算上进行了简化。

g

t

=

θ

J

(

θ

)

n

t

=

υ

n

t

1

+

(

1

υ

)

(

g

t

)

2

θ

t

=

θ

t

1

η

n

t

+

ϵ

g

t

g_t = nabla_{theta}J(theta)\ n_t = upsilon*n_{t-1}+ (1-upsilon)(g_t)^2\ theta_{t} = theta_{t-1} - frac{eta}{sqrt{n_t+epsilon}} *g_t

gt=θJ(θ)nt=υnt1+(1υ)(gt)2θt=θt1nt+ϵ

ηgt

其状态变量是对平方项

g

t

2

g_t^2

gt2的指数加权移动平均,所以看作最近的

1

1

v

frac 1{1-v}

1v1个时间步的小批量随机梯度平方项的加权平均。这样,自变量每个元素的学习率在迭代过程中就不再一直降低(或不变)。
在此处 Adadelta 还是依赖全局学习率的,然后作者又利用近似牛顿迭代法,做了一些改进:

E

[

g

2

]

t

=

ρ

E

[

g

2

]

t

1

+

(

1

ρ

)

(

g

t

)

2

Δ

θ

t

=

r

=

1

t

1

Δ

θ

r

E

[

g

2

]

t

+

ϵ

E[g^2]_t = rho*E[g^2]_{t-1} + (1-rho)*(g_t)^2\Deltatheta_{t} = - frac{sum^{t-1}_{r=1}Deltatheta_r}{sqrt{E[g^2]_t+epsilon}}

E[g2]t=ρE[g2]t1+(1ρ)(gt)2Δθt=E[g2]t+ϵ

r=1t1Δθr

其中,E代表求期望。

此时可以看出Adadelta已经不依赖全局learning rate了。

特点

  • 训练初中期,加速效果不错,很快。
  • 训练后期,反复在局部最小值附近抖动。

6. RMSprop

RMSprop可以看做Adadelta的一个特例。

当 ρ=0.5 时,

E

[

g

2

]

t

=

ρ

E

[

g

2

]

t

1

+

(

1

ρ

)

(

g

t

)

2

E[g^2]_t = rho*E[g^2]_{t-1} + (1-rho)*(g_t)^2

E[g2]t=ρE[g2]t1+(1ρ)(gt)2就变为求梯度平方和的平均数。

如果再求根的话,就变成RMS(Root Mean Squared,均方根):

R

M

S

[

g

]

t

=

E

[

g

2

]

t

+

ϵ

Δ

θ

t

=

η

R

M

S

[

g

]

t

g

t

RMS[g]_t = sqrt{E[g^2]_t + epsilon}\Deltatheta_{t} = - frac{eta}{sqrt{RMS[g]_t}} * g_t

RMS[g]t=E[g2]t+ϵ

Δθt=RMS[g]t

ηgt
比较好的一套参数设置为:η=0.001,γ=0.9

特点

  • 其实RMSprop依然依赖于全局学习率
  • RMSprop的效果介于Adagrad和Adadelta之间
  • 适合处理非平稳目标——对于RNN效果很好。

7. Adam

Adam(Adaptive Moment Estimation)本质上时带有动量项的RMSprop。

m

t

=

μ

m

t

1

+

(

1

μ

)

g

t

n

t

=

v

n

t

1

+

(

1

v

)

(

g

t

)

2

m

t

^

=

m

t

1

μ

t

n

t

^

=

n

t

1

v

t

Δ

θ

t

=

m

t

^

n

t

^

+

ϵ

η

m_t = mu*m_{t-1}+(1-mu)*g_t\n_t = v*n_{t-1}+(1-v)*(g_t)^2\hat{m_t} = frac{m_t}{1-mu^t}\hat{n_t} = frac{n_t}{1-v^t}\Delta theta_t = - frac{hat{m_t}}{sqrt{hat{n_t}}+epsilon} * eta

mt=μmt1+(1μ)gtnt=vnt1+(1v)(gt)2mt^=1μtmtnt^=1vtntΔθt=nt^

+ϵmt^η

mt,nt 分别是梯度的一阶矩估计和二阶矩估计,可以看作对期望

E

[

g

]

t

,

E

[

g

2

]

t

E[g]_t, E[g^2]_t

E[g]t,E[g2]t的估计;

m

t

^

,

n

t

^

hat{m_t}, hat{n_t}

mt^,nt^分别是对 mt,nt 的校正,这样可以近似为对期望的无偏估计。

可以看出,直接对梯度的矩估计对内存没有额外的要求,而且可以根据梯度进行动态调整,而

m

t

^

n

t

^

+

ϵ

- frac{hat{m_t}}{sqrt{hat{n_t}}+epsilon}

nt^

+ϵmt^对学习率形成一个动态约束,而且有明确范围。

作者提出的默认的参数设置为:μ=0.9,v=0.999,ϵ=10−8

特点

  • Adam梯度经过偏置校正后,每一次迭代学习率都有一个固定范围,使得参数比较平稳。
  • 结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点
  • 为不同的参数计算不同的自适应学习率
  • 也适用于大多非凸优化问题——适用于大数据集和高维空间。

8. Adamax

Adamax是Adam的一种变体,此方法对学习率的上限提供了一个更简单的范围。

n

t

=

m

a

x

(

v

n

t

1

,

g

t

)

Δ

θ

t

=

m

t

^

n

t

+

ϵ

η

n_t = max(v*n_{t-1}, |g_t|)\ Delta theta_t = - frac{hat{m_t}}{{{n_t}}+epsilon} * eta

nt=max(vnt1,gt)Δθt=nt+ϵmt^η
Adamax的学习率边界范围更简单。

9. Nadam

Nadam类似于带有NAG动量项的Adam。

g

t

^

=

g

t

1

i

=

1

t

μ

i

m

t

=

μ

t

m

t

1

+

(

1

μ

t

)

g

t

m

t

^

=

m

t

1

i

=

1

t

+

1

μ

i

n

t

=

v

n

t

1

+

(

1

v

)

(

g

t

)

2

n

t

^

=

n

t

1

v

t

m

t

^

=

(

1

μ

t

)

g

t

^

+

μ

t

+

1

m

t

^

Δ

θ

t

=

m

t

^

n

t

^

+

ϵ

η

hat{g_t} = frac{g_t}{1-prod^t_{i=1}mu_i}\m_t = mu_t*m_{t-1}+(1-mu_t)*g_t\hat{m_t} = frac{m_t}{1-prod^{t+1}_{i=1}mu_i}\n_t = v*n_{t-1}+(1-v)*(g_t)^2\hat{n_t} = frac{n_t}{1-v^t} hat{m_t} = (1-mu_t)*hat{g_t}+mu_{t+1}*hat{m_t}\Delta theta_t = - frac{hat{m_t}}{sqrt{hat{n_t}}+epsilon} * eta

gt^=1i=1tμigtmt=μtmt1+(1μt)gtmt^=1i=1t+1μimtnt=vnt1+(1v)(gt)2nt^=1vtntmt^=(1μt)gt^+μt+1mt^Δθt=nt^

+ϵmt^η

可以看出,Nadam对学习率有更强的约束,同时对梯度的更新也有更直接的影响。

一般而言,在使用带动量的RMSprop或Adam的问题上,使用Nadam可以取得更好的结果。


10. 几种算法下降过程的可视化

10.1. 算法的梯度下降过程对比:

在这里插入图片描述

可以看到:

Adagrad,Adadelta和RMSprop都是非常快到达右边的最优解,而这个时候Momentum和NAG才开始下降,而且刚开始的下降速度很慢。但是很快NAG就会找到正确的下降方向并且更加速的接近最优解。

SGD下降的最慢了,但是下降的方向总是最正确的。

10.2. 在鞍点(saddle point)处的对比:

在这里插入图片描述

可以看到:

SGD被困在鞍点了,没法继续优化。

SGD,Momentum和NAG都在鞍点来回晃动,但最终Momentum和NAG逃离了鞍点。

但是与此同时,Adagrad,RMSprop和Adadelta很快的就离开了鞍点。


11. 优化算法的选择

  • 对于稀疏数据,尽量使用学习率可自适应的算法,不用手动调节,而且最好采用默认参数
  • SGD通常训练时间最长,但是在好的初始化和学习率调度方案下,结果往往更可靠。但SGD容易困在鞍点,这个缺点也不能忽略。
  • 如果在意收敛的速度,并且需要训练比较深比较复杂的网络时,推荐使用学习率自适应的优化方法。
  • Adagrad,Adadelta和RMSprop是比较相近的算法,表现都差不多。
  • 在能使用带动量的RMSprop或者Adam的地方,使用Nadam往往能取得更好的效果。

12. 优化SGD的其他策略

12.1. Shuffling and Curriculum Learning

Shuffling就是打乱数据,每一次epoch之后 shuffle一次数据,可以避免训练样本的先后次序影响优化的结果。

但另一方面,在有些问题上,给训练数据一个有意义的顺序,可能会得到更好的性能和更好的收敛。这种给训练数据建立有意义的顺序的方法被叫做Curriculum Learning。

12.2. Batch Normalization

为了有效的学习参数,我们一般在一开始把参数初始化成0均值和单位方差。但是在训练过程中,参数会被更新到不同的数值范围,使得normalization的效果消失,从而导致训练速度变慢或梯度爆炸等等问题(当网络越来越深的时候)。

BN给每个batch的数据恢复了normalization,同时这些对数据的更改都是可还原的,即normalization了中间层的参数,又没有丢失中间层的表达能力。

使用BN之后,我们就可以使用更高的学习率,也不用再在参数初始化上花费那么多注意力。

BN还有正则化的作用,同时也削弱了对Dropout的需求。

12.3. Early Stopping

在训练的时候我们会监控validation的误差,并且会(要有耐心)提前停止训练,如果验证集的error没有很大的改进。

12.4. Gradient noise

在梯度更新的时候加一个高斯噪声:

g

t

,

i

=

g

t

,

i

+

N

(

0

,

σ

t

2

)

g_{t,i} = g_{t,i} + N(0,sigma^2_t)

gt,i=gt,i+N(0,σt2)

方差值的初始化策略是:

σ

t

2

=

η

(

1

+

t

)

γ

sigma^2_t = frac{eta}{(1+t)^{gamma}}

σt2=(1+t)γη

Neelakantan等人表明,噪声使得网络的鲁棒性更好,而且对于深度复杂的网络训练很有帮助。他们猜想添加了噪声之后,会使得模型有更多机会逃离局部最优解(深度模型经常容易陷入局部最优解)

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇

)">
下一篇>>