TensorFlow笔记-制作自己的训练集，利用卷积神经网络模型进行训练、测试

TensorFlow笔记-制作自己的训练集，利用卷积神经网络模型进行训练、测试（完整流程）
https://blog.csdn.net/jyy555555/article/details/80283219
在学习TensorFlow过程中，发现训练数据集（mnist）大都是直接从网上下载，直接加载到模型上。而如果我们大多时候需要用自己的图片进行训练、测试，为了解决这个问题，在网上看了很多教程，大概明白了制作自己训练数据集的过程。为此，以MNIST数字识别为例，总结一下训练神经网络模型的大致流程。主要包括以下几个部分：

一. 制作自己的数据集
通常情况下，我们需要利用自己的图片进行训练，一种方式是把训练数据存储到TFRecord文件，然后从TFRecord文件中读取样例进行解析，然后组合训练数据（batch）；另一种是网上的例子，可以从本地磁盘文件中读取图片，直接组合成batch样本数据。下面结合程序介绍一下这两种方式。

1. 通过TFRecord文件制作自己的数据集
TensorFlow提供了一种统一的格式来存储数据，这个格式就是TFRecord。TFRecord可以统一不同的原始数据格式，并更加有效地管理不同的属性。以下程序是把MNIST数据集中所有的训练数据存储到一个TFRecord文件中。

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import numpy as np
from PIL import Image
import os

#输出TFRecord文件的地址
filename="f:\\TFRecord\\output.tfrecords"
#创建一个writer来写TFRecord文件
writer=tf.python_io.TFRecordWriter(filename)
#---将MNIST数据集中所有的训练数据存储到一个TFRecord文件中--#
 
#生成字符型的属性

def _bytes_feature(value):
	return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))

#生成整数型的属性
    def _int64_feature(value):
    	return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
	
mnist=input_data.read_data_sets("/tmp/data/",dtype=tf.uint8,one_hot=True)
#MNIST数据集中的训练样本
images=mnist.train.images
#训练数据所对应的标签，可以作为一个属性保存在TFRecord中
labels=mnist.train.labels
#训练图像的分辨率，作为Example中的一个属性
pixels=images.shape[1]
#训练样本个数
num_examples=mnist.train.num_examples
 
for index in range(num_examples):
	#将图像矩阵转化成一个字符串
	image_raw=images[index].tostring()
	#将一个样例转化成Example Protocol Buffer，并将所有的信息写入这个数据结构
	example=tf.train.Example(features=tf.train.Features(feature={
	           'pixels': _int64_feature(pixels),
			   'label': _int64_feature(np.argmax(labels[index])),
			   'image_raw': _bytes_feature(image_raw)}))
	
	#将一个Example写入TFRecord文件中
	writer.write(example.SerializeToString())
writer.close()

我们也可以把本地磁盘文件中的图片存储到TFRecord文件中，下面程序就是把本地猫狗大战训练集中的训练数据存储到一个TFRecord文件中。猫狗大战数据集在这 链接：http://pan.baidu.com/s/1dFd8kmt 密码：psor

#---从自己电脑磁盘文件中读取图片，存储到一个TFRecord文件中，这里把猫狗大战的训练样本存储到一个TFRecord文件中---#
 
#猫狗大战训练样本在本地磁盘中的地址
file_dir="f:\\cat_dog_image\\train\\"
 
#生成字符型的属性
def _bytes_feature(value):
	return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))

#生成整数型的属性
def _int64_feature(value):
	return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
	
for file in os.listdir(file_dir):
	img_path=file_dir+file  #每个图片的地址
	img=Image.open(img_path)
	name = file.split(sep='.')
	if name[0]=='cat':
		label=0
	else:
		label=1
#将图像矩阵转化成一个字符串
	image_raw=img.tobytes()
	#获取图像尺寸
	(img_W,img_H)=img.size
	#图像通道数
	channels=3
	#将一个样例转化成Example Protocol Buffer，并将所有的信息写入这个数据结构
	example=tf.train.Example(features=tf.train.Features(feature={
	           'img_W': _int64_feature(img_W),
			   'img_H': _int64_feature(img_H),
			   'channels': _int64_feature(channels),
			   'label': _int64_feature(label),
			   'image_raw': _bytes_feature(image_raw)}))
	
	#将一个Example写入TFRecord文件中
	writer.write(example.SerializeToString())
writer.close()

接下来就是从TFRecord文件中读取单个样例并解析，然后将多个输入样例组织成一个batch可以提高模型训练的效率。TensorFlow提供了tf.train.batch > 和 > tf.train.shuffle_batch函数来将单个样例组织成batch的形式输出。这两个函数都会生成一个队列，队列的入队操作是生成单个样例的方法，而每个出队得到的是一个batch的样例。它们唯一区别就是是否将数据顺序打乱。以下是从TFRecord文件中读取并解析数据，然后组成batch的程序：

import tensorflow as tf
 
def get_batch(file_dir):
	#读取TFRecord文件，创建文件列表，并通过文件列表创建输入文件队列。在调用输入数据处理流程前，需要统一所有原始数据的格式并将它们存储到TFRecord文件中。
	files=tf.train.match_filenames_once(file_dir)
	filename_queue=tf.train.string_input_producer(files,shuffle=True) #不随机打乱
 
	#解析TFRecord文件里的数据
	reader=tf.TFRecordReader()
	_,serialized_example=reader.read(filename_queue)
	features=tf.parse_single_example(serialized_example,
		features={
			'image_raw': tf.FixedLenFeature([],tf.string),
			'label': tf.FixedLenFeature([],tf.int64),
			'pixels': tf.FixedLenFeature([],tf.int64),
			})
		  
	#得到图像原始数据、尺寸、标签。
	image,label,pixels=features['image_raw'],features['label'],features['pixels']
 
	#从原始图像数据解析出像素矩阵，并根据图像尺寸还原图像
	decode_image=tf.decode_raw(image,tf.uint8)
	decode_image=tf.reshape(decode_image,[28,28,1])
 
	#将图像和标签数据通过tf.train.shuffle_batch整理成神经网络训练时需要的batch
	min_after_dequeue=10000
	batch_size=100
	capacity=min_after_dequeue+3*batch_size
	image_batch,label_batch=tf.train.shuffle_batch([decode_image,label],batch_size=batch_size,capacity=capacity,min_after_dequeue=min_after_dequeue)
	
	image_batch=tf.cast(image_batch,tf.float32)
	#返回batch数据
	return image_batch,label_batch

一般情况下，我们可以把数据分成多个TFRecord文件来提高处理效率，这里我们把数据存储到一个TFRecord文件中。TnesorFlow提供了tf.train.match_filenames_once函数来获取一个正则表达式的所有文件，然后通过tf.train.string_input_producer函数创建一个输入队列，输入队列中原始的元素为文件列表中的所有文件。通过设置shuffle参数，tf.train.string_input_producer函数支持随机打乱文件列表中文件出队的顺序。当shuffle为True，文件加入队列之前的顺序会打乱，那么出队顺序也会打乱。随机打乱文件顺序以及加入输入队列的过程会运行在一个单独的线程上，这样不会影响获取文件的速度，为此TensorFlow提供了一套多线程输入数据处理的框架。

tf.train.batch 和 tf.train.shuffle_batch函数除了可以将单个训练数据整理成输入batch，也提供了并行化处理输入数据的方法，它们并行化的方式一致。通过设置tf.train.batch函数中的num_threads参数，可以指定多个线程同时执行入队操作。tf.train.batch函数的入队操作就是数据读取以及预处理的过程。当num_threads参数大于1时，多个线程会同时读取一个文件中的不同样例并进行预处理。下面另一种方式中设置了num_threds=64，开启多个线程同时读取文件中的不同样例。

2. 直接读取本地图片制作自己的数据集

import tensorflow as tf
import os
import numpy as np
 
#生成训练图片的路径
train_dir='f:\\cat_dog_image\\train\\'
 
 
#获取图片，存放到对应的列表中，同时贴上标签，存放到label列表中
def get_files(file_dir):
 
	cats =[]
	label_cats =[]
	dogs =[]
	label_dogs =[]
	for file in os.listdir(file_dir):
		name = file.split(sep='.')
		if name[0]=='cat':
			cats.append(file_dir + file)
			label_cats.append(0)
		else:
			dogs.append(file_dir + file)
			label_dogs.append(1)
	#合并数据
	image_list = np.hstack((cats, dogs))
	label_list = np.hstack((label_cats, label_dogs))
	#利用shuffle打乱数据
	temp = np.array([image_list, label_list])
	temp = temp.transpose()  # 转置
	np.random.shuffle(temp)
		
	#将所有的image和label转换成list
	image_list = list(temp[:, 0])
	label_list = list(temp[:, 1])
	label_list = [int(i) for i in label_list]
 
	return image_list, label_list
		
#将上面生成的List传入get_batch() ，转换类型，产生一个输入队列queue，因为img和lab  
#是分开的，所以使用tf.train.slice_input_producer()，然后用tf.read_file()从队列中读取图像
def get_batch(image,label,image_W,image_H,batch_size,capacity):
 
	#将python.list类型转换成tf能够识别的格式
	image=tf.cast(image,tf.string)
	label=tf.cast(label,tf.int32)
	
	#产生一个输入队列queue
	input_queue=tf.train.slice_input_producer([image,label])
	
	label=input_queue[1]
	image_contents=tf.read_file(input_queue[0])
	#将图像解码，不同类型的图像不能混在一起，要么只用jpeg，要么只用png等。  
	image=tf.image.decode_jpeg(image_contents,channels=3)
	
	#将数据预处理，对图像进行旋转、缩放、裁剪、归一化等操作，让计算出的模型更健壮。
	image=tf.image.resize_image_with_crop_or_pad(image,image_W,image_H)
	image=tf.image.per_image_standardization(image)
	
	#生成batch
	image_batch,label_batch=tf.train.batch([image,label],batch_size=batch_size,num_threads=64,capacity=capacity)
	
	#重新排列标签，行数为[batch_size]
	#label_batch=tf.reshape(label_batch,[batch_size])
	image_batch=tf.cast(image_batch,tf.float32)
	
	return image_batch,label_batch

二. 定义神将网络结构
当训练集准备完成后，接下来就是训练神将网络模型。首先我们要先定义前向传播的过程以及神将网络中的参数，这里我们以MNIST数字识别为例，所以我们采用经典的卷积神将网络模型（LeNet模型）。LeNet-5模型是Yann LeCun教授于1998年在论文Gradient-based learning applied to document recognition中提出的，它是第一个应用于数字识别问题的卷积神经网络。在MNIST数据集上，LeNet-5模型可以达到大约99.2%的正确率。LeNet-5模型总共有7层（不包括输入）。网上有很多关于卷积神经网络的讲解，这里就不细说了，下面主要说一下如何用程序实现LeNet-5模型。可以参考《TensorFlow实战Google深度学习框架》实现类似LeNet-5模型的卷积神经网络结构。

# -*- coding: utf-8 -*-
import tensorflow as tf
 
#配置神经网络的参数
INPUT_NODE=784
OUTPUT_NODE=10
 
IMAGE_SIZE=28
NUM_CHANNELS=1
NUM_LABELS=10
 
#第一层卷积层的尺寸和深度
CONV1_DEEP=6
CONV1_SIZE=5
 
#第三层卷积层的尺寸和深度
CONV2_DEEP=16
CONV2_SIZE=5
 
#第五层卷积层的尺寸和深度
CONV3_DEEP=120
CONV3_SIZE=5
 
#全连接层的节点个数
FC_SIZE=84
 
 
#定义卷积神经网络的前向传播过程。这里添加一个新的参数train，用于区分训练过程和测试过程。在这个程序中将用到Ddropout方法，dropout可以进一步提升模型可靠性
#并防止过拟合，dropout过程只在训练时使用。
def inference(input_tensor,train,regularizer):
	#声明第一层卷积层的变量并实现前向传播过程。通过使用不同的命名空间来隔离不同层的变量，这可以让每一层中的变量命名只需要考虑
	#在当前层的作用，而不需要担心重名的问题。和标准的LeNet-5模型不太一样，这里定义的卷积层输入为28x28x1的原始MNIST图片像素。
	#因为卷积层中使用了全0填充，所以输出为28x28x6的矩阵。
	with tf.variable_scope('layer1-conv1'):
		conv1_weights=tf.get_variable("weight",[CONV1_SIZE,CONV1_SIZE,NUM_CHANNELS,CONV1_DEEP],initializer=tf.truncated_normal_initializer(stddev=0.1))
		conv1_biases=tf.get_variable("bias",[CONV1_DEEP],initializer=tf.constant_initializer(0.0))
		
		#使用边长为5，深度为6的过滤器，过滤器移动的步长为1，且使用全0填充。
		conv1=tf.nn.conv2d(input_tensor,conv1_weights,strides=[1,1,1,1],padding='SAME')
		relu1=tf.nn.relu(tf.nn.bias_add(conv1,conv1_biases))
		
	#实现第二层池化层的前向传播过程。这里选用最大池化层，池化层过滤器的边长为2，使用全0填充且移动的步长为2.这一层的输入为上一层的输出
	#也就是28x28x6的矩阵。输出为14x14x6的矩阵。
	with tf.name_scope('layer2-pool1'):
		pool1=tf.nn.max_pool(relu1,ksize=[1,2,2,1],strides=[1,2,2,1],padding='VALID')
		
	#声明第三层卷积层的变量并实现前向传播过程。这一层输入为14x14x6的矩阵，因为卷积层没有使用全0填充，所以输出为10x10x16的矩阵
	with tf.variable_scope('layer3-conv2'):
		conv2_weights=tf.get_variable("weight",[CONV2_SIZE,CONV2_SIZE,CONV1_DEEP,CONV2_DEEP],initializer=tf.truncated_normal_initializer(stddev=0.1))
		conv2_biases=tf.get_variable("bias",[CONV2_DEEP],initializer=tf.constant_initializer(0.0))
		
		#使用边长为5，深度为16的过滤器，过滤器移动的步长为1，不使用全0填充
		conv2=tf.nn.conv2d(pool1,conv2_weights,strides=[1,1,1,1],padding='VALID')
		relu2=tf.nn.relu(tf.nn.bias_add(conv2,conv2_biases))
 
	#实现第四层池化层的前向传播过程。这一层和第二层的结构是一样的。这一层的输入为10x10x16的矩阵，输出为5x5x16的矩阵
	with tf.name_scope('layer4-pool2'):
		pool2=tf.nn.max_pool(relu2,ksize=[1,2,2,1],strides=[1,2,2,1],padding='VALID')
	
	#声明第五层全连接层（实际上是卷积层）的变量并实现前向传播过程。这一层输入是5x5x16的矩阵，因为没有使用全0填充，
	#所以输出为1x1x120的矩阵	
	with tf.name_scope('layer5-conv3'):
		conv3_weights=tf.get_variable("weights",[CONV3_SIZE,CONV3_SIZE,CONV2_DEEP,CONV3_DEEP],initializer=tf.truncated_normal_initializer(stddev=0.1))
		conv3_biases=tf.get_variable("bias",[CONV3_DEEP],initializer=tf.constant_initializer(0.0))
		#使用边长为5，深度为120的过滤器，过滤器移动的步长为1，不使用全0填充
		conv3=tf.nn.conv2d(pool2,conv3_weights,strides=[1,1,1,1],padding='VALID')
		relu3=tf.nn.relu(tf.nn.bias_add(conv3,conv3_biases))
		
	#将第五层卷积层的输出转化为第六层全连接层的输入格式。第五层的输出为1x1x120的矩阵，然而第六层全连接层需要的输入格式为向量，
	#所以在这里需要将这个1x1x120的矩阵拉直成一个向量。relu3.get_shape函数可以得到第五层输出矩阵的维度而不需要手工计算。注意因为
	#每一层神经网络的输入输出都为一个batch的矩阵，所以这里得到的维度也包含了一个batch中数据的个数。
	pool_shape=relu3.get_shape().as_list()
	
	#计算将矩阵拉直成向量之后的长度，这个长度就是矩阵长度及深度的乘积。注意这里pool_shape[0]为一个batch中数据的个数。
	nodes=pool_shape[1]*pool_shape[2]*pool_shape[3]
	#通过tf.reshape函数将第五层的输出变成一个batch的向量。
	reshaped=tf.reshape(relu3,[pool_shape[0],nodes])
	
	#声明第六层全连接层的变量并实现前向传播过程。这一层的输入时拉直之后的一组向量，向量长度为120，输出是一组长度为84的向量
	#这一层和之前在第五章中介绍的基本一致，唯一的区别就是引入了dropout的概念。dropout在训练时会随机将部分节点的输出为改为0.
	#dropout可以避免过拟合问题，从而使得模型在测试数据上的效果更好。dropout一般只在全连接层而不是卷积层或者池化层使用。
	with tf.variable_scope('layer6-fc1'):
		fc1_weights=tf.get_variable("weight",[nodes,FC_SIZE],initializer=tf.truncated_normal_initializer(stddev=0.1))
		#只有全连接层的权重需要加入正则化
		if regularizer !=None:
			tf.add_to_collection('losses',regularizer(fc1_weights))
		fc1_biases=tf.get_variable("bias",[FC_SIZE],initializer=tf.constant_initializer(0.1))
		fc1=tf.nn.relu(tf.matmul(reshaped,fc1_weights)+fc1_biases)
		if train:
			fc1=tf.nn.dropout(fc1,0.5)
			
	#声明第七层全连接层的变量并实现前向传播过程。这一层的输入为一组长度为84的向量，输出为一组长度为10的向量。这一层的输出通过
	#softmax之后就得到了最后的分类结果。
	with tf.variable_scope('layer7-fc2'):
		fc2_weights=tf.get_variable("weight",[FC_SIZE,NUM_LABELS],initializer=tf.truncated_normal_initializer(stddev=0.1))
		if regularizer !=None:
			tf.add_to_collection('losses',regularizer(fc2_weights))
		fc2_biases=tf.get_variable("bias",[NUM_LABELS],initializer=tf.constant_initializer(0.1))
		logit=tf.matmul(fc1,fc2_weights)+fc2_biases
		
	#返回第七层的输出
	return logit

三. 训练卷积神将网络模型（LeNet-5模型）
使用定义好的前向传播过程，训练神将网络模型。在训练结束后，把训练得到的模型保存下来方便下次直接使用。这里我们用自己制作的数据集训练，而不是直接从网上下载MNIST数据集加载到模型上训练。

# -*- coding: utf-8 -*-
import os
import tensorflow as tf
import numpy as np
 
#加载cat_dog_inference.py中定义的常量和前向传播函数
import selfdata_inference
import input_data
 
#配置神经网络的参数
BATCH_SIZE=100
LEARNING_RATE_BASE=0.001
LEARNING_RATE_DECAY=0.99
REGULARAZTION_RATE=0.0001
TRAINING_STEPS=30000
MOVING_AVERAGE_DECAY=0.99
 
#模型保存的路径和文件名。
MODEL_SAVE_PATH="/model/"
MODEL_NAME="model1.ckpt"
 
#TFRecord文件存储地址
file_dir="f:\\TFRecord\\output.tfrecords"
 
 
#定义训练过程
def train():
 
#从TFRecord文件中读取图片和标签数据，组合成batch数据
xs,ys=input_data.get_batch(file_dir)

regularizer=tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)
#直接使用mnist_interence.py中定义的前向传播过程
y=selfdata_inference.inference(xs,True,regularizer)
global_step=tf.Variable(0,trainable=False)

#定义滑动平均类和滑动平均操作
variable_averages=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
variables_averages_op=variable_averages.apply(tf.trainable_variables())

#定义交叉熵损失
cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=ys)
cross_entropy_mean=tf.reduce_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,55000/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')
	
#检验使用了滑动平均模型的神经网络前向传播的结果是否正确。tf.argmax(average_y,1)计算每一个样例的预测答案。其中average_y是一个
#batch_size*10 的二维数组，每一行表示一个样例的前向传播结果。tf.argmax的第二个参数“1“表示选取最大值的操作尽在第一个维度中进行
#也就是说，只在每一行选取最大值对应的下标。于是得到的结果是一个长度为batch的一维数组，这个一维数组中的值就表示了每一个样例对应的数字识别结果
#tf.equal判断两个张量的每一维是否相等，如果相等返回True，否则返回False。
correct_prediction=tf.equal(tf.argmax(y,1),ys)
#这个运算首先将一个布尔型的数字转换成实数型，然后计算平均值。这个平均值就是模型在这一组数据上的正确率。
accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

#初始化Tensorflow持久化类
saver=tf.train.Saver()
with tf.Session() as sess:
	#变量初始化
	tf.global_variables_initializer().run()
	#由于train.match_filenames_once()返回的文件列表作为临时变量并没有保存到checkpoint，所以并不会作为全局变量被global_variables_initializer()函数初始化，
	#所以要进行局部变量初始化，不然会报错
	tf.local_variables_initializer().run()
	
	coord = tf.train.Coordinator()
	threads = tf.train.start_queue_runners(sess=sess,coord=coord)
	try:
		for i in range(TRAINING_STEPS):
			#while not coord.should_stop():
			if coord.should_stop():
				break
			_,loss_value,accu,step=sess.run([train_op,loss,accuracy,global_step])	
			#每迭代训练1000次，输出总损失和在训练样本上的分类正确率
			if i%1000==0:
				print("Afetr %d training step(s),loss on training batch is %g,accuracy is %g." % (step,loss_value,accu))
				
		#保存训练结束后的神经网络模型，在测试或者离线时，直接加载模型
		#saver.save(sess,os.path.join(MODEL_SAVE_PATH,MODEL_NAME),global_step=global_step)
        
	except tf.errors.OutOfRangeError:
		print('done!')
	finally:
		coord.request_stop()
	coord.join(threads)
#主程序入口
def main(argv=None):
	#声明处理MNIST数据集的类，这个类在初始化时会自动下载数据
	#mnist=input_data.read_data_sets("/tmp/data/",one_hot=True)
	train()
	
#Tensorflow提供的一个主程序入口，tf.app.run会调用上面定义的main函数。
if __name__ == '__main__':
	tf.app.run()

迭代训练过程中总损失变化如下：

下面这张图是另一篇博客中直接下载MNIST数据集加载到模型上得到的结果，也是用的LeNet-5模型训练得到的。

四. 测试，验证训练得到的神经网络模型
我们利用之前训练结束后保存的模型进行测试，这里直接从网上下载MNIST数据集加载到模型上进行测试。并且从最终的测试结果中可以看出，LeNet-5模型可以达到大约99.2%的正确率。

# -*- coding: utf-8 -*-  
import tensorflow as tf  
import numpy as np  
from tensorflow.examples.tutorials.mnist import input_data  
  
#加载mnist_inference.py和mnist_train.py 中定义的常量和函数  
import mnist_inference  
import mnist_train  
  
def evaluate(mnist):  
    with tf.Graph().as_default() as g:  
        #定义输入输出的格式  
        x =tf.placeholder(tf.float32,[mnist.test.num_examples,mnist_inference.IMAGE_SIZE,  
            mnist_inference.IMAGE_SIZE,mnist_inference.NUM_CHANNELS],name="x-input")  
        y_=tf.placeholder(tf.float32,[None,mnist_inference.OUTPUT_NODE],name="y-input")  
          
        global_step = tf.Variable(0, trainable=False)  
          
        #直接通过调用封装好的函数来计算前向传播结果。因为测试时不关注正则化损失的，所以这里用于计算正则化损失的函数被  
        #设置为None,并且train设置为False。  
        y=mnist_inference.inference(x,False,None)  
          
        #使用前向传播的结果计算正确率。如果需要对未知样例进行分类，那么使用tf.argmax(y,1)就可以得到输入样例的预测类别了  
        correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(y_,1))  
        accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))  
          
        #通过变量重命名的方式来加载模型，这样在前向传播的过程中就不需要调用求滑动平均的函数来获取平均值了。这样就可以完全共用  
        #mnsit_inference.py中定义前向传播过程。  
        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)  
          
        with tf.Session() as sess:  
          
            #将输入的测试数据格式调整为一个四维矩阵，并将这个调整后的数据传入sess.run过程  
            xs, ys = mnist.test.next_batch(mnist.test.num_examples)  
            reshaped_xs=np.reshape(xs,(mnist.test.num_examples,  
                                       mnist_inference.IMAGE_SIZE,  
                                       mnist_inference.IMAGE_SIZE,  
                                       mnist_inference.NUM_CHANNELS))  
              
            #tf.train.get_checkpoint_state函数会通过cheakpoint文件自动找目录中最新模型的文件名。  
            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_test=sess.run(accuracy,feed_dict={x:reshaped_xs, y_:ys})  
                #输出测试结果和验证结果  
                print("After %s training step(s), test accuracy=%g" % (global_step,accuracy_test))  
                  
#主程序入口  
def main(argv=None):  
    #声明处理MNIST数据集的类，这个类在初始化时会自动下载数据  
    mnist=input_data.read_data_sets("/tmp/data/",one_hot=True)  
    evaluate(mnist)  
      
#Tensorflow提供的一个主程序入口，tf.app.run会调用上面定义的main函数。  
if __name__ == '__main__':  
    tf.app.run()  

利用LeNet-5模型在MNIST测试集上得到的结果：

    以上就是训练神经网络模型的大概流程，接下来就会把重点放到神经网络结构的设计上，需要搞明白的知识还有很多，继续前进！！