tensorflow(2):神经网络优化(loss,learning_rate)

案例: 预测酸奶的日销量, 由此可以准备产量, 使得损失小(利润大),假设销量是y , 影响销量的有两个因素x1, x2, 
需要预先采集数据,每日的x1,x2和销量y_, 拟造数据集X,Y_, 假设y_=x1+x2,为了更真实加一个噪声(-0.05-0.05)

batch_size=8 #一次喂给神经网络多少数据
seed=23455
#构造数据集
rdm=np.random.RandomState(seed) #基于seed产生随机数
X=rdm.rand(32,2) #32组数据
Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X] #rdm.rand()/10.0 是(0,1)随机数
print(‘X:\n‘,X)
print(‘Y_:\n‘,Y_)
#定义神经网络的输入 参数 输出 定义前向传播过程
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1)) # 合格或者不合格的特征
w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
y=tf.matmul(x,w1)
#定义损失函数 后向传播方法
loss_mse=tf.reduce_mean(tf.square(y_-y))
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
#train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss) #其他方法
#train_step=tf.train.AdamOptimizer(0.001).minimize(loss)   

#生成会话 训练
with tf.Session() as sess: #用会话计算结果
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    print(‘w1:\n‘, sess.run(w1)) #输出目前(未经训练的)参数取值
#训练模型
    steps=20000 #训练20000次
    for i in range(steps):
        start=(i*batch_size) %32
        end=start+batch_size
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]}) #8组数据
        if i % 500==0:  #每500轮打印一次w1值
            print(‘After %d training steps,w1 is:‘ %i)
            print(sess.run(w1),‘\n‘)
    print(‘Final w1 is:‘,sess.run(w1))

结果显示 w1=[0.98,1.015] 这与Y_=x1+x2一致,预测正确!!

1.loss优化

上述例子中, loss函数是均方和, 但是实际中,预测的销量(即要准备的产量y_) 与真实的销量y 之间的差异导致的损失 取决于 生产成本cost 与销售利润profit,

当预测多了, 损失成本, 预测少了,损失利润,

所以这里要自定义loss, 上述代码不变,只需要修改下loss参数

batch_size=8 #一次喂给神经网络多少数据
seed=23455
cost=1
profit=9
#构造数据集
rdm=np.random.RandomState(seed) #基于seed产生随机数
X=rdm.rand(32,2) #32组数据
Y_=[[x1+x2+(rdm.rand()/10.0-0.05)] for (x1,x2) in X] #rdm.rand()/10.0 是(0,1)随机数
print(‘X:\n‘,X)
print(‘Y_:\n‘,Y_)
#定义神经网络的输入 参数 输出 定义前向传播过程
x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1)) # 合格或者不合格的特征
w1=tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))
y=tf.matmul(x,w1)
#定义损失函数 后向传播方法
loss=tf.reduce_sum(tf.where(tf.greater(y,y_),cost*(y-y_),profit*(y_-y)))#tf.where(tf.greater(y,y_),cost*(y-y_),profit*(y_-y))第一个表示逻辑值,当为真时取第二项#为假时取第三项
train_step=tf.train.GradientDescentOptimizer(0.001).minimize(loss)
#train_step=tf.train.MomentumOptimizer(0.001,0.9).minimize(loss) #其他方法
#train_step=tf.train.AdamOptimizer(0.001).minimize(loss)   

#生成会话 训练
with tf.Session() as sess: #用会话计算结果
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    print(‘w1:\n‘, sess.run(w1)) #输出目前(未经训练的)参数取值
#训练模型
    steps=20000 #训练3000次
    for i in range(steps):
        start=(i*batch_size) %32
        end=start+batch_size
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]}) #8组数据
        if i % 500==0:  #每500轮打印一次结果
            print(‘After %d training steps,w1 is:‘ %i)
            print(sess.run(w1),‘\n‘)
    print(‘Final w1 is:‘,sess.run(w1))

得到结果是w1=[1.02,1.04] ,系数都大于1 ,这是由于多预测的损失 少于少预测的损失,结果也往多的方向预测了.要是 cost=9 ,profit=1,

最终得到参数w1=[0.96, 0.97] 都小于1

除了均方和, 自定义loss只要, 还有第三种 交叉熵(cross entropy)的loss,

交叉熵(cross entropy): 表示两个概率分布之间的距离, ce越大,距离也就越大.

交叉熵 ce
ce=-tf.reduce_mean(y_*tf.log(tf.clip_by_value(y,1e-12,1.0)))
n个分类的n输出

ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
cem=tf.reduce_mean(ce)

2.learning_rate 学习率调整

设置learning_rate=0.2

w=tf.Variable(tf.constant(5,dtype=tf.float32))
loss=tf.square(w+1) #定义损失函数
train_step=tf.train.GradientDescentOptimizer(0.2).minimize(loss)

with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    for i in range(40): #迭代40次
        sess.run(train_step)
        w_val=sess.run(w)
        loss_val=sess.run(loss)
        print(‘after %d steps, w is %f, loss is %f.‘%(i,w_val,loss_val))

若上述learning_rate=0.001, w趋于-1速度很慢,  learning_rate=1, w会发散,不会趋于-1

上述learning_rate 不能太大,也不能太小

#学习率 决定参数的更新 learning_rate
#根据运行的轮数决定动态更新学习率
learning_rate=LEARNING_RATE_BASE*LEARNING_RATE_DECAY^(global_step/LEARNING_RATE_STEP)
#LEARNING_RATE_BASE是学习率初始值   LEARNING_RATE_DECAY是学习衰减率(0,1)
#多少轮更新一次学习率,LEARNING_RATE_STEP 一般是总样本数/batch_size
global_step=tf.Variable(0,trainable=False) #记录当前共运行了多少轮batch-size
learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,
                                        global_step, LEARNING_RATE_STEP,
                                        LEARNING_RATE_DECAY,
                                        staircase=True)# staircase true 学习率阶梯型衰减, false则为平滑下降的曲线
#根据运行的轮数决定动态更新学习率
LEARNING_RATE_BASE=0.1 #最初学习率
LEARNING_RATE_DECAY=0.9 #学习率衰减率
LEARNING_RATE_STEP=1 # 喂入多少batch_size后更新一次学习率,一般是总样本数/batch_size,这里为了方便为1

global_step=tf.Variable(0,trainable=False) #记录当前共运行了多少轮batch-size
#定义指数下降学习率
learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,
                                        global_step, LEARNING_RATE_STEP,
                                        LEARNING_RATE_DECAY,
                                        staircase=True)

#优化参数 ,初值5
w=tf.Variable(tf.constant(5,dtype=tf.float32))
loss=tf.square(w+1) #定义损失函数
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    for i in range(40): #迭代40次
        sess.run(train_step)
        learning_rate_val=sess.run(learning_rate)
        global_step_val=sess.run(global_step)
        w_val=sess.run(w)
        loss_val=sess.run(loss)
        print(‘after %d steps, global_step is %f,w is %f, loss is %f.‘ %(i,global_step_val,w_val,loss_val))

结果:

原文地址:https://www.cnblogs.com/xuying-fall/p/8971642.html

时间: 2024-11-12 22:41:55

tensorflow(2):神经网络优化(loss,learning_rate)的相关文章

tensorflow(3):神经网络优化(ema,regularization)

1.指数滑动平均 (ema) 描述滑动平均: with tf.control_dependencies([train_step,ema_op]) 将计算滑动平均与 训练过程绑在一起运行 train_op=tf.no_op(name='train')  使它们合成一个训练节点 #定义变量一级滑动平均类 #定义一个32位浮点变量,初始值为0.0, 这个代码就是在不断更新w1参数,优化 w1,滑动平均做了一个w1的影子 w1=tf.Variable(0,dtype=tf.float32) #定义num

tensorflow:实战Google深度学习框架第四章02神经网络优化(学习率,避免过拟合,滑动平均模型)

1.学习率的设置既不能太小,又不能太大,解决方法:使用指数衰减法 例如: 假设我们要最小化函数 y=x2y=x2, 选择初始点 x0=5x0=5 1. 学习率为1的时候,x在5和-5之间震荡. import tensorflow as tf TRAINING_STEPS = 10 LEARNING_RATE = 1 x = tf.Variable(tf.constant(5, dtype=tf.float32), name="x") y = tf.square(x) train_op

【零基础】神经网络优化之Adam

一.序言 Adam是神经网络优化的另一种方法,有点类似上一篇中的“动量梯度下降”,实际上是先提出了RMSprop(类似动量梯度下降的优化算法),而后结合RMSprop和动量梯度下降整出了Adam,所以这里我们先由动量梯度下降引申出RMSprop,最后再介绍Adam.不过,由于RMSprop.Adam什么的,真的太难理解了,我就只说实现不说原理了. 二.RMSprop 先回顾一下动量梯度下降中的“指数加权平均”公式: vDW1 = beta*vDW0 + (1-beta)*dw1 vDb1 = b

神经网络优化(二) - 学习率

1 学习率的基本定义 学习率learning_rate:每次参数更新的幅度. 简单示例: 假设损失函数 loss = ( w + 1 )2,则梯度为 参数 w 初始化为 5 ,学习率为 0.2 ,则 运行次数 参数w值 计算 1次 5 5-0.2*(2*5+2) = 2.6 2次 2.6 2.6-0.2*(2*2.6+2) = 1.16 3次 1.16 1.16-0.2*(2*1.16+2) = 0.296 4次 0.296   2 学习率的初步应用 2.1  学习率 0.2 时 # 已知损失函

神经网络优化(二) - 搭建神经网络八股

为提高程序的可复用性,搭建模块化的神经网络八股 1 前向传播 前向传播就是设计.搭建从输入(参数 x ) 到输出(返回值为预测或分类结果 y )的完整网络结构,实现前向传播过程,一般将其放在 forward.py 文件中 前向传播需要定义三个函数(实际上第一个函数是框架,第二.三个函数是赋初值过程) def forward(x, regularizer): w = b = y = return y 函数功能: 定义前向传播过程,返回值为y 完成网络结构的设计,实现从输入到输出的数据通路 regu

利用Tensorflow实现神经网络模型

首先看一下神经网络模型,一个比较简单的两层神经. 代码如下: # 定义参数 n_hidden_1 = 256 #第一层神经元 n_hidden_2 = 128 #第二层神经元 n_input = 784 #输入大小,28*28的一个灰度图,彩图没有什么意义 n_classes = 10 #结果是要得到一个几分类的任务 # 输入和输出 x = tf.placeholder("float", [None, n_input]) y = tf.placeholder("float&q

使用Tensorflow训练神经网络模型

最近正在入坑机器学习,前期以读代码为主.买了一本才云科技郑泽宇的书,叫做<Tensorflow,实战Google深度学习框架>,觉得很适合入门的小菜鸟,拿出来跟大家分享下. 下面是第一个完整的训练神经网络模型的代码,里面综合了作者和我在网上查到的其他人关于代码的解读.整理之后如下: 1 #-*-coding:UTF-8-*- 2 import tensorflow as tf 3 #通过numpy工具包生成模拟数据集 4 from numpy.random import RandomState

神经网络优化(一)

一.损失函数(loss) [前向传播的预测值y与已知答案y_的差距]: 1.优化目标:使loss达到最小值. 2.优化方法:均方误差(mse) 交叉熵(ce) 自定义 详解: 1.均方误差mse: 公式: 函数:loss_mse = tf.reduce_mean(tf.square(y_ - y)) tf.reduce_mean(x)  :表示计算所有元素的平均值. 2.交叉熵cs: 表征两个概率分布之间的距离 公式: 函数:ce = -tf.reduce_mean(y_*tf.log(tf.c

记一次使用Tensorflow搭建神经网络模型经历

隐去背景, 作者最近第一次用Tensorflow实现训练了几个模型, 其中遇到了一些错误, 把它记录下来 前言 以下提到的所有代码, 都可以在github上面找到. 仓库地址 https://github.com/spxcds/neural_network_code/ 这个仓库里提到的几段代码, 分别实现在从最简单的lr, 到全连接神经网络, 再到卷积神经网络. 从最简单的自己实现交叉熵损失函数, 计算L2正则化, 到后来直接调用库函数, 由简到难, 由浅入深, 截止目前为止, 只实现了MLR,