MNIST資料集輸出手寫數字識別準確率

大綱

5.1 MNIST資料集

5.2 模組化搭建神經網路

5.3 手寫數字識別準確率輸出

目標

利用MNIST資料集鞏固模組化搭建神經網路的八股，實踐前向傳播和反向傳播過程，編寫測試程式輸出手寫數字識別準確率。

5.1 MNIST資料集

MNIST資料集：包含7萬張黑底白字手寫數字圖片，其中55000張為訓練集， 5000張為驗證集，10000張為測試集。每張圖片大小為28*28畫素，圖片中純黑色畫素值為0，純白色畫素值為1。資料集的標籤是長度為10的一維陣列，陣列中每個元素索引號表示對應數字出現的概率。 在將mnist資料集作為輸入喂入神經網路時，需先將資料集中每張圖片變為長度 784一維陣列，將該陣列作為神經網路輸入特徵喂入神經網路。 

例如： 一張數字手寫體圖片變成長度為784的一維陣列[0.0.0.0.0.231 0.235 0.459 ……0.219 0.0.0.0.]輸入神經網路。該圖片對應的標籤為[0.0.0.0.0.0.1.0.0.0]，標籤中索引號為6的元素為1，表示是數字6出現的概率為100%，則該圖片對應的識別結果是6。 

使用input_data模組中的read_data_sets()函式載入mnist資料集：

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

在 read_data_sets()函式中有兩個引數，第一個引數表示資料集存放路徑，第

返回mnist資料集中訓練集train、驗證集validation和測試集test樣本數 

在Tensorflow中用以下函式返回子集樣本數： 

①返回訓練集train樣本數

print “train data size:”,mnist.train.num_examples

輸出結果：train data size:55000

②返回驗證集validation樣本數

print “validationdata size:”,mnist.validation.num_examples 

輸出結果：validationdata size:5000

③返回測試集test樣本數

print “test data size:”,mnist.test.num_examples 

輸出結果：test data size:10000 

使用train.labels函式返回mnist資料集標籤

例如： 在mnist資料集中，若想要檢視訓練集中第0張圖片的標籤，則使用如下函式

mnist.train.labels[0] 輸出結果：array([0.,0.,0.,0.,0.,0.,1.,0.,0.,0]) 

使用train.images函式返回mnist資料集圖片畫素值

例如： 在 mnist 資料集中，若想要檢視訓練集中第 0 張圖片畫素值，則使用如下函式

mnist.train.images[0]

輸出結果：

array([0. ,0. ,0. ,

           0. ,0. ,0. ,

          0. ,0. ,0. ,

          …  …  …]) 

使用mnist.train.next_batch()函式將資料輸入神經網路

例如：

BATCH_SIZE = 200

xs,ys = mnist.train.next_batch(BATCH_SIZE) 

print “xsshape:”,xs.shape 

print “ys shape:”,ys.shape 

輸出結果：xs.shape(200,784)

輸出結果：ys.shape(200,10) 

其中，mnist.train.next_batch()函式包含一個引數BATCH_SIZE，表示隨機從訓練集中抽取BATCH_SIZE個樣本輸入神經網路，並將樣本的畫素值和標籤分別賦給xs和ys。在本例中，BATCH_SIZE設定為200，表示一次將200個樣本的畫素值和標籤分別賦值給xs和ys，故xs的形狀為(200,784)，對應的ys的形狀為(200,10)。

實現“Mnist資料集手寫數字識別”的常用函式：

①tf.get_collection(“”)函式表示從 collection 集合中取出全部變數生成一個列表。

②tf.add( )函式表示將引數列表中對應元素相加。 

例如：x=tf.constant([[1,2],[1,2]])    y=tf.constant([[1,1],[1,2]])  z=tf.add(x,y) print z

輸出結果：[[2,3],[2,4]] 

③tf.cast(x,dtype)函式表示將引數x轉換為指定資料型別。

例如：

A = tf.convert_to_tensor(np.array([[1,1,2,4], [3,4,8,5]]))   

print A.dtype   b = tf.cast(A, tf.float32)   print b.dtype

結果輸出：

<dtype: 'int64'>

<dtype: 'float32'>

從輸出結果看出，將矩陣A由整數型變為32位浮點型。

④tf.equal( )函式表示對比兩個矩陣或者向量的元素。若對應元素相等，則返回True；若對應元素不相等，則返回False。

例如：

A = [[1,3,4,5,6]]   B =[[1,3,4,3,2]]  

with tf.Session( ) as sess:  

print(sess.run(tf.equal(A, B))) 

輸出結果：[[True  True  True False False]]

在矩陣A和B中，第1、2、3個元素相等，第4、5個元素不等，故輸出結果中，第1、2、3個元素取值為True，第4、5個元素取值為False。

⑤tf.reduce_mean(x,axis)函式表示求取矩陣或張量指定維度的平均值。若不指定第二個引數，則在所有元素中取平均值；若指定第二個引數為0，則在第一維元素上取平均值，即每一列求平均值；若指定第二個引數為1，則在第二維元素上取平均值，即每一行求平均值。

例如：

x = [[1., 1.][2., 2.]] 

print(tf.reduce_mean(x))

輸出結果：1.5

print(tf.reduce_mean(x, 0))

輸出結果：[1.5, 1.5]

print(tf.reduce_mean(x, 1))

輸出結果：[1., 1.]

⑥tf.argmax(x,axis)函式表示返回指定維度axis下，引數x中最大值索引號。

例如：

在tf.argmax([1,0,0],1)函式中，axis為1，引數x為[1,0,0]，表示在引數x

的第一個維度取最大值對應的索引號，故返回0。

⑦os.path.join()函式表示把引數字串按照路徑命名規則拼接。

例如：

import os os.path.join('/hello/','good/boy/','doiido')

輸出結果：'/hello/good/boy/doiido'

⑧字串.split( )函式表示按照指定“拆分符”對字串拆分，返回拆分列表。 

例如：'./model/mnist_model-1001'.split('/')[-1].split('-')[-1]

在該例子中，共進行兩次拆分。第一個拆分符為‘/’，返回拆分列表，並提取列表中索引為-1的元素即倒數第一個元素；第二個拆分符為‘-’，返回拆分列表，並提取列表中索引為-1的元素即倒數第一個元素，故函式返回值為1001。

⑨tf.Graph( ).as_default( )函式表示將當前圖設定成為預設圖，並返回一個上下文管理器。該函式一般與with關鍵字搭配使用，應用於將已經定義好的神經網路在計算圖中復現。

例如：

with tf.Graph().as_default() as g，表示將在Graph()內定義的節點加入到計算圖g中。

 神經網路模型的儲存

 在反向傳播過程中，一般會間隔一定輪數儲存一次神經網路模型，併產生三個檔案（儲存當前圖結構的.meta檔案、儲存當前引數名的.index檔案、儲存當前引數的.data檔案），在Tensorflow中如下表示：

saver = tf.train.Saver()         
with tf.Session() as sess:       
    for i in range(STEPS):        
        if i % 輪數 == 0:         
           saver.save(sess, os.path.join(MODEL_SAVE_PATH,MODEL_NAME),global_step=global_step)

其中，tf.train.Saver()用來例項化saver物件。上述程式碼表示，神經網路每迴圈規定的輪數，將神經網路模型中所有的引數等資訊儲存到指定的路徑中，並在存放網路模型的資料夾名稱中註明儲存模型時的訓練輪數。

神經網路模型的載入 在測試網路效果時，需要將訓練好的神經網路模型載入，在Tensorflow中這樣表示：

with tf.Session() as sess:
    ckpt =tf.train.get_checkpoint_state(儲存路徑)     
        if ckpt and ckpt.model_checkpoint_path:
             saver.restore(sess,ckpt.model_checkpoint_path)

在with結構中進行載入儲存的神經網路模型，若ckpt和儲存的模型在指定路徑中存在，則將儲存的神經網路模型載入到當前會話中。 

載入模型中引數的滑動平均值 

在儲存模型時，若模型中採用滑動平均，則引數的滑動平均值會儲存在相應檔案中。通過例項化saver物件，實現引數滑動平均值的載入，在Tensorflow中如下表示：

ema = tf.train.ExponentialMovingAverage(滑動平均基數)
ema_restore = ema.variables_to_restore()         
saver = tf.train.Saver(ema_restore)

神經網路模型準確率評估方法在網路評估時，一般通過計算在一組資料上的識別準確率，評估神經網路的效果。

在Tensorflow中這樣表示：

correct_prediction= tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1)) 
accuracy =tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

在上述中，y 表示在一組資料（即batch_size 個數據）上神經網路模型的預測結果，y 的形狀為[batch_size,10]，每一行表示一張圖片的識別結果。通過tf.argmax()函式取出每張圖片對應向量中最大值元素對應的索引值，組成長度為輸入資料batch_size個的一維陣列。通過tf.equal()函式判斷預測結果張量和實際標籤張量的每個維度是否相等，若相等則返回True，不相等則返回False。通過 tf.cast()函式將得到的布林型數值轉化為實數型，再通過tf.reduce_mean()函式求平均值，最終得到神經網路模型在本組資料上的準確率。

5.2 模組化搭建神經網路

神經網路八股包括前向傳播過程、反向傳播過程、反向傳播過程中用到的正則化、指數衰減學習率、滑動平均方法的設定、以及測試模組。 

前向傳播過程（forward.py）

前向傳播過程完成神經網路的搭建，結構如下：

def forward(x, regularizer):

def forward(x, regularizer):
    w=  
    b=
    y= 
return y 
def get_weight(shape, regularizer): 
def get_bias(shape):          

前向傳播過程中，需要定義神經網路中的引數w和偏置b，定義由輸入到輸出的網路結構。通過定義函式get_weight()實現對引數w的設定，包括引數w的形狀和是否正則化的標誌。同樣，通過定義函式get_bias()實現對偏置b的設定。

反向傳播過程（backword.py）

反向傳播過程完成網路引數的訓練，結構如下：

def backward( mnist ):
x  = tf.placeholder(dtype, shape )
y_ = tf.placeholder(dtype, shape )
#定義前向傳播函式
y  = forward( )                  
global_step = 
loss = 
train_step =tf.train.GradientDescentOptimizer(learning_rate).
minimize(loss,global_step=global_step)
#例項化saver物件
saver = tf.train.Saver() with tf.Session() as sess:  
#初始化所有模型引數      
tf.initialize_all_variables().run()  
#訓練模型
  for i in range(STEPS):
     sess.run(train_step,feed_dict={x:   , y_:   })      
         if i % 輪數 == 0:          
            print
          saver.save(   )

反向傳播過程中，用tf.placeholder(dtype, shape)函式實現訓練樣本x和樣本標籤y_佔位，函式引數dtype表示資料的型別，shape表示資料的形狀；y表示定義的前向傳播函式forward；loss表示定義的損失函式，一般為預測值與樣本標籤的交叉熵（或均方誤差）與正則化損失之和；train_step表示利用優化演算法對模型引數進行優化，常用優化演算法GradientDescentOptimizer、AdamOptimizer、MomentumOptimizer演算法，在上述程式碼中使用的GradientDescentOptimizer優化演算法。接著例項化saver物件，其中利用tf.initialize_all_variables().run()函式例項化所有引數模型，利用sess.run( )函式實現模型的訓練優化過程，並每間隔一定輪數儲存一次模型。

正則化、指數衰減學習率、滑動平均方法的設定

①正則化項regularization

當在前向傳播過程中即forward.py檔案中，設定正則化引數regularization為 1時，則表明在反向傳播過程中優化模型引數時，需要在損失函式中加入正則化項。 結構如下：

首先，需要在前向傳播過程即forward.py檔案中加入

if regularizer !=None: tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))

其次，需要在反向傳播過程即backword.py檔案中加入

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

其中，tf.nn.sparse_softmax_cross_entropy_with_logits()表示softmax()函式與交叉熵一起使用。 

②指數衰減學習率 在訓練模型時，使用指數衰減學習率可以使模型在訓練的前期快速收斂接近較優解，又可以保證模型在訓練後期不會有太大波動。運用指數衰減學習率，需要在反向傳播過程即backword.py檔案中加入：

learning_rate = tf.train.exponential_decay( LEARNING_RATE_BASE,  global_step, 

LEARNING_RATE_STEP, LEARNING_RATE_DECAY,  staircase=True)

③滑動平均 在模型訓練時引入滑動平均可以使模型在測試資料上表現的更加健壯。

需要在反向傳播過程即backword.py檔案中加入：

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

測試過程（test.py）

當神經網路模型訓練完成後，便可用於測試資料集，驗證神經網路的效能。結構

如下： 首先，制定模型測試函式test()    

def test( mnist ):  
with tf.Graph( ).as_default( ) as g:
#給x y_佔位
x = tf.placeholder(dtype,shape)     
y_ = tf.placeholder(dtype,shape)  #前向傳播得到預測結果y
y = mnist_forward.forward(x,None)  #前向傳播得到y
#例項化可還原滑動平均的saver
ema =tf.train.ExponentialMovingAverage(滑動衰減率)
    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(儲存路徑)
        #如果已有ckpt模型則恢復  
                if ckpt andckpt.model_checkpoint_path: 
                    #恢復會話                    
                        saver.restore(sess, ckpt.model_checkpoint_path) 
                    #恢復輪數                    
                          global_ste = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]                          
                    #計算準確率 
                          accuracy_score = sess.run(accuracy,feed_dict={x:測試資料, y_:測試資料標籤 })                
                    # 列印提示   
                         print("After %straining step(s), test accuracy=%g" % (global_step, accuracy_score))                  
                     #如果沒有模型   
                          else:
                   print('No checkpoint file found') #模型不存在提示                                  
                   return     

其次，制定main()函式 def main(): 

#載入測試資料集   
mnist =input_data.read_data_sets("./data/", one_hot=True)
#呼叫定義好的測試函式test()    
   test(mnist) if __name__ == '__main__':    
   main()

通過對測試資料的預測得到準確率，從而判斷出訓練出的神經網路模型的效能好壞。當準確率低時，可能原因有模型需要改進，或者是訓練資料量太少導致過擬合。 

5.3 手寫數字識別準確率輸出

實現手寫體mnist資料集的識別任務，共分為三個模組檔案，分別是描述網路結構的前向傳播過程檔案（mnist_forward.py）、描述網路引數優化方法的反向傳播過程檔案（mnist_backward.py）、驗證模型準確率的測試過程檔案（mnist_test.py）。

前向傳播過程檔案（mnist_forward.py）

在前向傳播過程中，需要定義網路模型輸入層個數、隱藏層節點數、輸出層個數，定義網路引數w、偏置b，定義由輸入到輸出的神經網路架構。

實現手寫體mnist資料集的識別任務前向傳播過程如下： 

#coding:utf-8
#1前向傳播過程
import tensorflow as tf

#網路輸入節點為784個（代表每張輸入圖片的畫素個數）
INPUT_NODE = 784
#輸出節點為10個（表示輸出為數字0-9的十分類）
OUTPUT_NODE = 10
#隱藏層節點500個
LAYER1_NODE = 500


def get_weight(shape, regularizer):
	#引數滿足截斷正態分佈，並使用正則化，
    w = tf.Variable(tf.truncated_normal(shape,stddev=0.1))
    #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):  
	#初始化的一維陣列，初始化值為全 0
    b = tf.Variable(tf.zeros(shape))  
    return b
	
def forward(x, regularizer):
	#由輸入層到隱藏層的引數w1形狀為[784,500]
    w1 = get_weight([INPUT_NODE, LAYER1_NODE], regularizer)
	#由輸入層到隱藏的偏置b1形狀為長度500的一維陣列，
    b1 = get_bias([LAYER1_NODE])
	#前向傳播結構第一層為輸入 x與引數 w1矩陣相乘加上偏置 b1 ，再經過relu函式 ，得到隱藏層輸出 y1。
    y1 = tf.nn.relu(tf.matmul(x, w1) + b1)
    #由隱藏層到輸出層的引數w2形狀為[500,10]
    w2 = get_weight([LAYER1_NODE, OUTPUT_NODE], regularizer)
	#由隱藏層到輸出的偏置b2形狀為長度10的一維陣列
    b2 = get_bias([OUTPUT_NODE])
	#前向傳播結構第二層為隱藏輸出 y1與參 數 w2 矩陣相乘加上偏置 矩陣相乘加上偏置 b2，得到輸出 y。
	#由於輸出 。由於輸出 y要經過softmax oftmax 函式，使其符合概率分佈，故輸出y不經過 relu函式
    y = tf.matmul(y1, w2) + b2
    return y

反向傳播過程檔案（mnist_backward.py）

反向傳播過程實現利用訓練資料集對神經網路模型訓練，通過降低損失函式值，實現網路模型引數的優化，從而得到準確率高且泛化能力強的神經網路模型。

實現手寫體mnist資料集的識別任務反向傳播過程如下：

#coding:utf-8
#2反向傳播過程
#引入tensorflow、input_data、前向傳播mnist_forward和os模組
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):
    #用placeholder給訓練資料x和標籤y_佔位
    x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
    y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
    #呼叫mnist_forward檔案中的前向傳播過程forword()函式，並設定正則化，計算訓練資料集上的預測結果y
	y = mnist_forward.forward(x, REGULARIZER)
	#當前計算輪數計數器賦值，設定為不可訓練型別
    global_step = tf.Variable(0, trainable=False)

    #呼叫包含所有引數正則化損失的損失函式loss
    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
    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)
    train_step = tf.train.MomentumOptimizer(learning_rate,0.9).minimize(loss, global_step=global_step)
    #train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss, global_step=global_step)
    #定義引數的滑動平均
    ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
    ema_op = ema.apply(tf.trainable_variables())
	#例項化可還原滑動平均的saver 
	#在模型訓練時引入滑動平均可以使模型在測試資料上表現的更加健壯
    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)
        #每次喂入batch_size組（即200組）訓練資料和對應標籤，迴圈迭代steps輪
        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 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)


def main():
	#讀入mnist
    mnist = input_data.read_data_sets("./data/", one_hot=True)
    #反向傳播
	backward(mnist)

if __name__ == '__main__':
    main()

測試過程檔案（mnist_test.py）

當訓練完模型後，給神經網路模型輸入測試集驗證網路的準確性和泛化性。注意，所用的測試集和訓練集是相互獨立的。 實現手寫體mnist資料集的識別任務測試傳播過程如下： 

#coding:utf-8
#驗證網路的準確性和泛化性
import time
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import mnist_forward
import mnist_backward
#程式5秒的迴圈間隔時間
TEST_INTERVAL_SECS = 5

def test(mnist):
	#利用tf.Graph()復現之前定義的計算圖
    with tf.Graph().as_default() as g:
		#利用placeholder給訓練資料x和標籤y_佔位
        x = tf.placeholder(tf.float32, [None, mnist_forward.INPUT_NODE])
        y_ = tf.placeholder(tf.float32, [None, mnist_forward.OUTPUT_NODE])
		#呼叫mnist_forward檔案中的前向傳播過程forword()函式
        y = mnist_forward.forward(x, None)
        #例項化具有滑動平均的saver物件，從而在會話被載入時模型中的所有引數被賦值為各自的滑動平均值，增強模型的穩定性
        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
                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))
				#若模型不存在，則打印出模型不存在的提示，從而test()函式完成
                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()

執行以上三個檔案，可得到手寫體 mnist 資料集的識別任務的執行結果：

從終端顯示的執行結果可以看出，隨著訓練輪數的增加，網路模型的損失函式值在不斷降低，並且在測試集上的準確率在不斷提升，有較好的泛化能力。修改mnist_forward.py中w和b的初始化方法、修改隱藏層節點個數和隱藏層層數，修改mnist_backward.py程式碼中的超引數，找出最快提升準確度的“全連線網路”解決方案。

致謝

感謝曹老師的辛勤付出，來源曹健，人工智慧實踐：TensorFlow筆記，北京大學