深度学习基础训练1——逻辑回归

迈不过友情╰ 2022-10-08 13:27 169阅读 0赞

本篇文章主要介绍吴恩达的深度学习训练题目逻辑回归。  
**目标**：搭建一个可以对猫进行识别的简单神经网络。  
**成功运行环境**：  
python 3.6  
numpy 1.19.5  
h5py  
matplotlib  
**[数据集][Link 1]**  
完整代码在底部

导入所需库

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

下面正式开始  
首先我们需要做的是导入数据集

def load_dataset():
        # 读取训练集
        train_dataset = h5py.File('datasets/train_catvnoncat.h5','r')
        # 读取训练集图片
        train_set_x_orig = np.array(train_dataset["train_set_x"][:])
        # 读取训练集图像分类值：1为猫，0为非猫
        train_set_y_orig = np.array(train_dataset["train_set_y"][:])
        # print(train_set_y_orig)
    
        # 读取测试集
        test_dataset = h5py.File('datasets/test_catvnoncat.h5', 'r')
        # 读取测试集图片
        test_set_x_orig = np.array(test_dataset["test_set_x"][:])
        # 读取测试集图像分类值：1为猫，0为非猫
        test_set_y_orig = np.array(test_dataset["test_set_y"][:])
        # print(test_set_y_orig)
    
        # 保存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]))
        # print(train_set_y_orig)
        test_set_y_orig = test_set_y_orig.reshape((1,test_set_y_orig.shape[0]))
        # print(test_set_y_orig)
    
        return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes

我们介绍一下load\_dataset返回值

train_set_x_orig -- 训练集图片数据
     train_set_y_orig -- 训练集图像对应分类值，0为非猫，1为猫
     test_set_x_orig  -- 测试集图像数据
     test_set_y_orig  -- 测试集图像对应分类值，0为非猫，1为猫
     classes          -- 以bytes类型保存的两个字符串数据，数据为：[b'non-cat' b'cat']

加载数据集，取消注释可查看数据集图像

train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
    # plt.imshow(train_set_x_orig[25])
    # plt.show()

查看训练集和测试集数据

#训练集图片的数量
    m_train = train_set_y.shape[1]
    # 测试集图片的数量
    m_test = test_set_y.shape[1]
    # 训练集和测试集图片的宽和高（均为64x64）
    num_px = train_set_x_orig.shape[1]
    
    print("训练集的数量: m_train = " + str(m_train))
    print("测试集的数量 : m_test = " + str(m_test))
    print("每张图片的宽/高 : num_px = " + str(num_px))
    print("每张图片的大小 : (" + str(num_px) + ", " + str(num_px) + ", 3)")
    print("训练集_图片的维数 : " + str(train_set_x_orig.shape))
    print("训练集_标签的维数 : " + str(train_set_y.shape))
    print("测试集_图片的维数: " + str(test_set_x_orig.shape))
    print("测试集_标签的维数: " + str(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)

接着，我们需要对图片进行降维

''' 把维度为（64，64，3）的numpy数组重新构造为（64 x 64 x 3，1）的数组 为何图像维度为（64，64，3）的原因是每张图片是由64x64像素构成的，而每个像素点由（R，G，B）三原色构成的 将形状（a，b，c，d）的矩阵X平铺成形状（b * c * d，a）的矩阵X_flatten X_flatten = X.reshape(X.shape [0]，-1).T 其中X.T是X的转置 '''
    
    # 将测试集的维度降低并转置
    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))

运行结果

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

下面，我们需要对数据进行标准化，将数据标准化在\[0,1\]之间。由于图像由RGB三色通道构成，R、G、B的取值范围均为\[0,255\]，所以我们可以通过除以255来实现数据标准化。

# 将图像数据的R,G,B三色通道数值标准化为[0,1]之间
    train_set_x = train_set_x_flatten / 255
    test_set_x = test_set_x_flatten / 255

下面我们正式搭建神经网络。  
建立神经网络的主要步骤是：  
1.定义模型结构（例如输入特征的数量）  
2.初始化模型的参数  
3.循环：  
3.1 计算当前损失（正向传播）  
3.2 计算当前梯度（反向传播）  
3.3 更新参数（梯度下降）

神经网络相关数学表达式：  
训练样本函数： z ( i ) = w T x ( i ) + b z^\{(i)\}=w^\{T\}x^\{(i)\}+b z(i)=wTx(i)\+b  
通过**sigmoid**函数，将线性函数转换为非线性函数： y ^ ( i ) = s i g m o i d ( z ( i ) ) \\hat\{y\}^\{(i)\}=sigmoid(z^\{(i)\}) y^(i)=sigmoid(z(i))  
其中**sigmoid**函数为： 1 1 + e − x \\frac\{1\}\{1+e^\{-x\}\} 1\+e−x1  
逻辑回归模型的损失函数为：  
 L ( y ^ ( i ) , y ( i ) ) ) = − y ( i ) l o g ( y ^ ( i ) ) − ( 1 − y ( i ) ) l o g ( 1 − y ^ ( i ) ) L(\\hat\{y\}^\{(i)\},y^\{(i)\}))=-y^\{(i)\}log(\\hat\{y\}^\{(i)\})-(1-y^\{(i)\})log(1-\\hat\{y\}^\{(i)\}) L(y^(i),y(i)))=−y(i)log(y^(i))−(1−y(i))log(1−y^(i))  
那么逻辑回归的成本函数为： J = 1 m ∑ i = 1 m L ( y ^ ( i ) , y ( i ) ) J=\\frac\{1\}\{m\}\\sum\_\{i=1\}^\{m\}L(\\hat\{y\}^\{(i)\},y^\{(i)\}) J=m1∑i=1mL(y^(i),y(i))

先构建sigmoid函数

# 构建sigmoid(),signoid(w^T x + b)
    def sigmoid(z):
        ''' :param z: z - 任何大小的标量或numpy数组 :return: s - sigmoid(z) '''
        s = 1 / (1 + np.exp(-z))
    
        return s

初始化参数，采用0初始化方法

#初始化参数w,b
    def initialize_with_zeros(dim):
        ''' 为参数w建立一个维度为(dim,1)的0向量，并将b初始化为0 :param dim: dim - 需要的w矢量的大小 :return: w - 维度为(dim,1)的初始化向量 b - 初始化的标量 '''
        w = np.zeros(shape=(dim, 1))
        b = 0
        # 使用断言确保数据的正确性，w维度为(dim,1)，b的类型为float或者int
        assert(w.shape == (dim, 1))
        assert(isinstance(b, float) or isinstance(b, int))
    
        return (w, b)

前向传播，反向传播，计算成本

# 建立计算成本函数及其渐变的函数propagate()
    def propagate(w,b,X,Y):
        ''' 实现前向及后向传播的成本函数及其梯度 :param w: w - 权重，大小不等的数组 (num_px * num_px * 3,1) :param b: b - 偏差，一个标量 :param X: X - 矩阵类型为(num_px * num_px * 3,训练数量) :param Y: Y - 标签矢量，是猫为1，非猫为1，矩阵维度为(1,训练数据数量) :return: cost - 逻辑回归的负对数似然成本 dw - 相对于w的损失梯度，与w形状相同 db - 相对于b的损失梯度，与b形状相同 '''
        m = X.shape[1]
    
        # 正向传播
        A = sigmoid(np.dot(w.T,X) + b)# 计算激活值
        cost = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A)))#计算成本
    
        # 反向传播
        dw = (1 / m) * np.dot(X,(A - Y).T)
        db = (1 / m) * np.sum(A - Y)
    
        # 断言确保数据正确性，dw与w维度相同，db为float
        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 = w − l e a r n i n g w = w - learning w=w−learning *r a t e ∗ d w rate \* dw rate∗dw  
 b = b − l e a r n i n g b = b - learning b=b−learning* r a t e ∗ d b rate \* db rate∗db

def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
        """ 此函数通过运行梯度下降算法来优化w和b :param w: w - 权重，大小不等的数组 (num_px * num_px * 3,1) :param b: b - 偏差，一个标量 :param X: X - 矩阵类型为(num_px * num_px * 3,训练数量) :param Y: Y - 标签矢量，是猫为1，非猫为1，矩阵维度为(1,训练数据数量) :param num_iterations: num_iterations - 优化循环的迭代次数 :param learning_rate: learning_rate - 梯度下降更新规则的学习率 :param print_cost: print_cost - 每100步打印一次损失值 :return: params - 包含权重w和偏差b的字典 grads - 包含权重和偏差相对于成本函数的梯度的字典 costs - 优化期间计算的所有成本列表，用于绘制学习曲线 :tips: 需要写下两个步骤并遍历它们： （1）计算当前参数的成本和梯度，使用propagate(). （2）使用w和b的梯度下降法则更新参数 """
    
        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，误差值：%f" % (i, cost))
    
            params = { 
                "w": w,
                "b": b
            }
            grads = { 
                "dw": dw,
                "db": db
            }
        return (params, grads, costs)

下面是预测函数，计算预测值公式为： Y ^ = s i g m o i d ( W T X + b ) \\hat\{Y\}=sigmoid(W^\{T\}X+b) Y^=sigmoid(WTX\+b)  
当激活值值小于0.5，则归为0，判断为非猫，如果激活值大于0.5，则归为1，判断为猫。

def predict(w, b, X):
        """ 使用学习逻辑回归参数logistic(w,b)预测标签是0还是1 :param w: w - 权重，大小不等的数组 (num_px * num_px * 3,1) :param b: b - 偏差，一个标量 :param X: X - 矩阵类型为(num_px * num_px * 3,训练数量)的数据 :return: 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]转换为实际预测Y_prediction
            Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0
    
        #断言
        assert(Y_prediction.shape == (1,m))
    
        return Y_prediction

下面开始整合模型

def model(X_train, Y_train, X_test, Y_test, num_iteration=2000, learning_rate=0.5, print_cost = False):
        """ 构建逻辑回归模型 :param X_train: X_train - numpy数组，维度为(num_px * num_px * 3,m_train)的训练集 :param Y_train: Y_train - numpy数组，维度为(1,m_train)(矢量)的训练标签集 :param X_test: X_test - numpy数组，维度为(num_px * num_px * 3,m_test)的测试集 :param Y_test: Y_test - numpy数组，维度为(1,m_test)(向量)的测试标签集 :param num_iteration: num_iteration - 用于优化参数的迭代次数的超参数 :param learning_rate: learning_rate - 表示optimize()更行规则中使用的学习速率的超参数 :param print_cost: print_cost - 为true时，每100次迭代1打印一次成本 :return:、 d - 包含有关模型信息的字典 """
        w, b = initialize_with_zeros(X_train.shape[0])
        parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iteration, learning_rate, print_cost)
    
        # 从parameters检索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_prediction_train": Y_prediction_train,
            "w": w,
            "b": b,
            "learning_rate": learning_rate,
            "num_iterations": num_iteration
        }
        return d

最后，我们就可以开始实际测试了

d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iteration=2000, learning_rate=0.005, print_cost=True)
    
    #绘制图
    costs = np.squeeze(d['costs'])
    plt.plot(costs)
    plt.ylabel('costs')
    plt.xlabel('iterations(per hundreds)')
    plt.title("learning rate = "+str(d["learning_rate"]))
    plt.show()

本机运行结果

迭代次数：0，误差值：0.693147
    迭代次数：100，误差值：0.584508
    迭代次数：200，误差值：0.466949
    迭代次数：300，误差值：0.376007
    迭代次数：400，误差值：0.331463
    迭代次数：500，误差值：0.303273
    迭代次数：600，误差值：0.279880
    迭代次数：700，误差值：0.260042
    迭代次数：800，误差值：0.242941
    迭代次数：900，误差值：0.228004
    迭代次数：1000，误差值：0.214820
    迭代次数：1100，误差值：0.203078
    迭代次数：1200，误差值：0.192544
    迭代次数：1300，误差值：0.183033
    迭代次数：1400，误差值：0.174399
    迭代次数：1500，误差值：0.166521
    迭代次数：1600，误差值：0.159305
    迭代次数：1700，误差值：0.152667
    迭代次数：1800，误差值：0.146542
    迭代次数：1900，误差值：0.140872
    训练集准确性： 99.04306220095694 %
    测试集准确性： 70.0 %

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk0OTkyOA_size_16_color_FFFFFF_t_70_pic_center]

你也可以修改学习率和迭代次数，来查看学习率和迭代次数对预测结果的影响，也许你可以找到更合适的学习率。  
**完整代码**

# coding=gbk
    
    import numpy as np
    import h5py
    import matplotlib.pyplot as plt
    
    def load_dataset():
        # 读取训练集
        train_dataset = h5py.File('datasets/train_catvnoncat.h5','r')
        # 读取训练集图片
        train_set_x_orig = np.array(train_dataset["train_set_x"][:])
        # 读取训练集图像分类值：1为猫，0为非猫
        train_set_y_orig = np.array(train_dataset["train_set_y"][:])
        # print(train_set_y_orig)
    
        # 读取测试集
        test_dataset = h5py.File('datasets/test_catvnoncat.h5', 'r')
        # 读取测试集图片
        test_set_x_orig = np.array(test_dataset["test_set_x"][:])
        # 读取测试集图像分类值：1为猫，0为非猫
        test_set_y_orig = np.array(test_dataset["test_set_y"][:])
        # print(test_set_y_orig)
    
        # 保存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]))
        # print(train_set_y_orig)
        test_set_y_orig = test_set_y_orig.reshape((1,test_set_y_orig.shape[0]))
        # print(test_set_y_orig)
    
        return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
    
    train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
    # plt.imshow(train_set_x_orig[25])
    # plt.show()
    
    #训练集图片的数量
    m_train = train_set_y.shape[1]
    # 测试集图片的数量
    m_test = test_set_y.shape[1]
    # 训练集和测试集图片的宽和高（均为64x64）
    num_px = train_set_x_orig.shape[1]
    
    print("训练集的数量: m_train = " + str(m_train))
    print("测试集的数量 : m_test = " + str(m_test))
    print("每张图片的宽/高 : num_px = " + str(num_px))
    print("每张图片的大小 : (" + str(num_px) + ", " + str(num_px) + ", 3)")
    print("训练集_图片的维数 : " + str(train_set_x_orig.shape))
    print("训练集_标签的维数 : " + str(train_set_y.shape))
    print("测试集_图片的维数: " + str(test_set_x_orig.shape))
    print("测试集_标签的维数: " + str(test_set_y.shape))
    
    ''' 把维度为（64，64，3）的numpy数组重新构造为（64 x 64 x 3，1）的数组 要乘以3的原因是每张图片是由64x64像素构成的，而每个像素点由（R，G，B）三原色构成的，所以要乘以3 将形状（a，b，c，d）的矩阵X平铺成形状（b * c * d，a）的矩阵X_flatten X_flatten = X.reshape(X.shape [0]，-1).T 其中X.T是X的转置 '''
    
    # 将测试集的维度降低并转置
    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))
    
    # 将图像数据的R,G,B三色通道数值标准化为[0,1]之间
    train_set_x = train_set_x_flatten / 255
    test_set_x = test_set_x_flatten / 255
    
    ''' 建立神经网络的主要步骤是： 1.定义模型结构（例如输入特征的数量） 2.初始化模型的参数 3.循环： 3.1 计算当前损失（正向传播） 3.2 计算当前梯度（反向传播） 3.3 更新参数（梯度下降） '''
    # 构建sigmoid(),signoid(w^T x + b)
    def sigmoid(z):
        ''' :param z: z - 任何大小的标量或numpy数组 :return: s - sigmoid(z) '''
        s = 1 / (1 + np.exp(-z))
    
        return s
    
    #初始化参数w,b
    def initialize_with_zeros(dim):
        ''' 为参数w建立一个维度为(dim,1)的0向量，并将b初始化为0 :param dim: dim - 需要的w矢量的大小 :return: w - 维度为(dim,1)的初始化向量 b - 初始化的标量 '''
        w = np.zeros(shape=(dim, 1))
        b = 0
        # 使用断言确保数据的正确性，w维度为(dim,1)，b的类型为float或者int
        assert(w.shape == (dim, 1))
        assert(isinstance(b, float) or isinstance(b, int))
    
        return (w, b)
    
    # 建立计算成本函数及其渐变的函数propagate()
    def propagate(w,b,X,Y):
        ''' 实现前向及后向传播的成本函数及其梯度 :param w: w - 权重，大小不等的数组 (num_px * num_px * 3,1) :param b: b - 偏差，一个标量 :param X: X - 矩阵类型为(num_px * num_px * 3,训练数量) :param Y: Y - 标签矢量，是猫为1，非猫为1，矩阵维度为(1,训练数据数量) :return: cost - 逻辑回归的负对数似然成本 dw - 相对于w的损失梯度，与w形状相同 db - 相对于b的损失梯度，与b形状相同 '''
        m = X.shape[1]
    
        # 正向传播
        A = sigmoid(np.dot(w.T,X) + b)# 计算激活值
        cost = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A)))#计算成本
    
        # 反向传播
        dw = (1 / m) * np.dot(X,(A - Y).T)
        db = (1 / m) * np.sum(A - Y)
    
        # 断言确保数据正确性，dw与w维度相同，db为float
        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)
    
    def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
        """ 此函数通过运行梯度下降算法来优化w和b :param w: w - 权重，大小不等的数组 (num_px * num_px * 3,1) :param b: b - 偏差，一个标量 :param X: X - 矩阵类型为(num_px * num_px * 3,训练数量) :param Y: Y - 标签矢量，是猫为1，非猫为1，矩阵维度为(1,训练数据数量) :param num_iterations: num_iterations - 优化循环的迭代次数 :param learning_rate: learning_rate - 梯度下降更新规则的学习率 :param print_cost: print_cost - 每100步打印一次损失值 :return: params - 包含权重w和偏差b的字典 grads - 包含权重和偏差相对于成本函数的梯度的字典 costs - 优化期间计算的所有成本列表，用于绘制学习曲线 :tips: 需要写下两个步骤并遍历它们： （1）计算当前参数的成本和梯度，使用propagate(). （2）使用w和b的梯度下降法则更新参数 """
    
        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，误差值：%f" % (i, cost))
    
            params = { 
                "w": w,
                "b": b
            }
            grads = { 
                "dw": dw,
                "db": db
            }
        return (params, grads, costs)
    
    def predict(w, b, X):
        """ 使用学习逻辑回归参数logistic(w,b)预测标签是0还是1 :param w: w - 权重，大小不等的数组 (num_px * num_px * 3,1) :param b: b - 偏差，一个标量 :param X: X - 矩阵类型为(num_px * num_px * 3,训练数量)的数据 :return: 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]转换为实际预测Y_prediction
            Y_prediction[0,i] = 1 if A[0,i] > 0.5 else 0
    
        #断言
        assert(Y_prediction.shape == (1,m))
    
        return Y_prediction
    
    def model(X_train, Y_train, X_test, Y_test, num_iteration=2000, learning_rate=0.5, print_cost = False):
        """ 构建逻辑回归模型 :param X_train: X_train - numpy数组，维度为(num_px * num_px * 3,m_train)的训练集 :param Y_train: Y_train - numpy数组，维度为(1,m_train)(矢量)的训练标签集 :param X_test: X_test - numpy数组，维度为(num_px * num_px * 3,m_test)的测试集 :param Y_test: Y_test - numpy数组，维度为(1,m_test)(向量)的测试标签集 :param num_iteration: num_iteration - 用于优化参数的迭代次数的超参数 :param learning_rate: learning_rate - 表示optimize()更行规则中使用的学习速率的超参数 :param print_cost: print_cost - 为true时，每100次迭代1打印一次成本 :return:、 d - 包含有关模型信息的字典 """
        w, b = initialize_with_zeros(X_train.shape[0])
        parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iteration, learning_rate, print_cost)
    
        # 从parameters检索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_prediction_train": Y_prediction_train,
            "w": w,
            "b": b,
            "learning_rate": learning_rate,
            "num_iterations": num_iteration
        }
        return d
    
    d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iteration=2000, learning_rate=0.005, print_cost=True)
    
    #绘制图
    costs = np.squeeze(d['costs'])
    plt.plot(costs)
    plt.ylabel('costs')
    plt.xlabel('iterations(per hundreds)')
    plt.title("learning rate = "+str(d["learning_rate"]))
    plt.show()

[Link 1]: https://wwr.lanzoui.com/iiFprqkclla
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTk0OTkyOA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/760c1ca9c12e4edaa504f61dc6bce0aa.png