吴恩达2021年版深度学习作业(编程作业)第一章Week4深层神经网络 assigment4_2

最新推荐文章于 2023-11-13 16:56:43 发布

Alex_Tlover

最新推荐文章于 2023-11-13 16:56:43 发布

阅读量101

点赞数

分类专栏：吴恩达深度学习编程作业文章标签：深度学习神经网络 python

本文链接：https://blog.csdn.net/Alex_Tlover/article/details/129625373

版权

吴恩达深度学习编程作业专栏收录该内容

5 篇文章 0 订阅

订阅专栏

图片分类深层神经网络：应用

当你完成了本编程任务，你就完成了第四周的最后一个编程任务，也是这一章节的最后一个编程任务。

你将会使用在之前的编程任务中实现的函数来构建一个神经网络，并且将它应用到猫\非猫的分类中。希望你在精度方面能看到相对于之前实现的逻辑回归而言有所改善。

本编程任务之后，你讲会学习到：

构建并应用一个基于有监督学习的深层神经网络

让我们开始吧！


# Deep Neural Network for Image Classification: Application

When you finish this, you will have finished the last programming assignment of Week 4, and also the last programming assignment of this course! 

You will use use the functions you'd implemented in the previous assignment to build a deep network, and apply it to cat vs non-cat classification. Hopefully, you will see an improvement in accuracy relative to your previous logistic regression implementation.  

**After this assignment you will be able to:**
- Build and apply a deep neural network to supervised learning. 

Let's get started!

函数包

让我们先导入本任务所需要的所有函数包

numpy是Python中用于科学计算的重要函数包

matplotlib是Python中用于画图的库

h5py是一个与h5文件交互常用的函数包

PIL用于在最后使用自己的图片测试自己的模型

dnn_app_utils提供了构建你自己的神经网络所需要的函数：在上个编程任务中实现的函数

np.random.seed(1)是用来保持所有随机函数调用的一致性.这能帮助我们测评你的工作,请不要改变seed中的值


## 1 - Packages

Let's first import all the packages that you will need during this assignment. 
- [numpy](www.numpy.org) is the fundamental package for scientific computing with Python.
- [matplotlib](http://matplotlib.org) is a library to plot graphs in Python.
- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.
- [PIL](http://www.pythonware.com/products/pil/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end.
- dnn_app_utils provides the functions implemented in the "Building your Deep Neural Network: Step by Step" assignment to this notebook.
- np.random.seed(1) is used to keep all the random function calls consistent. It will help us grade your work.



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 *

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

数据集

你将会使用和“逻辑回归神经网络”(Assignment 2)一样的“猫\非猫“数据集。区分猫\非猫图片测试集精度为70%的模型。希望你的新模型能表现得更好。

问题表述：

你有一个数据集("data.h5"),其中包括：

一个包涵m_train个具有猫\非猫标注的图片训练集

一个包含m_test个具有猫\非猫标注的图片测试集

每张图片的维度都是(num_px,num_px,3)，其中3是3个RGB通道

为了更加深入了解数据集。运行下面的代码来加载你的数据集。


## 2 - Dataset

You will use the same "Cat vs non-Cat" dataset as in "Logistic Regression as a Neural Network" (Assignment 2). The model you had built had 70% test accuracy on classifying cats vs non-cats images. Hopefully, your new model will perform a better!

**Problem Statement**: You are given a dataset ("data.h5") containing:
    - a training set of m_train images labelled as cat (1) or non-cat (0)
    - a test set of m_test images labelled as cat and non-cat
    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB).

Let's get more familiar with the dataset. Load the data by running the cell below.


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

下面的代码会展示在数据集内的图片，你可以自由更换index内的值来多次运行下面的代码来查看更多的图片。


The following code will show you an image in the dataset. Feel free to change the index and re-run the cell multiple times to see other images.



# Example of a picture
index = 7
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.")

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

"""
**Expected Output**:

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

通常而言，你需要reshape照片的维度并且使其标准化再将他们放到网络中去训练。下面是操作的代码：


As usual, you reshape and standardize the images before feeding them to the network. The code is given in the cell below.

<img src="images/imvectorkiank.png" style="width:450px;height:300px;">

<caption><center> <u>Figure 1</u>: Image to vector conversion. <br> </center></caption>



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

"""
**Expected Output**:
train_x's shape: (12288, 209)
test_x's shape: (12288, 50)
"""

12288 = 64*64*3,这就是一张照片reshape之后的维度大小


$12,288$ equals $64 \times 64 \times 3$ which is the size of one reshaped image vector.

模型框架

现在你以及很了解你的数据集了，是时候去构建一个深层神经网络去识别猫的图片了。

你将会构建两个不同的模型

2层神经网络

L层神经网络

你会在最后对比这两个网络，并且尝试在不同L(隐藏层数量)值下对比网络的表现

让我们开始探索这两个框架


## 3 - Architecture of your model

Now that you are familiar with the dataset, it is time to build a deep neural network to distinguish cat images from non-cat images.

You will build two different models:
- A 2-layer neural network
- An L-layer deep neural network

You will then compare the performance of these models, and also try out different values for $L$. 

Let's look at the two architectures.

3.1 - 2层神经网络

### 3.1 - 2-layer neural network

<img src="images/2layerNN_kiank.png" style="width:650px;height:400px;">
<caption><center> <u>Figure 2</u>: 2-layer neural network. <br> The model can be summarized as: ***INPUT -> LINEAR -> RELU -> LINEAR -> SIGMOID -> OUTPUT***. </center></caption>

<u>Detailed Architecture of figure 2</u>:
- The input is a (64,64,3) image which is flattened to a vector of size $(12288,1)$. 
- The corresponding vector: $[x_0,x_1,...,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ of size $(n^{[1]}, 12288)$.
- You then add a bias term and take its relu to get the following vector: $[a_0^{[1]}, a_1^{[1]},..., a_{n^{[1]}-1}^{[1]}]^T$.
- You then repeat the same process.
- You multiply the resulting vector by $W^{[2]}$ and add your intercept (bias). 
- Finally, you take the sigmoid of the result. If it is greater than 0.5, you classify it to be a cat.

3.2 - L层神经网络

### 3.2 - L-layer deep neural network

It is hard to represent an L-layer deep neural network with the above representation. However, here is a simplified network representation:

<img src="images/LlayerNN_kiank.png" style="width:650px;height:400px;">
<caption><center> <u>Figure 3</u>: L-layer neural network. <br> The model can be summarized as: ***[LINEAR -> RELU] $\times$ (L-1) -> LINEAR -> SIGMOID***</center></caption>

<u>Detailed Architecture of figure 3</u>:
- The input is a (64,64,3) image which is flattened to a vector of size (12288,1).
- The corresponding vector: $[x_0,x_1,...,x_{12287}]^T$ is then multiplied by the weight matrix $W^{[1]}$ and then you add the intercept $b^{[1]}$. The result is called the linear unit.
- Next, you take the relu of the linear unit. This process could be repeated several times for each $(W^{[l]}, b^{[l]})$ depending on the model architecture.
- Finally, you take the sigmoid of the final linear unit. If it is greater than 0.5, you classify it to be a cat.


Let's now implement those two models!

3.3 - 构建网络的常规方法

### 3.3 - General methodology

As usual you will follow the Deep Learning methodology to build the model:
    1. Initialize parameters / Define hyperparameters
    2. Loop for 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

2层神经网络

问题：使用之前实现的辅助函数来帮助你构建以下结构的2层神经网络：

*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


## 4 - Two-layer neural network

**Question**:  Use the helper functions you have implemented in the previous assignment to build a 2-layer neural network with the following structure: *LINEAR -> RELU -> LINEAR -> SIGMOID*. The functions you may need and their inputs are:
```python
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)
        W1,b1, W2 ,b2  = update_parameters(parameters,grads,learning_rate)

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

Run the cell below to train your parameters. See if your model runs. The cost should be decreasing.It may take up to 5 minutes to run 2500 iterations.Check if the "Cost after iteration 0" matches the expected output below, if not click on the square (⬛) on the upper bar of the notebook to stop the cell and try to find your error.


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.5601966311605746
Cost after iteration 500: 0.515830477276473
Cost after iteration 600: 0.47549013139433255
Cost after iteration 700: 0.43391631512257495
Cost after iteration 800: 0.4007977536203889
Cost after iteration 900: 0.35807050113237976
Cost after iteration 1000: 0.3394281538366412
Cost after iteration 1100: 0.30527536361962637
Cost after iteration 1200: 0.2749137728213017
Cost after iteration 1300: 0.24681768210614846
Cost after iteration 1400: 0.19850735037466102
Cost after iteration 1500: 0.1744831811255664
Cost after iteration 1600: 0.17080762978095992
Cost after iteration 1700: 0.11306524562164728
Cost after iteration 1800: 0.09629426845937153
Cost after iteration 1900: 0.08342617959726856
Cost after iteration 2000: 0.07439078704319078
Cost after iteration 2100: 0.06630748132267929
Cost after iteration 2200: 0.059193295010381654
Cost after iteration 2300: 0.0533614034856055
Cost after iteration 2400: 0.04855478562877014

”“”


Run the cell below to train your parameters. See if your model runs. The cost should be decreasing. It may take up to 5 minutes to run 2500 iterations. Check if the "Cost after iteration 0" matches the expected output below, if not click on the square (⬛) on the upper bar of the notebook to stop the cell and try to find your error.

幸好你使用了向量化来进行实现，否则你可能花费超过这十倍的时间去训练你的网络。

现在你已经训练了一些参数去区分你的图片，运行下面的代码观察你的模型关于训练集以及测试集的表现。


Good thing you built a vectorized implementation! Otherwise it might have taken 10 times longer to train this.

Now, you can use the trained parameters to classify images from the dataset. To see your predictions on the training and test sets, run the cell below.



predictions_train = predict(train_x, train_y, parameters)
"""
**Expected Output**:
Accuracy: 0.9999999999999998
"""




predictions_test = predict(test_x, test_y, parameters)


"""
**Expected Output**:
Accuracy: 0.72
"""

提示：你可能注意到了迭代次数更少的模型（1500）在测试集有更好的精度，这就叫做“早停止”，下一章节我们会讲述有关的知识。早停是预防过拟合的手段之一。

恭喜！似乎你的2层神经网络比逻辑回归（70%，assugment week2）拥有更好的表现（72%）。让我们看看l层神经网络是否拥有更好的表现。


**Note**: You may notice that running the model on fewer iterations (say 1500) gives better accuracy on the test set. This is called "early stopping" and we will talk about it in the next course. Early stopping is a way to prevent overfitting. 

Congratulations! It seems that your 2-layer neural network has better performance (72%) than the logistic regression implementation (70%, assignment week 2). Let's see if you can do even better with an $L$-layer model.

L层神经网络

问题：使用之前实现的辅助函数来帮你构建一个以下结构的l层神经网络：

*[LINEAR -> RELU]$\times$(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


## 5 - L-layer Neural Network

**Question**: Use the helper functions you have implemented previously to build an $L$-layer neural network with the following structure: *[LINEAR -> RELU]$\times$(L-1) -> LINEAR -> SIGMOID*. The functions you may need and their inputs are:
```python
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
```

5层网络模型参数



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

现在你将会训练这个5层神经网络

运行以下代码来训练你的模型。损失函数应该会随着训练轮次的递增而减少。这可能会花费5分钟的时间去迭代2500次。检查"Cost after iteration 0"是否和预期的输出相匹配，如果不匹配，请单击jupyternotebook上方的停止按钮⬛来停止你的训练，并且尝试找出错误


You will now train the model as a 5-layer neural network. 

Run the cell below to train your model. The cost should decrease on every iteration. It may take up to 5 minutes to run 2500 iterations. Check if the "Cost after iteration 0" matches the expected output below, if not click on the square (⬛) on the upper bar of the notebook to stop the cell and try to find your error.



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

"""
**Expected Output**:
Cost after iteration 0: 0.695046
Cost after iteration 100: 0.589260
Cost after iteration 200: 0.523261
Cost after iteration 300: 0.449769
Cost after iteration 400: 0.420900
Cost after iteration 500: 0.372464
Cost after iteration 600: 0.347421
Cost after iteration 700: 0.317192
Cost after iteration 800: 0.266438
Cost after iteration 900: 0.219914
Cost after iteration 1000: 0.143579
Cost after iteration 1100: 0.453092
Cost after iteration 1200: 0.094994
Cost after iteration 1300: 0.080141
Cost after iteration 1400: 0.069402
Cost after iteration 1500: 0.060217
Cost after iteration 1600: 0.053274
Cost after iteration 1700: 0.047629
Cost after iteration 1800: 0.042976
Cost after iteration 1900: 0.039036
Cost after iteration 2000: 0.035683
Cost after iteration 2100: 0.032915
Cost after iteration 2200: 0.030472
Cost after iteration 2300: 0.028388
Cost after iteration 2400: 0.026615

"""

恭喜！似乎5层神经网络比2层神经网络（72%）在同一个测试集中拥有更好地表现（80%）



pred_train = predict(train_x, train_y, parameters)

pred_test = predict(test_x, test_y, parameters)
"""
**Expected Output**:
Accuracy: 0.9999999999999998
Accuracy: 0.74
"""

对于本次任务来说，这是一个好的表现。干得好！

通过下一章节"Improving deep neural networks"，你将会学习到如何通过系统地寻找更好地超参数（学习率，隐藏层数，迭代次数，其他）来拥有更高的精度。


Congrats! It seems that your 5-layer neural network has better performance (80%) than your 2-layer neural network (72%) on the same test set. 

This is good performance for this task. Nice job! 

Though in the next course on "Improving deep neural networks" you will learn how to obtain even higher accuracy by systematically searching for better hyperparameters (learning_rate, layers_dims, num_iterations, and others you'll also learn in the next course).

结果分析

首先，让我们来看看在l层神经网络被错误分类的图片。下面的代码将会展示一些错误分类的图片。


##  6) Results Analysis

First, let's take a look at some images the L-layer model labeled incorrectly. This will show a few mislabeled images.

一些在模型中被错误分类图片的特征：

猫的身体处于异常的位置

猫出现在与自身颜色相似的背景中

猫有不寻常的颜色和品种

摄像机的角度问题

图像过曝

尺度变化（小图片中猫占据很大的像素范围）


print_mislabeled_images(classes, test_x, test_y, pred_test)


**A few type of images the model tends to do poorly on include:** 
- Cat body in an unusual position
- Cat appears against a background of a similar color
- Unusual cat color and species
- Camera Angle
- Brightness of the picture
- Scale variation (cat is very large or small in image) 

"""

"""

测试你自己的图片（可选项/没有评分的内容）


## 7) Test with your own image (optional/ungraded exercise) ##

Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:
    1. Click on "File" in the upper bar of this notebook, then click "Open" to go on your Coursera Hub.
    2. Add your image to this Jupyter Notebook's directory, in the "images" folder
    3. Change your image's name in the following code
    4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!



## START CODE HERE ##

def L_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False,isPlot=True):
    """
    实现一个L层神经网络：[LINEAR-> RELU] *（L-1） - > LINEAR-> SIGMOID。

    参数：
	    X - 输入的数据，维度为(n_x，例子数)
        Y - 标签，向量，0为非猫，1为猫，维度为(1,数量)
        layers_dims - 层数的向量，维度为(n_y,n_h,···,n_h,n_y)
        learning_rate - 学习率
        num_iterations - 迭代的次数
        print_cost - 是否打印成本值，每100次打印一次
        isPlot - 是否绘制出误差值的图谱

    返回：
     parameters - 模型学习的参数。 然后他们可以用来预测。
    """
    np.random.seed(1)
    costs = []

    parameters = initialize_parameters_deep(layers_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)

        #打印成本值，如果print_cost=False则忽略
        if i % 100 == 0:
            #记录成本
            costs.append(cost)
            #是否打印成本值
            if print_cost:
                print("第", i ,"次迭代，成本值为：" ,np.squeeze(cost))
    #迭代完成，根据条件绘制图
    if isPlot:
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations (per tens)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()
    return parameters


## 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.")


parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True)
pred_train = predict(train_x, train_y, parameters)
pred_test = predict(test_x, test_y, parameters)

print_mislabeled_images(classes, test_x, test_y, pred_test)




“”“
第 0 次迭代，成本值为： 0.6950464961800915
第 100 次迭代，成本值为： 0.5892596054583805
第 200 次迭代，成本值为： 0.5232609173622991
第 300 次迭代，成本值为： 0.4497686396221906
第 400 次迭代，成本值为： 0.42090021618838996
第 500 次迭代，成本值为： 0.37246403061745953
第 600 次迭代，成本值为： 0.347420518702019
第 700 次迭代，成本值为： 0.31719191987370277
第 800 次迭代，成本值为： 0.2664377434774658
第 900 次迭代，成本值为： 0.21991432807842565
第 1000 次迭代，成本值为： 0.1435789889362378
第 1100 次迭代，成本值为： 0.45309212623221135
第 1200 次迭代，成本值为： 0.09499357670093511
第 1300 次迭代，成本值为： 0.08014128076781367
第 1400 次迭代，成本值为： 0.06940234005536465
第 1500 次迭代，成本值为： 0.06021664023174592
第 1600 次迭代，成本值为： 0.05327415758001877
第 1700 次迭代，成本值为： 0.04762903262098434
第 1800 次迭代，成本值为： 0.04297588879436871
第 1900 次迭代，成本值为： 0.03903607436513823
第 2000 次迭代，成本值为： 0.03568313638049028
第 2100 次迭代，成本值为： 0.03291526373054678
第 2200 次迭代，成本值为： 0.03047219305912063
第 2300 次迭代，成本值为： 0.02838785921294613
第 2400 次迭代，成本值为： 0.02661521237277608
”“”

Alex_Tlover

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
吴恩达2021年版深度学习作业(编程作业)第一章Week4深层神经网络 assigment4_2

当你完成了本编程任务，你就完成了第四周的最后一个编程任务，也是这一章节的最后一个编程任务。你将会使用在之前的编程任务中实现的函数来构建一个神经网络，并且将它应用到猫\非猫的分类中。希望你在精度方面能看到相对于之前实现的逻辑回归而言有所改善。本编程任务之后，你讲会学习到：构建并应用一个基于有监督学习的深层神经网络让我们开始吧！
复制链接

扫一扫