MNIST是一個手寫體數字識別資料體，作為機器學習的入門樣例。這個資料集包含了60000張圖片作為訓練資料，一般從中劃出5000張作為驗證資料（validation），另外55000張作為訓練資料（train），還有10000張圖片作為測試資料（test），且每一張圖片都代表了0-9中的一個數字。在TF中專門提供了一個類來處理MNIST資料：

from tensorflow.examples.tutorials.mnist import input_data

#載入MNIST資料集，如果MNIST_data資料夾中無資料，則自動從網上下載
mnist = input_data.read_data_sets("MNIST_data", one_hot=True)

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

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

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

print("Example training data:", mnist.train.images[0])
#Example training data:[0. 0. 0. 0. 0. ... 0. 0.365 0. ...] 共784項

print("Example training data label:", mnist.train.labels[0])
#列印資料的答案
#Example training data label:[0 0 0 0 0 0 0 0 0 0 0 1 0] 共10項，第幾項為1就代表數字幾
 

input_data.read_data_sets函式生成的類還提供了mnist.train.next_batch函式，以便從所有訓練資料中讀取一小部分作為一個訓練batch:

batch_size = 100
xs, ys = mnist.train.next_batch(batch_size)
print('x-shape:', xs.shape)
# x-shape: (100, 784)
print('y-shape:', ys.shape)
# y-shape: (100, 10)

以下程式碼給出了一個在MNIST資料集上實現這些功能的TF程式：

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

# MNIST資料集相關的常數
INPUT_NODE = 784
OUT_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, biases1, weights2, biases2):
    if avg_class == None: #若沒有提供滑動平均模型類，則直接使用引數當前值
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
        return tf.matmul(layer1, weights2) + biases2
    else:#若提供滑動平均模型類，首先使用avg_class.average()得到變數的滑動平均值，即影子變數
        layer1 = tf.nn.relu(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, OUT_NODE], name='y-input')

    #生成隱藏層和輸出層的引數的引數
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))
    #truncated_normal產生正太分佈的值如果與均值的差值大於兩倍的標準差，那就重新生成。
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))
    weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUT_NODE]))

    #計算當前引數下前向傳播的結果
    y = inference(x, None, weights1, biases1, weights2, biases2)

    #定義儲存訓練輪數的變數， 不可進行優化
    global_step = tf.Variable(0, trainable=False)

    #生成一個滑動平均的類，並在所有變數上使用滑動平均
    variables_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    variables_averages_op = variables_averages.apply(tf.trainable_variables())

    #計算使用滑動平均引數後的前向傳播的結果
    average_y = inference(x, variables_averages, weights1, biases1, weights2, biases2)

    #計算交叉熵及當前barch中的所有樣例的交叉熵平均值
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
    cross_entropy_mean = tf.reduce_mean(cross_entropy)
    #tf.argmax(vector, 1)：返回的是vector中的最大值的索引值

    #計算正則化損失函式 並得到最終的損失函式
    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) #打包

    correct_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1)) #判斷兩張量的每一維是否相等，相等返回True，不等返回False
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))#cast將布林值轉化為float32 求均值即得正確率


    with tf.Session() as sess:
        sess.run(tf.initialize_all_variables())

        #生成驗證資料
        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):

            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op, feed_dict={x: xs, y_: ys})

            if i%1000 == 0:
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                test_acc = sess.run(accuracy, feed_dict=test_feed)
                print("After %d training steps, validation accuracy using average model is %g，test accuracy using average model is %g" %(i, validate_acc, test_acc))

def main(argv=None):
    mnist = input_data.read_data_sets("MNIST_data", one_hot=True)
    train(mnist)

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

在上一篇中提到了5種設計神經網路的優化方法：在結構設計上，使用啟用函式和多隱藏層；在網路優化上，使用指數衰減的學習率、正則化、滑動平均模型。

通過對不同的模型進行比較，發現不用隱藏層和不用啟用函式對模型得正確率有很大影響，即神經網路得結構對最終模型效果有本質性得影響。滑動平均和指數衰減得學習率對最終模型的影響不大，由於他們都是限制神經網路中引數更新的速度。相比這兩種，正則化則給模型帶來的效果顯著體提升。