初始化

一個好的初始化可以做到：

• 梯度下降的快速收斂
• 收斂到的對訓練集只有較少錯誤的值

載入資料

import numpy as np
import matplotlib.pyplot as plt
import sklearn
import sklearn.datasets
from init_utils import sigmoid, relu, compute_loss, forward_propagation, backward_propagation
from init_utils import update_parameters, predict, load_dataset, plot_decision_boundary, predict_dec

%matplotlib inline
plt.rcParams['figure.figsize'
 
] = (7.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

# load image dataset: blue/red dots in circles
train_X, train_Y, test_X, test_Y = load_dataset()

備用方法介紹

def sigmoid(x):
    """
    Compute the sigmoid of x

    Arguments:
    x -- A scalar or numpy array of any size.

    Return:
    s -- sigmoid(x)
    """
 

    s = 1/(1+np.exp(-x))
    return s


def relu(x):
    """
    Compute the relu of x

    Arguments:
    x -- A scalar or numpy array of any size.

    Return:
    s -- relu(x)
    """
    s = np.maximum(0,x)

    return s


def compute_loss(a3, Y):

    """
    Implement the loss function

    Arguments:
    a3 -- post-activation, output of forward propagation
    Y -- "true" labels vector, same shape as a3

    Returns:
    loss - value of the loss function
    """
 


    m = Y.shape[1]
    logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
    loss = 1./m * np.nansum(logprobs)

    return loss

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)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat)
    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 = 1./m * (a3 - Y)
    dW3 = np.dot(dz3, a2.T)
    db3 = np.sum(dz3, axis=1, keepdims = True)

    da2 = np.dot(W3.T, dz3)
    dz2 = np.multiply(da2, np.int64(a2 > 0))
    dW2 = np.dot(dz2, a1.T)
    db2 = np.sum(dz2, axis=1, keepdims = True)

    da1 = np.dot(W2.T, dz2)
    dz1 = np.multiply(da1, np.int64(a1 > 0))
    dW1 = np.dot(dz1, X.T)
    db1 = 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


def update_parameters(parameters, grads, learning_rate):
    """
    Update parameters using gradient descent

    Arguments:
    parameters -- python dictionary containing your parameters 
    grads -- python dictionary containing your gradients, output of n_model_backward

    Returns:
    parameters -- python dictionary containing your updated parameters 
                  parameters['W' + str(i)] = ... 
                  parameters['b' + str(i)] = ...
    """

    L = len(parameters) // 2 # number of layers in the neural networks

    # Update rule for each parameter
    for k in range(L):
        parameters["W" + str(k+1)] = parameters["W" + str(k+1)] - learning_rate * grads["dW" + str(k+1)]
        parameters["b" + str(k+1)] = parameters["b" + str(k+1)] - learning_rate * grads["db" + str(k+1)]

    return parameters


def predict(X, y, parameters):
    """
    This function is used to predict the results of a  n-layer neural network.

    Arguments:
    X -- data set of examples you would like to label
    parameters -- parameters of the trained model

    Returns:
    p -- predictions for the given dataset X
    """

    m = X.shape[1]
    p = np.zeros((1,m), dtype = np.int)

    # Forward propagation
    a3, caches = forward_propagation(X, parameters)

    # convert probas to 0/1 predictions
    for i in range(0, a3.shape[1]):
        if a3[0,i] > 0.5:
            p[0,i] = 1
        else:
            p[0,i] = 0

    # print results
    print("Accuracy: "  + str(np.mean((p[0,:] == y[0,:]))))

    return p


def load_dataset():
    np.random.seed(1)
    train_X, train_Y = sklearn.datasets.make_circles(n_samples=300, noise=.05)
    np.random.seed(2)
    test_X, test_Y = sklearn.datasets.make_circles(n_samples=100, noise=.05)
    # Visualize the data
    plt.scatter(train_X[:, 0], train_X[:, 1], c=train_Y, s=40, cmap=plt.cm.Spectral);
    train_X = train_X.T
    train_Y = train_Y.reshape((1, train_Y.shape[0]))
    test_X = test_X.T
    test_Y = test_Y.reshape((1, test_Y.shape[0]))
    return train_X, train_Y, test_X, test_Y


def plot_decision_boundary(model, X, y):
    # Set min and max values and give it some padding
    x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
    y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
    h = 0.01
    # Generate a grid of points with distance h between them
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
    # Predict the function value for the whole grid
    Z = model(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    # Plot the contour and training examples
    plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
    plt.ylabel('x2')
    plt.xlabel('x1')
    plt.scatter(X[0, :], X[1, :], c=y, cmap=plt.cm.Spectral)
    plt.show()


def predict_dec(parameters, X):
    """
    Used for plotting decision boundary.

    Arguments:
    parameters -- python dictionary containing your parameters 
    X -- input data of size (m, K)

    Returns
    predictions -- vector of predictions of our model (red: 0 / blue: 1)
    """

    # Predict using forward propagation and a classification threshold of 0.5
    a3, cache = forward_propagation(X, parameters)
    predictions = (a3>0.5)
    return predictions

1 神經網路模型

我們將用一個3-layer神經網路對上文散點圖進行分類。

1.2 初始化方法

• 零值初始化：initialization = “zeros”
• 隨機初始化：initialization = “random”
• He 初始化：initialization = “random” （按照He的論文進行的隨機初始化）

1.3 三層神經網路模型

def model(X, Y, learning_rate = 0.01, num_iterations = 15000, print_cost = True, initialization = "he"):
    """
    Implements a three-layer neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SIGMOID.

    Arguments:
    X -- input data, of shape (2, number of examples)
    Y -- true "label" vector (containing 0 for red dots; 1 for blue dots), of shape (1, number of examples)
    learning_rate -- learning rate for gradient descent 
    num_iterations -- number of iterations to run gradient descent
    print_cost -- if True, print the cost every 1000 iterations
    initialization -- flag to choose which initialization to use ("zeros","random" or "he")

    Returns:
    parameters -- parameters learnt by the model
    """

    grads = {}
    costs = [] # to keep track of the loss
    m = X.shape[1] # number of examples
    layers_dims = [X.shape[0], 10, 5, 1]

    # Initialize parameters dictionary.
    if initialization == "zeros":
        parameters = initialize_parameters_zeros(layers_dims)
    elif initialization == "random":
        parameters = initialize_parameters_random(layers_dims)
    elif initialization == "he":
        parameters = initialize_parameters_he(layers_dims)

    # Loop (gradient descent)

    for i in range(0, num_iterations):

        # Forward propagation: LINEAR -> RELU -> LINEAR -> RELU -> LINEAR -> SIGMOID.
        a3, cache = forward_propagation(X, parameters)

        # Loss
        cost = compute_loss(a3, Y)

        # Backward propagation.
        grads = backward_propagation(X, Y, cache)

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

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

    # plot the loss
    plt.plot(costs)
    plt.ylabel('cost')
    plt.xlabel('iterations (per hundreds)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()

    return parameters

2 零值初始化

初始化（W1,b1）… (Wl,b,)

# GRADED FUNCTION: initialize_parameters_zeros 

def initialize_parameters_zeros(layers_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the size of each layer.

    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                    b1 -- bias vector of shape (layers_dims[1], 1)
                    ...
                    WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                    bL -- bias vector of shape (layers_dims[L], 1)
    """

    parameters = {}
    L = len(layers_dims)            # number of layers in the network

    for l in range(1, L):
        ### START CODE HERE ### (≈ 2 lines of code)
        parameters['W' + str(l)] = np.zeros((layers_dims[l],layers_dims[l-1]))
        parameters['b' + str(l)] = np.zeros((layers_dims[l],1))
        ### END CODE HERE ###
    return 




parameters = initialize_parameters_zeros([3,2,1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

試一試

parameters = initialize_parameters_zeros([3,2,1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))


# On the train set:
# Accuracy: 0.5
# On the test set:
# Accuracy: 0.5

準確率一半，還不如猜呢，並且隨著迭代次數增加，cost並沒有任何變化。

plt.title("Model with Zeros initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

結論

零值初始化無法打破對稱性，導致每個神經元學習同樣的內容，相當於只有一層，和線性邏輯迴歸沒什麼區別。

3 隨機初始化（大值初始化）

# GRADED FUNCTION: initialize_parameters_random

def initialize_parameters_random(layers_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the size of each layer.

    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                    b1 -- bias vector of shape (layers_dims[1], 1)
                    ...
                    WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                    bL -- bias vector of shape (layers_dims[L], 1)
    """

    np.random.seed(3)               # This seed makes sure your "random" numbers will be the as ours
    parameters = {}
    L = len(layers_dims)            # integer representing the number of layers

    for l in range(1, L):
        ### START CODE HERE ### (≈ 2 lines of code)
        parameters['W' + str(l)] = np.random.randn(layers_dims[l],layers_dims[l-1])*10
        parameters['b' + str(l)] = np.zeros((layers_dims[l],1))
        ### END CODE HERE ###

    return parameters



parameters = initialize_parameters_random([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

試一試

parameters = model(train_X, train_Y, initialization = "random")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)

# On the train set:
# Accuracy: 0.83
# On the test set:
# Accuracy: 0.86

plt.title("Model with large random initialization")
axes = plt.gca()
axes.set_xlim([-1.5,1.5])
axes.set_ylim([-1.5,1.5])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

結論

• 用大值隨機初始化時開始cost很大，逐步縮小，但下降緩慢
• 不好的初始化會導致梯度消失或梯度爆炸，也拖慢了演算法優化的速度

看來小值初始化會表現的更好，但是小值是多小呢？

4 He 初始化

• He 初始化Wl：sqrt(2./layers_dims[l-1])
• Xavier 初始化Wl：sqrt(1./layers_dims[l-1])

# GRADED FUNCTION: initialize_parameters_he

def initialize_parameters_he(layers_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the size of each layer.

    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layers_dims[1], layers_dims[0])
                    b1 -- bias vector of shape (layers_dims[1], 1)
                    ...
                    WL -- weight matrix of shape (layers_dims[L], layers_dims[L-1])
                    bL -- bias vector of shape (layers_dims[L], 1)
    """

    np.random.seed(3)
    parameters = {}
    L = len(layers_dims) - 1 # integer representing the number of layers

    for l in range(1, L + 1):
        ### START CODE HERE ### (≈ 2 lines of code)
        parameters['W' + str(l)] = np.random.randn(layers_dims[l],layers_dims[l-1])*np.sqrt(2./layers_dims[l-1])
        parameters['b' + str(l)] = np.zeros((layers_dims[l],1))
        ### END CODE HERE ###

    return parameters




parameters = initialize_parameters_he([2, 4, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))

試一試

parameters = model(train_X, train_Y, initialization = "he")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)

![image](http://123.57.75.26:8080/notePicture/picture/1521723027058_c1w2_heInit_rate.png)

總結

很明顯，在不多的迴圈下，分類效果就已經很好了。

5 各種初始化的結論

Model	Train accuracy	Problem/Comment
3-layer NN 零值初始化	50%	無法打破對稱性
3-layer NN with large random initialization	83%	權重太大
3-layer NN with He initialization	99%	推薦的演算法

正則化

1 導包

# import packages
import numpy as np
import matplotlib.pyplot as plt
from reg_utils import sigmoid, relu, plot_decision_boundary, initialize_parameters, load_2D_dataset, predict_dec
from reg_utils import compute_cost, predict, forward_propagation, backward_propagation, update_parameters
import sklearn
import sklearn.datasets
import scipy.io
from testCases import *

%matplotlib inline
plt.rcParams['figure.figsize'] = (7.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

有用的方法

def initialize_parameters(layer_dims):
    """
    Arguments:
    layer_dims -- python array (list) containing the dimensions of each layer in our network

    Returns:
    parameters -- python dictionary containing your parameters "W1", "b1", ..., "WL", "bL":
                    W1 -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
                    b1 -- bias vector of shape (layer_dims[l], 1)
                    Wl -- weight matrix of shape (layer_dims[l-1], layer_dims[l])
                    bl -- bias vector of shape (1, layer_dims[l])

    Tips:
    - For example: the layer_dims for the "Planar Data classification model" would have been [2,2,1]. 
    This means W1's shape was (2,2), b1 was (1,2), W2 was (2,1) and b2 was (1,1). Now you have to generalize it!
    - In the for loop, use parameters['W' + str(l)] to access Wl, where l is the iterative integer.
    """

    np.random.seed(3)
    parameters = {}
    L = len(layer_dims) # number of layers in the network

    for l in range(1, L):
        parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1]) / np.sqrt(layer_dims[l-1])
        parameters['b' + str(l)] = np.zeros((layer_dims[l], 1))

        assert(parameters['W' + str(l)].shape == layer_dims[l], layer_dims[l-1])
        assert(parameters['W' + str(l)].shape == layer_dims[l], 1)


    return parameters


def compute_cost(a3, Y):
    """
    Implement the cost function

    Arguments:
    a3 -- post-activation, output of forward propagation
    Y -- "true" labels vector, same shape as a3

    Returns:
    cost - value of the cost function
    """
    m = Y.shape[1]

    logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y)
    cost = 1./m * np.nansum(logprobs)

    return cost


def load_2D_dataset():
    data = scipy.io.loadmat('datasets/data.mat')
    train_X = data['X'].T
    train_Y = data['y'].T
    test_X = data['Xval'].T
    test_Y = data['yval'].T

    plt.scatter(train_X[0, :], train_X[1, :], c=train_Y, s=40, cmap=plt.cm.Spectral);

    return train_X, train_Y, test_X, test_Y

問題描述

你被法國足球俱樂部聘為 AI 專家，他們想讓你推薦守門員應把球踢到什麼位置以便其它法國隊員可以用頭部擊球。

下面給出過去十場比賽的二維資料集。

train_X, train_Y, test_X, test_Y = load_2D_dataset()

圖中每個點對應了守門員發球到不同位置後其它球員的擊球情況。
- 藍點：法國球員擊球
- 紅點：其它球員擊球

目標

利用深度學習模型找到守門員應該把球踢往哪些位置。

資料集分析

從資料集上看，資料有一些噪音，不過大體可以看出可以用一條斜對角線分為左上藍點去和右下紅點區。

分別嘗試非正則化模型和正則化模型，最後選擇用哪種模型解決該問題。

1 非正則化模型

你可以使用如下已經實現好的模型。該模型也可以用於：

• 正則化模型：只需將引數 lambd 設定為非0值
• dropout 模型：只需將引數 keep_prob 設定為小於1的數

首先嚐試沒有正則化的模型，然後再實現其他兩種模型：

• L2 正則化：實現方法“compute_cost_with_regularization()” 和 “backward_propagation_with_regularization()”
• Dropout: 實現方法“forward_propagation_with_dropout()” 和 “backward_propagation_with_dropout()”

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
    keep_prob - probability of keeping a neuron active during drop-out, scalar.

    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

訓練非正則化模型

parameters = model(train_X, train_Y)
print ("On the training set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)



Cost after iteration 0: 0.6557412523481002
Cost after iteration 10000: 0.16329987525724216
Cost after iteration 20000: 0.13851642423255986

On the training set:
Accuracy: 0.947867298578
On the test set:
Accuracy: 0.915

訓練集準確率94.8%，測試集準確率91.5%。

plt.title("Model without regularization")
axes = plt.gca()
axes.set_xlim([-0.75,0.40])
axes.set_ylim([-0.75,0.65])
plot_decision_boundary(lambda x: predict_dec(parameters, x.T), train_X, train_Y)

結論

從圖上看，訓練集明顯有點過擬合了，適應了噪點。

下面我們看看降低過擬合的兩種技術。

2 L2 正則化

損失函式：

• 非正則化

J=−1m∑i=1m(y(i)log(a[l](i))+(1−y(i))log(1−a[l](i)))$$J=-\frac{1}{m}\sum _{i=1}^m(y^{(i)}log(a^{[l](i)})+(1-y^{(i)})log(1-a^{[l](i)}))$$

• 正則化
  Jregularized=−1m∑i=1m(y(i

  相關推薦

  吳恩達Coursera深度學習課程 deeplearning.ai (5-1) 迴圈序列模型--程式設計作業(一)：構建迴圈神經網路

  Part 1: 構建神經網路 歡迎來到本週的第一個作業，這個作業我們將利用numpy實現你的第一個迴圈神經網路。 迴圈神經網路(Recurrent Neural Networks: RNN) 因為有”記憶”，所以在自然語言處理(Natural Languag

  吳恩達Coursera深度學習課程 deeplearning.ai (2-1) 深度學習實踐--程式設計作業

  初始化 一個好的初始化可以做到： 梯度下降的快速收斂 收斂到的對訓練集只有較少錯誤的值 載入資料 import numpy as np import matplotlib.pyplot as plt import sklearn impo

  吳恩達Coursera深度學習課程 deeplearning.ai (3-1) 機器學習(ML)策略（1）--課程筆記

  1.1 為什麼是 ML 策略 實踐中優化深度學習模型的方法有好多種，應該如何抉擇? 1.2 正交化 正交化： 一個維度做且只做一件事，各個維度相互獨立，不影響其他維度做的事情。 比如電視條件：有調節高度的按鈕，寬度的按鈕，旋轉的按鈕， 色彩

  吳恩達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)

  吳恩達Coursera深度學習課程 deeplearning.ai (5-1) 迴圈序列模型--課程筆記

  1.1 為什麼選擇序列模型 序列模型的應用 語音識別：將輸入的語音訊號直接輸出相應的語音文字資訊。無論是語音訊號還是文字資訊均是序列資料。 音樂生成：生成音樂樂譜。只有輸出的音樂樂譜是序列資料，輸入可以是空或者一個整數。 情感分類：將輸入的評論句子轉換

  吳恩達Coursera深度學習課程 deeplearning.ai (5-3) 序列模型和注意力機制--程式設計作業(二)：觸發字檢測

  Part 2: 觸發字檢測 關鍵詞語音喚醒 觸發字檢測 歡迎來到這個專業課程的最終程式設計任務！ 在本週的視訊中，你瞭解瞭如何將深度學習應用於語音識別。在本作業中，您將構建一個語音資料集並實現觸發字檢測演算法（有時也稱為關鍵字檢測或喚醒檢測）。觸發字

  吳恩達Coursera深度學習課程 DeepLearning.ai 程式設計作業——Regularization（2-1.2）

  如果資料集沒有很大，同時在訓練集上又擬合得很好，但是在測試集的效果卻不是很好，這時候就要使用正則化來使得其擬合能力不會那麼強。 import numpy as np import sklearn import matplotlib.pyplot as plt

  吳恩達Coursera深度學習課程 DeepLearning.ai 提煉筆記（1-2）-- 神經網路基礎

  以下為在Coursera上吳恩達老師的DeepLearning.ai課程專案中，第一部分《神經網路和深度學習》第二週課程部分關鍵點的筆記。筆記並不包含全部小視訊課程的記錄，如需學習筆記中捨棄的內容請至Coursera 或者 網易雲課堂。同時在閱讀以下

  吳恩達Coursera深度學習課程 deeplearning.ai (4-4) 人臉識別和神經風格轉換--課程筆記

  Part 1：人臉識別 4.1 什麼是人臉識別？ 人臉驗證: 輸入圖片，驗證是不是 A 人臉識別: 有一個庫，輸入圖片，驗證是不是庫裡的一員 人臉識別難度更大，要求準確率更高，因為1%的人臉驗證錯誤在人臉識別中會被放大很多倍。 4.2 O

  吳恩達Coursera深度學習課程 DeepLearning.ai 提煉筆記（5-1）-- 迴圈神經網路

  Ng最後一課釋出了，撒花！以下為吳恩達老師 DeepLearning.ai 課程專案中，第五部分《序列模型》第一週課程“迴圈神經網路”關鍵點的筆記。 同時我在知乎上開設了關於機器學習深度學習的專欄收錄下面的筆記，以方便大家在移動端的學習。歡迎關

  吳恩達Coursera深度學習課程 deeplearning.ai (5-3) 序列模型和注意力機制--課程筆記

  3.1 基礎模型 sequence to sequence sequence to sequence：兩個序列模型組成，前半部分叫做編碼，後半部分叫做解碼。用於機器翻譯。 image to sequence sequence to sequenc

  吳恩達Coursera深度學習課程 DeepLearning第一課第二週程式設計作業

       最近在學習吳恩達的Deep Learning 系列課程，首先在此對吳老師表示深深的謝意。第一次接觸深度學習方面的知識，更是第一次用程式碼程式設計實現深度學習的演算法。所以在完成老師的作業過程中，遇到很多問題，最終在度孃的幫助下，花了一天的時間，終於把程式設計實現了邏

  吳恩達Coursera深度學習課程 deeplearning.ai (5-2) 自然語言處理與詞嵌入--程式設計作業(一)：詞向量運算

  Part 1: 詞向量運算 歡迎來到本週第一個作業。 由於詞嵌入的訓練計算量龐大切耗費時間長，絕大部分機器學習人員都會匯入一個預訓練的詞嵌入模型。 你將學到： 載入預訓練單詞向量，使用餘弦測量相似度 使用詞嵌入解決類別問題，比如 “Man is to

  吳恩達Coursera深度學習課程 DeepLearning.ai 提煉筆記（5-3）-- 序列模型和注意力機制

  完結撒花！以下為吳恩達老師 DeepLearning.ai 課程專案中，第五部分《序列模型》第三週課程“序列模型和注意力機制”關鍵點的筆記。 同時我在知乎上開設了關於機器學習深度學習的專欄收錄下面的筆記，以方便大家在移動端的學習。歡迎關注我的知

  吳恩達Coursera深度學習課程 deeplearning.ai (4-2) 深度卷積網路：例項探究--課程筆記

  本課主要講解了一些典型的卷積神經網路的思路，包括經典神經網路的leNet/AlexNet/VGG, 以及殘差網路ResNet和Google的Inception網路，順便講解了1x1卷積核的應用，便於我們進行學習和借鑑。 2.1 為什麼要進行例項探究 神經

  吳恩達Coursera深度學習課程 DeepLearning.ai 提煉筆記（1-3）-- 淺層神經網路

  以下為在Coursera上吳恩達老師的DeepLearning.ai課程專案中，第一部分《神經網路和深度學習》第三週課程“淺層神經網路”部分關鍵點的筆記。筆記並不包含全部小視訊課程的記錄，如需學習筆記中捨棄的內容請至Coursera 或者 網易雲課堂

  吳恩達Coursera深度學習課程 deeplearning.ai (4-4) 人臉識別和神經風格轉換--程式設計作業

  Part 1：Happy House 的人臉識別 本週的第一個作業我們將完成一個人臉識別系統。 人臉識別問題可以分為兩類： 人臉驗證: 輸入圖片，驗證是不是A 1:1 識別 舉例：人臉解鎖手機，人臉刷卡 人臉識別: 有一個庫，輸入圖片，驗證是不是庫裡的

  吳恩達Coursera深度學習課程 deeplearning.ai (5-2) 自然語言處理與詞嵌入--程式設計作業(二)：Emojify表情包

  Part 2: Emojify 歡迎來到本週的第二個作業，你將利用詞向量構建一個表情包。 你有沒有想過讓你的簡訊更具表現力？ emojifier APP將幫助你做到這一點。 所以不是寫下”Congratulations on the promotion! L

  吳恩達Coursera深度學習課程 DeepLearning.ai 提煉筆記（1-4）-- 深層神經網路

  以下為在Coursera上吳恩達老師的DeepLearning.ai課程專案中，第一部分《神經網路和深度學習》第四周課程“深層神經網路”部分關鍵點的筆記。筆記並不包含全部小視訊課程的記錄，如需學習筆記中捨棄的內容請至 Coursera 或者 網易雲課