卷積神經網路

CNN 與神經網路所提及之DNN(或是MLP, Multilayer Perceptron, 多層感知器) 的主要差異可由下圖看出，即，CNN 在輪入層中多了卷積層與池化層，而DNN中的每一層都是Dense Layer，也就是Fully Connected Layer。

更進一步來看MPL與CNN的架構差異，我們同樣以圖形識別為例，在讀入一張圖片後，MLP的做法如下：

就是將2維圖片矩陣「攤平」為1維矩陣(也就會損失了圖片的空間特徵)，然後每個矩陣的值搭配一個權重往下一層傳送進行運算，可以想像，如果第二層有100個神經元，就代表會有100*(36+1)個參數，其中+1為bias。而CNN的做法則如下圖:

而CNN則是透過卷積核(kernel, 即圖5中的filter)對整張圖做卷積，部份的保留了圖片的空間特徵，同時也減少了參數數量。

由此看來，較之CNN，DNN有兩個缺點^{2, 3}：

1. 需要大量記憶體:
   在處理 256x256 大小的彩色圖片時，會需要用到 256 * 256 * 3 =196,608 個 Input Neuron，如果中間的隱藏層有 1000 個 Neuron，每個神經元需要一個浮點數的權重值 (8 bytes)，那麼總共需要 196,608 * 1001 * 8 = 1.47 GB 的記憶體才夠。更何況這還只是個簡單的模型。
   
2. 多層感知器只針對圖片中每個單一像素去作判斷，完全捨棄重要的影像特徵。人類在判斷所看到的物體時，會從不同部位的特徵先作個別判斷，例如當你看到一架飛機，會先從機翼、機鼻、機艙體等這些特徵，再跟記憶中的印象來判斷是否為一架飛機，甚至再進一步判斷為客機還是戰鬥機。但是多層感知器沒有利用這些特徵，所以在影像的判讀上準確率就沒有接下來要討論的 CNN 來得好。
   

與 DNN 相比，CNN多了卷積層與池化層，卷積層用來強調圖案(資料)特徵，池化層則可以縮減取樣，減少 overfitting 問題。二者的比較如下圖⁴所示：

想具體的了解卷積核的功能，可以先到這裡來體驗一下。

在神經網路中，我們曾經提出如下的卷積運算例子：

經由如下的矩陣計算，我們可以初步擬定一條分類規則：若是運算所得值大於0，則此圖像為＼；若是運算所得值小於0，則判定為／。

在上述範例中：

• 矩陣K對矩陣A、B所進行的運算即為卷積(convolution)，矩陣K在卷積神經網路中稱之為卷積核(convolution kernel)，其作用即在於萃取出資料特徵。藉此，我們達成了利用數學運算來擷取圖像特徵，也可以理解到為何深度學習能夠過濾資料雜訊而完成圖像識別。
  
• 計算得到結果後，我們私自擬定一條分類規則：若是運算所得值大於0，則此圖像為＼；若是運算所得值小於0，則判定為／。在神經網路中，這就是激勵函數(Activation Function)。
  

以全連接層來處理神經網路的問題在於：全連接層會忽略資料的「形狀」。例如，假設輸入資料為影像，則通常會包含水平、垂直、色版方向的三維形狀，然而當這些資料輸入全連接層時，三維資料就必須變為平面（一維資料），如前述的 MNist 資料集，輸入為(1, 28, 28)，即，一種顏色、28*28 像素，輸入全連接層後會變成一行的 784 個資料。

三維形狀的影像包含了許多重要的空間資料，例如，類似的空間有著相似的象素值、RGB 各色版間有緊密連接的關連性，距離較遠的像素彼此沒有關連…等特質，這些特質會在全連接層中被忽略掉。卷積層（Convolution layer）則能維持這些形狀，我們把 CNN 的卷積層輸出入資料稱作特徵圖（input / output feature map），而在卷積層中執行的處理則稱為卷積運算，若以影像處理來比喻卷積運算，則相當於「濾鏡效果」。卷積層的意義即是將原本一個影像經由卷積運算產生多個影像，每個影像均代表不同特徵。卷積運算方式如下：

典型的卷積運算如圖9，此處特徵圖為(4,4)，濾鏡為(3,3)，輸出為(2,2)，這裡所謂的濾鏡就是CNN中的卷積核(convolution kernel)，其初始值由隨機方式產生。此外，在全連接網路層中，除了權重參數(weight)之外，還有偏權值(bias)，其結果如圖10。

由圖9、10的卷積運算可以看出，輸入特徵值在經過運算後，其大小會縮小，可以預見的結果是，在經過多層神經網路反複進行卷積運算後，輸出特徵值大小很快就會縮小為 1，而無法再進行卷積運算。為了避免這種情況發生，在進行卷積運算前，可以針對輸入資料周圍補上一圈固定的資料（例如 0），這個動作稱為填補(padding)，如果我們對在卷積運算前對於圖9中的輸入特徵值進行寬度 1 的填補，則其結果如圖11所示。

進行上述卷積運算時，每次自左而右、自上而下，自輸入特徵值取出一個與核大小相同的子矩陣與核進行運算，而每個取出的子矩陣的間隔稱為步幅(stride)，上述範例中的stride均為 1，若 stride 設為 2，則一個(7,7)的輸入特徵值與一個(3,3)的核進行運算後，其輸出特徵值大小只剩(3,3)。

上述範例中的特徵值均為二維矩陣，亦即，僅能表示水平與垂直方向的單色點陣圖，若輸入中包含色彩資料(RGB)，則輸入特徵圖將升及為三維矩陣（三層二維矩陣，每層表示一種 RGB 值），核的結構也是三維矩陣，但輸出特徵值則為二維矩陣。 以 MNist 資料集為例，將數字 7 的 28*28 影像以隨機產生的 5*5 濾鏡(或稱 filter weight、kernel)對其進行卷積，其結果如圖12所示，這種效果有助於提取輸入影像的不同特徵，例如邊緣、線條…等。

實際建構模型時，不會只進行單一 kenrel 的卷積，圖13即是隨機產生 16 個 kernel 對輸入影像提取不同特徵。

全連接層(又稱密集層, dense layer)和卷積層之間的根本區別在於：全連接層會由輸入的特徵空間中學習全域的 pattern，而卷積層則是學習局部的 pattern。以影像辨識為例，卷積層會把輸入分解成小小的 2D 窗格，然後從中找出 pattern。這個關鍵特性為 CNN 提供了兩個有趣的特質：

• 學習到的 pattern 具平移不變性(translation invariant)：在影像的右下角學習到的某個 pattern，CNN 可以在任何位置識別這樣的 pattern(如左上角)，相對的，當全連接層連接神經網路看到 pattern 出現在新位置時，就必須重新學習，這使的 CNN 可以更有效率地處理影像資料。
  
• 學習到 pattern 的空間層次結構(spatial hierarchies of patterns)：第一層卷積層會學習到諸如邊邊角角的小局部圖案，第二層卷積層則會基於第一層學到的特徵(小圖案)來學習較大的圖案，這使得 CNN 能夠有效地學習越來越複雜和抽象的視覺概念。
  

CNN 所運算的 3D 張量稱為特徵映射圖(feature maps，簡稱特徵圖)，特徵圖有 2 個空間軸(height, width)以及 1 個色深度軸(depth / channel)，對於 RGB 影像來說，depth 值為 3。卷積運算會從輸入特徵中萃取出各種小區塊 pattern，當它對整張影像都做完萃取之後，就會產生輸出特徵映射圖(output feature map)。輸出特徵映射圖仍是 3D 張量，具有寬度和高度，但此時其深度軸已不再代表 RGB 顏色值，此時它代表過濾器(filter)，每一種 filter 會對輸入資料進行特定面向的編碼、萃取出結果，例如，filter 可以萃取到「在輸入資料中出現一張臉」這種高階抽象的概念，將不是臉的都過濾掉。

卷積層之間通常會加一個池化層(Pooling Layer)，它是一個壓縮圖片並保留重要資訊的方法，取樣的方法一樣是採滑動視窗，但是通常取最大值(Max-Pooling)，而非加權總和，若滑動視窗大小設為 2，『滑動步長』(Stride) 也為 2，則資料量就降為原本的四分之一，但因為取最大值，它還是保留局部範圍比對的最大可能性。也就是說，池化後的資訊更專注於圖片中是否存在相符的特徵，而非圖片中『哪裡』存在這些特徵，幫助 CNN 判斷圖片中是否包含某項特徵，而不必關心特徵所在的位置，這樣圖像偏移，一樣可以辨識出來。其架構如圖14所示。⁵

池化層以縮減取樣(downsampling)的方式縮小影像可以帶來以下優點：

1. 減少需要處理的資料點：減少後續運算所需時間。
   
2. 讓影像位置差異變小：影像要辨識的目標（如 MNist 資料集的數字）可能因為在影像中的位置不同而影響辦識，減小影像可以讓數字的位置差異變小。
   
3. 參數的數量程計算量下降：同時也能控制 overfitting。
   

圖15即為使用 Max-Pool 對 16 個卷積影像進行縮減取樣(downsampling)的效果，將 16 個 28*28 個影像縮小為 16 個 14*14 的影像，但仍保持其特徵。MaxPooling 主要是由輸入特徵圖中做採樣並輸出樣本的最大值，它在概念上類似於卷積層操作，但並不是用卷積核(convolution kernel)張量積的方式來轉換局部區塊，而是經由手動編碼的 max 張量操作進行轉換。與卷積層操作的很大區別是 MaxPooling 通常用 2×2 窗格和步長(strides)2 來完成，以便將特徵圖每一軸的採樣減少到原來的 1/2，而卷積層操作通常使用 3×3 窗格且不指定步長(即使用預設步長 1)。

為什麼要採用這種方式來縮小採樣特徵圖而不用原來的特徵圖尺寸一路執行下去？假設一個有不加入 MaxPooling 而是以全卷積層的模型設計如下：

1: model_no_max_pool = models.Sequential()
2: model_no_max_pool.add(layers.Conv2D(32, (3, 3), activation='relu'),
3:                       input_shape=(28, 28, 1))
4: model_no_max_pool.add(layers.Conv2D(64, (3, 3), activation='relu'),)
5: model_no_max_pool.add(layers.Conv2D(64, (3, 3), activation='relu'),)

上述設計的問題可以從以下兩個面向來看：⁶

• 不利於學習特徵的空間層次結構。當 strides=1，第二層的 3×3 窗格要走過 5×5 的區域才能包含第一層的 7×7 區城，進而生成下一層的完整 3×3 區域，依此類推，第三層的 3×3 窗格也要走過 5×5 的區域才能包含第二層的 5×5 區域。也就是說，第三層的 3×3 窗格實際上僅包含來自原始輸入的 7×7 區城的資訊。相對於初始輸入，由卷積神經網路學習的高階 pattern 仍然進展很小，不足以學習分類數字。我們希望的是：最後一個卷積層的輸出特徵已經能提供有關輸入資料的總體訊息。
  
• 最終特徵圖的每個樣本總係數為 22×22×64=3-976，這是相當巨大的 model，如果要將其展平以在頂部連接大小為 512 的 Dense 層，則該層將會有 1580 萬個參數，這對小 model 而言實在是太大，而且會導致 overfitting。
  

雖然 MaxPooling 並不是縮小探樣特徵圖的唯一方法（也可以透過卷積層的 strides 來調整，或是使用平均池化而非 MaxPooling）,不過就經驗來看，MaxPooling 往往比這些方案好。主要原因是：特徵通常是源自於空間某些有特色的 pattern，因此要取其最大值才更具訊息性，若採用平均值，則特色就被掩蓋了。

當我們在比較分析兩組數據資料時，可能會遭遇因單位的不同(例如：身高與體重)，或數字大小的代表性不同(例如：粉專1萬人與滿足感0.8)，造成各自變化的程度不一，進而影響統計分析的結果⁸，即：那些變化量最大的因素（特徵）會主導分析結果。

正式將資料送至模型訓練前，資料應進行相應的缺漏值處理以及資料正規化，詳細處理方式可參考資料預處理。

整理完資料集後，接下來就是要選擇訓練用的模型，像是決策樹、LSTM、RNN等等都是機器學習中常使用的訓練模型，其中目前較常拿來訓練股市的是「LSTM」，中文叫做長短期記憶，是屬於深度學習中的一個模型。另一種CNN模型則適合處理圖形資料。

選擇好訓練模型後，再來要將訓練集資料丟進去模型中做訓練，每層要放多少神經元、要跑幾層等等都會影響模型訓練出來的結果，這部分只能靠經驗跟不斷嘗試去學習，或是上網多爬文看別人怎麼撰寫訓練模型。

在真正訓練前應該再設定好模型的loss function, optimizer。

當模型訓練完成後，接下來就是判斷該模型是否有過度擬合(overfitting)，這裡就是帶入測試集的資料進行評估，也可以嘗試利用交叉驗證的方式進行模型的擬合性判斷，以及利用RESM、MSE等統計計算來判斷模型的準確度

1: scores = model.evaluate(x_Train, y_TestOneHot)

到這大致上模型已經完成了50%，最後的一步就是進行參數的微調，我們也稱為「超參數 (Hyperparamters)」，讓整個模型更加的精準，但也不能過度的調整，因為會造成overfitting的結果，這個取捨就只能依照無窮盡的反覆迭帶去尋找了，這部分也是相對較耗時間的地方

到此，模型已經正式完成。那，怎麼知道這個模型夠不夠優秀？能不能正常運作？最簡單的評估方式是以一筆新的資料來測試。

1: prediction = model.predict_classes(x_Test4D_normalize)
2: print(prediction[:10])

以MNIST手寫數字辨識為例，我們可以自已寫一個數字餵給模型，看看模型是否能正確預測。

對於模型來說，這類全新的數據則是一個未知數，如果我們在訓練與測試階段都用同一批資料，這就好像上課與考試的內容都一樣，這會導致學生其實沒有學到真正的知識，而考試得到的分數也不會太準確。這種訓練資料與測試資料過於雷同而導致模型對新型別的資料欠缺處理能力的問題即為 過度擬合(overfitting) ；反之，如果我們的模型對於各種新型態資料都能辨識，則這個模型就具有 泛化（Generalization） 的預測能力。

• MNIST 是機器學習領域中相當著名的資料集，號稱機器學習領域的「Hello world.」，其重要性不言可喻。
  
• MNIST 資料集由 0~9 的數字影像構成(如圖16)，共計 60000 張訓練影像、10000 張測試影像。
  
• 一般的 MMIST 資料集的用法為：使用訓練影像進行學習，再利用學習後的模型預測能否正確分類測試影像。
  

準備資料是訓練模型的第一步，基礎資料可以是網上公開的資料集，也可以是自己的資料集。視覺、語音、語言等各種型別的資料在網上都能找到相應的資料集。

MNIST 數據集來自美國國家標準與技術研究所, National Institute of Standards and Technology (NIST). 訓練集 (training set) 由來自 250 個不同人手寫的數字構成, 其中 50% 是高中學生, 50% 來自人口普查局 (the Census Bureau) 的工作人員. 測試集(test set) 也是同樣比例的手寫數字數據。MNIST 數據集可在 http://yann.lecun.com/exdb/mnist/ 獲取, 它包含了四個部分:

1. Training set images: train-images-idx3-ubyte.gz (9.9 MB, 解壓後 47 MB, 包含 60,000 個樣本)
   
2. Training set labels: train-labels-idx1-ubyte.gz (29 KB, 解壓後 60 KB, 包含 60,000 個標籤)
   
3. Test set images: t10k-images-idx3-ubyte.gz (1.6 MB, 解壓後 7.8 MB, 包含 10,000 個樣本)
   
4. Test set labels: t10k-labels-idx1-ubyte.gz (5KB, 解壓後 10 KB, 包含 10,000 個標籤)
   

雖然自己手動下載是個不錯的主意，可以讓你練習如何從網路抓檔案、解壓、設定這些檔案的下載路徑、然後再讀進來變成numpy的array或是pandas的dataframe，再把這些資料餵給tensorflow模組去建模型…..不過這對初學者來說著實是一件很麻煩的事，所以多數的套件都很貼心的幫你準備好了直接從網路抓下資料集的function，像tensorflow的load_data。

• 在這個模型中，第一層(同時也身兼輸入層)有32個卷積核，也就是有32個神經元
  
• 第一層的每個神經元有10個參數\(3*3+1\)，因為卷積核大小為\(3*3\)，還有一個bias
  

 1: from keras import layers
 2: from keras import models
 3: model = models.Sequential()
 4: model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
 5: model.add(layers.MaxPooling2D((2, 2)))
 6: model.add(layers.Conv2D(64, (3, 3), activation='relu'))
 7: model.add(layers.MaxPooling2D((2, 2)))
 8: model.add(layers.Flatten())
 9: model.add(layers.Dense(512, activation='relu'))
10: model.add(layers.Dense(10, activation='softmax'))
11: model.summary()  # 查看模型摘要

Model: "sequential_18"
_________________________________________________________________
 Layer (type)                Output Shape              Param #
=================================================================
 conv2d_32 (Conv2D)          (None, 26, 26, 32)        320

 max_pooling2d_25 (MaxPooli  (None, 13, 13, 32)        0
 ng2D)

 conv2d_33 (Conv2D)          (None, 11, 11, 64)        18496

 max_pooling2d_26 (MaxPooli  (None, 5, 5, 64)          0
 ng2D)

 flatten_7 (Flatten)         (None, 1600)              0

 dense_26 (Dense)            (None, 512)               819712

 dense_27 (Dense)            (None, 10)                5130

=================================================================
Total params: 843658 (3.22 MB)
Trainable params: 843658 (3.22 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

在編譯時，以adim優化器，由於使用 softmax 單元結束神經網路，所以配合使用 categorical_crossentropy 為損失基準。

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

1: import os
2: os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # 设置 Tensorflow 日志级别为 ERROR
3: 
4: history = model.fit(X_train, Y_train,  # 训练数据和标签
5:                     batch_size=128,     # 批次大小
6:                     epochs=10,          # 训练轮数
7:                     validation_split=0.2)  # 验证集比例（可选）

Epoch 1/10
375/375 [==============================] - 7s 18ms/step - loss: 0.0074 - accuracy: 0.9973 - val_loss: 0.0429 - val_accuracy: 0.9900
Epoch 2/10
375/375 [==============================] - 7s 19ms/step - loss: 0.0039 - accuracy: 0.9988 - val_loss: 0.0458 - val_accuracy: 0.9904
Epoch 3/10
375/375 [==============================] - 7s 19ms/step - loss: 0.0044 - accuracy: 0.9986 - val_loss: 0.0543 - val_accuracy: 0.9887
Epoch 4/10
375/375 [==============================] - 7s 19ms/step - loss: 0.0055 - accuracy: 0.9978 - val_loss: 0.0456 - val_accuracy: 0.9905
Epoch 5/10
375/375 [==============================] - 7s 19ms/step - loss: 0.0020 - accuracy: 0.9993 - val_loss: 0.0428 - val_accuracy: 0.9911
Epoch 6/10
375/375 [==============================] - 7s 19ms/step - loss: 9.6022e-04 - accuracy: 0.9997 - val_loss: 0.0503 - val_accuracy: 0.9912
Epoch 7/10
375/375 [==============================] - 7s 19ms/step - loss: 1.9383e-04 - accuracy: 1.0000 - val_loss: 0.0471 - val_accuracy: 0.9917
Epoch 8/10
375/375 [==============================] - 8s 21ms/step - loss: 4.2269e-05 - accuracy: 1.0000 - val_loss: 0.0484 - val_accuracy: 0.9922
Epoch 9/10
375/375 [==============================] - 8s 20ms/step - loss: 3.1525e-05 - accuracy: 1.0000 - val_loss: 0.0490 - val_accuracy: 0.9924
Epoch 10/10
375/375 [==============================] - 7s 20ms/step - loss: 1.5961e-05 - accuracy: 1.0000 - val_loss: 0.0504 - val_accuracy: 0.9923

 1: # 在测试数据上评估模型
 2: loss, accuracy = model.evaluate(X_test, Y_test)
 3: print('Test loss:', loss)
 4: print('Test accuracy:', accuracy)
 5: 
 6: import matplotlib.pyplot as plt
 7: 
 8: # 获取训练历史中的损失值和准确率值
 9: train_loss = history.history['loss']
10: val_loss = history.history['val_loss']
11: train_accuracy = history.history['accuracy']
12: val_accuracy = history.history['val_accuracy']
13: 
14: # 绘制损失值折线图
15: plt.cla()
16: plt.plot(train_loss, label='Training Loss')
17: plt.plot(val_loss, label='Validation Loss')
18: plt.title('Training and Validation Loss')
19: plt.xlabel('Epoch')
20: plt.ylabel('Loss')
21: plt.legend()
22: plt.savefig('images/cnn-mnist-Loss.png', dpi=300)
23: 
24: # 绘制准确率折线图
25: plt.cla()
26: plt.plot(train_accuracy, label='Training Accuracy')
27: plt.plot(val_accuracy, label='Validation Accuracy')
28: plt.title('Training and Validation Accuracy')
29: plt.xlabel('Epoch')
30: plt.ylabel('Accuracy')
31: plt.legend()
32: plt.savefig('images/cnn-mnist-Accuracy.png', dpi=300)

313/313 [==============================] - 1s 4ms/step - loss: 0.0358 - accuracy: 0.9929
Test loss: 0.03584390878677368
Test accuracy: 0.992900013923645

1: # 使用模型进行预测
2: predictions = model.predict(x_test)
3: 
4: # 輸出前10個樣本的预测结果
5: for i in range(10):
6:     print("Predicted:", predictions[i].argmax(), "Actual:", Y_test[i].argmax())

313/313 [==============================] - 1s 4ms/step
Predicted: 7 Actual: 7
Predicted: 2 Actual: 2
Predicted: 1 Actual: 1
Predicted: 0 Actual: 0
Predicted: 4 Actual: 4
Predicted: 1 Actual: 1
Predicted: 4 Actual: 4
Predicted: 9 Actual: 9
Predicted: 6 Actual: 5
Predicted: 9 Actual: 9

 1: import pandas as pd
 2: 
 3: # 假设 predictions 和 y_test 是模型预测结果和实际标签
 4: # 假设 predictions 和 y_test 都是一维数组，每個元素是樣本对应的类别标签
 5: 
 6: # 将预测结果和实际标签转换为 Pandas Series
 7: predicted_labels = pd.Series(predictions.argmax(axis=1), name='Predicted')
 8: actual_labels = pd.Series(Y_test.argmax(axis=1), name='Actual')
 9: 
10: # 使用 pd.crosstab 计算交叉表
11: crosstab_result = pd.crosstab(actual_labels, predicted_labels)
12: 
13: # 輸出交叉表
14: print(crosstab_result)

Predicted    0     1     2     3    4    5    6     7    8    9
Actual
0          977     0     0     0    1    0    0     1    1    0
1            0  1128     1     1    0    1    1     0    3    0
2            1     1  1026     0    0    0    0     4    0    0
3            0     0     1  1004    0    3    0     0    2    0
4            0     0     0     0  979    0    0     0    1    2
5            2     0     1     9    0  873    3     1    3    0
6            2     2     0     0    3    1  948     0    2    0
7            0     0     3     0    0    0    0  1021    1    3
8            2     0     1     0    0    0    0     2  968    1
9            0     0     0     1    8    2    0     0    3  995

1: import matplotlib.pyplot as plt
2: import numpy as np
3: 
4: x = np.random.uniform(0.0, 3, (10))
5: y = 78 + 7.8*x + np.random.normal(0.0, 3, len(x))
6: print('x: ', x)
7: print('y: ', y)
8: 
9: plt.scatter(x, y)

x:  [1.04495966 2.63828713 1.05394772 ... 2.7829483  2.5038085  0.7773407 ]
y:  [ 85.07647921  96.21107688  90.60605344 ...  97.41007778 102.38380208 80.86243195]

結果如下圖，一共有10個點，如何畫出一條迴歸線代表這10個點的趨勢？這個題目本身是什麼意思？

想像一下，上面是10個學生的資料，X軸是學生對於數學的喜愛程度，Y軸是該生的數學期末考成績，看起來二者間是存在某種關係的。那，如果已知某生對數學的喜愛程為2.0，我們可以預測他的數學期末考成績嗎？—可以的，如果我們有一條像底下的迴歸線公式：
\[ MathScore_i = a * MathLove_i + b \]
如此一來，我們就能輸入喜愛程度，得到對數學成績的預測結果。

當樣本數不太多，而你的計算能力也不弱時，也許你可以手動將上述公式中的a與b求出，得到一條 \(y=ax+b\) 的迴歸線，但萬一樣本數有2000個點呢(如圖25)?

接下來我們想建一個CNN模型來幫我們畫一條迴歸線。

 1: from sklearn import linear_model
 2: regr=linear_model.LinearRegression()
 3: 
 4: x = x.reshape(-1, 1)
 5: # 改變x的格式形狀，
 6: # 原本x為 [x1, x2, x3, ...]
 7: # 要改格式符合scikit learn迴歸模組的需求，變成: [ [x1], [x2], [x3], ...]
 8: y = y.reshape(-1, 1)
 9: regr.fit(x, y)
10: 
11: #短短兩行code，模型已經建構完成了! 接下來，我們來看看訓練集的成果。
12: plt.clf()
13: plt.scatter(x, y, s=10)
14: plt.plot(x, regr.predict(x), color='red', linewidth=4)
15: print("====實際(前三筆)====")
16: print(y[:3])
17: print("====預測(前三筆)====")
18: print(regr.predict(x[:3]))

====實際(前三筆)====
[[85.07647921]
 [96.21107688]
 [90.60605344]]
====預測(前三筆)====
[[86.09718013]
 [98.58801576]
 [86.16764168]]

 1: from keras.models import Sequential
 2: from keras.layers import Dense
 3: from keras.layers import Dropout
 4: 
 5: # A simple regression model
 6: model = Sequential()
 7: model.add(Dense(4, input_shape=(1,)))
 8: model.add(Dropout(0.5))
 9: model.add(Dense(8, input_shape=(1,)))
10: model.add(Dropout(0.5))
11: model.add(Dense(1, input_shape=(1,)))
12: model.compile(loss='mse', optimizer='rmsprop', metrics=['mse'])
13: print(model)

<Sequential name=sequential_1, built=True>

 1: # 將實際資料分為訓練集與測試集
 2: x_Train = x[:1500]
 3: x_Test = x[1500:]
 4: y_Train = y[:1500]
 5: y_Test = y[1500:]
 6: # The fit() method - trains the model
 7: train_history = model.fit(x=x_Train, y=y_Train,
 8:                           validation_split=0.2,
 9:                           epochs=100, batch_size=200,
10:                           verbose=1)
11: print(train_history)

Epoch 1/100
6/6 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step - loss: 8444.8213 - mse: 8444.8223 - val_loss: 8150.6479 - val_mse: 8155.1191
略...
Epoch 100/100
6/6 ━━━━━━━━━━━━━━━━━━━━ 0m 37m 0m  1m0s 0m 2ms/step - loss: 3507.2502 - mse: 3507.2505 - val_loss: 2969.5845 - val_mse: 2959.9399
<keras.src.callbacks.history.History object at 0x16c613e60>

 1: print(train_history.history.keys())
 2: import matplotlib.pyplot as plt
 3: plt.cla()
 4: plt.title('Train History - Loss')
 5: plt.ylabel('Loss')
 6: plt.xlabel('Epoch')
 7: plt.plot(train_history.history['loss'])
 8: plt.plot(train_history.history['val_loss'])
 9: #plt.show()
10: plt.savefig("images/cnn-regression-4.png", dpi=300)

dict_keys(['loss', 'mse', 'val_loss', 'val_mse'])

1: # The evaluate() method - gets the loss statistics
2: score = model.evaluate(x_Test, y_Test, batch_size=200)
3: print(score)

3/3 [==============================] - 0s 990us/step - loss: 727.6573
727.6573486328125

1: # The predict() method - predict the outputs for the given inputs
2: print(y_Test[:5])
3: print(model.predict(x_Test[:5]))

[[92.71580667]
 [80.35926946]
 [94.14913803]
 [80.94617382]
 [94.81639264]]
1/1 [==============================] - 0s 87ms/step
[[74.310616]
 [49.009674]
 [75.51746 ]
 [54.195095]
 [68.86794 ]]

• model架構
  
• loss function
  
• optimizer
  
• hyper parameters
  

回家執行：下載需要 一點 時間….

 1: ### 1.  Import Library
 2: from keras.datasets import cifar10
 3: import numpy as np
 4: np.random.seed(10)
 5: 
 6: ### 2. 資料準備
 7: (x_img_train,y_label_train),(x_img_test,y_label_test) = cifar10.load_data()
 8: x_img_train_normalize = x_img_train.astype('float32') / 255.0
 9: x_img_test_normalize = x_img_test.astype('float32') / 255.0
10: '''正規化'''
11: from tensorflow.keras.utils import to_categorical
12: 
13: y_label_train_OneHot = to_categorical(y_label_train)
14: y_label_test_OneHot = to_categorical(y_label_test)

 1: ### 3. 建立模型
 2: from keras import layers
 3: from keras import models
 4: '''卷積層1與池化層1'''
 5: # 隨機產生32個3*3的濾鏡，輸入的影像為32*32*3(RGB)
 6: model = models.Sequential()
 7: 
 8: model.add(layers.Conv2D(filters=32,kernel_size=(3,3), input_shape=(32, 32, 3),
 9:                  activation='relu', padding='same'))
10: model.add(layers.Dropout(rate=0.25)) # 每次訓練迭代時會隨機放棄25%的神經元
11: model.add(layers.Conv2D(filters=32, kernel_size=(3, 3),
12:                  activation='relu', padding='same'))
13: # 進行第一次縮減取樣，將影像縮為16*16
14: model.add(layers.MaxPooling2D(pool_size=(2, 2)))
15: '''卷積層2與池化層2'''
16: # 將前一層傳進的32個16*16影像轉為64個16*16影像
17: model.add(layers.Conv2D(filters=64, kernel_size=(3, 3), ### 產生64個影像
18:                  activation='relu', padding='same'))
19: model.add(layers.Dropout(0.25))
20: model.add(layers.Conv2D(filters=64, kernel_size=(3, 3),
21:                  activation='relu', padding='same'))
22: # 再將64個16*16影像縮減取樣為8*8
23: model.add(layers.MaxPooling2D(pool_size=(2, 2)))
24: '''卷積層3與池化層3'''
25: # 將64個8*8個影像轉為128個
26: model.add(layers.Conv2D(filters=128, kernel_size=(3, 3),
27:                  activation='relu', padding='same'))
28: model.add(layers.Dropout(0.3))
29: model.add(layers.Conv2D(filters=128, kernel_size=(3, 3),
30:                  activation='relu', padding='same'))
31: # 再將128個8*8影像縮減取樣為4*4
32: model.add(layers.MaxPooling2D(pool_size=(2, 2)))
33: '''建立神經網路(平坦層、隱藏層、輸出層)'''
34: # 將128*4*4的3維矩陣轉為1維(2048個float數字，對應到2048個神經元)
35: model.add(layers.Flatten())
36: model.add(layers.Dropout(0.3))
37: model.add(layers.Dense(2500, activation='relu')) ### 隠藏層1有2500個神經元
38: model.add(layers.Dropout(0.3))
39: model.add(layers.Dense(1500, activation='relu')) ### 隠藏層2有1500神經元
40: model.add(layers.Dropout(0.3))
41: model.add(layers.Dense(10, activation='softmax')) ### 10個label
42: print(model.summary())

Model: "sequential_5"
_________________________________________________________________
 Layer (type)                Output Shape              Param #
=================================================================
 conv2d_19 (Conv2D)          (None, 32, 32, 32)        896

 dropout_18 (Dropout)        (None, 32, 32, 32)        0

 conv2d_20 (Conv2D)          (None, 32, 32, 32)        9248

 max_pooling2d_9 (MaxPoolin  (None, 16, 16, 32)        0
 g2D)

 conv2d_21 (Conv2D)          (None, 16, 16, 64)        18496

 dropout_19 (Dropout)        (None, 16, 16, 64)        0

 conv2d_22 (Conv2D)          (None, 16, 16, 64)        36928

 max_pooling2d_10 (MaxPooli  (None, 8, 8, 64)          0
 ng2D)

 conv2d_23 (Conv2D)          (None, 8, 8, 128)         73856

 dropout_20 (Dropout)        (None, 8, 8, 128)         0

 conv2d_24 (Conv2D)          (None, 8, 8, 128)         147584

 max_pooling2d_11 (MaxPooli  (None, 4, 4, 128)         0
 ng2D)

 flatten_3 (Flatten)         (None, 2048)              0

 dropout_21 (Dropout)        (None, 2048)              0

 dense_9 (Dense)             (None, 2500)              5122500

 dropout_22 (Dropout)        (None, 2500)              0

 dense_10 (Dense)            (None, 1500)              3751500

 dropout_23 (Dropout)        (None, 1500)              0

 dense_11 (Dense)            (None, 10)                15010

=================================================================
Total params: 9176018 (35.00 MB)
Trainable params: 9176018 (35.00 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
None

 1: ### 4. 載入之前訓練的模型
 2: try:
 3:     model.load_weights("SaveModel/cifarCnnModelnew1.h5")
 4:     print("載入模型成功!繼續訓練模型")
 5: except:
 6:     print("載入模型失敗!開始訓練一個新模型")
 7: 
 8: ### 5. 訓練模型
 9: # 訓練前先以compile設定模型, 設定內容包含
10: # 1. 損失函數, 2. 最佳化方法, 3. 評估模型的方法
11: model.compile(loss='categorical_crossentropy',
12:               optimizer='adam', metrics=['accuracy'])
13: # 開始訓練, 執行50次訓練週期、每一批次500筆資料
14: # 40000筆資料，每一批次500筆資料, 分為80批次進行訓練
15: # 每個epoch訓練完後會存一筆accuracy和loss記錄到train_history
16: train_history=model.fit(x_img_train_normalize, y_label_train_OneHot,
17:                         validation_split=0.2,
18:                         epochs=5, batch_size=500, verbose=1)
19: import matplotlib.pyplot as plt
20: def show_train_history(train_acc,test_acc):
21:     plt.plot(train_history.history[train_acc])
22:     plt.plot(train_history.history[test_acc])
23:     plt.title('Train History')
24:     plt.ylabel('Accuracy')
25:     plt.xlabel('Epoch')
26:     plt.legend(['train', 'test'], loc='upper left')
27:     #plt.show()
28: show_train_history('accuracy','val_accuracy')
29: 
30: ### 6. 評估模型準確率
31: scores = model.evaluate(x_img_test_normalize,
32:                         y_label_test_OneHot, verbose=0)
33: print(scores[1])
34: 
35: ### 7. 進行預測
36: prediction=model.predict(x_img_test_normalize)
37: print(prediction[:10])

載入模型失敗!開始訓練一個新模型
Epoch 1/5
80/80 [==============================] - 71s 879ms/step - loss: 1.9843 - accuracy: 0.2581 - val_loss: 2.0850 - val_accuracy: 0.2409
Epoch 2/5
80/80 [==============================] - 75s 934ms/step - loss: 1.5619 - accuracy: 0.4269 - val_loss: 1.6944 - val_accuracy: 0.3912
Epoch 3/5
80/80 [==============================] - 75s 937ms/step - loss: 1.3769 - accuracy: 0.4967 - val_loss: 1.5183 - val_accuracy: 0.4387
Epoch 4/5
80/80 [==============================] - 75s 938ms/step - loss: 1.2417 - accuracy: 0.5524 - val_loss: 1.2065 - val_accuracy: 0.5647
Epoch 5/5
80/80 [==============================] - 75s 944ms/step - loss: 1.1236 - accuracy: 0.5959 - val_loss: 1.1469 - val_accuracy: 0.5937
0.5929999947547913
313/313 [==============================] - 7s 21ms/step
[[6.46312302e-03 8.62431712e-03 2.74472516e-02 5.00399292e-01
  2.81555019e-02 9.06480253e-02 3.07343274e-01 4.68559610e-03
  2.12734081e-02 4.96020494e-03]
 [7.61443824e-02 3.05925645e-02 8.70503602e-04 7.35422189e-04
  8.07344739e-04 7.03643236e-05 3.87530803e-04 3.73235853e-05
  8.88279617e-01 2.07493710e-03]
 [2.19170123e-01 3.15457061e-02 2.23177653e-02 1.75716318e-02
  3.48090231e-02 5.49549609e-03 1.05224168e-02 3.76811461e-03
  6.39865100e-01 1.49346180e-02]
 [4.80774581e-01 5.90456650e-03 2.44085774e-01 1.69374775e-02
  1.14243045e-01 1.07119661e-02 1.00224596e-02 1.61196198e-02
  9.24141407e-02 8.78633745e-03]
 [5.03382122e-04 9.75311195e-05 6.01756126e-02 4.26706523e-02
  3.55109274e-01 6.51758304e-03 5.32512546e-01 2.19794596e-03
  1.07646527e-04 1.07893706e-04]
 [2.17650877e-03 6.94291375e-04 2.25894004e-02 6.15960397e-02
  2.69289650e-02 1.98316220e-02 8.60564947e-01 3.63973179e-03
  7.52524647e-04 1.22592552e-03]
 [7.00628571e-03 1.10443816e-01 2.33118124e-02 1.84527755e-01
  9.68367886e-03 1.67584091e-01 3.15246195e-01 1.13006774e-02
  1.70870777e-03 1.69187024e-01]
 [5.39396284e-03 2.00870680e-04 2.21061304e-01 5.73799871e-02
  2.93410629e-01 1.22425267e-02 4.05219078e-01 3.07954405e-03
  1.57088123e-03 4.41132550e-04]
 [7.44145736e-03 2.97625345e-04 2.10883513e-01 4.50782835e-01
  5.35527207e-02 2.20824048e-01 3.02264839e-02 2.32125558e-02
  1.64294522e-03 1.13576988e-03]
 [3.26189846e-02 7.81687021e-01 6.97707012e-03 4.02900390e-03
  3.50690144e-03 2.40204763e-03 1.28890313e-02 7.98477267e-04
  3.92462090e-02 1.15845300e-01]]

 1: 
 2: ### 8. 查看預測結果
 3: label_dict={0:"airplane",1:"automobile",2:"bird",3:"cat",4:"deer",
 4:             5:"dog",6:"frog",7:"horse",8:"ship",9:"truck"}
 5: 
 6: import matplotlib.pyplot as plt
 7: def plot_images_labels_prediction(images,labels,prediction,idx,num=10):
 8:     plt.cla()
 9:     fig = plt.gcf()
10:     fig.set_size_inches(12, 14)
11:     if num>25: num=25
12:     for i in range(0, num):
13:         ax=plt.subplot(5,5, 1+i)
14:         ax.imshow(images[idx],cmap='binary')
15:         title = str(i) + ',' + label_dict[int(labels[idx][0])]
16:         # 將labels[idx]轉換為整數
17:         #title=str(i)+','+label_dict[labels[i][0]]
18:         if len(prediction)>0:
19:             title+='=>'+label_dict[np.argmax(prediction[i])]
20:         ax.set_title(title,fontsize=10)
21:         ax.set_xticks([]);ax.set_yticks([])
22:         idx+=1
23:     #plt.show()
24:     plt.savefig('images/cifar10-predict.png', dpi=300)
25: plot_images_labels_prediction(x_img_test,y_label_test,
26:                               prediction,0,10)

 1: 
 2: ### 9. 查看預測機率
 3: Predicted_Probability=model.predict(x_img_test_normalize)
 4: def show_Predicted_Probability(y, prediction,
 5:                                x_img, Predicted_Probability, i):
 6:     print('label:',label_dict[y[i][0]],
 7:           'predict:',label_dict[np.argmax(prediction[i])])
 8:     plt.figure(figsize=(2,2))
 9:     plt.imshow(np.reshape(x_img_test[i],(32, 32, 3)))
10:     #plt.show()
11:     plt.savefig(f'images/cifar10-predict-image-{i}.png', dpi=300)
12:     print(f'images/cifar10-predict-image-{i}.png')
13:     for j in range(10):
14:         #print(label_dict[j])
15:         #print(Predicted_Probability[i][j])
16:         print(label_dict[j]+
17:               ' Probability:%1.9f'%(Predicted_Probability[i][j]))
18: 
19: show_Predicted_Probability(y_label_test, prediction,
20:                            x_img_test, Predicted_Probability, 0)
21: show_Predicted_Probability(y_label_test, prediction,
22:                            x_img_test, Predicted_Probability, 3)

313/313 [==============================] - 6s 20ms/step
label: cat predict: cat
images/cifar10-predict-image-0.png
airplane Probability:0.006463123
automobile Probability:0.008624317
bird Probability:0.027447252
cat Probability:0.500399292
deer Probability:0.028155502
dog Probability:0.090648025
frog Probability:0.307343274
horse Probability:0.004685596
ship Probability:0.021273408
truck Probability:0.004960205
label: airplane predict: airplane
images/cifar10-predict-image-3.png
airplane Probability:0.480774581
automobile Probability:0.005904566
bird Probability:0.244085774
cat Probability:0.016937478
deer Probability:0.114243045
dog Probability:0.010711966
frog Probability:0.010022460
horse Probability:0.016119620
ship Probability:0.092414141
truck Probability:0.008786337

 1: ### 10. confusion matrix
 2: import pandas as pd
 3: print(label_dict)
 4: pd.crosstab(y_label_test.reshape(-1),np.argmax(prediction, axis=1),
 5:             rownames=['label'],colnames=['predict'])
 6: ### 11. Save model to JSON
 7: model_json = model.to_json()
 8: with open("Downloads/cifarCnnModelnew.json", "w") as json_file:
 9:     json_file.write(model_json)
10: 
11: ### 12. Save Weight to h5
12: model.save_weights("Downloads/cifarCnnModelnew.h5")
13: print("Saved model to disk")

{0: 'airplane', 1: 'automobile', 2: 'bird', 3: 'cat', 4: 'deer', 5: 'dog', 6: 'frog', 7: 'horse', 8: 'ship', 9: 'truck'}
Saved model to disk

現在來看看另一組較複雜的數據資料，請你試著自己建個模型來預測這些詭異的資料…
請參考5，完成以下工作畫出Loss的折線圖來評估模型的優劣。

深度學習的基本特色是在它能自行在訓練資料中找到有趣的特徵，而不需要人為介入，但這只有在具備大量訓練樣本時才成立，特別是對於像圖片這類高維度(high-dimensional)的輸入樣本。所以也有人說深度學習一定要有大量資料才能進行。

然而樣本數與神經網路的大小與深度息息相關。只用幾十個樣本不可能訓練出可以解決複雜問題的卷積神經網路；相反的，如果只是要用來解決簡單任務，而且已經做好了 well-regularized 的小 model，那麼幾百個樣本或許就足夠了。因為卷積神經網路可以學習局部 pattern 且具平移不變性，所以在感知問題上具有高度的資料效率性。

此外，本質上，深度學習 model 是可高度再利用的。例如，使用大規模資料集訓練的影像 model 或語音轉文字的 model，只要進行小小的更改，便可以重新用於其他不同問題上。以電腦視覺的應用而言，許多預先訓練好的 model(通常是使用 Image-Net 資料集進行訓練)都是可公開下載的，以這些預先訓練好的 model 為基礎，再加以少量資料的訓練，就能產出更強大的 model。

Overfitting 的部份成因是由於樣本太少導致無法訓練出具備普適性、可套用到新資料的 model，想像一下如果有無限量的資料，則 model 將會因應用手邊資料的各種可能面向，也就不致於 overfitting。資料擴增(Data Augmentation)就是由現有訓練樣本生成更多訓練資料的方法，主要是透過隨機變換原始資料，以產生相似的影像，進而增加訓練樣本數。最終目標是在訓練時，model 不會看到兩次完全相同的影像。

在 Keras 中，我們可以藉由設定 ImageDataGenerator，在讀取影像時執行隨機變換(random transformation)來達到資料擴增，至於變換的方向則可以在 ImageDataGenerator 的參數中進一步指定。以下例來看：

1: datagen = ImageDataGenerator(
2:     rotation_range=40,       #旋轉角度值(0~180)
3:     width_shift_range=0.2,   #水平隨機平移(圖片寬度之百分比)
4:     height_shift_range=0.2,  #垂直隨機平移(圖片高度之百分比)
5:     shear_range=0.2,         #隨機傾斜(順時鐘傾斜角度)
6:     zoom_range=0.2,          #隨機縮放(縮放百分比)
7:     horizontal_flip=True,    #隨機水平翻轉(影像非左右對稱才有效)
8:     fill_mode='nearest')     #新建影像填補像素方法

上述程式之 fill__mode 共提供四種像素填補方法：

• constant: 依照輸入的 cval(浮點數或整數)將影像邊界之外都以該值填補，例如 cval=k，則影像填補為 kkkkkkkk|abcd|kkkkkkkk
  
• nearest: 以最接近的像素值填補，如：aaaaaaaa|abcd|dddddddd
  
• reflect: 以影像重複填補(影像以一正一反方向)，如 abcddcba|abcd|dcbaabcd
  
• wrap: 以影像重複填補，如：abcdabcd|abcd|abcdabcd
  

以下為實際運作的示範：

 1: import matplotlib
 2: import platform
 3: if platform.system() == 'Darwin':
 4:     matplotlib.use('MacOSX')
 5: else:
 6:     matplotlib.use('TkAgg')
 7: 
 8: from keras.preprocessing.image import ImageDataGenerator
 9: 
10: datagen = ImageDataGenerator(
11:     rotation_range=40,       #旋轉角度值(0~180)
12:     width_shift_range=0.2,   #水平隨機平移(圖片寬度之百分比)
13:     height_shift_range=0.2,  #垂直隨機平移(圖片高度之百分比)
14:     shear_range=0.2,         #隨機傾斜(順時鐘傾斜角度)
15:     zoom_range=0.2,          #隨機縮放(縮放百分比)
16:     horizontal_flip=True,    #隨機水平翻轉(影像非左右對稱才有效)
17:     fill_mode='nearest')     #新建影像填補像素方法
18: 
19: import os, shutil
20: 
21: # 解壓縮資料夾所在的目錄路徑(以訓練集中的貓為例)
22: train_cats_dir = os.path.join(train_dir, 'cats')
23: 
24: from keras.preprocessing import image
25: import numpy as np
26: 
27: fnames = [os.path.join(train_cats_dir, fname) for fname in os.listdir(train_cats_dir)]
28: 
29: img_path = fnames[3] #選一張影像來擴充
30: print(img_path)
31: 
32: #讀取影像、調整大小
33: img = image.load_img(img_path, target_size=(150, 150))
34: #將其調整為shape=(150, 150, 3)
35: x = image.img_to_array(img)
36: #調整shape為(1, 150, 150, 3)
37: x = x.reshape((1, ) + x.shape)
38: print(x.shape)
39: 
40: i = 0
41: # 繪製model的損失率與精確率
42: import matplotlib.pyplot as plt
43: 
44: for batch in datagen.flow(x, batch_size=1):
45:     plt.figure(i)
46:     #imgplot = plt.imshow(image.array_to_img(batch[0]))
47:     plt.imshow(image.array_to_img(batch[0]))
48:     #plt.clf()
49:     plt.plot()
50:     plt.savefig("CatsAugmentation"+str(i)+".png")
51:     i += 1
52:     if i % 4 == 0:
53:         break
54: #plt.show()
55: #plt.savefig("CatsAugmentation.png")

/Volumes/LaCie/data/cats_and_dogs_small/train/cats/cat.3.jpg
(1, 150, 150, 3)

雖然資料擴增能擴充來自少量的原始圖片，但終究無法自行產生資訊，只能重新混合現有資訊，影像間仍是高度相關，仍不足以完全擺脫 overfitting 問題，所以進一步在密集連接的分類器前，在 model 中增加 Dropout 層(Fatten 層後)。

  1: import matplotlib
  2: import platform
  3: if platform.system() == 'Darwin':
  4:     matplotlib.use('MacOSX')
  5: else:
  6:     matplotlib.use('TkAgg')
  7: 
  8: from keras.preprocessing.image import ImageDataGenerator
  9: 
 10: import os, shutil
 11: 
 12: # 解壓縮資料夾所在的目錄路徑
 13: # 參考原程式的路徑
 14: 
 15: # 分拆成訓練、驗證與測試目錄位置
 16: train_dir = os.path.join(base_dir, 'train')
 17: validation_dir = os.path.join(base_dir, 'validation')
 18: test_dir = os.path.join(base_dir, 'test')
 19: train_cats_dir = os.path.join(train_dir, 'cats')
 20: train_dogs_dir = os.path.join(train_dir, 'dogs')
 21: validation_cats_dir = os.path.join(validation_dir, 'cats')
 22: validation_dogs_dir = os.path.join(validation_dir, 'dogs')
 23: test_cats_dir = os.path.join(test_dir, 'cats')
 24: test_dogs_dir = os.path.join(test_dir, 'dogs')
 25: 
 26: # 建立模組
 27: from keras import layers
 28: from keras import models
 29: from keras import regularizers
 30: model = models.Sequential()
 31: model.add(layers.Conv2D(32, (3, 3), activation='relu',
 32:                         input_shape=(150, 150, 3)))
 33: model.add(layers.MaxPooling2D((2, 2)))
 34: model.add(layers.Conv2D(64, (3, 3), activation='relu'))
 35: model.add(layers.MaxPooling2D((2, 2)))
 36: model.add(layers.Conv2D(128, (3, 3), activation='relu'))
 37: model.add(layers.MaxPooling2D((2, 2)))
 38: model.add(layers.Conv2D(128, (3, 3), activation='relu'))
 39: model.add(layers.MaxPooling2D((2, 2)))
 40: model.add(layers.Flatten())
 41: model.add(layers.Dropout(0.5))
 42: model.add(layers.Dense(512, activation='relu'))
 43: model.add(layers.Dense(1, activation='sigmoid'))
 44: model.summary()  # 查看模型摘要
 45: 
 46: # 配置 model 以進行訓練
 47: from keras import optimizers
 48: 
 49: model.compile(loss='binary_crossentropy',
 50:               optimizer=optimizers.RMSprop(learning_rate=1e-4),
 51:               metrics=['acc'])
 52: 
 53: #資料擴增
 54: train_datagen = ImageDataGenerator(
 55:     rescale=1./255,
 56:     rotation_range=40,
 57:     width_shift_range=0.2,
 58:     height_shift_range=0.2,
 59:     shear_range=0.2,
 60:     zoom_range=0.2,
 61:     horizontal_flip=True, )
 62: 
 63: test_datagen = ImageDataGenerator(rescale=1./255) # 請注意！驗證資料不應該擴充!!!
 64: 
 65: train_generator = train_datagen.flow_from_directory(
 66:   train_dir,    # 目標目錄
 67:   target_size=(150, 150), # 所有圖像大小調整成 150×150
 68:   batch_size=32,
 69:   class_mode='binary') # 因為使用二元交叉熵 binary_crossentropy 作為損失，所以需要二元標籤
 70: 
 71: validation_generator = test_datagen.flow_from_directory(
 72:   validation_dir,
 73:   target_size=(150, 150),
 74:   batch_size=32,
 75:   class_mode='binary')
 76: 
 77: # 訓練
 78: history = model.fit_generator(
 79:   train_generator,
 80:   epochs=50, verbose=1,
 81:   validation_data=validation_generator,
 82:   validation_steps=1)
 83: 
 84: model.save('cats_and_dogs_small_data_augmentation.h5')
 85: 
 86: # 繪製model的損失率與精確率
 87: import matplotlib.pyplot as plt
 88: 
 89: acc = history.history['acc']
 90: val_acc = history.history['val_acc']
 91: loss = history.history['loss']
 92: val_loss = history.history['val_loss']
 93: 
 94: epochs = range(1, len(acc) + 1)
 95: plt.clf()
 96: plt.plot(epochs, acc, 'bo', label='Training acc')
 97: plt.plot(epochs, val_acc, 'b', label='Validation acc')
 98: plt.title('Training and validation accuracy')
 99: plt.legend()
100: plt.plot()
101: plt.savefig("CatsDogsDataAugmentation-acc.png")
102: plt.figure()
103: 
104: plt.clf()
105: plt.plot(epochs, loss, 'bo', label='Training loss')
106: plt.plot(epochs, val_loss, 'b', label='Validation loss')
107: plt.title('Training and validation loss')
108: plt.legend()
109: plt.plot()
110: plt.savefig("CatsDogsDataAugmentation-loss.png")

Model: "sequential_3"
_________________________________________________________________
 Layer (type)                Output Shape              Param #
=================================================================
 conv2d_12 (Conv2D)          (None, 148, 148, 32)      896

 max_pooling2d_12 (MaxPooli  (None, 74, 74, 32)        0
 ng2D)

 conv2d_13 (Conv2D)          (None, 72, 72, 64)        18496

 max_pooling2d_13 (MaxPooli  (None, 36, 36, 64)        0
 ng2D)

 conv2d_14 (Conv2D)          (None, 34, 34, 128)       73856

 max_pooling2d_14 (MaxPooli  (None, 17, 17, 128)       0
 ng2D)

 conv2d_15 (Conv2D)          (None, 15, 15, 128)       147584

 max_pooling2d_15 (MaxPooli  (None, 7, 7, 128)         0
 ng2D)

 flatten_3 (Flatten)         (None, 6272)              0

 dropout_2 (Dropout)         (None, 6272)              0

 dense_6 (Dense)             (None, 512)               3211776

 dense_7 (Dense)             (None, 1)                 513

=================================================================
Total params: 3453121 (13.17 MB)
Trainable params: 3453121 (13.17 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.RMSprop` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.RMSprop`.
Found 2000 images belonging to 2 classes.
Found 1000 images belonging to 2 classes.
Epoch 1/50
63/63 [==============================] - 19s 302ms/step - loss: 0.6926 - acc: 0.5030 - val_loss: 0.6853 - val_acc: 0.5312
Epoch 2/50
63/63 [==============================] - 19s 296ms/step - loss: 0.6916 - acc: 0.5195 - val_loss: 0.6850 - val_acc: 0.5625
...略...
Epoch 49/50
63/63 [==============================] - 30s 469ms/step - loss: 0.5058 - acc: 0.7555 - val_loss: 0.4970 - val_acc: 0.7188
Epoch 50/50
63/63 [==============================] - 29s 463ms/step - loss: 0.5037 - acc: 0.7535 - val_loss: 0.5148 - val_acc: 0.7188

由圖40和39可以發現，在加入了 data augmentation 和 dropout 後，訓練曲線與驗證曲線漸趨一致，不再 overfitting，model 的準確度也達到 84%。但值的一提的是: 同樣的資料集與演算法，在 Google colab 上以 GPU 執行的結果(下圖)與在本機執行(上圖)時並不相同。

在透過進一步 regularization 技術的使用，以及調整神經網路參數(如每個卷積層的過濾器數量、神經網路中的層數)，我們就能獲得更高的準確度(86%或 87%)，但在資料不及的情況下(如本例)，我們仍很難進一步提升準確度，此時，就要使用預先訓練 model。

Pretrained network，以簡單的話來說，就是「站在巨人的肩膀」⁹，所謂「巨人」，就是別人已經用 ImageNet 訓練好的模型，例如 Google 的 Inception Model、Microsoft 的 Resnet Model 等等，把它當作 Pre-trained Model，幫助我們提取出照片的特徵(feature)。順帶一提，所謂的 Transfer Learning 就是把 Pre-trained Model 最後一層拔掉 (註：最後一層是用來分類的)，加入新的一層，然後用新資料訓練新層的參數。

能夠用來被當成 pretrained netwrok 的 model 通常是擁有大量資料集的大規模圖片分類模型，如果這個原始資料集足夠大量且具通用性，那麼 pretrained network 學習的空間層次特徵(spartial hierarchy features)就足以充當視覺世界的通用 model，其特徵對於許多不同的電腦視覺問題都同樣有效，即便是要辨識與原始任務完全不同的類別也能通用。

例如，以 ImageNet 先訓練出一個神經網路(其辨識項目為日常生活用品)，然後重新訓練這個已訓練完成的神經網路，去識別和原始樣本天差地別的家具產品等。和許多淺層的神經網路相較，深度學習的關鍵優勢在於學習到的特徵可移植到不同問題上。

以下由 Karen Simonyan 和 Andrew Zisserman 於 2014 年開發的 VGG16 架構。使用 pretrain network 有兩種方式：特徵萃取(feature extraction)和徵調(fine-tuning)。

以下的工作主要是在給定輸入影像後，以圖形化的方式顯示卷積神經網路中各個卷積層和池化層輸出的特徵圖。讓我們能看到在CNN的學習過程中，輸入資料是如何經由逐層分解到不同的過濾器。雖然輸入資料為三個維度(width, height, channel)，但其實每個 channel 會針對相對獨立的特徵值(features)進行編碼，所以此處是將每個 channel 的內容獨立繪製成 2D 圖形秀出。

先載入之前儲存好的 model，取一張測試集中的照片(未經訓練過)，秀出原始內容，然後萃取出特徵圖，因為在這裡只是想看一張圖，所以要建新一個新的 Keras model。

1: from keras.models import load_model
2: 
3: # 加載保存的模型：
4: model = load_model('cats_and_dogs_small_i.h5')
5: model.summary()  # 打印模型

WARNING:absl:At this time, the v2.11+ optimizer `tf.keras.optimizers.RMSprop` runs slowly on M1/M2 Macs, please use the legacy Keras optimizer instead, located at `tf.keras.optimizers.legacy.RMSprop`.
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #
=================================================================
 conv2d (Conv2D)             (None, 148, 148, 32)      896

 max_pooling2d (MaxPooling2  (None, 74, 74, 32)        0
 D)

 conv2d_1 (Conv2D)           (None, 72, 72, 64)        18496

 max_pooling2d_1 (MaxPoolin  (None, 36, 36, 64)        0
 g2D)

 conv2d_2 (Conv2D)           (None, 34, 34, 128)       73856

 max_pooling2d_2 (MaxPoolin  (None, 17, 17, 128)       0
 g2D)

 conv2d_3 (Conv2D)           (None, 15, 15, 128)       147584

 max_pooling2d_3 (MaxPoolin  (None, 7, 7, 128)         0
 g2D)

 flatten (Flatten)           (None, 6272)              0

 dense (Dense)               (None, 512)               3211776

 dense_1 (Dense)             (None, 1)                 513

=================================================================
Total params: 3453121 (13.17 MB)
Trainable params: 3453121 (13.17 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

留意一下上述的summary()結果，第一層卷積層(conv2d)的輸出為32個channel所生成的148×148的特徵圖，等一下我們就從中間挑出一張來瞧瞧成果。

使用一個未被模型看過的圖像作為輸入(一個貓的圖片，它不是訓練集的一部分)：

 1: img_path = '/Volumes/LaCie/data/cats_and_dogs_small/test/cats/cat.1700.jpg'
 2: # 我們把圖像轉換成網絡要求的張量shape (4D 張量)
 3: # (樣本數, 圖像高度, 圖像寬度, 圖像通道)
 4: from keras.preprocessing import image
 5: import numpy as np
 6: 
 7: img = image.load_img(img_path, target_size=(150, 150)) # 載入圖像並轉換大小為150x150
 8: img_tensor = image.img_to_array(img) # 把影像物件轉換成 numpy ndarray物件
 9: 
10: print("Origin img_tensor shape: ", img_tensor.shape)
11: 
12: img_tensor = np.expand_dims(img_tensor, axis=0) # 多增加一個維度來符合Keras Conv2D的要求
13: 
14: print("After reshape img_tensor shape: ", img_tensor.shape)
15: 
16: # 這個模型的輸入是有經過歸一化的前處理
17: # 所以我們也要進行相同的前處理
18: img_tensor /= 255. # 進行資料尺度(scale)的轉換

Origin img_tensor shape:  (150, 150, 3)
After reshape img_tensor shape:  (1, 150, 150, 3)

這張測試集照片的原圖如下:

因為原始模型的目的並不是要讓使用者查看每一層的輸出結果，為了讓我們能強力介入每一層去看出各層的輸出，我們要建立一個新的模型，只以一張圖(圖49)做為輸入，並輸出所有經過卷積層和池化層的激勵輸出結果。

這個模型需要兩個參數：輸入張量（或輸入張量列表）以及輸出張量（或輸出張量列表）。所得到的類別是一個Keras模型(model)物件，就如同我們之前所建立的Sequential模型，但是這個Model類別允許具有多個輸出的模型，這是與之前我們建立的Sequential最大的不同。

1: from keras import models
2: 
3: # 創建一個list來儲存前8層處理後的outputs
4: layer_outputs = [layer.output for layer in model.layers[:8]]
5: 
6: # 產生一個model物件, 它的input是原先模型的input, 而它的output則是前8層處理後的outputs
7: activation_model = models.Model(inputs=model.input, outputs=layer_outputs)
8: 
9: print(layer_outputs) # 看一下物件的結構

[<KerasTensor: shape=(None, 148, 148, 32) dtype=float32 (created by layer 'conv2d')>,
<KerasTensor: shape=(None, 74, 74, 32) dtype=float32 (created by layer 'max_pooling2d')>,
<KerasTensor: shape=(None, 72, 72, 64) dtype=float32 (created by layer 'conv2d_1')>,
<KerasTensor: shape=(None, 36, 36, 64) dtype=float32 (created by layer 'max_pooling2d_1')>,
<KerasTensor: shape=(None, 34, 34, 128) dtype=float32 (created by layer 'conv2d_2')>,
<KerasTensor: shape=(None, 17, 17, 128) dtype=float32 (created by layer 'max_pooling2d_2')>,
<KerasTensor: shape=(None, 15, 15, 128) dtype=float32 (created by layer 'conv2d_3')>,
<KerasTensor: shape=(None, 7, 7, 128) dtype=float32 (created by layer 'max_pooling2d_3')>]

當我們將圖像餵進這個模型時，此模型會傳回原始模型中特定層被激勵函數處理過後的值，這個模型只有1個輸入、8個輸出，每一層的激勵函數輸出結果變成一個輸出。

1: # 透過model.predict()的處理, model將會回傳一個有8個神經層處理後的output的列表:
2: activations = activation_model.predict(img_tensor)
3: 
4: print(len(activations)) # 讓我們確認一下產生的數量

1/1 [==============================] - 0s 17ms/step
8

以下是我們的貓圖(如圖49)經過CNN後的第一個卷積層在經過的激勵函數轉換
後的輸出：

1: first_layer_activation = activations[0]
2: print(first_layer_activation.shape) # 看一下第一層產生的shape

(1, 148, 148, 32)

這是一個具有32個channel的148x148特徵圖(feature map)。

現在，我們來輸出這個CNN模型中每一層輪出的完整樣貌，我們從中提取、繪製每8個特徵圖(feature maps)中的通道，並將結果以類似matplotlib的subplot()呈現出來。

 1: import keras
 2: 
 3: # 輸出每一層的神經層名稱
 4: layer_names = []
 5: for layer in model.layers[:8]:
 6:     layer_names.append(layer.name)
 7: 
 8: images_per_row = 16 # 每一排輸出16個特徵圖
 9: 
10: # 每一層特徵圖的Shapes
11: # layer#01 -> (148, 148, 32)
12: # layer#02 -> (74, 74, 32)
13: # layer#03 -> (72, 72, 64)
14: # layer#04 -> (36, 36, 64)
15: # layer#05 -> (34, 34, 128)
16: # layer#06 -> (17, 17, 128)
17: # layer#07 -> (15, 15, 128)
18: # layer#08 -> (7, 7, 128)
19: 
20: # 輸出特徵圖
21: for layer_name, layer_activation in zip(layer_names, activations): # 我們有8層的神經元的輸出
22:     n_features = layer_activation.shape[-1] # 取得每一層特徵圖的數量
23:     size = layer_activation.shape[1] # 取得每一個特徵圖的寬與高 (1, size, size, n_features)
24: 
25:     # 我們會把多個特徵圖串接在一個比較大的矩陣
26:     n_cols = n_features // images_per_row # 算一下這個大矩陣的會有幾欄
27:     display_grid = np.zeros((size * n_cols, images_per_row * size)) # 產生一個大矩陣
28: 
29:     # 模擬matpolotlib subplot()效果
30:     for col in range(n_cols):
31:         for row in range(images_per_row):
32:             channel_image = layer_activation[0, :, :, col * images_per_row + row]
33:             # Post-process the feature to make it visually palatable
34:             channel_image -= channel_image.mean()
35:             channel_image /= channel_image.std()
36:             channel_image *= 64
37:             channel_image += 128
38:             channel_image = np.clip(channel_image, 0, 255).astype('uint8')
39:             display_grid[col * size : (col + 1) * size,
40:                          row * size : (row + 1) * size] = channel_image
41: 
42:     # 展示拼貼出來的結果
43:     scale = 1. / size
44:     plt.figure(figsize=(scale * display_grid.shape[1],
45:                         scale * display_grid.shape[0]))
46:     plt.title(layer_name)
47:     plt.grid(False)
48:     fn = layer_name+".png"
49:     plt.imshow(display_grid, aspect='auto', cmap='viridis')
50:     plt.savefig('images/'+fn, dpi=300)
51: #plt.show()

由上圖可知，隨層數越來越高，啟動函數的輸出變得越來越抽象，視覺上也越來越難解釋，model 開始編碼出更高階的概念。此外，啟動函數輸出的稀疏性也隨著層數的深度而增加，在第一層中，所有的過濾器都被輸入影響所驅動(都有值)，但接下來就有越來越多的 filter 的值是空的(全黑)，這表示在這些層的輸入影像中已經找不到過濾器要編碼的圖案 pattern 了。

上述示例也證明了深度神經網路所學習到的表示法有一個重要特性：各層萃取的特徵隨著層的𣶶度而變的越來越抽象，越高階的啟動函數越不會帶有關於特定輸入的資訊，卻具備更多關於目標的資訊（此例中指的是貓或狗）。這和人或動物感知世界的方式很像：在觀察一個場景幾秒中後閉眼，我們可以記得場景中有哪些抽象事物，但不會記得每個物體的特殊外觀，因為大腦也會將事物抽象化。