tf必备模板(手写数字识别)

这里提供源码供大家学习debug

原理可以参考MNIST机器学习入门

forward.py

#coding:utf-8
#0导入包文件，定义网格模型输入层个数，隐藏层节点数，输出层个数，
import tensorflow as tf

INPUT_MODE = 784
OUTPUT_MODE = 10
LAYER1_MODE = 500

#定义网格参数W和偏置b
def get_weight(shape, regularizer):
    w = tf.Variable(tf.random_normal(shape,stddev=0.1))
    if regularizer != None: tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

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

#定义前向传播方法，初始化输入、输出、各层参数
def forward(x, regularizer):
    w1 = get_weight([INPUT_MODE, LAYER1_MODE], regularizer)
    b1 = get_bias([LAYER1_MODE])
    y1 = tf.nn.relu(tf.matmul(x, w1) + b1)

    w2 = get_weight([LAYER1_MODE,OUTPUT_MODE], regularizer)
    b2 = get_bias([OUTPUT_MODE])
    y = tf.matmul(y1, w2) + b2

    return y

backward.py

#coding:utf-8
#定义反向传播方法，加入动态学习率提高学习效率，引入滑动平均观察模型中损失函数值查看模型优化效果，使模型在测试数据上更加健壮
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import os

BATCH_SIZE = 200
LEARNING_RATE_BASE = 0.1
LEARNING_RATE_DECAY = 0.99
REGULARIZER = 0.0001
STEPS = 50000
MOVING_AVERAGE_DECAY = 0.99
MODEL_SAVE_PATH = "./model/"
MODEL_NAME = "mnist_model"


def backward(mnist):
    x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_MODE])
    y_= tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_MODE])
    y = mnist_forward.forward(x,REGULARIZER)
    global_step = tf.Variable(0, trainable=False)

    ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cem = tf.reduce_mean(ce)
    loss = cem + 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,
        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')
    
    saver = tf.train.Saver()

    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()
        sess.run(init_op)
        
        #断点续训
        ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH)
        if ckpt and ckpt.model_checkpoint_path:
            saver.restore(sess, ckpt.model_checkpoint_path)

        for i in range(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:
                print("After %d training steps, loss on training batch is %g." %(step, loss_value))
                saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step = global_step)


def main():
    mnist = input_data.read_data_sets("./data/", one_hot=True)
    backward(mnist)

if __name__ =='__main__':
    main()

test.py

#coding:utf-8
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import mnist_backward
TEST_INTERVAL_SECS = 5

def test(mnist):
    with tf.Graph().as_default() as g:
        x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_MODE])
        y_= tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_MODE])
        y = mnist_forward.forward(x, None)

        ema = tf.train.ExponentialMovingAverage(mnist_backward.MOVING_AVERAGE_DECAY)
        ema_restore = ema.variables_to_restore()
        saver = tf.train.Saver(ema_restore)

        correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        
        while True:
            with tf.Session() as sess:
                ckpt = tf.train.get_checkpoint_state(mnist_backward.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={x: mnist.test.images, y_: mnist.test.labels})
                    
                    print ("After %s training steps, test accuracy = %g" %(global_step, accuracy_score))
                else:
                    print ("No checkpoint file found")
                    return

            time.sleep(TEST_INTERVAL_SECS)

def main():
    mnist = input_data.read_data_sets("./data/", one_hot=True)
    test(mnist)

if __name__=='__main__':
    main()

app.py

#coding:utf-8
#应用程序，首先明确输入输出的形式，然后先处理收入的图片，再送入已经训练好的模型算出预测值
import tensorflow as tf
import mnist_backward
from PIL import Image
import mnist_forward
import numpy as np


def restore_model(testPicArr):
    #创建一个图，在图中执行以下操作
    with tf.Graph().as_default() as tg:
        x = tf.placeholder(tf.float32, shape=[None, mnist_forward.INPUT_MODE])
        y = mnist_forward.forward(x,None)
        preValue = tf.argmax(y, 1) #得到概率最大的预测值

        #实现滑动平均模型，参数MOVING_AVERAGE_DECAY用于控制模型更新的速度，训练过程中会对每一个变量维护一个影子变量，这个影子变量的出是值，就是相应变量的初始值，每次变量更新时，影子变量就会随之跟新
        variable_averages = tf.train.ExponentialMovingAverage(mnist_backward.MOVING_AVERAGE_DECAY)
        variables_to_restore = variable_averages.variables_to_restore()
        saver = tf.train.Saver(variables_to_restore)

        with tf.Session() as sess:
            #通过checkpoint文件定位到最新保存的模型
            ckpt = tf.train.get_checkpoint_state(mnist_backward.MODEL_SAVE_PATH)
            if ckpt and ckpt.model_checkpoint_path:
                saver.restore(sess, ckpt.model_checkpoint_path)

                preValue = sess.run(preValue, feed_dict={x: testPicArr})
                return preValue
            else:
                print("No checkpoint file found")
                return -1

#预处理，包括resize， 转变灰度图，二值化操作
def pre_pic(picName):
    img = Image.open(picName)
    #对图片处理为28x28的图片
    reIm = img.resize((28,28), Image.ANTIALIAS)
    #另外将图片转为灰度图
    im_arr = np.array(reIm.convert('L'))
    threshold = 50 #设定合理的阈值
    #输入图片一般为白底黑字的图片要转为白底黑子
    for i in range(28):
        for j in range(28):
            im_arr[i][j] = 255 - im_arr[i][j]
            if (im_arr[i][j] < threshold):
                im_arr[i][j] = 0
            else: im_arr[i][j] = 255

    nm_arr = im_arr.reshape([1, 784])
    nm_arr = nm_arr.astype(np.float32)
    #二值化操作
    img_ready = np.multiply(nm_arr, 1.0/255.0)

    return img_ready
            

#定义应用操作处理函数
def application():
    test_Num = input("Input the number of the test picture:")
    for i in range(test_Num):
        testPic = raw_input("The path of test picture:")
        testPicArr = pre_pic(testPic)
        preValue = restore_model(testPicArr)
        print "The prediction number is:", preValue

def main():
    application()

if __name__ == '__main__':
    main()