TensorFlow神经网络（三）神经网络优化

最新推荐文章于 2022-11-23 13:25:11 发布
最新推荐文章于 2022-11-23 13:25:11 发布
阅读量636 收藏 1
点赞数
分类专栏： python tensorflow machine learning
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/petSym/article/details/83653478
版权

一、激活函数

在这里插入图片描述

二、损失函数

① mse（mean squared error）均方误差

loss_mse = tf.reduce_mean(tf.square(y_ - y)

② ce（cross entropy）交叉熵

表示两个概率分布之间的距离。
交叉熵越大，两个概率分布距离越远，两个概率分布越相异。
交叉熵越小，两个概率分布距离越近，两个概率分布越相似。
在这里插入图片描述

ce = tf.reduce_mean(y_ * tf.log(tf.clip_by_value(y, 1e-12, 1.0)))
# y 小于1e-12为1e-12，否则大于1.0为1.0

在实际操作中，为了让前向传播的结果满足概率分布，即推测出的n分类的输出y1~yn（每个情况出现的可能性）每个都在[0,1]之间，且n个输出之和为1，引入softmax函数，将n个输出经过softmax函数，得到符合概率分布的分类结果：
在这里插入图片描述
在这里插入图片描述
在TensorFlow中，一般让模型的输出经过softmax函数，以获得输出分类的概率分布，再与标准答案对比，求出交叉熵，得到损失函数：

ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = y, lables = tf.argmax(y_, 1))
cem = tf.reduce_mean(ce)
# 在工程实用中，可以直接用此两行替换上面一行求交叉熵的函数

③ 自定义

# e.g. 自定义分段函数
# greater函数结果为真时取前一个分段，否则取后一个
loss_selfdefine = tf.reduce_sum( tf.where( tf.greater(y, y_), COST*(y - y_), PROFIT*(y_ - y) ) )

三、学习率

① 任意设置学习率

损失函数

loss = (w +1)^2

学习率设置0.2，可以最终得到损失函数为0的参数w=-1

# coding: utf-8
import tensorflow as tf
# initialize w
w = tf.Variable(tf.constant(5, dtype = tf.float32))

# loss function
loss = tf.square(w+1)
# define back propagation method
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
# train
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    for i in range(40):
        sess.run(train_step)
        w_val = sess.run(w)
        loss_val = sess.run(loss)
        print("after %s steps: w is %f, loss is %f." % (i, w_val, loss_val))

在这里插入图片描述

  • 学习率大了，振荡不收敛，学习率小了收敛速度太慢

② 指数衰减学习率

在这里插入图片描述

global_step表示运行到第几轮
LEARNING_RATE_STEP表示多少轮更新一次学习率，如500个训练样本，BATCH_SIZE取5，共100轮，则每100轮更新一次，即每次喂完所有数据之后，下一轮重新进500个样本的时候更新。

# coding: utf-8
import tensorflow as tf

LEARNING_RATE_BASE = 0.1 #最初学习率
LEARNING_RATE_DECAY = 0.99 #学习率衰减率
LEARNING_RATE_STEP = 1 #喂人多少轮BATCH_SIZE后，更新学习率

#标记运行到第几轮Batch_size的计数器，初始化0，设为不可被训练
global_step = tf.Variable(0, trainable = False)

#定义指数下降学习率
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, LEARNING_RATE_STEP, LEARNING_RATE_DECAY, staircase = True)

#定义待优化函数
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):
		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 %s steps: global_step is %f, w is %f, lr is %f, loss is %f" %(i, global_step_val, w_val, learning_rate_val, loss_val))

四、滑动平均/影子值

  • 参数变化，影子缓慢追随
  • 记录了过往一段时间内模型中所有参数w和b的各自的平均值
  • 不仅表现当前值，还 表现了过去一段时间内的平均值
  • 利用滑动平均值可以增强模型的泛化性能
    在这里插入图片描述
############# warm up ! #############

'''
# 实例化滑动平均类。给出滑动平均参数，衰减率和当前轮数
 ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

# tf.trainable_variables()自动将所有待训练参数汇总为列表
# 所以下面这句可以对所有参数求滑动平均
ema_op = ema.apply(tf.trainable_variables())  

# 将滑动平均和训练过程同步进行
with tf.control_dependencies([train_step, ema_op]):
# 将滑动平均和训练过程合成一个训练节点
train_op = tf.no_op(name = 'train')

# 查看某参数的滑动平均值
ema.average(parameter)

'''

############ full coding! ##########
# coding : utf-8
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'  #hide warnings

# step 1: 定义变量及滑动平均类
# 要优化的w1参数，赋初值0.0
w1 = tf.Variable(0, dtype = tf.float32)

# 定义神经网络迭代轮数，赋初值0，不可被训练/优化
global_step = tf.Variable(0, trainable = False)

# 滑动平均衰减率
MOVING_AVERAGE_DECAY = 0.99

# 实例化滑动平均类
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

# 将滑动平均类apply到所有待训练的参数列表中，得到滑动平均节点
ema_op = ema.apply(tf.trainable_variables())

# step 2: 查看不同迭代中变量取值的变化
with tf.Session() as sess:
	# 初始化训练节点
	init_op = tf.global_variables_initializer()
	sess.run(init_op)

	# 打印出当前参数w1和其滑动平均值
	print(sess.run([w1, ema.average(w1)]))

	# 更新w1 的值为1
	sess.run(tf.assign(w1, 1))
	# 执行滑动平均节点
	sess.run(ema_op)
	# 打印
	print(sess.run([w1, ema.average(w1)]))

	# 更新step和w1的值，模拟100次迭代后，w1的值变为10
	sess.run(tf.assign(global_step, 100))
	sess.run(tf.assign(w1, 10))
	sess.run(ema_op)
	# 打印
	print(sess.run([w1, ema.average(w1)]))

	# 继续重复，执行滑动平均节点的操作
	sess.run(ema_op)
	print(sess.run([w1, ema.average(w1)]))

	sess.run(ema_op)
	print(sess.run([w1, ema.average(w1)]))

	sess.run(ema_op)
	print(sess.run([w1, ema.average(w1)]))

	sess.run(ema_op)
	print(sess.run([w1, ema.average(w1)]))

	sess.run(ema_op)
	print(sess.run([w1, ema.average(w1)]))

	sess.run(ema_op)
	print(sess.run([w1, ema.average(w1)]))
  • 输出结果：
λ python movingAverage.py
D:\anaconda3-5.2.0\anaconda3-5.2.0\lib\site-packages\h5py\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.
  from ._conv import register_converters as _register_converters
[0.0, 0.0]
[1.0, 0.9]
[10.0, 1.6445453]
[10.0, 2.3281732]
[10.0, 2.955868]
[10.0, 3.532206]
[10.0, 4.061389]
[10.0, 4.547275]
[10.0, 4.9934072]

五、正则化

  • 神经网络模型在训练数据集上的准确率较高，但是在对新的数据进行预测或分类时准确率较低，说明模型的泛化能力差，模型存在过拟合。
  • 正则化：在损失函数中引入模型复杂度指标，即给每个参数 w加上权重，从而弱化训练数据的噪声，减小过拟合。
  • 使用正则化后，损失函数loss变为两项之和：
loss = loss(y, y_) + REGULARIZER * loss(w)
// 1.第一项是预测y和标准答案y_之间的差距
（原来不正则化方案的loss），如交叉熵、均方误差等；
// 2.第二项是正则化结果，有L1和L2两种正则化计算方法。
REGULARIZER是正则化的权重，
给出参数w在总loss中比例的超参数
  • 正则化的两种计算方法：

① L1正则化：所有w绝对值之和
在这里插入图片描述

loss(w) = tf.contrib.layers.l1_regularizer(REGULARIZER)(W)

② L2正则化：所有w平方的绝对值之和
在这里插入图片描述

loss(w) = tf.contrib.layers.l2_regularizer(REGULARIZER)(W)
  • 实例
    在这里插入图片描述
  • 预热：一些要用到的新的语法函数
################# warm up ! ######################
# 把各个w的正则化加到losses集合对应位置
tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(REGULARIZER)(w))

# 把losses集合的各个值相加，再加上交叉熵：
loss = cem + tf.add_n(tf.get_collection('losses'))

# 安装python中的可视化工具模块
pip install matplotlib

# 指定颜色实现点(x, y)的可视化
plt.scatter(x, y, c = " ")
# 显示结果
plt.show()

# 找到指定区域内以步长为分辨率的行列网格坐标点
xx, yy = np.mgrid[startx: endx: stepx, starty, endy, stepy]
# 收集规定区域内所有的网格坐标点，组成矩阵
grid = np.c_[xx.ravel(), yy.ravel()]

# 告知x，y坐标，用levels指定高度的点描上颜色
plt.contour(x, y, height, levels = [])
  • 不使用正则化进行预测的结果
################ complete coding! #################

# coding: utf-8
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'  #hide warnings

BATCH_SIZE = 30
seed = 2

######## step 1 ：数据集的产生和预处理

# 基于seed产生随机数
rdm = np.random.RandomState(seed)

# 随机数返回300行2列的矩阵，表示300组坐标点，作为输入数据集
X = rdm.randn(300, 2)

# 手工标注数据分类
Y_ = [int(x0*x0 + x1*x1 < 2)for (x0, x1) in X]

# Y_为1，标记红色，否则蓝色
Y_c = [['red' if y else 'blue'] for y in Y_]

# 对数据集和标签进行reshape， X整理为n行2列，Y为n行1列，第一个元素-1表示n行
X = np.vstack(X).reshape(-1, 2)
Y_ = np.vstack(Y_).reshape(-1, 1)

print("X:\n")
print(X)
print("Y_:\n")
print(Y_)
print("Y_c:\n")
print(Y_c)

# 从每个点的可视化，到整个图的可视化
plt.scatter(X[:, 0], X[:, 1], c = np.squeeze(Y_c))
plt.show()

########### step 2 ：神经网络前向传播

# 定义初始化权重、将正则化后权重加入losses集合的函数
def get_weight(shape, regularizer):
	w = tf.Variable(tf.random_normal(shape), dtype = tf.float32)
	tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
	return w

# 定义初始化偏置的函数
def get_bias(shape):
	b = tf.Variable(tf.constant(0.01, shape = shape))
	return b

# placeholder占位
x = tf.placeholder(tf.float32, shape = (None, 2))
y_ = tf.placeholder(tf.float32, shape = (None, 1))

# 网络结构计算图
w1 = get_weight([2, 11], 0.01)
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x, w1) + b1)

w2 = get_weight([11, 1], 0.01)
b2 = get_bias([1])
y = tf.matmul(y1, w2) + b2 #输出层不通过激活函数

# 定义损失函数
loss_mse = tf.reduce_mean(tf.square(y - y_))
# 均方误差loss加上正则化w的loss
loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))


########### step 3 ：神经网络反向传播 + 不含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_mse)

with tf.Session() as sess:
	init_op = tf.global_variables_initializer()
	sess.run(init_op)
	STEPS = 40000
	for i in range(STEPS):
		start = (i * BATCH_SIZE) % 300
		end = start + BATCH_SIZE
		sess.run(train_step, feed_dict = {x: X[start: end], y_: Y_[start: end]})
		if i % 2000 ==0:
			loss_mse_val = sess.run(loss_mse, feed_dict = {x: X, y_: Y_})
			print("after %d steps, loss of mse is %f:" %(i, loss_mse_val))

	# 生成二维网格坐标点
	xx, yy = np.mgrid[-3:3:.01, -3:3:.01]

	# 将xx，yy拉直，合并成一个2列的矩阵，得到一个网络坐标点的集合
	grid = np.c_[xx.ravel(), yy.ravel()]

	# 将网格坐标点喂入神经网络，神经网络推算出的结果赋给probs
	# 这样两列的输入x才是符合这个神经网络结构的
	probs = sess.run(y, feed_dict = {x: grid})

	# probs调整成和xx一样的shape
	probs = probs.reshape(xx.shape)

	print("w1:\n", sess.run(w1))
	print("b1:\n", sess.run(b1))
	print("w2:\n", sess.run(w2))
	print("b2:\n", sess.run(b2))

# 可视化
plt.scatter(X[:, 0], X[:, 1], c = np.squeeze(Y_c))
# 给probs值为0.5的所有点(xx, yy)上色
plt.contour(xx, yy, probs, levels = [.5])
plt.show()

在这里插入图片描述

########### step 3 v2：神经网络反向传播 + 含正则化

train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_total)

with tf.Session() as sess:
	init_op = tf.global_variables_initializer()
	sess.run(init_op)
	STEPS = 40000
	for i in range(STEPS):
		start = (i * BATCH_SIZE) % 300
		end = start + BATCH_SIZE
		sess.run(train_step, feed_dict = {x: X[start:end], y_: Y_[start:end]})
		if i % 2000 ==0:
			loss_v = sess.run(loss_total, feed_dict = {x: X, y_: Y_})
			print("after %d steps, loss for total is %f" %(i, loss_v))

	xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
	grid = np.c_[xx.ravel(), yy.ravel()]
	probs = sess.run(y, feed_dict = {x: grid})
	probs = probs.reshape(xx.shape)

	print("w1:\n", sess.run(w1))
	print("b1:\n", sess.run(b1))
	print("w2:\n", sess.run(w2))
	print("b2:\n", sess.run(b2))

# 可视化
plt.scatter(X[:, 0], X[:, 1], c = np.squeeze(Y_c))
# 给probs值为0.5的所有点(xx, yy)上色
plt.contour(xx, yy, probs, levels = [.5])
plt.show()

在这里插入图片描述
对比有无正则化模型的结果，可以看出，有正则化模型的拟合曲线更平滑，模型具有更好的泛化能力。

petSym
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深度学习与TensorFlow实战（四）神经网络优化
法兰西流浪者博客
08-21 524
神经元模型：，f为激活函数，神经网络是以神经元作为基本单元构成。 激活函数：引入非线性激活因素，提升模型的表达能力 常用的激活函数relu，sigmoid，tanh等。 1，激活函数relu：tf.nn.relu() 2，激活函数sigmoid：tf.nn.sigmoid(） 3，激活函数tanh：tf.nn.tanh() 神经网络的复杂度：可用神经网络的层数和神经网络中待...
TensorFlow神经网络优化：复杂学习率、激活函数、损失函数、过拟合、梯度爆炸、优化器
Explore
05-31 2413
神经网络优化：复杂学习率（指数衰减学习率、分段常数衰减学习率），激活函数（非线性、可微性、单调性、近似恒等性），损失函数（均方误差、交叉熵、自定义），过拟合，梯度爆炸（逐步减小学习率、数据预处理），优化器
基于遗传算法GA算法优化BP神经网络（Python代码实现）
weixin_61181717的博客
11-23 6661
BP-GA算法的设计︰基于遗传算法的BP神经网络算法(以下简称BP-GA)就是在BP神经网络的学习过程中,将权重和阀值描述为染色体,并选取适宜的适应函数,然后进行GA迭代,直到某种意义上的收敛.与普通BP学习算法相比,算法 BP一GA的优势在于可以处理一些传统方法不能处理的例子,例如不可导的特性函数(传递函数)或者没有梯度信息存在的节点.该算法涉及到两个关键问题,分别是染色体位串与权系值的编码映射和评价函数。
第三十四课.模糊神经网络
热门推荐
白景屹的博客
01-03 1万+
目录模糊理论Fuzzy SetFuzzy set operationsFuzzy Min Max Classifier应用：基于模糊神经网络的水轮机调速器PID控制 模糊理论 在本篇内容中，我们将了解模糊神经网络（Fuzzy Neural Network），在此之前，先了解模糊理论。现实世界总是充满不确定性。因此，在建模系统的时候，我们需要考虑这种不确定性。我们之前其实已经在概率论中接触过这种不确定的建模形式。类似于概率论，Zadeh开发了一种不同的不确定表示形式，即模糊集（Fuzzy Set）。 Fuzz
遗传算法优化BP神经网络代码.zip
04-23
利用遗传算法优化BP神经网络模型对数据进行仿真训练，可以对变形监测数据以及其他领域的数据进行预测，实验结果表明遗传算法优化BP神经网络模型比BP神经网络模型有着更好的预测精度，代码是基于matlab语言自己写的，可供参考
TensorFlow神经网络优化策略学习
09-20
TensorFlow神经网络优化策略学习 TensorFlow神经网络优化策略学习是指在神经网络模型优化的过程中，会遇到许多问题，如如何设置学习率、过拟合问题等。下面将详细介绍这些问题的解决方法。 学习率的设置 学习率...
python tensorflow神经网络预测模型
最新发布
12-15
使用Python编写一个预测模型，可以使用深度学习库例如TensorFlow或PyTorch来构建神经网络模型。资源是一个使用TensorFlow构建神经网络预测模型的简单示例。在这个例子中，首先使用np.array来定义训练数据的特征向量X...
tensorflow笔记之神经网络优化
03-23
TensorFlow笔记之神经网络优化 本资源主要介绍了神经网络优化的相关知识点，包括神经网络复杂度、学习率策略、激活函数、损失函数、优化器等内容。 神经网络复杂度是指神经网络模型的时间复杂度和空间复杂度。时间...
Tensorflow人工神经网络详解
05-10
**Tensorflow人工神经网络详解** 人工神经网络(ANN)是一种监督学习算法，它利用多个超参数来近似输入与输出之间的复杂关系。超参数是我们在构建模型时预先设定的值，影响模型的学习和性能。在神经网络中，关键的超...
Tensorflow实现的简单BP神经网络模型
06-19
在TensorFlow框架下实现BP神经网络模型，可以充分利用其强大的计算能力和丰富的API，使得模型的构建、训练和评估变得更加高效。 **1. TensorFlow简介** TensorFlow是由Google开发的开源机器学习库，支持分布式计算...
小波分析神经网络预测源代码
09-02
基于小波分析，消除一定干扰因子，再利用人工神经网络，对人口变化趋势进行预测，得到了很好的结果。
遗传算法优化BP神经网络
09-14
遗传算法优化BP神经网络全部代码，交流与学习，仅是简单实现，希望能够交流学习，并指正。遗传算法优化BP神经网络全部代码，交流与学习，仅是简单实现，希望能够交流学习，并指正。
BP模糊神经网络python实现（含数据）
06-22
BP模糊神经网络python实现，有注解。可参考博文https://blog.csdn.net/yangxiluo/article/details/125402029?spm=1001.2014.3001.5502看算法实现过程。
基于遗传算法的BP神经网络优化算法
05-06
这是基于遗传算法的BP神经网络优化算法的MATLAB仿真源码，下载后可以直接运行，请大家参考！！！
天牛须智能算法(BAS)加模糊神经网络对水质预测&离散模糊控制MATLAB程序.zip
06-17
该资源内包括两个东西，一个是用天牛须智能算法(BAS)配合模糊神经网络对水质评估的论文说明，另一个是有关于离散模糊控制的MATLAB程序，可以通过第二个了解相关的模糊神经网络原理
机器学习————神经网络的算法优化
weixin_41460135的博客
08-19 479
文章目录神经网络的算法优化正则化Inverted DropOut反向随机失活梯度下降的优化算法指数加权平均指数加权平均的作用动量梯度算法RMSpropAdamSoftmax代码实现tensorflow实现DNNSoftmax_regression 神经网络的算法优化 正则化 Inverted DropOut反向随机失活 d3 = np.randm.rand(a3.shape[0], a3.sha...
基于遗传算法优化的BP神经网络的 非线性函数拟合
qq_18343569的博客
07-26 1万+
遗传算法 ( GA , Genetic Algorithm ) ，也称进化算法 。 遗传算法是受达尔文的进化论的启发，借鉴生物进化过程而提出的一种启发式搜索算法。因此在介绍遗传算法前有必要简单的介绍生物进化知识。     一.进化论知识  　　作为遗传算法生物背景的介绍，下面内容了解即可： 　　种群(Population)：生物的进化以群体的形式进行，这样的一个群体称
【深度学习】神经网络的优化方法
Daycym的博客
11-08 4424
前言 \quad\quad我们都知道，神经网络的学习目的是找到使损失函数的值尽可能小的参数，这是一个寻找最优参数的问题，解决这个问题的过程可以称为最优化，但由于参数空间非常复杂，无法轻易找到最优解，而且在深度学习中，参数的数量非常大，导致最优化问题更加复杂。 \quad\quad在这之前，我们是将参数的梯度（导数）作为线索，使参数沿着梯度方向更新，并重复执行多次，从而逐渐靠近最优参数，这个过程称为...
神经网络+tensorflow基础（一）
01-25
本篇文章是关于神经网络与TensorFlow基础的入门教程，主要针对初学者介绍了如何在Python环境下使用TensorFlow构建和理解神经网络的基本概念。首先，文章强调了神经网络在特征提取中的重要作用，这是深度学习中的关键...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值