[关闭]
@Perfect-Demo 2018-05-01T08:42:13.000000Z 字数 8271 阅读 1020

deep_learning_week4.2_Deep_Neural_Network

机器学习深度学习

代码已上传github:
https://github.com/PerfectDemoT/my_deeplearning_homework

1.1

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

  1. import time
  2. import numpy as np
  3. import h5py
  4. import matplotlib.pyplot as plt
  5. import scipy
  6. import pylab #这个包是为了后面显示图片用的
  7. from PIL import Image
  8. from scipy import ndimage
  9. from dnn_app_utils import * #这里导入的就是前一篇写好的各个函数。

然后老样子，和上一篇一样，先设置一下绘图尺寸，颜色啥的。。。

  1. #%matplotlib inline
  2. plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
  3. plt.rcParams['image.interpolation'] = 'nearest'
  4. plt.rcParams['image.cmap'] = 'gray'
  6. #%load_ext autoreload
  7. #%autoreload 2 ​
  8. np.random.seed(1)

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

  1. #导入数据
  2. train_x_orig, train_y, test_x_orig, test_y, classes = load_data()
  4. # Example of a picture显示一下
  5. index = 10
  6. plt.imshow(train_x_orig[index])
  7. pylab.show()
  8. print ("y = " + str(train_y[0,index]) + ". It's a " + classes[train_y[0,index]].decode("utf-8") +  " picture.")
  12. # Explore your dataset
  13. m_train = train_x_orig.shape[0]
  14. num_px = train_x_orig.shape[1]
  15. m_test = test_x_orig.shape[0]
  17. print ("Number of training examples: " + str(m_train))
  18. print ("Number of testing examples: " + str(m_test))
  19. print ("Each image is of size: (" + str(num_px) + ", " + str(num_px) + ", 3)")
  20. print ("train_x_orig shape: " + str(train_x_orig.shape))
  21. print ("train_y shape: " + str(train_y.shape))
  22. print ("test_x_orig shape: " + str(test_x_orig.shape))
  23. print ("test_y shape: " + str(test_y.shape))
  24. print("================================")
  26. #Reshape the training and test examples 向量化一下
  27. train_x_flatten = train_x_orig.reshape(train_x_orig.shape[0], -1).T   # The "-1" makes reshape flatten the remaining dimensions
  28. test_x_flatten = test_x_orig.reshape(test_x_orig.shape[0], -1).T
  30. # Standardize data to have feature values between 0 and 1.
  31. train_x = train_x_flatten/255.
  32. test_x = test_x_flatten/255.
  34. print ("train_x's shape: " + str(train_x.shape))
  35. print ("test_x's shape: " + str(test_x.shape))
  36. print("====================================")

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

  1. #来看看这个两层的模型
  2. # GRADED FUNCTION: two_layer_model
  3. def two_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False):
  4.     """
  5.     Implements a two-layer neural network: LINEAR->RELU->LINEAR->SIGMOID.
  7.     Arguments:
  8.     X -- input data, of shape (n_x, number of examples)
  9.     Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
  10.     layers_dims -- dimensions of the layers (n_x, n_h, n_y)
  11.     num_iterations -- number of iterations of the optimization loop
  12.     learning_rate -- learning rate of the gradient descent update rule
  13.     print_cost -- If set to True, this will print the cost every 100 iterations
  15.     Returns:
  16.     parameters -- a dictionary containing W1, W2, b1, and b2
  17.     """
  19.     np.random.seed(1)
  20.     grads = {}
  21.     costs = []  # to keep track of the cost
  22.     m = X.shape[1]  # number of examples
  23.     (n_x, n_h, n_y) = layers_dims
  25.     # Initialize parameters dictionary, by calling one of the functions you'd previously implemented
  26.     ### START CODE HERE ### (≈ 1 line of code)
  27.     parameters = initialize_parameters(n_x, n_h, n_y)
  28.     ### END CODE HERE ###
  30.     # Get W1, b1, W2 and b2 from the dictionary parameters.
  31.     W1 = parameters["W1"]
  32.     b1 = parameters["b1"]
  33.     W2 = parameters["W2"]
  34.     b2 = parameters["b2"]
  36.     # Loop (gradient descent)
  38.     for i in range(0, num_iterations):
  39.         # Forward propagation: LINEAR -> RELU -> LINEAR -> SIGMOID. Inputs: "X, W1, b1". Output: "A1, cache1, A2, cache2".
  40.         ### START CODE HERE ### (≈ 2 lines of code)
  41.         A1, cache1 = linear_activation_forward(X, W1, b1, activation = 'relu')
  42.         A2, cache2 = linear_activation_forward(A1, W2, b2, activation = 'sigmoid')
  43.         ### END CODE HERE ###
  45.         # Compute cost
  46.         ### START CODE HERE ### (≈ 1 line of code)
  47.         cost = compute_cost(A2, Y)
  48.         ### END CODE HERE ###
  50.         # Initializing backward propagation
  51.         dA2 = - (np.divide(Y, A2) - np.divide(1 - Y, 1 - A2))
  53.         # Backward propagation. Inputs: "dA2, cache2, cache1". Outputs: "dA1, dW2, db2; also dA0 (not used), dW1, db1".
  54.         ### START CODE HERE ### (≈ 2 lines of code)
  55.         dA1, dW2, db2 = linear_activation_backward(dA2, cache2, activation = 'sigmoid')
  56.         dA0, dW1, db1 = linear_activation_backward(dA1, cache1, activation = 'relu')
  57.         ### END CODE HERE ###
  59.         # Set grads['dWl'] to dW1, grads['db1'] to db1, grads['dW2'] to dW2, grads['db2'] to db2
  60.         grads['dW1'] = dW1
  61.         grads['db1'] = db1
  62.         grads['dW2'] = dW2
  63.         grads['db2'] = db2
  65.         # Update parameters.
  66.         ### START CODE HERE ### (approx. 1 line of code)
  67.         parameters = update_parameters(parameters, grads, learning_rate)
  68.         ### END CODE HERE ###
  70.         # Retrieve W1, b1, W2, b2 from parameters
  71.         W1 = parameters["W1"]
  72.         b1 = parameters["b1"]
  73.         W2 = parameters["W2"]
  74.         b2 = parameters["b2"]
  76.         # Print the cost every 100 training example
  77.         if print_cost and i % 100 == 0:
  78.             print("Cost after iteration {}: {}".format(i, np.squeeze(cost)))
  79.         if print_cost and i % 100 == 0:
  80.             costs.append(cost)
  82.     # plot the cost
  83.     plt.plot(np.squeeze(costs))
  84.     plt.ylabel('cost')
  85.     plt.xlabel('iterations (per tens)')
  86.     plt.title("Learning rate =" + str(learning_rate))
  87.     plt.show()
  89.     return parameters
  92. #调用一下
  93. parameters = two_layer_model(train_x, train_y, layers_dims = (n_x, n_h, n_y), num_iterations = 2500, print_cost=True)
  96. #下面用训练集和验证集分别看看准确度
  97. #predictions_train = predict(train_x, train_y, parameters)
  98. #训练集准确度百分之百
  99. #predictions_test = predict(test_x, test_y, parameters)
  100. #测试集准确度百分之七十二

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

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

先上代码：

  1. #接下来开始N层的神经网络
  2. ### CONSTANTS ###
  3. #先设置一下各层的神经元数目
  4. #当然，也可以在后面调用的时候设置这个数组
  5. layers_dims = [12288 , 20 , 7 , 5 , 1] #  5-layer model
  7. # GRADED FUNCTION: L_layer_model
  8. def L_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False):  # lr was 0.009
  9.     """
  10.     Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID.
  12.     Arguments:
  13.     X -- data, numpy array of shape (number of examples, num_px * num_px * 3)
  14.     Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples)
  15.     layers_dims -- list containing the input size and each layer size, of length (number of layers + 1).
  16.     learning_rate -- learning rate of the gradient descent update rule
  17.     num_iterations -- number of iterations of the optimization loop
  18.     print_cost -- if True, it prints the cost every 100 steps
  20.     Returns:
  21.     parameters -- parameters learnt by the model. They can then be used to predict.
  22.     """
  23.     np.random.seed(1)
  24.     costs = []  # keep track of cost
  26.     # Parameters initialization.
  27.     ### START CODE HERE ###
  28.     parameters = initialize_parameters_deep(layers_dims)
  29.     ### END CODE HERE ###
  31.     # Loop (gradient descent)
  32.     for i in range(0, num_iterations):
  33.         #Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID.
  34.         ### START CODE HERE ### (≈ 1 line of code)
  35.         AL, caches = L_model_forward(X, parameters)
  36.         ### END CODE HERE ###
  38.         # Compute cost.
  39.         ### START CODE HERE ### (≈ 1 line of code)
  40.         cost = compute_cost(AL, Y)
  41.         ### END CODE HERE ###
  43.         # Backward propagation.
  44.         ### START CODE HERE ### (≈ 1 line of code)
  45.         grads = L_model_backward(AL, Y, caches)
  46.         ### END CODE HERE ###
  48.         # Update parameters.
  49.         ### START CODE HERE ### (≈ 1 line of code)
  50.         parameters = update_parameters(parameters, grads, learning_rate)
  51.         ### END CODE HERE ###
  53.         # Print the cost every 100 training example
  54.         if print_cost and i % 100 == 0:
  55.             print("Cost after iteration %i: %f" % (i, cost))
  56.         if print_cost and i % 100 == 0:
  57.             costs.append(cost)
  59.     # plot the cost
  60.     plt.plot(np.squeeze(costs))
  61.     plt.ylabel('cost')
  62.     plt.xlabel('iterations (per tens)')
  63.     plt.title("Learning rate =" + str(learning_rate))
  64.     plt.show()
  66.     return parameters

上面就是这个分类器了，赶紧来调用一下

  1. #调用一下
  2. parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)

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

  1. Cost after iteration 0: 0.771749
  2. Cost after iteration 100: 0.673350
  3. Cost after iteration 200: 0.648247
  4. Cost after iteration 300: 0.620384
  5. Cost after iteration 400: 0.568401
  6. Cost after iteration 500: 0.520754
  7. Cost after iteration 600: 0.469203
  8. Cost after iteration 700: 0.487263
  9. Cost after iteration 800: 0.358436
  10. Cost after iteration 900: 0.347641
  11. Cost after iteration 1000: 0.291955
  12. Cost after iteration 1100: 0.273223
  13. Cost after iteration 1200: 0.229250
  14. Cost after iteration 1300: 0.196667
  15. Cost after iteration 1400: 0.176585
  16. Cost after iteration 1500: 0.157727
  17. Cost after iteration 1600: 0.142742
  18. Cost after iteration 1700: 0.139015
  19. Cost after iteration 1800: 0.123863
  20. Cost after iteration 1900: 0.111514
  21. Cost after iteration 2000: 0.105953
  22. Cost after iteration 2100: 0.098199
  23. Cost after iteration 2200: 0.094213
  24. Cost after iteration 2300: 0.087161
  25. Cost after iteration 2400: 0.082077

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

然后输出cost-num_itera的曲线
cost下降曲线

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

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

得到：

  1. train_Accuracy: 1.0
  2. test_Accuracy: 0.84

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

  1. #测试一下自己的图片
  2. ## START CODE HERE ##
  3. my_image = "my_image.jpg" # change this to the name of your image file
  4. my_label_y = [1] # the true class of your image (1 -> cat, 0 -> non-cat)
  5. ## END CODE HERE ##
  7. fname = "images/" + my_image
  8. image = np.array(ndimage.imread(fname, flatten=False))
  9. my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((num_px*num_px*3,1))
  10. my_predicted_image = predict(my_image, my_label_y, parameters)
  12. plt.imshow(image)
  13. pylab.show()
  14. 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.")

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

猫咪预测

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

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

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注