title: ‘DeepLearning.ai作業:(4-1)-- 卷積神經網路（Foundations of CNN）’
id: dl-ai-4-1h
tags:

• dl.ai
• homework
  categories:
• AI
• Deep Learning
  date: 2018-09-30 16:07:23

首發於個人部落格:fangzh.top，歡迎來訪
本週的作業分為了兩部分：

• 卷積神經網路的模型搭建
• 用TensorFlow來訓練卷積神經網路

Part1：Convolutional Neural Networks: Step by Step

主要內容：

• convolution funtions:
  • Zero Padding
  • Convolve window
  • Convolution forward
  • Convolution backward (optional)
• Pooling functions：
  • Pooling forward
  • Create mask
  • Distribute value
  • Pooling backward (optional)

Convolutional Neural Networks

建立CNN的主要函式

1. Zero Padding

先建立一個padding函式，用來輸入影象X，輸出padding後的影象，這裡使用的是np.pad()函式，

a = np.pad(a, ((0,0), (1,1), (0,0), (3,3), (0,0)), 'constant', constant_values = (..,..))
表示a有5個維度，在第1維的兩邊都填上1個pad，和第3維的兩邊都填上3個pad，constant_values表示兩邊要填充的值

def zero_pad(X, pad):
    """
    Pad with zeros all images of the dataset X. The padding is applied to the height and width of an image, 
    as illustrated in Figure 1.
    
    Argument:
    X -- python numpy array of shape (m, n_H, n_W, n_C) representing a batch of m images
    pad -- integer, amount of padding around each image on vertical and horizontal dimensions
    
    Returns:
    X_pad -- padded image of shape (m, n_H + 2*pad, n_W + 2*pad, n_C)
    """
 

    
    ### START CODE HERE ### (≈ 1 line)
    X_pad = np.pad(X, ((0,0),(pad,pad),(pad,pad),(0,0)), 'constant', constant_values=(0,0))
    ### END CODE HERE ###
    
    return X_pad

2.Single step of convolution

建立一個單步的卷積運算，也就是一次輸入一個切片，大小和卷積核相同，對應元素相乘再求和，最後再加個bias項。

# GRADED FUNCTION: conv_single_step

def conv_single_step(a_slice_prev, W, b):
    """
    Apply one filter defined by parameters W on a single slice (a_slice_prev) of the output activation 
    of the previous layer.
    
    Arguments:
    a_slice_prev -- slice of input data of shape (f, f, n_C_prev)
    W -- Weight parameters contained in a window - matrix of shape (f, f, n_C_prev)
    b -- Bias parameters contained in a window - matrix of shape (1, 1, 1)
    
    Returns:
    Z -- a scalar value, result of convolving the sliding window (W, b) on a slice x of the input data
    """

    ### START CODE HERE ### (≈ 2 lines of code)
    # Element-wise product between a_slice and W. Do not add the bias yet.
    s = a_slice_prev * W
    # Sum over all entries of the volume s.
    Z = np.sum(s)
    # Add bias b to Z. Cast b to a float() so that Z results in a scalar value.
    Z = Z + float(b)
    ### END CODE HERE ###

    return Z

3.Convolutional Neural Networks - Forward pass

建立一次完整的卷積過程，也就是利用上面的一次卷積，進行for迴圈。進行切片的時候，注意邊界vert_start, vert_end, horiz_start and horiz_end

這一步應該先弄清楚A_prev，A，W，b的維度，超引數項包括了stride和pad

$n_H = \lfloor \frac{n_{H_{prev}} - f + 2 \times pad}{stride} \rfloor +1$
$n_W = \lfloor \frac{n_{W_{prev}} - f + 2 \times pad}{stride} \rfloor +1$
$n_C = \text{number of filters used in the convolution}$

# GRADED FUNCTION: conv_forward

def conv_forward(A_prev, W, b, hparameters):
    """
    Implements the forward propagation for a convolution function
    
    Arguments:
    A_prev -- output activations of the previous layer, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)
    W -- Weights, numpy array of shape (f, f, n_C_prev, n_C)
    b -- Biases, numpy array of shape (1, 1, 1, n_C)
    hparameters -- python dictionary containing "stride" and "pad"
        
    Returns:
    Z -- conv output, numpy array of shape (m, n_H, n_W, n_C)
    cache -- cache of values needed for the conv_backward() function
    """
    
    ### START CODE HERE ###
    # Retrieve dimensions from A_prev's shape (≈1 line)  
    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
    
    # Retrieve dimensions from W's shape (≈1 line)
    (f, f, n_C_prev, n_C) = W.shape
    
    # Retrieve information from "hparameters" (≈2 lines)
    stride = hparameters['stride']
    pad = hparameters['pad']
    
    # Compute the dimensions of the CONV output volume using the formula given above. Hint: use int() to floor. (≈2 lines)
    n_H = int((n_H_prev + 2 * pad - f) / stride + 1)
    n_W = int((n_W_prev + 2 * pad - f) / stride + 1)

    # Initialize the output volume Z with zeros. (≈1 line)
    Z = np.zeros((m, n_H, n_W, n_C))
    
    # Create A_prev_pad by padding A_prev
    A_prev_pad = zero_pad(A_prev, pad)
    
    for i in range(m):                               # loop over the batch of training examples
        a_prev_pad = A_prev_pad[i]                               # Select ith training example's padded activation
        for h in range(n_H):                           # loop over vertical axis of the output volume
            for w in range(n_W):                       # loop over horizontal axis of the output volume
                for c in range(n_C):                   # loop over channels (= #filters) of the output volume
                    
                    # Find the corners of the current "slice" (≈4 lines)
                    vert_start = h * stride
                    vert_end = h * stride + f
                    horiz_start = w * stride
                    horiz_end = w * stride + f
                    
                    # Use the corners to define the (3D) slice of a_prev_pad (See Hint above the cell). (≈1 line)
                    a_slice_prev = a_prev_pad[vert_start : vert_end, horiz_start : horiz_end]
                    
                    # Convolve the (3D) slice with the correct filter W and bias b, to get back one output neuron. (≈1 line)
                    Z[i, h, w, c] = conv_single_step(a_slice_prev,W[:,:,:,c],b[:,:,:,c])
                                        
    ### END CODE HERE ###
    
    # Making sure your output shape is correct
    assert(Z.shape == (m, n_H, n_W, n_C))
    
    # Save information in "cache" for the backprop
    cache = (A_prev, W, b, hparameters)
    
    return Z, cache

Pooling layer

建立池化層，注意得到的維度需要向下取整，用int()對float()進行轉換

$n_H = \lfloor \frac{n_{H_{prev}} - f}{stride} \rfloor +1$
$n_W = \lfloor \frac{n_{W_{prev}} - f}{stride} \rfloor +1$
$n_C = n_{C_{prev}}$

同樣需要先進行切邊，而後分為max和average兩種，分別用np.max和np.mean

def pool_forward(A_prev, hparameters, mode = "max"):
    """
    Implements the forward pass of the pooling layer
    
    Arguments:
    A_prev -- Input data, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)
    hparameters -- python dictionary containing "f" and "stride"
    mode -- the pooling mode you would like to use, defined as a string ("max" or "average")
    
    Returns:
    A -- output of the pool layer, a numpy array of shape (m, n_H, n_W, n_C)
    cache -- cache used in the backward pass of the pooling layer, contains the input and hparameters 
    """
    
    # Retrieve dimensions from the input shape
    (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape
    
    # Retrieve hyperparameters from "hparameters"
    f = hparameters["f"]
    stride = hparameters["stride"]
    
    # Define the dimensions of the output
    n_H = int(1 + (n_H_prev - f) / stride)
    n_W = int(1 + (n_W_prev - f) / stride)
    n_C = n_C_prev
    
    # Initialize output matrix A
    A = np.zeros((m, n_H, n_W, n_C))              
    
    ### START CODE HERE ###
    for i in range(m):                         # loop over the training examples
        for h in range(n_H):                     # loop on the vertical axis of the output volume
            for w in range(n_W):                 # loop on the horizontal axis of the output volume
                for c in range (n_C):            # loop over the channels of the output volume
                    
                    # Find the corners of the current "slice" (≈4 lines)
                    vert_start = h * stride
                    vert_end = vert_start + f
                    horiz_start = w * stride
                    horiz_end = horiz_start + f
                    
                    # Use the corners to define the current slice on the ith training example of A_prev, channel c. (≈1 line)
                    a_prev_slice = A_prev[i, vert_start : vert_end, horiz_start : horiz_end, c]
                    
                    # Compute the pooling operation on the slice. Use an if statment to differentiate the modes. Use np.max/np.mean.
                    if mode == "max":
                        A[i, h, w, c] = np.max(a_prev_slice)
                    elif mode == "average":
                        A[i, h, w, c] = np.mean(a_prev_slice)
    
    ### END CODE HERE ###
    
    # Store the input and hparameters in "cache" for pool_backward()
    cache = (A_prev, hparameters)
    
    # Making sure your output shape is correct
    assert(A.shape == (m, n_H, n_W, n_C))
    
    return A, cache

Backpropagation in convolutional neural networks

卷積神經網路的求導是比較難以理解的，這裡有卷積層的求導和池化層的求導。

1.Convolutional layer backward pass

假設經過卷積層後我們的輸出 $Z = W \times A +b$

那麼反向傳播過程中需要求的就是 $dA,dW,db$，其中 $dA$是原輸入的資料，包含了原影象中的每一個畫素，

而這個時候假設從後面傳過來的 $dZ$是已經知道的。

1.計算dA

從公式可以看出， $dA = W \times dZ$，具體一點， $dA$的每一個切片就是 $W_c$乘上 $dZ$在輸出圖片的每一個畫素的求和結果，從矩陣的角度，每一次 $ W c × 相關推薦 DeepLearning.ai作業:(4-1)-- 卷積神經網路（Foundations of CNN） title: ‘DeepLearning.ai作業:(4-1)-- 卷積神經網路（Foundations of CNN）’ id: dl-ai-4-1h tags: dl.ai homework categories: AI Deep Learning d DeepLearning.ai筆記:(4-1)-- 卷積神經網路（Foundations of CNN） title: ‘DeepLearning.ai筆記:(4-1)-- 卷積神經網路（Foundations of CNN）’ id: dl-ai-4-1 tags: dl.ai categories: AI Deep Learning date: 2018-09- 吳恩達Coursera深度學習課程 deeplearning.ai (4-1) 卷積神經網路--程式設計作業 Part 1：卷積神經網路 本週課程將利用numpy實現卷積層(CONV) 和 池化層(POOL), 包含前向傳播和可選的反向傳播。 變數說明 上標[l][l] 表示神經網路的第幾層 上標(i)(i) 表示第幾個樣本 上標[i][i] 表示第幾個mi 吳恩達Coursera深度學習課程 deeplearning.ai (4-1) 卷積神經網路--課程筆記 本課主要講解了卷積神經網路的基礎知識，包括卷積層基礎（卷積核、Padding、Stride），卷積神經網路的基礎：卷積層、池化層、全連線層。 主要知識點 卷積核: 過濾器，各元素相乘再相加 nxn * fxf -> (n-f+1)x(n-f+1) TensorFlow實戰：Chapter-4（CNN-2-經典卷積神經網路（AlexNet、VGGNet）） 引言 AlexNet AlexNet 簡介 AlexNet的特點 AlexNet論文分析 引言 TensorFlow實戰：Chapter-6（CNN-4-經典卷積神經網路（ResNet）) ResNet ResNet簡介 ResNet(Residual Neural Network)由微軟研究院的何凱明大神等4人提出，ResNet通過使用Residual Unit成功訓練152層神經網路，在ILSCRC2015年比賽中獲得3.75%的 TensorFlow學習筆記（5）--實現卷積神經網路（MNIST資料集） 這裡使用TensorFlow實現一個簡單的卷積神經網路，使用的是MNIST資料集。網路結構為：資料輸入層–卷積層1–池化層1–卷積層2–池化層2–全連線層1–全連線層2（輸出層），這是一個簡單但非常有代表性的卷積神經網路。 import tensorflow TensorFlow實戰：經典卷積神經網路（AlexNet、VGGNet） 下面表格是兩個網路的簡單比較: 特點 AlexNet VGGNet 論文貢獻 介紹完整CNN架構模型(近些年的許多CNN模型都是依據此模型變種來的)和多種訓練技巧 CNN模型復興的開山之作 使用GPU加速 吳恩達深度學習第四課：卷積神經網路（學習筆記2） 前言 1.之所以堅持記錄，是因為看到其他人寫的優秀部落格，內容準確詳實，思路清晰流暢，這也說明了作者對知識的深入思考。我也希望能儘量將筆記寫的準確、簡潔，方便自己回憶也方便別人參考； 2.昨天看到兩篇關於計算機視覺的發展介紹的文章：[觀點|朱鬆純：初探計算機 TensorFlow實現用於影象分類的卷積神經網路（程式碼詳細註釋） 這裡我們採用cifar10作為我們的實驗資料庫。 首先下載TensorFlow Models庫，以便使用其中提供的CIFAR-10資料的類。 git clone https://github.com/tensorflow/models.git cd mo 吳恩達深度學習筆記（deeplearning.ai）之卷積神經網路（CNN）（上） 1. Padding 在卷積操作中，過濾器（又稱核）的大小通常為奇數，如3x3，5x5。這樣的好處有兩點： 在特徵圖（二維卷積）中就會存在一箇中心畫素點。有一箇中心畫素點會十分方便，便於指出過濾器的位置。 在沒有padding的情況下，經過卷積操作，輸出的資 deeplearning筆記4：卷積神經網路 卷積神經網路 為什麼要用卷積神經網路-卷積神經網路的作用 防止model overfitting 在計算機視覺中，input vector往往維度很高，將其直接應用於neural network很有可能會造成overfitting，以下圖為例： 在“cat re 卷積神經網路（4）----目標檢測 一、分類、定位和檢測 簡單來說，分類、定位和檢測的區別如下： 分類：是什麼？ 定位：在哪裡？是什麼？（單個目標） 檢測：在哪裡？分別是什麼？（多個目標）       (1)目標分 卷積神經網路---My way of AI 21 卷積神經網路 上一篇文章實現了用全連線層神經網路手寫數字識別，但是全連線層神經網路有一個缺點就是：假設我是32323的RGB圖片，如果我的第一層全連線層是500個節點，那麼我需要的引數就是32323*500+500一共需要150多萬個引數，這樣會導致計算過慢以及 卷積神經網路（1） 卷積神經網路作為一種置換了傳統網路中隱藏層的可自動提取樣本特徵的技術，具有較高的識別率。本文利用dlib與TensorFlow平臺實現了卷積神經網路人臉識別。結果準確率達到了0.984，取的了較為理想的結果。 ** 1 引言 ** 人臉識別是通過提取 TensorFlow實戰：Chapter-3（CNN-1-卷積神經網路簡介） 卷積神經網路簡介 卷積神經網路(convolutional neural network，CNN)最初是用來解決影象識別等問題設計的，隨著計算機的發展，現在CNN的應用已經非常廣泛了，在自然語言處理(NLP)、醫藥發現、文字處理等等中都有應用。這裡我 Coursera吳恩達《卷積神經網路》課程筆記(1)卷積神經網路 計算機視覺 計算機視覺問題 圖片分類 目標檢測 畫風遷移 在大圖片上的深度學習 如果採用傳統的全連線層，可能會導致引數巨大，導致無法進行計算。卷積神經網路由此產生 【學習筆記1】吳恩達_卷積神經網路_第一週卷積神經網路（1） 一、卷積神經網路 1.邊緣檢測 不同的語言中表示卷積的函式不同，在Python中為在tensorflow裡為 濾波器：垂直、水平邊緣檢測。 Sobel filter:其優點在於增加了中間一行元素的權重，即影象中間的畫素點提高，會使結果的魯棒（robust）性提高。 十四、卷積神經網路（1）：介紹卷積神經網路 本篇部落格主要內容參考圖書《神經網路與深度學習》，李航博士的《統計學習方法》National Taiwan University (NTU)李巨集毅老師的《Machine Learning》的課程，在下文中如果不正確的地方請積極指出。 如果喜歡請點贊 吳恩達《深度學習-卷積神經網路》1--卷積神經網路 1. Computer Vision計算機視覺包括：  --圖片分類（圖片識別）Image classification  --目標檢測 object detection  --神經風格遷移 neural style transfer，如合成圖片創造新的藝術風格計算機視覺面臨 $