优化器
深度学习模型通过引入损失函数，用来计算目标预测的错误程度。根据损失函数计算得到的误差结果，需要对模型参数（即权重和偏差）进行很小的更改，以期减少预测错误。但问题是如何知道何时应更改参数，如果要更改参数，应更改多少？这就是引入优化器的时候了。简单来说，优化器可以优化损失函数，优化器的工作是以使损失函数最小化的方式更改可训练参数，损失函数指导优化器朝正确的方向移动
优化器即优化算法是用来求取模型的最优解的，通过比较神经网络自己预测的输出与真实标签的差距，也就是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 inrange(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 inrange(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 inrange(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等人表明，噪声使得网络的鲁棒性更好，而且对于深度复杂的网络训练很有帮助。他们猜想添加了噪声之后，会使得模型有更多机会逃离局部最优解（深度模型经常容易陷入局部最优解）
版权归原作者 LogosTR_ 所有， 如有侵权，请联系我们删除。