优化器
深度学习模型通过引入损失函数,用来计算目标预测的错误程度。根据损失函数计算得到的误差结果,需要对模型参数(即权重和偏差)进行很小的更改,以期减少预测错误。但问题是如何知道何时应更改参数,如果要更改参数,应更改多少?这就是引入优化器的时候了。简单来说,优化器可以优化损失函数,优化器的工作是以使损失函数最小化的方式更改可训练参数,损失函数指导优化器朝正确的方向移动
优化器即优化算法是用来求取模型的最优解的,通过比较神经网络自己预测的输出与真实标签的差距,也就是Loss函数。
为了找到最小的loss(也就是在神经网络训练的反向传播中,求得局部的最优解),通常采用的是梯度下降(Gradient Descent)的方法,而梯度下降,便是优化算法中的一种。
1. SGD(梯度下降法)
1.1 原理
表示某一函数在该点处的方向导数沿着该方向取得最大值,即函数在该点处沿着该方向(此梯度的方向)变化最快,变化率最大(为该梯度的模)
1.2 梯度下降法迭代步骤
梯度下降的一个直观的解释:
比如我们在一座大山上的某处位置,由于我们不知道怎么下山,于是决定走一步算一步,也就是在每走到一个位置的时候,求解当前位置的梯度,沿着梯度的负方向,也就是当前最陡峭的位置向下走一步,然后继续求解当前位置梯度,向这一步所在位置沿着最陡峭最易下山的位置走一步。 这样一步步的走下去,一直走到觉得我们已经到了山脚。当然这样走下去,有可能我们不能走到山脚,而是到了某一个局部的山峰低处。
以MSE为例:
J
(
θ
)
=
1
m
∑
i
=
1
m
(
x
∗
θ
−
y
)
2
J(\theta)=\frac 1m\sum^m_{i=1}(x*\theta-y)^2
J(θ)=m1i=1∑m(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=μ∗mt−1+η∇θJ(θ)θt=θt−1−mt
其中,μ是动量因子,通常被设置为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=μ∗mt−1+η∇θJ(θ−μ∗mt−1)θt=θt−1−mt
Momentum 与 NAG 的对比,如下图:
- 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=nt−1+(gt)2θt=θt−1−nt+ϵη∗gtθt=θt−1−∑r=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=υ∗nt−1+(1−υ)(gt)2θt=θt−1−nt+ϵη∗gt
其状态变量是对平方项
g
t
2
g_t^2
gt2的指数加权移动平均,所以看作最近的
1
1
−
v
\frac 1{1-v}
1−v1个时间步的小批量随机梯度平方项的加权平均。这样,自变量每个元素的学习率在迭代过程中就不再一直降低(或不变)。
在此处 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\\\Delta\theta_{t} = - \frac{\sum^{t-1}_{r=1}\Delta\theta_r}{\sqrt{E[g^2]_t+\epsilon}} E[g2]t=ρ∗E[g2]t−1+(1−ρ)∗(gt)2Δθt=−E[g2]t+ϵ∑r=1t−1Δθ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]t−1+(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}\\\Delta\theta_{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=μ∗mt−1+(1−μ)∗gtnt=v∗nt−1+(1−v)∗(gt)2mt^=1−μtmtnt^=1−vtntΔθ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(v∗nt−1,∣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^=1−∏i=1tμigtmt=μt∗mt−1+(1−μt)∗gtmt^=1−∏i=1t+1μimtnt=v∗nt−1+(1−v)∗(gt)2nt^=1−vtntmt^=(1−μt)∗gt^+μt+1∗mt^Δθ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等人表明,噪声使得网络的鲁棒性更好,而且对于深度复杂的网络训练很有帮助。他们猜想添加了噪声之后,会使得模型有更多机会逃离局部最优解(深度模型经常容易陷入局部最优解)