tensorflow 基础学习八：重构MNIST神经网络

　　使用前面介绍的技术，实践一个神经网络模型。将训练和测试分成两个独立的程序，训练网络的程序可以持续输出训练好的模型，测试程序可以每隔一段时间检验最新模型的正确率。

mnist_inference.py

# -*- coding:utf-8 -*-
import tensorflow as tf

# 定义神经网络结构相关的参数
INPUT_NODE=784
OUTPUT_NODE=10
LAYER1_NODE=500

# 通过tf.get_variable函数来获取变量。在训练神经网络时会创建这些变量；在测试时会通过
# 保存的模型加载这些变量的取值。而且更加灵活的是，因为可以在变量加载时将滑动平均变量
# 重命名，所以可以直接通过同样的名字在训练时使用变量自身，而在测试时使用变量的滑动
# 平均值。在这个函数中也会将变量的正则化损失加入损失集合。
def get_weight_variable(shape,regularizer):
    weights=tf.get_variable('weights',shape,initializer=tf.truncated_normal_initializer(stddev=0.1))
    
    if regularizer != None:
        tf.add_to_collection('losses',regularizer(weights))
    
    return weights

# 定义神经网络的前向传播过程
def inference(input_tensor,regularizer):
    # 如果在同一个程序中多次调用，在第一次调用之后需要将参数reuse设置为True
    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

# -*- coding:utf-8 -*-
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.99
REGULARAZTION_RATE=0.0001
TRAINING_STEPS=30000
MOVING_AVERAGE_DECAY=0.99

# 模型保存的路径和文件名
MODEL_SAVE_PATH='log/'
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)
    # 直接使用mnist_inference.py 中定义的前向传播过程。
    y=mnist_inference.inference(x,regularizer)
    
    global_step=tf.Variable(0,trainable=False)
    
    variable_averages=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
    variable_averages_op=variable_averages.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.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,
                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,variable_averages_op]):
        train_op=tf.no_op(name='train')
    
    # 初始化Tensorflow持久化类
    saver=tf.train.Saver()
    with tf.Session() as sess:
        tf.global_variables_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})
            
            # 每1000轮保存一次模型
            if i % 1000 == 0:
                print('After {} training step(s), loss on training batch is {}.'.format(step,loss_value))
                # 这里给出了global_step参数，可以在每个被保存模型的文件名末尾加上训练的轮数
                saver.save(sess,os.path.join(MODEL_SAVE_PATH,MODEL_NAME),global_step=global_step)
                
def main(argv=None):
    mnist=input_data.read_data_sets('.',one_hot=True)
    train(mnist)

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

mnist_eval.py:

# -*- coding:utf-8 -*-
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_inference
import mnist_train

# 每10s加载一个最新的模型，并在测试数据上测试最新模型的正确率
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)
        
        # 使用前向传播的结果计算正确率。如果需要对未知的样例进行分类，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))
        
        # 通过变量重命名的方式来加载模型，这样在前向传播的过程中就不需要调用求滑动平均的函数来获取平均值了。
        # 这样就可以完全共用mnist_inference.py中定义的前向传播过程。
        variable_averages=tf.train.ExponentialMovingAverage(mnist_train.MOVING_AVERAGE_DECAY)
        variable_to_restore=variable_averages.variables_to_restore()
        saver=tf.train.Saver(variable_to_restore)
        
        # 每隔EVAL_INTERVAL_SECS秒计算一次正确率
        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 {} training step(s), validation accuracy={}'.format(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('.',one_hot=True)
    evaluate(mnist)

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