MNIST数字识别

1、数据下载

from tensorflow.examples.tutorials.mnist import input_data

#载入MNIST数据集，主动下载数据
mnist = input_data.read_data_sets("./MNIST_data", one_hot=True)

#打印Training data size :55000
print("Training data size: ", mnist.train.num_examples)

#打印Validating data size:5000
print("Validating data size: ", mnist.validation.num_examples)

#打印Testing data size: 10000
print("Testing data size: ", mnist.test.num_examples)

#打印Example training data 
print("Example training data: ", mnist.train.images[0])

#打印Example trainning data labl
print('Example training data label: ', mnist.train.labels[0] )

从上述代码可以看出。通过input_data.read_data_sets函数生成的类会自动将MNIST数据集划分为train、validation和test三个数据集。

Training data size:  55000
Validating data size:  5000
Testing data size:  10000

处理后的每一张图片是一个长度为784的一维数组。为了方便使用随机梯度下降，input_data.read_data_sets函数还提供了mnist.train.next_batch函数，可以从所有的训练数据中读取一小部分作为一个batch。如下

batch_size = 100
xs, ys = mnist.train.next_batch(batch_size)
#从train的集合中选取batch_size个训练数据
print("x shape: ", xs.shape)
#输出X shape：(100, 784)

print("y shape: ", ys.shape)
#输出y shape：(100, 10)

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

INPUT_NODE = 784
OUTPUT_NODE = 10

#配置神经网络的参数
LAYER1_NODE = 500
BATCH_SIZE = 100

LEARNING_RATE_BASE = 0.8
LEARNING_RATE_DECAY = 0.99
REGULARIZATION_RATE = 0.0001
TRAINING_STEPS = 30000
MOVING_AVERAGE_DECAY = 0.99

def inference(input_tensor, avg_class, weights1, biase1, weights2, biase2):
        #当没有平滑类提供时，直接使用参数当前的取值
        if avg_class is None:
                layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1)+biase1)
                return tf.matmul(layer1, weights2) + biase2
            
        else:
                layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weights1))+avg_class.average(biase1))
                return tf.matmul(layer1, avg_class.average(weights2))+avg_class.average(biase2)
      

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

        #生成隐藏层  
        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）。
        #在使用TensorFlow训练神经网络时，一般会将代表训练轮数的变量指定为不可训练的参数
        global_step = tf.Variable(0, trainable=False)
        #给定滑动平均衰减率和训练轮数的变量，初始化滑动平均类。给定训练轮数的变量可以加快训练早起变量的更新速度
        variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

        #在所有带边神经网络参数的变量上使用滑动平均，其他辅助变量（比如global_step）就不需要了，
        #tf.trainable_variables返回的就是图上集合GraphKeys.TRAINABLE_VARIABLES中的元素。这个集合的元素就是所有没有指定trainable=False的参数
        variables_average_op = variable_averages.apply(tf.trainable_variables())
      
        #计算使用了滑动平均之后的前向传播结果。滑动平均不会改变变量本身的取值，而是会维护一个影子变量，来记录其滑动平均值。所以当需要使用这个滑动平均值时，
        #需要明确调用average函数
        average_y = inference(x, variable_averages, weights1, biases1, weights2, biases2)

        #使用saprse_softmax_cross_entripy_with_logits函数计算交叉熵
        cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
        #计算在当前batch中所有样例交叉熵的平均值
        cross_entropy_mean = tf.reduce_mean(cross_entropy)

        #计算L2正则化损失函数
        regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_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)

        #优化损失函数
        train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
        #更新参数
        #下面两行代码等价
        #train_op = tf.group(train_step, variables_averages_op)
        with tf.control_dependencies([train_step, variables_average_op]):
                train_op = tf.no_op(name='train')

        #检验使用滑动平均模型的神经网络前向传播的结果是否正确。tf.argmax(average_y, 1)计算每个样例的预测答案
        #其中average_y是一个batch_size*10的二维数组，每一行表示一个样例的前向传播结果。tf.argnax的第二个参数“1”表示选取最大值得操作仅在第一个维度进行
        #也就是说，只在每一行选取最大值对应的下标。于是得到的结果是一个长度为batch的一维数组，这个一维数组中的值就表示了每一个样例对应的数字识别的结果
        #tf.equal判断两个张量的每一个维度是否相等，如果相等返回True，否则返回False
        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.global_variables_initializer().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):
                        if i % 1000 == 0:
                                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('./',one_hot=True)
        train(mnist)

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

After 0 training step(s), validation accuracy using average model is 0.1274
After 1000 training step(s), validation accuracy using average model is 0.9782
After 2000 training step(s), validation accuracy using average model is 0.9818
After 3000 training step(s), validation accuracy using average model is 0.9826
After 4000 training step(s), validation accuracy using average model is 0.984
After 5000 training step(s), validation accuracy using average model is 0.983
After 6000 training step(s), validation accuracy using average model is 0.9844
After 7000 training step(s), validation accuracy using average model is 0.984
After 8000 training step(s), validation accuracy using average model is 0.984
After 9000 training step(s), validation accuracy using average model is 0.9836
After 10000 training step(s), validation accuracy using average model is 0.9834
After 11000 training step(s), validation accuracy using average model is 0.9848
After 12000 training step(s), validation accuracy using average model is 0.9846
After 13000 training step(s), validation accuracy using average model is 0.9844
After 14000 training step(s), validation accuracy using average model is 0.9832
After 15000 training step(s), validation accuracy using average model is 0.9836
After 16000 training step(s), validation accuracy using average model is 0.984
After 17000 training step(s), validation accuracy using average model is 0.9834
After 18000 training step(s), validation accuracy using average model is 0.9844
After 19000 training step(s), validation accuracy using average model is 0.983
After 20000 training step(s), validation accuracy using average model is 0.9834
After 21000 training step(s), validation accuracy using average model is 0.9836
After 22000 training step(s), validation accuracy using average model is 0.9842
After 23000 training step(s), validation accuracy using average model is 0.9842
After 24000 training step(s), validation accuracy using average model is 0.9836
After 25000 training step(s), validation accuracy using average model is 0.9854
After 26000 training step(s), validation accuracy using average model is 0.9846
After 27000 training step(s), validation accuracy using average model is 0.984
After 28000 training step(s), validation accuracy using average model is 0.9848
After 29000 training step(s), validation accuracy using average model is 0.9848
After 30000 training step(s), test accuracy using average model is 0.9838