[吳恩達 DL] CLass2 Week1 Part1 Regularization（正則化）小結+程式碼實現

一 Regularization小結

為什麼要使用regularization：
主要是因為Deep neural network結構十分靈活，容易造成對資料集的過擬合（尤其在資料集較小時）
常用的正則化方法：
(1) L1/L2 Regularizaion
(2) Dropout
L2 regularizaion
(1) 什麼是L2 regularization:
L2 regularization就是在cost function中增加一L2正則項，對引數W進行懲罰：
Jregularized=−1m∑i=1m(y(i)log(a[L](i))+(1−y(i))log(1−a[

L](i)))cross-entropy cost+1mλ2∑l∑k∑jW[l]2k,jL2 regularization cost
(2) L2 regularization為什麼有效？
L2 regularization是建立在這樣的假設上的：即引數值越小，模型越簡單。因此，通過懲罰引數W的平方項，W越大，Cost值越大，即為了減小Cost，引數W不會過大。這樣建立的模型將更平滑，輸出對輸入的敏感性將下降。
(3) L2 regularization的注意事項
因為對Cost function增加了L2正則項，因此在進行反向傳播計算時，需要將L2正則項的梯度考慮進去。

Dropout
(1) 什麼是Dropout
Dropout 就是在訓練過程中，在每一次iteration過程中，對每一層的節點隨機刪除保留。
(2) Dropout為什麼有效
由於在訓練過程中，所有節點將被隨機保留刪除，因此在每一次iteration過程中，都相當於對不同的模型進行訓練，因此輸出對任意節點的依賴將大大降低。
(3) Dropout的注意事項：
· 只在訓練時採用Dropout
· 訓練時，forward 和 backward 均需要使用Dropout
· 由於對每層節點以概率p進行保留，因此該層的輸出需要除以p以保證輸出滿足預期。

二程式碼實現

下面的程式碼將針對一個特定三層神經網路結構：
LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID

首先建立一個通用的（無regularization，L2 regularization, Dropout）的神經網路模型，然後對三種情況的前向反向傳播演算法進行實現。匯入資料，初始化等程式碼請參看：
[吳恩達 DL] Class1 Week4 深層神經網路+程式碼實現

1. model

def model(X, Y, learning_rate = 0.3, num_iterations = 30000, print_cost = True, lambd = 0, keep_prob = 1):
    """
    Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.

    Arguments:
    X -- input data, of shape (input size, number of examples)
    Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (output size, number of examples)
    learning_rate -- learning rate of the optimization
    num_iterations -- number of iterations of the optimization loop
    print_cost -- If True, print the cost every 10000 iterations
    lambd -- regularization hyperparameter, scalar (為0時不使用L2 regularization)
    keep_prob - probability of keeping a neuron active during drop-out, scalar.(為1時不使用Dropout)

    Returns:
    parameters -- parameters learned by the model. They can then be used to predict.
    """

    grads = {}
    costs = []                            # to keep track of the cost
    m = X.shape[1]                        # number of examples
    layers_dims = [X.shape[0], 20, 3, 1]

    # Initialize parameters dictionary.
    parameters = initialize_parameters(layers_dims)

    # Loop (gradient descent)

    for i in range(0, num_iterations):

        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.
        if keep_prob == 1:
            a3, cache = forward_propagation(X, parameters)
        elif keep_prob < 1:
            a3, cache = forward_propagation_with_dropout(X, parameters, keep_prob)

        # Cost function
        if lambd == 0:
            cost = compute_cost(a3, Y)
        else:
            cost = compute_cost_with_regularization(a3, Y, parameters, lambd)

        # Backward propagation.
        assert(lambd==0 or keep_prob==1)    # it is possible to use both L2 regularization and dropout, 
                                            # but this assignment will only explore one at a time
        if lambd == 0 and keep_prob == 1:
            grads = backward_propagation(X, Y, cache)
        elif lambd != 0:
            grads = backward_propagation_with_regularization(X, Y, cache, lambd)
        elif keep_prob < 1:
            grads = backward_propagation_with_dropout(X, Y, cache, keep_prob)

        # Update parameters.
        parameters = update_parameters(parameters, grads, learning_rate)

        # Print the loss every 10000 iterations
        if print_cost and i % 10000 == 0:
            print("Cost after iteration {}: {}".format(i, cost))
        if print_cost and i % 1000 == 0:
            costs.append(cost)

    # plot the cost
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations (x1,000)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()

    return parameters

2. 不採用任何regularization

# 前向傳播
def forward_propagation(X, parameters):
    """
    Implements the forward propagation (and computes the loss) presented in Figure 2.

    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    parameters -- python dictionary containing your parameters "W1", "b1", "W2", "b2", "W3", "b3":
                    W1 -- weight matrix of shape ()
                    b1 -- bias vector of shape ()
                    W2 -- weight matrix of shape ()
                    b2 -- bias vector of shape ()
                    W3 -- weight matrix of shape ()
                    b3 -- bias vector of shape ()

    Returns:
    loss -- the loss function (vanilla logistic loss)
    """

    # retrieve parameters
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    W3 = parameters["W3"]
    b3 = parameters["b3"]

    # LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID
    Z1 = np.dot(W1, X) + b1
    A1 = relu(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = relu(Z2)
    Z3 = np.dot(W3, A2) + b3
    A3 = sigmoid(Z3)

    cache = (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3)

    return A3, cache

# 反向傳播
def backward_propagation(X, Y, cache):
    """
    Implement the backward propagation presented in figure 2.

    Arguments:
    X -- input dataset, of shape (input size, number of examples)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat)
    cache -- cache output from forward_propagation()

    Returns:
    gradients -- A dictionary with the gradients with respect to each parameter, activation and pre-activation variables
    """
    m = X.shape[1]
    (Z1, A1, W1, b1, Z2, A2, W2, b2, Z3, A3, W3, b3) = cache

    dZ3 = A3 - Y
    dW3 = 1./m * np.dot(dZ3, A2.T)
    db3 = 1./m * np.sum(dZ3, axis=1, keepdims = True)

    dA2 = np.dot(W3.T, dZ3)
    dZ2 = np.multiply(dA2, np.int64(A2 > 0))
    dW2 = 1./m * np.dot(dZ2, A1.T)
    db2 = 1./m * np.sum(dZ2, axis=1, keepdims = True)

    dA1 = np.dot(W2.T, dZ2)
    dZ1 = np.multiply(dA1, np.int64(A1 > 0))
    dW1 = 1./m * np.dot(dZ1, X.T)
    db1 = 1./m * np.sum(dZ1, axis=1, keepdims = True)

    gradients = {"dZ3": dZ3, "dW3": dW3, "db3": db3,
                 "dA2": dA2, "dZ2": dZ2, "dW2": dW2, "db2": db2,
                 "dA1": dA1, "dZ1": dZ1, "dW1": dW1, "db1": db1}

    return gradients

3. L2 Regularization

主要有兩處不同：
（1） Cost function中增加L2 正則項：

Jregularized=−1m∑i=1m(y(i)log(a[L](i))+(1−y(i))log(1−a[L](i)))cross-entropy cost+1mλ

[吳恩達 DL] CLass2 Week1 Part1 Regularization（正則化）小結+程式碼實現

一 Regularization小結為什麼要使用regularization：主要是因為Deep neural network結構十分靈活，容易造成對資料集的過擬合（尤其在資料集較小時）常用的正則化方法： (1) L1/L2 Regularizai

改善深層神經網路第一週-Regularization（正則化）

RegularizationWelcome to the second assignment of this week. Deep Learning models have so much flexibility and capacity that overfitting c

神經網路九：Regularization（正則化）與Dropout

本文主要講解神經網路中的正則化（Regularization）和Dropout，都是用了減小過擬合。正則化在機器學習領域中很重要。主要針對模型過擬合問題而提出來的。本文是觀看麥子學院的視訊整理而來。下

[吳恩達 DL] CLass2 Week3 TensorFlow Tutorial

下面是吳恩達DeepLearning課程第二課第三週的作業，其實主要是介紹如何利用框架TensorFLow建立神經網路模型並進行訓練預測。 TensorFlow Tutorial Welcome to this week’s programming ass

[吳恩達 DL] CLass4 Week1 Part2 Convolution model

以下內容為吳恩達 Deep Learning 系列課程中第四課第一週作業的第部二分：利用Tensorflow構建卷積神經網路並及用於分類應用。 Convolutional Neural Networks: Application Welcome to Co

吳恩達深度學習2-Week1課後作業2-正則化

一、deeplearning-assignment 這一節作業的重點是理解各個正則化方法的原理，以及它們的優缺點，而不是去注重演算法實現的具體末節。問題陳述：希望你通過一個數據集訓練一個合適的模型，從而幫助推薦法國守門員應該踢球的位置，這樣法國隊的球員可以用頭打。法國過

[吳恩達 DL]Class1 Week2 神經網路基礎 + 邏輯迴歸程式碼實現

本週的內容主要圍繞邏輯迴歸二分類問題展開，針對邏輯迴歸的定義，損失函式，梯度下降優化，向量化等知識點進行講解。分課程筆記及程式碼實現兩部分進行講解。一課程筆記 1.結構即給定x，求y^=P（y=1|x）(1) y^=σ(z)=σ(

吳恩達 DeepLearning.ai 課程提煉筆記（4-2）卷積神經網絡 --- 深度卷積模型

mes and shift abd actual 應用比賽特征通道 1. 經典的卷積網絡介紹幾種經典的卷積神經網絡結構，分別是LeNet、AlexNet、VGGNet。 LeNet-5： LeNet-5主要是針對灰度設計的，所以其輸入較小，為，其結構如下：

Coursera 深度學習吳恩達 deep learning.ai 筆記整理（3-2）——機器學習策略

新的 bsp 誤差 spa 歸納空間 font 處理整理一、誤差分析定義：有時我們希望算法能夠勝任人類能做的任務，但是當算法還沒達到人類所預期的性能時，人工檢查算法錯誤會讓你知道接下來做什麽，這也就是誤差分析檢查，發現會把夠狗當恒，是否需要做一個項目專門處理狗

吳恩達老師機器學習筆記SVM（二）

今天的部分是利用高斯核函式對分佈稍微複雜一點的資料進行分類這裡的高斯核函式是構建新的特徵，該特徵是關於到其餘所有樣點的歐式距離。下面放出程式碼： load('ex6data2.mat'); [m n]=size(X); f=zeros(m,m); a=0.005 for i=

吳恩達老師機器學習筆記SVM（一）

時隔好久沒有再拾起機器學習了，今日抽空接著學今天是從最簡單的二維資料分類開始學習SVM~ （上圖為原始資料） SVM的代價函式這裡套用以前logistic迴歸的模板改一下下。。 load('ex6data1.mat'); theta=rand(3,1); [

機器學習 | 吳恩達機器學習第八週程式設計作業(Python版）

實驗指導書下載密碼:higl 本篇部落格主要講解，吳恩達機器學習第八週的程式設計作業，主要包含KMeans實驗和PCA實驗兩部分。原始實驗使用Matlab實現，本篇部落格提供Python版本。目錄 1.實驗包含的檔案 2.KMeans實驗 3.K-me

機器學習 | 吳恩達機器學習第六週程式設計作業(Python版）

實驗指導書下載密碼:4t4y 本篇部落格主要講解，吳恩達機器學習第六週的程式設計作業，作業內容主要是實現一個正則化的線性迴歸演算法，涉及本週講的模型選擇問題，繪製學習曲線判斷高偏差/高方差問題。原始實驗使用Matlab實現，本篇部落格提供Python版本。目錄 1.實驗包

吳恩達機器學習邏輯迴歸python實現（未正則化）[對應ex2-ex2data2.txt資料集]

寫在前面： 1.筆記重點是python程式碼實現，不敘述如何推導。參考本篇筆記前，要有邏輯迴歸的基礎（熟悉代價函式、梯度下降、矩陣運算和python等知識），沒有基礎的同學可通過網易雲課堂上吳恩達老師的機器學習課程學習。網上也有一些對吳恩達老師課後作業的python實現，大多數都是用

吳恩達深度學習筆記(22)-深層神經網路說明及前後向傳播實現

深層神經網路（Deep L-layer neural network）目前為止我們已經學習了只有一個單獨隱藏層的神經網路的正向傳播和反向傳播，還有邏輯迴歸，並且你還學到了向量化，這在隨機初始化權重時是很重要。目前所要做的是把這些理念集合起來，就可以執行你自己的深度神經網路。

吳恩達新書-機器學習學習筆記-（四）學習曲線

1.診斷偏差與方差：學習曲線學習曲線可以將開發集的誤差與訓練集樣本的數量進行關聯比較。想要繪製出它，你需要設定不同大小的訓練集執行演算法。假設有1000個樣本，你可以選擇在規模為100、200、300、····1000的樣本集中分別執行演算法，接著便能得到開發集誤差隨訓練

吳恩達新書-機器學習學習筆記-（五）與人類表現水平對比

1.為何與人類表現水平進行對比許多機器學習系統的設計目的是想要自動化處理一些人類可以處理得很好的事情。可舉的例子有影象識別、語音識別以及垃圾郵件分類等等。學習演算法進步如此之快，有許多類似任務的處理已經超過了人類的表現水平。有很多理由表明在處理人類擅長的任務時，構建一

吳恩達Coursera深度學習課程筆記（1-1）神經網路和深度學習-深度學習概論

這系列文章是我在學習吳恩達教授深度學習課程時為了加深自己理解，同時方便後來對內容進行回顧而做的筆記，其中難免有錯誤的理解和不太好的表述方式，歡迎各位大佬指正並提供建議。1、什麼是神經網路在簡單的從房屋面積預測價格時，神經網路可以理解為將輸入的房屋

吳恩達-DeepLearning.ai-05 序列模型（一）

吳恩達-DeepLearning.ai-05 序列模型迴圈序列模型 1、為什麼選擇序列模型？舉了幾個例子：語音識別、音樂生成、情感分析、DNA序列分析、機器翻譯、視訊動作識別、命名實體識別等 2、數學符號文字資料的表示：命名實體識別中，要識別的內容標籤為1，其他為

吳恩達機器學習課程作業tips（更新中）

ex4, 一開始做的時候，卡在了代價函式這裡，建議大家用for迴圈來練習這道題目，真正理解神經網路演算法和one-vs-all演算法的不同。這個式子的重點在於計算 one-vs-all，十個分類器，分別做十次logistic迴歸。每一個的結果都要和y求誤差。也就是

[吳恩達 DL] CLass2 Week1 Part1 Regularization（正則化） 小結+程式碼實現

一 Regularization小結

二 程式碼實現

1. model

2. 不採用任何regularization

3. L2 Regularization

相關推薦

[吳恩達 DL] CLass2 Week1 Part1 Regularization（正則化）小結+程式碼實現

二程式碼實現