Neural Networks and Deep Learning（week4）Deep Neural Network - Application（图像分类）

Deep Neural Network for Image Classification: Application

预先实现的代码，保存在本地 dnn_app_utils_v3.py

import numpy as np
import matplotlib.pyplot as plt
import h5py
def sigmoid(Z):
    """
    Implements the sigmoid activation in numpy
    Arguments:
    Z -- numpy array of any shape
    Returns:
    A -- output of sigmoid(z), same shape as Z
    cache -- returns Z as well, useful during backpropagation
    """
    A = 1/(1+np.exp(-Z))
    cache = Z
    return A, cache
def relu(Z):
    """
    Implement the RELU function.
    Arguments:
    Z -- Output of the linear layer, of any shape
    Returns:
    A -- Post-activation parameter, of the same shape as Z
    cache -- a python dictionary containing "A" ; stored for computing the backward pass efficiently
    """
    A = np.maximum(0,Z)
    assert(A.shape == Z.shape)
    cache = Z
    return A, cache
def relu_backward(dA, cache):
    """
    Implement the backward propagation for a single RELU unit.
    Arguments:
    dA -- post-activation gradient, of any shape
    cache -- 'Z' where we store for computing backward propagation efficiently
    Returns:
    dZ -- Gradient of the cost with respect to Z
    """
    Z = cache
    dZ = np.array(dA, copy=True) # just converting dz to a correct object.
    # When z <= 0, you should set dz to 0 as well.
    dZ[Z <= 0] = 0
    assert (dZ.shape == Z.shape)
    return dZ
def sigmoid_backward(dA, cache):
    """
    Implement the backward propagation for a single SIGMOID unit.
    Arguments:
    dA -- post-activation gradient, of any shape
    cache -- 'Z' where we store for computing backward propagation efficiently
    Returns:
    dZ -- Gradient of the cost with respect to Z
    """
    Z = cache
    s = 1/(1+np.exp(-Z))
    dZ = dA * s * (1-s)
    assert (dZ.shape == Z.shape)
    return dZ
def load_data():
    train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels
    test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels
    classes = np.array(test_dataset["list_classes"][:]) # the list of classes
    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
def initialize_parameters(n_x, n_h, n_y):
    """
    Argument:
    n_x -- size of the input layer
    n_h -- size of the hidden layer
    n_y -- size of the output layer
    Returns:
    parameters -- python dictionary containing your parameters:
                    W1 -- weight matrix of shape (n_h, n_x)
                    b1 -- bias vector of shape (n_h, 1)
                    W2 -- weight matrix of shape (n_y, n_h)
                    b2 -- bias vector of shape (n_y, 1)
    """
    np.random.seed(1)
    W1 = np.random.randn(n_h, n_x)*0.01
    b1 = np.zeros((n_h, 1))
    W2 = np.random.randn(n_y, n_h)*0.01
    b2 = np.zeros((n_y, 1))
    assert(W1.shape == (n_h, n_x))
    assert(b1.shape == (n_h, 1))
    assert(W2.shape == (n_y, n_h))
    assert(b2.shape == (n_y, 1))
    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}
    return parameters     
def initialize_parameters_deep(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":
                    Wl -- weight matrix of shape (layer_dims[l], layer_dims[l-1])
                    bl -- bias vector of shape (layer_dims[l], 1)
    """
    np.random.seed(1)
    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]) #*0.01
        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['b' + str(l)].shape == (layer_dims[l], 1))
    return parameters
def linear_forward(A, W, b):
    """
    Implement the linear part of a layer's forward propagation.
    Arguments:
    A -- activations from previous layer (or input data): (size of previous layer, number of examples)
    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)
    b -- bias vector, numpy array of shape (size of the current layer, 1)
    Returns:
    Z -- the input of the activation function, also called pre-activation parameter
    cache -- a python dictionary containing "A", "W" and "b" ; stored for computing the backward pass efficiently
    """
    Z = W.dot(A) + b
    assert(Z.shape == (W.shape[0], A.shape[1]))
    cache = (A, W, b)
    return Z, cache
def linear_activation_forward(A_prev, W, b, activation):
    """
    Implement the forward propagation for the LINEAR->ACTIVATION layer
    Arguments:
    A_prev -- activations from previous layer (or input data): (size of previous layer, number of examples)
    W -- weights matrix: numpy array of shape (size of current layer, size of previous layer)
    b -- bias vector, numpy array of shape (size of the current layer, 1)
    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"
    Returns:
    A -- the output of the activation function, also called the post-activation value
    cache -- a python dictionary containing "linear_cache" and "activation_cache";
             stored for computing the backward pass efficiently
    """
    if activation == "sigmoid":
        # Inputs: "A_prev, W, b". Outputs: "A, activation_cache".
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = sigmoid(Z)
    elif activation == "relu":
        # Inputs: "A_prev, W, b". Outputs: "A, activation_cache".
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = relu(Z)
    assert (A.shape == (W.shape[0], A_prev.shape[1]))
    cache = (linear_cache, activation_cache)
    return A, cache
def L_model_forward(X, parameters):
    """
    Implement forward propagation for the [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID computation
    Arguments:
    X -- data, numpy array of shape (input size, number of examples)
    parameters -- output of initialize_parameters_deep()
    Returns:
    AL -- last post-activation value
    caches -- list of caches containing:
                every cache of linear_relu_forward() (there are L-1 of them, indexed from 0 to L-2)
                the cache of linear_sigmoid_forward() (there is one, indexed L-1)
    """
    caches = []
    A = X
    L = len(parameters) // 2                  # number of layers in the neural network
    # Implement [LINEAR -> RELU]*(L-1). Add "cache" to the "caches" list.
    for l in range(1, L):
        A_prev = A
        A, cache = linear_activation_forward(A_prev, parameters['W' + str(l)], parameters['b' + str(l)], activation = "relu")
        caches.append(cache)
    # Implement LINEAR -> SIGMOID. Add "cache" to the "caches" list.
    AL, cache = linear_activation_forward(A, parameters['W' + str(L)], parameters['b' + str(L)], activation = "sigmoid")
    caches.append(cache)
    assert(AL.shape == (1,X.shape[1]))
    return AL, caches
def compute_cost(AL, Y):
    """
    Implement the cost function defined by equation (7).
    Arguments:
    AL -- probability vector corresponding to your label predictions, shape (1, number of examples)
    Y -- true "label" vector (for example: containing 0 if non-cat, 1 if cat), shape (1, number of examples)
    Returns:
    cost -- cross-entropy cost
    """
    m = Y.shape[1]
    # Compute loss from aL and y.
    cost = (1./m) * (-np.dot(Y,np.log(AL).T) - np.dot(1-Y, np.log(1-AL).T))
    cost = np.squeeze(cost)      # To make sure your cost's shape is what we expect (e.g. this turns [[17]] into 17).
    assert(cost.shape == ())
    return cost
def linear_backward(dZ, cache):
    """
    Implement the linear portion of backward propagation for a single layer (layer l)
    Arguments:
    dZ -- Gradient of the cost with respect to the linear output (of current layer l)
    cache -- tuple of values (A_prev, W, b) coming from the forward propagation in the current layer
    Returns:
    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
    db -- Gradient of the cost with respect to b (current layer l), same shape as b
    """
    A_prev, W, b = cache
    m = A_prev.shape[1]
    dW = 1./m * np.dot(dZ,A_prev.T)
    db = 1./m * np.sum(dZ, axis = 1, keepdims = True)
    dA_prev = np.dot(W.T,dZ)
    assert (dA_prev.shape == A_prev.shape)
    assert (dW.shape == W.shape)
    assert (db.shape == b.shape)
    return dA_prev, dW, db
def linear_activation_backward(dA, cache, activation):
    """
    Implement the backward propagation for the LINEAR->ACTIVATION layer.
    Arguments:
    dA -- post-activation gradient for current layer l
    cache -- tuple of values (linear_cache, activation_cache) we store for computing backward propagation efficiently
    activation -- the activation to be used in this layer, stored as a text string: "sigmoid" or "relu"
    Returns:
    dA_prev -- Gradient of the cost with respect to the activation (of the previous layer l-1), same shape as A_prev
    dW -- Gradient of the cost with respect to W (current layer l), same shape as W
    db -- Gradient of the cost with respect to b (current layer l), same shape as b
    """
    linear_cache, activation_cache = cache
    if activation == "relu":
        dZ = relu_backward(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)
    elif activation == "sigmoid":
        dZ = sigmoid_backward(dA, activation_cache)
        dA_prev, dW, db = linear_backward(dZ, linear_cache)
    return dA_prev, dW, db
def L_model_backward(AL, Y, caches):
    """
    Implement the backward propagation for the [LINEAR->RELU] * (L-1) -> LINEAR -> SIGMOID group
    Arguments:
    AL -- probability vector, output of the forward propagation (L_model_forward())
    Y -- true "label" vector (containing 0 if non-cat, 1 if cat)
    caches -- list of caches containing:
                every cache of linear_activation_forward() with "relu" (there are (L-1) or them, indexes from 0 to L-2)
                the cache of linear_activation_forward() with "sigmoid" (there is one, index L-1)
    Returns:
    grads -- A dictionary with the gradients
             grads["dA" + str(l)] = ...
             grads["dW" + str(l)] = ...
             grads["db" + str(l)] = ...
    """
    grads = {}
    L = len(caches) # the number of layers
    m = AL.shape[1]
    Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL
    # Initializing the backpropagation
    dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))
    # Lth layer (SIGMOID -> LINEAR) gradients. Inputs: "AL, Y, caches". Outputs: "grads["dAL"], grads["dWL"], grads["dbL"]
    current_cache = caches[L-1]
    grads["dA" + str(L-1)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache, activation = "sigmoid")
    for l in reversed(range(L-1)):
        # lth layer: (RELU -> LINEAR) gradients.
        current_cache = caches[l]
        dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 1)], current_cache, activation = "relu")
        grads["dA" + str(l)] = dA_prev_temp
        grads["dW" + str(l + 1)] = dW_temp
        grads["db" + str(l + 1)] = db_temp
    return grads
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 L_model_backward
    Returns:
    parameters -- python dictionary containing your updated parameters
                  parameters["W" + str(l)] = ...
                  parameters["b" + str(l)] = ...
    """
    L = len(parameters) // 2 # number of layers in the neural network
    # Update rule for each parameter. Use a for loop.
    for l in range(L):
        parameters["W" + str(l+1)] = parameters["W" + str(l+1)] - learning_rate * grads["dW" + str(l+1)]
        parameters["b" + str(l+1)] = parameters["b" + str(l+1)] - learning_rate * grads["db" + str(l+1)]
    return parameters
def predict(X, y, parameters):
    """
    This function is used to predict the results of a  L-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]
    n = len(parameters) // 2 # number of layers in the neural network
    p = np.zeros((1,m))
    # Forward propagation
    probas, caches = L_model_forward(X, parameters)
    # convert probas to 0/1 predictions
    for i in range(0, probas.shape[1]):
        if probas[0,i] > 0.5:
            p[0,i] = 1
        else:
            p[0,i] = 0
    #print results
    #print ("predictions: " + str(p))
    #print ("true labels: " + str(y))
    print("Accuracy: "  + str(np.sum((p == y)/m)))
    return p
def print_mislabeled_images(classes, X, y, p):
    """
    Plots images where predictions and truth were different.
    X -- dataset
    y -- true labels
    p -- predictions
    """
    a = p + y
    mislabeled_indices = np.asarray(np.where(a == 1))
    plt.rcParams['figure.figsize'] = (40.0, 40.0) # set default size of plots
    num_images = len(mislabeled_indices[0])
    for i in range(num_images):
        index = mislabeled_indices[1][i]
        plt.subplot(2, num_images, i + 1)
        plt.imshow(X[:,index].reshape(64,64,3), interpolation='nearest')
        plt.axis('off')
        plt.title("Prediction: " + classes[int(p[0,index])].decode("utf-8") + " \n Class: " + classes[y[0,index]].decode("utf-8"))

1 - 导入包

import time
import numpy as np
import h5py
import matplotlib.pyplot as plt
import scipy
from PIL import Image
from scipy import ndimage
import skimage
from dnn_app_utils_v3 import *
 
%matplotlib inline
plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
 
%load_ext autoreload
%autoreload 2
 
np.random.seed(1)

2 - 导入数据集（Cat vs non-Cat）

Problem Statement: You are given a dataset ("data.h5") containing:

• m_train个图像训练集（cat-1, non-cat-0）
• m_test个图像测试集（cat , non-cat）
• 每个图像的shape：（num_px, num_px, 3）(RGB)

train_x_orig, train_y, test_x_orig, test_y, classes = load_data()

下面的代码将显示数据集中的图像:

# Example of a picture
index = 19
plt.imshow(train_x_orig[index])
print ("y = " + str(train_y[0,index]) + ". It's a " + classes[train_y[0,index]].decode("utf-8") +  " picture.")

y = 1. It's a cat picture.

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAWAAAAFdCAYAAAA9hbc/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0Agg==" alt="" />

# Explore your dataset
m_train = train_x_orig.shape[0]
num_px = train_x_orig.shape[1]
m_test = test_x_orig.shape[0]
print ("Number of training examples: " + str(m_train))
print ("Number of testing examples: " + str(m_test))
print ("Each image is of size: (" + str(num_px) + ", " + str(num_px) + ", 3)")
print ("train_x_orig shape: " + str(train_x_orig.shape))
print ("train_y shape: " + str(train_y.shape))
print ("test_x_orig shape: " + str(test_x_orig.shape))
print ("test_y shape: " + str(test_y.shape))

Number of training examples: 209
Number of testing examples: 50
Each image is of size: (64, 64, 3)
train_x_orig shape: (209, 64, 64, 3)
train_y shape: (1, 209)
test_x_orig shape: (50, 64, 64, 3)
test_y shape: (1, 50)

2.2 reshape和标准化数据

# Reshape the training and test examples
train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T   # The "-1" makes reshape flatten the remaining dimensions
test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T
# Standardize data to have feature values between 0 and 1.
train_x = train_x_flatten/255.
test_x = test_x_flatten/255.
print ("train_x's shape: " + str(train_x.shape))
print ("test_x's shape: " + str(test_x.shape))

train_x's shape: (12288, 209)
test_x's shape: (12288, 50)

12,288 个 64×64×3 （重塑图像向量的 size）

3 - 模型的结构

你将构建两种不同的模型：一个2层神经网络和一个L层深层神经网络；然后比较两种模型的性能，并为 L 测试不同值

3.1 - 2-layer neural network

The model can be summarized as: INPUT -> LINEAR -> RELU -> LINEAR -> SIGMOID -> OUTPUT.

3.2 - L-layer deep neural network

The model can be summarized as: [LINEAR -> RELU] × (L-1) -> LINEAR -> SIGMOID

3.3 - 常规方法（构建深度学习）

1. Initialize parameters / Define hyperparameters （初始化参数/定义超参数）

2. Loop for num_iterations:（迭代 num_iterations 次）
      a. Forward propagation     (前向传播)
       b. Compute cost function  (计算代价函数)
       c. Backward propagation   (后向传播)
       d. Update parameters (using parameters, and grads from backprop) （更新参数--使用后向传播得到的参数和梯度）

4. Use trained parameters to predict labels （使用训练好的参数预测标签）

 

4 - 两层神经网络

Question: 使用下面函数实现该结构： LINEAR -> RELU -> LINEAR -> SIGMOID.

def initialize_parameters(n_x, n_h, n_y):
    ...
    return parameters
def linear_activation_forward(A_prev, W, b, activation):
    ...
    return A, cache
def compute_cost(AL, Y):
    ...
    return cost
def linear_activation_backward(dA, cache, activation):
    ...
    return dA_prev, dW, db
def update_parameters(parameters, grads, learning_rate):
    ...
    return parameters

### CONSTANTS DEFINING THE MODEL ####
n_x = 12288     # num_px * num_px * 3
n_h = 7
n_y = 1
layers_dims = (n_x, n_h, n_y)

# GRADED FUNCTION: two_layer_model
def two_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):
    """
    Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.
    Arguments:
    X -- input data, of shape (n_x, number of examples)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
    layers_dims -- dimensions of the layers (n_x, n_h, n_y)
    num_iterations -- number of iterations of the optimization loop
    learning_rate -- learning rate of the gradient descent update rule
    print_cost -- If set to True, this will print the cost every 100 iterations 
    Returns:
    parameters -- a dictionary containing W1, W2, b1, and b2
    """
    np.random.seed(1)
    grads = {}
    costs = []                              # to keep track of the cost
    m = X.shape[1]                           # number of examples
    (n_x, n_h, n_y) = layers_dims
    # Initialize parameters dictionary, by calling one of the functions you'd previously implemented
    ### START CODE HERE ### (≈ 1 line of code)
    parameters = initialize_parameters(n_x, n_h, n_y)
    ### END CODE HERE ###
    # Get W1, b1, W2 and b2 from the dictionary parameters.
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    # Loop (gradient descent)
    for i in range(0, num_iterations):
        # Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: "X, W1, b1". Output: "A1, cache1, A2, cache2".
        ### START CODE HERE ### (≈ 2 lines of code)
        A1, cache1 = linear_activation_forward(X, W1, b1, activation='relu')
        A2, cache2 = linear_activation_forward(A1, W2, b2, activation='sigmoid')
        ### END CODE HERE ###
        # Compute cost
        ### START CODE HERE ### (≈ 1 line of code)
        cost = compute_cost(A2, Y)
        ### END CODE HERE ###
        # Initializing backward propagation
        dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))
        # Backward propagation. Inputs: "dA2, cache2, cache1". Outputs: "dA1, dW2, db2; also dA0 (not used), dW1, db1".
        ### START CODE HERE ### (≈ 2 lines of code)
        dA1, dW2, db2 = linear_activation_backward(dA2, cache2, activation='sigmoid')
        dA0, dW1, db1 = linear_activation_backward(dA1, cache1, activation='relu')
        ### END CODE HERE ###
        # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2
        grads['dW1'] = dW1
        grads['db1'] = db1
        grads['dW2'] = dW2
        grads['db2'] = db2
        # Update parameters.
        ### START CODE HERE ### (approx. 1 line of code)
        parameters = update_parameters(parameters, grads, learning_rate=learning_rate)
        ### END CODE HERE ###
        # Retrieve W1, b1, W2, b2 from parameters
        W1 = parameters["W1"]
        b1 = parameters["b1"]
        W2 = parameters["W2"]
        b2 = parameters["b2"]
        # Print the cost every 100 training example
        if print_cost and i % 100 == 0:
            print("Cost after iteration {}: {}".format(i, np.squeeze(cost)))
        if print_cost and i % 100 == 0:
            costs.append(cost)
    # plot the cost
    plt.plot(np.squeeze(costs))
    plt.ylabel('cost')
    plt.xlabel('iterations (per tens)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()
    return parameters

parameters = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)

Cost after iteration 0: 0.693049735659989
Cost after iteration 100: 0.6464320953428849
Cost after iteration 200: 0.6325140647912678
Cost after iteration 300: 0.6015024920354665
Cost after iteration 400: 0.5601966311605748
Cost after iteration 500: 0.5158304772764729
Cost after iteration 600: 0.4754901313943325
Cost after iteration 700: 0.43391631512257495
Cost after iteration 800: 0.40079775362038844
Cost after iteration 900: 0.3580705011323798
Cost after iteration 1000: 0.3394281538366413
Cost after iteration 1100: 0.30527536361962654
Cost after iteration 1200: 0.27491377282130164
Cost after iteration 1300: 0.2468176821061486
Cost after iteration 1400: 0.19850735037466108
Cost after iteration 1500: 0.17448318112556666
Cost after iteration 1600: 0.17080762978097128
Cost after iteration 1700: 0.11306524562164708
Cost after iteration 1800: 0.09629426845937153
Cost after iteration 1900: 0.08342617959726871
Cost after iteration 2000: 0.07439078704319085
Cost after iteration 2100: 0.06630748132267934
Cost after iteration 2200: 0.059193295010381744
Cost after iteration 2300: 0.053361403485605585
Cost after iteration 2400: 0.048554785628770226

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAdAAAAGBCAYAAADWj+BSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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" alt="" />

predictions_train = predict(train_x, train_y, parameters)

Expected Output:

Accuracy

1.0

predictions_test = predict(test_x, test_y, parameters)

Expected Output:

Accuracy

0.72

5 - L层神经网络

Question: 使用下面函数实现该结构： [LINEAR -> RELU]×(L-1) -> LINEAR -> SIGMOID. 

def initialize_parameters_deep(layer_dims):
    ...
    return parameters
def L_model_forward(X, parameters):
    ...
    return AL, caches
def compute_cost(AL, Y):
    ...
    return cost
def L_model_backward(AL, Y, caches):
    ...
    return grads
def update_parameters(parameters, grads, learning_rate):
    ...
    return parameters

### CONSTANTS ###
layers_dims = [12288, 20, 7, 5, 1] #  5-layer model

# GRADED FUNCTION: L_layer_model
def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):#lr was 0.009
    """
    Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.
    Arguments:
    X -- data, numpy array of shape (number of examples, num_px * num_px * 3)
    Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
    layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).
    learning_rate -- learning rate of the gradient descent update rule
    num_iterations -- number of iterations of the optimization loop
    print_cost -- if True, it prints the cost every 100 steps
    Returns:
    parameters -- parameters learnt by the model. They can then be used to predict.
    """
    np.random.seed(1)
    costs = []                         # keep track of cost
    # Parameters initialization.
    ### START CODE HERE ###
    parameters = initialize_parameters_deep(layers_dims)
    ### END CODE HERE ###
    # Loop (gradient descent)
    for i in range(0, num_iterations):
        # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.
        ### START CODE HERE ### (≈ 1 line of code)
        AL, caches = L_model_forward(X, parameters)
        ### END CODE HERE ###
        # Compute cost.
        ### START CODE HERE ### (≈ 1 line of code)
        cost = compute_cost(AL, Y)
        ### END CODE HERE ###
        # Backward propagation.
        ### START CODE HERE ### (≈ 1 line of code)
        grads = L_model_backward(AL, Y, caches)
        ### END CODE HERE ###
        # Update parameters.
        ### START CODE HERE ### (≈ 1 line of code)
        parameters = update_parameters(parameters, grads, learning_rate=learning_rate)
        ### END CODE HERE ###
        # Print the cost every 100 training example
        if print_cost and i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))
        if print_cost and i % 100 == 0:
            costs.append(cost)
    # plot the cost
    plt.plot(np.squeeze(costs))
    plt.ylabel('cost')
    plt.xlabel('iterations (per tens)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()
    return parameters

parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)

Cost after iteration 0: 0.771749
Cost after iteration 100: 0.672053
Cost after iteration 200: 0.648263
Cost after iteration 300: 0.611507
Cost after iteration 400: 0.567047
Cost after iteration 500: 0.540138
Cost after iteration 600: 0.527930
Cost after iteration 700: 0.465477
Cost after iteration 800: 0.369126
Cost after iteration 900: 0.391747
Cost after iteration 1000: 0.315187
Cost after iteration 1100: 0.272700
Cost after iteration 1200: 0.237419
Cost after iteration 1300: 0.199601
Cost after iteration 1400: 0.189263
Cost after iteration 1500: 0.161189
Cost after iteration 1600: 0.148214
Cost after iteration 1700: 0.137775
Cost after iteration 1800: 0.129740
Cost after iteration 1900: 0.121225
Cost after iteration 2000: 0.113821
Cost after iteration 2100: 0.107839
Cost after iteration 2200: 0.102855
Cost after iteration 2300: 0.100897
Cost after iteration 2400: 0.092878

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAdAAAAGBCAYAAADWj+BSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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%0AtkyIwVwAAAAASUVORK5CYII=" alt="" />

pred_train = predict(train_x, train_y, parameters)

Train Accuracy

0.985645933014

pred_test = predict(test_x, test_y, parameters)

Expected Output:

Test Accuracy

0.8

在相同的测试集上，你的5层神经网络的性能(80%)比2层神经网络(72%)要好

6 - 结果分析

print_mislabeled_images(classes, test_x, test_y, pred_test)

有几种类型的图像模型往往做的不好，包括：

• 猫的身体在一个不寻常位置出现
• 猫的背景与背景相似
• 不寻常的猫色和各种相机角度亮度的图像尺度变化（猫很大或很小的图像）

7 - 测试你的图片

## START CODE HERE ##
my_image = "my_image2.jpg" # change this to the name of your image file
my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)
## END CODE HERE ##
fname = "images/" + my_image
image = np.array(plt.imread(fname))
my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))
my_predicted_image = predict(my_image, my_label_y, parameters)
plt.imshow(image)
print ("y = " + str(np.squeeze(my_predicted_image)) + ", your L-layer model predicts a \"" + classes[int(np.squeeze(my_predicted_image)),].decode("utf-8") +  "\" picture.")

Accuracy: 1.0
y = 1.0, your L-layer model predicts a "cat" picture.