深度学习的优化函数

发表于 2023-10-30 分类于 2-深度学习， A-基础知识阅读次数：本文字数： 12k 阅读时长 ≈ 11 分钟

本文讲解了对神经网络进行参数更新的优化器，最基础的优化器是w=w-rg，其中w,r,g表示参数、学习率和梯度，后面针对历史梯度、自适应学习率发展出不同的优化器，如AdaGrad，Adam等

什么是优化器？

优化器在深度学习反向传播过程中，指引损失函数（目标函数）的各个参数往正确的方向进行适合的更新，使得更新后的各个参数让损失函数（目标函数）值不断逼近全局最小
如何求最小值呢？对于凸函数可以直接求导可以找到最值，但是神经网络的优化本质上是一个非凸问题，而简单的基于梯度的优化器在实践中似乎总是能够解决这类问题

深度学习中的优化挑战有哪些？

病态情况： 在优化凸函数的时候，会遇到Hessian矩阵(黑塞矩阵) 病态的情况。病态情况一般被认为广泛存在于神经网络的训练过程中，体现在随机梯度下降会“卡”在某些特殊的情况，此时即使很小的更新步长也会增加代价函数
局部最小值： 当优化问题的数值解接近局部最优值时，随着目标函数解的梯度接近或变为零，通过最终迭代获得的数值解可能仅使目标函数局部最优，而不是全局最优。只有一定程度的噪声可能会使参数超出局部最小值
鞍点：指函数的所有梯度都消失但既不是全局最小值也不是局部最小值的任何位置

深度学习有哪些优化函数？

1）基础版梯度下降法 (独立可变梯度)：梯度下降法 (Gradient descent, GD) 、批量梯度下降 (Batch Gradient Descent, BGD) 、小批量梯度下降 (Mini-Batch Gradient Descent, MBGD) 、随机梯度下降 (stochastic gradient descent, SGD)
2）加强版梯度下降法 (带一阶动量的梯度)：带动量 (Momentum)项、Nesterov 动量项
3）自适应学习率梯度下降法 (学习率与自身的梯度自相关)：AdaGrad AdaDelta
4）带二阶动态的梯度下降法：RMSProp、 Adam 、Nadam 、Adamax、RAdam
基于动量的优化器可以利用历史梯度参与参数更新；基于自适应学习率通过约束学习率达到快速收敛的目的

如何选择优化算法？

如果是为了快速地获得原型，选择自适应算法，即AdaGrad 、AdaDelta、RMSProp、Adam
如果是为了得到最好的结果，选择梯度下降算法，如小批量梯度下降(Mini-Batch Gradient Descent, MBGD)
如果你的数据偏小而且能够适应一次迭代，那么就可以选择诸如 LBFGS这样的二阶技术。这是因为，二阶技术虽然速度非常快并且非常准确，但是只适用于数据偏小的情况。

Pytorch如何求梯度？

即求取神经网络中输出相对于输入参数的变化率，以便确定神经网络中参数的调整方向及调整尺度，并最终达到减少网络输出与真实结果的差异
Pytorch中为求导定义专门的包：autograd，如果使用Variable来定义神经网络参数，Variable自动定义两个变量，其中data表示原始数据，grad表示求导后的数据，也就是梯度

求取 out=mean ((x+2) * (x+2) * 3)的梯度，假设

z=(x+2)*(x+2)*3

，则导数为：

z=3*(x+2)/2

，当 x=1时，导数值为4.5

>>> import torch
>>> from torch.autograd import Variable
>>> x=Variable(torch.ones(2,2),requires_grad=True)
>>> x,x.grad
(tensor([[1., 1.],
        [1., 1.]], requires_grad=True), None)
>>> y=x+2
>>> y,y.grad # 正在访问非叶Tensor的grad属性y.grad。在backward()期间不会填充。如果确实希望为非叶张量填充.grad字段，请在非叶张量器上使用.retain_grad()
(tensor([[3., 3.],
        [3., 3.]], grad_fn=), None)
>>> z=y*y*3
>>> z,z.grad
(tensor([[27., 27.],
        [27., 27.]], grad_fn=), None)
>>> z.backward() # RuntimeError: grad can be implicitly created only for scalar outputs
>>> out=z.mean()
>>> out,out.grad
(tensor(27., grad_fn=), None)
>>> out.backward()
>>> x.grad,y.grad,z.grad
(tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]]), None, None)

什么是批量梯度下降(Batch Gradient Descent, BGD)?

采用整个训练集的数据来计算梯度，计算起来非常慢，遇到很大量的数据集也会非常棘手，而且不能投入新数据实时更新模型

Batch gradient descent 对于凸函数可以收敛到全局极小值，对于非凸函数可以收敛到局部极小值

1
2
3

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

什么是随机梯度下降(stochastic gradient descent, SGD)？

不像批量梯度下降(Batch Gradient Descent, BGD)一次用所有数据计算梯度，SGD每次更新时对每个样本进行梯度更新，对于很大的数据集来说，可能会有相似的样本，这样 BGD 在计算梯度时会出现冗余，而 SGD 一次只进行一次更新，就没有冗余，而且比较快，并且可以新增样本
$W \leftarrow W-\eta \frac{\partial L}{\partial W}$
可以看到BGD和SGD是两个极端，SGD由于每次参数更新仅仅需要计算一个样本的梯度，训练速度很快，即使在样本量很大的情况下，可能只需要其中一部分样本就能迭代到最优解，由于每次迭代并不是都向着整体最优化方向，导致梯度下降的波动非常大
虽然看起来SGD波动非常大，会走很多弯路，但是对梯度的要求很低（计算梯度快），而且对于引入噪声，大量的理论和实践工作证明，只要噪声不是特别大，SGD都能很好地收敛

什么是小批量梯度下降 (Mini-Batch Gradient Descent, MBGD)?

小批量梯度下降法就是结合批量梯度下降(Batch Gradient Descent, BGD)和随机梯度下降(stochastic gradient descent, SGD) 的折中，对于含有 $n$ 个训练样本的数据集，每次参数更新，选择一个大小为
Mini-batch gradient descent 不能保证很好的收敛性，学习速率 (learning rate)如果选择的太小，收敛速度会很慢，如果太大，损失函数就会在极小值处不停地震荡甚至偏离
对于非凸函数，还要避免陷于局部极小值处，或者鞍点处，因为鞍点所有维度的梯度都接近于0，SGD很容易被困在这里
Batch size的选择参考：如何选择合理的batch size?

什么是在线梯度下降(Online GD）?

Online GD于随机梯度下降(stochastic gradient descent, SGD) 、小批量梯度下降(Mini-Batch Gradient Descent, MBGD) 的区别在于，所有训练数据只用一次，然后丢弃。这样做的优点在于可预测最终模型的变化趋势
Online GD在互联网领域用的较多，比如搜索广告的点击率（CTR）预估模型，网民的点击行为会随着时间改变。用普通的BGD算法（每天更新一次）一方面耗时较长（需要对所有历史数据重新训练）；另一方面，无法及时反馈用户的点击行为迁移。而Online GD算法可以实时的依据网民的点击行为进行迁移

为什么选择Mini-Batch进行梯度下降，而不是1个或全部样本？

小批量梯度下降(Mini-Batch Gradient Descent, MBGD)用部分样本来近似全部样本，梯度相对于batch size为1更为准确，同时相比与使用全部样本，计算量减小，计算速度和收敛速度都会得到提升
为什么小批量的梯度下降更快，详细查看：为什么10000样本训练1次会比100样本训练100次收敛慢呢？

随机梯度下降（SGD）、批量梯度下降（BGD）、小批量梯度下降（Mini-batch GD）、和Online GD的区别?

SGD与自适应算法的区别？

随机梯度下降(stochastic gradient descent, SGD) 在更新参数时对各个维度上梯度的放缩是一致的，并且在训练数据分布极不均很时训练效果很差，所以SGD前期收敛慢
自适应优化算法Adam、AdaGrad、RMSProp等这些自适应的优化算法虽然可以在训练早期展现出快速的收敛速度，但其在测试集上的表现却会很快陷入停滞，并最终被 SGD 超过

如何理解深度学习中带动量(Momentum)的优化算法？

随机梯度下降(stochastic gradient descent, SGD) 和小批量梯度下降(Mini-Batch Gradient Descent, MBGD)算法都存在样本选择的随机性，因此含有较多的噪声，而momentum技术能解决上述噪声问题，借助类似指数加权平均(exponentially weighted averges) ，利用历史梯度参与参数更新。权重更新变为
$\begin{array}{c} v_{t+1} \leftarrow \alpha v_{t}-\eta \frac{\partial L}{\partial W_{t}} \\\\ W_{t+1} \leftarrow W_{t}+v_{t+1} \end{array}$
其中 $v_{t+1}$ 是动量项，取代之前的梯度 $\frac{\partial L}{\partial W_{t}}$ ，它是上一时刻的动量项与本次梯度值的加权平均值，按照时间展开，可知 $V_{t+1}$ 会按指数级累积以前的动量； $\alpha$ 是学习率， $\mu$ 是动量系数
加入的这一项，可以使得梯度方向不变的维度上速度变快，梯度方向有所改变的维度上的更新速度变慢，这样就可以加快收敛并减小震荡，一般 γ 取值 0.9 左右
形象地说，动量法就像我们从山上推下一个球，在滚落过程中累积动量，速度越来越快，直到达到终极速度。在梯度更新过程中，对在梯度点处具有相同方向的维度，增大其动量项，对于在梯度点处改变方向的维度，减小其动量项

什么是Nesterov Accelerated Gradient(NGA)优化算法?

NAG全称Nesterov Accelerated Gradient，是在随机梯度下降 (SGD) 、带动量(Momentum)项的基础上的进一步改进，我们知道在时刻t的主要下降方向是由累积动量决定的，自己的梯度方向说了也不算，那与其看当前梯度方向，不如先看看如果跟着累积动量走了一步，那个时候再怎么走。因此，NAG不计算当前位置的梯度方向，而是计算如果按照累积动量走了一步，给动量项一个预知的能力，即梯度“多走一步”，可能跳出局部最优解
$\begin{array}{c} v_{t+1} \leftarrow \alpha v_{t}-\eta \frac{\partial L\left(W_{t}+\alpha v_{t}\right)}{\partial W_{t}} \\\\ W_{t+1} \leftarrow W_{t}+v_{t+1} \end{array}$
我们利用动量项 $αv_t$ 更新参数 $w_t$ ，通过计算( $W_t+αv_t$ )得到参数未来位置的一个近似值，计算关于参数未来的近似位置的梯度，而不是关于当前参数Wt的梯度，这样NAG算法可以高效地求解
相对于Momentum的改进在于，NAG算法相对于Momentum多了一个本次梯度相对上次梯度的变化量，这个变化量本质上是对目标函数二阶导的近似。由于利用了二阶导的信息，NAG算法才会比Momentum具有更快的收敛速度
形象地说，当球滚落的时候，一般是盲目地沿着某个斜率方向，结果并不一定能令人满意。于是我们希望有一个较为“智能”的球，能够自己判断下落的方向，这样在途中遇到斜率上升的时候能够知道减速

什么是AdaGrad自适应优化算法？

已知梯度下降法(Gradient descent, GD) 依赖于人工设定的学习率，如果设置过小，收敛太慢，而如果设置太大，可能导致算法那不收敛。和通过带动量(Momentum)项加速收敛不同，AdaGrad算法是通过约束学习率达到快速收敛的目的
对于经常更新的参数，我们已经积累了大量关于它的知识，不希望被单个样本影响太大，希望学习速率慢一些；对于偶尔更新的参数，我们了解的信息太少，希望能从每个偶然出现的样本身上多学一些，即学习速率大一些，AdaGrad算法使用二阶动量感知参数的学习率，它是所有历史梯度的平方和，即
$h \leftarrow h+\frac{\partial L}{\partial W} \cdot \frac{\partial L}{\partial W}$
在更新参数时，通过乘以 $\frac {1} {\sqrt{h}}$ ，就可以调整学习的尺度，前期 $g_t$ 较小的时候， $\frac {1} {\sqrt{h}}$ 较大，能够放大梯度；后期 $g_t$ 较大的时候， $\frac {1} {\sqrt{h}}$ 较小，能够约束梯度，适合处理稀疏梯度
$W \leftarrow W-\frac{\eta}{\sqrt{h}} \cdot \frac{\partial L}{\partial W}$
AdaGrad算法依赖于人工设置一个全局学习率η，设置过大的话，会使正则化项过于敏感，对梯度的调节过大，并且在训练的中后期，分母上梯度的平方的积累将会越来越大，使gradient趋向0, 使得训练提前结束

什么是AdaDelta自适应优化算法？

Adadelta不累积全部历史梯度，而只关注过去一段时间窗口的下降梯度，即只累加固定大小的项，并且也不直接存储这些项，仅仅是近似计算对应的平均值（指数移动平均值），这就避免了二阶动量持续累积、导致训练过程提前结束的问题了
$\begin{array}{c} h_{t} \leftarrow \alpha h_{t-1}+(1-\alpha) \frac{\partial L}{\partial W_{t}} \cdot \frac{\partial L}{\partial W_{t}} \\\\ \Delta x_{t}=\frac{\sqrt{\sum_{k=1}^{t-1} \Delta x_{k}}}{\sqrt{h_{t}}} \frac{\partial L}{\partial W} \\\\ W \leftarrow W-\Delta x_{t} \end{array}$
Adadelta是对AdaGrad的改进，避免了长期累积梯度值所导致的学习率趋向于0的问题，同时去掉人工设置的全局学习率的依赖
Adadelta不依赖于全局学习率，在训练初、中期，加速效果理想化，训练后期，反复在局部最小值附近抖动

什么是RMSProp自适应优化算法？

RMSProp算法修改了AdaGrad的梯度平方和累加为指数加权平均(exponentially weighted averges)，使得其在非凸设定下效果更好
$\begin{array}{c} h \leftarrow \alpha h+(1-\alpha) \frac{\partial L}{\partial W} \cdot \frac{\partial L}{\partial W} \\\\ W \leftarrow W- \frac{\eta}{\sqrt{h}} \frac{\partial L}{\partial W} \end{array}$
RMSProp可以算作AdaDelta的一个特例，依然依赖于全局学习率。RMSProp效果趋于AdaGrad和Adadelta之间，适合处理非平稳目标，适用于RNN的优化

什么是Adam优化算法？

Adam结合了前面方法的一阶动量和二阶动量对参数进行校正，本质上是带动量(Momentum)项的RMSProp，其中一阶动量用于累积历史梯度，形成带动量(Momentum)项，二阶梯度用于累计梯度平方和，用于调整学习率
$m_{t} \leftarrow \beta_{1} m_{t-1}+\left(1-\beta_{1}\right) \frac{\partial L}{\partial W} \\\\ v_{t} \leftarrow \beta_{2} v_{t-1}+\left(1-\beta_{2}\right) \frac{\partial L}{\partial W} \cdot \frac{\partial L}{\partial W} \\\\$
对一阶动量与二阶动量进行校正，并按下公式更新参数
$\begin{array}{c} \hat{m}_{t}=\frac{m_{t}}{\left(1-\beta_{1}\right)} \\\\ \hat{v}_{t}=\frac{v_{t}}{\left(1-\beta_{2}\right)} \\\\ W_{t}=W_{t-1}- \frac{\alpha}{\sqrt{\hat{v}_{t}}} \hat{m}_{t} \end{array}$
可以看出，Adam会设置3个超参数，即学习率 $\alpha$ ，一次momentum系数 $\beta_1$ ，二次momentum系数 $\beta_2$
Adam算法的优点主要在于经过偏置校正后，每一次迭代学习率都有个确定的范围，使参数比较平稳；对内存需求较小，适用于大多数非凸优化问题，尤其适合处理大数据集和高维空间问题

什么是Adamax优化算法？

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

1 2	>>> import torch.optim as optim >>> optim.Adamax(model.parameters(),lr=0.002,beta_1=0.9,beta_2=0.999,epsilon=1e-08)

什么是Nadam优化算法？

Nadam是融合Nesterov动量项的Adam ，对学习率有了更强的约束，同时对梯度的更新也有更直接的影响
一般而言，在使用带动量的RMSProp或Adam的问题上，使用Nadam可以取得更好的结果

什么是AMSGrad优化算法？

AMSGrad是一个随机梯度下降优化方法，它试图解决基于Adam的优化器的收敛问题。AMSGrad使用最大化过去平方梯度 $v_t$ 来更新参数，而不是使用指数平均，这样就降低了指数衰减平均，造成重要历史信息快速丢失的影响
$\begin{array}{c} m_{t} =\beta_{1} m_{t-1}+\left(1-\beta_{1}\right) g_{t} \\ \\ v_{t} =\beta_{2} v_{t-1}+\left(1-\beta_{2}\right) g_{t}^{2}\\ \\ \hat{v}_{t}=\max \left(\hat{v}_{t-1}, v_{t}\right)\\ \\ \theta_{t+1}=\theta_{t}-\frac{\eta}{\sqrt{\hat{v}_{t}}+\epsilon} m_{t} \end{array}$
$g_t$ 是当前参数的梯度， $β_1$ 为一阶矩估计的指数衰减率， $β_2$ 是二阶矩估计的指数衰减率，前者控制一阶矩估计，后者控制二阶矩估计，从上面的公式可以看出，参数更新公式与Adam没有啥区别，但是求 $\hat{v}_{t}$ 有区别

什么是AdaBound优化算法？

AdaBound算法训练速度比肩Adam，性能媲美SGD。随机梯度下降(stochastic gradient descent, SGD) 现在后期调优时还是经常使用到，但SGD的问题是前期收敛速度慢，自适应优化算法Adam、AdaGrad、RMSProp等这些自适应的优化算法虽然可以在训练早期展现出快速的收敛速度，但其在测试集上的表现却会很快陷入停滞，并最终被 SGD 超过
AdaBound 对学习率进行动态裁剪，在这一设置下，在训练早期由于上下界对学习率的影响很小，算法更加接近于 Adam；而随着时间增长裁减区间越来越收紧，模型的学习率逐渐趋于稳定，在末期更加贴近于 SGD
$\begin{array}{c} m_{t} =\beta_{1} m_{t-1}+\left(1-\beta_{1}\right) g_{t} \\ \\ v_{t} =\beta_{2} v_{t-1}+\left(1-\beta_{2}\right) g_{t}^{2}\\ \\ V_{t}=\operatorname{diag}\left(v_{t}\right) \\ \\ \left.\hat{\eta}_{t}=\operatorname{Clip}\left(\alpha / \sqrt{(} V_{t}\right), \eta_{l}(t), \eta_{u}(t)\right) \\ \\ \eta_{t}=\hat{\eta}_{t} / \sqrt{t}\\\\ \theta_{t+1}=\theta_{t}-\eta_{t} \odot m_{t} \end{array}$
把学习率限定在 $[\eta_{l}, \eta_{u}]$ 之间，其中 $\eta_{l}$ 是一个非递减函数，从0逐渐的收敛到α，而 $\eta_{u}$ 是一个非递增函数，从∞逐渐收敛到α , 在这种设置下，AdaBound在最开始表现的像Adam，因为最开始学习率的边界对更新公式影响很小，渐渐的表现的像SGD+momentum，因为学习率逐渐被限制住了

什么是AdamW优化算法？

AdamW本质上就是在损失函数里面加入了L2正则化，然后计算梯度和更新参数的时候都需要考虑这个正则项
$\begin{array}{l} m_{t}=\beta_{1} m_{t-1}+\left(1-\beta_{1}\right) \nabla L\left(\theta_{t-1}\right) \\ v_{t}=\beta_{2} v_{t-1}+\left(1-\beta_{2}\right)\left(\nabla L\left(\theta_{t-1}\right)\right)^{2} \\ \theta_{t}=\theta_{t-1}-\eta\left(\frac{1}{\sqrt{\hat{v}_{t}}+\epsilon} \hat{m}_{t}-\gamma \theta_{t-1}\right) \end{array}$
权重衰减和Adam算法一起效果不佳，如果要一起使用，建议使用AdamW

什么是RAdam优化算法？

一种兼具Adam和随机梯度下降(stochastic gradient descent, SGD) 两者之美的新优化器，收敛速度快，还很鲁棒
试图解决的问题是：自适应学习率优化器（如Adam）需要学习率预热(warm-up)操作，否则就会陷入糟糕的局部最优。但是warm-up操作针对不同数据集需要手动调整，非常麻烦
RAdam使用了基于实际方差的整流函数进行“启发式warm-up”，直到数据的方差稳定下来。通过这样做，避免了需要手动warm-up，并且训练会自动稳定。一旦方差稳定下来，RAdam基本上在训练的剩余阶段就会退化成Adam甚至等同于SGD

什么是Lookahead优化算法？

Lookahead是一种梯度下降优化器，它迭代的更新两个权重集合，”fast”和”slow”。直观地说，该算法通过向前看由另一个优化器生成的快速权值序列来选择搜索方向。梯度下降的时候，走几步会退回来检查是否方向正确。避免突然掉入局部最低点
Fast weights：它是由内循环优化器（inner-loop）生成的k次序列权重；这里的优化器就是原有的优化器，如SGD，Adam等均可；其优化方法与原优化器并没有区别，例如给定优化器A，目标函数L，当前训练mini-batch样本d，这里会将该轮循环的k次权重，用序列都保存下来
Slow Weights：在每轮内循环结束后，根据本轮的k次权重，计算等到Slow Weights；这里采用的是指数移动平均（exponential moving average, EMA）算法来计算，最终模型使用的参数也是慢更新（Slow Weights）那一套，因此快更新（Fast Weights）相当于做了一系列实验，然后慢更新再根据实验结果选一个比较好的方向，这有点类似 Nesterov Momentum 的思想

什么是梯度消失(gradient vanishing) ？

根据链式法则，如果每一层神经元对上一层的输出的梯度乘上权重结果都小于1的话，那么即使这个结果是0.99，在经过足够多层传播之后，误差对输入层的梯度会趋于0
当梯度消失发生时，接近于输出层的隐藏层由于其梯度相对正常，所以权值更新时也就相对正常，但是当越靠近输入层时，由于梯度消失现象，会导致靠近输入层的隐藏层权值更新缓慢或者更新停滞。这就导致在训练时，只等价于后面几层的浅层网络的学习