手寫數字識別——手動搭建全連接層

本文使用TensorFlow2.0手動搭建簡單的全連接網絡進行MNIST手寫數據集的分類識別，逐步講述實現過程，穿插TensorFlow2.0語法，文末給出完整的代碼。廢話少說，開始動手吧！

 

 

一、量子波動擼代碼

該節先給出各代碼片段，第二節將這些片段匯總成程序，這些代碼片段故意包含了一些錯誤之處，在第二節中會進行一一修正。如要正確的代碼，請直接參考第三節。如若讀者有一番閑情逸致，可跟隨筆者腳步，看看自己是否可以事先發現這些錯誤。

首先，導入依賴的兩個模塊，一個是tensorflow，另一個是tensorflow.keras.datasets，我們要的數據集MNIST就是由這個datasets管理下載的。https://tensorflow.google.cn/datasets/catalog/overview?hl=en中列出了datasets管理的所有數據集。

import tensorflow as tf
#數據集管理器
from tensorflow.keras import datasets

 

導入數據集，數據集一般由訓練數據和測試數據構成，用（x,y）存儲訓練圖片和標簽，用（val_x,val_y）存儲測試圖片和標簽。

(x,y),(val_x,val_y) = datasets.mnist.load_data()

 

在導入后，需要對數據形式進行初步查看，對於圖像識別來說，圖片的數量、大小、通道數量和數據范圍、類型是必須了解的。以一下程序能打印出這些信息，注釋為輸出結果。由結果可知，datasets導出的數據是Numpy數組，類型為uint8，訓練圖片共60k張，大小為28*28，為灰度圖像，灰度范圍0~255；測試圖片共10k張。

print(type(x),x.dtype)  　　　　　　#<class 'numpy.ndarray'> uint8
print(type(y),y.dtype)  　　　　　　#<class 'numpy.ndarray'> uint8
print(x.shape,y.shape)  　　　　　　#(60000, 28, 28) (60000,)
print(val_x.shape,val_y.shape)    #(10000, 28, 28) (10000,)
print(x.max(),x.min())　　　　　　　#255 0
print(y.max(),y.min())　　　　　　　#9 0

 

在訓練前必須先將數據轉為Tensor。用tf.convert_to_tensor(value,dtype)函數可將value轉為Tensor，並可指定數據類型（dtype）。將x,val_x轉成浮點類型，而訓練數據的標簽y需要先轉為Tensor整型再轉化為獨熱碼形式，測試數據val_y的標簽轉化為Tensor整型，獨熱碼轉換可用tf.one_hot(indices,depth,dtype)，indices必須是整型，這也就是為什么先轉成Tensor整型的原因，depth決定獨熱碼位數，dtype默認是tf.float32。以下代碼完成數據類型轉換。

#需要將數據轉成Tensor
x = tf.convert_to_tensor(x,dtype=tf.float32)
y = tf.convert_to_tensor(y,dtype=tf.int32)
val_x = tf.convert_to_tensor(val_x,dtype=tf.float32)    
val_y = tf.convert_to_tensor(val_y,dtype=tf.int32)
#獨熱碼
y = tf.one_hot(y,depth=10)
print(y.shape) #(60000, 10)

 

對於如此龐大的數據集，直接一次性加載到內存進行計算是不現實的，所以采用批處理的方式將數據集分批喂進網絡，在分批前先對數據shuffle一下，以防網絡發現順序規律。事實上，把整個數據集一次喂給網絡來更新參數的過程稱為批梯度下降；而每次只喂一張圖片，則稱為隨機梯度下降；每次將一小批圖片喂給網絡，稱為小批量梯度下降。關於三者的區別可以參考https://www.cnblogs.com/lliuye/p/9451903.html。簡單來說，小批量梯度下降是最合適的，一般Batch設的較大，則達到最大准確率的速度變慢，但更容易收斂；Batch設小了，在一開始，准確率提高得非常快，但是最終收斂可能不太好。

test_db =  tf.data.Dataset.from_tensor_slices((val_x,val_y)).shuffle(10000).batch(256)
train_db =  tf.data.Dataset.from_tensor_slices((x,y)).shuffle(10000).batch(256)

 

 train_db是可以直接迭代的，下面進行一次迭代，觀察迭代結果，可以知道每一次迭代圖片數量就是Batch大小。

train_iter = iter(train_db)
sample = next(train_iter)
print(sample[0].shape,sample[1].shape)  #(256, 28, 28) (256, 10)

 

 

下面就可以開始構建全連接網絡了，結構如上圖所示。網絡節點數為784（input）->256->128->10(output)，加上輸入輸出一共4層，其中輸入層是打平后的圖片，共28*28=784個像素；輸出層由類別數決定，這里手寫數字0~9共10類，故輸出有10個節點，這些節點表示屬於該類的概率。構建網絡需要有初始化的參數，可以利用高斯分布進行參數的初始化，即函數tf.random.normal(shape,mean=0.0,stddev=1.0)，但是為了避免參數初始化過大，常采用截斷型正態分布，即函數tf.random.truncated_normal(shape,mean=0.0,stddev=1.0)，該函數將丟棄幅度大於平均值的2個標准偏差的值並重新選擇，這里也就是說隨機的值范圍在-2~2之間。在初始化參數時也要注意參數的shape，例如784->256的參數shape應為(784,256)，偏置shape應為(256,)，這樣還方便之后的矩陣運算。偏置一般都初始化為0。此外，所有參數都必須轉為tf.Variable類型，才可以記錄下梯度信息。

#input(layer0)->layer1: nodes:784->256
theta_1 = tf.Variable(tf.random.truncated_normal([784,256]))#因為后面要記錄梯度信息，所以要用Varible
bias_1  = tf.Variable(tf.zeros([256]))

#layer1->layer2: nodes:256->128
theta_2 = tf.Variable(tf.random.truncated_normal([256,128]))
bias_2  = tf.Variable(tf.zeros([128]))

#layer2->out(layer3): nodes:128->10
theta_3 = tf.Variable(tf.random.truncated_normal([128,10]))
bias_3  = tf.Variable(tf.zeros([10]))

初始化參數后，可以統計一下網絡的參數量：784*256+256*128+128*10+256+128+10=235146。大約20萬個參數，相比一些經典卷積網絡，全連接網絡的參數量還是比較少的。

 

對train_db進行迭代，套上enumerate()以便獲取迭代批次。每一批數據，都要進行前向傳播。首先，將shape為[256,28,28]圖片打平為[256,784]，這個可以借助tf.reshape(tensor,shape)，在不改變元素個數的前提下，對維度進行分解或者合並。這樣，h_1=x@theta1+bias1就可以得到下一層網絡的節點值。h_1的shape為[256,256]；同理，h_2的shape為[256,128]，h_3的shape為[256,10]。每一層計算之后都應該加上一個激活函數，最常用的就是ReLu，通過激活函數可以增加網絡的非線性表達能力，這里使用函數tf.nn.relu(features)。

由於更新參數需要得到各參數的梯度信息，因此前向傳播要用with tf.GradientTape() as tape:包裹起來，關於with as 的語法如果不熟悉可以參考https://www.cnblogs.com/DswCnblog/p/6126588.html。此外，還得計算代價函數，就是Loss，一般采用差平方的均值來計算，差平方使用tf.math.square(x)，均值采用tf.math.reduce_mean(input_tensor,axis=None)，如果不指定axis就對所有元素求均值，返回值是標量，而如果指定axis，就僅對該axis做均值，結果的shape中該axis消失。

for batch, (x, y) in enumerate(train_db):
    # x:[256,28,28]
    x = tf.reshape(x, [-1, 28 * 28])  # 最后一批<256個,用-1可以自動計算
    with tf.GradientTape() as tape:
        # 前向傳播
        # x:[256,784] theta_1:[784,256] bias_1:[256,] h_1:[256,256]
        h_1 = x @ theta_1 + bias_1
        h_1 = tf.nn.relu(h_1)
        # h_1:[256,256] theta_2:[256,128] bias_2:[128,] h_2:[256,128]
        h_2 = h_1 @ theta_2 + bias_2
        h_2 = tf.nn.relu(h_2)
        # h_2:[256,128] theta_3:[128,10] bias_2:[10,] out:[256,10]
        out = h_2 @ theta_3 + bias_3# 計算代價函數
        # out:[256,10] y:[256,10]
        loss = tf.math.square(y - out)
        # loss:[256,10]->scalar
        loss = tf.math.reduce_mean(loss)

 

上一部分對梯度信息進行了記錄，我們要更新參數，必須先執行loss對各參數求導，之后根據學習率進行參數更新：

alpha = tf.constant(1e-3)
#獲取梯度信息，grads為一個列表，順序依據給定的參數列表
grads = tape.gradient(loss,[theta_1,bias_1,theta_2,bias_2,theta_3,bias_3])
#根據給定列表順序，對參數求導
theta_1 = theta_1 - alpha * grads[0]
theta_2 = theta_2 - alpha * grads[2]
theta_3 = theta_3 - alpha * grads[4]
bias_1 = bias_1 - alpha * grads[1]
bias_2 = bias_2 - alpha * grads[3]
bias_3 = bias_3 - alpha * grads[5]
#每隔100個batch打印一次loss
if batch % 100 ==0:
    print(batch,'loss:',float(loss))

 

到此為止，整個訓練網絡就完成了。為了測試網絡的效果，我們需要對測試數據集進行預測，並且計算出准確率。關於測試的前向傳播同之前的一樣，但測試時並不需要對參數進行更新。網絡的輸出層有10個類別的概率，我們要取概率最大的作為預測的類別，這可以通過tf.math.argmax(input,axis=None)來實現，該函數可以返回數組中最大數的位置，axis的作用類似與reduce_mean。預測結果的正確與否可用tf.math.equal(x,y)來判別，它返回Bool型列表。由於一批次有256個圖片，那么預測結果也有256個，可以用tf.math.reduce_sum(input_tensor,axis=None)進行求和，求和前通過tf.cast(x,dtype)將Bool類型轉為整型。

correct_cnt = 0  # 預測對的數量
total_val = val_y.shape[0]  # 測試樣本總數

# 測試數據預測
for (val_x, val_y) in test_db:
    val_x = tf.reshape(val_x, [-1, 28 * 28])
    val_h_1 = val_x @ theta_1 + bias_1
    val_h_1 = tf.nn.relu(val_h_1)
    val_h_2 = val_h_1 @ theta_2 + bias_2
    val_h_2 = tf.nn.relu(val_h_2)
    val_out = val_h_2 @ theta_3 + bias_3

    # val_out:(256,10) pred:(256,)
    pred = tf.math.argmax(val_out, axis=-1)
    # acc:bool (256,)
    acc = tf.math.equal(pred, val_y)
    acc = tf.cast(acc, dtype=tf.int32)
    correct_cnt += tf.math.reduce_sum(acc)

percent = float(correct_cnt / total_val)
print('val_acc:',percent)

 

自此所有的代碼片段都已分析完畢。下一節將展示綜合的代碼和運行結果。

 

 

 

 

二、亡羊補牢，搞定BUG

為了之后敘述的方便，這里先給出綜合的代碼，在原有基礎上，還加上了訓練集的准確度計算，和時間記錄。

import tensorflow as tf
#數據集管理器
from tensorflow.keras import datasets
import time

#導入數據集
(x,y),(val_x,val_y) = datasets.mnist.load_data()
#數據集信息
print('type_x:',type(x),'dtype_x:',x.dtype)
print('type_y:',type(y),'dtype_y:',y.dtype)
print('shape_x:',x.shape,'shape_y:',y.shape)
print('shape_val:',val_x.shape,'shape_val:',val_y.shape)
print('max_x:',x.max(),'min_x:',x.min())
print('max_y:',y.max(),'min_y:',y.min())

#需要將數據轉成Tensor
x = tf.convert_to_tensor(x,dtype=tf.float32)
y = tf.convert_to_tensor(y,dtype=tf.int32)
val_x = tf.convert_to_tensor(val_x,dtype=tf.float32)
val_y = tf.convert_to_tensor(val_y,dtype=tf.int32)
#獨熱碼
y = tf.one_hot(y,depth=10)
print('one_hot_y:',y.shape)

#生成批處理
test_db =  tf.data.Dataset.from_tensor_slices((val_x,val_y)).shuffle(10000).batch(256)
train_db =  tf.data.Dataset.from_tensor_slices((x,y)).shuffle(10000).batch(256)
#批處理數據信息
train_iter = iter(train_db)
sample = next(train_iter)
print('sample_x_shape:',sample[0].shape,'sample_y_shape:',sample[1].shape)

#參數初始化
#input(layer0)->layer1: nodes:784->256
theta_1 = tf.Variable(tf.random.truncated_normal([784,256]))#因為后面要記錄梯度信息，所以要用Varible
bias_1  = tf.Variable(tf.zeros([256]))

#layer1->layer2: nodes:256->128
theta_2 = tf.Variable(tf.random.truncated_normal([256,128]))
bias_2  = tf.Variable(tf.zeros([128]))

#layer2->out(layer3): nodes:128->10
theta_3 = tf.Variable(tf.random.truncated_normal([128,10]))
bias_3  = tf.Variable(tf.zeros([10]))

#確定學習率
alpha = tf.constant(1e-3)
# 測試樣本總數
total_val = val_y.shape[0]
# 訓練樣本總數
total_y = y.shape[0]
#開始時間
start_time = time.time()

for echo in range(500):
    #前向傳播
    correct_cnt = 0       # 預測對的數量

    for batch, (x, y) in enumerate(train_db):
        # x:[256,28,28]
        x = tf.reshape(x, [-1, 28 * 28])  # 最后一批<256個,用-1可以自動計算
        with tf.GradientTape() as tape:
            # 前向傳播
            # x:[256,784] theta_1:[784,256] bias_1:[256,] h_1:[256,256]
            h_1 = x @ theta_1 + bias_1
            h_1 = tf.nn.relu(h_1)
            # h_1:[256,256] theta_2:[256,128] bias_2:[128,] h_2:[256,128]
            h_2 = h_1 @ theta_2 + bias_2
            h_2 = tf.nn.relu(h_2)
            # h_2:[256,128] theta_3:[128,10] bias_2:[10,] out:[256,10]
            out = h_2 @ theta_3 + bias_3
            # 計算代價函數
            # out:[256,10] y:[256,10]
            loss = tf.math.square(y - out)
            # loss:[256,10]->scalar
            loss = tf.math.reduce_mean(loss)

        # 獲取梯度信息，grads為一個列表，順序依據給定的參數列表
        grads = tape.gradient(loss, [theta_1, bias_1, theta_2, bias_2, theta_3, bias_3])
        # 根據給定列表順序，對參數求導
        theta_1 = theta_1 - alpha * grads[0]
        theta_2 = theta_2 - alpha * grads[2]
        theta_3 = theta_3 - alpha * grads[4]
        bias_1 = bias_1 - alpha * grads[1]
        bias_2 = bias_2 - alpha * grads[3]
        bias_3 = bias_3 - alpha * grads[5]

        pred = tf.math.argmax(out, axis=-1)
        y_label = tf.math.argmax(y, axis=-1)
        acc = tf.math.equal(pred, y_label)
        acc = tf.cast(acc, dtype=tf.int32)
        correct_cnt += tf.math.reduce_sum(acc)

        # 每隔100個batch打印一次loss
        if batch % 100 == 0:
            print(batch, 'loss:', float(loss))

    #訓練的准確度
    percent = float(correct_cnt / total_y)
    print('train_acc:', percent)

    correct_cnt = 0  # 預測對的數量


    # 測試數據預測
    for (val_x, val_y) in test_db:
        val_x = tf.reshape(val_x, [-1, 28 * 28])
        val_h_1 = val_x @ theta_1 + bias_1
        val_h_1 = tf.nn.relu(val_h_1)
        val_h_2 = val_h_1 @ theta_2 + bias_2
        val_h_2 = tf.nn.relu(val_h_2)
        val_out = val_h_2 @ theta_3 + bias_3

        # val_out:(256,10) pred:(256,)
        pred = tf.math.argmax(val_out, axis=-1)
        # acc:bool (256,)
        acc = tf.math.equal(pred, val_y)
        acc = tf.cast(acc, dtype=tf.int32)
        correct_cnt += tf.math.reduce_sum(acc)

    #測試准確度
    percent = float(correct_cnt / total_val)
    print('val_acc:', percent)
    print('time:',int(time.time()-start_time)//60,':',int(time.time()-start_time)%60)

 

以為自此萬事大吉，沒想到剛跑就報錯，報錯如下：

0 loss: 75169185792.0
Traceback (most recent call last):
File "D:/programe/tensorflow/tf-project/practice01/forward.py", line 76, in <module>
theta_1 = theta_1 - alpha * grads[0]
ValueError: Attempt to convert a value (None) with an unsupported type (<class 'NoneType'>) to a Tensor.

 

由報錯可知，錯誤大概出在參數更新那里。並且此時第一loss已經被打印出來了，雖然這個Loss有點大得離譜，不過應該不會使得theta_1為None或者grads為None。經過Debug確認為grads為None，並且還發現參數經過一次更新后，其類型從Variable變成了普通的Tensor類型。這就說明問題了，Variable在和Tensor計算時會轉換成Tensor。之前曾說過，只有Variable才能記錄下梯度信息，因此在第二輪更新時，梯度已經不能正常記錄了，才導致grads為None。解決的辦法有兩種，一種在更新后用tf.Variable進行轉換；第二種就是使用原地更新，Variable特有方法.assign_sub進行減法運算，除此之外，還有類似的加法運算等。將上面程序的81~86行改成下面程序段：

theta_1.assign_sub(alpha*grads[0])#原地更新，類型不變
theta_2.assign_sub(alpha * grads[2])
theta_3.assign_sub(alpha * grads[4])
bias_1.assign_sub(alpha*grads[1])
bias_2.assign_sub(alpha * grads[3])
bias_3.assign_sub(alpha * grads[5])

 

再次運行程序，且看報錯信息：

0 loss: 87516119040.0
100 loss: nan
200 loss: nan
train_acc: 0.09881666666666666
Traceback (most recent call last):
  File "D:/programe/tensorflow/tf-project/practice01/forward.py", line 110, in <module>
    acc = tf.math.equal(pred, val_y)
tensorflow.python.framework.errors_impl.InvalidArgumentError: cannot compute Equal as input
#1(zero-based) was expected to be a int64 tensor but is a int32 tensor [Op:Equal]

 

這里的報錯跟loss也沒關系，根據報錯提示，這里的equal應該要求兩個數據的類型要相同，而實際上pred是argmax默認返回的int64類型，val_y我們之前把它轉為了int32，為了統一，將程序的第20行改為:

val_y = tf.convert_to_tensor(val_y,dtype=tf.int64) #與argmax返回值類型統一

 

再次運行程序，終於不報錯了，但是之前忽略的Loss問題就出現了，看一下輸出結果：

0 loss: 110720491520.0
100 loss: nan
200 loss: nan
train_acc: 0.09888333333333334
val_acc: 0.098
0 loss: nan
100 loss: nan
200 loss: nan
train_acc: 0.09871666666666666
val_acc: 0.098

 

關於Python值出現nan的原因可以參考博客https://www.jianshu.com/p/d9caa4ab46e1。根據博客，inf的運算可能會導致nan。那么，我們可以通過Debug查看運算過程中是否有變量出現了inf，結果在Debug到71行時第70行的loss變為了inf，並且其他變量包括網絡權重都非常大，例如下圖：

 

 為了解決該問題，可以采用特征縮放，即把圖片的灰度值縮放到(0,1)或者(-0.5,0.5)之間，有關特征縮放的好處可以參考https://www.cnblogs.com/kensporger/p/11747100.html#_lab2_2_3。將第17行、19行改為：

x = tf.convert_to_tensor(x,dtype=tf.float32) /255.5 -0.5
val_x = tf.convert_to_tensor(val_x,dtype=tf.float32) /255.5 -0.5

 

 再次運行程序，但是loss仍然為nan，但第一次計算的loss比原先小了許多，但還不夠小，看一下輸出結果：

0 loss: 2819718.5
100 loss: nan
200 loss: nan
train_acc: 0.09841666666666667
val_acc: 0.098
0 loss: nan
100 loss: nan
200 loss: nan
train_acc: 0.09871666666666666
val_acc: 0.098

 

我們之前縮小了特征值，但是參數初始化的范圍是[-2,2]。這個參數還是過大了，通過Debug可以知道輸出節點大約在1k左右，那么用這個1k去做差平方顯然是不對的，要知道標簽值也就0/1。因此我們將參數初始化為[-0.2,0.2]，這樣輸出節點值大約在1左右，梯度大約為1e-3級別。將第35、39、43行改為以下內容：

theta_1 = tf.Variable(tf.random.truncated_normal([784,256],stddev=0.1))#因為后面要記錄梯度信息，所以要用Varible
theta_2 = tf.Variable(tf.random.truncated_normal([256,128],stddev=0.1))
theta_3 = tf.Variable(tf.random.truncated_normal([128,10],stddev=0.1))

 

再次運行程序，可發現loss在穩步下降，acc正常上升，所有問題都已解決。程序最終准確率大約為0.9，訓練時間25分鍾。可以試一下增加以下網絡層數，因為就目前的train_acc和val_acc來看，並沒有達到過擬合狀態，可能層數增加，准確度還可以提高個2%左右。如果還想再有所提升，可能就得采用TensorFlow提供的優化手段了，這個下次再寫。

 

補充：到這里，筆者忽略了一個錯誤，實際上對Loss的計算不應該采用差平方的均值，這種方法更適合二分類；對於多分類，應采用交叉熵函數進行計算。改動原程序的第73-76行，注意，我們仍需要對交叉熵計算出的Loss取均值才是每個樣本的Loss。

 

loss = tf.keras.losses.categorical_crossentropy(y,out,from_logits=True)
loss = tf.math.reduce_mean(loss)

 

 事實證明，通過交叉熵計算Loss，准確率上升更快，經過大約7分鍾的訓練，准確度能達到0.93左右。

 

 

 

三、智慧結晶

這次實例，需要注意的地方：

1.Variable要用assign_sub進行更新；

2.equal要求比較的兩者數據類型要一致；

3.argmax默認返回int64類型；

4.特征縮放是必須的；

5.權重初始化要使得輸出節點值和梯度值合理；

6.多元分類使用交叉熵計算Loss;

 

import tensorflow as tf
#數據集管理器
from tensorflow.keras import datasets
import time

#導入數據集
(x,y),(val_x,val_y) = datasets.mnist.load_data()
#數據集信息
print('type_x:',type(x),'dtype_x:',x.dtype)
print('type_y:',type(y),'dtype_y:',y.dtype)
print('shape_x:',x.shape,'shape_y:',y.shape)
print('shape_val:',val_x.shape,'shape_val:',val_y.shape)
print('max_x:',x.max(),'min_x:',x.min())
print('max_y:',y.max(),'min_y:',y.min())

#需要將數據轉成Tensor
x = tf.convert_to_tensor(x,dtype=tf.float32) /255 -0.5
y = tf.convert_to_tensor(y,dtype=tf.int32)
val_x = tf.convert_to_tensor(val_x,dtype=tf.float32)/255 -0.5
val_y = tf.convert_to_tensor(val_y,dtype=tf.int64) #與argmax返回值類型統一
#獨熱碼
y = tf.one_hot(y,depth=10)
print('one_hot_y:',y.shape)

#生成批處理
test_db =  tf.data.Dataset.from_tensor_slices((val_x,val_y)).shuffle(10000).batch(256)
train_db =  tf.data.Dataset.from_tensor_slices((x,y)).shuffle(10000).batch(256)
#批處理數據信息
train_iter = iter(train_db)
sample = next(train_iter)
print('sample_x_shape:',sample[0].shape,'sample_y_shape:',sample[1].shape)

#參數初始化
#input(layer0)->layer1: nodes:784->256
theta_1 = tf.Variable(tf.random.truncated_normal([784,256],stddev=0.1))#因為后面要記錄梯度信息，所以要用Varible
bias_1  = tf.Variable(tf.zeros([256]))

#layer1->layer2: nodes:256->128
theta_2 = tf.Variable(tf.random.truncated_normal([256,128],stddev=0.1))
bias_2  = tf.Variable(tf.zeros([128]))

#layer2->out(layer3): nodes:128->10
theta_3 = tf.Variable(tf.random.truncated_normal([128,10],stddev=0.1))
bias_3  = tf.Variable(tf.zeros([10]))

#確定學習率
alpha = tf.constant(1e-3)
# 測試樣本總數
total_val = val_y.shape[0]
# 訓練樣本總數
total_y = y.shape[0]
#開始時間
start_time = time.time()

for echo in range(500):
    #前向傳播
    correct_cnt = 0       # 預測對的數量

    for batch, (x, y) in enumerate(train_db):
        # x:[256,28,28]
        x = tf.reshape(x, [-1, 28 * 28])  # 最后一批<256個,用-1可以自動計算
        with tf.GradientTape() as tape:
            # 前向傳播
            # x:[256,784] theta_1:[784,256] bias_1:[256,] h_1:[256,256]
            h_1 = x @ theta_1 + bias_1
            h_1 = tf.nn.relu(h_1)
            # h_1:[256,256] theta_2:[256,128] bias_2:[128,] h_2:[256,128]
            h_2 = h_1 @ theta_2 + bias_2
            h_2 = tf.nn.relu(h_2)
            # h_2:[256,128] theta_3:[128,10] bias_2:[10,] out:[256,10]
            out = h_2 @ theta_3 + bias_3

            # 計算代價函數
            # out:[256,10] y:[256,10]
            loss = tf.losses.categorical_crossentropy(y,out,from_logits=True)# loss:[256,10]->scalar
            loss = tf.math.reduce_mean(loss)

        # 獲取梯度信息，grads為一個列表，順序依據給定的參數列表
        grads = tape.gradient(loss, [theta_1, bias_1, theta_2, bias_2, theta_3, bias_3])
        # 根據給定列表順序，對參數求導
        theta_1.assign_sub(alpha * grads[0])  # 原地更新，類型不變
        theta_2.assign_sub(alpha * grads[2])
        theta_3.assign_sub(alpha * grads[4])
        bias_1.assign_sub(alpha * grads[1])
        bias_2.assign_sub(alpha * grads[3])
        bias_3.assign_sub(alpha * grads[5])

        pred = tf.math.argmax(out, axis=-1)
        y_label = tf.math.argmax(y, axis=-1)
        acc = tf.math.equal(pred, y_label)
        acc = tf.cast(acc, dtype=tf.int32)
        correct_cnt += tf.math.reduce_sum(acc)

        # 每隔100個batch打印一次loss
        if batch % 100 == 0:
            print(batch, 'loss:', float(loss))

    #訓練的准確度
    percent = float(correct_cnt / total_y)
    print('train_acc:', percent)

    correct_cnt = 0  # 預測對的數量


    # 測試數據預測
    for (val_x, val_y) in test_db:
        val_x = tf.reshape(val_x, [-1, 28 * 28])
        val_h_1 = val_x @ theta_1 + bias_1
        val_h_1 = tf.nn.relu(val_h_1)
        val_h_2 = val_h_1 @ theta_2 + bias_2
        val_h_2 = tf.nn.relu(val_h_2)
        val_out = val_h_2 @ theta_3 + bias_3

        # val_out:(256,10) pred:(256,)
        pred = tf.math.argmax(val_out, axis=-1)
        # acc:bool (256,)
        acc = tf.math.equal(pred, val_y)
        acc = tf.cast(acc, dtype=tf.int32)
        correct_cnt += tf.math.reduce_sum(acc)

    #測試准確度
    percent = float(correct_cnt / total_val)
    print('val_acc:', percent)
    print('time:',int(time.time()-start_time)//60,':',int(time.time()-start_time)%60)