人工智能的本质：最优化（神经网络优化算法python手写实现）

女爷i 2022-12-12 02:15 101阅读 0赞

人工智能的本质就是最优化。假设把任务比作是一碗饭，  
传统的解决方法，就是根据数学公式，然后一口气吃完饭，如果饭碗小，数学公式还行，如果饭碗大，数学公式能一口吃完饭吗？  
人工智能的本质就是最优化，得益于有很多优化算法，优化算法等于是一口一口吃饭，再大的饭碗,再多的饭，也能干。  
本文以一元线性回归为例，  
通过代码来感受下神经网络的优化算法。

## 一.梯度下降算法SGD ##

梯度下降是一种非常通用的优化算法。  
假设在浓雾下，你迷失在了大山中，你只能感受到自己脚下的坡度，为了最快到达山底，最好的方法就是沿着坡度最陡的地方下山。这就是梯度下降。它计算误差函数关于参数θ 的局部梯度，同时它沿着梯度下降的方向进行下一次迭代，当梯度值为0的时候，就达到误差函数最小值。  
具体来说，开始时，需要指定一个随机的θ ,然后逐渐去改进它，每次变化一小步，每一次都试着降低损失函数，直到算法收敛到一个最小值。  
![20201005102624606.png][]

在梯度下降中一个最重要的参数就是步长，也叫学习率  
如果学习率太小，则需要多次迭代才能达到最小值。  
![20201005102837778.png][]  
如果学习率太大，可能跳过最小值，很难收敛。  
![20201005102942698.png][]

并不是所有的损失函数都是一个V型，有的像山脊等各种不规则地形。如果早早地结束训练可能会陷入局部最小值，所以这时需要指定训练轮数，当轮数过大，才有可能得到全局最小值。

![20201005103705698.png][]

线性目标函数为  
![20201005104229718.png_pic_center][]  
![20201005104258388.png_pic_center][]  
线性回归损失函数为

![20201005104422868.png_pic_center][] 优化函数 ![20201005104504492.png_pic_center][] 对于一元线性回归的优化函数为： ![20201005104550938.png_pic_center][] ![20201005104629820.png][]

import numpy as np
    import matplotlib.pyplot as plt
    
    #定义线性回归
    def model(a, b, x):
        return a*x + b
    
    #损失函数
    def cost_function(a, b, x, y):
        n = 5#5个样本，后面举例的数据为5个样本
        return 0.5/n * (np.square(y-a*x-b)).sum()
    
    #梯度下降
    #梯度下降
    def sgd(a,b,x,y):
        n = 5#5个样本
        alpha = 1e-1
        y_hat = model(a,b,x)#预测值
        da = (1.0/n) * ((y_hat-y)*x).sum()
        db = (1.0/n) * ((y_hat-y).sum())
        a = a - alpha*da
        b = b - alpha*db
        return a, b
    #定义数据 5个样本
    x=np.array([1,2,3,4,5])
    y=np.array([2.1,4.2,5.9,7.8,10.2])
    
    
    
    def train():
        # 初始化参数
        a = np.random.random()
        b = np.random.random()
        n_iterations = 10000 # 轮数
        print('初始值 a,b', a, b)
        for i in range(n_iterations):
            a, b= sgd(a, b,  x, y)
            cost=cost_function(a,b,x,y)
            if np.abs(cost)<0.01:
                break
        return a,b,i
    a,b,i=train()
    print('a,b,i',a,b,i)
    
    y1=np.dot(x,a)+b
    plt.scatter(x,y)
    plt.plot(x,y1,color='red',)
    plt.show()

![20201005140820431.png_pic_center][] ![20201005140839218.png_pic_center][]

梯度下降算法代码  
![20201110145208985.png_pic_center][]  
![20201110145706209.png_pic_center][]  
![20201110150314164.png_pic_center][]

## 二.动量优化Momentum ##

梯度下降算法只是通过直接减去损失函数J(θ)相对于θ的梯度，乘以学习率η来更新权重θ,方程是θ=θ-η∇J(θ)。它不关心早期的梯度是什么，如果局部梯度很小，则会非常缓慢。  
动量优化Momentum很关心之前的梯度，在每次迭代时，它将动量矢量m(乘以学习率β)与局部梯度相加，并通过简单地减去或加上该动量矢量来更新权重。换句话讲，梯度作用于加速度，不作用于速度,人为引入了一个初速度βm。

公式为

![20201005142400578.png_pic_center][] 其中的β类似于摩擦系数，一般取0.9，m为动量。

import numpy as np
    import matplotlib.pyplot as plt
    
    #定义线性回归
    def model(a, b, x):
        return a*x + b
    
    #损失函数
    def cost_function(a, b, x, y):
        n = 5#5个样本，后面举例的数据为5个样本
        return 0.5/n * (np.square(y-a*x-b)).sum()
    
    #动量优化
    def nesterov(a, b, ma, mb, x, y):
        n = 5#5个样本
        alpha = 1e-1
        beta = 0.1
        y_hat = model(a,b,x)
        da = (1.0/n) * ((y_hat-y)*x).sum()
        db = (1.0/n) * ((y_hat-y).sum())
        ma = beta*ma + alpha*da#动量矢量，其中beta*ma 控制速度，alpha*da控制加速度
        mb = beta*mb + alpha*db#动力矢量
        a = a - ma#权重参数更新
        b = b - mb#权重参数更新
        return a, b, ma, mb
    
    #定义数据 5个样本
    x=np.array([1,2,3,4,5])
    y=np.array([2.1,4.2,5.9,7.8,10.2])
    
    
    
    def train():
        # 初始化参数
        a = np.random.random()
        b = np.random.random()
    
        n_iterations = 10000 # 轮数
        print('初始值 a,b', a, b)
        for i in range(n_iterations):
            a, b, ma, mb = nesterov(a, b, 0.9, 0.9, x, y)
            cost=cost_function(a,b,x,y)
            if np.abs(cost)<1:
                break
        return a,b,i
    a,b,i=train()
    print('a,b,i',a,b,i)
    
    y1=np.dot(x,a)+b
    plt.scatter(x,y)
    plt.plot(x,y1,color='red',)
    plt.show()

> ma = beta*ma + alpha*da\#动量矢量，其中beta*ma 控制速度，alpha*da控制加速度  
> 合理选择速度  
> 数据量大还行，数据量小我感觉效果不如梯度下降

![20201005142222496.png_pic_center][] ![20201005142151723.png_pic_center][]

## 三.AdaGrad ##

在图中，蓝色的为梯度下降，它朝着梯度最大的方向快速前进，而不是朝着全局最后前进。黄色的是AdaGrad，它指向的是全局最优。它的办法是缩小（scaling down）最大的梯度参数。  
![20201005142940504.png_pic_center][]

![20201005143414387.png_pic_center][]

对频繁出现的参数采用小的步长（因为sa叠加的多），对频繁出现的参数采用大的步长（sa叠加次数少）

import numpy as np
    import matplotlib.pyplot as plt
    
    #定义线性回归
    def model(a, b, x):
        return a*x + b
    
    #损失函数
    def cost_function(a, b, x, y):
        n = 5#5个样本，后面举例的数据为5个样本
        return 0.5/n * (np.square(y-a*x-b)).sum()
    
    #ada_grad
    def ada_grad(a,b,sa, sb, x,y):
        epsilon=1e-10
        n = 5#5个样本
        alpha = 1e-1
        y_hat = model(a,b,x)
        da = (1.0/n) * ((y_hat-y)*x).sum()
        db = (1.0/n) * ((y_hat-y).sum())
        sa=sa+da*da + epsilon
        sb=sb+db*db + epsilon
        # da,db随着轮数变小，sa,sb大趋势随着轮数变大
        a = a - alpha*da / np.sqrt(sa)
        b = b - alpha*db / np.sqrt(sb)
        return a, b, sa, sb
    
    
    #定义数据 5个样本
    x=np.array([1,2,3,4,5])
    y=np.array([2.1,4.2,5.9,7.8,10.2])
    
    
    
    def train():
        # 初始化参数
        a = np.random.random()
        b = np.random.random()
    
        n_iterations = 10000 # 轮数
        print('初始值 a,b', a, b)
        for i in range(n_iterations):
            a, b, sa, sb = ada_grad(a, b, 0.9, 0.9, x, y)
            cost=cost_function(a,b,x,y)
            if np.abs(cost)<0.1:
                break
        return a,b,i,sa,sb
    a,b,i,sa,sb=train()
    print('sa,sb',sa,sb)
    print('a,b,i',a,b,i)
    
    y1=np.dot(x,a)+b
    plt.scatter(x,y)
    plt.plot(x,y1,color='red',)
    plt.show()

解析：

> sa=sa+da*da + epsilon，sb=sb+db*db + epsilon 会随着轮数越来越大，然后导致学习率1/ np.sqrt(sa) 越来越小，权重更新得越慢。即开始时学习率比较大，后面学习率较小，学习率一直在变，是一种自适应学习率。

![20201005144502513.png_pic_center][] ![20201005144529379.png_pic_center][]

## 四.RMSProp ##

尽管AdaGrad的速度变慢了一些，并且从未收敛到全局最优。  
AdaGrad 权重更新,学习率累积的时训练以来的所以梯度(sa累积的是所有的da，sb累积的是所有的db）

> AdaGrad 中  
> sa=sa+da*da + epsilon  
> sb=sb+db*db + epsilon  
> a = a - alpha*da / np.sqrt(sa)  
> b = b - alpha*db / np.sqrt(sb)  
> da,db总体上会随着轮数越来越小，，sa,sb随着轮数变大  
> 1/ np.sqrt(sa)，1/ np.sqrt(sb) 学习率随着轮数变小，容易陷入局部最小值，（因为当它局部最小值附近时，da小，学习率也小，很难爬出小凹谷）

RMSProp 通过仅累积最近迭代的（da,db）的梯度来修正这个问题，它通过在第一步中使用指数衰减来实现。  
![20201005145745771.png_pic_center][]  
相比于AdaGrad ,RMSProp就是在AdaGrad基础上减缓学习率\[1 / np.sqrt(sa) 和1/ np.sqrt(sb) \]的变化。

import numpy as np
    import matplotlib.pyplot as plt
    
    #定义线性回归
    def model(a, b, x):
        return a*x + b
    
    #损失函数
    def cost_function(a, b, x, y):
        n = 5#5个样本，后面举例的数据为5个样本
        return 0.5/n * (np.square(y-a*x-b)).sum()
    
    #rmsprop
    def rmsprop(a,b,sa, sb, x,y):
        epsilon=1e-10
        beta = 0.9
        n = 5#本文5个样本数据
        alpha = 1e-1
        y_hat = model(a,b,x)
        da = (1.0/n) * ((y_hat-y)*x).sum()
        db = (1.0/n) * ((y_hat-y).sum())
        sa=beta*sa+(1-beta)*da*da + epsilon
        sb=beta*sb+(1-beta)*db*db + epsilon
        #da,db会随着轮数越来越小，sa,sb，大趋势变小
        a = a - alpha*da / np.sqrt(sa)
        b = b - alpha*db / np.sqrt(sb)
        return a, b, sa, sb
    
    
    #定义数据 5个样本
    x=np.array([1,2,3,4,5])
    y=np.array([2.1,4.2,5.9,7.8,10.2])
    
    
    
    def train():
        # 初始化参数
        a = np.random.random()
        b = np.random.random()
    
        n_iterations = 10000 # 轮数
        print('初始值 a,b', a, b)
        for i in range(n_iterations):
            a, b, sa, sb = rmsprop(a, b, 0.9, 0.9, x, y)
            cost=cost_function(a,b,x,y)
            if np.abs(cost)<0.1:
                break
        return a,b,i,sa,sb
    a,b,i,sa,sb=train()
    print('sa,sb',sa,sb)
    print('a,b,i',a,b,i)
    
    y1=np.dot(x,a)+b
    plt.scatter(x,y)
    plt.plot(x,y1,color='red',)
    plt.show()

解析

> sa=beta*sa+(1-beta)dada + epsilon. beta=0.9,现在=0.9以前的+0.1的现在梯度。  
> sa=beta*sa+(1-beta)*da*da + epsilon  
> sb=beta*sb+(1-beta)dbdb + epsilon  
> \#da,db总体上会随着轮数越来越小，sa,sb，大趋势变小。学习率1 / np.sqrt(sa)变大  
> a = a - alpha*da / np.sqrt(sa)  
> b = b - alpha\*db / np.sqrt(sb)  
> 当处于局部最小值附近时，学习率足够大，容易爬出小凹谷。

![20201005150803761.png_pic_center][] ![202010051508440.png_pic_center][]

## 五.Adam ##

简而言之，Adam使用动量和自适应学习率来加快收敛速度。

Momentum (动量)  
在解释动量时，研究人员和从业人员都喜欢使用比球滚下山坡而向局部极小值更快滚动的类比法，但从本质上讲，我们必须知道的是，动量算法在相关方向上加速了随机梯度下降，如 以及抑制振荡。

为了将动量引入我们的神经网络，我们将时间元素添加到过去时间步长的更新向量中，并将其添加到当前更新向量中。 这样可以使球的动量增加一定程度。 可以用数学表示，如下图所示。  
![20201005152249278.png_pic_center][]

动量更新方法，其中θ是网络的参数，即权重，偏差或激活值，η是学习率，J是我们要优化的目标函数，γ是常数项，也称为动量。 Vt-1（注意t-1是下标）是过去的时间步长，而Vt（注意t是下标）是当前的时间步长。

动量项γ通常被初始化为0.9

适应性学习率  
通过将学习率降低到我们在AdaGrad，RMSprop，Adam和AdaDelta中看到的预定义时间表(schedule)，可以将自适应学习率视为训练阶段的学习率调整。这也称为学习率时间表 有关该主题的更多详细信息  
在不花太多时间介绍AdaGrad优化算法的情况下，这里将解释RMSprop及其在AdaGrad上的改进以及如何随时间改变学习率。

RMSprop（即均方根传播）其目的是解决AdaGrad的学习率急剧下降的问题。 简而言之，RMSprop更改学习速率的速度比AdaGrad慢，但是RMSprop仍可从AdaGrad（更快的收敛速度）中受益-数学表达式请参见下图  
![20201005152323423.png_pic_center][]

E \[g²\] t的第一个方程是平方梯度的指数衰减平均值。 Geoff Hinton建议将γ设置为0.9，而学习率η的默认值为0.001

这可以使学习率随着时间的流逝而适应，这很重要，因为这种现象也存在于Adam中。 当我们将两者（Momentum 和RMSprop）放在一起时，我们得到了Adam

![20201005152618919.png_pic_center][]

import numpy as np
    import matplotlib.pyplot as plt
    
    #定义线性回归
    def model(a, b, x):
        return a*x + b
    
    #损失函数
    def cost_function(a, b, x, y):
        n = 5#5个样本，后面举例的数据为5个样本
        return 0.5/n * (np.square(y-a*x-b)).sum()
    
    #Adam
    def adam(a, b, ma, mb, sa, sb, t, x, y):
        epsilon = 1e-10
        beta1 = 0.9
        beta2 = 0.9
        n = 5#5个样本
        alpha = 1e-1
        y_hat = model(a, b, x)
        da = (1.0 / n) * ((y_hat - y) * x).sum()#计算梯度a
        db = (1.0 / n) * ((y_hat - y).sum())#计算梯度b
        ma = beta1 * ma - (1 - beta1) * da#计算动量ma
        mb = beta1 * mb - (1 - beta1) * db#计算动量mb
        sa = beta2 * sa + (1 - beta2) * da * da#自适应sa
        sb = beta2 * sb + (1 - beta2) * db * db#自适应sb
        ma_hat = ma / (1 - beta1 ** t)#动量添加指数
        mb_hat = mb / (1 - beta1 ** t)#动量添加指数
        sa_hat = sa / (1 - beta2 ** t)#自适应添加指数
        sb_hat = sb / (1 - beta2 ** t)#自适应添加指数
    
        a = a + alpha * ma_hat / np.sqrt(sa_hat)#权重更新
        b = b + alpha * mb_hat / np.sqrt(sb_hat)
    
        return a, b, ma, mb, sa, sb
    
    
    #定义数据 5个样本
    x=np.array([1,2,3,4,5])
    y=np.array([2.1,4.2,5.9,7.8,10.2])
    
    
    
    def train():
        # 初始化参数
        a = np.random.random()
        b = np.random.random()
    
        n_iterations = 10000 # 轮数
        print('初始值 a,b', a, b)
        for i in range(n_iterations):
            a, b, ma,mb,sa, sb = adam(a, b, 0.05, 0.05, 0.9,0.9,1000,x, y)
            cost=cost_function(a,b,x,y)
            if np.abs(cost)<0.1:
                break
        return a,b,i,sa,sb
    a,b,i,sa,sb=train()
    print('sa,sb',sa,sb)
    print('a,b,i',a,b,i)
    
    y1=np.dot(x,a)+b
    plt.scatter(x,y)
    plt.plot(x,y1,color='red',)
    plt.show()

解析

> adam(a, b, ma, mb, sa, sb, t, x, y):  
> 中的ma,mb控制初速度，要不要一来就梯度更新得很快（数据量大时可以考虑较大的ma,mb） 做学习率的分子  
> sa,sb控制权重更新速度，越大更新越慢，做学习率的分母

![20201005153757652.png_pic_center][] ![20201005153824785.png_pic_center][]

本文主要参考文献如下，感谢大佬。  
1.[Adam 优化算法详解][Adam]

2.https://blog.csdn.net/juwikuang/article/details/108039680

、、、、、、、、、、、、、、、、、、、、、、、、、、、、

常用优化算法就这些，还有其他的未列举。

我也感觉似懂非懂，唉。  
![在这里插入图片描述][20201005154622419.jpg_pic_center]

电气工程的计算机萌新：余登武。  
写博文不容易，如果你觉得本文对你有用，请点个赞支持下，谢谢。  
![在这里插入图片描述][20201005161017795.gif_pic_center]

[20201005102624606.png]: /images/20221123/bff50bad48aa4851bff4a9bb066fcdda.png
[20201005102837778.png]: /images/20221123/3b5751fd784246febf1a9e4581a59cfd.png
[20201005102942698.png]: /images/20221123/9372e0220ade4d3bac33cb039039970d.png
[20201005103705698.png]: /images/20221123/c5e4a493fdda40a0b8c856ade50dbf1f.png
[20201005104229718.png_pic_center]: /images/20221123/75571f965c344d4c9c40a5ef90dba7aa.png
[20201005104258388.png_pic_center]: /images/20221123/7fa17c95b1594cedba91a82665c5fa82.png
[20201005104422868.png_pic_center]: https://img-blog.csdnimg.cn/20201005104422868.png#pic_center
[20201005104504492.png_pic_center]: https://img-blog.csdnimg.cn/20201005104504492.png#pic_center
[20201005104550938.png_pic_center]: https://img-blog.csdnimg.cn/20201005104550938.png#pic_center
[20201005104629820.png]: /images/20221123/e6339e0c3079410a878eec28404637e4.png
[20201005140820431.png_pic_center]: https://img-blog.csdnimg.cn/20201005140820431.png#pic_center
[20201005140839218.png_pic_center]: /images/20221123/f167d0127136436f89d4f8db93ca6379.png
[20201110145208985.png_pic_center]: /images/20221123/01261fc405554caf84153c193b0e76dd.png
[20201110145706209.png_pic_center]: /images/20221123/4ea6ebdd926742d1a3bcec3e2ad87e93.png
[20201110150314164.png_pic_center]: /images/20221123/53b8acfc27a143e08b3bf4ffde61004b.png
[20201005142400578.png_pic_center]: /images/20221123/b09c2f34a0864b1b81a8bb8453173027.png
[20201005142222496.png_pic_center]: https://img-blog.csdnimg.cn/20201005142222496.png#pic_center
[20201005142151723.png_pic_center]: /images/20221123/20e68d858e4e45e7b66dd15b5bf4445f.png
[20201005142940504.png_pic_center]: /images/20221123/3936f2d0a4444a6a958737a94826f528.png
[20201005143414387.png_pic_center]: /images/20221123/24132f16ed354bcdbf57de4f9df6c67a.png
[20201005144502513.png_pic_center]: https://img-blog.csdnimg.cn/20201005144502513.png#pic_center
[20201005144529379.png_pic_center]: /images/20221123/0e9100447f7f45b1afb8250c81107e53.png
[20201005145745771.png_pic_center]: /images/20221123/0426fce316664ea5b0332aa7f8154fde.png
[20201005150803761.png_pic_center]: https://img-blog.csdnimg.cn/20201005150803761.png#pic_center
[202010051508440.png_pic_center]: /images/20221123/9c4c52e262bb4e6bbd6091b5c20f26bb.png
[20201005152249278.png_pic_center]: /images/20221123/46ae71b7e29a41b5966c6868a991e267.png
[20201005152323423.png_pic_center]: /images/20221123/b58e0a8053744559bef173b24b69561c.png
[20201005152618919.png_pic_center]: /images/20221123/b4048d61bbbc496db671b54f82539eb9.png
[20201005153757652.png_pic_center]: https://img-blog.csdnimg.cn/20201005153757652.png?#pic_center
[20201005153824785.png_pic_center]: /images/20221123/7193d6f79b824563ae43f356826d3ceb.png
[Adam]: https://blog.csdn.net/deephub/article/details/106563023?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param
[20201005154622419.jpg_pic_center]: /images/20221123/1704095ae97744eca5cb6863fb4b1c0b.png
[20201005161017795.gif_pic_center]: /images/20221123/3e6c9d60b0574730bc61e31a5a89b5c7.png