优化器简单概述

————————————————————————————————————

优化算法

前言

参考：https://zhuanlan.zhihu.com/p/376387915
首先应该知道优化算法的目的是什么：既然在变量空间的某一点处，函数沿梯度方向具有最大的变化率，那么在优化目标函数的时候，沿着负梯度方向去减小函数值，以此达到我们的优化目标。

梯度的定义如下：
$gradf(x_0,x_1,...,x_n)=(\frac{\partial f}{\partial x_0},\frac{\partial f}{\partial x_1},...,\frac{\partial f}{\partial x_n})$
梯度的提出只为回答一个问题：
　函数在变量空间的某一点处，沿着哪一个方向有最大的变化率？(针对这一点，我们都知道对于神经网络而言，神经元节点可看做变量x，而每个变量x都有自己的参数$w$，在某一隐藏层，可能存在256的神经元节点，每个神经元节点对于损失函数来说都有属于自己的方程，我们实质性求得梯度，是基于损失函数在该神经元节点的导数，可能又出现一个问题是众多的偏导数和梯度有什么关系，这也就回到了梯度的定义上，一个空间中存在多个变量，而沿着哪一方向有最大的变化率，则为梯度，而这个变化率就是所求的导)
　梯度定义如下：
　函数在某一点的梯度是一个向量，它的方向与取得最大方向导数的方向一致，而它的模为方向导数的最大值。
　这里注意三点：
　1）梯度是一个向量，即有方向有大小
　2）梯度的方向是最大方向导数的方向
　3）梯度的值是最大方向导数的值
　
参考文章：https://zhuanlan.zhihu.com/p/32230623
首先定义：待优化的参数：$w$，目标函数：$f(w)$，初始学习率：$l_r$
而后，开始进行迭代优化。在每个$epoch$：

• 1 计算目标函数关于当前参数的梯度(可以理解为计算损失函数关于当前网络层参数的梯度)：$g_t=\nabla f(w_t)$
• 2 根据历史梯度计算一阶动量和二阶动量：$m_t=\varphi (g_1,g_2....g_t)$，$V_t=\phi (g_1,g_2....g_t)$
• 3 计算当前时刻的下降梯度：${\eta }_t=\frac{l_r\times m_t}{{\sqrt{V}}_t}$
• 4 根据下降梯度进行最优参数的更新： $w_{t+1}=w_t-{\eta }_t$
  掌握了这个框架，你可以轻轻松松设计自己的优化算法。

SGD理解1

SGD是每一次迭代计算mini-batch的梯度。
SGD没有动量的概念，也就是说：$m_t=g_t$，$V_t=I^2$
代入步骤3，可以看到下降梯度就是最简单的:${\eta }_t=l_r\times g_t$
代入步骤4，可以得到梯度更新公式为：$w_{t+1}=w_t-l_r\times g_t$
SGD最大的缺点是下降速度慢，而且可能会在沟壑的两边持续震荡，停留在一个局部最优点。
$g_t$是当前batch的梯度，所以$l_r\times g_t$可理解为允许当前batch的梯度多大程度影响参数更新
SGD with Momentum
为了抑制SGD的震荡，SGDM(SGD with momentum)认为梯度下降过程可以加入惯性。下坡的时候，如果发现是陡坡，那就利用惯性跑的快一些。在SGD基础上引入了一阶动量：$m_t={\beta }_1\times m_{t-1}+g_t$
也就是说，t时刻的下降方向，不仅由当前点的梯度方向决定，而且由此前累积的下降方向决定。${\beta }_1$的经验值为0.9，这就意味着下降方向主要是此前累积的下降方向，并略微偏向当前时刻的下降方向。
代入步骤4，可以得到梯度更新公式为：$w_{t+1}=w_t-\frac{l_r(\times {\beta }_1\times m_{t-1}+(1-{\beta }_1)\times g_t)}{{\sqrt{V}}_t}$

SGD理解2

原理：

模型每次反向传导都会给各个可学习参数$w$计算出一个偏导数$g_t$，用于更新对应的参数$w$。通常偏导数$g_t$不会直接作用到对应的可学习参数$w$上，而是通过优化器做一下处理，得到一个新的值${\hat{g}}_t$，处理过程用函数F表示（不同的优化器对应的F的内容不同），即$\widehat{g_t}=F(g_t)$，然后和学习率$l_r$一起用于更新可学习参数$w$，即$w=w-l_r\times \widehat{g_t}$。
在pytorch中，SGD定义为：

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

params：模型中需要被更新的可学习参数
lr：学习率
momentum：动量—通过上一次的$v_{t-1}$和当前的偏导数$g_t$，得到本次的$v_t$，即$v_t=v_{t-1}\times momentum+g_t$，这个就是上述的函数F。
dampening：是乘到偏导数g上的一个数，即：$v_t=v_{t-1}\times momentum+g_t\times (1-dampening)$。注意：dampening在优化器第一次更新时，不起作用。
weight_decay：权重衰减参数：其直接作用于$g_t$，即：$g_t=g_t+(g_{t-1}\times weigh{t}_{decay})$
流程计算：

1.先计算：$g_t=g_t+(w\times weigh{t}_{decay})$ 得到当前轮关于$w$的导数$g_t$，在第一轮训练中，$w$为初始化的随机梯度值，或者加载的预训练权值。
2.在计算：$v_t=v_{t-1}\times momentum+g_t\times (1-dampening)$ 此时的$v_0=0;v_1=g_1$
3.参数更新：$w_t=w_t-l_r\times v_t$

例：

假设函数$Y=W^2$，$W$的随机梯度初始值为100，则$Y$的导为$2W$，假设$weigh{t}_{decay}$为0.1，假设$momentum$为0.9，假设$dampening$为0.5，$l_r$为0.01。第一次更新SGD默认不使用$dampening$。
第一轮：
$g_1=g_1+(w\times weigh{t}_{decay})=200+(100\ast 0.1)=210$
$v_1=v_0\times momentum+g_1\times (1-dampening)=210$
$w=w-l_r\times v_1=100-0.01\ast 210=97.9$
第二轮：
$g_2=g_2+(w\times weigh{t}_{decay})=195.8+(97.9\ast 0.1)=205.59$
$v_2=v_1\times momentum+g_2\times (1-dampening)=210\ast 0.9+205.59\ast (1-0.5)=189+102.795=291.795$
$w=w-l_r\times v_2=97.9-0.01\ast 291.795=97.9-2.92=94.98$

为了验证这一流程的正确项，使用pytorch定义这个函数，并反向传播验证所计算得到的梯度值：

import torch
def test_sgd():
    # 定义一个可学习参数w，初值是100
    w = torch.tensor(data=[100], dtype=torch.float32, requires_grad=True)
    # 定义SGD优化器，nesterov=False，其余参数都有效
    optimizer = torch.optim.SGD(params=[w], lr=0.01, momentum=0.9, dampening=0.5, weight_decay=0.1, nesterov=False)
    # 进行5次优化
    for i in range(5):
        y = w ** 2  # 优化的目标是让w的平方，即y尽可能小
        optimizer.zero_grad()  # 让w的偏导数置零
        y.backward()  # 反向传播，计算w的偏导数
        optimizer.step()  # 根据上述两个公式，计算一个v，然后作用到w
        print('grad=%.2f, w=%.2f' % (w.grad, w.data))  # 查看w的梯度和更新后的值
if __name__=="__main__":
    test_sgd()
'''
输入日志如下：
grad=200.00, w=97.90
grad=195.80, w=94.98
grad=189.96, w=91.36
grad=182.72, w=87.14
grad=174.28, w=82.42
'''
#------------------神经网络模型损失优化器定义---------------------
model = MyModel()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-4)
for epoch in range(1, epochs):
    for i, (inputs, labels) in enumerate(train_loader):
        output= model(inputs)  #---这就是上面的 y=w*2 函数
        loss = criterion(output, labels)  #---损失计算
        optimizer.zero_grad()  #---梯度清零
        loss.backward()   #---误差反向传播
        optimizer.step()   #梯度更新

Adam 优化算法

原理：

模型每次反向传导都会给各个可学习参数$w$计算出一个偏导数$g_t$，用于更新对应的参数$w$。通常偏导数$g_t$不会直接作用到对应的可学习参数$w$上，而是通过优化器做一下处理，得到一个新的值$\widehat{g_t}$，处理过程用函数$F$表示（不同的优化器对应的F的内容不同），即$\widehat{g_t}=F(g_t)$，然后和学习率$l_r$一起用于更新可学习参数$w$，即$w=w-l_r\times \widehat{g_t}$。
在pytorch中，Adam定义为：

torch.optim.Adam(params,
                lr=0.001,
                betas=(0.9, 0.999),
                eps=1e-08,
                weight_decay=0,
                amsgrad=False)

params：模型里需要被更新的可学习参数
lr：学习率
betas：平滑常数${\beta }_1$和${\beta }_2$
eps：$ϵ$非常小的数，预防分母为0
weight-decay：权值(可学习参数)衰减系数，用于修改偏导数：$g_t=g_t+(w\times weigh{t}_{decay})$，其中$g_t$为可学习参数$w$的偏导数。
amsgrad：amsgrad和Adam并无直接关系。
计算过程如下：
初始1：学习率 lr
初始2：平滑常数（或者叫做衰减速率)${\beta }_1,{\beta }_2$，分别用于平滑$m$和$v$。
初始3：可学习参数 $w$
初始4：$m_0=0;v_0=0;t=0$
while 是否进行训练:
训练次数更新：t = t + 1
计算梯度：$g_t$(所有的可学习参数都有自己的梯度，因此$g_t$表示的是全部梯度的集合）
累计梯度：$m_t={\beta }_1\times m_{t-1}+(1-{\beta }_1)\times g_t$(每个导数对应一个m，因此m也是个集合）
累计梯度的平方：$v_t={\beta }_2\times v_{t-1}+(1-\beta 2)\times (g_t{)}^2$(每个导数对应一个v，因此v也是个集合）
偏差纠正$\hat{m}$：$\widehat{m_t}=\frac{m_t}{1-({\beta }_1{)}^t}$
偏差纠正$\hat{v}$：$\widehat{v_t}=\frac{v_t}{1-({\beta }_2{)}^t}$
更新参数$w$：$w=w-l_r\times \frac{\widehat{m_t}}{\sqrt{\widehat{v_t}}+ϵ}$
end while
例：

假设函数$Y=W^2$，$W$的随机梯度初始值为100，则$Y$的导为$2W$，假设$weigh{t}_{decay}$为0.1，假设$betas=({\beta }_1,{\beta }_2)$为(0.9,0.999)，$l_r$为0.01。
第一轮：t=1
$w=100,g_1=2w=200$,$m_1={\beta }_1\times m_0+(1-{\beta }_1)\times g_1=0.9\ast 0+(1-0.9)200=20$
$v_1={\beta }_2\times v_0+(1-\beta 2)\times (g_1{)}^2=0.999\ast 0+(1-0.999)\ast 40000=40$
$\widehat{m_1}=\frac{m_1}{1-({\beta }_1{)}^t}=20/0.1=200$
$\widehat{v_1}=\frac{v_1}{1-({\beta }_2{)}^t}=40000$
$w=w-l_r\times \frac{\widehat{m_t}}{\sqrt{\widehat{v_t}}+ϵ}=100-0.01\ast 1=99.99$
第二轮：t = 2
$w=99.99,g_2=2w=199.98$,$m_2={\beta }_1\times m_1+(1-{\beta }_1)\times g_2=0.9\ast 20+0.1\ast 199.98=37.998$
$v_2={\beta }_2\times v_1+(1-\beta 2)\times (g_2{)}^2=0.999\ast 40+(1-0.999)\ast 199.98\ast 199.98=79.68$
$\widehat{m_2}=\frac{m_2}{1-({\beta }_1{)}^t}=37.998/0.01=3799.8$
$\widehat{v_2}=\frac{v_2}{1-({\beta }_2{)}^t}=79.68/0.000001=79680000$
$w=w-l_r\times \frac{\widehat{m_t}}{\sqrt{\widehat{v_t}}+ϵ}=99.99-0.01\ast 3799.8/8926=99.98$

实践是检验真理的唯一标准：

import torch
def test_sgd():
    # 定义一个可学习参数w，初值是100
    w = torch.tensor(data=[100], dtype=torch.float32, requires_grad=True)

    # 定义SGD优化器，nesterov=False，其余参数都有效
    #optimizer = torch.optim.SGD(params=[w], lr=0.01, momentum=0.9, dampening=0.5, weight_decay=0.1, nesterov=False)
    optimizer = torch.optim.Adam(params=[w],lr=0.01,betas=(0.9, 0.999),eps=1e-08,weight_decay=0.1,amsgrad=False)

    # 进行5次优化
    for i in range(5):
        y = w ** 2  # 优化的目标是让w的平方，即y尽可能小
        optimizer.zero_grad()  # 让w的偏导数置零
        y.backward()  # 反向传播，计算w的偏导数
        optimizer.step()  # 根据上述两个公式，计算一个v，然后作用到w
        print('grad=%.2f, w=%.2f' % (w.grad, w.data))  # 查看w的梯度和更新后的值

if __name__=="__main__":
    test_sgd()
'''
输入日志如下：
grad=200.00, w=99.99
grad=199.98, w=99.98
grad=199.96, w=99.97
grad=199.94, w=99.96
grad=199.92, w=99.95
'''

代码例子来自：https://blog.csdn.net/qq_37541097 非常厉害的一位博主，跟着他的博客和视频学习到很多，再次表示感谢❤❤❤