Course1-神经网络和深度学习编程作业

毛十三

发布日期: 2020-05-04 12:29:24 浏览量: 142
评分:
star star star star star star star star star star_border
*转载请注明来自write-bug.com

第一课第二周

实现功能:这段代码主要实现的功能是判断一张图片是否有cat,实现的是二分类,有就为1,没有就为0。

训练方法:BP网络,此代码很简单,没有隐藏层,直接就是输入层连着输出层,z=W’X+b,a=sigmoid(z) ,y=a故权值w是一维。(这一步体现在w = np.zeros(shape = (dim,1), dtype = np.float32))网络结构如下图所示:(实际输入不止x1,x2,x3。是x1,x2~~x12288.(个数是由图片64x64x3算出来的))

BP算法

基本思想:学习过程由信号的正向传播和误差的反向传播两个过程组成。(这一步体现在propagate()函数)

数学工具:微积分的链式求导法则。

求解最小化成本函数(cost function):梯度下降法。(这一步体现在optimize()函数)

损失函数(Loss function):指单个训练样本进行预测的结果与实际结果的误差。

代价函数(Cost function):整个训练集,所有样本误差总和(所有损失函数总和)的平均值


在开始之前,我们有需要引入的库:

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

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

  • matplotlib:是一个著名的库,用于在Python中绘制图表。

  • lr_utils :课程提供的一个加载资料包里面的数据的简单功能的库。

lr_utils.py代码如下:

  1. import numpy as np
  2. import h5py
  3. def load_dataset():
  4. train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
  5. train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
  6. train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels
  7. test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
  8. test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
  9. test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels
  10. classes = np.array(test_dataset["list_classes"][:]) # the list of classes
  11. train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
  12. test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
  13. return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

释以下上面的load_dataset() 返回的值的含义:

  • 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’]。

我们可以看一下我们加载的文件里面的图片都是些什么样子的,比如查看训练集里面的第26张图片。

  1. index = 25
  2. plt.imshow(train_set_x_orig[index])
  3. plt.show()#显示图片是只猫的图片

现在我们可以结合一下训练集里面的数据来看一下到底都加载了一些什么东西。

  1. #打印出当前的训练标签值
  2. #使用np.squeeze的目的是压缩维度
  3. #【未压缩】train_set_y[:,index]的值为[1] , 【压缩后】np.squeeze(train_set_y[:,index])的值为1
  4. #print("【使用np.squeeze:" + str(np.squeeze(train_set_y[:,index])) + "
  5. #不使用np.squeeze: " + str(train_set_y[:,index]) + "】")
  6. #只有压缩后的值才能进行解码操作
  7. print("y=" + str(train_set_y[:,index]) + ", it's a " + classes[np.squeeze(train_set_y[:,index])].decode("utf-8") + "' picture")

打印出的结果是:y=[1], it’s a cat’ picture,参数解释:

  • m_train :训练集里图片的数量。

  • m_test :测试集里图片的数量。

  • num_px : 训练、测试集里面的图片的宽度和高度(均为64x64)。

记住:trainset_x_orig 是一个维度为(m\​​train,num_px,num_px,3)的数组。

  1. m_train = train_set_y.shape[1] #训练集里图片的数量。
  2. m_test = test_set_y.shape[1] #测试集里图片的数量。
  3. num_px = train_set_x_orig.shape[1] #训练、测试集里面的图片的宽度和高度(均为64x64)。
  4. #现在看一看我们加载的东西的具体情况
  5. print ("训练集的数量: m_train = " + str(m_train))
  6. print ("测试集的数量 : m_test = " + str(m_test))
  7. print ("每张图片的宽/高 : num_px = " + str(num_px))
  8. print ("每张图片的大小 : (" + str(num_px) + ", " + str(num_px) + ", 3)")
  9. print ("训练集_图片的维数 : " + str(train_set_x_orig.shape))
  10. print ("训练集_标签的维数 : " + str(train_set_y.shape))
  11. print ("测试集_图片的维数: " + str(test_set_x_orig.shape))
  12. print ("测试集_标签的维数: " + str(test_set_y.shape))

运行结果:

  1. 训练集的数量: m_train = 209
  2. 测试集的数量 : m_test = 50
  3. 每张图片的宽/高 : num_px = 64
  4. 每张图片的大小 : (64, 64, 3)
  5. 训练集_图片的维数 : (209, 64, 64, 3)
  6. 训练集_标签的维数 : (1, 209)
  7. 测试集_图片的维数: (50, 64, 64, 3)
  8. 测试集_标签的维数: (1, 50)

为了方便,我们要把维度为(64,64,3)的numpy数组重新构造为(64 x 64 x 3,1)的数组,要乘以3的原因是每张图片是由64x64像素构成的,而每个像素点由(R,G,B)三原色构成的,所以要乘以3。从此,训练和测试的数据集是一个numpy数组,每列代表一个平坦的图像,应该有m_train和m_test列。

当你想将形状(a,b,c,d)的矩阵X平铺成形状(bxcxd,a)的矩阵X_flatten时,可以使用以下代码:

  1. #X_flatten = X.reshape(X.shape [0],-1).T #X.T是X的转置
  2. #将训练集的维度降低并转置。
  3. train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
  4. #将测试集的维度降低并转置。
  5. test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T

这一段意思是指把数组变为209行的矩阵(因为训练集里有209张图片),但是不知道列有多少,于是我就用-1告诉程序帮我算,最后程序算出来时12288列,我再最后用一个T表示转置,这就变成了12288行,209列。测试集亦如此。

然后我们看看降维之后的情况是怎么样的:

  1. print ("训练集降维最后的维度: " + str(train_set_x_flatten.shape))
  2. print ("训练集_标签的维数 : " + str(train_set_y.shape))
  3. print ("测试集降维之后的维度: " + str(test_set_x_flatten.shape))
  4. print ("测试集_标签的维数 : " + str(test_set_y.shape))

执行之后的结果为:

  1. 训练集降维最后的维度: (12288, 209)
  2. 训练集_标签的维数 : (1, 209)
  3. 测试集降维之后的维度: (12288, 50)
  4. 测试集_标签的维数 : (1, 50)

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

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

至此,已经把加载的数据集弄好了。


现在开始构建神经网络。

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

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

  2. 初始化模型的参数

  3. 循环:
    (1)计算当前损失(正向传播)
    (2)计算当前梯度(反向传播)
    (3)更新参数(梯度下降)

现在构建sigmoid(),需要使用 sigmoid(w ^ T x + b)计算来做出预测。

  1. #定义激励函数
  2. def sigmoid(z):
  3. s = 1/(1 + np.exp(-z))
  4. return s

初始化我们需要的参数w和b。

  1. def initialize_with_zeros(dim):
  2. """
  3. 此函数为w创建一个维度为(dim,1)的0向量,并将b初始化为0。
  4. 参数:
  5. dim - 我们想要的w矢量的大小(或者这种情况下的参数数量)
  6. 返回:
  7. w - 维度为(dim,1)的初始化向量。
  8. b - 初始化的标量(对应于偏差)
  9. """
  10. w = np.zeros(shape = (dim,1))
  11. b = 0
  12. #使用断言来确保我要的数据是正确的
  13. assert(w.shape == (dim, 1)) #w的维度是(dim,1)
  14. assert(isinstance(b, float) or isinstance(b, int)) #b的类型是float或者是int
  15. return (w , b)

初始化参数的函数已经构建好了,现在就可以执行“前向”和“后向”传播步骤来学习参数。

  1. def propagate(w, b, X, Y):
  2. """
  3. 实现前向和后向传播的成本函数及其梯度。
  4. 参数:
  5. w - 权重,大小不等的数组(num_px * num_px * 3,1)
  6. b - 偏差,一个标量
  7. X - 矩阵类型为(num_px * num_px * 3,训练数量)
  8. Y - 真正的“标签”矢量(如果非猫则为0,如果是猫则为1),矩阵维度为(1,训练数据数量)
  9. 返回:
  10. cost- 逻辑回归的负对数似然成本
  11. dw - 相对于w的损失梯度,因此与w相同的形状
  12. db - 相对于b的损失梯度,因此与b的形状相同
  13. """
  14. m = X.shape[1]
  15. #正向传播
  16. A = sigmoid(np.dot(w.T,X) + b) #计算激活值,请参考公式2。
  17. cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) #计算成本.
  18. #反向传播
  19. dw = (1 / m) * np.dot(X, (A - Y).T) #请参考视频中的偏导公式。
  20. db = (1 / m) * np.sum(A - Y) #请参考视频中的偏导公式。
  21. #使用断言确保我的数据是正确的
  22. assert(dw.shape == w.shape)
  23. assert(db.dtype == float)
  24. cost = np.squeeze(cost)
  25. assert(cost.shape == ())
  26. #创建一个字典,把dw和db保存起来。
  27. grads = {
  28. "dw": dw,
  29. "db": db
  30. }
  31. return (grads , cost)

现在,我要使用渐变下降更新参数,目标是通过最小化成本函数J来学习w和b。

  1. def optimize(w , b , X , Y , num_iterations , learning_rate , print_cost = False):
  2. """
  3. 此函数通过运行梯度下降算法来优化w和b
  4. 参数:
  5. w - 权重,大小不等的数组(num_px * num_px * 3,1)
  6. b - 偏差,一个标量
  7. X - 维度为(num_px * num_px * 3,训练数据的数量)的数组。
  8. Y - 真正的“标签”矢量(如果非猫则为0,如果是猫则为1),矩阵维度为(1,训练数据的数量)
  9. num_iterations - 优化循环的迭代次数
  10. learning_rate - 梯度下降更新规则的学习率
  11. print_cost - 每100步打印一次损失值
  12. 返回:
  13. params - 包含权重w和偏差b的字典
  14. grads - 包含权重和偏差相对于成本函数的梯度的字典
  15. 成本 - 优化期间计算的所有成本列表,将用于绘制学习曲线。
  16. 提示:
  17. 我们需要写下两个步骤并遍历它们:
  18. 1)计算当前参数的成本和梯度,使用propagate()。
  19. 2)使用w和b的梯度下降法则更新参数。
  20. """
  21. costs = []
  22. for i in range(num_iterations):
  23. grads, cost = propagate(w, b, X, Y)
  24. dw = grads["dw"]
  25. db = grads["db"]
  26. w = w - learning_rate * dw
  27. b = b - learning_rate * db
  28. #记录成本
  29. if i % 100 == 0:
  30. costs.append(cost)
  31. #打印成本数据
  32. if (print_cost) and (i % 100 == 0):
  33. print("迭代的次数: %i , 误差值: %f" % (i,cost))
  34. params = {
  35. "w" : w,
  36. "b" : b }
  37. grads = {
  38. "dw": dw,
  39. "db": db }
  40. return (params , grads , costs)

现在我们要实现预测函数predict()。

  1. def predict(w , b , X ):
  2. """
  3. 使用学习逻辑回归参数logistic (w,b)预测标签是0还是1,
  4. 参数:
  5. w - 权重,大小不等的数组(num_px * num_px * 3,1)
  6. b - 偏差,一个标量
  7. X - 维度为(num_px * num_px * 3,训练数据的数量)的数据
  8. 返回:
  9. Y_prediction - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组(向量)
  10. """
  11. m = X.shape[1] #图片的数量
  12. Y_prediction = np.zeros((1,m))
  13. w = w.reshape(X.shape[0],1)
  14. #计预测猫在图片中出现的概率
  15. A = sigmoid(np.dot(w.T , X) + b)
  16. for i in range(A.shape[1]):
  17. #将概率a [0,i]转换为实际预测p [0,i]
  18. Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0
  19. #使用断言
  20. assert(Y_prediction.shape == (1,m))
  21. return Y_prediction

就目前而言,我们基本上把所有的东西都做完了,现在我们要把这些函数统统整合到一个model()函数中,届时只需要调用一个model()就基本上完成所有的事了。

  1. def model(X_train , Y_train , X_test , Y_test , num_iterations = 2000 , learning_rate = 0.5 , print_cost = False):
  2. """
  3. 通过调用之前实现的函数来构建逻辑回归模型
  4. 参数:
  5. X_train - numpy的数组,维度为(num_px * num_px * 3,m_train)的训练集
  6. Y_train - numpy的数组,维度为(1,m_train)(矢量)的训练标签集
  7. X_test - numpy的数组,维度为(num_px * num_px * 3,m_test)的测试集
  8. Y_test - numpy的数组,维度为(1,m_test)的(向量)的测试标签集
  9. num_iterations - 表示用于优化参数的迭代次数的超参数
  10. learning_rate - 表示optimize()更新规则中使用的学习速率的超参数
  11. print_cost - 设置为true以每100次迭代打印成本
  12. 返回:
  13. d - 包含有关模型信息的字典。
  14. """
  15. w , b = initialize_with_zeros(X_train.shape[0])
  16. parameters , grads , costs = optimize(w , b , X_train , Y_train,num_iterations , learning_rate , print_cost)
  17. #从字典“参数”中检索参数w和b
  18. w , b = parameters["w"] , parameters["b"]
  19. #预测测试/训练集的例子
  20. Y_prediction_test = predict(w , b, X_test)
  21. Y_prediction_train = predict(w , b, X_train)
  22. #打印训练后的准确性
  23. print("训练集准确性:" , format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100) ,"%")
  24. print("测试集准确性:" , format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100) ,"%")
  25. d = {
  26. "costs" : costs,
  27. "Y_prediction_test" : Y_prediction_test,
  28. "Y_prediciton_train" : Y_prediction_train,
  29. "w" : w,
  30. "b" : b,
  31. "learning_rate" : learning_rate,
  32. "num_iterations" : num_iterations }
  33. return d

绘制学习效率曲线图。

  1. costs = np.squeeze(d['costs'])
  2. plt.plot(costs)
  3. plt.ylabel('cost')
  4. plt.xlabel('iterations (per hundreds)')
  5. plt.title("Learning rate =" + str(d["learning_rate"]))
  6. plt.show()
上传的附件

发送私信

3
文章数
0
评论数
最近文章
eject