Building your DNN & DNN for Image Classification: Application-2

版权为吴恩达老师所有，参考Koala_Tree的博客，部分根据自己实践添加

使用google翻译，部分手工翻译

你可能需要的参考资料 https://pan.baidu.com/s/1OvGGcVLSgVEJMoFu461B2Q

第2部分：图像分类的深度神经网络：应用

1 - 包

让我们首先导入在此分配期间您需要的所有包。
- numpy是使用Python进行科学计算的基础包。
- matplotlib是一个用Python绘制图形的库。
- h5py是与存储在H5文件中的数据集进行交互的通用包。
- 此处使用PIL和scipy来测试您的模型，最后使用您自己的图片。
- dnn_app_utils提供在“构建您的深度神经网络：逐步”中为此笔记本分配的功能。
- np.random.seed（1）用于保持所有随机函数调用一致。它将帮助我们评估您的工作。

import time
import numpy as np 
import h5py
import matplotlib.pyplot as plt 
import scipy
from PIL import Image
from scipy import ndimage
from dnn_app_utils_v2 import *

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

np.random.seed(1)

2 - 数据集

您将使用与“Logistic回归为神经网络”（作业2）相同的“Cat vs non-Cat”数据集。您构建的模型在对猫和非猫图像进行分类时具有70％的测试准确度。希望您的新模型表现更好！

问题陈述：您将获得一个数据集（“data.h5”），其中包含：
- 标记为cat（1）或非cat（0）的m_train图像的训练集
- 标记为cat和non的m_test图像的测试集cat
- 每个图像都是形状（num_px，num_px，3），其中3表示3个通道（RGB）。

让我们更熟悉数据集。通过运行下面的单元格加载数据。

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

以下代码将显示数据集中的图像。随意更改index并重复运行代码以查看其他图像。

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

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))

像往常一样，您在将图像送入网络之前对图像进行整形和标准化。代码在下面的单元格中给出。

还在路上，稍等...

train_x_flatten=train_x_orig.reshape(train_x_orig.shape[0],-1).T 
test_x_flatten=test_x_orig.reshape(test_x_orig.shape[0],-1).T 

train_x=train_x_flatten/255.0
test_x=test_x_flatten/2555.0

print ("train_x's shape: " + str(train_x.shape))
print ("test_x's shape: " + str(test_x.shape))

12288等于64×64×3 这是一个重新成形的图像矢量的大小。

3 - 模型的架构

现在您已经熟悉了数据集，现在是时候构建一个深度神经网络来区分猫图像和非猫图像。

您将构建两个不同的模型：
- 2层神经网络
- L层深度神经网络

然后，您将比较这些模型的性能，并尝试不同的L值该.

让我们看看这两种架构。

3.1 - 2层神经网络

还在路上，稍等...

该模型可以概括为：INPUT - > LINEAR - > RELU - > LINEAR - > SIGMOID - > OUTPUT。

上图的详细结构：
-输入的是（64,64,3）的图像转换成的（12288，1）向量。
- 相应的向量： $[x_{1},x_{2},...,x_{12287}]^{T}$ 然后乘以权重矩阵 $W^{[1]}$ $(n^{[1]},12288)$ 。
- 然后你添加一个b,并通过relu函数得到以下向量： $[a_{0}^{[1]},a_{1}^{[1]},...,a_{n^{[1]}-1}^{[1]},]^{T}$ 。
- 然后重复相同的过程。
- 将结果向量乘以 $W^{[2]}$ 并加上b。
- 最后，你取结果的sigmoid。如果它大于0.5，则将其归类为猫。

3.2 - L层深度神经网络

用上述表示很难表示L层深度神经网络。但是，这是一个简化的网络表示：

还在路上，稍等...

该模型可以概括为：[LINEAR - > RELU] × （L-1） - > LINEAR - > SIGMOID

上图的详细结构：
- 输入是（64,64,3）图像，其被变形为大小为（12288,1）的向量。
- 相应的向量： $[x_{1},x_{2},...,x_{12287}]^{T}$ 然后乘以权重矩阵 $W^{[1]}$ 并加上 $b^{[1]}$ 。结果称为线性单位。
- 接下来，你拿线性单元的relu。这个过程可以重复几次 $(W^{[l]},b^{[l]})$ 取决于模型架构。
- 最后，你取最终线性单位的sigmoid。如果它大于0.5，则将其归类为猫。

3.3 - 一般方法

像往常一样，您将遵循深度学习方法来构建模型：
1.初始化参数/定义超参数
2.循环for num_iterations：
a.前向传播
b.计算成本函数
c.向后传播
d.更新参数（使用参数和backprop的梯度）
4.使用经过训练的参数来预测

我们现在实现这两个模型吧！

4 - 双层神经网络

问题：使用您在先前任务中实现的辅助函数来构建具有以下结构的2层神经网络：LINEAR - > RELU - > LINEAR - > SIGMOID。您可能需要的功能及其输入是：

def two_layer_model(X,Y,layer_dims,learning_rate=0.0075,num_iterations=3000,print_cost=False):
    np.random.seed(1)
    grads={}
    costs=[]
    m=X.shape[1]
    (n_x,n_h,n_y)=layer_dims

    parameters=initialize_parameters(n_x,n_h,n_y)

    W1=parameters["W1"]
    b1=parameters["b1"]
    W2=parameters["W2"]
    b2=parameters["b2"]

    for i in range(0,num_iterations):
        A1,cache1=linear_activation_forward(X,W1,b1,activation="relu")
        A2,cache2=linear_activation_forward(A1,W2,b2,activation="sigmoid")

        cost=compute_cost(A2,Y)

        dA2=-(np.divide(Y,A2)-np.divide(1-Y,1-A2))

        dA1,dW2,db2=linear_activation_backward(dA2,cache2,activation="sigmoid")
        dA0,dW1,db1=linear_activation_backward(dA1,cache1,activation="relu")

        grads["dW1"]=dW1
        grads["db1"]=db1
        grads["dW2"]=dW2
        grads["db2"]=db2

        parameters=update_parameters(parameters,grads,learning_rate)

        W1=parameters["W1"]
        b1=parameters["b1"]
        W2=parameters["W2"]
        b2=parameters["b2"]

        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)

    plt.plot(np.squeeze(costs))
    plt.ylabel("cost")
    plt.xlabel("iterations (per tens)")
    plt.title("learning rate = "+str(learning_rate))
    plt.show()

    return parameters

n_x = 12288     # num_px * num_px * 3
n_h = 7
n_y = 1
layers_dims = (n_x, n_h, n_y)
parameters = two_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost=True)

运行下面的单元格来训练您的参数。看看你的模型是否运行。成本应该在下降。运行2500次迭代可能需要5分钟。检查“迭代后的成本0”是否与下面的预期输出匹配

你构建了一个矢量化实现的好东西！否则可能需要花费10倍的时间来训练它。

现在，您可以使用训练的参数对数据集中的图像进行分类。要查看有关训练和测试集的预测，请运行下面的代码。

predictions_train = predict(train_x, train_y, parameters)

predictions_test = predict(test_x, test_y, parameters)

注意：您可能会注意到，在较少的迭代（例如1500）上运行模型可以提高测试集的准确性。这被称为“提前停止”，我们将在下一个课程中讨论它。提前停车是防止过度装配的一种方法。

恭喜！您的2层神经网络似乎比逻辑回归实施（70％，任务第2周）具有更好的性能（72％）。让我们看看你是否可以用L做得更好该层模型。

5 - L层神经网络

问题：使用先前实现的辅助函数构建L该具有以下结构的层神经网络：[LINEAR - > RELU] ×（L-1） - > LINEAR - > SIGMOID。您可能需要的功能及其输入是：

def L_layer_model(X,Y,layer_dims,learning_rate=0.0075,num_iterations=3000,print_cost=False):
    np.random.seed(1)
    costs=[]

    parameters=initialize_parameters_deep(layer_dims)

    for i in range(0,num_iterations):
        AL,caches=L_model_forward(X,parameters)
        cost=compute_cost(AL,Y)
        grads=L_model_backward(AL,Y,caches)
        parameters=update_parameters(parameters,grads,learning_rate)

        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)
    
    plt.plot(np.squeeze(costs))
    plt.ylabel('cost')
    plt.xlabel('iterations (per tens)')
    plt.title("Learning rate =" + str(learning_rate))
    plt.show()

    return parameters

layers_dims = [12288, 20, 7, 5, 1]
parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)

您现在将模型训练为5层神经网络。

运行下面的单元格来训练您的模型。每次迭代都会降低成本。运行2500次迭代可能需要5分钟

pred_train = predict(train_x, train_y, parameters)

pred_test = predict(test_x, test_y, parameters)

恭喜！在同一测试集中，您的5层神经网络似乎比2层神经网络（72％）具有更好的性能（80％）。

这是此任务的良好表现。不错的工作！

虽然在接下来的“改进深度神经网络”课程中，您将学习如何通过系统地搜索更好的超参数（learning_rate，layers_dims，num_iterations以及您将在下一课程中学习的其他内容）来获得更高的准确度。

6）结果分析

首先，让我们看一下L层模型标记错误的一些图像。这将显示一些贴错标签的图像。

print_mislabeled_images(classes, test_x, test_y, pred_test)

还在路上，稍等...

说实话,在我运行上述代码看到的图像是这样的:

模型往往表现不佳的几种类型的图像包括：
- 猫身体处于不寻常的位置
- 猫出现在相似颜色的背景下
- 不寻常的猫颜色和物种
- 相机角度
- 图片的亮度
- 比例变化（猫是非常大或小的图像）

7）用你自己的图像进行测试（可选/未分级练习）

恭喜你完成了这项任务。您可以使用自己的图像并查看模型的输出。

my_image = "my_image.jpg"  
my_label_y = [1] 

fname = 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)
plt.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.")

测试图像: