【tensorflow框架神经网络实现鸢尾花分类—优化器】

文章目录

  • 1、前言
  • 2、神经网络参数优化器
    • 2.1、SGD
    • 2.2、SGDM
    • 2.3、Adagrad
    • 2.4、RMSProp
    • 2.5、Adam
  • 3、实验对比不同优化器
  • 4、结果对比

1、前言

  • 此前,在【tensorflow框架神经网络实现鸢尾花分类】一文中使用梯度下降算法SGD,对权重 w w w和偏置 b b b进行更新,本篇将对比不同优化器的训练效果

2、神经网络参数优化器

  • 待优化参数 w w w,损失函数 l o s s loss loss,学习了 l r lr lr,每次迭代一个 b a t c h batch batch t t t表示当前 b a t c h batch batch迭代的总次数:
    • 计算t时刻损失函数关于当前参数的梯度 g t = ∇ l o s s = ∂ l o s s ∂ w t g_t=\nabla loss=\frac{\partial loss}{\partial w_t} gt=loss=wtloss
    • 计算 t t t时刻的一阶动量 m t m_t mt和二阶动量 V t V_t Vt
    • 计算 t t t时刻的下降梯度: η t = l r ∗ m t V t η_t=lr*\frac{m_t}{\sqrt{V_t}} ηt=lrVt mt
    • w t + 1 = w t − η t = w t − l r ∗ m t V t w_{t+1}=w_t-η_t=w_t-lr*\frac{m_t}{\sqrt{V_t}} wt+1=wtηt=wtlrVt mt

  • 一阶动量:与梯度相关的函数
  • 二阶动量:与梯度平方相关的函数

2.1、SGD

  • 随机梯度下降(stochastic gradient descent,SGD),无动量momentum,常用的梯度下降法。

m t = g t m_t=g_t mt=gt
V t = 1 V_t=1 Vt=1
η t = l r ∗ m t V t = l r ∗ g t η_t=lr*\frac{m_t}{\sqrt{V_t}}=lr*g_t ηt=lrVt mt=lrgt
w t + 1 = w t − η t = w t − l r ∗ m t V t = w t − l r ∗ g t w_{t+1}=w_{t}-η_{t}=w_t-lr*\frac{m_t}{\sqrt{V_t}}=w_t-lr*g_t wt+1=wtηt=wtlrVt mt=wtlrgt


w t + 1 = w t − l r ∗ ∂ l o s s ∂ w t w_{t+1}=w_t-lr*\frac{\partial loss}{\partial w_t} wt+1=wtlrwtloss

  • 代码
# sgd
w.assign_sub(lr * grads[0]) # 参数w自更新
b.assign_sub(lr * grads[1]) # 参数b自更新

2.2、SGDM

  • SGDM(SGD with momentum,SGDM),在SGD的基础上增加一阶动量。
  • m t − 1 m_{t-1} mt1表示上一时刻的一阶动量,并且上一时刻的一阶动量在公式中占主导,经验值是0.9。

m t = β ∗ m t − 1 + ( 1 − β ) ∗ g t m_t=β*m_{t-1} + (1-β)*g_t mt=βmt1+(1β)gt
V t = 1 V_t=1 Vt=1
η t = l r ∗ m t V t = l r ∗ m t = l r ∗ ( β ∗ m t − 1 + ( 1 − β ) ∗ g t ) η_t=lr*\frac{m_t}{\sqrt{V_t}}=lr*m_t=lr*(β*m_{t-1} + (1-β)*g_t) ηt=lrVt mt=lrmt=lr(βmt1+(1β)gt)
w t + 1 = w t − η t = w t − l r ∗ m t V t = w t − l r ∗ ( β ∗ m t − 1 + ( 1 − β ) ∗ g t ) w_{t+1}=w_{t}-η_{t}=w_t-lr*\frac{m_t}{\sqrt{V_t}}=w_t-lr*(β*m_{t-1} + (1-β)*g_t) wt+1=wtηt=wtlrVt mt=wtlr(βmt1+(1β)gt)

  • 代码
m_w, m_b = 0, 0
beta = 0.9
# sgd-momentun  
m_w = beta * m_w + (1 - beta) * grads[0]
m_b = beta * m_b + (1 - beta) * grads[1]
w1.assign_sub(lr * m_w)
b1.assign_sub(lr * m_b)

2.3、Adagrad

  • Adagrad,在SGD的基础上增加二阶动量。
  • 二阶动量是从开始到现在,梯度平方的累计和。

m t = g t m_t=g_t mt=gt
V t = ∑ τ = 1 t g τ 2 V_t=\sum_{τ=1}^{t}g_{τ}^{2} Vt=τ=1tgτ2
η t = l r ∗ m t V t = l r ∗ m t = l r ∗ g t ∑ τ = 1 t g τ 2 η_t=lr*\frac{m_t}{\sqrt{V_t}}=lr*m_t=\frac{lr*g_t}{\sqrt{\sum_{τ=1}^{t}g_{τ}^{2}}} ηt=lrVt mt=lrmt=τ=1tgτ2 lrgt
w t + 1 = w t − η t = w t − l r ∗ g t ∑ τ = 1 t g τ 2 w_{t+1}=w_{t}-η_{t}=w_t-\frac{lr*g_t}{\sqrt{\sum_{τ=1}^{t}g_{τ}^{2}}} wt+1=wtηt=wtτ=1tgτ2 lrgt

  • 代码
v_w, v_b = 0, 0
# adagrad
v_w += tf.square(grads[0])
v_b += tf.square(grads[1])
w1.assign_sub(lr * grads[0] / tf.sqrt(v_w))
b1.assign_sub(lr * grads[1] / tf.sqrt(v_b))

2.4、RMSProp

  • RMSProp,在SGD的基础上增加二阶动量。
  • 二阶动量使用指数滑动平均值计算,表征的是过去一段时间的平均值。

m t = g t m_t=g_t mt=gt
V t = β ∗ V t − 1 + ( 1 − β ) ∗ g t 2 V_t=β*V_{t-1} +(1-β)*g_{t}^{2} Vt=βVt1+(1β)gt2
η t = l r ∗ m t V t = l r ∗ g t β ∗ V t − 1 + ( 1 − β ) ∗ g t 2 η_t=lr*\frac{m_t}{\sqrt{V_t}}=\frac{lr*g_t}{\sqrt{β*V_{t-1} +(1-β)*g_{t}^{2}}} ηt=lrVt mt=βVt1+(1β)gt2 lrgt
w t + 1 = w t − η t = w t − l r ∗ g t β ∗ V t − 1 + ( 1 − β ) ∗ g t 2 w_{t+1}=w_{t}-η_{t}=w_t-\frac{lr*g_t}{\sqrt{β*V_{t-1} +(1-β)*g_{t}^{2}}} wt+1=wtηt=wtβVt1+(1β)gt2 lrgt

  • 代码
v_w, v_b = 0, 0
beta = 0.9
# rmsprop
v_w = beta * v_w + (1 - beta) * tf.square(grads[0])
v_b = beta * v_b + (1 - beta) * tf.square(grads[1])
w1.assign_sub(lr * grads[0] / tf.sqrt(v_w))
b1.assign_sub(lr * grads[1] / tf.sqrt(v_b))

2.5、Adam

  • Adam,同时结合SGDM的一阶动量和RMSProp的二阶动量。
  • 在一阶动量和二阶动量的基础上,加入了修正项。

m t = β 1 ∗ m t − 1 + ( 1 − β 1 ) ∗ g t m_t=β_1*m_{t-1} + (1-β_1)*g_t mt=β1mt1+(1β1)gt
修正一阶动量的偏差: m t ^ = m t 1 − β 1 t \hat{m_t}=\frac{m_t}{1-β_{1}^{t}} mt^=1β1tmt
V t = β 2 ∗ V t − 1 + ( 1 − β 2 ) ∗ g t 2 V_t=β_2*V_{t-1} +(1-β_2)*g_{t}^{2} Vt=β2Vt1+(1β2)gt2
修正二阶动量的偏差: V t ^ = V t 1 − β 2 t \hat{V_t}=\frac{V_t}{1-β_{2}^{t}} Vt^=1β2tVt
η t = l r ∗ m t ^ V t ^ = l r ∗ m t 1 − β 1 t V t 1 − β 2 t η_t=lr*\frac{\hat{m_t}}{\sqrt{\hat{V_t}}}=lr*\frac{\frac{m_t}{1-β_{1}^{t}}}{\frac{V_t}{1-β_{2}^{t}}} ηt=lrVt^ mt^=lr1β2tVt1β1tmt
w t + 1 = w t − η t = w t − l r ∗ m t 1 − β 1 t V t 1 − β 2 t w_{t+1}=w_{t}-η_{t}=w_t-lr*\frac{\frac{m_t}{1-β_{1}^{t}}}{\frac{V_t}{1-β_{2}^{t}}} wt+1=wtηt=wtlr1β2tVt1β1tmt

  • 代码
m_w, m_b = 0, 0
v_w, v_b = 0, 0
beta1, beta2 = 0.9, 0.999
delta_w, delta_b = 0, 0
global_step = 0
# adam
m_w = beta1 * m_w + (1 - beta1) * grads[0]
m_b = beta1 * m_b + (1 - beta1) * grads[1]
v_w = beta2 * v_w + (1 - beta2) * tf.square(grads[0])
v_b = beta2 * v_b + (1 - beta2) * tf.square(grads[1])

m_w_correction = m_w / (1 - tf.pow(beta1, int(global_step)))
m_b_correction = m_b / (1 - tf.pow(beta1, int(global_step)))
v_w_correction = v_w / (1 - tf.pow(beta2, int(global_step)))
v_b_correction = v_b / (1 - tf.pow(beta2, int(global_step)))

w1.assign_sub(lr * m_w_correction / tf.sqrt(v_w_correction))
b1.assign_sub(lr * m_b_correction / tf.sqrt(v_b_correction))

3、实验对比不同优化器

  • 在此前代码中【tensorflow框架神经网络实现鸢尾花分类】替换优化器部分,加入时间模块,进行时间对比,以及训练曲线的对比。
  • Adam代码示例
# 导入所需模块
import tensorflow as tf
from sklearn import datasets
from matplotlib import pyplot as plt
import numpy as np
import time  ##1##

# 导入数据,分别为输入特征和标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target

# 随机打乱数据(因为原始数据是顺序的,顺序不打乱会影响准确率)
# seed: 随机数种子,是一个整数,当设置之后,每次生成的随机数都一样(为方便教学,以保每位同学结果一致)
np.random.seed(116)  # 使用相同的seed,保证输入特征和标签一一对应
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

# 将打乱后的数据集分割为训练集和测试集,训练集为前120行,测试集为后30行
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]

# 转换x的数据类型,否则后面矩阵相乘时会因数据类型不一致报错
x_train = tf.cast(x_train, tf.float32)
x_test = tf.cast(x_test, tf.float32)

# from_tensor_slices函数使输入特征和标签值一一对应。(把数据集分批次,每个批次batch组数据)
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)

# 生成神经网络的参数,4个输入特征故,输入层为4个输入节点;因为3分类,故输出层为3个神经元
# 用tf.Variable()标记参数可训练
# 使用seed使每次生成的随机数相同(方便教学,使大家结果都一致,在现实使用时不写seed)
w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))

lr = 0.1  # 学习率为0.1
train_loss_results = []  # 将每轮的loss记录在此列表中,为后续画loss曲线提供数据
test_acc = []  # 将每轮的acc记录在此列表中,为后续画acc曲线提供数据
epoch = 500  # 循环500轮
loss_all = 0  # 每轮分4个step,loss_all记录四个step生成的4个loss的和

##########################################################################
m_w, m_b = 0, 0
v_w, v_b = 0, 0
beta1, beta2 = 0.9, 0.999
delta_w, delta_b = 0, 0
global_step = 0
##########################################################################

# 训练部分
now_time = time.time()  ##2##
for epoch in range(epoch):  # 数据集级别的循环,每个epoch循环一次数据集
    for step, (x_train, y_train) in enumerate(train_db):  # batch级别的循环 ,每个step循环一个batch
 ##########################################################################       
        global_step += 1
 ##########################################################################       
        with tf.GradientTape() as tape:  # with结构记录梯度信息
            y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
            y = tf.nn.softmax(y)  # 使输出y符合概率分布(此操作后与独热码同量级,可相减求loss)
            y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式,方便计算loss和accuracy
            loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
            loss_all += loss.numpy()  # 将每个step计算出的loss累加,为后续求loss平均值提供数据,这样计算的loss更准确
        # 计算loss对各个参数的梯度
        grads = tape.gradient(loss, [w1, b1])

##########################################################################
 # adam
        m_w = beta1 * m_w + (1 - beta1) * grads[0]
        m_b = beta1 * m_b + (1 - beta1) * grads[1]
        v_w = beta2 * v_w + (1 - beta2) * tf.square(grads[0])
        v_b = beta2 * v_b + (1 - beta2) * tf.square(grads[1])

        m_w_correction = m_w / (1 - tf.pow(beta1, int(global_step)))
        m_b_correction = m_b / (1 - tf.pow(beta1, int(global_step)))
        v_w_correction = v_w / (1 - tf.pow(beta2, int(global_step)))
        v_b_correction = v_b / (1 - tf.pow(beta2, int(global_step)))

        w1.assign_sub(lr * m_w_correction / tf.sqrt(v_w_correction))
        b1.assign_sub(lr * m_b_correction / tf.sqrt(v_b_correction))
##########################################################################

    # 每个epoch,打印loss信息
    print("Epoch {}, loss: {}".format(epoch, loss_all / 4))
    train_loss_results.append(loss_all / 4)  # 将4个step的loss求平均记录在此变量中
    loss_all = 0  # loss_all归零,为记录下一个epoch的loss做准备

    # 测试部分
    # total_correct为预测对的样本个数, total_number为测试的总样本数,将这两个变量都初始化为0
    total_correct, total_number = 0, 0
    for x_test, y_test in test_db:
        # 使用更新后的参数进行预测
        y = tf.matmul(x_test, w1) + b1
        y = tf.nn.softmax(y)
        pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引,即预测的分类
        # 将pred转换为y_test的数据类型
        pred = tf.cast(pred, dtype=y_test.dtype)
        # 若分类正确,则correct=1,否则为0,将bool型的结果转换为int型
        correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
        # 将每个batch的correct数加起来
        correct = tf.reduce_sum(correct)
        # 将所有batch中的correct数加起来
        total_correct += int(correct)
        # total_number为测试的总样本数,也就是x_test的行数,shape[0]返回变量的行数
        total_number += x_test.shape[0]
    # 总的准确率等于total_correct/total_number
    acc = total_correct / total_number
    test_acc.append(acc)
    print("Test_acc:", acc)
    print("--------------------------")
total_time = time.time() - now_time  
print("total_time", total_time)

# 绘制测试Acc曲线和训练loss曲线
fig, ax = plt.subplots()
ax.plot(train_loss_results,'b-')
ax.set_xlabel('Epoch')
ax.set_ylabel('Loss')

ax1 = ax.twinx()
ax1.plot(test_acc,'r-')
ax1.set_ylabel('Acc')

ax1.spines['left'].set_color('blue')
ax1.spines['right'].set_color('red')
ax.set_title('SGD', fontsize=12)

在这里插入图片描述

4、结果对比

优化器训练用时结果可视化
SGD8.742414951324463在这里插入图片描述
SGDM8.880060911178589在这里插入图片描述
Adagrad8.902021646499634在这里插入图片描述
RMSProp9.599585771560669在这里插入图片描述
Adam10.520380973815918在这里插入图片描述

学习视频参考:https://www.bilibili.com/video/BV1B7411L7Qt/

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/520209.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

多态.Java

(1)什么是多态? 同类型的对象,表现出不同的形态。前者指父类,后者指不同的子类 说简单点,就是父类的同一种方法,可以在不同子类中表现出不同的状态,或者说在不同子类中可以实现不同…

[技术闲聊]我对电路设计的理解(七)-Cadence原理图绘制

一、原理图软件推荐 之前的章节有讲过AD、PADS、Cadence,以及三者的应用标准,今天再讲讲这一点。 如果是学生,可以学习AD软件,因为学校在学习,上手容易,而且即使工作后,如果是电机控制等4层板或…

websokcet服务端实现

一/websokcet服务端实现 步骤一&#xff1a; springboot底层帮我们自动配置了websokcet&#xff0c;引入maven依赖 1 2 3 4 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</arti…

力扣刷题 二叉树遍历的统一迭代法

题干 给定一个二叉树的根节点 root &#xff0c;返回 它的 前中后序 遍历 。 示例 1&#xff1a; 输入&#xff1a;root [1,null,2,3] 输出&#xff1a;[1,3,2]示例 2&#xff1a; 输入&#xff1a;root [] 输出&#xff1a;[]示例 3&#xff1a; 输入&#xff1a;root […

Python 之 Fastapi 框架学习

依赖安装 Fastapi 有版本要求&#xff0c;需要的 Python 版本至少是 Python 3.8&#xff08;不要犟&#xff0c;按照版本要求来&#xff0c;我最先也是在我 Python3.6 上装的&#xff0c;果不其然跑不起来&#xff09;&#xff0c;幸好我 Win7 老古董能支持的 Python 最高版本…

FastWiki发布`0.2.4`支持js 函数

Release v0.2.4 AIDotNet/fast-wiki (github.com) 支持JS动态functioncall调用支持动态function管理支持JS在线编辑提供智能代码提示支持JS在线编辑提供部分绑定的c#类&#xff08;默认提供Console&#xff0c;HttpClient&#xff09;支持Application绑定多个Function Call优…

跨站请求伪造漏洞(CSRF)

什么是CSRF CSRF&#xff08;Cross-Site Request Forgery&#xff09;&#xff0c;也被称为 one-click attack 或者 session riding&#xff0c;即跨站请求伪造攻击。 漏洞原理 跨站请求伪造漏洞的原理主要是利用了网站对用户请求的验证不严谨。攻击者会在恶意网站中构造一个…

linux 文件提权|属性修改

文章目录 suid&#xff08;set uid&#xff09;添加文件属性查看文件属性i &#xff08;immutable&#xff09; umask suid&#xff08;set uid&#xff09; 让文件在执行的时候具有属主&#xff08;对应文件 user &#xff09;的权限 chmod 7744 temp.txt 第一位的7表示权限位…

探寻大数据思想的主要贡献者与核心内容

引言&#xff1a; 在当今数字化时代&#xff0c;大数据已成为企业和科学研究的关键要素。其背后的思想和概念不仅引领了数据处理和分析的革新&#xff0c;也推动了人类对于信息时代的理解与认知。 大数据思想的起源&#xff1a; 在信息爆炸的时代背景下&#xff0c;大数据思…

海外仓的出入库流程有什么痛点?位像素海外仓系统怎么提高出入库效率?

随着跨境电商的蓬勃发展&#xff0c;海外仓是其中不可或缺的一个关键环节。而货物的出库与入库则是海外仓管理中的一个核心业务流程&#xff0c;它的运作效率直接影响到整个跨境物流的效率和客户体验。今天&#xff0c;让我们具体来看一看关于海外仓出入库的流程&#xff0c;其…

150行Python代码模拟太阳系行星运转

今天我们用Python来模拟一下太阳系行星运动轨迹~ 先上成品图&#xff08;运行效果含音乐的呦&#xff09; 想要实现这样的效果并不难 准备材料 首先我们需要准备这样一些材料 宇宙背景图 背景透明的行星图 编写代码 代码分块详解 导入需要的模块 import pygame import …

深度学习理论基础(六)多头注意力机制的自定义及Pytoch库的使用详细代码

目录 1. Scaled Dot-Product Attention2. 多头注意力机制框图&#xff08;1&#xff09;计算公式&#xff08;2&#xff09;具体计算过程&#xff08;3&#xff09;具体代码 深度学习中的注意力机制&#xff08;Attention Mechanism&#xff09;是一种模仿人类视觉和认知系统的…

轻量应用服务器4核8G12M配置优惠价格646元一年零3个月,12M公网带宽

腾讯云轻量4核8G12M服务器优惠价格646元15个月&#xff0c;买一年送3个月&#xff0c;配置为轻量4核8G12M、180GB SSD盘、2000GB月流量、12M带宽&#xff0c;腾讯云优惠活动页面 yunfuwuqiba.com/go/txy 活动链接打开如下图&#xff1a; 腾讯云4核8G服务器租用价格 腾讯云&…

SaaS模式Java版云HIS系统源码 覆盖医院所有业务的HIS信息管理系统源码

SaaS模式Java版云HIS系统源码 覆盖医院所有业务的HIS信息管理系统源码 HIS&#xff08;Hospital Information System&#xff09;是覆盖医院所有业务和业务全过程的信息管理系统。 HIS系统以财务信息、病人信息和物资信息为主线&#xff0c;通过对信息的收集、存储、传递、统…

Android 窗口那些事儿

目录 1. &#x1f4c2; 前言 你&#xff0c;是否有过这些疑问&#xff1f; 2. &#x1f531; Window 2.1 认识 Window 的几个阶段 1&#xff09;阶段一&#xff1a;Window 约等于 Activity 2&#xff09;阶段二&#xff1a;Window 约等于 View 3&#xff09;阶段三&…

list的使用

前言 我们前面已经对string和vector进行了学习使用&#xff0c;以及对他们的底层进行了模拟实现&#xff01;本期我们继续学习STL的另外一个容器---list。 本期内容介绍 什么是list&#xff1f; list的常用接口 什么是list? 还是来看看官方的文档说明&#xff01; 这里通过…

[蓝桥杯 2017 国 C] 合根植物

[蓝桥杯 2017 国 C] 合根植物 题目描述 w 星球的一个种植园&#xff0c;被分成 m n m \times n mn 个小格子&#xff08;东西方向 m m m 行&#xff0c;南北方向 n n n 列&#xff09;。每个格子里种了一株合根植物。 这种植物有个特点&#xff0c;它的根可能会沿着南北…

【MySQL】增删改查操作(基础)

文章目录 1、新增操作&#xff08;Create&#xff09;1.1单行数据全列插入1.2多行数据指定列插入 2、查询操作&#xff08;Retrieve&#xff09;2.1全列查询2.2指定列查询2.3指定列查询2.4别名&#xff08;as&#xff09;2.5去重&#xff08;distinct&#xff09;2.6排序&#…

数据结构—图

图的基本概念 图就是由顶点的有穷非空集合和顶点之间的边组成的集合。通常表示为&#xff1a;G(V,E)&#xff0c;其中&#xff0c;G 表示一个图&#xff0c;V 表示顶点的集合&#xff0c;E 表示边的集合。 顶点 图中的数据元素&#xff0c;我们称之为顶点&#xff0c;图至少有…

常见现代卷积神经网络(Pytorch 09)

本章将介绍现代的 卷积神经网络架构&#xff0c;许多现代卷积神经网络的研究都是建立在这一章的基础上的。在本章中的每一个模型都曾一度占据主导地位&#xff0c;其中许多模型都是 ImageNet竞赛 的优胜者。ImageNet竞赛自2010年以来&#xff0c;一直是计算机视觉中监督学习进展…