【TensorFlow】MNIST数字识别问题

共有三个程序：

• mnist.inference.py：定义了前向传播的过程以及神经网络中的参数
• mnist_train.py：定义了神经网络的训练过程
• mnist_eval.py：定义了测试过程

【mnist_inference.py】
在这段代码中定义了神经网络的前向传播算法。无论是训练时还是测试时，都可以直接调用inference这个函数，而不用关心具体的神经网络结构

import tensorflow as tf

INPUT_NODE = 784
OUTPUT_NODE = 10
LAYER1_NODE = 500

# 通过tf.get_variable函数来获取变量。
# tensorflow提供了通过变量名称来创建或者获取一个变量的机制，通过这个机制，在不同的函数中可以直接通过变量的名字来使用变量，而不需要将变量通过参数的形式到处传递， 下面这两个定义是等价的
# v = tf.get_variable("v", shape=[1], initializer=tf.constant_initiaizer(1.0))
# v = tf.Variable(tf.constant(1.0, shape=[1], name="v"))
# 在训练时神经网络会创建这些变量；在测试时会通过保存的模型加载这些变量的取值，而且更加方便的是，因为可以在变量加载时将滑动平均变量重命名，所以可以直接通过同样的名字在训练时使用变量自身，而在测试时使用变量的滑动平均值。在这个函数中也会讲变量的正则化损失加入损失集合
def get_weight_variable(shape, regularizer):
	weights = tf.get_variable("weights", shape, initializer=tf.truncated_normal_initializer(stddev=0.1))
	
	# 当给出了正则化生成函数时，将当前变量的正则化损失加入名字为losses的集合
	if regularizer != None:
		tf.add_to_collection('losses', regularizer(weights))
	
	return weights

# 定义神经网络的前向传播过程
def inference(input_tensor, regularizer):
	# 声明第一层神经网络的变量并完成前向传播过程
	with tf.variable_scope('layer1'):
		weights = get_weight_variable([INPUT_NODE, LAYER1_NODE], regularizer)
		biases = tf.get_variable("biases", [LAYER1_NODE], initializer=tf.constant_initializer(0.0))
		layer1 = tf.nn.relu(tf.matmul(input_tensor, weights)+biases)
	
	# 声明第二层神经网络的变量并完成前向传播过程
	with tf.variable_scope('layer2'):
		weights = get_weight_variable([LAYER1_NODE, OUTPUT_NODE], regularizer)
		biases = tf.get_variable("biases", [OUTPUT_NODE], initializer=tf.constant_initializer(0.0))
		layer2 = tf.matmul(layer1, weights) + biases
	
	return layer2

【mnist_train.py】
使用定义好的前向传播过程，以下代码给出了神经网络的训练程序：

import os
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

import mnist_inference

BATCH_SIZE = 100
LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.9
REGULARAZTION_RATE = 0.0001
TRAINING_STEPS = 30000
MOVIING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH = '/path/to/model'
MODEL_NAME = 'model.ckpt'

def train(mnist):
	# 定义输入输出placeholder
	x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
	y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')

	regularizer = tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
	
	y = mnist_inference.inference(x, regularizer)
	global_step = tf.Variable(0, trainable=False)

	# 滑动平均操作
	variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
	variables_averrages_op = avriabe_averrages.apply(tf.trainable_variables())

	cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
	cross_entropy_mean = tf.refuce_mean(cross_entropy)
	loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))

	learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, mnist.train.num_examples/BATCH_SIZE, LEARNING_RATE_DECAY)
	
	train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

	# 既反向传播，又滑动平均参数更新
	with tf.control_dependencies([train_step, variables_averages_op]):
		train_op = tf.no_op(name='train')

	saver = tf.train.Saver()
	with tf.Session() as sess:
		tf.global_vatiables_initializer().run()

		for i in range(TRAINING_STEPS):
			xs, ys = mnist.train.next_batch(BATCH_SIZE)
			_, loss_value, step = sess.run([train_op, loss, global_step],
											feed_dict={x:xs, y_:ys}})
		
		if i%1000 == 0:
		# 保存当前的模型，注意这里给出了global_step参数，这样可以让每个被保存模型的文件名末尾加上训练的轮数，比如model.ckpt-1000
			saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_setp)

def main(argv=None):
	mnist = input_data.read_data_sets("/path/to/mnist_data", one_hot=True)
	train(mnist)

if __name__ == '__main__':
	tf.app.run()

【mnist_eval.py】
在以上程序中，每1000轮保存一次训练好的模型，这样可以通过一个单独的测试程序，更加方便的在滑动平均模型上做测试。

import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

import mnist_inference
import mnist_train

# 每10秒加载一次最新的模型，并在测试数据上测试最新模型的正确率
EVAL_INTERVAL_SECS = 10

def evaluate(mnist):
	with tf.Graph().as_default() as g:
		x = tf.placeholder(tf.float32, [None, mnist_inference.INPUT_NODE], name='x-input')
		y_ = tf.placeholder(tf.float32, [None, mnist_inference.OUTPUT_NODE], name='y-input')
		validate_feed = {x:mnist.validation.images, y_:mnist.validation.labels}

		# 直接通过调用封装好的函数来计算前向传播的结果，因为测试时不关注正则化损失的值，所以这里用于计算正则化损失损失的函数被设置为None
		y = mnist_inference.inference(x, None)

		correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
		accuracy = tf.reduce_mean((tf.cast(correct_prediction, tf.float32)))

		# 通过变量重命名的方式来加载模型，这样在前向传播的过程中就不需要调用求滑动平均的函数来获取平均值了，这样就可以完全共用mnist_inference.py中定义的前向传播过程
		# 在采用随机梯度下降算法训练神经网络时，使用滑动平均模型在很多应用中都可以在一定程度提高最终模型在测试数据上的表现，
		# 在tensorflow中提供了tf.train.ExpotentialMovingAverage来实现滑动平均模型，
		# 在初始化ExpotentialMovingAverage时，需要提供一个衰减率，这个衰减率将用于控制模型更新的速度，
		# ExpotentialMovingAverage对每一个变量会维护一个影子变量，这个影子变量的初始值就是相应变量的初始值，
		# 每次运行变量更新时，影子变量的值会更新为shadow_variable=decay*shadow_variable + (1-decay)*variable.
		# 其中shadow_variable为影子变量，variable为待更新的变量，decay为衰减率
		# decay决定了模型更新的速度，decay越大模型越趋于稳定
		variable_averages = tf.train.ExponentialMovingAverage(mnist_train.MOVING_AVERAGE_DECAY)
		variables_to_restore = variable_averages.variables_to_restore()
		saver = tf.train.Saver(variables_to_restore)
		
		while True:
			with tf.Session() as sess:
				# tf.train.get_checkpoint_state函数会通过checkpoint文件自动找到目录中最新模型的文件名
				ckpt = tf.train.get_checkpoint_state(mnist_train.MODEL_SAVE_PATH)
				if ckpt and ckpt.model_checkpoint_path:
					saver.restore(sess, ckpt.model_checkpoint_path)

					# 通过文件名得到模型保存时迭代的轮数
					global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
					accuracy_score = sess.run(accuracy, feed_dict=validate_feed)
					print("After %s training steps, validation accuracy=%g" % (global_step, accuracy_score))
				else:
					print('No checkpoint file found')
					return
			time.sleep(EVAL_INTERVAL_SECS)

def main(argv=None):
	mnist = input_data.read_data_sets("/path/to/mnist_data", one_hot=True)
	evaluate(mnist)

if __name__ == '__main__':
	tf.app.run()

参考资料：
TensorFlow实战Google深度学习框架-中国公信出版集团