現在讓我們裝載 Keras 和它的依賴包吧：

import keras 
from keras.preprocessing.image import ImageDataGenerator 
from keras_tqdm import TQDMNotebookCallback 
from keras.models import Sequential 
from keras.layers import Dense 
from keras.layers import Dropout 
from keras.layers import Flatten 
from keras.constraints import maxnorm 
from keras.optimizers import SGD 
from keras.layers.convolutional import Conv2D 
from keras.layers.convolutional import MaxPooling2D 
from keras.utils import np_utils 
from keras.callbacks import Callback 

圖像生成器和數據增強

在訓練模型時，我們不會將整個數據集裝載進內存，因為這種做法并不高效，特別是你使用的還是你自己本地的機器。

我們將用到 ImageDataGenerator 類，這個類可以***制地從訓練集和測試集中批量地引入圖像流。在ImageDataGenerator 類中，我們將在每個批次引入隨機修改。

這個過程我們稱之為數據增強（dataaugmentation)。它可以生成更多的圖片使得我們的模型不會看見兩張完全相同的圖片。這種方法可以防止過擬合，也有助于模型保持更好的泛化性。

我們要創(chuàng)建兩個 ImageDataGenerator 對象。train_datagen 對應訓練集，val_datagen 對應測試集，兩者都會對圖像進行縮放，train_datagen 還將做一些其他的修改。

batch_size = 32 
 
train_datagen = ImageDataGenerator(rescale=1/255., 
shear_range=0.2, 
zoom_range=0.2, 
horizontal_flip=True 
) 
val_datagen = ImageDataGenerator(rescale=1/255.) 

基于前面的兩個對象，我們接著創(chuàng)建兩個文件生成器：

• train_generator
• validation_generator

每個生成器在實時數據增強的作用下，在目錄處可以生成批量的圖像數據。這樣，數據將會***制地循環(huán)生成。

train_generator = train_datagen.flow_from_directory( 
'./data/train/', 
target_size=(150, 150), 
batch_size=batch_size, 
class_mode='categorical') 
 
validation_generator = val_datagen.flow_from_directory( 
'./data/validation/', 
target_size=(150, 150), 
batch_size=batch_size, 
class_mode='categorical') 
 
##Found 20000 images belonging to 2 classes. 
##Found 5000 images belonging to 2 classes. 

模型結構

我將使用擁有 3 個卷積/池化層和 2 個全連接層的 CNN。3 個卷積層將分別使用 32，32，64 的 3 * 3的濾波器（fiter）。在兩個全連接層，我使用了 dropout 來避免過擬合。

model = Sequential() 
 
model.add(Conv2D(32, (3, 3), input_shape=(150, 150, 3), padding='same', activation='relu')) 
model.add(MaxPooling2D(pool_size=(2, 2))) 
 
model.add(Conv2D(32, (3, 3), padding='same', activation='relu')) 
model.add(MaxPooling2D(pool_size=(2, 2))) 
 
model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) 
model.add(MaxPooling2D(pool_size=(2, 2))) 
 
model.add(Dropout(0.25)) 
model.add(Flatten()) 
model.add(Dense(64, activation='relu')) 
model.add(Dropout(0.5)) 
model.add(Dense(2, activation='softmax')) 

我使用隨機梯度下降法進行優(yōu)化，參數 learning rate 為 0.01，momentum 為 0.9。

epochs = 50 
lrate = 0.01 
decay = lrate/epochs 
sgd = SGD(lr=lrate, momentum=0.9, decay=decay, nesterov=False) 
model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy']) 

Keras 提供了一個非常方便的方法來展示模型的全貌。對每一層，我們可以看到輸出的形狀和可訓練參數的個數。在開始擬合模型前，檢查一下是個明智的選擇。

model.summary()

下面讓我們看一下網絡的結構。

結構可視化

在訓練模型前，我定義了兩個將在訓練時調用的回調函數 (callback function)：

• 一個用于在損失函數無法改進在測試數據的效果時，提前停止訓練。
• 一個用于存儲每個時期的損失和精確度指標：這可以用來繪制訓練錯誤圖表。

## Callback for loss logging per epoch 
class LossHistory(Callback): 
def on_train_begin(self, logs={}): 
self.losses = [] 
self.val_losses = [] 
 
def on_epoch_end(self, batch, logs={}): 
self.losses.append(logs.get('loss')) 
self.val_losses.append(logs.get('val_loss')) 
 
history = LossHistory() 
 
## Callback for early stopping the training 
early_stopping = keras.callbacks.EarlyStopping(monitor='val_loss', 
min_delta=0, 
patience=2, 
verbose=0, mode='auto') 

我還使用了 keras-tqdm，這是一個和 keras ***整合的非常棒的進度條。它可以讓我們非常容易地監(jiān)視模型的訓練過程。

要想使用它，你僅需要從 keras_tqdm 中加載 TQDMNotebookCallback 類，然后將它作為第三個回調函數傳遞進去。

下面的圖在一個簡單的樣例上展示了 keras-tqdm 的效果。

關于訓練過程，還有幾點要說的：

• 我們使用 fit_generator 方法，它是一個將生成器作為輸入的變體（標準擬合方法）。
• 我們訓練模型的時間超過 50 個 epoch。

fitted_model = model.fit_generator( 
train_generator, 
steps_per_epoch= int(n * (1-ratio)) // batch_size, 
epochs=50, 
validation_data=validation_generator, 
validation_steps= int(n * ratio) // batch_size, 
callbacks=[TQDMNotebookCallback(leave_inner=True, leave_outer=True), early_stopping, history], 
verbose=0) 

這個模型運行時的計算量非常大：

• 如果你在自己的電腦上跑，每個 epoch 會花費 15 分鐘的時間。
• 如果你和我一樣在 EC2 上的 p2.xlarge 虛擬機上跑，每個 epoch 需要花費 2 分鐘的時間。

分類結果

我們在模型運行 34 個 epoch 后達到了 89.4% 的準確率（下文展示訓練/測試錯誤和準確率），考慮到我沒有花費很多時間來設計網絡結構，這已經是一個很好的結果了?，F在我們可以將模型保存，以備以后使用。

model.save(`./models/model4.h5)

下面我們在同一張圖上繪制訓練和測試中的損失指標值：

losses, val_losses = history.losses, history.val_losses 
fig = plt.figure(figsize=(15, 5)) 
plt.plot(fitted_model.history['loss'], 'g', label="train losses") 
plt.plot(fitted_model.history['val_loss'], 'r', label="val losses") 
plt.grid(True) 
plt.title('Training loss vs. Validation loss') 
plt.xlabel('Epochs') 
plt.ylabel('Loss') 
plt.legend() 

當在兩個連續(xù)的 epoch 中，測試損失值沒有改善時，我們就中止訓練過程。

下面繪制訓練集和測試集上的準確度。

losses, val_losses = history.losses, history.val_losses 
fig = plt.figure(figsize=(15, 5)) 
plt.plot(fitted_model.history['acc'], 'g', label="accuracy on train set") 
plt.plot(fitted_model.history['val_acc'], 'r', label="accuracy on validation set") 
plt.grid(True) 
plt.title('Training Accuracy vs. Validation Accuracy') 
plt.xlabel('Epochs') 
plt.ylabel('Loss') 
plt.legend() 

這兩個指標一直是增長的，直到模型即將開始過擬合的平穩(wěn)期。

裝載預訓練的模型

我們在自己設計的 CNN 上取得了不錯的結果，但還有一種方法能讓我們取得更高的分數：直接載入一個在大型數據集上預訓練過的卷積神經網絡的權重，這個大型數據集包含 1000 個種類的貓和狗的圖片。

這樣的網絡會學習到與我們分類任務相關的特征。

我將加載 VGG16 網絡的權重，具體來說，我要將網絡權重加載到所有的卷積層。這個網絡部分將作為一個特征檢測器來檢測我們將要添加到全連接層的特征。

與 LeNet5 相比，VGG16 是一個非常大的網絡，它有 16 個可以訓練權重的層和 1.4 億個參數。要了解有關 VGG16 的信息，請參閱此篇 pdf 鏈接:https://arxiv.org/pdf/1409.1556.pdf

from keras import applications 
# include_top: whether to include the 3 fully-connected layers at the top of the network. 
model = applications.VGG16(include_top=False, weights='imagenet') 
datagen = ImageDataGenerator(rescale=1. / 255) 

現在我們將圖像傳進網絡來得到特征表示，這些特征表示將會作為神經網絡分類器的輸入。

generator = datagen.flow_from_directory('./data/train/', 
target_size=(150, 150), 
batch_size=batch_size, 
class_mode=None, 
shuffle=False) 
bottleneck_features_train = model.predict_generator(generator, int(n * (1 - ratio)) // batch_size) 
np.save(open('./features/bottleneck_features_train.npy', 'wb'), bottleneck_features_train) 
##Found 20000 images belonging to 2 classes. 
generator = datagen.flow_from_directory('./data/validation/', 
target_size=(150, 150), 
batch_size=batch_size, 
class_mode=None, 
shuffle=False) 
bottleneck_features_validation = model.predict_generator(generator, int(n * ratio) // batch_size,) 
np.save('./features/bottleneck_features_validation.npy', bottleneck_features_validation) 
##Found 5000 images belonging to 2 classes. 

圖像在傳遞到網絡中時是有序傳遞的，所以我們可以很容易地為每張圖片關聯上標簽。

train_data = np.load('./features/bottleneck_features_train.npy') 
train_labels = np.array([0] * (int((1-ratio) * n) // 2) + [1] * (int((1 - ratio) * n) // 2)) 
validation_data = np.load('./features/bottleneck_features_validation.npy') 
validation_labels = np.array([0] * (int(ratio * n) // 2) + [1] * (int(ratio * n) // 2)) 

現在我們設計了一個小型的全連接神經網絡，附加上從 VGG16 中抽取到的特征，我們將它作為 CNN 的分類部分。

model = Sequential() 
model.add(Flatten(input_shape=train_data.shape[1:])) 
model.add(Dense(512, activation='relu')) 
model.add(Dropout(0.5)) 
model.add(Dense(256, activation='relu')) 
model.add(Dropout(0.2)) 
model.add(Dense(1, activation='sigmoid')) 
model.compile(optimizer='rmsprop', 
loss='binary_crossentropy', metrics=['accuracy']) 
fitted_model = model.fit(train_data, train_labels, 
epochs=15, 
batch_size=batch_size, 
validation_data=(validation_data, validation_labels[:validation_data.shape[0]]), 
verbose=0, 
callbacks=[TQDMNotebookCallback(leave_inner=True, leave_outer=False), history]) 

在 15 個 epoch 后，模型就達到了 90.7% 的準確度。這個結果已經很好了，注意現在每個 epoch 在我自己的電腦上跑也僅需 1 分鐘。

fig = plt.figure(figsize=(15, 5)) 
plt.plot(fitted_model.history['loss'], 'g', label="train losses") 
plt.plot(fitted_model.history['val_loss'], 'r', label="val losses") 
plt.grid(True) 
plt.title('Training loss vs. Validation loss - VGG16') 
plt.xlabel('Epochs') 
plt.ylabel('Loss') 
plt.legend() 

fig = plt.figure(figsize=(15, 5)) 
plt.plot(fitted_model.history['acc'], 'g', label="accuracy on train set") 
plt.plot(fitted_model.history['val_acc'], 'r', label="accuracy on validation sete") 
plt.grid(True) 
plt.title('Training Accuracy vs. Validation Accuracy - VGG16') 
plt.xlabel('Epochs') 
plt.ylabel('Loss') 
plt.legend() 

許多深度學習領域的大牛人物都鼓勵大家在做分類任務時使用預訓練網絡，實際上，預訓練網絡通常使用的是在一個非常大的數據集上生成的非常大的網絡。

而 Keras 可以讓我們很輕易地下載像 VGG16、GoogleNet、ResNet 這樣的預訓練網絡。想要了解更多關于這方面的信息，請參考這里：https://keras.io/applications/

有一句很棒的格言是：不要成為英雄！不要重復發(fā)明輪子！使用預訓練網絡吧！

接下來還可以做什么？

如果你對改進一個傳統(tǒng) CNN 感興趣的話，你可以：

• 在數據集層面上，引入更多增強數據。
• 研究一下網絡超參數（network hyperparameter)：卷積層的個數、濾波器的個數和大小，在每種組合后要測試一下效果。
• 改變優(yōu)化方法。
• 嘗試不同的損失函數。
• 使用更多的全連接層。
• 引入更多的 aggressive dropout。

如果你對使用預訓練網絡獲得更好的分類結果感興趣的話，你可以嘗試：

• 使用不同的網絡結構。
• 使用更多包含更多隱藏單元的全連接層。

如果你想知道 CNN 這個深度學習模型到底學習到了什么東西，你可以：

• 將 feature maps 可視化。
• 可以參考：https://arxiv.org/pdf/1311.2901.pdf

如果你想使用訓練過的模型：

• 可以將模型放到 Web APP 上，使用新的貓和狗的圖像來進行測試。這也是一個很好地測試模型泛化性的好方法。

總結

這是一篇手把手教你在 AWS 上搭建深度學習環(huán)境的教程，并且教你怎樣從頭開始建立一個端到端的模型，另外本文也教了你怎樣基于一個預訓練的網絡來搭建一個 CNN 模型。

用 Python 來做深度學習是讓人愉悅的事情，而 Keras 讓數據的預處理和網絡層的搭建變得更加簡單。

如果有一天你需要按自己的想法來搭建一個神經網絡，你可能需要用到其他的深度學習框架。

現在在自然語言處理領域，也有很多人開始使用卷積神經網絡了，下面是一些基于此的工作：

使用了 CNN 的文本分類：

https://chara.cs.illinois.edu/sites/sp16-cs591txt/files/0226-presentation.pdf

自動為圖像生成標題：

https://cs.stanford.edu/people/karpathy/sfmltalk.pdf

字級別的文本分類：

https://papers.nips.cc/paper/5782-character-level-convolutional-networks-fortext-classification.pdf

【51CTO原創(chuàng)稿件，合作站點轉載請注明原文作者和出處為51CTO.com】