手寫數字識別——基於全鏈接層和MNIST數據集

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

 

 

1、量子波動擼代碼

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

首先，導入依賴的兩個模塊，一個是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一下，以防網絡發現順序規律。事實上，把整個數據集一次餵給網絡來更新參數的過程稱爲批梯度降低；而每次只喂一張圖片，則稱爲隨機梯度降低；每次將一小批圖片餵給網絡，稱爲小批量梯度降低。關於三者的區別能夠參考http://www.javashuo.com/article/p-fribneoh-eq.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 的語法若是不熟悉能夠參考http://www.javashuo.com/article/p-zjagbirq-kz.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)

 

自此全部的代碼片斷都已分析完畢。下一節將展現綜合的代碼和運行結果。

 

 

 

 

2、亡羊補牢，搞定BUG

爲了以後敘述的方便，這裏先給出綜合的代碼，在原有基礎上，還加上了訓練集的準確度計算，和時間記錄。

  1 import tensorflow as tf
  2 #數據集管理器
  3 from tensorflow.keras import datasets
  4 import time
  5 
  6 #導入數據集
  7 (x,y),(val_x,val_y) = datasets.mnist.load_data()
  8 #數據集信息
  9 print('type_x:',type(x),'dtype_x:',x.dtype)
 10 print('type_y:',type(y),'dtype_y:',y.dtype)
 11 print('shape_x:',x.shape,'shape_y:',y.shape)
 12 print('shape_val:',val_x.shape,'shape_val:',val_y.shape)
 13 print('max_x:',x.max(),'min_x:',x.min())
 14 print('max_y:',y.max(),'min_y:',y.min())
 15 
 16 #須要將數據轉成Tensor
 17 x = tf.convert_to_tensor(x,dtype=tf.float32)
 18 y = tf.convert_to_tensor(y,dtype=tf.int32)
 19 val_x = tf.convert_to_tensor(val_x,dtype=tf.float32)
 20 val_y = tf.convert_to_tensor(val_y,dtype=tf.int32)
 21 #獨熱碼
 22 y = tf.one_hot(y,depth=10)
 23 print('one_hot_y:',y.shape)
 24 
 25 #生成批處理
 26 test_db =  tf.data.Dataset.from_tensor_slices((val_x,val_y)).shuffle(10000).batch(256)
 27 train_db =  tf.data.Dataset.from_tensor_slices((x,y)).shuffle(10000).batch(256)
 28 #批處理數據信息
 29 train_iter = iter(train_db)
 30 sample = next(train_iter)
 31 print('sample_x_shape:',sample[0].shape,'sample_y_shape:',sample[1].shape)
 32 
 33 #參數初始化
 34 #input(layer0)->layer1: nodes:784->256
 35 theta_1 = tf.Variable(tf.random.truncated_normal([784,256]))#由於後面要記錄梯度信息，因此要用Varible
 36 bias_1  = tf.Variable(tf.zeros([256]))
 37 
 38 #layer1->layer2: nodes:256->128
 39 theta_2 = tf.Variable(tf.random.truncated_normal([256,128]))
 40 bias_2  = tf.Variable(tf.zeros([128]))
 41 
 42 #layer2->out(layer3): nodes:128->10
 43 theta_3 = tf.Variable(tf.random.truncated_normal([128,10]))
 44 bias_3  = tf.Variable(tf.zeros([10]))
 45 
 46 #肯定學習率
 47 alpha = tf.constant(1e-3)
 48 # 測試樣本總數
 49 total_val = val_y.shape[0]
 50 # 訓練樣本總數
 51 total_y = y.shape[0]
 52 #開始時間
 53 start_time = time.time()
 54 
 55 for echo in range(500):
 56     #前向傳播
 57     correct_cnt = 0       # 預測對的數量
 58 
 59     for batch, (x, y) in enumerate(train_db):
 60         # x:[256,28,28]
 61         x = tf.reshape(x, [-1, 28 * 28])  # 最後一批<256個,用-1能夠自動計算
 62         with tf.GradientTape() as tape:
 63             # 前向傳播
 64             # x:[256,784] theta_1:[784,256] bias_1:[256,] h_1:[256,256]
 65             h_1 = x @ theta_1 + bias_1
 66             h_1 = tf.nn.relu(h_1)
 67             # h_1:[256,256] theta_2:[256,128] bias_2:[128,] h_2:[256,128]
 68             h_2 = h_1 @ theta_2 + bias_2
 69             h_2 = tf.nn.relu(h_2)
 70             # h_2:[256,128] theta_3:[128,10] bias_2:[10,] out:[256,10]
 71             out = h_2 @ theta_3 + bias_3
 72             # 計算代價函數
 73             # out:[256,10] y:[256,10]
 74             loss = tf.math.square(y - out)
 75             # loss:[256,10]->scalar
 76             loss = tf.math.reduce_mean(loss)
 77 
 78         # 獲取梯度信息，grads爲一個列表，順序依據給定的參數列表
 79         grads = tape.gradient(loss, [theta_1, bias_1, theta_2, bias_2, theta_3, bias_3])
 80         # 根據給定列表順序，對參數求導
 81         theta_1 = theta_1 - alpha * grads[0]
 82         theta_2 = theta_2 - alpha * grads[2]
 83         theta_3 = theta_3 - alpha * grads[4]
 84         bias_1 = bias_1 - alpha * grads[1]
 85         bias_2 = bias_2 - alpha * grads[3]
 86         bias_3 = bias_3 - alpha * grads[5]
 87 
 88         pred = tf.math.argmax(out, axis=-1)
 89         y_label = tf.math.argmax(y, axis=-1)
 90         acc = tf.math.equal(pred, y_label)
 91         acc = tf.cast(acc, dtype=tf.int32)
 92         correct_cnt += tf.math.reduce_sum(acc)
 93 
 94         # 每隔100個batch打印一次loss
 95         if batch % 100 == 0:
 96             print(batch, 'loss:', float(loss))
 97 
 98     #訓練的準確度
 99     percent = float(correct_cnt / total_y)
100     print('train_acc:', percent)
101 
102     correct_cnt = 0  # 預測對的數量
103 
104 
105     # 測試數據預測
106     for (val_x, val_y) in test_db:
107         val_x = tf.reshape(val_x, [-1, 28 * 28])
108         val_h_1 = val_x @ theta_1 + bias_1
109         val_h_1 = tf.nn.relu(val_h_1)
110         val_h_2 = val_h_1 @ theta_2 + bias_2
111         val_h_2 = tf.nn.relu(val_h_2)
112         val_out = val_h_2 @ theta_3 + bias_3
113 
114         # val_out:(256,10) pred:(256,)
115         pred = tf.math.argmax(val_out, axis=-1)
116         # acc:bool (256,)
117         acc = tf.math.equal(pred, val_y)
118         acc = tf.cast(acc, dtype=tf.int32)
119         correct_cnt += tf.math.reduce_sum(acc)
120 
121     #測試準確度
122     percent = float(correct_cnt / total_val)
123     print('val_acc:', percent)
124     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級別。將第3五、3九、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正常上升，全部問題都已解決。程序最終準確率大約爲90%，訓練時間25分鐘。能夠試一下增長如下網絡層數，由於就目前的train_acc和val_acc來看，並無達到過擬合狀態，可能層數增長，準確度還能夠提升個2%左右。若是還想再有所提高，可能就得采用TensorFlow提供的優化手段了，這個下次再寫。

 

 

 

3、智慧結晶

此次實例，須要注意的地方：

1.Variable要用assign_sub進行更新；

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

3.argmax默認返回int64類型；

4.特徵縮放是必須的；

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

 

最後貼上正確的完整代碼：

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