tensorflow笔记04

tensorflow笔记04:神经网络搭建的模块化过程

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

定义前向传播首先要定义三个函数：

1.1 forward()

def forward(x, regularizer):
	 w=				#权重参数
     b=				#偏置项bias
     y=				#网络输出结果，或预分类结果
     return y

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

1.2 get_weight()

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 中。

1.3 get_bias()

def get_bias(shape):
	b = tf.Variable()				#偏置bias
    return b

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

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

2.1 backward()

def backward( ):
    x = tf.placeholder()				#给输入x 占位
    y_ = tf.placeholder()				#给标准值y_的输入 占位

    y = forward.forward(x, REGULARIZER)
    global_step = tf.Variable(0, trainable=False)
    loss =
......

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

2.2 设置正则化

在 Tensorflow 中,正则化表示为:

1. 首先,计算预测结果与标准答案的损失值
   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_的差距
2. 其次,总损失值为预测结果与标准答案的损失值加上正则化项
   loss = y 与 y_的差距 + tf.add_n(tf.get_collection(‘losses’))

2.3 设置指数衰减学习率

在 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)

2.4 设置滑动平均

在 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 为同一个参数。

2.5 使用with结构初始化神经网络的变量

用 with 结构初始化所有参数

with tf.Session() as sess:
	init_op = tf.global_variables_initializer()
	sess.run(init_op)				#初始化参数
	for i in range(STEPS):
		sess.run(train_step, feed_dict={x:, y_:)				#开始训练，并喂入数据
		if i % 轮数 == 0:
			print

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

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

if __name__=='__main__':
        backward()

该部分用来判断 python 运行的文件是否为主文件。若是主文件,则执行 backword()函数。

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

这个模块用于数据集的整理，使得格式能正确喂入神经网络

最后 实例演示

例如:
用 300 个符合正态分布的点 X[x 0 , x 1 ]作为数据集,根据点 X[x 0 , x 1 ]的不同进行标注 Y_,将数据集标
注为红色和蓝色。标注规则为:当 x 02 + x 12 < 2 时,y_=1,点 X 标注为红色;当 x 02 + x 12 ≥2 时,
y_=0,点 X 标注为蓝色。我们加入指数衰减学习率优化效率,加入正则化提高泛化性,并使用模块化
设计方法,把红色点和蓝色点分开。

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

1生 成 数 据 集 (module_generate_data.py)

#coding:utf-8
#产生数据集模块
import numpy as np

def generate():

	SEED = 2
	rand = np.random.RandomState(SEED)
	X = rand.randn(300,2)
	Y_ = [int(x0*x0+x1*x1<2) for (x0,x1) in X]
	Y_c = [['red' if y else 'blue'] for y in Y_]
	X = np.vstack(X).reshape(-1,2)
	Y_ = np.vstack(Y_).reshape(-1,1)
	print X
	print Y_
	print Y_c
	return X,Y_,Y_c

2前 向 传 播 (forward.py)

#coding:utf-8

import tensorflow as tf
#module:forward
import numpy as np

#定义三个函数
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

3反 向 传 播(backward.py)

#coding:utf-8
import tensorflow as tf 
import matplotlib.pyplot as plt
import numpy as np
import module_generate_data
import forward

#轮数
STEPS = 40000
#喂入数据大小
BATCH_SIZE = 30
#设定指数衰减的学习率
learning_rate_decay = 0.999
learning_rate_base = 0.001
#设置正则化系数
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 = module_generate_data.generate()

	y = 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_opt = tf.global_variables_initializer()
		sess.run(init_opt)
		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 ,the 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()

在终端输入 python backward.py,效果如下：
原本的数据图：

分类效果：线的划分还算平滑。