吳恩達老師深度學習課程Course4卷積神經網絡-第二周課后作業

本文參考文章https://blog.csdn.net/u013733326/article/details/80250818完成，原文寫的非常好，非常詳細，如果是第一次做這個作業的同學可以去看一下這個作者的文章，非常推薦。

本次作業的內容有兩項，一是框架Keras的入門練習，二是搭建一個殘差網絡。下面開始第一項任務。

1 Keras入門 - 笑臉識別

Keras框架是一個高級的神經網絡的框架，能夠運行在包括TensorFlow和CNTK的幾個較低級別的框架之上的框架。通過引入所需要的庫可以實現從Keras中導入很多功能， 只需直接調用它們即可輕松使用它們。 比如：X = Input(…) 或者X = ZeroPadding2D(…)。

import numpy as np
from keras import layers
from keras.layers import Input, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D
from keras.layers import AveragePooling2D, MaxPooling2D, Dropout, GlobalMaxPooling2D, GlobalAveragePooling2D
from keras.models import Model
from keras.preprocessing import image
from keras.utils import layer_utils
from keras.utils.data_utils import get_file
from keras.applications.imagenet_utils import preprocess_input
import pydot
from IPython.display import SVG
from keras.utils.vis_utils import model_to_dot
from keras.utils import plot_model
import kt_utils 

import keras.backend as K
K.set_image_data_format('channels_last')
import matplotlib.pyplot as plt
from matplotlib.pyplot import imshow

1.1 任務描述

此次項目實現的功能就是識別圖片中的人是否是笑臉，來判斷人物是否開心，下面是我們的數據集：

我們先來加載一下我們的數據：

X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = kt_utils.load_dataset()

# Normalize image vectors
X_train = X_train_orig/255.
X_test = X_test_orig/255.

# Reshape
Y_train = Y_train_orig.T
Y_test = Y_test_orig.T
print ("number of training examples = " + str(X_train.shape[0]))
print ("number of test examples = " + str(X_test.shape[0]))
print ("X_train shape: " + str(X_train.shape))
print ("Y_train shape: " + str(Y_train.shape))
print ("X_test shape: " + str(X_test.shape))
print ("Y_test shape: " + str(Y_test.shape))

可以看到圖片的維度是64*64*3，訓練集有600張，測試集有150張。

1.2 構建模型

接下來我們利用Keras框架構建出來我們要的模型：

def HappyModel(input_shape):
    """
    實現一個檢測笑容的模型

    參數：
        input_shape - 輸入的數據的維度
    返回：
        model - 創建的Keras的模型

    """

    # 你可以參考和上面的大綱
    X_input = Input(input_shape)

    # 使用0填充：X_input的周圍填充0
    X = ZeroPadding2D((3, 3))(X_input)

    # 對X使用 CONV -> BN -> RELU 塊
    X = Conv2D(32, (7, 7), strides=(1, 1), name='conv0')(X)
    X = BatchNormalization(axis=3, name='bn0')(X)
    X = Activation('relu')(X)

    # 最大值池化層
    X = MaxPooling2D((2, 2), name='max_pool')(X)

    # 降維，矩陣轉化為向量 + 全連接層
    X = Flatten()(X)
    X = Dense(1, activation='sigmoid', name='fc')(X)

    # 創建模型，講話創建一個模型的實體，我們可以用它來訓練、測試。
    model = Model(inputs=X_input, outputs=X, name='HappyModel')

    return model

可以看到用Keras框架實現的模型非常簡單，因為框架為我們提供了比如填充、卷積操作等函數，我們只需要用一行代碼調用一下就行，並且只需要完成前向傳播，所以看起來很方便。

現在我們已經設計好了我們的模型了，要訓練並測試模型我們需要這么做：

1. 創建一個模型實體。
2. 編譯模型，可以使用這個語句：model.compile(optimizer = "...", loss = "...", metrics = ["accuracy"])。
3. 訓練模型：model.fit(x = ..., y = ..., epochs = ..., batch_size = ...)。
4. 評估模型：model.evaluate(x = ..., y = ...)。

接下來我們運行這些步驟：

#創建一個模型實體
happy_model = HappyModel(X_train.shape[1:])
#編譯模型
happy_model.compile("adam","binary_crossentropy", metrics=['accuracy'])
#訓練模型
#請注意，此操作會花費你大約6-10分鍾。
happy_model.fit(X_train, Y_train, epochs=40, batch_size=50)
#評估模型
preds = happy_model.evaluate(X_test, Y_test, batch_size=32, verbose=1, sample_weight=None)
print ("誤差值 = " + str(preds[0]))
print ("准確度 = " + str(preds[1]))

下面是我的運行結果：

以上就是用Keras搭建的卷積神經網絡框架，Keras框架還是很強的，應該仔細的學一下，另外，在搭建項目之前遇到了版本對應的錯誤，因為Keras框架運行於TensorFlow之上，所以會用到這兩種框架，我安裝的TensorFlow是1.5版本的，默認安裝的Keras框架是最新版本2.4多的，所以這兩框架不匹配，大家在實現之前可以先看一下自己的TensorFlow框架的版本，在網上查一下匹配版本對應，再安裝對應版本的Keras。

2 殘差網絡的搭建

第二項作業是搭建殘差網絡，殘差網絡一般深度都很大，利用殘差網絡可以解決過深的網絡難以訓練的問題。此次作業實現兩部分：一是實現殘差塊，二是把這些殘差塊放一起，實現並訓練用於圖像分類的網絡。首先是用到的庫函數。

import numpy as np
import tensorflow as tf

from keras import layers
from keras.layers import Input, Add, Dense, Activation, ZeroPadding2D, BatchNormalization, Flatten, Conv2D, AveragePooling2D, MaxPooling2D, GlobalMaxPooling2D
from keras.models import Model, load_model
from keras.preprocessing import image
from keras.utils import layer_utils
from keras.utils.data_utils import get_file
from keras.applications.imagenet_utils import preprocess_input
from keras.utils.vis_utils import model_to_dot
from keras.utils import plot_model
from keras.initializers import glorot_uniform

import pydot
from IPython.display import SVG
import scipy.misc
from matplotlib.pyplot import imshow
import keras.backend as K
K.set_image_data_format('channels_last')
K.set_learning_phase(1)

import resnets_utils    

2.1 構建一個殘差網絡

在殘差網絡中，一個“捷徑（shortcut）”或者說“跳躍連接（skip connection）”允許梯度直接反向傳播到更淺的層，如下圖：

圖像左邊是神經網絡的主路，圖像右邊是添加了一條捷徑的主路，通過這些殘差塊堆疊在一起，可以形成一個非常深的網絡。

我們在視頻中可以看到使用捷徑的方式使得每一個殘差塊能夠很容易學習到恆等式功能，這意味着我們可以添加很多的殘差塊而不會損害訓練集的表現。

殘差塊有兩種類型，主要取決於輸入輸出的維度是否相同

2.1.1 恆等塊（Identity block）

恆等塊是殘差網絡使用的的標准塊，對應於輸入的激活值（比如）與輸出激活值（比如）具有相同的維度。為了具象化殘差塊的不同步驟，我們來看看下面的圖吧~

上圖就是一個恆等塊，大家可以看一下原文作者對於恆等塊的介紹，要實現這個恆等塊不僅要實現主路徑的內容，還要把這條捷徑表示出來。具體步驟如下：

1. 主路徑的第一部分：

   • 第一個CONV2D有F1個過濾器，其大小為（1，1），步長為（1，1），使用填充方式為“valid”，命名規則為conv_name_base + '2a'，使用0作為隨機種子為其初始化。

   • 第一個BatchNorm是通道的軸歸一化，其命名規則為bn_name_base + '2a'。

   • 接着使用ReLU激活函數，它沒有命名也沒有超參數。

2. 主路徑的第二部分：

   • 第二個CONV2D有F2​個過濾器，其大小為（f，f），步長為（1，1），使用填充方式為“same”，命名規則為conv_name_base + '2b'，使用0作為隨機種子為其初始化。

   • 第二個BatchNorm是通道的軸歸一化，其命名規則為bn_name_base + '2b'。

   • 接着使用ReLU激活函數，它沒有命名也沒有超參數。

3. 主路徑的第三部分：

   • 第三個CONV2D有F3個過濾器，其大小為（1，1），步長為（1，1），使用填充方式為“valid”，命名規則為conv_name_base + '2c'，使用0作為隨機種子為其初始化。

   • 第三個BatchNorm是通道的軸歸一化，其命名規則為bn_name_base + '2c'。

   • 注意這里沒有ReLU函數

4. 最后一步：

   • 將捷徑與輸入加在一起

   • 使用ReLU激活函數，它沒有命名也沒有超參數。

接下來我們就要代碼實現殘差網絡的恆等塊了，在實現之前，我們可以先看看Keras框架的中文使用手冊：https://keras-cn.readthedocs.io/en/latest/layers/convolutional_layer/#conv2d

def identity_block(X, f, filters, stage, block):
    """
    實現圖3的恆等塊
    
    參數：
        X - 輸入的tensor類型的數據，維度為( m, n_H_prev, n_W_prev, n_H_prev )
        f - 整數，指定主路徑中間的CONV窗口的維度
        filters - 整數列表，定義了主路徑每層的卷積層的過濾器數量
        stage - 整數，根據每層的位置來命名每一層，與block參數一起使用。
        block - 字符串，據每層的位置來命名每一層，與stage參數一起使用。
        
    返回：
        X - 恆等塊的輸出，tensor類型，維度為(n_H, n_W, n_C)
    
    """
    
    #定義命名規則
    conv_name_base = "res" + str(stage) + block + "_branch"
    bn_name_base   = "bn"  + str(stage) + block + "_branch"
    
    #獲取過濾器
    F1, F2, F3 = filters
    
    #保存輸入數據，將會用於為主路徑添加捷徑
    X_shortcut = X
    
    #主路徑的第一部分
    ##卷積層
    X = Conv2D(filters=F1, kernel_size=(1,1), strides=(1,1) ,padding="valid",
               name=conv_name_base+"2a", kernel_initializer=glorot_uniform(seed=0))(X)
    ##歸一化
    X = BatchNormalization(axis=3,name=bn_name_base+"2a")(X)
    ##使用ReLU激活函數
    X = Activation("relu")(X)
    
    #主路徑的第二部分
    ##卷積層
    X = Conv2D(filters=F2, kernel_size=(f,f),strides=(1,1), padding="same",
               name=conv_name_base+"2b", kernel_initializer=glorot_uniform(seed=0))(X)
    ##歸一化
    X = BatchNormalization(axis=3,name=bn_name_base+"2b")(X)
    ##使用ReLU激活函數
    X = Activation("relu")(X)
    
    
    #主路徑的第三部分
    ##卷積層
    X = Conv2D(filters=F3, kernel_size=(1,1), strides=(1,1), padding="valid",
               name=conv_name_base+"2c", kernel_initializer=glorot_uniform(seed=0))(X)
    ##歸一化
    X = BatchNormalization(axis=3,name=bn_name_base+"2c")(X)
    ##沒有ReLU激活函數
    
    #最后一步：
    ##將捷徑與輸入加在一起
    X = Add()([X,X_shortcut])
    ##使用ReLU激活函數
    X = Activation("relu")(X)
    
    return X

2.1.2 卷積塊

我們已經實現了殘差網絡的恆等塊，現在，殘差網絡的卷積塊是另一種類型的殘差塊，它適用於輸入輸出的維度不一致的情況，它不同於上面的恆等塊，與之區別在於，捷徑中有一個CONV2D層，如下圖：

捷徑中的卷積層將把輸入x卷積為不同的維度，因此在主路徑最后那里需要適配捷徑中的維度。比如：把激活值中的寬高減少2倍，我們可以使用1x1的卷積，步伐為2。捷徑上的卷積層不使用任何非線性激活函數，它的主要作用是僅僅應用（學習后的）線性函數來減少輸入的維度，以便在后面的加法步驟中的維度相匹配。

具體步驟如下：

1. 主路徑第一部分：

   • 第一個卷積層有F1個過濾器，其維度為（1，1），步伐為（s，s），使用“valid”的填充方式，命名規則為conv_name_base + '2a'

   • 第一個規范層是通道的軸歸一化，其命名規則為bn_name_base + '2a'

   • 使用ReLU激活函數，它沒有命名規則也沒有超參數。

2. 主路徑第二部分：

   • 第二個卷積層有F2個過濾器，其維度為（f，f），步伐為（1，1），使用“same”的填充方式，命名規則為conv_name_base + '2b'

   • 第二個規范層是通道的軸歸一化，其命名規則為bn_name_base + '2b'

   • 使用ReLU激活函數，它沒有命名規則也沒有超參數。

3. 主路徑第三部分：

   • 第三個卷積層有F3個過濾器，其維度為（1，1），步伐為（s，s），使用“valid”的填充方式，命名規則為conv_name_base + '2c'

   • 第三個規范層是通道的軸歸一化，其命名規則為bn_name_base + '2c'

   • 沒有激活函數

4. 捷徑：

   • 此卷積層有F3個過濾器，其維度為（1，1），步伐為（s，s），使用“valid”的填充方式，命名規則為conv_name_base + '1'

   • 此規范層是通道的軸歸一化，其命名規則為bn_name_base + '1'

5. 最后一步：

   • 將捷徑與輸入加在一起

   • 使用ReLU激活函數

下面是實現代碼：

def convolutional_block(X, f, filters, stage, block, s=2):
    """
    實現圖5的卷積塊
    
    參數：
        X - 輸入的tensor類型的變量，維度為( m, n_H_prev, n_W_prev, n_C_prev)
        f - 整數，指定主路徑中間的CONV窗口的維度
        filters - 整數列表，定義了主路徑每層的卷積層的過濾器數量
        stage - 整數，根據每層的位置來命名每一層，與block參數一起使用。
        block - 字符串，據每層的位置來命名每一層，與stage參數一起使用。
        s - 整數，指定要使用的步幅
    
    返回：
        X - 卷積塊的輸出，tensor類型，維度為(n_H, n_W, n_C)
    """
    
    #定義命名規則
    conv_name_base = "res" + str(stage) + block + "_branch"
    bn_name_base   = "bn"  + str(stage) + block + "_branch"
    
    #獲取過濾器數量
    F1, F2, F3 = filters
    
    #保存輸入數據
    X_shortcut = X
    
    #主路徑
    ##主路徑第一部分
    X = Conv2D(filters=F1, kernel_size=(1,1), strides=(s,s), padding="valid",
               name=conv_name_base+"2a", kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3,name=bn_name_base+"2a")(X)
    X = Activation("relu")(X)
    
    ##主路徑第二部分
    X = Conv2D(filters=F2, kernel_size=(f,f), strides=(1,1), padding="same",
               name=conv_name_base+"2b", kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3,name=bn_name_base+"2b")(X)
    X = Activation("relu")(X)
    
    ##主路徑第三部分
    X = Conv2D(filters=F3, kernel_size=(1,1), strides=(1,1), padding="valid",
               name=conv_name_base+"2c", kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3,name=bn_name_base+"2c")(X)
    
    #捷徑
    X_shortcut = Conv2D(filters=F3, kernel_size=(1,1), strides=(s,s), padding="valid",
               name=conv_name_base+"1", kernel_initializer=glorot_uniform(seed=0))(X_shortcut)
    X_shortcut = BatchNormalization(axis=3,name=bn_name_base+"1")(X_shortcut)
    
    #最后一步
    X = Add()([X,X_shortcut])
    X = Activation("relu")(X)
    
    return X

2.2 構建一個殘差網絡（50層）

我們已經做完所需要的所有殘差塊了，下面這個圖就描述了神經網絡的算法細節，圖中的"ID BLOCK"是指標准的恆等塊，"ID BLOCK X3"是指把三個恆等塊放在一起。

這個50層的網絡的細節如下:

1. 對輸入數據進行0填充，padding =（3,3）

2. stage1：

   • 卷積層有64個過濾器，其維度為（7，7），步伐為（2，2），命名為“conv1”

   • 規范層（BatchNorm）對輸入數據進行通道軸歸一化。

   • 最大值池化層使用一個（3，3）的窗口和（2，2）的步伐。

3. stage2：

   • 卷積塊使用f=3個大小為[64，64，256]的過濾器，f=3，s=1,block=“a”

   • 2個恆等塊使用三個大小為[64，64，256]的過濾器，f=3，block=“b”、“c”

4. stage3：

   • 卷積塊使用f=3個大小為[128,128,512]的過濾器，f=3，s=2,block=“a”

   • 3個恆等塊使用三個大小為[128,128,512]的過濾器，f=3，block=“b”、“c”、“d”

5. stage4：

   • 卷積塊使用f=3個大小為[256,256,1024]的過濾器，f=3，s=2,block=“a”

   • 5個恆等塊使用三個大小為[256,256,1024]的過濾器，f=3，block=“b”、“c”、“d”、“e”、“f”

6. stage5：

   • 卷積塊使用f=3個大小為[512,512,2048]的過濾器，f=3，s=2,block=“a”

   • 2個恆等塊使用三個大小為[256,256,2048]的過濾器，f=3，block=“b”、“c”

7. 均值池化層使用維度為（2,2）的窗口，命名為“avg_pool”

8. 展開操作沒有任何超參數以及命名

9. 全連接層（密集連接）使用softmax激活函數，命名為"fc" + str(classes)

def ResNet50(input_shape=(64,64,3),classes=6):
    """
    實現ResNet50
    CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
    -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
    
    參數：
        input_shape - 圖像數據集的維度
        classes - 整數，分類數
        
    返回：
        model - Keras框架的模型
        
    """
    
    #定義tensor類型的輸入數據
    X_input = Input(input_shape)
    
    #0填充
    X = ZeroPadding2D((3,3))(X_input)
    
    #stage1
    X = Conv2D(filters=64, kernel_size=(7,7), strides=(2,2), name="conv1",
               kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name="bn_conv1")(X)
    X = Activation("relu")(X)
    X = MaxPooling2D(pool_size=(3,3), strides=(2,2))(X)
    
    #stage2
    X = convolutional_block(X, f=3, filters=[64,64,256], stage=2, block="a", s=1)
    X = identity_block(X, f=3, filters=[64,64,256], stage=2, block="b")
    X = identity_block(X, f=3, filters=[64,64,256], stage=2, block="c")
    
    #stage3
    X = convolutional_block(X, f=3, filters=[128,128,512], stage=3, block="a", s=2)
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block="b")
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block="c")
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block="d")
    
    #stage4
    X = convolutional_block(X, f=3, filters=[256,256,1024], stage=4, block="a", s=2)
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block="b")
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block="c")
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block="d")
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block="e")
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block="f")
    
    #stage5
    X = convolutional_block(X, f=3, filters=[512,512,2048], stage=5, block="a", s=2)
    X = identity_block(X, f=3, filters=[512,512,2048], stage=5, block="b")
    X = identity_block(X, f=3, filters=[512,512,2048], stage=5, block="c")
    
    #均值池化層
    X = AveragePooling2D(pool_size=(2,2),padding="same")(X)
    
    #輸出層
    X = Flatten()(X)
    X = Dense(classes, activation="softmax", name="fc"+str(classes),
              kernel_initializer=glorot_uniform(seed=0))(X)
    
    
    #創建模型
    model = Model(inputs=X_input, outputs=X, name="ResNet50")
    
    return model

然后我們對模型做實體化和編譯工作：

model = ResNet50(input_shape=(64,64,3),classes=6)
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])

模型准備好后，我們就可以加載數據進行訓練了：

X_train_orig, Y_train_orig, X_test_orig, Y_test_orig, classes = resnets_utils.load_dataset()

# Normalize image vectors
X_train = X_train_orig / 255.
X_test = X_test_orig / 255.

# Convert training and test labels to one hot matrices
Y_train = resnets_utils.convert_to_one_hot(Y_train_orig, 6).T
Y_test = resnets_utils.convert_to_one_hot(Y_test_orig, 6).T

model.fit(X_train,Y_train,epochs=2,batch_size=32)

這樣，殘差網絡就訓練完畢了，原作者還利用模型測試了自己拍的圖片，我就不做測試了，另外作者繪制了網絡結構圖（可以去原作者那里看這張圖，圖片比較長），利用這張圖可以很清晰的看懂網絡結構，其實殘差網絡並不復雜，無非就是網絡層數比較多，但是沒有太復雜的結構。本周的作業是基於Keras框架的，由於對該框架掌握不深，所以此次作業的代碼都是參考的原作者的代碼，再次感謝一下作者。

參考文章：https://blog.csdn.net/u013733326/article/details/80250818