cs230 深度学习 Lecture 2 编程作业: Logistic Regression with a Neural Network mindset
本文结构:
- 将 Logistic 表达为 神经网络 的形式
- 构建模型
- 导入包
- 获得数据
- 并进行预处理: 格式转换,归一化
- 整合模型:
- A. 构建模型
- a. 初始化参数:w 和 b 为 0
- b. 前向传播:计算当前的损失
- c. 反向更新:计算当前的梯度
- B. 梯度更新求模型参数
- C. 进行预测
- A. 构建模型
- 绘制学习曲线
1. 将 Logistic 表达为 神经网络 的形式
本文的目的是要用神经网络的思想实现 Logistic Regression,输入一张图片就可以判断该图片是不是猫。
那么什么是神经网络呢?
可以看我之前写的这篇文章:
什么是神经网络
其中一个很重要的概念,神经元:
再来看 Logistic 模型的表达:
那么把 Logistic 表达为 神经网络 的形式为:
(关于 Logistic 可以看这两篇文章:
Logistic Regression 为什么用极大似然函数
Logistic regression 为什么用 sigmoid ?)
接下来就可以构建模型:
2. 构建模型
我们的目的是学习 www 和 b" role="presentation" style="position: relative;">bbb 使 cost function JJJ 达到最小,
方法就是:
- 通过前向传播 (forward propagation) 计算当前的损失,
- 通过反向传播 (backward propagation) 计算当前的梯度,
- 再用梯度下降法对参数进行优化更新 (gradient descent)
关于反向传播可以看这两篇文章:
手写,纯享版反向传播算法公式推导
构建模型,训练模型,并进行预测,包含下面几步:
- 导入包
- 获得数据
- 并进行预处理: 格式转换,归一化
- 整合模型:
- A. 构建模型
- a. 初始化参数:w 和 b 为 0
- b. 前向传播:计算当前的损失
- c. 反向更新:计算当前的梯度
- B. 梯度更新求模型参数
- C. 进行预测
- A. 构建模型
- 绘制学习曲线
下面进入详细代码:
1. 导入包
引入需要的 packages,
其中,
h5py 是 python 中用于处理 H5 文件的接口,
PIL 和 scipy 在本文是用自己的图片来测试训练好的模型,
load_dataset 读取数据
import numpy as np
import matplotlib.pyplot as plt
import h5py
import scipy
from PIL import Image
from scipy import ndimage
from lr_utils import load_dataset%matplotlib inline
其中 lr_utils.py 如下,是对 H5 文件进行解析 :
#lr_utils.py import numpy as np
import h5py def load_dataset(): train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r") train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r") test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels classes = np.array(test_dataset["list_classes"][:]) # the list of classes train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0])) test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0])) return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
2. 获得数据
# Loading the data (cat/non-cat)
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
可以看一下图片的例子:
# Example of a picture
index = 25
plt.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.")
3. 进行预处理: 格式转换,归一化
这时需要获得下面几个值:
- m_train (训练样本数量)
- m_test (测试样本数量)
- num_px (训练数据集的长和宽)
### START CODE HERE ### (≈ 3 lines of code)### STA
m_train = train_set_y.shape[1]
m_test = test_set_y.shape[1]
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))
图像需要进行 reshape,原本是 (num_px, num_px, 3)
,要扁平化为一个向量 (num_px * num_px * 3, 1)
,
将 (a, b, c, d) 维的矩阵转换为 (b∗c∗d, a) 可以用: X_flatten = X.reshape(X.shape[0], -1).T
# 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
### 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 = train_set_x_flatten / 255.
test_set_x = test_set_x_flatten / 255.
4. 整合模型
- A. 构建模型- a. 初始化参数:w 和 b 为 0- b. 前向传播:计算当前的损失- c. 反向更新:计算当前的梯度
- B. 梯度更新求模型参数
- C. 进行预测
先来 A. 构建模型
按照前面提到的三步:
初始化参数:w 和 b 为 0
前向传播:计算当前的损失
反向更新:计算当前的梯度
首先需要一个辅助函数 sigmoid( w^T x + b)
# GRADED FUNCTION: sigmoiddef sigmoid(z):"""Compute the sigmoid of zArguments:x -- A scalar or numpy array of any size.Return:s -- sigmoid(z)"""### START CODE HERE ### (≈ 1 line of code)s = 1 / (1 + np.exp(-z))### END CODE HERE ###return s
a. 初始化参数:w 和 b 为 0
# GRADED FUNCTION: initialize_with_zerosdef initialize_with_zeros(dim):"""This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.Argument:dim -- size of the w vector we want (or number of parameters in this case)Returns:w -- initialized vector of shape (dim, 1)b -- initialized scalar (corresponds to the bias)"""### START CODE HERE ### (≈ 1 line of code)w = np.zeros(shape=(dim, 1))b = 0### END CODE HERE ###assert(w.shape == (dim, 1))assert(isinstance(b, float) or isinstance(b, int))return w, b
b. 前向传播:计算当前的损失
c. 反向更新:计算当前的梯度
# GRADED FUNCTION: propagatedef propagate(w, b, X, Y):"""Implement the cost function and its gradient for the propagation explained aboveArguments:w -- weights, a numpy array of size (num_px * num_px * 3, 1)b -- bias, a scalarX -- data of size (num_px * num_px * 3, number of examples)Y -- true "label" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)Return:cost -- negative log-likelihood cost for logistic regressiondw -- gradient of the loss with respect to w, thus same shape as wdb -- gradient of the loss with respect to b, thus same shape as bTips:- Write your code step by step for the propagation"""m = X.shape[1]# FORWARD PROPAGATION (FROM X TO COST)### START CODE HERE ### (≈ 2 lines of code)A = sigmoid(np.dot(w.T, X) + b) # compute activationcost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A))) # compute cost### END CODE HERE #### BACKWARD PROPAGATION (TO FIND GRAD)### 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 == ())grads = {"dw": dw,"db": db}return grads, cost
B. 梯度更新求模型参数
这一步 optimize 的目的是要学习 w" role="presentation" style="position: relative;">www 和 bbb 使 cost function J" role="presentation" style="position: relative;">JJJ 达到最小,
用到的方法是梯度下降 θ=θ−α dθθ=θ−αdθ \theta = \theta - \alpha \text{ } d\theta,
# GRADED FUNCTION: optimizedef optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):"""This function optimizes w and b by running a gradient descent algorithmArguments:w -- weights, a numpy array of size (num_px * num_px * 3, 1)b -- bias, a scalarX -- data of shape (num_px * num_px * 3, number of examples)Y -- true "label" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)num_iterations -- number of iterations of the optimization looplearning_rate -- learning rate of the gradient descent update ruleprint_cost -- True to print the loss every 100 stepsReturns:params -- dictionary containing the weights w and bias bgrads -- dictionary containing the gradients of the weights and bias with respect to the cost functioncosts -- list of all the costs computed during the optimization, this will be used to plot the learning curve.Tips:You basically need to write down two steps and iterate through them:1) Calculate the cost and the gradient for the current parameters. Use propagate().2) Update the parameters using gradient descent rule for w and b."""costs = []for i in range(num_iterations):# Cost and gradient calculation (≈ 1-4 lines of code)### START CODE HERE ### grads, cost = propagate(w, b, X, Y)### END CODE HERE #### Retrieve derivatives from gradsdw = grads["dw"]db = grads["db"]# update rule (≈ 2 lines of code)### START CODE HERE ###w = w - learning_rate * dw # need to broadcastb = b - learning_rate * db### END CODE HERE #### Record the costsif i % 100 == 0:costs.append(cost)# Print the cost every 100 training examplesif print_cost and i % 100 == 0:print ("Cost after iteration %i: %f" % (i, cost))params = {"w": w,"b": b}grads = {"dw": dw,"db": db}return params, grads, costs
C. 进行预测
# GRADED FUNCTION: predictdef predict(w, b, X):'''Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)Arguments:w -- weights, a numpy array of size (num_px * num_px * 3, 1)b -- bias, a scalarX -- data of size (num_px * num_px * 3, number of examples)Returns:Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X'''m = X.shape[1]Y_prediction = np.zeros((1, m))w = w.reshape(X.shape[0], 1)# Compute vector "A" predicting the probabilities of a cat being present in the picture### 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]):# Convert probabilities a[0,i] to actual predictions p[0,i]### START CODE HERE ### (≈ 4 lines of code)Y_prediction[0, i] = 1 if A[0, i] > 0.5 else 0### END CODE HERE ###assert(Y_prediction.shape == (1, m))return Y_prediction
下面为整合的逻辑回归模型:
将参数初始化,优化求参,预测整合在一起,
输入为 训练集,测试集,迭代次数,学习速率,是否打印中间损失
打印 test 和 train 集的预测准确率
返回的 d 含有 参数 w,b,还有 test train 集上面的预测值,
# GRADED FUNCTION: modeldef model(X_train, Y_train, X_test, Y_test, num_iterations=2000, learning_rate=0.5, print_cost=False):"""Builds the logistic regression model by calling the function you've implemented previouslyArguments:X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)num_iterations -- hyperparameter representing the number of iterations to optimize the parameterslearning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()print_cost -- Set to true to print the cost every 100 iterationsReturns:d -- dictionary containing information about the model."""### START CODE HERE #### initialize parameters with zeros (≈ 1 line of code)w, b = initialize_with_zeros(X_train.shape[0])# Gradient descent (≈ 1 line of code)parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)# Retrieve parameters w and b from dictionary "parameters"w = parameters["w"]b = parameters["b"]# Predict test/train set examples (≈ 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/test Errorsprint("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
下面代码进行模型训练:
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.693147
Cost after iteration 100: 0.584508
Cost after iteration 200: 0.466949
Cost after iteration 300: 0.376007
Cost after iteration 400: 0.331463
Cost after iteration 500: 0.303273
Cost after iteration 600: 0.279880
Cost after iteration 700: 0.260042
Cost after iteration 800: 0.242941
Cost after iteration 900: 0.228004
Cost after iteration 1000: 0.214820
Cost after iteration 1100: 0.203078
Cost after iteration 1200: 0.192544
Cost after iteration 1300: 0.183033
Cost after iteration 1400: 0.174399
Cost after iteration 1500: 0.166521
Cost after iteration 1600: 0.159305
Cost after iteration 1700: 0.152667
Cost after iteration 1800: 0.146542
Cost after iteration 1900: 0.140872
train accuracy: 99.04306220095694 %
test accuracy: 70.0 %
得到模型后可以看指定 index 所代表图片的预测值:
# Example of a picture that was wrongly classified.# Exampl
index = 5
plt.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[d["Y_prediction_test"][0, index]].decode("utf-8") + "\" picture.")
5. 绘制学习曲线
# Plot learning curve (with costs)# Plot l
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()
可以看出 costs 是在下降的,如果增加迭代次数,那么训练数据的准确率会进一步提高,但是测试数据集的准确率可能会明显下降,这就是由于过拟合造成的。
还可以对比下不同学习率对应下的学习效果:
learning_rates = [0.01, 0.001, 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()
当学习率过大 (例 0.01) 时,costs 出现上下震荡,甚至可能偏离,不过这里 0.01 最终幸运地收敛到了一个比较好的值。
推荐阅读
历史技术博文链接汇总
也许可以找到你想要的:
[入门问题][TensorFlow][深度学习][强化学习][神经网络][机器学习][自然语言处理][聊天机器人]
cs230 深度学习 Lecture 2 编程作业: Logistic Regression with a Neural Network mindset相关推荐
- 吴恩达深度学习神经网络基础编程作业Logistic Regression with a Neural Network mindset
- 2.深度学习练习:Logistic Regression with a Neural Network mindset
本文节选自吴恩达老师<深度学习专项课程>编程作业,在此表示感谢. 课程链接:https://www.deeplearning.ai/deep-learning-specialization ...
- DL:深度学习算法(神经网络模型集合)概览之《THE NEURAL NETWORK ZOO》的中文解释和感悟(六)
DL:深度学习算法(神经网络模型集合)概览之<THE NEURAL NETWORK ZOO>的中文解释和感悟(六) 目录 DRN DNC NTM CN KN AN 相关文章 DL:深度学习 ...
- DL:深度学习算法(神经网络模型集合)概览之《THE NEURAL NETWORK ZOO》的中文解释和感悟(四)
DL:深度学习算法(神经网络模型集合)概览之<THE NEURAL NETWORK ZOO>的中文解释和感悟(四) 目录 CNN DN DCIGN 相关文章 DL:深度学习算法(神经网络模 ...
- DL:深度学习算法(神经网络模型集合)概览之《THE NEURAL NETWORK ZOO》的中文解释和感悟(二)
DL:深度学习算法(神经网络模型集合)概览之<THE NEURAL NETWORK ZOO>的中文解释和感悟(二) 目录 AE VAE DAE SAE 相关文章 DL:深度学习算法(神经网 ...
- DL:深度学习算法(神经网络模型集合)概览之《THE NEURAL NETWORK ZOO》的中文解释和感悟(一)
DL:深度学习算法(神经网络模型集合)概览之<THE NEURAL NETWORK ZOO>的中文解释和感悟(一) 目录 THE NEURAL NETWORK ZOO perceptron ...
- DL:深度学习算法(神经网络模型集合)概览之《THE NEURAL NETWORK ZOO》的中文解释和感悟(三)
DL:深度学习算法(神经网络模型集合)概览之<THE NEURAL NETWORK ZOO>的中文解释和感悟(三) 目录 MC HN BM RBM DBN 相关文章 DL:深度学习算法(神 ...
- Cousera吴恩达深度学习第二次编程作业
第二次编程作业出现在第三周,下载链接->深度学习 (6月13日上传,如果看不到可能还在审核)
- 深度学习笔记(四)——循环神经网络(Recurrent Neural Network, RNN)
目录 一.RNN简介 (一).简介 (二).RNN处理任务示例--以NER为例 二.模型提出 (一).基本RNN结构 (二).RNN展开结构 三.RNN的结构变化 (一).N to N结构RNN模型 ...
最新文章
- SSH,SCP,SFTP命令汇总
- HBase总结(十二)Java API 与HBase交互实例
- 数据结构二叉树的所有基本功能实现。(C++版)
- C/C++报错:全局变量重定义或是多次定义
- mitmproxy 中间人代理工具,抓包工具,linux抓包工具 mitmproxy 使用
- 【Python】万花筒
- QML 自定义鼠标光标
- 计算机英语用哪个软件,电脑学习英语的软件哪个好?
- 学习Tomcat这一篇就够了
- alpha-beta剪枝 个人理解
- Java可以hook微信吗,Hook实现Android 微信、陌陌 、探探位置模拟(附源码下载)
- HTML5自动换行的间距设置,设置EXCEL自动换行的行与行之间的间距的办法
- html中的input文本框禁止输入问题
- 20年嵌入式工程师经验分享:从0开发一款嵌入式产品-道合顺大数据Infinigo
- gazebo的bumper使用
- time of our lives---从世界杯主题曲看厚脸皮的德国人:)
- jenkins pipeline部署补充记录
- 世界上第一台电子计算机的配置,1 世界上第一台电子计算机诞生于年
- 基于 Springboot 的 Bark 通知辅助处理项目
- php等级水平评定标准,网球水平定级标准~看看你什么等级
热门文章
- 数据结构——家谱管理系统
- Android 一键分享功能
- android 蓝牙 驱动,转个蓝牙修改帖--Android BCM4330 蓝牙BT驱动调试记录
- 天若有情天亦老月如无恨月长圆
- 绝对路径${pageContext.request.contextPath}的使用
- 五、调试声卡pcm设备
- 解决浏览器图片缓存问题
- 如何使Windows 10中的任务栏图标居中
- 还在用JSON? Google Protocol Buffers 更快更小 (原理篇)
- 2022年武汉市首席技师、技术能手评选和技能大师工作室建设项目申报条件、流程