[深度学习]Tensorflow教学 - 手写数字识别例程MNIST代码实现

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

# 手动从Lecun乐村大牛的网站下载图片
SOURCE_URL = 'http://yann.lecun.com/exdb/mnist/'
WORK_DIRECTORY = "/tmp/mnist"

def maybe_download(filename):
    if not os.path.exists(WORK_DIRECTORY):
        os.mkdir(WORK_DIRECTORY)
    filepath = os.path.join(WORK_DIRECTORY, filename)
    if not os.path.exists(filepath):
        filepath, _ = urllib.request.urlretrieve(SOURCE_URL + filename,filepath)
        statinfo = os.stat(filepath)
        print('Successfully downloaded', filename, statinfo.st_size,'bytes.')
    else:
        print('Already downloaded',filename)
        print(filepath)

    return filepath

train_data_filename = maybe_download('train-images-idx3-ubyte.gz')
train_label_filename = maybe_download('train-labels-idx1-ubyte.gz')
test_data_filename = maybe_download('t10k-images-idx3-ubyte.gz')
test_labels_filename = maybe_download('t10k-labels-idx1-ubyte.gz')

# 常数
INPUT_NODE = 784    # 输入图片28*28 = 784维度，转化为向量输入
OUTPUT_NODE = 10    # 输出节点识别0-9 10个数字

# 神经网络参数
LAYER1_NODE = 500                   # 隐含层一层，节点500个
BATCH_SIZE = 100                    # 每次取一批数据训练
LEARNING_RATE_BASE = 0.8            # 基础学习率
LEARNING_RATE_DECAY = 0.99          # 学习率的衰减率
REGULAROZATION_RATE = 0.0001        # 描述模型复杂度的正则化项在损失函数中的系数
TRAINING_STEPS = 30000              # 训练总次数
MOVING_AVERAGE_DECAY = 0.99         # 滑动平均衰减率

def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
    if(avg_class==None):
        # tf.nn.relu() 线性整流函数
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1)+biases1)
        # 计算输出层的前向传播结果 因为计算损失函数时会一并计算softmax函数，所以这里
        # 不需要加入激活函数。而且不加入softmax不会影响预测结果。因为预测时
        # 使用的是不同类别对应节点输出值的相对大小，有没有softmax层对最后分类的结果的
        # 计算没有影响。于是在计算整个神经网络的前向传播时可以不加入最后的softmax层。
        return tf.matmul(layer1,weights2)+biases2
        
    else:
        layer1 = tf.nn.relu(
            # avg_class.average 训练时滑动平均参数，使得在随机batch训练时更加平滑
            # 防止参数突变太厉害
            tf.matmul(input_tensor,avg_class.average(weights1))+
            avg_class.average(biases1))

        return (tf.matmul(layer1,avg_class.average(weights2))+
            avg_class.average(biases2))

# 训练模型的过程
def train(mnist):
    # 输入输出占位
    x   = tf.placeholder(tf.float32,[None,INPUT_NODE], name='x-input')
    y_  = tf.placeholder(tf.float32,[None, OUTPUT_NODE], name = 'y-input')
 
    # 生成隐藏层的参数 tf.truncated_normal截断的正态分布
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE],stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1,shape=[LAYER1_NODE]))

    # 生成输出层的参数
    weights2 = tf.Variable(tf.truncated_normal( [LAYER1_NODE, OUTPUT_NODE],stddev = 0.1))
    biases2 = tf.Variable(tf.constant(0.1,shape=[OUTPUT_NODE]))

    # 计算出当前参数下神经网络前向出传播的结果。这里给出的用于计算滑动平均的类为None,
    # 所以函数不会使用参数的滑动平均值
    y = inference(x,None,weights1,biases1,weights2,biases2)

    # 定义存储训练轮数的变量。这个变量不需要计算滑动平均值，所以这里指定这个变量为
    # 不可训练的变量(trainable = False)
    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())

    # 计算使用了滑动平均之后的前向传播结果
    average_y = inference(x, variable_averages, weights1, biases1, weights2, biases2)

    # 计算交叉熵 argmax是返回最大值的下标，tensorflow用序号输入
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels = tf.argmax(y_,1) ,logits =y)
    
    #计算在当前batch中所有样例的交叉熵平均值
    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    # 计算L2正则化损失函数
    regularizer = tf.contrib.layers.l2_regularizer(REGULAROZATION_RATE)

    # 计算模型的正则化损失。
    regularization = regularizer(weights1) + regularizer(weights2)
    # 总损失等于交叉熵和正则化损失的和
    loss = cross_entropy_mean + regularization
    
    # 设置指数衰减的学习率
    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        mnist.train.num_examples / BATCH_SIZE,
        LEARNING_RATE_DECAY
    )

    # 使用tf.train.GradientDescentOptimizer 优化算法来优化损失函数，注意这里损失函数包含
    # 交叉熵损失和L2正则化损失。

    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')

    correct_prediction = tf.equal(tf.argmax(average_y,1),tf.argmax(y_,1))

    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # 初始化会话并开始训练过程
    with tf.Session() as sess:
        tf.initialize_all_variables().run()
        # 准备验证数据。一般在神经网络的训练过程中会通过验证数据来大致判断停止的
        # 条件和评判训练的效果
        
        validate_feed = {x:mnist.validation.images,
                        y_:mnist.validation.labels}

        # 准备测试数据。在真实的应用中，这部分数据在训练时是不可见的，这个数据只是作为
        # 模型优劣的评判训练的效果

        test_feed = {x:mnist.test.images, y_:mnist.test.labels}

        # 迭代地训练神经网络
        for i in range(TRAINING_STEPS):
            # 每1000轮输出一次在验证数据集上的测试结果
            if(i % 1000 == 0):

            # 计算滑动平均模型在验证数据上的结果。因为MNIST数据集比较小，所以一次
            # 可以处理所有的验证数据。为了计算方便，本样例程序没有将验证数据划分为更
            # 小的batch。当神经网络模型比较复杂或者验证数据比较大时，太大的batch
            # 会导致计算时间过长甚至发生内存溢出的错误。

                validate_acc = sess.run(accuracy, feed_dict = validate_feed)
                print("After %d training step(s), validation accuracy"
                        "using average model is %g" % (i, validate_acc))

            # 产生这一轮使用的一个batch的训练数据，并运行训练过程
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op,feed_dict={x:xs,y_:ys})

        # 在训练结束之后，在测试数据上检测神经网络模型的最终正确率
        test_acc = sess.run(accuracy,feed_dict = test_feed)
        print("After %d training step(s), test accuracy using average"
                "model is %g" % (TRAINING_STEPS, test_acc))
        
# 主程序入口
def main(argv = None):
    # 声明处理MNIST数据集的类，这个类在初始化时会自动下载数据
    
    mnist = input_data.read_data_sets("/tmp/mnist/",one_hot = True)
    train(mnist)

# TensorFlow 提供的一个主程序入口, tf.app.run会调用上面定义的main函数
if __name__ == '__main__':
    tf.app.run()