版权为吴恩达老师所有,参考Koala_Tree的博客,部分根据自己实践添加
使用bing翻译,部分手工翻译
3-学习算法的一般体系结构
是时候设计一个简单的算法来区分猫的图像与非猫图像。
你将建立一个逻辑回归, 使用神经网络思维。下图解释了为什么逻辑回归实际上是一个非常简单的神经网络!
算法的数学表达式:
举一个例子:
(1)
(2)
(3)
然后通过对所有训练实例计算总的成本:
(4)
关键步骤:
在本练习中, 您将执行以下步骤:
-初始化模型的参数
-通过了解模型的参数来最大限度地减少成本
-使用所学参数使预测 (在测试集)
-分析结果并得出结论
4-建立我们的算法的部分 # #
构建神经网络的主要步骤有:
1. 定义模型结构 (如输入特征的数量)
2。初始化模型的参数
3。循环:
-计算当前损耗 (正向传播)
-计算当前渐变 (向后传播)
-更新参数 (渐变下降)
您通常单独构建 1-3, 并将它们集成到我们调用的model()
函数中。
4.1-助手函数
练习: 使用代码来自 "Python 基础",实现。如上图所示,您需要计算 做出预测。使用np.exp ()。
def sigmoid(z):
s=1.0/(1.0+np.exp(-z))
return s
4.2-初始化参数
练习:在下面的单元格中实现参数初始化。您必须将 w 初始化为零的向量。如果您不知道要使用什么 numpy 功能, 请在 numpy 库的文档中查找 np. zeros()。
def initialize_with_zeros(dim):
w=np.zeros((dim,1))
b=0
assert(w,shape==(dim,1))
assert(isinstance(b,float) or isinstance(b,int))
return w,b
对于图像输入, w 将是形状(num_px × num_px × 3, 1)
练习:实现计算成本propagate()
函数及其梯度函数。
提示:
正向传播:
你将得到X
你将计算
计算成本函数
下面是要使用的两个公式:
def propagate(w,b,X,Y):
m=X.shape[1]
A=sigmoid(np.dot(w.T,X)+b)
cost=-(1.0/m)*np.sum(Y*np.log(A)+(1-Y)*np.log(1-A))
dw=(1.0/m)*np.dot(X,(A-Y).T)
db=(1.0/m)*np.sum(A-Y)
assert(dw.shape==w.shape)
assert(db.dtype==float)
cost=np.squeeze(cost)
assert(cost.shape==())
grads={"dw":dw,"db":db}
return grads,cost
d) 优化
- 您已经初始化了参数。
- 您还可以计算成本函数及其梯度。
- 现在, 您需要使用梯度下降来更新参数。
练习:记下优化函数。目标是学习w和b通过最小化成本函数J.对于参数θ, 更新规则是θ=θ−αdθ, 其中α是学习率。
def optimize(w,b,X,Y,num_iterations,learning_rate,print_cost=False):
costs=[]
for i in range(num_iterations):
grads,cost=propagate(w,b,X,Y)
dw=grads["dw"]
db=grads["db"]
w=w-learning_rate*dw
b=b-learning_rate*db
if i%100==0:
costs.append(cost)
if 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
练习:以前的函数将输出所学 w 和 b。我们可以使用 w 和 b 来预测数据集 x 的标签,实现predict()
函数,计算预测有两个步骤:
-
计算
-
将 a 转换为 0 (if a < = 0.5) 或 1 (if a > 0.5), 则将预测存储在向量
Y_prediction
中。如果愿意, 可以在for循环中使用if/else语句 (尽管还有一种方法可以向量化此)。
def predict(w,b,X):
m=X.shape[1]
Y_prediction=np.zeros((1,m))
w=w.reshape(X.shape[0],1)
A=sigmoid(np.dot(w.T,X)+b)
for i in range(A.shape[1]):
if A[0,i]>0.5:
Y_prediction[0,i]=1
else:
Y_prediction[0,i]=0
assert(Y_prediction.shape==(1,m))
return Y_prediction
应记住的内容:
您已经实现了以下几个函数:
-初始化 (w,b)
-以迭代的形式优化损失以学习参数(w, b):
-计算成本及其梯度
-更新参数使用梯度下降
-使用已学 (w, b) 来预测给定示例集的标签
5-将所有函数合并到模型中
现在, 您将通过将所有模块 (在前面的部分中实现的函数) 组合在一起, 以正确的顺序来查看整个模型的结构。
练习:实现模型函数。使用以下记法:
-Y_prediction 为您在测试集的预测
-Y_prediction_train 为您在训练集的预测
-w,cost,grads为optimize()的输出
def model(X_train,Y_train,X_test,Y_test,num_iterations=2000,learning_rate=0.5,print_cost = False):
w,b=initialize_with_zeros(X_train.shape[0])
parameters,grads,costs=optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)
w=parameters["w"]
b=parameters["b"]
Y_prediction_test=predict(w,b,X_test)
Y_prediction_train=predict(w,b,X_train)
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
评论: 培训的准确性接近100%。这是一个很好的健全检查: 你的模型是工作, 并有足够高的能力, 以适应培训数据。测试错误为68%。考虑到我们使用的小数据集和逻辑回归是线性分类器, 这个简单模型实际上并不坏。
# encoding:utf-8
import numpy as np
import matplotlib.pyplot as plt
import h5py
import scipy
import pylab
from PIL import Image
from scipy import ndimage
from lr_utils import load_dataset
def sigmoid(z):
s=1.0/(1.0+np.exp(-z))
return s
def initialize_with_zeros(dim):
w=np.zeros((dim,1))
b=0
assert(w.shape==(dim,1))
assert(isinstance(b,float) or isinstance(b,int))
return w,b
def propagate(w,b,X,Y):
m=X.shape[1]
A=sigmoid(np.dot(w.T,X)+b)
cost=-(1.0/m)*np.sum(Y*np.log(A)+(1-Y)*np.log(1-A))
dw=(1.0/m)*np.dot(X,(A-Y).T)
db=(1.0/m)*np.sum(A-Y)
assert(dw.shape==w.shape)
assert(db.dtype==float)
cost=np.squeeze(cost)
assert(cost.shape==())
grads={"dw":dw,"db":db}
return grads,cost
def optimize(w,b,X,Y,num_iterations,learning_rate,print_cost = False):
costs=[]
for i in range(num_iterations):
grads,cost=propagate(w,b,X,Y)
dw=grads["dw"]
db=grads["db"]
w=w-learning_rate*dw
b=b-learning_rate*db
if i%100==0:
costs.append(cost)
if 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
def predict(w,b,X):
m=X.shape[1]
Y_prediction=np.zeros((1,m))
w=w.reshape(X.shape[0],1)
A=sigmoid(np.dot(w.T,X)+b)
for i in range(A.shape[1]):
if A[0,i]>0.5:
Y_prediction[0,i]=1
else:
Y_prediction[0,i]=0
assert(Y_prediction.shape==(1,m))
return Y_prediction
def model(X_train,Y_train,X_test,Y_test,num_iterations=2000,learning_rate=0.5,print_cost = False):
w,b=initialize_with_zeros(X_train.shape[0])
parameters,grads,costs=optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)
w=parameters["w"]
b=parameters["b"]
Y_prediction_test=predict(w,b,X_test)
Y_prediction_train=predict(w,b,X_train)
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
#Loading the data (cat/non-cat)
train_set_x_orig,train_set_y,test_set_x_orig,test_set_y,classes=load_dataset()
m_train=train_set_x_orig.shape[0]
m_test=test_set_x_orig.shape[0]
num_px=train_set_x_orig.shape[1]
train_set_x_flatten=train_set_x_orig.reshape(m_train,-1).T
test_set_x_flatten=test_set_x_orig.reshape(m_test,-1).T
train_set_x=train_set_x_flatten/255.0
test_set_x=test_set_x_flatten/255.0
d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)