神经网络优化-滑动平均与正则化

最新推荐文章于 2020-04-03 18:40:31 发布
最新推荐文章于 2020-04-03 18:40:31 发布
阅读量987 收藏 1
点赞数 3
分类专栏： 机器学习 文章标签： python ai
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42229034/article/details/82078246
版权

老夫马上要回学校了，这几天先不更了。

滑动平均：记录了一段时间内模型中所有参数w和b各自的平均值。利用滑动平均值可以增强模型的泛化能力。

滑动平均值（影子）计算公式：

影子 = 衰减率 * 影子 +（1 - 衰减率）* 参数

其中，衰减率，影子初值=参数初值

用Tesnsorflow函数表示为：

ema =tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY，global_step) 

其中，MOVING_AVERAGE_DECAY表示滑动平均衰减率，一般会赋接近1的值，global_step表示当前训练了多少轮。

ema_op =ema.apply(tf.trainable_variables())

其中，ema.apply()函数实现对括号内参数求滑动平均，tf.trainable_variables()函数实现把所有待训练参数汇总为列表。

with tf.control_dependencies([train_step,ema_op]):
     train_op = tf.no_op(name='train')

其中，该函数实现将滑动平均和训练过程同步运行。

查看模型中参数的平均值，可以用ema.average()函数。 例如：

在神经网络模型中，将MOVING_AVERAGE_DECAY设置为0.99，参数w1设置为0，w1的滑动平均值设置为0。

①开始时，轮数global_step设置为0，参数w1更新为1，则w1的滑动平均值为：

w1滑动平均值=min(0.99,1/10)*0+(1–min(0.99,1/10)*1 = 0.9

②当轮数global_step设置为100时，参数w1更新为10，则滑动平均值变为：

w1滑动平均值=min(0.99,101/110)*0.9+(1–min(0.99,101/110)*10 = 0.826+0.818=1.644

③再次运行，参数w1更新为1.644，则滑动平均值变为：

w1滑动平均值=min(0.99,101/110)*1.644+(1–min(0.99,101/110)*10 = 2.328

④再次运行，参数w1更新为2.328，则滑动平均值：

w1滑动平均值=2.956

代码范式：

#coding:utf-8
import tensorflow as tf
 
#1. 定义变量及滑动平均类
#定义一个32位浮点变量，初始值为0.0  这个代码就是不断更新w1参数，优化w1参数，滑动平均做了个w1的影子
w1 = tf.Variable(0, dtype=tf.float32)
#定义num_updates（NN的迭代轮数）,初始值为0，不可被优化（训练），这个参数不训练
global_step = tf.Variable(0, trainable=False)
#实例化滑动平均类，给衰减率为0.99，当前轮数global_step
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
#ema.apply后的括号里是更新列表，每次运行sess.run（ema_op）时，对更新列表中的元素求滑动平均值。
#在实际应用中会使用tf.trainable_variables()自动将所有待训练的参数汇总为列表
#ema_op = ema.apply([w1])
ema_op = ema.apply(tf.trainable_variables())
 
#2. 查看不同迭代中变量取值的变化。
with tf.Session() as sess:
    # 初始化
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
	#用ema.average(w1)获取w1滑动平均值 （要运行多个节点，作为列表中的元素列出，写在sess.run中）
	#打印出当前参数w1和w1滑动平均值
    print "current global_step:", sess.run(global_step)
    print "current w1", sess.run([w1, ema.average(w1)]) 
    
    # 参数w1的值赋为1
    sess.run(tf.assign(w1, 1))
    sess.run(ema_op)
    print "current global_step:", sess.run(global_step)
    print "current w1", sess.run([w1, ema.average(w1)]) 
    
    # 更新global_step和w1的值,模拟出轮数为100时，参数w1变为10, 以下代码global_step保持为100，每次执行滑动平均操作，影子值会更新 
    sess.run(tf.assign(global_step, 100))  
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print "current global_step:", sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])       
    
    # 每次sess.run会更新一次w1的滑动平均值
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])
 
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])
 
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])
 
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])
 
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])
 
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])
 
#更改MOVING_AVERAGE_DECAY 为 0.1  看影子追随速度

运行结果如下：

从运行结果可知，最初参数w1和滑动平均值都是0；参数w1设定为1后，滑动平均值变为0.9；当迭代轮数更新为100轮时，参数w1更新为10后，滑动平均值变为1.644。随后每执行一次，参数 w1的滑动平均值都向参数w1靠近。可见，滑动平均追随参数的变化而变化。 

4.4 正则化

过拟合：神经网络模型在训练数据集上的准确率较高，在新的数据进行预测或分类时准确率较低，说明模型的泛化能力差。

正则化：在损失函数中给每个参数w加上权重，引入模型复杂度指标，从而抑制模型噪声，减小过拟合。

使用正则化后，损失函数loss变为两项之和：

loss = loss(y与y_)+ REGULARIZER*loss(w)

其中，第一项是预测结果与标准答案之间的差距，如之前讲过的交叉熵、均方误差等；第二项是正则化计算结果。

正则化计算方法：

① L1正则化：  

用Tesnsorflow函数表示:loss(w)= tf.contrib.layers.l1_regularizer(REGULARIZER)(w)

② L2正则化：  

用Tesnsorflow函数表示:loss(w)= tf.contrib.layers.l2_regularizer(REGULARIZER)(w)

用Tesnsorflow函数实现正则化：

tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w) loss = cem +tf.add_n(tf.get_collection('losses'))

cem的计算已在4.1节中给出。

例如：

用300个符合正态分布的点X[x0, x1]作为数据集，根据点X[x0, x1]计算生成标注Y_，将数据集标注为红色点和蓝色点。

标注规则为：当x02 + x12 < 2 时，y_=1，标注为红色；当x02 + x122 时，y_=0，标注为蓝色。

我们分别用无正则化和有正则化两种方法，拟合曲线，把红色点和蓝色点分开。在实际分类时，如果前向传播输出的预测值y接近1则为红色点概率越大，接近0则为蓝色点概率越大，输出的预测值y为0.5是红蓝点概率分界线。  

在本例子中，我们使用了之前未用过的模块与函数：

matplotlib模块：Python中的可视化工具模块，实现函数可视化

终端安装指令：

sudo apt install python-tk

sudo pip install matplotlib

函数plt.scatter()：利用指定颜色实现点(x,y)的可视化

plt.scatter (x坐标, y坐标, c=”颜色”) 

plt.show()

收集规定区域内所有的网格坐标点：

xx, yy = np.mgrid[起:止:步长, 起:止:步长] #找到规定区域以步长为分辨率的行列网格坐标点

grid = np.c_[xx.ravel(), yy.ravel()]  #收集规定区域内所有的网格坐标点

plt.contour()函数：告知x、y坐标和各点高度，用levels指定高度的点描上颜色

plt.contour (x轴坐标值, y轴坐标值, 该点的高度,levels=[等高线的高度]) plt.show()

示例代码如：

#coding:utf-8
#0导入模块 ，生成模拟数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
BATCH_SIZE = 30 
seed = 2 
#基于seed产生随机数
rdm = np.random.RandomState(seed)
#随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
X = rdm.randn(300,2)
#从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
#作为输入数据集的标签（正确答案）
Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
#遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
Y_c = [['red' if y else 'blue'] for y in Y_]
#对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X = np.vstack(X).reshape(-1,2)
Y_ = np.vstack(Y_).reshape(-1,1)
print X
print Y_
print Y_c
#用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
plt.show()
 
 
#定义神经网络的输入、参数和输出，定义前向传播过程 
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
	
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_total = loss_mse + tf.add_n(tf.get_collection('losses'))
 
#定义反向传播方法：不含正则化
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_v = sess.run(loss_mse, feed_dict={x:X, y_:Y_})
			print("After %d steps, loss is: %f" %(i, loss_mse_v))
    #xx在-3到3之间以步长为0.01，yy在-3到3之间以步长0.01,生成二维网格坐标点
	xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
	#将xx , yy拉直，并合并成一个2列的矩阵，得到一个网格坐标点的集合
	grid = np.c_[xx.ravel(), yy.ravel()]
	#将网格坐标点喂入神经网络 ，probs为输出
	probs = sess.run(y, feed_dict={x:grid})
	#probs的shape调整成xx的样子
	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))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()
 
 
#定义反向传播方法：包含正则化
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 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)) 
plt.contour(xx, yy, probs, levels=[.5])
plt.show()

执行代码，效果如下：

首先，数据集实现可视化，x02 + x12 < 2的点显示红色， x02 + x122 的点显示蓝色，如图所示：

接着，执行无正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示： 

最后，执行有正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示：

对比无正则化与有正则化模型的训练结果，可看出有正则化模型的拟合曲线平滑，模型具有更好的泛化能力。

4.5 神经网络搭建八股

前向传播：由输入到输出，搭建完整的网络结构 描述前向传播的过程需要定义三个函数： 

def forward(x, regularizer):

w=

b= 

y= 

return y

第一个函数 forward()完成网络结构的设计，从输入到输出搭建完整的网络结构，实现前向传播过程。该函数中，参数x为输入，regularizer为正则化权重，返回值为预测或分类结果y。

def get_weight(shape, regularizer):

w = tf.Variable()

tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))

return w
第二个函数get_weight()对参数w设定。该函数中，参数shape表示参数w的形状，regularizer 表示正则化权重，返回值为参数w。其中，tf.variable()给w赋初值，tf.add_to_collection()表示将参数w正则化损失加到总损失losses中。

defget_bias(shape):       

b =tf.Variable(    )      

return b

第三个函数get_bias()对参数b进行设定。该函数中，参数shape表示参数b的形状,返回值为参数b。其中，tf.variable()表示给w赋初值。

反向传播：训练网络，优化网络参数，提高模型准确性。

def backward(  ):

x= tf.placeholder(    )

y_ = tf.placeholder(    ) 

y =forward.forward(x, REGULARIZER)

global_step = tf.Variable(0,trainable=False)   

loss =   

函数 backward()中，placeholder()实现对数据集x和标准答案y_占位，forward.forward()实现前向传播的网络结构，参数global_step表示训练轮数，设置为不可训练型参数。在训练网络模型时，常将正则化、指数衰减学习率和滑动平均这三个方法作为模型优化方法。

在Tensorflow中，正则化表示为：首先，计算预测结果与标准答案的损失值

①MSE：   y 与 y_的差距(loss_mse) =tf.reduce_mean(tf.square(y-y_)) 

②交叉熵：ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_, 1))    

y与 y_的差距(cem) = tf.reduce_mean(ce)    

③自定义：y 与 y_的差距

其次，总损失值为预测结果与标准答案的损失值加上正则化项

loss = y 与 y_的差距 +tf.add_n(tf.get_collection('losses'))     

在Tensorflow中，指数衰减学习率表示为：

learning_rate= tf.train.exponential_decay(LEARNING_RATE_BASE, global_step,

数据集总样本数 / BATCH_SIZE,

LEARNING_RATE_DECAY,staircase=True)

train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)
在Tensorflow中，滑动平均表示为：
ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

ema_op =ema.apply(tf.trainable_variables())

with tf.control_dependencies([train_step, ema_op]):

train_op = tf.no_op(name='train')

其中，滑动平均和指数衰减学习率中的global_step为同一个参数。

用with结构初始化所有参数 

with tf.Session() as sess:        
 init_op =tf.global_variables_initializer()       
    sess.run(init_op)  for i inrange(STEPS):
     sess.run(train_step, feed_dict={x:   , y_:  })            
        if i % 轮数 == 0:
          print

其中，with结构用于初始化所有参数信息以及实现调用训练过程，并打印出loss值。

判断python运行文件是否为主文件

if __name__=='__main__':

backward()

该部分用来判断python运行的文件是否为主文件。若是主文件，则执行backword()函数。 例如： 用300个符合正态分布的点X[x0, x1]作为数据集，根据点X[x0, x1]的不同进行标注Y_，将数据集标注为红色和蓝色。标注规则为：当x02 + x12 < 2 时，y_=1，点X标注为红色；当x02 + x12 2 时，y_=0，点X标注为蓝色。我们加入指数衰减学习率优化效率，加入正则化提高泛化性，并使用模块化设计方法，把红色点和蓝色点分开。

代码总共分为三个模块：生成数据集(generateds.py)、前向传播(forward.py)、反向传播(backward.py)。 

①生成数据集的模块(generateds.py) 

#coding:utf-8
#0导入模块 ，生成模拟数据集
import numpy as np
import matplotlib.pyplot as plt
seed = 2 
def generateds():
	#基于seed产生随机数
	rdm = np.random.RandomState(seed)
	#随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
	X = rdm.randn(300,2)
	#从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
	#作为输入数据集的标签（正确答案）
	Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
	#遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
	Y_c = [['red' if y else 'blue'] for y in Y_]
	#对数据集X和标签Y进行形状整理，第一个元素为-1表示跟随第二列计算，第二个元素表示多少列，可见X为两列，Y为1列
	X = np.vstack(X).reshape(-1,2)
	Y_ = np.vstack(Y_).reshape(-1,1)
	return X, Y_, Y_c	
#print X
#print Y_
#print Y_c
#用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
#plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
#plt.show()

②前向传播模块(forward.py)

#coding:utf-8
#0导入模块 ，生成模拟数据集
import tensorflow as tf
 
#定义神经网络的输入、参数和输出，定义前向传播过程 
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
	
def forward(x, regularizer):
	
	w1 = get_weight([2,11], regularizer)	
	b1 = get_bias([11])
	y1 = tf.nn.relu(tf.matmul(x, w1) + b1)
 
	w2 = get_weight([11,1], regularizer)
	b2 = get_bias([1])
	y = tf.matmul(y1, w2) + b2 
	
	return y

③反向传播模块(backward.py) 

#coding:utf-8
#0导入模块 ，生成模拟数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import opt4_8_generateds
import opt4_8_forward
 
STEPS = 40000
BATCH_SIZE = 30 
LEARNING_RATE_BASE = 0.001
LEARNING_RATE_DECAY = 0.999
REGULARIZER = 0.01
 
def backward():
	x = tf.placeholder(tf.float32, shape=(None, 2))
	y_ = tf.placeholder(tf.float32, shape=(None, 1))
 
	X, Y_, Y_c = opt4_8_generateds.generateds()
 
	y = opt4_8_forward.forward(x, REGULARIZER)
	
	global_step = tf.Variable(0,trainable=False)	
 
	learning_rate = tf.train.exponential_decay(
		LEARNING_RATE_BASE,
		global_step,
		300/BATCH_SIZE,
		LEARNING_RATE_DECAY,
		staircase=True)
 
 
	#定义损失函数
	loss_mse = tf.reduce_mean(tf.square(y-y_))
	loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
	
	#定义反向传播方法：包含正则化
	train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)
 
	with tf.Session() as sess:
		init_op = tf.global_variables_initializer()
		sess.run(init_op)
		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 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)
	
	plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
	plt.contour(xx, yy, probs, levels=[.5])
	plt.show()
	
if __name__=='__main__':
	backward()

运行结果如下：

由运行结果可见，程序使用模块化设计方法，加入指数衰减学习率，使用正则化后，红色点和蓝色点的分割曲线相对平滑，效果变好。

//本文部分图片和代码来自于skytoby，找图比较麻烦。

学分
关注
专栏目录
神经网络优化-正则化&DropOut
Bazingaea的博客
10-28 694
  实现正则化主要需要在两个地方做出修改： 1.cost计算（L2 regularization） #正则化 n = len(parameters)//2 cost_extra = 0 for x in range(n): w = parameters['w'+str(x+1)] cost_extra += np.sum(np...
神经网络的优化（4）----正则化
liupc的学习笔记
04-18 376
点击此处返回总目录 下面开始讲regularization。 ...
神经网络优化----正则化
yijiancmy的博客
02-10 452
过拟合：神经网络模型在训练数据集上的准确率较高，在新的数据进行预测或分类时准确率较低，说明模型的泛化能力差。 正则化：在损失函数中给每个参数w加上权重，引入模型复杂度指标，从而抑制模型噪声，减小过拟合。 使用正则化后，损失函数loss变为两项之和： loss = loss(y与y_) + REGULARIZER * loss(w) 其中，第一项是预测解锁与标准答案之间的差距，如之前讲过的交叉熵、均...
神经网络优化（二） - 滑动平均
weixin_33950035的博客
11-03 453
1 滑动平均概述 滑动平均（也称为 影子值 ）：记录了每一个参数一段时间内过往值的平均，增加了模型的泛化性。 滑动平均通常针对所有参数进行优化：W 和 b， 简单地理解，滑动平均像是给参数加了一个影子，参数变化，影子缓慢追随。 滑动平均的表示公式为 影子 = 衰减率 * 影子 + ( 1 - 衰减率 ) * 参数 或 滑动平均值 = 衰减率 * 滑动平均值 + ( 1 - 衰减率 ）...
Tensorflow 神经网络优化 关于滑动平均 正则化
Castanea的博客
08-19 277
滑动平均 滑动平均（影子值）：记录了每个参数一段时间内过往值的平均，增加了模型的泛化性。 针对所有参数：w和b （像是给参数加了影子，参数变化，影子缓慢追随/） 影子 = 衰减率* 影子 +（1 - 衰减率）* 参数 影子初值 = 参数初值 衰减率 = min{MOVING_AVERAGE_DECAY, } step为轮数 #参数为 衰减率当前轮数 ema=tf.train....
【TensorFlow】MNIST（使用全连接神经网络+滑动平均+正则化+指数衰减法+激活函数）
widiot的博客
12-09 2889
代码已上传至 Github —— mnist_all.py 下载MNIST数据集 以下有两种下载方式，如果链接失效可以搜索网上的资源 官方下载地址（可能需要梯子） 百度网盘下载 密码: 84pb 下载之后将其放在 mnist/data/ 文件夹下，目录结构如下 mnist mnist_all.py data/ train-images-idx
TensorFlow MNIST神经网络实战：正则化与滑动平均
代码定义了两个函数：inference用于执行神经网络的前向传播，接受输入张量（input_tensor），以及可能的滑动平均类对象（avg_class），然后计算经过ReLU激活后的隐藏层输出，最后通过第二个权重矩阵（weights2）和...
TensorFlow神经网络优化策略学习
12-23
总结来说，TensorFlow提供了丰富的工具和策略来优化神经网络的训练，包括指数衰减的学习率调整、正则化技术来防止过拟合，以及滑动平均模型以提升模型在未知数据上的表现。理解和掌握这些技术对于构建高性能的深度...
卷积神经网络优化：学习率调整与正则化技术
随着网络模型的不断发展和优化，学习率调整和正则化技术成为了提升卷积神经网络性能的重要手段。 ## 1.2 目的和意义 本章将介绍卷积神经网络优化中学习率调整和正则化技术的原理和应用。学习率调整方法对于网络的...
CNN神经网络优化常用函数范式一览(损失函数loss,学习率learning_rate,滑动平均ema,正则化regularization)
dolor_059的博客
08-27 4739
来源: 学习北大曹健老师Tensorflow课程后做的学习笔记,整理后在此分享给大家. 之前是抄在本子上的, 可能存在一些抄写错误或是标记缺失, 若发现了可以评论告诉我.谢谢. 一. 损失函数(loss):预测值y与已知答案y_的差距 神经网络优化目标即找到适合的w以减小loss, 有三种减小loss的方法 1. 均方误差mse(Mean Squared Error) 2. 自定义损失函...
神经网络中的网络优化和正则化（一）之学习率衰减和动态梯度方向
Thinkgamer博客
09-22 2272
引言 神经网络中的网络优化和正则化问题介绍主要分为上，中，下三篇进行介绍。 上篇包括 网络优化和正则化概述 优化算法介绍 中篇包括 参数初始化 数据预处理 逐层归一化 超参数优化 下篇包括 网络正则化 概述 虽然神经网络有比较强的表达能力，但是应用神经网络到机器学习任务时仍存在一些问题，主要分为： 网络优化 神经网络模型是一个非凸函数，再加上神经网络中的梯度消失和梯度...
神经网络中的最优化方法及正则化
wusecaiyun的专栏
02-24 347
第一篇《Intro to optimization in deep learning: Gradient Descent》https://blog.paperspace.com/intro-to-optimization-in-deep-learning-gradient-descent/ 第二篇《Intro to optimization in deep learning: Moment...
TensorFlow笔记-07-神经网络优化-学习率,滑动平均
热门推荐
肖朋伟
08-28 1万+
TensorFlow 笔记-06-神经网络优化-交叉熵，学习率 交叉熵 交叉熵（Cross Entropy）：表示两个概率分布之间的距离，交叉熵越大，两个概率分布距离越远，两个概率分布越相异；交叉熵越小，两个概率分布距离越近，两个概率分布越相似 交叉熵计算公式：H(y_, y) = -Σy_ * log y 用 Tensorflow 函数表示 ce = -tf.reduce_mean(...
2.4神经网络优化之正则化
SuperBetterMan的博客
04-03 299
在提出正则化这个概念之前，我们先介绍过拟合现象。所谓过拟合就是所训练的模型仅仅适用于训练集，对于新的数据就不适用。那么如何解决过拟合呢？我们提出正则化方法，通过正则化方法可以有效解决过拟合 正则化就是在损失函数引入复杂度指标，利用给参数加权值，以弱化训练数据的噪声 使用正则化后，损失函数loss变成两部分 在图片中,我们看到如何在代码去实现求loss(w) eg.生成一套数据集，随机产生300个...
tensorflow笔记3：之神经网络优化算法二（正则化、滑动平均模型）
AI新视界
12-11 1104
目录 1、神经网络进一步优化——过拟合与正则化 2、神经网络进一步优化 ——滑动平均模型 1、神经网络进一步优化——过拟合与正则化 过拟合，指的是当一个模型过为复杂后，它可以很好的“记忆”每一个训练数据中随机噪音的部分而忘了要去“学习”训练数据中通用的趋势。举一个极端的例子，如果一个模型中的参数比训练数据的总数还多，那么只要训练数据不冲突，这个模型完全可以记住所有训练数据的结果从...
优化之——滑动平均模型
zd_nupt的博客
01-05 925
滑动平均模型可以使模型在测试数据上更加健壮。仅用于测试数据。 shadow_variable = decay*shadow_variable+(1-decay)*variable decay为衰减率， variable为待更新的变量。 decay=min(decay_base,(1+global_step)/(10+global_step)) decay越大模型越稳定，一般设置为0.999，，
TensoFlow解决过拟合问题：正则化、滑动平均模型、衰减率
萝卜虫的博客
04-29 4216
对多层神经网络的总结激活函数　　神经网络解决非线性问题的方法是使用激活函数，TensorFlow中常用的激活函数有：tf.nn.relu、tf.sigmoid、tf.tanh。 　　使用激活函数的前向传播算法：a = tf.nn.relu(tf.matmul(x, w1) + biases1。 　　 反向传播算法 　　 反向传播算法是训练神经网络的核心算法。它可以根据定义好的损失函数优化神经网
深层神经网络——滑动平均模型
魂小猫的博客
07-20 6010
在采用随机梯度下降算法训练神经网络时，使用滑动平均模型在很多应用中都可以在一定程度上提高最终模型在测试数据上的表笑。 在Tensorflow中提供了tf.train.ExponentialMovingAverage来实现滑动平均模型。在初始化ExponentialMovingAverage 时，需要提供一个衰减率（decay）。这个衰减率会用于控制模型的更新速度。ExponentialMovin
神经网络优化--滑动平均
yijiancmy的博客
02-10 1758
滑动平均：记录了一段时间内模型中所有参数w和b各自的平均值。利用滑动平均值可以增强模型的泛化能力。 滑动平均值（影子）计算公式： 影子 = 衰减率 * 影子 + (1 - 衰减率) * 参数 其中，影子初值 = 参数初值 用Tensorflow函数表示为： ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_s...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值