搭配使用 Keras 和 TPU，翻新 convnets、squeezenet 和 Xception 模型

1. 總覽

在本實驗室中，您將瞭解現代卷積架構，並運用所學知識實作簡單但有效的卷積神經網路，稱為「squeezenet」。

本實驗室包含卷積類神經網路的必要理論說明，是開發人員學習深度學習的良好起點。

本實驗室是「TPU 上的 Keras」系列實驗室的第 4 部分。你可以依下列順序執行這些步驟，也可以單獨執行。

• TPU 高速資料管道：tf.data.Dataset 和 TFRecords
• 第一個 Keras 模型，採用遷移學習
• 使用 Keras 和 TPU 建構卷積類神經網路
• [本實驗室] 搭配使用 Keras 和 TPU，翻新 convnet、squeezenet 和 Xception 模型

課程內容

• 如要精通 Keras 函式樣式
• 如要使用 SqueezeNet 架構建構模型
• 使用 TPU 快速訓練模型，並疊代架構
• 如何使用 tf.data.dataset 實作資料擴增
• 在 TPU 上微調預先訓練的大型模型 (Xception)

意見回饋

如果您發現這個程式碼研究室有任何錯誤，請告訴我們。你可以透過 GitHub 問題 [意見回饋連結] 提供意見。

2. Google Colaboratory 快速入門

本實驗室使用 Google Colaboratory，您無須進行任何設定。Colaboratory 是線上筆記本平台，適用於教育用途。提供免費的 CPU、GPU 和 TPU 訓練。

您可以開啟這個範例筆記本，並執行幾個儲存格，熟悉 Colaboratory 的操作方式。

Welcome to Colab.ipynb

選取 TPU 後端

在 Colab 選單中，依序選取「執行階段」>「變更執行階段類型」，然後選取「TPU」。在本程式碼研究室中，您將使用強大的 TPU (Tensor Processing Unit)，支援硬體加速訓練。首次執行時，系統會自動連線至執行階段，您也可以使用右上角的「連線」按鈕。

筆記本執行

按一下儲存格並使用 Shift-ENTER，即可一次執行一個儲存格。您也可以依序選取「執行階段」>「全部執行」，執行整個筆記本。

Table of contents

所有筆記本都有目錄。你可以使用左側的黑色箭頭開啟這個選單。

隱藏的儲存格

部分儲存格只會顯示標題，這是 Colab 專屬的筆記本功能。你可以按兩下查看其中的程式碼，但通常不會很有趣。通常是支援或視覺化函式。您仍需執行這些儲存格，才能定義其中的函式。

驗證

只要使用已授權的帳戶進行驗證，Colab 就能存取您的私人 Google Cloud Storage bucket。上述程式碼片段會觸發驗證程序。

3. [INFO] 什麼是 Tensor Processing Unit (TPU)？

簡介

TPU 是專門用於深度學習任務的硬體加速器。在本程式碼研究室中，您將瞭解如何搭配 Keras 和 TensorFlow 2 使用這些工具。Cloud TPU 的基本設定為 8 個核心，此外還有多種大型設定，稱為「TPU Pod」，最多可達 2048 個核心。增加訓練批量，藉此加速訓練。

在 Keras 中於 TPU 上訓練模型的程式碼 (如果沒有 TPU，則改用 GPU 或 CPU)：

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

我們今天將使用 TPU，以互動式速度 (每次訓練執行幾分鐘) 建構及最佳化花朵分類器。

為何選擇 TPU？

現代 GPU 是以可程式化的「核心」為基礎架構，這種架構非常靈活，可處理各種工作，例如 3D 算繪、深度學習、物理模擬等。另一方面，TPU 會將傳統向量處理器與專用矩陣乘法單元配對，並擅長處理大型矩陣乘法運算占主導地位的任何工作，例如類神經網路。

插圖：密集類神經網路層，以矩陣乘法表示，一次透過類神經網路處理一批八張圖片。請執行一行 x 欄的乘法，確認這確實是圖像所有像素值的加權總和。卷積層也可以表示為矩陣乘法，但會稍微複雜一些 ( 請參閱第 1 節的說明)。

硬體

MXU 和 VPU

TPU v2 核心由矩陣乘法單元 (MXU) 和向量處理單元 (VPU) 組成，前者用於執行矩陣乘法，後者則用於執行所有其他工作，例如活化、softmax 等。VPU 會處理 float32 和 int32 運算。另一方面，MXU 則是以混合精度的 16 到 32 位元浮點格式運作。

混合精確度浮點和 bfloat16

MXU 會使用 bfloat16 輸入和 float32 輸出計算矩陣乘法。中繼累計作業會以 float32 精確度執行。

類神經網路訓練通常能抵禦因浮點數精確度降低而產生的雜訊。有時雜訊甚至有助於最佳化工具收斂。傳統上，16 位元浮點數精度用於加速運算，但 float16 和 float32 格式的範圍差異很大。將精確度從 float32 降為 float16 通常會導致溢位和下溢。雖然有解決方案，但通常需要額外作業才能讓 float16 運作。

因此，Google 在 TPU 中導入了 bfloat16 格式。bfloat16 是經過截斷的 float32，與 float32 的指數位元和範圍完全相同。此外，TPU 會以混合精度計算矩陣乘法，並使用 bfloat16 輸入，但輸出為 float32，因此通常不需要變更程式碼，就能享有精度降低帶來的效能提升。

在 TPU 上，預設會使用 bfloat16/float32 混合精確度。您不必變更 Tensorflow 程式碼，即可啟用這項功能。您仍可在整個程式碼中使用 float32。執行矩陣乘法時，TPU 會自動將輸入內容截斷為 bfloat16。產生的矩陣為 float32。

Systolic array

MXU 會使用所謂的「脈動陣列」架構，在硬體中實作矩陣乘法，讓資料元素流經硬體運算單元陣列。(在醫學上，「收縮」是指心臟收縮和血液流動，這裡則是指資料流動。)

矩陣乘法的基本元素是兩個矩陣中，一個矩陣的列與另一個矩陣的欄之間的點積 (請參閱本節頂端的插圖)。以矩陣乘法 Y=X*W 來說，結果的一個元素會是：

Y[2,0] = X[2,0]*W[0,0] + X[2,1]*W[1,0] + X[2,2]*W[2,0] + ... + X[2,n]*W[n,0]

在 GPU 上，您可以將這個點積程式設計到 GPU「核心」，然後在盡可能多的「核心」上平行執行，嘗試一次計算結果矩陣的每個值。如果產生的矩陣為 128x128 大小，則需要 128x128=16K 個「核心」，這通常是不可能的。最大的 GPU 約有 4000 個核心。另一方面，TPU 會為 MXU 中的運算單元使用最少的硬體：只有 bfloat16 x bfloat16 => float32 乘法累加器，沒有其他元件。這些單元非常小，TPU 可以在 128x128 MXU 中實作 16K 個單元，並一次處理這個矩陣乘法。

插圖：MXU 脈動陣列。運算元素是乘法累加器。一個矩陣的值會載入陣列 (紅點)。其他矩陣的值會流經陣列 (灰色點)。垂直線會將值向上傳播。水平線會傳播部分總和。使用者必須自行驗證，當資料流經陣列時，右側會輸出矩陣乘法運算的結果。

此外，在 MXU 中計算點積時，中間總和只會在相鄰的運算單元之間流動。這類值不需要儲存及從記憶體或暫存器檔案中擷取。因此，在計算矩陣乘法時，TPU 脈動陣列架構在密度和電力方面具有顯著優勢，且速度也比 GPU 快上不少。

Cloud TPU

在 Google Cloud Platform 上要求「Cloud TPU v2」時，您會取得具有 PCI 連接 TPU 板的虛擬機器 (VM)。TPU 板有四個雙核心 TPU 晶片。每個 TPU 核心都具備 VPU (向量處理單元) 和 128x128 MXU (矩陣乘法單元)。這個「Cloud TPU」通常會透過網路連線至要求該 TPU 的 VM。因此，完整圖片如下所示：

插圖：您的 VM，以及透過網路連結的「Cloud TPU」加速器。「Cloud TPU」本身是由 VM 和 PCI 連接的 TPU 板組成，板上則有四個雙核心 TPU 晶片。

TPU Pod

在 Google 的資料中心，TPU 會連線至高效能運算 (HPC) 互連，因此可視為一個非常大的加速器。Google 將這些節點稱為 Pod，最多可包含 512 個 TPU v2 核心或 2048 個 TPU v3 核心。

插圖：TPU v3 Pod。透過 HPC 互連網路連線的 TPU 板和機架。

在訓練期間，系統會使用 all-reduce 演算法在 TPU 核心之間交換梯度 ( 這裡有 all-reduce 的詳細說明)。訓練中的模型可透過訓練大量批次，充分運用硬體資源。

插圖：在 Google TPU 的 2D 環面網格 HPC 網路中，使用 all-reduce 演算法訓練期間的梯度同步。

軟體

大型批次大小訓練

TPU 的理想批次大小為每個 TPU 核心 128 個資料項目，但每個 TPU 核心 8 個資料項目時，硬體就能展現良好的使用率。請注意，一個 Cloud TPU 有 8 個核心。

在本程式碼研究室中，我們將使用 Keras API。在 Keras 中，您指定的批次是整個 TPU 的全域批次大小。系統會自動將批次分割為 8 個，並在 TPU 的 8 個核心上執行。

如需其他效能提示，請參閱 TPU 效能指南。如果批次大小非常大，部分模型可能需要特別注意，詳情請參閱 LARSOptimizer。

幕後花絮：XLA

Tensorflow 程式會定義計算圖。TPU 不會直接執行 Python 程式碼，而是執行 TensorFlow 程式定義的運算圖。在幕後，名為 XLA (加速線性代數編譯器) 的編譯器會將運算節點的 Tensorflow 圖形轉換為 TPU 機器碼。這個編譯器也會對程式碼和記憶體配置執行許多進階最佳化作業。當工作傳送至 TPU 時，系統會自動進行編譯。您不必在建構鏈中明確加入 XLA。

圖解：如要在 TPU 上執行，Tensorflow 程式定義的運算圖會先轉換為 XLA (加速線性代數編譯器) 表示法，然後由 XLA 編譯為 TPU 機器碼。

在 Keras 中使用 TPU

自 Tensorflow 2.1 起，Keras API 支援 TPU。Keras 支援 TPU 和 TPU Pod。以下範例適用於 TPU、GPU 和 CPU：

try: # detect TPUs
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver.connect()
    strategy = tf.distribute.TPUStrategy(tpu)
except ValueError: # detect GPUs
    strategy = tf.distribute.MirroredStrategy() # for CPU/GPU or multi-GPU machines

# use TPUStrategy scope to define model
with strategy.scope():
  model = tf.keras.Sequential( ... )
  model.compile( ... )

# train model normally on a tf.data.Dataset
model.fit(training_dataset, epochs=EPOCHS, steps_per_epoch=...)

在這個程式碼片段中：

• TPUClusterResolver().connect() 會在網路上尋找 TPU。在大多數 Google Cloud 系統 (AI Platform 工作、Colaboratory、Kubeflow、透過「ctpu up」公用程式建立的深度學習 VM) 上，這項工具都能在沒有參數的情況下運作。這些系統會透過 TPU_NAME 環境變數得知 TPU 所在位置。如要手動建立 TPU，請在您使用的 VM 上設定 TPU_NAME 環境變數，或使用明確的參數呼叫 TPUClusterResolver：TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy 是實作分配和「全縮減」梯度同步演算法的部分。
• 這項策略是透過範圍套用。模型必須在策略範圍() 內定義。
• tpu_model.fit 函式預期會收到 tf.data.Dataset 物件，做為 TPU 訓練的輸入內容。

常見的 TPU 移植作業

• 雖然在 TensorFlow 模型中載入資料的方法有很多種，但使用 TPU 時，必須使用 tf.data.Dataset API。
• TPU 的速度非常快，因此在 TPU 上執行時，擷取資料通常會成為瓶頸。您可以使用 TPU 效能指南中的工具，偵測資料瓶頸和其他效能提示。
• 系統會將 int8 或 int16 數字視為 int32。TPU 沒有在少於 32 位元上運作的整數硬體。
• 系統不支援部分 TensorFlow 作業。請參閱這份清單。好消息是，這項限制只適用於訓練程式碼，也就是模型的前向和後向傳遞。您仍可在資料輸入管道中使用所有 TensorFlow 作業，因為這些作業會在 CPU 上執行。
• TPU 不支援 tf.py_func。

4. [INFO] Neural network classifier 101

簡介

如果下一段粗體字詞你都瞭解，即可進行下一個練習。如果你才剛開始接觸深度學習，歡迎閱讀下文。

類神經網路分類器是由多個神經元層組成。如果是圖片分類，這些可以是密集或更常見的捲積層。通常會使用 relu 活化函式啟動。最後一層使用的神經元數量與類別數量相同，並以 softmax 啟動。對於分類，交叉熵是最常用的損失函式，可比較 one-hot 編碼的標籤 (即正確答案) 與類神經網路預測的機率。為盡量減少損失，最好選擇具有動量的最佳化工具，例如 AdamOptimizer，並在訓練圖片和標籤的批次上進行訓練。

如要以層序列建構模型，Keras 提供 Sequential API。舉例來說，使用三個密集層的圖片分類器可以 Keras 撰寫，如下所示：

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[192, 192, 3]),
    tf.keras.layers.Dense(500, activation="relu"),
    tf.keras.layers.Dense(50, activation="relu"),
    tf.keras.layers.Dense(5, activation='softmax') # classifying into 5 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

密集類神經網路

這是最簡單的圖片分類類神經網路。由分層排列的「神經元」組成。第一層會處理輸入資料，並將輸出內容饋送至其他層。由於每個神經元都會連結至上一層的所有神經元，因此稱為「密集」。

您可以將圖像的所有像素 RGB 值攤平成長向量，並做為輸入內容，將圖像饋送至這類網路。這並非圖像辨識的最佳技術，但我們稍後會加以改良。

神經元、啟動、RELU

「神經元」會計算所有輸入的加權總和，加上稱為「偏差」的值，然後透過所謂的「活化函數」饋送結果。權重和偏差一開始是未知的。這些權重會隨機初始化，並透過大量已知資料訓練類神經網路「學習」。

最常用的活化函式稱為 RELU，也就是線性整流函數。如上圖所示，這項函式非常簡單。

Softmax 啟用

上述網路以 5 個神經元的層級結尾，因為我們要將花朵分類為 5 個類別 (玫瑰、鬱金香、蒲公英、雛菊、向日葵)。中間層的神經元會使用經典的 RELU 啟動函式啟動。不過，在最後一層中，我們想計算介於 0 和 1 之間的數字，代表這朵花是玫瑰、鬱金香等的機率。為此，我們會使用名為「softmax」的啟動函式。

對向量套用 Softmax 時，會先計算每個元素的指數，然後將向量正規化，通常是使用 L1 範數 (絕對值總和)，使值加總為 1，並可解讀為機率。

為什麼「softmax」稱為 softmax？指數是急遽增加的函式。這會增加神經元輸出之間的差異。接著，當您將向量正規化時，主導常態的最大元素會正規化為接近 1 的值，而所有其他元素則會除以較大的值，並正規化為接近 0 的值。產生的向量會清楚顯示哪個是勝出類別 (即「max」)，但會保留值的原始相對順序，因此是「soft」。

交叉熵損失

現在類神經網路會根據輸入圖片產生預測結果，我們需要測量預測結果的準確度，也就是網路提供的結果與正確答案 (通常稱為「標籤」) 之間的距離。請注意，資料集中的所有圖片都有正確標籤。

任何距離都適用，但對於分類問題，所謂的「交叉熵距離」最有效。我們將此稱為誤差或「損失」函式：

「One-hot」編碼是指使用 5 個值的向量表示「3) 蒲公英」標籤，除了第 3 個值為 1 以外，其餘值皆為零。這個向量代表是蒲公英的機率為 100%。我們的類神經網路也會以 5 個機率值的向量輸出預測結果。方便比較。

梯度下降

「訓練」類神經網路實際上是指使用訓練圖片和標籤調整權重和偏誤，盡量減少交叉熵損失函式。運作方式如下：

交叉熵是權重、偏差、訓練圖片的像素及其已知類別的函式。

如果我們計算相對於所有權重和所有偏差的交叉熵偏導數，就會得到「梯度」，這是針對特定圖片、標籤，以及權重和偏差的現值計算而得。請注意，我們可能有數百萬個權重和偏差，因此計算梯度聽起來像是大量的工作。幸好，Tensorflow 會為我們執行這項作業。漸層的數學特性是「向上」指向。由於我們希望交叉熵較低，因此要朝相反方向移動。我們會根據梯度的一小部分更新權重和偏差值。接著，我們會在訓練迴圈中，使用下一批訓練圖片和標籤，重複執行相同的操作。希望這會收斂到交叉熵最小的地方，但無法保證這個最小值是唯一的。

「學習率」：您無法在每次疊代中，依據整個梯度長度更新權重和偏差值。這就像穿著七里靴試圖抵達谷底，您會從山谷的一側跳到另一側。如要到達底部，您必須採取較小的步驟，也就是只使用一小部分的漸層，通常在 1/1000 範圍內。這個分數稱為「學習率」。

小批次和動量

您可以在單一範例圖片上計算梯度，並立即更新權重和偏差，但如果對一批 (例如 128 張) 圖片執行這項操作，得出的梯度就能更準確地呈現不同範例圖片施加的限制，因此更有可能更快收斂至解決方案。迷你批次的大小是可調整的參數。

這項技術有時稱為「隨機梯度下降」，還有另一項更實用的優點：處理批次資料也表示要處理較大的矩陣，而這類矩陣通常更容易在 GPU 和 TPU 上進行最佳化。

不過，收斂過程可能還是有點混亂，如果梯度向量全為零，甚至可能會停止。這是否表示我們已找到最小值？不一定。梯度分量在最小值或最大值時可為零。如果梯度向量有數百萬個元素，且全為零，則每個零都對應到最小值，且沒有任何一個對應到最大值的機率相當小。在多維空間中，鞍點相當常見，我們不希望停留在鞍點。

插圖：鞍點。梯度為 0，但並非所有方向的最小值。(圖片出處： Wikimedia：作者 Nicoguaro - Own work，CC BY 3.0)

解決方法是為最佳化演算法增加一些動能，讓演算法能順利通過鞍點，不會停滯不前。

Tensorflow 程式庫提供各種最佳化工具，從 tf.train.GradientDescentOptimizer 開始。內建動能的進階熱門最佳化工具為 tf.train.RMSPropOptimizer 或 tf.train.AdamOptimizer。

詞彙

批次或迷你批次：訓練一律會對批次的訓練資料和標籤執行。這麼做有助於演算法收斂。「批次」維度通常是資料張量的第一個維度。舉例來說，形狀為 [100, 192, 192, 3] 的張量包含 100 張 192x192 像素的圖片，每個像素有三個值 (RGB)。

交叉熵損失：分類器常用的特殊損失函式。

密集層：神經元層，其中每個神經元都會連結至前一層的所有神經元。

特徵：神經網路的輸入內容有時稱為「特徵」。找出要將資料集中的哪些部分 (或部分組合) 輸入類神經網路，才能獲得準確預測結果，這門技術稱為「特徵工程」。

標籤：監督式分類問題中的「類別」或正確答案的別名

學習率：在訓練迴圈的每次疊代中，權重和偏差值更新的梯度比例。

logit：套用啟動函式前，神經元層的輸出內容稱為「logit」。這個詞彙源自「邏輯函數」，又稱「S 函數」，這是最常用的活化函數。「Neuron outputs before logistic function」縮短為「logits」。

損失：比較類神經網路輸出內容與正確答案的錯誤函式

神經元：計算輸入內容的加權總和、加入偏差，並透過啟動函式提供結果。

One-hot 編碼：5 個類別中的第 3 個類別會編碼為 5 個元素的向量，除了第 3 個元素是 1 以外，其餘都是零。

relu：線性整流函數。神經元的熱門啟動函式。

sigmoid：另一種曾廣受歡迎的啟動函式，在特殊情況下仍有用處。

softmax：一種特殊啟用函式，可作用於向量、增加最大分量與所有其他分量之間的差異，並將向量正規化為總和為 1，因此可解讀為機率向量。用做分類器的最後一個步驟。

張量：「張量」類似於矩陣，但維度數量任意。1 維張量是向量。2 維張量是矩陣。然後，您就可以使用 3、4、5 個以上的維度張量。

5. [INFO] 卷積類神經網路

簡介

如果下一段粗體字詞你都瞭解，即可進行下一個練習。如果您才剛開始接觸卷積類神經網路，請繼續閱讀。

插圖：使用兩個連續的濾鏡篩選圖片，每個濾鏡由 4x4x3=48 個可學習權重組成。

卷積類神經網路會對輸入圖片套用一系列可學習的濾鏡。卷積層是由濾鏡 (或核心) 大小、套用的濾鏡數量和步幅定義。卷積層的輸入和輸出都有三個維度 (寬度、高度、通道數)，從輸入圖片 (寬度、高度、RGB 通道) 開始。堆疊捲積層時，可以使用步幅 >1 或 max-pooling 運算，調整輸出內容的寬度和高度。使用更多或更少的篩選器，即可調整輸出內容的深度 (通道數)。

以下是 Keras 中簡易卷積類神經網路的樣貌：

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=3, filters=24, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=6, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

卷積類神經網路 101

在卷積網路的層中，一個「神經元」只會對上方一小塊圖像區域的像素進行加權總和。它會新增偏差值，並透過啟動函式饋送總和，就像一般密集層中的神經元一樣。然後使用相同權重，在整張圖片上重複執行這項作業。請注意，在密集層中，每個神經元都有自己的權重。在此，單一「權重修補程式」會以兩個方向滑過圖片 (即「捲積」)。輸出值數量與圖片中的像素數量相同 (但邊緣需要一些邊框間距)。這是篩選作業，使用 4x4x3=48 個權重的篩選器。

不過，48 個權重並不夠。如要增加自由度，請使用一組新的權重重複相同作業。系統會產生一組新的篩選器輸出內容。以輸入圖片中的 R、G、B 通道類比，我們將輸出內容稱為「通道」。

這兩組 (或更多組) 權重可以透過新增維度加總為一個張量。這會提供卷積層權重張量的通用形狀。由於輸入和輸出管道的數量是參數，我們可以開始堆疊和串連捲積層。

插圖：卷積類神經網路將資料「立方體」轉換為其他資料「立方體」。

步進卷積、最大池化

以 2 或 3 的步幅執行捲積時，我們也可以縮減結果資料方塊的水平維度。常見做法有兩種：

• 步進式捲積：滑動篩選器，但步進 >1
• 最大集區化：套用 MAX 作業的滑動視窗 (通常在 2x2 修補程式上，每 2 像素重複一次)

插圖：將運算視窗滑動 3 像素，輸出值就會減少。步幅式捲積或最大集區化 (在以步幅 2 滑動的 2x2 視窗上取最大值) 是縮減水平維度資料立方體的方法。

「最大池化」可協助我們直覺地瞭解卷積網路的運作方式：假設在訓練期間，權重的修補程式會演變成可辨識基本形狀 (水平和垂直線、曲線等) 的篩選器，那麼簡化實用資訊的方法之一，就是保留各層中辨識出形狀且強度最大的輸出內容。實務上，在最大集區層中，神經元輸出會以 2x2 的群組處理，且只會保留最大值。

Convolutional classifier

最後，我們將最後一個資料立方體攤平，並透過密集、softmax 啟用的層饋送，附加分類標題。典型的捲積分類器可能如下所示：

插圖：使用捲積和 Softmax 層的圖片分類器。它使用 3x3 和 1x1 濾鏡。maxpool 層會取 2x2 資料點群組的最大值。分類標頭是透過具有 softmax 啟動的密集層實作。

在 Keras 中

上述的捲積堆疊可以寫成 Keras 程式碼，如下所示：

model = tf.keras.Sequential([
  # input: images of size 192x192x3 pixels (the three stands for RGB channels)    
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu', input_shape=[192, 192, 3]),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=32, padding='same', activation='relu'),
  tf.keras.layers.MaxPooling2D(pool_size=2),
  tf.keras.layers.Conv2D(kernel_size=3, filters=16, padding='same', activation='relu'),
  tf.keras.layers.Conv2D(kernel_size=1, filters=8, padding='same', activation='relu'),
  tf.keras.layers.Flatten(),
  # classifying into 5 categories
  tf.keras.layers.Dense(5, activation='softmax')
])

model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy'])

卷積層的邊框間距參數可有兩個值：

• 「same」：以零填補，使輸出內容的寬度/高度與輸入內容相同
• 「valid」：無邊框間距，僅使用實際像素

6. [新資訊] 現代卷積架構

簡介

以「Inception」和「Inception v2」為首的現代捲積網路，通常會使用「模組」，在同一個輸入上同時嘗試不同的捲積層，將輸出內容串連起來，並透過訓練決定哪個層最實用。

插圖：卷積「模組」。此時最適合做什麼？max-pool 層，後面接著 1x1 捲積層，或是其他層的組合？請嘗試所有方法、串連結果，然後讓網路決定。右側：使用這類模組的「 inception」卷積架構。

在 Keras 中，如要建立資料流可分支進出的模型，必須使用「函式」模型樣式。範例如下：

l = tf.keras.layers # syntax shortcut

y = l.Conv2D(filters=32, kernel_size=3, padding='same',
             activation='relu', input_shape=[192, 192, 3])(x) # x=input image

# module start: branch out
y1 = l.Conv2D(filters=32, kernel_size=1, padding='same', activation='relu')(y)
y3 = l.Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(y)
y = l.concatenate([y1, y3]) # output now has 64 channels
# module end: concatenation

# many more layers ...

# Create the model by specifying the input and output tensors.
# Keras layers track their connections automatically so that's all that's needed.
z = l.Dense(5, activation='softmax')(y)
model = tf.keras.Model(x, z)

其他廉價手法

小型 3x3 濾鏡

這張插圖顯示兩個連續 3x3 濾鏡的結果。嘗試追蹤哪些資料點促成結果：這兩個連續的 3x3 篩選器會計算 5x5 區域的某種組合。這並非 5x5 篩選器會計算的完全相同組合，但值得嘗試，因為兩個連續的 3x3 篩選器比單一 5x5 篩選器便宜。

1x1 卷積 ?

以數學術語來說，「1x1」的捲積是乘以常數，並非很有用的概念。不過，在卷積神經網路中，請注意，篩選器會套用至資料立方體，而不只是 2D 圖片。因此，「1x1」篩選器會計算 1x1 資料欄的加權總和 (請參閱插圖)，並在您滑動資料時，取得輸入管道的線性組合。這其實很有用。如果將管道視為個別篩選作業的結果，例如「尖耳朵」的篩選器、「鬍鬚」的篩選器，以及「細縫眼睛」的篩選器，那麼「1x1」卷積層就會計算這些特徵的多種可能線性組合，這在尋找「貓」時可能很有用。此外，1x1 層使用的權重較少。

7. Squeezenet

「Squeezenet」論文中展示了如何簡單地將這些概念結合在一起。作者建議採用非常簡單的捲積模組設計，僅使用 1x1 和 3x3 捲積層。

插圖：以「fire 模組」為基礎的 SqueezeNet 架構。這些層會交替使用 1x1 層，先「擠壓」垂直維度中的輸入資料，再使用兩個平行的 1x1 和 3x3 卷積層，再次「擴展」資料深度。

實作

繼續使用先前的筆記本，並建構以 SqueezeNet 為靈感的卷積類神經網路。您必須將模型程式碼變更為 Keras「函式樣式」。

Keras_Flowers_TPU (playground).ipynb

其他資訊

請將這些訓練的 EPOCH 計數調高至 35。

定義 squeezenet 模組的輔助函式，對這項練習很有幫助：

def fire(x, squeeze, expand):
  y = l.Conv2D(filters=squeeze, kernel_size=1, padding='same', activation='relu')(x)
  y1 = l.Conv2D(filters=expand//2, kernel_size=1, padding='same', activation='relu')(y)
  y3 = l.Conv2D(filters=expand//2, kernel_size=3, padding='same', activation='relu')(y)
  return tf.keras.layers.concatenate([y1, y3])

# this is to make it behave similarly to other Keras layers
def fire_module(squeeze, expand):
  return lambda x: fire(x, squeeze, expand)

# usage:
x = l.Input(shape=[192, 192, 3])
y = fire_module(squeeze=24, expand=48)(x) # typically, squeeze is less than expand
y = fire_module(squeeze=32, expand=64)(y)
...
model = tf.keras.Model(x, y)

這次的目標是達到 80% 的準確度。

建議做法

先從單一卷積層開始，然後依序加入「fire_modules」，並與 MaxPooling2D(pool_size=2) 層交替。您可以在網路中實驗 2 到 4 個最大集區化層，也可以在最大集區化層之間實驗 1、2 或 3 個連續的 Fire 模組。

在 fire 模組中，「squeeze」參數通常應小於「expand」參數。這些參數實際上是篩選器的數量。通常介於 8 到 196 之間。您可以實驗架構，讓網路中的篩選器數量逐漸增加，也可以使用簡單的架構，讓所有 Fire 模組的篩選器數量相同。

範例如下：

x = tf.keras.layers.Input(shape=[*IMAGE_SIZE, 3]) # input is 192x192 pixels RGB

y = tf.keras.layers.Conv2D(kernel_size=3, filters=32, padding='same', activation='relu')(x)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.MaxPooling2D(pool_size=2)(y)
y = fire_module(24, 48)(y)
y = tf.keras.layers.GlobalAveragePooling2D()(y)
y = tf.keras.layers.Dense(5, activation='softmax')(y)

model = tf.keras.Model(x, y)

此時，您可能會發現實驗成效不佳，而且 80% 的準確度目標似乎遙不可及。現在要介紹幾個更簡單的技巧。

批次正規化

批次正規化有助於解決您遇到的收斂問題。我們會在下一個研討會中詳細說明這項技術，目前請先將其視為「神奇」的黑箱輔助工具，在網路中每個卷積層之後加入這行程式碼，包括 fire_module 函式內的層：

y = tf.keras.layers.BatchNormalization(momentum=0.9)(y)
# please adapt the input and output "y"s to whatever is appropriate in your context

由於資料集較小，動量參數必須從預設值 0.99 減少至 0.9。目前先不用理會這項細節。

資料擴增

透過簡單的轉換 (例如飽和度變化的左右翻轉) 擴增資料，即可獲得更多百分比點數：

在 TensorFlow 中，使用 tf.data.Dataset API 即可輕鬆完成這項作業。為資料定義新的轉換函式：

def data_augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_saturation(image, lower=0, upper=2)
    return image, label

然後在最終資料轉換中使用 (「訓練和驗證資料集」儲存格，函式「get_batched_dataset」)：

dataset = dataset.repeat() # existing line
# insert this
if augment_data:
  dataset = dataset.map(data_augment, num_parallel_calls=AUTO)
dataset = dataset.shuffle(2048) # existing line

請務必將資料擴增設為選用，並新增必要程式碼，確保只有訓練資料集會擴增。擴增驗證資料集沒有意義。

現在應該可以在 35 個訓練週期內達到 80% 的準確率。

解決方案

解決方案筆記本在此。如果遇到困難，可以參考這項工具。

Keras_Flowers_TPU_squeezenet.ipynb

涵蓋內容

• 🤔 Keras「函式樣式」模型
• 🤓 Squeezenet 架構
• 🤓 使用 tf.data.dataset 進行資料擴增

請花點時間在腦中瀏覽這份檢查清單。

8. 微調 Xception

可分離的捲積

最近，另一種實作卷積層的方式越來越受歡迎，那就是深度可分離卷積。我知道這很難記，但概念相當簡單。這些層級在 TensorFlow 和 Keras 中會實作為 tf.keras.layers.SeparableConv2D。

可分離卷積也會對圖片執行濾波器，但會為輸入圖片的每個管道使用不同的權重集。接著是「1x1 捲積」，也就是一系列的點積，可得出經過濾通道的加權總和。每次都會使用新的權重，並視需要計算多個管道的加權重組。

插圖：可分離的捲積。第 1 階段：對每個聲道使用個別的濾鏡進行捲積。第 2 階段：管道的線性重組。使用一組新的權重重複上述步驟，直到達到所需的輸出通道數。階段 1 也可以重複執行，每次都使用新的權重，但實際上很少這麼做。

在最新的卷積網路架構中，大多會使用可分離的卷積，例如 MobileNetV2、Xception 和 EfficientNet。順帶一提，MobileNetV2 是您先前用於遷移學習的項目。

這類卷積比一般卷積便宜，且實務上效果相同。以下是上述範例的權重計數：

卷積層：4 x 4 x 3 x 5 = 240

可分離卷積層：4 x 4 x 3 + 3 x 5 = 48 + 15 = 63

讀者可自行練習，以類似方式計算套用每種風格的捲積層級時所需的乘法次數。可分離式捲積較小，運算效率也高得多。

實作

從「遷移學習」Playground 筆記本重新開始，但這次請選取 Xception 做為預先訓練模型。Xception 只使用可分離的捲積。讓所有權重都能訓練。我們會根據資料微調預先訓練的權重，而不是直接使用預先訓練的層。

Keras Flowers transfer learning (playground).ipynb

目標：準確度高於 95% (真的可以做到！)

這是最後一個練習，因此需要更多程式碼和資料科學工作。

微調的其他資訊

tf.keras.application.* 中的標準預先訓練模型提供 Xception，請勿忘記這次要將所有權重設為可訓練。

pretrained_model = tf.keras.applications.Xception(input_shape=[*IMAGE_SIZE, 3],
                                                  include_top=False)
pretrained_model.trainable = True

如要微調模型並獲得良好結果，請注意學習率，並使用含有升溫期的學習率排程。如下所示：

如果從標準學習率開始，會中斷模型的預先訓練權重。逐步啟動可保留這些資料，直到模型鎖定資料並以合理方式修改為止。斜坡期過後，您可以繼續使用常數或指數衰減的學習率。

在 Keras 中，學習率是透過回呼指定，您可以在其中計算每個訓練週期的適當學習率。Keras 會在每個訓練週期將正確的學習率傳遞至最佳化工具。

def lr_fn(epoch):
  lr = ...
  return lr

lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_fn, verbose=True)

model.fit(..., callbacks=[lr_callback])

解決方案

解決方案筆記本在此。如果遇到困難，可以參考這項工具。

07_Keras_Flowers_TPU_xception_fine_tuned_best.ipynb

涵蓋內容

• 🤔 深度可分離卷積
• 🤓 學習率時間表
• 😈 微調預先訓練模型。

請花點時間在腦中瀏覽這份檢查清單。

9. 恭喜！

您已建構第一個現代卷積類神經網路，並透過 TPU 在短短幾分鐘內完成連續訓練，將準確率提升至 90% 以上。這就是 4 堂「Keras on TPU Codelab」的內容：

• TPU 高速資料管道：tf.data.Dataset 和 TFRecords
• 第一個 Keras 模型，採用遷移學習
• 使用 Keras 和 TPU 建構卷積類神經網路
• [本實驗室] 搭配使用 Keras 和 TPU，翻新 convnet、squeezenet 和 Xception 模型

TPU 實務

TPU 和 GPU 可在 Cloud AI Platform 上使用：

• 在 Deep Learning VM 上
• 在 AI 平台筆記本中
• 在 AI Platform Training 工作中

最後，我們非常重視意見回饋。如果您在本實驗室中發現任何錯誤，或認為有需要改進之處，請告訴我們。你可以透過 GitHub 問題 [意見回饋連結] 提供意見。

作者：Martin Görner Twitter：@martin_gorner

www.tensorflow.org