NG深度学习第一门课作业1 构建一个逻辑回归分类器来识别猫-白红宇

NG深度学习第一门课作业1 构建一个逻辑回归分类器来识别猫

阅读量：4128 次

发布时间：2019-05-25

本文共 15072 字，大约阅读时间需要 50 分钟。

欢迎来到你的第一个(必需的)编程任务！你将建立一个逻辑回归分类器来识别猫。这项作业将带你逐步了解如何用神经网络思维来做这件事，因此也将磨练你对深度学习的直觉。

第一部分：导包

在开始之前，我们有需要引入的库：

numpy ：是用Python进行科学计算的基本软件包。

h5py：是与H5文件中存储的数据集进行交互的常用软件包。

matplotlib：是一个著名的库，用于在Python中绘制图表。

lr_utils ：在本文的资料包里，一个加载资料包里面的数据的简单功能的库。

import numpy as npimport matplotlib.pyplot as pltimport h5pyimport scipyfrom PIL import Imagefrom scipy import ndimagefrom lr_utils import load_dataset%matplotlib inline

第二部分：问题概述

1-加载数据

# Loading the data (cat/non-cat)train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()print(train_set_x_orig.shape)print(train_set_y.shape)print(test_set_x_orig.shape)print(test_set_y.shape)print(classes)

结果：

(209, 64, 64, 3)(1, 209)(50, 64, 64, 3)(1, 50)[b'non-cat' b'cat']

含义：

train_set_x_orig ：保存的是训练集里面的图像数据（本训练集有209张64x64的图像）。

train_set_y_orig ：保存的是训练集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。

test_set_x_orig ：保存的是测试集里面的图像数据（本训练集有50张64x64的图像）。

test_set_y_orig ：保存的是测试集的图像对应的分类值（【0 | 1】，0表示不是猫，1表示是猫）。

classes ：保存的是以bytes类型保存的两个字符串数据，数据为：[b’non-cat’ b’cat’]。

2-试着查看训练集中的随机一张照片，index可以输入在0-208之间，示例输入index=23

# Example of a pictureindex = 23plt.imshow(train_set_x_orig[index])print ("y = " + str(train_set_y[:, index]) + ", it's a '" + classes[np.squeeze(train_set_y[:, index])].decode("utf-8") +  "' picture.")

结果：

y = [0], it's a 'non-cat' picture.

含义：

使用np.squeeze的目的是压缩维度，【未压缩】train_set_y[:,index]的值为[1] , 【压缩后】np.squeeze(train_set_y[:,index])的值为1。只有压缩后的值才能进行解码操作。

3-练习:查找以下值:

m_train ：训练集里图片的数量。

m_test ：测试集里图片的数量。

num_px ：训练、测试集里面的图片的宽度和高度（均为64x64）。

其中，train_set_x_orig 是一个维度为(m_train，num_px，num_px，3）的数组。

### START CODE HERE ### (≈ 3 lines of code)m_train = train_set_x_orig.shape[0]m_test = test_set_x_orig.shape[0]num_px = train_set_x_orig.shape[1]### END CODE HERE ###print ("Number of training examples: m_train = " + str(m_train))print ("Number of testing examples: m_test = " + str(m_test))print ("Height/Width of each image: num_px = " + str(num_px))print ("Each image is of size: (" + str(num_px) + ", " + str(num_px) + ", 3)")print ("train_set_x shape: " + str(train_set_x_orig.shape))print ("train_set_y shape: " + str(train_set_y.shape))print ("test_set_x shape: " + str(test_set_x_orig.shape))print ("test_set_y shape: " + str(test_set_y.shape))

结果：

Number of training examples: m_train = 209Number of testing examples: m_test = 50Height/Width of each image: num_px = 64Each image is of size: (64, 64, 3)train_set_x shape: (209, 64, 64, 3)train_set_y shape: (1, 209)test_set_x shape: (50, 64, 64, 3)test_set_y shape: (1, 50)

4-练习：重塑训练和测试数据集

为了方便，我们要把维度为（64，64，3）的numpy数组重新构造为（64 x 64 x 3，1）的数组，要乘以3的原因是每张图片是由64x64像素构成的，而每个像素点由（R，G，B）三原色构成的，所以要乘以3。在此之后，我们的训练和测试数据集是一个numpy数组，【每列代表一个平坦的图像】，应该有m_train和m_test列。也就是把数组变为209行的矩阵。

当你想将形状（a，b，c，d）的矩阵X平铺成形状（b * c * d，a）的矩阵X_flatten时，可以使用以下代码：

X_flatten = X.reshape(X.shape[0], -1).T      # X.T是X的转置

这是老师已经把答案提前透露出来啦！

# Reshape the training and test examples### START CODE HERE ### (≈ 2 lines of code)train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T  #将训练集的维度降低并转置。test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T  #将测试集的维度降低并转置。# train_set_x_flatten = train_set_x_orig.reshape(-1, train_set_x_orig.shape[0])### END CODE HERE ###print ("train_set_x_flatten shape: " + str(train_set_x_flatten.shape))print ("train_set_y shape: " + str(train_set_y.shape))print ("test_set_x_flatten shape: " + str(test_set_x_flatten.shape))print ("test_set_y shape: " + str(test_set_y.shape))print ("sanity check after reshaping: " + str(train_set_x_flatten[0:5,0]))

结果：

train_set_x_flatten shape: (12288, 209)train_set_y shape: (1, 209)test_set_x_flatten shape: (12288, 50)test_set_y shape: (1, 50)sanity check after reshaping: [17 31 56 22 33]

为了表示彩色图像，必须为每个像素指定红色，绿色和蓝色通道（RGB），因此像素值实际上是从0到255范围内的三个数字的向量。机器学习中一个常见的预处理步骤是对数据集进行居中和标准化，这意味着可以减去每个示例中整个numpy数组的平均值，然后将每个示例除以整个numpy数组的标准偏差。但对于图片数据集，它更简单，更方便，几乎可以将数据集的每一行除以255（像素通道的最大值），因为在RGB中不存在比255大的数据，所以我们可以放心的除以255，让标准化的数据位于[0,1]之间，现在标准化我们的数据集：

train_set_x = train_set_x_flatten/255.test_set_x = test_set_x_flatten/255.

第三部分学习算法的一般架构

是时候设计一个简单的算法来区分猫图像和非猫图像了。你将使用神经网络思维建立逻辑回归。下图解释了为什么逻辑回归实际上是一个非常简单的神经网络！

现在总算是把我们加载的数据弄完了，我们现在开始构建神经网络。

以下是数学表达式，如果对数学公式不甚理解，请仔细看一下吴恩达的视频。

关键步骤:在本练习中，您将执行以下步骤:

初始化模型的参数

通过最小化成本了解模型参数

使用学习到的参数进行预测(在测试集上)

分析结果并得出结论

第四部分构建神经网络

建立神经网络的主要步骤是：

1. 定义模型结构（例如输入特征的数量）

2. 初始化模型的参数

3. 循环：

计算当前损失（正向传播）

计算当前梯度（反向传播）

更新参数（梯度下降）

通常分别构建1-3个，并将它们集成到一个我们称为model()的函数中。

1-练习:使用“Python基础”中的代码，实现sigmoid()。

# GRADED FUNCTION: sigmoiddef sigmoid(z):    """    参数：z  - 任何大小的标量或numpy数组。    返回：s  -  sigmoid（z）    """    ### START CODE HERE ### (≈ 1 line of code)    s = 1 / (1 + np.exp(-z))  # exp()表示指数函数    ### END CODE HERE ###        return s

测试：

print ("sigmoid([0, 2]) = " + str(sigmoid(np.array([0,2]))))  #测试sigmoid函数

结果：

sigmoid([0, 2]) = [ 0.5         0.88079708]

2 -初始化参数

练习:在下面的单元格中实现参数初始化，初始化我们需要的参数w和b。

# GRADED FUNCTION: initialize_with_zerosdef initialize_with_zeros(dim):    """        此函数为w创建一个维度为（dim，1）的0向量，并将b初始化为0。        参数：            dim  - 我们想要的w矢量的大小（或者这种情况下的参数数量）        返回：            w  - 维度为（dim，1）的初始化向量。            b  - 初始化的标量（对应于偏差）    """    ### START CODE HERE ### (≈ 1 line of code)    w = np.zeros((dim, 1))    b = 0    ### END CODE HERE ###    #使用断言来确保我要的数据是正确的    assert(w.shape == (dim, 1))    #w的维度是(dim,1)    assert(isinstance(b, float) or isinstance(b, int))  #b的类型是float或者是int        return w, b

测试：

dim = 2w, b = initialize_with_zeros(dim)print ("w = " + str(w))print ("b = " + str(b))

结果：

w = [[ 0.] [ 0.]]b = 0

3 -前向和反向传播

现在您的参数已经初始化，您可以执行“向前”和“向后”传播步骤来学习参数。

练习:实现一个计算成本函数及其梯度的函数propagate()。

# GRADED FUNCTION: propagatedef propagate(w, b, X, Y):    """    实现前向和后向传播的成本函数及其梯度。    参数：        w  - 权重，大小不等的数组（num_px * num_px * 3，1）        b  - 偏差，一个标量        X  - 矩阵类型为（num_px * num_px * 3，训练数量）        Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据数量)    返回：        cost- 逻辑回归的负对数似然成本        dw  - 相对于w的损失梯度，因此与w的维度相同        db  - 相对于b的损失梯度，因此与b的维度相同    """    m = X.shape[1]    # 前向传播    ### START CODE HERE ### (≈ 2 lines of code)    A = sigmoid(np.dot(w.T,X) + b) #计算激活值，请参考公式2，dot()函数表示矩阵相乘。    cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) #计算成本，请参考公式3和4。    ### END CODE HERE ###    # 反向传播    ### START CODE HERE ### (≈ 2 lines of code)    dw = (1 / m) * np.dot(X, (A - Y).T) #请参考视频中的偏导公式。    db = (1 / m) * np.sum(A - Y) #请参考视频中的偏导公式。    ### END CODE HERE ###    #使用断言确保数据是正确的    assert(dw.shape == w.shape)    assert(db.dtype == float)    cost = np.squeeze(cost)    assert(cost.shape == ())    #创建一个字典，把dw和db保存起来。    grads = {"dw": dw,             "db": db}    return grads , cost

测试：

w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])grads, cost = propagate(w, b, X, Y)print ("dw = " + str(grads["dw"]))print ("db = " + str(grads["db"]))print ("cost = " + str(cost))

结果：

dw = [[ 0.99993216] [ 1.99980262]]db = 0.499935230625cost = 6.00006477319

4-使用梯度下降更新参数

练习:写下优化函数

目标是通过最小化成本函数 J 来学习 w和b 。对于参数 θ ，更新规则是 θ=θ−α dθ，其中 α 是学习率。

# GRADED FUNCTION: optimizedef optimize(w , b , X , Y , num_iterations , learning_rate , print_cost = False):    """    此函数通过运行梯度下降算法来优化w和b    参数：        w  - 权重，大小不等的数组（num_px * num_px * 3，1）        b  - 偏差，一个标量        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数组。        Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据的数量)        num_iterations  - 优化循环的迭代次数        learning_rate  - 梯度下降更新规则的学习率        print_cost  - 每100步打印一次损失值    返回：        params  - 包含权重w和偏差b的字典        grads  - 包含权重和偏差相对于成本函数的梯度的字典        成本 - 优化期间计算的所有成本列表，将用于绘制学习曲线。    提示：    我们需要写下两个步骤并遍历它们：        1）计算当前参数的成本和梯度，使用propagate（）。        2）使用w和b的梯度下降法则更新参数。    """    costs = []    for i in range(num_iterations):        # 成本和梯度计算        ### START CODE HERE ###        grads, cost = propagate(w, b, X, Y)  # 直接调用上一步的函数        ### END CODE HERE ###        dw = grads["dw"]  # 获取字典对应的键来取出值        db = grads["db"]            # 更新规则           ### START CODE HERE ###        w = w - learning_rate * dw  # w=w-学习率*梯度        b = b - learning_rate * db        ### END CODE HERE ###        # 打印每隔100次的代价        if i % 100 == 0:            costs.append(cost)        # 打印成本数据        if (print_cost) and (i % 100 == 0):            print("迭代的次数: %i ， 误差值： %f" % (i,cost))    params  = {"w": w,     # 用字典的格式保存               "b": b }    grads = {"dw": dw,             "db": db }     return params, grads, costs

测试：

params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)print ("w = " + str(params["w"]))print ("b = " + str(params["b"]))print ("dw = " + str(grads["dw"]))print ("db = " + str(grads["db"]))

结果：

w = [[0.1124579 ] [0.23106775]]b = 1.5593049248448891dw = [[0.90158428] [1.76250842]]db = 0.4304620716786828

5-练习：预测部分

optimize函数会输出已学习的w和b的值，我们可以使用w和b来预测数据集X的标签。

现在我们要实现预测函数predict（）。计算预测有两个步骤：

计算预测结果 Y^=A=σ(wTX+b)Y^=A=σ(wTX+b)

将a的值变为0（如果激活值<= 0.5）或者为1（如果激活值> 0.5），

然后将预测值存储在向量Y_prediction中。

# GRADED FUNCTION: predictdef predict(w, b, X):    '''    使用学习逻辑回归参数logistic （w，b）预测标签是0还是1，    参数：        w  - 权重，大小不等的数组（num_px * num_px * 3，1）        b  - 偏差，一个标量        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数据    返回：        Y_prediction  - 包含X中所有图片的所有预测[0 | 1]的一个numpy数组（向量）    '''        m = X.shape[1]  #图片的数量    Y_prediction = np.zeros((1,m))  # 维度是1行m列    w = w.reshape(X.shape[0], 1)         # 计算预测猫在图片中出现的概率    ### START CODE HERE ### (≈ 1 line of code)    A = sigmoid(np.dot(w.T, X) + b)    ### END CODE HERE ###    for i in range(A.shape[1]):                #将概率a [0，i]转换为实际预测p [0，i]        ### START CODE HERE ### (≈ 4 lines of code)        if A[0, i] <= 0.5:            Y_prediction[0, i] = 0        else:            Y_prediction[0, i] = 1        ### END CODE HERE ###        assert(Y_prediction.shape == (1, m)) #使用断言        return Y_prediction

测试：

print ("predictions = " + str(predict(w, b, X)))

结果：

predictions = [[ 1.  1.]]

记住:您已经实现了几个功能:

初始化(w，b)

迭代优化损失以学习参数(w,b):◾计算成本及其梯度 ◾更新使用梯度下降的参数

使用所学(w，b)来预测给定示例集的标签

6-将所有功能合并到一个模型中

把这些函数统统整合到一个model()函数中，届时只需要调用一个model()即可。

练习:实现模型功能。

使用以下符号:

您对测试集的预测的Y_prediction

在训练集中为您的预测设置Y_prediction_train

optimize()输出的w, costs, grads

# GRADED FUNCTION: modeldef model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):    """    通过调用之前实现的函数来构建逻辑回归模型    参数：        X_train  - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集        Y_train  - numpy的数组,维度为（1，m_train）（矢量）的训练标签集        X_test   - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集        Y_test   - numpy的数组,维度为（1，m_test）的（向量）的测试标签集        num_iterations  - 表示用于优化参数的迭代次数的超参数        learning_rate  - 表示optimize（）更新规则中使用的学习速率的超参数        print_cost  - 设置为true以每100次迭代打印成本    返回：        d  - 包含有关模型信息的字典。    """        ### START CODE HERE ###        # 用零初始化参数 (≈ 1 line of code)    w, b = initialize_with_zeros(X_train.shape[0])    # 梯度下降 (≈ 1 line of code)    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)        # 从字典“参数”中检索参数w和b    w = parameters["w"]    b = parameters["b"]        # 预测测试/训练集的例子 (≈ 2 lines of code)    Y_prediction_test = predict(w, b, X_test)    Y_prediction_train = predict(w, b, X_train)    ### END CODE HERE ###    # 打印训练后的准确性    print("train accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))    print("test accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))        d = {"costs": costs,         "Y_prediction_test": Y_prediction_test,          "Y_prediction_train" : Y_prediction_train,          "w" : w,          "b" : b,         "learning_rate" : learning_rate,         "num_iterations": num_iterations}        return d

测试（2000次迭代，学习率为0.005）：

d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)

结果：

Cost after iteration 0: 0.693147Cost after iteration 100: 0.584508Cost after iteration 200: 0.466949Cost after iteration 300: 0.376007Cost after iteration 400: 0.331463Cost after iteration 500: 0.303273Cost after iteration 600: 0.279880Cost after iteration 700: 0.260042Cost after iteration 800: 0.242941Cost after iteration 900: 0.228004Cost after iteration 1000: 0.214820Cost after iteration 1100: 0.203078Cost after iteration 1200: 0.192544Cost after iteration 1300: 0.183033Cost after iteration 1400: 0.174399Cost after iteration 1500: 0.166521Cost after iteration 1600: 0.159305Cost after iteration 1700: 0.152667Cost after iteration 1800: 0.146542Cost after iteration 1900: 0.140872train accuracy: 99.04306220095694 %test accuracy: 70.0 %

我们更改一下学习率和迭代次数，有可能会发现训练集的准确性可能会提高，但是测试集准确性会下降，这是由于过拟合造成的，但是我们并不需要担心，我们以后会使用更好的算法来解决这些问题的。

到这里所有的代码编写工作就完成了。

7-查看一个分类错误的例子

# Example of a picture that was wrongly classified.index = 6plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))print ("y = " + str(test_set_y[0,index]) + ", you predicted that it is a \"" + classes[int(d["Y_prediction_test"][0,index])].decode("utf-8") +  "\" picture.")

结果：

y = 1, you predicted that it is a "non-cat" picture.

8-绘制图像

# Plot learning curve (with costs)costs = np.squeeze(d['costs'])plt.plot(costs)plt.ylabel('cost')plt.xlabel('iterations (per hundreds)')plt.title("Learning rate =" + str(d["learning_rate"]))plt.show()

解释:你可以看到成本在下降。它显示参数正在被学习。但是，您可以看到，您可以在训练集中对模型进行更多的训练。尝试增加上面单元格中的迭代次数，然后重新运行单元格。你可能会看到训练集的精度提高了，但是测试集的精度降低了。这叫做过度拟合。

9-进一步分析(可选/未分级练习)

祝贺你建立了你的第一个图像分类模型。让我们进一步分析它，并检查学习率α的可能选择。

学习率的选择

提醒:为了让梯度下降发挥作用，你必须明智地选择学习速度。学习率α决定了我们更新参数的速度。如果学习率太大，我们可能会“超过”最佳值。同样，如果它太小，我们将需要太多迭代才能收敛到最佳值。这就是为什么使用良好的学习率至关重要。让我们将模型的学习曲线与几种学习率选择进行比较。运行下面的单元格。这大约需要1分钟。也可以尝试不同于我们初始化学习率变量所包含的三个值，看看会发生什么。

learning_rates = [0.01, 0.005, 0.001, 0.0005, 0.0001]models = {}for i in learning_rates:    print ("learning rate is: " + str(i))    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)    print ('\n' + "-------------------------------------------------------" + '\n')for i in learning_rates:    plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))plt.ylabel('cost')plt.xlabel('iterations')legend = plt.legend(loc='upper center', shadow=True)frame = legend.get_frame()frame.set_facecolor('0.90')plt.show()

结果：

learning rate is: 0.01train accuracy: 99.52153110047847 %test accuracy: 68.0 %-------------------------------------------------------learning rate is: 0.005train accuracy: 97.60765550239235 %test accuracy: 70.0 %-------------------------------------------------------learning rate is: 0.001train accuracy: 88.99521531100478 %test accuracy: 64.0 %-------------------------------------------------------learning rate is: 0.0005train accuracy: 82.77511961722487 %test accuracy: 56.0 %-------------------------------------------------------learning rate is: 0.0001train accuracy: 68.42105263157895 %test accuracy: 36.0 %-------------------------------------------------------

图不同的学习率在相同的迭代次数下的变化

解释: 不同的学习率会产生不同的成本，从而产生不同的预测结果。如果学习率太大(0.01)，成本可能上下波动。它甚至可能有所不同(尽管在这个例子中，使用0.01最终还是会得到一个很好的成本值)。较低的成本并不意味着更好的模式。你必须检查是否有可能过度拟合。当训练精度远远高于测试精度时，就会发生这种情况。

在深度学习中，我们通常建议您: