TensorFlow神经网络：模块化的神经网络八股

1、前向传播：

搭建从输入到输出的网络结构
forward.py:

# 定义前向传播过程
def forward(x, regularizer):
	w = 
	b = 
	y = 
	return y

# 给w赋初值，并把w的正则化损失加到总损失中
def get_weight(shape, regularizer):
	w = tf.Variable()
	tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
	return w

def get_bias(shape)
	b = tf.Variable()
	return b

2、反向传播

训练网络，优化网络参数，提高模型准确性
backward.py：

# 定义反向传播
def backward():
	# 对数据集x和标准答案y_占位
	x = tf.placeholder()
	y_ = tf.placeholder(
		)
	# 利用forward模块复现前向传播网络的结构，计算得到y
	y = forward.forward(x, REGULARIZER)

	# 定义轮数计数器
	global_step = tf.Variable(0, trainable = False)

	# 定义损失函数
	loss = 

	'''
	# 均方误差
	loss = tf.reduce_mean(tf.square(y - y_))
	# 交叉熵
	ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = y, lables = tf.argmax(y_, 1))
	loss = tf.reduce_mean(ce)
	'''

	# 在训练网络模型时
	# 常常将1正则化、2指数衰减学习率、3滑动平均这三个方法作为优化模型的方法
	
	'''
	# 使用正则化时的损失函数
	loss = loss(y, y_) + tf.add_n(tf.get_collection('losses'))

	# 使用指数衰减的学习率时，加上：
	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)
	
	# 如果使用滑动平均时，加上：
	'''
	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')
	'''

	# 训练过程
	with tf.Session() as sess:
		# 初始化所有参数
		init_op = tf.global_variables_initializer()
		sess.run(init_op)
		# 循环迭代
		for i in range(STEPS):
			# 每轮调用sess.run执行训练过程train_step
			sess.run(train_step, feed_dict = {x: , y_: })
			# 每运行一定轮数，打印出当前的loss信息
			if i %  轮数==0
			    print

3、判断主文件

# 判断python运行文件是否为主文件，如果是，则执行
if __name__ == '__main__':
	backward()

4、实例模块化展示

加入指数衰减学习率–优化效率
加入正则化–提高泛化性能
模块化设计
① generateds.py

# modelNN_generateds.py
# 数据导入模块，生成模拟数据集
# coding: utf-8

import numpy as np
import matplotlib.pyplot as plt
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'  #hide warnings

seed = 2

def generateds():
	# 基于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) 

	return X, Y_, Y_c

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

② forward.py

# modelNN_generateds.py
# 前向传播模块
# 定义神经网络的输入、参数和输出，定义前向传播过程
# coding: utf-8

import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'  #hide warnings

# 给w赋初值，并把w的正则化损失加到总损失中
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

# 给b赋初值
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

# modelNN_generateds.py
# 反向传播模块
# 定义神经网络的反向传播过程
# coding: utf-8

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import modelNN_generateds
import modelNN_forward
import os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'  #hide warnings

# 定义超参数
STEPS = 40000 #训练轮数
BATCH_SIZE = 30 
LEARNING_RATE_BASE = 0.001 #初始学习率
LEARNING_RATE_DECAY = 0.999 # 学习率衰减率
REGULARIZER = 0.01 # 正则化参数

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

	# 生成数据集
	X, Y_, Y_c = modelNN_generateds.generateds()

	# 前向传播推测输出y
	y = modelNN_forward.forward(x, REGULARIZER)

	# 定义global_step
	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 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)

	# 可视化
	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()

# 判断python运行文件是否为主文件，如果是，则执行
if __name__ == '__main__':
	backward()

在这里插入图片描述

TensorFlow神经网络：模块化的神经网络八股

猜你喜欢