简单函数模拟优化器

于 2022-09-16 11:15:49 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： 算法 python编程 人工智能 文章标签： python 机器学习 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43828944/article/details/126872238
版权

简单函数模拟优化器

优化器是引导神经网络更新参数的工具，深度学习在计算出损失函数之后，需要利用优化器来进行反向传播，完成网络参数的更新。在这个过程中，便会使用到优化器，优化器可以利用计算机数值计算的方法来获取损失函数最小的网络参数。
接下来，我们利用简单的数学模型构建一个模拟的优化器。

首先，构建相关函数

import numpy as np
import matplotlib.pyplot as plt

#打印结果
def print_info( k, x_0, y_0, f2):
    print('迭代次数：{}'.format(k))
    print('极值点：【x_0】：{} 【y_0】：{}'.format(x_0, y_0))
    print('函数的极值：{}'.format(f2))

#绘制效果图
def draw_process(w):
    X = np.arange(0, 1.5, 0.01)  # 起始、终止、步长
    Y = np.arange(-1, 1, 0.01)
    [x, y] = np.meshgrid(X, Y)  # 将x中每一个数据和y中每一个数据组合生成很多点,然后将这些点的x坐标放入到X中,y坐标放入Y中,并且相应位置是对应的
    f = x ** 3 - y ** 3 + 3 * x ** 2 + 3 * y ** 2 - 9 * x
    plt.contour(x, y, f, 20)
    plt.plot(w[:, 0], w[:, 1], 'g*', w[:, 0], w[:, 1])
    plt.show()

#生成函数
def fn(x, y):
    return x ** 3 - y ** 3 + 3 * x ** 2 + 3 * y ** 2 - 9 * x

#对x求偏导
def dx(x):
    return 3 * x ** 2 + 6 * x - 9

#对y求偏导
def dy(y):
    return - 3 * y ** 2 + 6 * y

"""
    函数: f(x) = x**3 - y**3 + 3 * x**2 + 3 * y**2 - 9 * x
    最优解: x = 1, y = 0
    极小值: f(x,y) = -5
"""

其次，构建各种优化器函数：

1、Momentum（使用动量的随机梯度下降)

SGD每次都会在当前位置沿梯度负方向更新，不会考虑先前的梯度方向及大小；Momentum则是通过引入一个新的变量v去积累之前的梯度，从来可以加速网络的学习过程，也就是说如果当前时刻的梯度方向与之前时刻累计的梯度方向一致，那么梯度会加强，梯度下降的幅度更大，反之，梯度下降的幅度会降低。

Monmentum涉及到的函数与参数：

生成函数：z = f(x,y)
损失函数：Loss()
初始参数：weight
初始速度：v
学习率：lr
动量参数：alpha
误差阈值：epsilon

大致流程：

(1)从训练集中采集把后含m个样本{x1,······,xm}的小批量，对应目标yi。
(2)计算梯度估计：
在这里插入图片描述
(3)计算速度更新：
在这里插入图片描述
(4)应用更新：
在这里插入图片描述
(5)重复执行（1）到（4），直到达到终止条件为止，终止条件一般是迭代次数达到iters或者预测值与真实值之间的误差小于误差阈值epsilon。

模拟优化器的具体代码：

#使用动量的随机梯度下降
def momentum(x_0,y_0):
    f1, f2 = fn(x_0, y_0), 0 # f1为预测值，f2为真实值（目标值）
    w = np.array([x_0, y_0])  # 每次迭代后的函数值，用于绘制梯度曲线
    k = 0  # 当前迭代次数

    lr = 0.01 #学习率
    alpha = 0.9 #动量参数
    iters = 100000 #迭代次数上限
    epsilon = 1e-10 #误差阈值
    v = 0.0 #速度

    while True:
        if abs(f1 - f2) <= epsilon or k > iters:
            break

        f1 = fn(x_0, y_0)
        g = np.array([dx(x_0), dy(y_0)])
        v = alpha * v - lr * g  # 速度更新
        x_0, y_0 = np.array([x_0, y_0]) + v  # 应用更新

        f2 = fn(x_0, y_0)

        w = np.vstack((w, (x_0, y_0)))
        k += 1
    print_info(k, x_0, y_0, f2)
    draw_process(w)

momentum(x_0=0.5,y_0=0.5)

迭代次数：195
极值点：【x_0】：0.9999837364060098 【y_0】：-1.2415641058597648e-05
函数的极值：-4.999999997950532

效果图
在这里插入图片描述

2、AdaGrad（自适应梯度下降）

针对SGD与Momentum存在的问题，AdaGrad（Adaptive Gradient）是在SGD基础上引入二阶动量，能够对不同的参数使用不同的学习率进行更新，对于梯度较大的参数，那么学习率就会变得较小；而对于梯度较小的参数，那么学习率就会变得较大，这样就会使在陡峭的区域下降速度快，平缓的区域下降速度慢。

AdaGrad涉及到的函数与参数：

生成函数：z = f(x,y)
损失函数：Loss()
初始参数：weight
梯度累计变量：r (伽马）
学习率：lr
小常数：delta，（为了数值稳定，一般设置为10^-7）
误差阈值：epsilon

大致流程：

初始化累计变量 r = 0
(1)从训练集中采集把后含m个样本{x1,······,xm}的小批量，对应目标yi。
(2)计算梯度估计：
在这里插入图片描述
(3)累计平方梯度：
在这里插入图片描述
(4)计算参数更新：
在这里插入图片描述
(5)应用更新：
在这里插入图片描述
(5)重复执行（1）到（4），直到达到终止条件为止，终止条件一般是迭代次数达到iters或者预测值与真实值之间的误差小于误差阈值epsilon。

模拟优化器的具体代码：

##使用学习率自适应的随机梯度下降
def AdaGrad(x_0,y_0):
    f1, f2 = fn(x_0, y_0), 0 # f1为预测值，f2为真实值（目标值）
    w = np.array([x_0, y_0])  # 每次迭代后的函数值，用于绘制梯度曲线
    k = 0  # 当前迭代次数

    lr = 0.01 #学习率
    delta = 1e-7 #小常数
    iters = 100000 #迭代次数上限
    epsilon = 1e-10 #误差阈值
    r = 0.0 #梯度累计变量

    while True:
        if abs(f1 - f2) <= epsilon or k > iters:
            break

        f1 = fn(x_0, y_0)
        g = np.array([dx(x_0), dy(y_0)])
        r = r + np.dot(g,g)
        #np.dot(a, b), 其中a为一维的向量，b为一维的向量，这里a和b都是np.ndarray类型的（一维的所以是向量叉乘）
        #两个不共线的向量叉乘的结果是与这两个向量所在平面垂直的一个向量（外积），两个向量点积的结果是一个数值（内积）。

        delta_weight = np.dot(-lr / (delta + pow(r, 1 / 2)), g) #参数更新
        x_0, y_0 = np.array([x_0, y_0]) + delta_weight #应用更新

        f2 = fn(x_0, y_0)

        w = np.vstack((w, (x_0, y_0)))
        k += 1
    print_info(k, x_0, y_0, f2)
    draw_process(w)

AdaGrad(x_0=0.5,y_0=0.5)

迭代次数：13691
极值点：【x_0】：0.999999963104632 【y_0】：0.00016986797379206335
函数的极值：-4.999999913439508

效果图
在这里插入图片描述

3、RMSProp

RMSProp算法修改AdaGrad以在非凸设定下效果更好，改变梯度积累为指数加权的移动平均。Adagrad旨在应用于图问题是快速收敛。当应用于非凸函数训练神经网络时，学习轨迹可能穿过了很多不同的结构，最后到达一个局部是非碗区域。AdaGrad根据平方梯度的整个历史收缩学习率，可能使得学习率在达到这样的凸结构前就变得太小了。
RMSProp使用指数衰减平均一丢弃遥远过去的历史，使其能够在找到凸碗结构后快速收敛，它就像一个初始化与该碗状结构的AdaGrad算法实例。

RMSProp涉及到的函数与参数：

生成函数：z = f(x,y)
损失函数：Loss()
初始参数：weight
梯度累计变量：r (伽马）
学习率：lr
衰减速率：ρ （代码里我们那就用p表示）
小常数：delta，（δ，为了数值稳定，建议默认为为10^-6）
误差阈值：epsilon （ε）

大致流程：

初始化累计变量 r = 0
(1)从训练集中采集把后含m个样本{x1,······,xm}的小批量，对应目标yi。
(2)计算梯度估计：
在这里插入图片描述
(3)累计平方梯度：
在这里插入图片描述
(4)计算参数更新：
在这里插入图片描述
(5)应用更新：
在这里插入图片描述
(5)重复执行（1）到（4），直到达到终止条件为止，终止条件一般是迭代次数达到iters或者预测值与真实值之间的误差小于误差阈值epsilon。

模拟优化器的具体代码：

#使用RMSProp的随机梯度下降
def RMSProp(x_0,y_0):
    f1, f2 = fn(x_0, y_0), 0 # f1为预测值，f2为真实值（目标值）
    w = np.array([x_0, y_0])  # 每次迭代后的函数值，用于绘制梯度曲线
    k = 0  # 当前迭代次数

    lr = 0.01 #学习率
    delta = 1e-6 #小常数
    p = 0.5  # 衰减速率
    iters = 100000 #迭代次数上限
    epsilon = 1e-10 #误差阈值
    r = 0.0 #梯度累计变量

    while True:
        if abs(f1 - f2) <= epsilon or k > iters:
            break

        f1 = fn(x_0, y_0)
        g = np.array([dx(x_0), dy(y_0)])
        r = p * r + (1 - p) * np.dot(g,g)
        #np.dot(a, b), 其中a为一维的向量，b为一维的向量，这里a和b都是np.ndarray类型的（一维的所以是向量叉乘）
        #两个不共线的向量叉乘的结果是与这两个向量所在平面垂直的一个向量（外积），两个向量点积的结果是一个数值（内积）。

        delta_weight = np.dot(-lr / pow(delta + r, 1 / 2), g) # 参数更新
        x_0, y_0 = np.array([x_0, y_0]) + delta_weight #应用更新

        f2 = fn(x_0, y_0)

        w = np.vstack((w, (x_0, y_0)))
        k += 1
    print_info(k, x_0, y_0, f2)
    draw_process(w)

RMSProp(x_0=0.5,y_0=0.5)

迭代次数：100001
极值点：【x_0】：1.0049930572293455 【y_0】：0.0
函数的极值：-4.999850291797012

效果图
在这里插入图片描述

很明显，RMSProp迭代的时间更久了。

4、Adam (Adaptive moments）

Adam是另一种学习率自适应的优化算法。

Adam是将Momentum与RMSProp结合起来的一种算法，引入了Momentum的一阶动量来累计梯度与RMSProp的二阶动量可以使得收敛速度快的同时使得波动幅度小，然后在此基础上增加了两个修正项，能够实现参数自新。

Adam优化器具有以下优点：

  1. 实现简单，计算高效，对内存需求少
  2. 参数的更新不受梯度的伸缩变换影响
  3. 超参数具有很好的解释性，且通常无需调整或仅需很少的微调
  4. 更新的步长能够被限制在大致的范围内（初始学习率）
  5. 能自然地实现步长退火过程（自动调整学习率）
  6. 很适合应用于大规模的数据及参数的场景
  7. 适用于不稳定目标函数
  8. 适用于梯度稀疏或梯度存在很大噪声的问题

Adam涉及到的函数与参数：

生成函数：z = f(x,y)
损失函数：Loss()
初始参数：weight
梯度累计变量：s，r (伽马）
学习率：lr （步长，建议默认为0.001）
矩估计衰减速率：ρ1和ρ2在区间[0,1)内。（建议默认为：分别为0.9和0.999） （代码里我们暂用p1与p2表示）
小常数：delta，（δ，为了数值稳定，建议默认为为10^-8）
误差阈值：epsilon （ε）

大致流程：

初始化一阶和二阶矩变量 s = 0，r = 0
初始化时间步 t = 0
(1)从训练集中采集把后含m个样本{x1,······,xm}的小批量，对应目标yi。
(2)计算梯度估计：
在这里插入图片描述
(3)更新有偏一阶矩估计：
在这里插入图片描述
(4)更新有偏二阶矩估计：
在这里插入图片描述
(5)修正一阶矩的偏差：
在这里插入图片描述
(6)修正一阶矩的偏差：
在这里插入图片描述
(7)计算参数更新：
在这里插入图片描述
(8)应用更新：
在这里插入图片描述
(5)重复执行（1）到（4），直到达到终止条件为止，终止条件一般是迭代次数达到iters或者预测值与真实值之间的误差小于误差阈值epsilon。

模拟优化器的具体代码：

#使用动量的随机梯度下降
def Adam(x_0,y_0):
    f1, f2 = fn(x_0, y_0), 0 # f1为预测值，f2为真实值（目标值）
    w = np.array([x_0, y_0])  # 每次迭代后的函数值，用于绘制梯度曲线
    k = 0  # 当前迭代次数

    lr = 0.001 # 学习率
    delta = 1e-8 # 小常数
    iters = 100000 # 迭代次数上限
    epsilon = 1e-10 # 误差阈值

    p1 = 0.9  # 一阶矩估计指数衰减速率
    p2 = 0.999  # 二阶矩估计指数衰减速率
    s = 0  # 一阶矩估计累计平方梯度（一阶矩变量）
    r = 0  # 二阶矩估计累计平方梯度（二阶矩变量）
    t = 0  # 初始化时间步

    while True:
        if abs(f1 - f2) <= epsilon or k > iters:
            break

        f1 = fn(x_0, y_0)
        g = np.array([dx(x_0), dy(y_0)])

        t = t + 1
        s = p1 * s + (1 - p1) * g
        r = p2 * r + np.dot((1 - p2) * g, g)
        # np.dot(a, b), 其中a为一维的向量，b为一维的向量，这里a和b都是np.ndarray类型的（一维的所以是向量叉乘）
        # 两个不共线的向量叉乘的结果是与这两个向量所在平面垂直的一个向量（外积），两个向量点积的结果是一个数值（内积）。

        s1 = s / (1 - pow(p1, t))  # s1为修正后的一阶矩偏差
        r1 = r / (1 - pow(p2, t))  # r1为修正后的二阶矩偏差

        delta_weight = (-lr * s1) / (pow(r1, 1 / 2) + delta)  # 参数更新
        x_0, y_0 = np.array([x_0, y_0]) + delta_weight  # 应用更新

        f2 = fn(x_0, y_0)

        w = np.vstack((w, (x_0, y_0)))
        k += 1
    print_info(k, x_0, y_0, f2)
    draw_process(w)

Adam(x_0=0.5,y_0=0.5)

迭代次数：2784
极值点：【x_0】：0.9999999989212892 【y_0】：4.760876046908952e-05
函数的极值：-4.9999999932003245

效果图
在这里插入图片描述

很明显，Adam迭代得更快了。

FPGA中国创新中心
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
博客
ZC-CLS381RGB颜色识别+8x8点阵指示（完）
10-17 3945
基于FPGA的ZC-CLS381RGB颜色识别+8x8点阵指示设计
博客
ZC-CLS381RGB颜色识别+8x8点阵指示——WS2812点阵驱动（中）
10-17 4647
基于FPGA的ZC-CLS381RGB颜色识别+8x8点阵指示设计
博客
基于双端口RAM的乒乓操作测试
08-04 1107
基于双端口RAM的乒乓操作测试
博客
基于SDRAM的串口回环测试
07-25 1072
基于SDRAM的串口回环测试
博客
VGA显示彩色方块测试
07-20 1154
VGA显示彩色方块测试
博客
基于异步FIFO的串口回环测试
07-19 1535
基于异步FIFO的串口回环测试
博客
ZC-CLS381RGB颜色识别+8x8点阵指示——配置颜色识别寄存器组（上）
06-07 6774
基于FPGA的ZC-CLS381RGB颜色识别+8x8点阵指示设计
博客
RGB转YCbCr——Python(1)
04-09 1120
《基于MATLAB与FPGA的图像处理教程》
博客
PAJ7620U2手势识别——读取手势数据寄存器数据与LED指示(完)
04-09 3884
PAJ7620U2手势识别——读取手势数据寄存器数据与LED显示(完)
博客
PAJ7620U2手势识别——配置手势数据寄存器(6)
04-07 2097
PAJ7620U2手势识别——配置手势数据寄存器(6)
博客
PAJ7620U2手势识别——配置寄存器组(5)
04-07 1898
PAJ7620U2手势识别——配置寄存器组(5)
博客
PAJ7620U2手势识别——读取0x00寄存器数据(4)
04-01 2258
PAJ7620U2手势识别——读取0x00寄存器数据(4)
博客
口罩检测——模型推理(5)
03-31 1879
口罩检测，模型推理
博客
口罩检测——模型转换(4)
03-31 1904
口罩检测，paddlepaddle模型转换为OpenVINO模型。
博客
口罩检测——模型训练(3)
03-31 2272
口罩检测ppyoloe模型训练
博客
口罩检测——数据准备(2)
03-29 2790
数据准备
博客
口罩检测——环境准备(1)
03-28 3682
ppyoloe口罩检测+openvino推理，环境准备。
博客
PAJ7620U2手势识别——配置0x00寄存器(3)
03-28 2411
PAJ7620U2手势识别——配置0x00寄存器实现
博客
PAJ7620U2手势识别——激活BANK0(2)
03-28 2647
基于FPGA的PAJ7620手势识别——激活BANK0实现
博客
PAJ7620U2手势识别——唤醒操作(1)
03-27 5082
基于FPGA的PAJ7620手势识别——唤醒操作实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值