基于TensorFlow的mnist手写数字图片识别

在学习了BP算法后在mnist数据集上做了练习，特在此总结。
- mnist
包含7万张手写黑白数字图片，每张图片是28*28像素，纯黑像素值0，纯白1，数据集标签长度是10的一维数组，包含对应数字出现的概率。通过input_data函数加载数据集，是4个压缩包，包含训练集50000张，验证集5000张和测试集10000张，One-hot=True采用独热码的形式加载。

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('./data/',one_hot=True)

Extracting ./data/train-images-idx3-ubyte.gz
Extracting ./data/train-labels-idx1-ubyte.gz
Extracting ./data/t10k-images-idx3-ubyte.gz
Extracting ./data/t10k-labels-idx1-ubyte.gz

mnist.train.num_examples

55000

mnist.validation.num_examples

5000

mnist.test.num_examples

10000

mnist.train.images[0].shape

(784,)

mnist.train.labels[0]

array([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.])

batch_size = 200
xs,ys = mnist.train.next_batch(batch_size)
print(xs.shape)
print(ys.shape)

(200, 784)
(200, 10)

通过next_batch函数从训练集中随机抽取batch_size个样本喂入神经网络，并将样本像素值和标签传给xs,ys。
- 模块化搭建网络
TensorFlow框架方便我们模块化搭建神经网络，思考：我们想通过BP算法实现手写数字图片识别，需要三个步骤：前向传播，反向传播，测试。为了提高模型的泛化性能，加入优化方法。
- forward
前向传播中，我们需要完成定义输入、获得参数、获得输出：

import tensorflow as tf
INPUT_NODE = 784
OUTPUT_NODE = 10
LAYER1_NODE = 500

我们构建了2层NN，隐藏层有500个神经元，输入层有784个神经元，代表输入的每张图片的784个像素，输出层有10个神经元，代表数据集的标签。

def get_weight(shape, regularizer):
    w = tf.Variable(tf.truncated_normal(shape,stddev=0.1))#除去较大离散点的正态分布
    if regularizer != None: tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

定义get_weight()函数用来对权重w进行设定，传入参数是w的size和正则化系数，初始化权重后将L2正则化损失加入到总损失中。

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

def forward(x, regularizer):
    w1 = get_weight([INPUT_NODE, LAYER1_NODE], regularizer)
    b1 = get_bias([LAYER1_NODE])
    y1 = tf.nn.relu(tf.matmul(x, w1) + b1)#激活函数使用relu:y=max(x,0)

    w2 = get_weight([LAYER1_NODE, OUTPUT_NODE], regularizer)
    b2 = get_bias([OUTPUT_NODE])
    y = tf.matmul(y1, w2) + b2
    return y

参数偏执设定和前向传播过程，传入参数x为输入，返回预测结果y。
- Backward
反向传播完成训练，参数优化。

def backward(mnist):
    #输入占位
    x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
    y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
    #预测值由前向传播得到
    y = mnist_forward.forward(x, REGULARIZER)
    global_step = tf.Variable(0, trainable=False)

    #交叉熵+softmax，考虑正则化系数
    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结构初始化所有参赛
    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()
        sess.run(init_op)

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

            #反向传播过程中每隔一定轮数保存模型，并产生3个文件（图结构.mata,当前参数名.index,当前参数.data
             if i % 1000 == 0:
                print("After %d training step(s), loss on training batch is %g." % (step, loss_value))
                saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)#将训练模型和训练轮数保存到指定路径

在反向传播中，先对输入x和实际标签y_占位，前向传播得到预测值，优化参数，实例化模型用于保存，开启会话先对参数进行初始化，训练模型更新参数和损失函数，一定轮数打印和保存模型。
其中，参数优化用来提高模型的泛化能力，包括交叉熵+softmax，指数衰减学习率，滑动平均，正则化。
指数衰减学习率使学习率随着训练轮数动态变化，需要提前赋值学习率基数和学习衰减率。
滑动平均用来得到在一定时间内所有参数，w,b的平均值，提前赋值平均衰减率。
学习方法是梯度下降，每次喂入batch_size个训练样本最小化损失函数。
此时，我们的神经网络模型已经搭建好了，若想用于测试，需要定义测试函数用来加载模型。
- Test

def test(mnist):
    #将当前图设置为默认图并保存，与with使用，用于将已定义好的NN复现
    with tf.Graph().as_default() as g:
        x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
        y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])#标签真实值
        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)
        #准确率评估
        #y是batch_size个数据的预测结果，大小[batch_size,10],argmax()返回最大值元素对应索引值
        #通过tf.equal()函数与实际标签张量对比，相等返回true，不等返回false，再通过cast函数将布尔型转为实数
        #通过reduce_mean()求平均值，得到本组数据在NN上的准确率
        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:
                #加载NN模型
                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 step(s), test accuracy = %g" % (global_step, accuracy_score))
                else:
                    print('No checkpoint file found')
                    return
            time.sleep(TEST_INTERVAL_SECS)

其中，TensorFlow是基于计算图的操作，我们在图中添加operation作为节点，就是对张量的计算，在所有节点添加完成后，开启session，完成对指定节点的计算。在test函数中，将当前图设置为默认图，在默认图中添加张量输入值、标签、预测值、加载参数和输出模型准确率，with session开启会话完成对当前图的计算：加载保存模型，计算准确率。
截图运行backward和test程序结果：