在 TPU 上使用 Keras 和新型收斂公司

在 TPU 上使用 Keras 和新型收斂公司

程式碼研究室簡介

上次更新時間：10月 2, 2021

作者：Martin Görner - @martin_gorner

1. 總覽

在本研究室中，您將瞭解如何使用 Keras 和 Tensorflow 2，從頭開始建構、訓練及調整捲積類神經網路。現在只要使用 TPU 的強大功能，就能在幾分鐘內完成這項作業。您也將探索多種做法，包括非常簡單的遷移學習，以及 Squeezenet 等現代卷積架構。本研究室提供類神經網路的理論解釋，是開發人員學習深度學習的絕佳起點。

閱讀深度學習論文可能並不容易，令人困惑。讓我們實際瞭解現代卷積類神經網路架構。

課程內容

• 能使用 Keras 和 Tensor Processing Unit (TPU) 加快自訂模型建構速度。
• 使用 tf.data.Dataset API 和 TFRecord 格式，有效率地載入訓練資料。
• 要趕上 😈?，請採用遷移學習技術，不要自行建構模型。
• 使用 Keras 依序和函式模型樣式。
• 使用 softmax 層和交叉熵損失建立自己的 Keras 分類器。
• 使用選擇喜歡的捲積層來微調模型。
• 探索現代化對話網架構構想，例如模組、全球平均集區等。
• 為了使用 Squeezenet 架構建構簡易的新型 convnet。

意見回饋

如果您在這個程式碼研究室中發現不尋常的狀況，請告訴我們。您可以透過 GitHub 問題提供意見 [feedback link]。

2. Google Colaboratory 快速入門

本研究室使用 Google 協作工具，因此您不需要進行任何設定。你可以透過 Chromebook 執行。請開啟下方檔案並執行儲存格，熟悉 Colab 筆記本。

Welcome to Colab.ipynb

選取 TPU 後端

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

執行筆記本

按一下儲存格並使用 Shift + Enter 鍵，即可逐一執行儲存格。您也可以透過「執行階段 >」全部執行

Table of contents

所有筆記本都有目錄。您可以使用左側的黑色箭頭開啟報表。

隱藏的儲存格

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

驗證

Colab 有機會存取您的私人 Google Cloud Storage 值區，但您必須使用已授權的帳戶進行驗證。上方的程式碼片段會觸發驗證程序。

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。

切割陣列

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 約有 4,000 個核心。另一方面，TPU 在 MXU 中運算單元使用的硬體最低只有 bfloat16 x bfloat16 => float32，只有 bfloat16 x bfloat16 => float32 乘積才會達到此值。這些都太小，TPU 可以在 128x128 MXU 中實作 16K 的容器，並一次處理這個矩陣乘法。

插圖：MXU 收縮壓陣列，運算元素為乘數。其中一個矩陣的值會載入至陣列 (紅點)。其他矩陣的值流經陣列 (灰點)。垂直線會將值向上傳播。水平線會傳播部分總和。這之後是使用者的練習，用來驗證資料通過陣列時，你得到的矩陣乘積結果來自右側。

此外，雖然內積是以 MXU 計算中度積，但在相鄰的運算單元之間，中繼總和其實只會流動。不需要儲存和擷取記憶體，甚至是註冊檔案。最終結果是 TPU 脈動陣列架構在計算矩陣乘法時，具有顯著密度和效能優勢；此外，在計算矩陣乘法時，TPU 的速度優勢也不是無法忽略。

Cloud TPU

如果您要求一個「Cloud TPU v2使用 Google Cloud Platform 時，您會得到一個具備 PCI 連接 TPU 電路板的虛擬機器 (VM)。TPU 電路板有四個雙核心 TPU 晶片。每個 TPU 核心都有一個 VPU (向量處理器) 和 128x128 MXU (MatriX 乘數)。此「Cloud TPU」接著，通常會透過網路連線至發出該執行個體的 VM整體畫面看起來會像這樣：

插圖：您的 VM 附加了網路連接的「Cloud TPU」加速器。「Cloud TPU」這個 VM 本身就是 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 核心之間交換梯度 ( 這是所有原因的詳細說明)。受訓練的模型可利用大型批量進行訓練，以充分運用硬體。

圖解：在 Google TPU 的 2-D 環面網狀 HPC 網路使用 all-red 演算法，在訓練期間同步處理梯度。

軟體

大型批量訓練

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 平台工作、Colaboratory、Kubeflow、透過「ctpu up」公用程式建立的深度學習 VM) 中運作，完全不需要參數。這些系統知道 TPU_NAME 環境變數的 TPU 位置。如要手動建立 TPU，請設定 TPU_NAME 環境。var 的變數數量。並在所用 VM 上執行，或是使用明確參數呼叫 TPUClusterResolver：TPUClusterResolver(tp_uname, zone, project)
• TPUStrategy 是實作發行方式的部分，並用「all-reduce」梯度同步處理演算法
• 系統是透過範圍套用策略。模型必須在策略 scope() 內定義。
• tpu_model.fit 函式預期輸入用於 TPU 訓練的 tf.data.Dataset 物件。

常見 TPU 移植工作

• 在 TensorFlow 模型中載入資料的方法很多，但如果是 TPU，則必須使用 tf.data.Dataset API。
• TPU 速度飛快，且執行時擷取資料經常成為瓶頸。請參閱 TPU 效能指南，瞭解您可以使用哪些工具偵測資料瓶頸和其他效能提示。
• 系統會將 int8 或 int16 號碼視為 int32。TPU 不提供小於 32 位元的整數硬體運作。
• 不支援部分 Tensorflow 作業。查看清單。好消息是，這項限制僅適用於訓練程式碼，也就是前後通過模型的程式碼。您仍可在資料輸入管道中使用所有 TensorFlow 作業，因為 TensorFlow 將在 CPU 上執行。
• TPU 不支援 tf.py_func。

4. 正在載入資料

我們會使用花朵圖片資料集。目的是學習把它們分為 5 種花朵類型。資料載入作業是使用 tf.data.Dataset API 執行。首先，讓我們瞭解這個 API。

實作

請開啟下列筆記本，執行儲存格 (Shift-ENTER)，然後按照指示操作，即可看到「已完成工作」標籤。

Fun with tf.data.Dataset (playground).ipynb

其他資訊

關於「花」資料集

資料集儲存在 5 個資料夾中。每個資料夾都包含一種種類的花。資料夾的名稱為「向日葵」、「雛菊」、「蒲公英」、「鬱金香」和「玫瑰」。這些資料託管於 Google Cloud Storage 的公開值區。摘錄：

gs://flowers-public/sunflowers/5139971615_434ff8ed8b_n.jpg
gs://flowers-public/daisy/8094774544_35465c1c64.jpg
gs://flowers-public/sunflowers/9309473873_9d62b9082e.jpg
gs://flowers-public/dandelion/19551343954_83bb52f310_m.jpg
gs://flowers-public/dandelion/14199664556_188b37e51e.jpg
gs://flowers-public/tulips/4290566894_c7f061583d_m.jpg
gs://flowers-public/roses/3065719996_c16ecd5551.jpg
gs://flowers-public/dandelion/8168031302_6e36f39d87.jpg
gs://flowers-public/sunflowers/9564240106_0577e919da_n.jpg
gs://flowers-public/daisy/14167543177_cd36b54ac6_n.jpg

為什麼要使用 tf.data.Dataset？

Keras 和 Tensorflow 接受所有訓練和評估函式中的資料集。將資料載入資料集後，API 就會提供所有對類神經網路訓練資料有用的通用功能：

dataset = ... # load something (see below)
dataset = dataset.shuffle(1000) # shuffle the dataset with a buffer of 1000
dataset = dataset.cache() # cache the dataset in RAM or on disk
dataset = dataset.repeat() # repeat the dataset indefinitely
dataset = dataset.batch(128) # batch data elements together in batches of 128
AUTOTUNE = tf.data.AUTOTUNE
dataset = dataset.prefetch(AUTOTUNE) # prefetch next batch(es) while training

如要瞭解效能提示和資料集最佳做法，請參閱這篇文章。如需參考文件，請按這裡。

tf.data.Dataset 基本概念

資料通常會以多個檔案，在這裡的圖片。您可以呼叫下列指令來建立檔案名稱的資料集：

filenames_dataset = tf.data.Dataset.list_files('gs://flowers-public/*/*.jpg')
# The parameter is a "glob" pattern that supports the * and ? wildcards.

然後「繪製」一個函式對每個檔案名稱建立一個函式，通常會將檔案載入並解碼為實際記憶體內的實際資料：

def decode_jpeg(filename):
  bits = tf.io.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  return image

image_dataset = filenames_dataset.map(decode_jpeg)
# this is now a dataset of decoded images (uint8 RGB format)

如要對資料集進行疊代作業：

for data in my_dataset:
  print(data)

元組資料集

在監督式學習中，訓練資料集通常是以成對的訓練資料與正確答案組成。為此，解碼函式可能會傳回元組。如此一來，當您對其進行疊代時，就會傳回包含元組和元組的資料集。傳回的值就是 Tensorflow Tensor，可供模型使用。您可以對其呼叫 .numpy() 查看原始值：

def decode_jpeg_and_label(filename):
  bits = tf.read_file(filename)
  image = tf.io.decode_jpeg(bits)
  label = ... # extract flower name from folder name
  return image, label

image_dataset = filenames_dataset.map(decode_jpeg_and_label)
# this is now a dataset of (image, label) pairs 

for image, label in dataset:
  print(image.numpy().shape, label.numpy())

結論：逐一載入圖片的速度很慢！

疊代這個資料集時，您會發現每秒可以載入 1 到 2 張圖片。太慢了！我們用於訓練的硬體加速器可以維持這個速率，可以維持好幾次。請參閱下一節，瞭解我們如何達成此目標。

解決方案

以下是解決方案筆記本。如果遇到問題，可以使用此功能。

Fun with tf.data.Dataset (solution).ipynb

涵蓋內容

• 🤔? tf.data.Dataset.list_files
• 🤔? tf.data.Dataset.map
• 🤔? 元組的資料集
• 😀? 反覆查詢不同資料集

請花點時間研讀這份檢查清單，

5. 快速載入資料

本研究室使用的 Tensor Processing Unit (TPU) 硬體加速器非常快速。資料提供的速度要夠快，才能保持繁忙度，是該公司的一大挑戰。Google Cloud Storage (GCS) 能夠提供極高的處理量，但如同所有雲端儲存空間系統，啟動連線需要一些網路往返費用。因此，將資料儲存為數千個個別檔案並不理想。我們將在較少的檔案中批次處理這些檔案，並使用 tf.data.Dataset 功能，平行讀取多個檔案。

詳閱

以下筆記本會載入圖片檔、將其調整為常見大小，然後儲存至 16 個 TFRecord 檔案，程式碼位於下列筆記本中。請盡速閱讀。因此不需要執行，因為本程式碼研究室的其他部分將會提供正確的 TFRecord 格式資料。

Flower pictures to TFRecords.ipynb

最適合 GCS 處理量的理想資料版面配置

基本原則是將資料分割成數個 (10 到 100 秒) 看起來很差的檔案 (10 到 100 MB)。如果您擁有太多檔案，或許會因為檔案數量增加而難以存取每個檔案。如果檔案太少 (例如一到兩個檔案)，就無法同時透過多個檔案進行串流。

TFRecord 檔案格式

Tensorflow 偏好的資料檔案格式是以 protobuf 為基礎的 TFRecord 格式。其他序列化格式也適用，但您可以編寫下列程式碼，直接從 TFRecord 檔案載入資料集：

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

為獲得最佳效能，建議您使用下列較複雜的程式碼一次讀取多個 TFRecord 檔案。這個程式碼會並行讀取 N 個檔案，並優先忽略資料順序，以提供讀取速度。

AUTOTUNE = tf.data.AUTOTUNE
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False

filenames = tf.io.gfile.glob(FILENAME_PATTERN)
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(...) # do the TFRecord decoding here - see below

TFRecord 一覽表

可將三種類型的資料儲存在 TFRecords 中：位元組字串 (位元組清單)、64 位元整數和 32 位元浮點。這些資料一律會儲存為清單，單一資料元素清單的大小為 1。您可以使用下列輔助函式將資料儲存至 TFRecords。

寫入位元組字串

# warning, the input is a list of byte strings, which are themselves lists of bytes
def _bytestring_feature(list_of_bytestrings):
  return tf.train.Feature(bytes_list=tf.train.BytesList(value=list_of_bytestrings))

寫入整數

def _int_feature(list_of_ints): # int64
  return tf.train.Feature(int64_list=tf.train.Int64List(value=list_of_ints))

寫入浮點數

def _float_feature(list_of_floats): # float32
  return tf.train.Feature(float_list=tf.train.FloatList(value=list_of_floats))

編寫 TFRecord，使用上述輔助程式

# input data in my_img_bytes, my_class, my_height, my_width, my_floats
with tf.python_io.TFRecordWriter(filename) as out_file:
  feature = {
    "image": _bytestring_feature([my_img_bytes]), # one image in the list
    "class": _int_feature([my_class]),            # one class in the list
    "size": _int_feature([my_height, my_width]),  # fixed length (2) list of ints
    "float_data": _float_feature(my_floats)       # variable length  list of floats
  }
  tf_record = tf.train.Example(features=tf.train.Features(feature=feature))
  out_file.write(tf_record.SerializeToString())

如要從 TFRecord 讀取資料，您必須先宣告已儲存記錄的版面配置。在宣告中，您可以透過固定長度清單或變數長度清單存取任何已命名欄位：

從 TFRecords 讀取

def read_tfrecord(data):
  features = {
    # tf.string = byte string (not text string)
    "image": tf.io.FixedLenFeature([], tf.string), # shape [] means scalar, here, a single byte string
    "class": tf.io.FixedLenFeature([], tf.int64),  # shape [] means scalar, i.e. a single item
    "size": tf.io.FixedLenFeature([2], tf.int64),  # two integers
    "float_data": tf.io.VarLenFeature(tf.float32)  # a variable number of floats
  }

  # decode the TFRecord
  tf_record = tf.io.parse_single_example(data, features)

  # FixedLenFeature fields are now ready to use
  sz = tf_record['size']

  # Typical code for decoding compressed images
  image = tf.io.decode_jpeg(tf_record['image'], channels=3)

  # VarLenFeature fields require additional sparse.to_dense decoding
  float_data = tf.sparse.to_dense(tf_record['float_data'])

  return image, sz, float_data

# decoding a tf.data.TFRecordDataset
dataset = dataset.map(read_tfrecord)
# now a dataset of triplets (image, sz, float_data)

實用的程式碼片段：

讀取單一資料元素

tf.io.FixedLenFeature([], tf.string)   # for one byte string
tf.io.FixedLenFeature([], tf.int64)    # for one int
tf.io.FixedLenFeature([], tf.float32)  # for one float

讀取固定大小的元素清單

tf.io.FixedLenFeature([N], tf.string)   # list of N byte strings
tf.io.FixedLenFeature([N], tf.int64)    # list of N ints
tf.io.FixedLenFeature([N], tf.float32)  # list of N floats

讀取不同數量的資料項目

tf.io.VarLenFeature(tf.string)   # list of byte strings
tf.io.VarLenFeature(tf.int64)    # list of ints
tf.io.VarLenFeature(tf.float32)  # list of floats

VarLenFeature 會傳回稀疏向量，解碼 TFRecord 後需要執行其他步驟：

dense_data = tf.sparse.to_dense(tf_record['my_var_len_feature'])

您也可以在 TFRecords 中提供選用欄位。如果您在讀取欄位時指定預設值，那麼如果缺少該欄位，則會傳回預設值，而不是錯誤。

tf.io.FixedLenFeature([], tf.int64, default_value=0) # this field is optional

涵蓋內容

• 🤔? 分割資料檔案以便快速存取 GCS
• 😓? 如何編寫 TFRecords。(您忘記語法了嗎？沒關係，您可以將這個網頁加入書籤，做為一覽表)
• 🤔? 使用 TFRecordDataset 從 TFRecord 載入資料集

請花點時間研讀這份檢查清單，

6. [資訊] 類神經網路分類器 101

概述

如果您知道下個段落中的所有以粗體顯示的字詞，則可進行下一個練習。如果您剛開始學習深度學習，歡迎繼續閱讀。

類神經網路分類器是由多個「神經元」層組成。對於圖片分類，可以是「密集」或「卷積」層。通常啟用 relu 啟動函式即可啟用。最後一層會使用多少類別神經元，並透過 softmax 啟用。以分類作業來說，cross-entropy 是最常用的 loss 函式，將 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 值壓平成長向量，並將其做為輸入內容，提供給此類網路使用。這不是圖片辨識的最佳技術，但我們稍後會加以改進。

Neuron、啟動、RELU

「神經元」計算所有輸入內容的加權總和，然後加上名為「偏誤」的值並透過名為「啟用函式」將結果傳送給我們一開始不知道權重和偏誤。模擬程序將隨機進行，「學習」，運用大量已知資料訓練類神經網路

最常見的活化函數稱為 RELU，用於直線式線性單位。如上圖所示，這是非常簡單的函式。

啟用 Softmax

由於我們將花分為 5 種類別 (玫瑰、鬱金香、蒲公英、雛菊、向日葵)，上方的網路以 5 個神經元層為結尾。而中間層中的神經元是透過傳統版 RELU 活化函式啟用。但在上一層中，我們想要計算 0 到 1 之間的數字，代表這朵花成為玫瑰、鬱金香等的可能性。我們會使用名為「softmax」的活化函式。

在向量上套用 softmax 時，系統會採用每個元素的指數，然後對向量進行正規化，一般會使用 L1 常式 (絕對值總和)，讓各個值加總為 1，並解讀為機率。

為什麼是「softmax」叫做 softmax指數是急遽增加的函數。這會增加神經元輸出內容之間的差異。接著將向量正規化時，佔據常態的最大元素，會正規化為接近 1 的值，而所有其他元素則除以一個大值，然後一體成接近 0 的值。產生的向量清楚顯示勝出的類別「最大值」，但保留值的原始相對順序，因此構成「軟」。

交叉熵損失

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

任何距離都可行，但就分類問題而言，我們稱為「交叉熵距離」是最有效的做法。我們將此錯誤稱為「損失」函式：

「One-hot」編碼代表您代表「3) dandelion」標籤。這個向量代表 100% 成為蒲公英的機率。我們的類神經網路也會將其預測輸出為 5 個機率值的向量。這些模型很容易進行比較。

漸層下降

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

交叉熵是指權重、偏誤、訓練圖片像素及其已知類別的功能。

如果我們針對所有權重和所有偏誤，計算出交叉熵的部分導數，就會取得「梯度」，根據指定圖片、標籤以及權重和偏誤的現值計算。請記住，我們可以擁有數百萬個權重和偏誤，因此計算梯度聽起來好像是許多工作。幸好，Tensorflow 幫我們辦到。漸層的數學特性是指向「上方」。由於我們要前往十字區的低點，所以方向是相反的。我們會更新部分漸層的權重和偏誤。接著，我們會在訓練迴圈中使用下一批的訓練圖片和標籤，再次執行相同的操作。希望這個例子能創造出交叉熵，但不保證這個下限不會重複。

「學習率」：您無法在每次疊代時按照漸層的完整長度更新權重和偏誤。可以想著穿著七個聯賽的靴子，想一路探究山谷底部系統會從山谷的其中一側跳到另一側。如要到達底部，您需要採取較小的步驟，例如只使用漸層的一小部分 (通常位於第 1/1000 的範圍中)。這個分數稱為「學習率」。

微批次和發展動能

您可以只用一張範例圖片計算漸層，並立即更新權重和偏誤，但以批次方式進行，例如，128 張圖片能夠產生較理想的漸層，更能充分代表不同範例圖片所施加的限制，因此可能更快地聚集在解決方案中。迷你批次的大小是可調整的參數，

這項技巧有時也稱為「隨機梯度下降」還有另一項更實用的優點：處理批次也意味著處理更大型的矩陣，且這些運算通常較容易在 GPU 和 TPU 上最佳化。

然而，收斂法還是有點混亂，而且即使漸層向量全為零，甚至會停止。這代表我們已經找到最低限度了？不一定。漸層元件可以是最小值或最大值。如果某個漸層向量有數百萬個元素，但全都是零，則每個零對應最小，且都不對應到最大點的機率極小。而且在許多維度的空間中很常見，我們不想停下來。

插圖：馬鞍縫。漸層為 0，但並非在所有方向的最小值。(圖片出處 Wikimedia: by Nicoguaro - Own Work, CC BY 3.0)

解決方法是為最佳化演算法增加成長動能，讓演算法能在不停歇的加速點前進。

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

詞彙

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

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

稠密層：神經元層，每個神經元都會連接至上一層的所有神經元。

features (特徵)：類神經網路的輸入內容有時也稱為「特徵」。要準確判斷資料集的哪些部分 (或零件組合) 並提供給類神經網路以獲得準確的預測結果，就稱為「特徵工程」。

labels：「類別」的另一個名稱或是更正監督式分類問題的答案

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

logits：套用活化函式前一層神經元層的輸出內容稱為「logits」。字詞取自「邏輯函式」a.k.a.「sigmoid 函式」這個模型過去是最常使用的活化函數，「Logistic 函式前方的遠端輸出」已縮短為「logits」。

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

neuron：計算輸入內容的加權總和、加上偏誤，並透過活化函式提供結果。

one-hot 編碼：類別 3 之 3 會編碼為 5 個元素的向量，除了第三個 1 之外，其他所有零。

relu：固定線性單元。神經元經常使用的活化函數。

sigmoid：過去廣受歡迎的活化函數，在特殊情況下仍可派上用場。

softmax：一種特殊的活化函數，用於向量、增加最大元件與所有其他元件之間的差異，並將向量正規化為 1 的總和，讓該向量被解為機率向量。做為分類器中的最後一個步驟。

tensor：Tensor就像矩陣，不過可以任意數量的維度1 維張量是一種向量。2 維度張量就是矩陣。接著，就能使用有 3、4、5 或更多維度的張量。

7. 遷移學習

如果是圖片分類問題，密集圖層可能還不夠。我們必須瞭解卷積層，以及它們的多種排列方式。

但我們也提供捷徑！有經過完整訓練的捲積類神經網路可供下載。可以切斷最後一個層 (softmax 分類頭) 再自行取代。所有經過訓練的權重和偏誤都會維持不變，您只需重新訓練新增的 softmax 圖層。這種技術稱為「遷移學習」，但只要用在類神經網路經過預先訓練的資料集「夠近」的程度，這項技術就能發揮效用。自訂提示。

實作

請開啟下列筆記本，執行儲存格 (Shift-ENTER)，然後按照指示操作，即可看到「已完成工作」標籤。

Keras Flowers transfer learning (playground).ipynb

其他資訊

有了遷移學習，您就能受益於頂尖研究人員所開發的進階卷積類神經網路架構，以及預先訓練大量圖像資料集。在這個案例中，我們要從在 ImageNet 上訓練的網路中遷移學習過程。ImageNet 是一種圖片資料庫，內含許多植物和室外場景的圖片，而這些圖像幾乎可以滿足花朵的需求。

插圖：以黑色方塊的形式訓練複雜的捲積類神經網路，只重新訓練分類頭部。這就是遷移學習。我們稍後會見證卷積層的複雜排列方式。目前這是其他人的問題。

在 Keras 中遷移學習

在 Keras 中，您可以從 tf.keras.applications.* 集合將預先訓練模型執行個體化。舉例來說，MobileNet V2 就是一個很好的捲積架構，在大小合理範圍內。選取 include_top=False 後，您就能取得不含最終 softmax 層的預先訓練模型，以便新增自己的模型：

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

model = tf.keras.Sequential([
    pretrained_model,
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(5, activation='softmax')
])

另請注意 pretrained_model.trainable = False 設定。會凍結預先訓練模型的權重和偏誤，因此您只能訓練 softmax 層。這類程序通常包含相對較少的權重，因此可快速完成，且不需要使用非常龐大的資料集。不過，如果您擁有大量資料，搭配 pretrained_model.trainable = True 使用遷移學習的效果會更好。預先訓練的權重然後提供絕佳的初始值，而且也可以透過訓練進行調整，讓模型更準確地反映您的問題。

最後，請注意在稠密 softmax 層之前插入的 Flatten() 層。密集圖層適用於平面資料向量，但我們不知道預先訓練模型傳回的內容為何。這就是為什麼需要簡化。下一章我們將深入探討卷積架構，其中會說明卷積層傳回的資料格式。

採用這種做法可將準確率提高近 75%。

解決方案

以下是解決方案筆記本。如果遇到問題，可以使用此功能。

Keras Flowers transfer learning (solution).ipynb

涵蓋內容

• 🤔? 如何在 Keras 中編寫分類器
• 🤓? 上設定了「softmax」最後一層，且有交叉熵損失
• 😈? 遷移學習
• 🤔? 訓練第一個模型
• 🧐? 瞭解訓練期間的損失和準確率

請花點時間研讀這份檢查清單，

8. [資訊] 卷積類神經網路

概述

如果您知道下個段落中的所有以粗體顯示的字詞，則可進行下一個練習。如果您剛開始使用卷積類神經網路，請繼續閱讀下文。

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

卷積類神經網路會對輸入圖片套用一系列可學習的篩選器。卷積層由「篩選器 (或核心) 大小」、套用的「篩選器數量」和「步距」定義。卷積層的輸入內容和輸出內容有三種尺寸 (寬度、高度、聲道數)，從輸入的圖片 (寬度、高度、RGB 管道) 開始。堆疊卷積層時，可使用步距 >1 或 max-pooling 運算調整輸出的寬度和高度。輸出內容的深度 (Nb 頻道) 會因使用更多或更少篩選條件而調整。

以下是簡易卷積類神經網路在 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'])

卷積神經網路基本知識

在卷積網路層中，一個「神經元」計算圖片上方小區域的像素加權總和。它會增加偏誤並透過活化函數提供總和，就像一般密集層中的神經元一樣。接著，系統會為整張圖片，以相同的權重重複執行這項作業。請記住，在稠密層中，每個神經元都有各自的權重。在這個例子中，的權重滑過圖片中左右兩側 (「卷積」)。輸出內容的值與圖片中的像素數量一樣多 (但邊緣需要一些邊框間距)。本身是篩選作業，使用 4x4x3=48 權重的篩選器。

但是 48 個權重是不夠的。為了增加更多的自由度，我們以一組新的權重重複同一項作業。這會產生一組新的篩選器輸出內容。命名為「channel」輸出圖片中的 R、G、B 管道表示輸出內容。

透過新增維度，即可將兩組或更多的權重加總為一個張量。這就是卷積層的權重張量的一般形狀。由於輸入和輸出通道的數量是參數，因此我們可以開始堆疊及鏈結卷積層。

插圖：卷積類神經網路改變了「方塊」將資料匯出至其他「立方體」資料安全

碰撞卷積，最大集區

透過 2 或 3 序列執行卷積，我們也可縮小產生的資料方塊水平維度。有兩種常見方式：

• 網格卷積：相同滑步濾鏡，但步長大於 1
• 最大集區：套用 MAX 運算的滑動窗口 (通常在 2x2 修補程式中，每 2 個像素重複一次)

插圖：將運算視窗滑動 3 像素，輸出值就會較少。傾斜的捲積或最大集區 (最長可滑動 2 點的 2x2 視窗範圍) 可縮小水平維度的資料方塊。

「最大集區」可幫助我們以直覺化的方式瞭解卷積網路的運作原理：假設您認為在訓練期間，權重修補程式會轉變為可辨識基本形狀 (水平和垂直線、曲線等等) 的濾鏡，然後形成有用資訊的其中一種方式，就是在辨識出最大強度的輸出的各層中。實際上，在最大集區層神經元輸出內容中，神經元輸出內容會以 2x2 為一組進行處理，而且只會保留最大值。

卷積分類器

最後，我們會簡化最後一個資料立方體，並透過稠密的 softmax-activated 層提供資料，以附加分類頭。卷積分類器通常如下所示：

插圖：使用卷積層和 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"：以 0 填充零，以便產生與輸入內容相同的寬度/高度輸出內容
• 「valid」：無邊框間距，只能使用真實的像素

9. 您的自訂轉換

實作

讓我們從頭開始建構並訓練卷積類神經網路。使用 TPU 可讓我們非常快速地疊代。請開啟下列筆記本，執行儲存格 (Shift-ENTER)，然後按照指示操作，即可看到「已完成工作」標籤。

Keras_Flowers_TPU (playground).ipynb

目標是突破遷移學習模型 75% 的準確率。該模型的優勢在於，他們使用數百萬張圖片的資料集預先進行訓練，而這裡只有 3670 張圖片。你能不能至少達到這個水準？

其他資訊

有多少層？有多少層？

選擇圖層大小不只是科學而已，必須在參數過少與過多 (權重和偏誤) 之間取得平衡。如果權重太少，類神經網路就無法呈現花形的複雜度。如果素材資源過多，可能會發生「過度配適」的情形，例如專門用培訓圖片，也無法一般化。參數數量過多時，模型的訓練速度也會變慢。在 Keras 中，model.summary() 函式會顯示模型的結構和參數數量：

Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 192, 192, 16)      448       
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 192, 192, 30)      4350      
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 96, 96, 30)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 96, 96, 60)        16260     
_________________________________________________________________
 ... 
_________________________________________________________________
global_average_pooling2d (Gl (None, 130)               0         
_________________________________________________________________
dense (Dense)                (None, 90)                11790     
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 455       
=================================================================
Total params: 300,033
Trainable params: 300,033
Non-trainable params: 0
_________________________________________________________________

以下提供幾個訣竅：

• 擁有多個圖層的好處是「深度」有效的類神經網路以這個簡單的花朵辨識問題來說，5 到 10 層應該很合理。
• 使用小型篩選器。一般而言，3x3 篩選器適用於任何地方。
• 您也可以使用 1x1 篩選器，而且價格較低。實際上不會「過濾」而是會計算管道的線性組合並使用真實濾鏡。(詳情請參閱下一節的「1x1 卷積」)。
• 如果是像這樣的分類問題，請經常使用最大集區層 (或步長 >1 的捲積) 進行向下取樣。您不需要在乎花朵在哪裡，只要是玫瑰花或黃銅，就不重要，因此減少 x 和 y 資訊不重要，而篩選較小區域的費用也比較低。
• 篩選器數量通常會與聯播網結尾的類別數量類似 (為什麼？請參閱下方的「全球平均集區」技巧)。如果分類為數百個類別，請在連續圖層中逐步提高篩選器數量。若為含有 5 個類別的花卉資料集，只使用 5 個篩選器是不夠的。您可以在多數圖層中使用相同的篩選器數量，例如 32 個，並減少至末端。
• 最終稠密層的成本是/昂貴。其權重可能比所有捲積層的總和還多。舉例來說，即使在最後一個資料立方體為 24x24x10 的資料點中，輸出的結果相當合理，100 個神經元稠密層還是會產生 24x24x10x100=576,000 權重 !!!！請謹慎思考，或嘗試全球平均集區 (請見下方說明)。

全球平均集區

比起在卷積類神經網路的結尾，使用昂貴的密集層，您可將傳入的資料「立方」分割為分類到所有類別，然後平均計算其值，再透過 softmax 啟動函式將這些片段提供給這些部分。這種建構分類成本的方法可花費 0 個權重。在 Keras 中，語法為 tf.keras.layers.GlobalAveragePooling2D().

卷積類神經網路會偵測物體的位置。篩選器對某些功能做出強烈回應時，它會在特定 x,y 位置執行。視您想執行的操作而定，類神經網路可以訓練成使用或捨棄這些位置資料。使用全域平均集區會明確捨棄所有位置資料。這或許適用於花朵分類器，但可能不適用於其他工作，例如計算圖片中的花朵。請謹慎使用。

解決方案

以下是解決方案筆記本。如果遇到問題，可以使用此功能。

Keras_Flowers_TPU (solution).ipynb

涵蓋內容

• 🤔? 運用卷積層
• 🤓? 試過以最大池化、推擠和全球平均池為目標等實驗...
• 😀? 於 TPU 上快速疊代處理實際模型

請花點時間研讀這份檢查清單，

10. [資訊] 現代卷積架構

概述

現代卷積網路，從「Inception」和Inception v2"，通常使用「modules」可在相同的輸入上一次嘗試不同的捲積層，而它們的輸出內容將串連在一起，而網路會透過訓練，判斷哪一層最實用。

插圖：卷積「模組」。目前哪一邊最適合？最大集區層後面接著 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)

其他超值秘訣

小 3 x 3 濾鏡

在這張插圖中，您會看到兩個連續 3x3 濾鏡的結果。試著追溯造成結果的資料點：這兩個連續的 3x3 篩選器會計算出一個 5x5 區域的任意組合。這與 5x5 濾波器會計算的組合並不完全相同，但值得嘗試，因為兩個連續 3x3 篩選器的費用比一個 5x5 篩選器便宜。

1x1 卷積？

在數學術語中，「1x1」卷積是常數的乘法，不是非常實用的概念。不過在卷積類神經網路中，篩選器會套用至資料立方體，而非只有 2D 圖片。因此「1x1」篩選器會計算 1x1 資料欄的加權總和 (請見圖解)，當您在資料之間滑動時，會得到輸入管道的線性組合。這其實很有用。舉例來說，如果將管道視為個別篩選作業的結果，例如使用「pointy ears」的篩選器，就會比較「Whiskers」第三則代表「亮眼」接著是「1x1」卷積層會計算這些特徵的多個可能線性組合，您在尋找「貓」時相當實用。除此之外，1x1 層使用的權重更少。

11. 擠檸檬

「Squeezenet」紙。作者提出非常簡單的捲積模組設計建議，僅使用 1x1 和 3x3 卷積層。

插圖：以「火災模組」為基礎的擠檸檬架構。他們交錯 1x1 層，「擠壓」垂直維度傳入的資料，後面接著兩個「展開」的 1x1 和 3x3 卷積層又能降低資料的深度

實作

接著使用先前的筆記本，建立以擠壓網路為靈感的捲積類神經網路。您必須將模型程式碼變更為 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 個連續的火焰模組。

在火焰模組中，參數通常應小於「展開」參數。這些參數實際上是篩選器的數量。通常介於 8 至 196 之間。您可以嘗試不同的架構，讓篩選器數量透過網路逐漸增加，或者是單純的架構 (所有啟動模組都具有相同數量的篩選器)。

範例如下：

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

由於我們的資料集很小，因此 Moumum 參數必須從預設值 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.datset 擴增資料

請花點時間研讀這份檢查清單，

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

這可以做為練習，讓讀取器計算和套用每個卷積層以類似的方式縮放所需要的乘數多之乘數。可分割的捲積較小，且運算效能更佳。

實作

重新開始「遷移學習」遊樂場筆記本，但這次請選取 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

涵蓋內容

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

請花點時間研讀這份檢查清單，

13. 恭喜！

您已成功建立第一個現代化卷積類神經網路，並將該網路訓練至 90% 以上的準確率。有了 TPU，就能在短短幾分鐘內完成連續訓練的疊代作業。

TPU 實務

Google Cloud 的 Vertex AI 提供 TPU 和 GPU：

• 在深度學習 VM 上
• 在 Vertex AI Notebooks 中
• 在 Vertex AI 訓練工作工作中

最後，我們非常喜歡使用者的意見。如果您在研究室中發現任何錯誤，或認為需要改善，請告訴我們。您可以透過 GitHub 問題提供意見 [feedback link]。

作者：Martin Görner Twitter：@martin_gorner