[TensorFlow实战] 构建LeNet实现手写数字识别

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Kexiii/article/details/78019925

基本架构

• mnist_inference.py
  LeNet网络构建以及前向传播过程
• mnist_train.py
  网络训练，并在每一定epoch后写checkpoint
• mnist_eval.py
  模型评价，定时读取checkpoint进行模型评价

在这里，mnist_train.py和mnist_eval.py可以分别同时运行，eval模块会定时读取由train模块运行过程中写的checkpoint从而实时对模型进行评估。最终的准确率应该在99.4%左右

代码

mnist_inference.py

import tensorflow as tf

#define basic parameters
INPUT_NODE = 28*28 # mnist 28*28 image
OUTPUT_NODE = 10 # 10 classes classification

IMAGE_SIZE = 28
NUM_CHANNELS = 1
NUM_LABELS = 10

#neural network's parameters
CONV1_DEPTH = 32
CONV1_SIZE = 5

CONV2_DEPTH = 64
CONV2_SIZE = 5

#512 nodes fully connected layer
FC_SIZE = 512

def inference(input_tensor,train,regularizer=None):
    """CNN forward pass
    Args:
        input_tensor:
            input mnist image tensor with shape [None,28,28,1]
        train:
            indicate whether it's a training pass. If not,
            dropout will not be applied
        regularizer:
            standard tensorflow weights regularizer
    return:
        output tensor with shape [NUM_LABELS]
    """
    with tf.variable_scope('layer1-conv1'):
        conv1_weights = tf.get_variable('weight',
         [CONV1_SIZE,CONV1_SIZE,NUM_CHANNELS,CONV1_DEPTH],
         initializer=tf.truncated_normal_initializer(stddev=0.1))

        conv1_biases = tf.get_variable('bias',
         [CONV1_DEPTH],initializer=tf.constant_initializer(0.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))

    with tf.name_scope('layer2-pool1'):
        pool1 = tf.nn.max_pool(relu1,
         ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')

    with tf.variable_scope('layer3-conv2'):
        conv2_weights = tf.get_variable('weight',
         [CONV2_SIZE,CONV2_SIZE,CONV1_DEPTH,CONV2_DEPTH],
         initializer=tf.truncated_normal_initializer(stddev=0.1))

        conv2_biases = tf.get_variable('bias',
         [CONV2_DEPTH],initializer=tf.constant_initializer(0.0))

        conv2 = tf.nn.conv2d(pool1,conv2_weights,
         strides=[1,1,1,1],padding='SAME')
        relu2 = tf.nn.relu(tf.nn.bias_add(conv2,conv2_biases))  

    with tf.name_scope('layer4-pool2'):
        pool2 = tf.nn.max_pool(relu2,
         ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')      

    #flatten
    pool_shape = pool2.get_shape().as_list()
    nodes = pool_shape[1]*pool_shape[2]*pool_shape[3]
    fc_input = tf.reshape(pool2,[-1,nodes])

    with tf.variable_scope('layer5-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(fc_input,fc1_weights)+fc1_biases)
        if train:
            fc1 = tf.nn.dropout(fc1,0.5)

    with tf.variable_scope('layer6-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

mnist_train.py

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

#define biasc parameters
BATCH_SIZE = 100
TRAINING_STEPS = 30000
MOVING_AVERAGE_DECAY = 0.99

#PATH INFO
MODEL_SAVE_PATH='./'
MODEL_NAME = 'mnist_CNN_model.ckpt'

def train(mnist):
    """CNN training process
    Args:
        mnist:
            mnist image generator         
    """
    x = tf.placeholder(tf.float32,
     [BATCH_SIZE,mnist_inference.IMAGE_SIZE,
     mnist_inference.IMAGE_SIZE,
     mnist_inference.NUM_CHANNELS],
     name='x-input')

    y_ = tf.placeholder(tf.float32,
     [BATCH_SIZE,mnist_inference.OUTPUT_NODE],
     name='y-input')

    #forward pass
    y = mnist_inference.inference(x,train=True)

    global_step = tf.Variable(0,trainable=False)
    #compute loss
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
     y,tf.argmax(y_,1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    loss = cross_entropy_mean
    train_step = tf.train.AdamOptimizer().minimize(loss=loss,
     global_step=global_step)

    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)

            reshaped_xs = np.reshape(xs,
             (BATCH_SIZE,
             mnist_inference.IMAGE_SIZE,
             mnist_inference.IMAGE_SIZE,
             mnist_inference.NUM_CHANNELS)
             )

            _,loss_value,step = sess.run(
             [train_step,loss,global_step],
             feed_dict={x:reshaped_xs,y_:ys}
             )

            if i% 100 == 0:
                print('step(s) :%d'%(step))
            if i % 1000 == 0:
                print("After %d training step(s), loss:%g"%(step,loss_value))

                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('/tmp/data',one_hot=True)
    train(mnist)

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

mnist_eval.py

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

import mnist_inference
import mnist_train

#evalute the model 20 seonds per time
EVAL_INTERVAL_SECS = 20

def evaluate(mnist):
    """evaluate the model 20s per time
    Args:
        mnist:
            mnist image generator   
    """
    with tf.Graph().as_default() as g:
        x = tf.placeholder(tf.float32,
         [None,
         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')

        xv = mnist.validation.images
        reshaped_xv = np.reshape(xv,
             (5000,
             mnist_inference.IMAGE_SIZE,
             mnist_inference.IMAGE_SIZE,
             mnist_inference.NUM_CHANNELS)
             )

        validate_feed={x:reshaped_xv,
         y_:mnist.validation.labels}

        y = mnist_inference.inference(x,train=False)
        correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))

        saver = tf.train.Saver()

        while True:
            with tf.Session() as sess:
                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 step(s), score:%g"%\
                    (global_step,accuracy_score))
                else:
                    print("failed to open checkpoint file")
                time.sleep(EVAL_INTERVAL_SECS)

def main(argv=None):
    mnist = input_data.read_data_sets('/tmp/data',one_hot=True)
    evaluate(mnist)

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