吴恩达deep_learning_week4.2_Deep_Neural_Network

标签： 机器学习深度学习

---

1.1

首先先导入包，（注意这和上一篇有一点不一样，多了一个包）

import time
import numpy as np
import h5py
import matplotlib.pyplot as plt
import scipy
import pylab #这个包是为了后面显示图片用的
from PIL import Image
from scipy import ndimage
from dnn_app_utils 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)

然后开始导入数据，向量化，归一化，输出看看（之前的几篇文章都有详细一步步介绍，此不赘述，直接贴出代码）

#导入数据
train_x_orig, train_y, test_x_orig, test_y, classes = load_data()

# Example of a picture显示一下
index = 10
plt.imshow(train_x_orig[index])
pylab.show()
print ("y = " + str(train_y[0,index]) + ". It's a " + classes[train_y[0,index]].decode("utf-8") +  " picture.")



# 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))
print("================================")

#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))
print("====================================")

1.2 慢慢一步步来，并且对照效果，我们这里先试一试两层神经的网络的分类器模型（前面的文章对此已经介绍过，此不详细说明啦）

#来看看这个两层的模型
# 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)
        ### 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)


#下面用训练集和验证集分别看看准确度
#predictions_train = predict(train_x, train_y, parameters)
#训练集准确度百分之百
#predictions_test = predict(test_x, test_y, parameters)
#测试集准确度百分之七十二

说明一下，上面的函数虽然用了,layers_dims数组来存储所有的神经网络层的结点个数，不过内部只进行了两层的计算，所以没有扩展到N层的能力。

---

2.1 好了，现在开始真正的表演，建立一个可扩展的（即：可以自己设定要多少层网络，以及每层多少个结点）

先上代码：

#接下来开始N层的神经网络
### 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)
        ### 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)

别慌，这个一调用，会花不少训练时间，在此期间可以看看每经过100次运算，你所得到的cost函数是多少
过程如下：

Cost after iteration 0: 0.771749
Cost after iteration 100: 0.673350
Cost after iteration 200: 0.648247
Cost after iteration 300: 0.620384
Cost after iteration 400: 0.568401
Cost after iteration 500: 0.520754
Cost after iteration 600: 0.469203
Cost after iteration 700: 0.487263
Cost after iteration 800: 0.358436
Cost after iteration 900: 0.347641
Cost after iteration 1000: 0.291955
Cost after iteration 1100: 0.273223
Cost after iteration 1200: 0.229250
Cost after iteration 1300: 0.196667
Cost after iteration 1400: 0.176585
Cost after iteration 1500: 0.157727
Cost after iteration 1600: 0.142742
Cost after iteration 1700: 0.139015
Cost after iteration 1800: 0.123863
Cost after iteration 1900: 0.111514
Cost after iteration 2000: 0.105953
Cost after iteration 2100: 0.098199
Cost after iteration 2200: 0.094213
Cost after iteration 2300: 0.087161
Cost after iteration 2400: 0.082077

真是跑了一会儿啊，这多几层，，，跑一天不是梦。。。

然后输出cost-num_itera的曲线

cost下降曲线

然后输出了对于训练集和测试集的准确率

#看看训练集的准确度
pred_train = predict(train_x, train_y, parameters)
#看看测试集的准确度
pred_test = predict(test_x, test_y, parameters)

得到：

train_Accuracy: 1.0
test_Accuracy: 0.84

现在可以拿自己的图跑一跑啦，看看它认不认识你的猫咪

#测试一下自己的图片
## START CODE HERE ##
my_image = "my_image.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(ndimage.imread(fname, flatten=False))
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)
pylab.show()
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.")

会显示一下你的图片，然后下面输出预测：

猫咪预测

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

好了，我们的猫咪检测器就这样做好了！！！