吴恩达深度学习第二周编程练习--识别猫的逻辑回归神经网络

吴恩达深度学习第二周编程练习--识别猫的逻辑回归神经网络

识别猫】 的简单的神经网络,用python实现

注:开始编程前需要下载两个.h5文件,并将它们放到和python文件统一目录下(可到我的资源里下载)

百度云pycharm项目源码:https://pan.baidu.com/s/12q_Er1vJpeo-O8h_KQYgCQ

csdn .h5文件资源链接:https://download.csdn.net/download/qq_34290470/11583959

接下来就直接按照步骤将代码复制到python编程软件中即可(我这里使用的是Pycharm)

接下来我们一起来开始编程实现吧!!!

 

1.引入库:

numpy :是用Python进行科学计算的基本软件包。
h5py:是与H5文件中存储的数据集进行交互的常用软件包。
matplotlib:是一个著名的库,用于在Python中绘制图表。

使用代码导入需要用到的库

import numpy as np
import matplotlib.pyplot as plt
import h5py

 

2.数据处理

  • 定义load_dataset()函数用于从.h5文件中导入数据
  • 返回

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

def load_dataset():
    train_dataset = h5py.File('train_catvnoncat.h5', "r")
    
    # 保存的是训练集里面的图像数据(本训练集有209张64x64的图像)。
    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) 
    
    # 保存的是训练集的图像对应的分类值(【0 | 1】,0表示不是猫,1表示是猫)。
    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) 

    test_dataset = h5py.File('test_catvnoncat.h5', "r")
    
    # 保存的是测试集里面的图像数据(本训练集有50张64x64的图像)。
    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
    
    # 保存的是测试集的图像对应的分类值(【0 | 1】,0表示不是猫,1表示是猫)。
    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels

    # 保存的是以bytes类型保存的两个字符串数据,数据为:[b’non-cat’ b’cat’]。
    classes = np.array(test_dataset["list_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
 

测试一下:

index=25
train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = load_dataset() # 加载数据集
plt.imshow(train_set_x_orig[index]) # 查看训练集中的图片
plt.show()

 测试结果:

吴恩达深度学习第二周编程练习--识别猫的逻辑回归神经网络_第1张图片

 

打印出当前的训练标签值 

#打印出当前的训练标签值
# train_set_y是二维数组,使用np.squeeze的目的是压缩维度,即去掉shape中的1
# classe[0]='non-cat',classes[1]='cat'
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=train_set_x_orig.shape[0] # 训练集内的图片数量
m_test=test_set_x_orig.shape[0] # 测试集内的图片数量
num_px=train_set_x_orig.shape[1] #训练、测试集里面的图片的宽度和高度(均为64x64)

print("训练集中的数量:m_train=",m_train)
print("测试集中的数量:m_test=",m_test)
print("每张图片的宽/高:num_px=",num_px)
print("每张图片的大小:",train_set_x_orig[0].shape)
print("训练集_图片的维数:",train_set_x_orig.shape)
print("训练集_标签的维数: ",train_set_y.shape)
print("测试集_图片的维数:",test_set_x_orig.shape)
print("测试集_标签的维数:",test_set_y.shape)
 

输出结果:

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

 

3.向量化

每张图片的维度是(64,64,3),我们需要将维度降为(64x64x3,1);因此每列代表一张平坦的图片
将训练集和测试集都转化为(12288,1)列向量的形式

数据标准化,由于RGB实际是值为0到255的三个向量。因此数据直接除以255,就可以将值缩放到0到1之间

# 每张图片的维度是(64,64,3),我们需要将维度降为(64x64x3,1);因此每列代表一张平坦的图片
# 将训练集和测试集都转化为如上形式

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

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

# 数据标准化,由于RGB实际是值为0到255的三个向量。因此数据直接除以255,就可以将值缩放到0到1之间
train_set_x=train_set_x_flatten/255
test_set_x=test_set_x_flatten/255

输出结果:

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

 

4.构建神经网络

sigmoid激活函数

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

# sigmoid函数

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

初始化参数w和b

# 初始化参数

def initialize_with_zeros(dim):
    '''
    此函数为w创建一个维度为(dim,1)的向量,并将b初始化为0

    参数
    dim - w的矢量大小

    返回
    w - 维度为(dim,1)的初始化向量(对应权重)
    b - 初始化标量(对应偏差)

    '''
    w = np.zeros((dim, 1))
    b = 0

    # 利用断言来确保使用数据的正确
    assert (w.shape == (dim, 1))
    assert (isinstance(b, int) or isinstance(b, float))

    return (w, b)

实现一个计算成本函数及其渐变的函数propagate()

def propagate(w, b, X, Y):
    '''
    实现前向和后向传播的成本函数及其梯度

    参数
    w - 权重,维度(num_p * num_px * 3,1)
    b - 偏差,标量
    X - 训练集,维度(num_p * num_px * 3,m_train)
    Y - 真实标签,维度(1,m_train)

    返回
    cost- 逻辑回归的负对数似然成本
    dw  - 相对于w的损失梯度,维度与w相同
    db  - 相对于b的损失梯度,维度与b相同

    '''
    m = X.shape[1]

    # 正向传播
    A = sigmoid(np.dot(w.T, X) + b)
    cost = (-1 / m) * np.sum((1 - Y) * np.log(1 - A) + Y * np.log(A))
    cost = np.squeeze(cost)

    # 反向传播
    dw = (1 / m) * np.dot(X, (A - Y).T)
    db = (1 / m) * np.sum(A - Y)

    # 使用断言确保数据的准确性
    assert (dw.shape == w.shape)
    assert (db.dtype == float)

    # 创建一个字典存储dw和db
    grads = {
        'dw': dw,
        'db': db
    }

    return (grads, cost)

梯度下降函数optimize

使用渐变下降更新参数。

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

def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost):
    '''此函数通过运行梯度下降算法来优化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  - 包含权重和偏差相对于成本函数的梯度的字典
        成本 - 优化期间计算的所有成本列表,将用于绘制学习曲线。'''

    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("迭代次数:", i, "误差:", cost)

    params = {
        "w": w,
        "b": b
    }
    grads = {
        'dw': dw,
        'db': db
    }

    return (params, grads, costs)

测试一下优化函数:

#测试optimize
w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1,2], [3,4]]), np.array([[1, 0]])
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.55930492484
dw = [[ 0.90158428]
 [ 1.76250842]]
db = 0.430462071679 

 

预测函数predict()

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

现在我们要实现预测函数predict()。计算预测有两个步骤:

计算 Y^=A=σ(wTX+b)Y^=A=σ(wTX+b)
将a的值变为0(如果激活值<= 0.5)或者为1(如果激活值> 0.5),

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

def 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)) 
    w = w.reshape(X.shape[0],1)

    #计预测猫在图片中出现的概率
    A = sigmoid(np.dot(w.T , X) + b)
    for i in range(A.shape[1]):
        #将概率a [0,i]转换为实际预测p [0,i]
        Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0
    #使用断言
    assert(Y_prediction.shape == (1,m))

    return Y_prediction

 

model()函数

通过调用之前实现的函数来构建逻辑回归模型

把上述所有函数统统整合到一个model()函数中,我们就只需要调用一个model()函数

def 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  - 包含有关模型信息的字典。
    """
    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和b
    w , b = parameters["w"] , parameters["b"]

    #预测测试/训练集的例子
    Y_prediction_test = predict(w , b, X_test)
    Y_prediction_train = predict(w , b, X_train)

    #打印训练后的准确性
    print("训练集准确性:"  , format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100) ,"%")
    print("测试集准确性:"  , format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100) ,"%")

    d = {
            "costs" : costs,
            "Y_prediction_test" : Y_prediction_test,
            "Y_prediciton_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)

 输出结果:

迭代次数: 0 误差: 0.6931471805599453
迭代次数: 100 误差: 0.5845083636993086
迭代次数: 200 误差: 0.46694904094655476
迭代次数: 300 误差: 0.37600686694802077
迭代次数: 400 误差: 0.3314632893282513
迭代次数: 500 误差: 0.30327306747438293
迭代次数: 600 误差: 0.2798795865826048
迭代次数: 700 误差: 0.26004213692587574
迭代次数: 800 误差: 0.24294068467796623
迭代次数: 900 误差: 0.22800422256726066
迭代次数: 1000 误差: 0.21481951378449635
迭代次数: 1100 误差: 0.20307819060644985
迭代次数: 1200 误差: 0.1925442771670686
迭代次数: 1300 误差: 0.18303333796883503
迭代次数: 1400 误差: 0.17439859438448876
迭代次数: 1500 误差: 0.16652139705400335
迭代次数: 1600 误差: 0.15930451829756614
迭代次数: 1700 误差: 0.15266732471296504
迭代次数: 1800 误差: 0.1465422350398234
迭代次数: 1900 误差: 0.14087207570310162
测试集的准确性: 99.7 %
训练集的准确性: 99.99043062200957 %

 

5.数据可视化

# 可视化
costs=d['costs']
plt.plot(costs)
plt.title("Learning rate = 0.005")
plt.xlabel("iterations (per hundreds)")
plt.ylabel("Cost")
plt.show()

吴恩达深度学习第二周编程练习--识别猫的逻辑回归神经网络_第2张图片

梯度下降优化

学习率α 决定了我们更新参数的速度。如果学习率过高,我们可能会“超过”最优值。同样,如果它太小,我们将需要太多迭代才能收敛到最佳值。这就是为什么使用良好调整的学习率至关重要的原因。

我们可以比较一下我们模型的学习曲线和几种学习速率的选择。也可以尝试使用不同于我们初始化的learning_rates变量包含的三个值,并看一下会发生什么。

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

输出结果:

learning rate is: 0.01
测试集的准确性: 99.68 %
训练集的准确性: 99.99521531100478 %

-------------------------------------------------------

learning rate is: 0.001
测试集的准确性: 99.64 %
训练集的准确性: 99.88995215311004 %

-------------------------------------------------------

learning rate is: 0.0001
测试集的准确性: 99.36 %
训练集的准确性: 99.6842105263158 %

-------------------------------------------------------

吴恩达深度学习第二周编程练习--识别猫的逻辑回归神经网络_第3张图片

 

注:有任何疑问请留言,看到了我就会回复。

你可能感兴趣的:(深度学习,吴恩达深度学习作业,深度学习,识别猫的神经网络,机器学习,深度学习实战)