1.简单的识别猫的程序

标签：set 程序 print shape train 简单 test 识别 orig

import numpy as np

import matplotlib.pyplot as plt

import h5py

import skimage.transform as tf

%matplotlib inline

#########################################

1. import numpy as np: 这里导入了NumPy库，并将其重命名为np，这是一个用于数学计算的常用库。

2. import matplotlib.pyplot as plt: 这里导入了Matplotlib库中的pyplot模块，并将其重命名为plt，用于绘制图表和图形。

3. import h5py: 这里导入了h5py库，它用于处理HDF5文件格式的数据。

4. import skimage.transform as tf: 这里导入了scikit-image库中的transform模块，该模块提供了图像变换和几何变换的功能。

5. %matplotlib inline: 这是一个IPython魔术命令，用于在Jupyter Notebook等环境中显示Matplotlib图形，而不需要使用plt.show()来显示图形。

#########################################

def load_dataset():

    train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r") 

    train_set_x_orig = np.array(train_dataset["train_set_x"][:])

    train_set_y_orig = np.array(train_dataset["train_set_y"][:])

    test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")

    test_set_x_orig = np.array(test_dataset["test_set_x"][:])

    test_set_y_orig = np.array(test_dataset["test_set_y"][:])

    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

#########################################

 

这段代码定义了一个名为load_dataset的函数，该函数用于加载一个包含训练和测试数据集的HDF5文件，并返回这些数据集以及类别信息。

1. train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r"): 这一行代码打开名为'train_catvnoncat.h5'的HDF5文件，并将其存储在train_dataset变量中。文件以只读模式（"r"）打开。

2. train_set_x_orig = np.array(train_dataset["train_set_x"][:]): 这一行代码从train_dataset中提取了名为"train_set_x"的数据集，将其存储在train_set_x_orig变量中，并将其转换为NumPy数组。

3. train_set_y_orig = np.array(train_dataset["train_set_y"][:]): 这一行代码从train_dataset中提取了名为"train_set_y"的标签集，将其存储在train_set_y_orig变量中，并将其转换为NumPy数组。

4. test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r"): 这一行代码打开名为'test_catvnoncat.h5'的HDF5文件，将其存储在test_dataset变量中，同样以只读模式打开。

5. test_set_x_orig = np.array(test_dataset["test_set_x"][:]): 这一行代码从test_dataset中提取了名为"test_set_x"的测试数据集，将其存储在test_set_x_orig变量中，并将其转换为NumPy数组。

6. test_set_y_orig = np.array(test_dataset["test_set_y"][:]): 这一行代码从test_dataset中提取了名为"test_set_y"的测试标签集，将其存储在test_set_y_orig变量中，并将其转换为NumPy数组。

7. classes = np.array(test_dataset["list_classes"][:]): 这一行代码从test_dataset中提取了名为"list_classes"的类别信息，并将其存储在classes变量中。

8. 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])): 这两行代码将train_set_y_orig和test_set_y_orig的形状从(样本数,)调整为(1, 样本数)，以确保它们的维度正确。

最后，函数返回了以下内容：

• train_set_x_orig: 训练数据的特征集（原始图像）作为NumPy数组。
• train_set_y_orig: 训练数据的标签集（0表示非猫，1表示猫）作为NumPy数组。
• test_set_x_orig: 测试数据的特征集（原始图像）作为NumPy数组。
• test_set_y_orig: 测试数据的标签集（0表示非猫，1表示猫）作为NumPy数组。
• classes: 类别信息，表示标签的含义（例如，0对应非猫，1对应猫）。

这个函数用于加载用于猫识别问题的数据集，并为进一步的机器学习任务提供了所需的数据。

#########################################

train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()

#########################################

这行代码调用了之前定义的 load_dataset() 函数，将它的返回值分配给了多个变量。

• train_set_x_orig: 这个变量接收了 load_dataset() 函数返回的训练数据的特征集（原始图像），它是一个NumPy数组。

• train_set_y: 这个变量接收了 load_dataset() 函数返回的训练数据的标签集，表示每个训练示例的标签（0表示非猫，1表示猫）。请注意，这个变量的名称与 load_dataset() 函数返回的 train_set_y_orig 可能不同，因为您可以选择不使用原始标签集的变量名。

• test_set_x_orig: 这个变量接收了 load_dataset() 函数返回的测试数据的特征集（原始图像），也是一个NumPy数组。

• test_set_y: 这个变量接收了 load_dataset() 函数返回的测试数据的标签集，表示每个测试示例的标签（同样，0表示非猫，1表示猫）。

• classes: 这个变量接收了 load_dataset() 函数返回的类别信息，用于解释标签的含义（例如，0对应非猫，1对应猫）。

这行代码的目的是将数据集的各个部分（训练集的特征和标签，测试集的特征和标签，类别信息）分别分配给不同的变量，以便后续的机器学习任务中使用。

#########################################

index = 30
plt.imshow(train_set_x_orig[index])
print ("标签为" + str(train_set_y[:, index]) + ", 这是一个'" + classes[np.squeeze(train_set_y[:, index])].decode("utf-8") + "' 图片.")

#########################################

这段代码用于显示训练数据集中的第30个图像，并输出相关信息。

1. index = 30: 这一行代码将变量 index 设置为30，即我们要显示训练数据集中的第30个图像。

2. plt.imshow(train_set_x_orig[index]): 这一行代码使用Matplotlib的imshow函数来显示训练数据集中的第30个图像。train_set_x_orig是一个存储原始图像的NumPy数组，train_set_x_orig[index]选择了第30个图像，并且plt.imshow()用于显示它。

3. print ("标签为" + str(train_set_y[:, index]) + ", 这是一个'" + classes[np.squeeze(train_set_y[:, index])].decode("utf-8") + "' 图片."): 这一行代码用于输出与第30个图像相关的信息。具体来说：

   • train_set_y[:, index]：这部分代码获取了第30个训练示例的标签。
   • str(train_set_y[:, index])：将标签转换为字符串格式。
   • classes[np.squeeze(train_set_y[:, index])]：通过将标签作为索引，获取与之相关的类别信息。np.squeeze()用于去除多余的维度。
   • .decode("utf-8")：将类别信息从字节格式解码为UTF-8字符串格式。
   • print()函数将所有这些信息输出到控制台，以便查看。

总之，这段代码的目的是可视化训练数据集中的第30个图像，并显示其相关的标签信息。

#########################################

print ("train_set_x_orig shape: " + str(train_set_x_orig.shape))
print ("train_set_y shape: " + str(train_set_y.shape))
print ("test_set_x_orig shape: " + str(test_set_x_orig.shape))
print ("test_set_y shape: " + str(test_set_y.shape))

#########################################

这些代码用于打印出训练数据集和测试数据集的形状（维度）。

1. print ("train_set_x_orig shape: " + str(train_set_x_orig.shape)): 这一行代码打印出训练数据集的特征集（原始图像）的形状。train_set_x_orig.shape返回一个元组，包含了训练特征集的维度信息，例如（样本数，图像宽度，图像高度，通道数）。

2. print ("train_set_y shape: " + str(train_set_y.shape)): 这一行代码打印出训练数据集的标签集的形状。train_set_y.shape返回一个元组，包含了训练标签集的维度信息，通常是（1，样本数），其中1表示每个标签的维度。

3. print ("test_set_x_orig shape: " + str(test_set_x_orig.shape)): 这一行代码打印出测试数据集的特征集的形状，与第一行代码类似。

4. print ("test_set_y shape: " + str(test_set_y.shape)): 这一行代码打印出测试数据集的标签集的形状，与第二行代码类似。

通过打印这些形状信息，您可以了解到训练数据集和测试数据集的维度，这在进行数据处理和机器学习任务时非常重要。

#########################################

m_train = train_set_x_orig.shape[0]
m_test = test_set_x_orig.shape[0]
num_px = test_set_x_orig.shape[1] # 由于我们的图片是正方形的，所以长宽相等

print ("训练样本数: m_train = " + str(m_train))
print ("测试样本数: m_test = " + str(m_test))
print ("每张图片的宽/高: num_px = " + str(num_px))

#########################################

这些代码计算并打印了有关数据集的一些重要信息。

1. m_train = train_set_x_orig.shape[0]: 这一行代码计算了训练数据集中的样本数，即m_train。train_set_x_orig.shape返回一个包含数据集形状信息的元组，其中的第一个元素（索引0）是样本数。

2. m_test = test_set_x_orig.shape[0]: 这一行代码计算了测试数据集中的样本数，即m_test，与上面的代码类似。

3. num_px = test_set_x_orig.shape[1]: 这一行代码计算了每张图片的宽度（或高度，因为它们相等），即num_px。test_set_x_orig.shape返回一个包含数据集形状信息的元组，其中的第二个元素（索引1）是图像的宽度（或高度）。

4. print ("训练样本数: m_train = " + str(m_train)): 这一行代码打印出训练样本数，使用了前面计算得到的m_train变量。

5. print ("测试样本数: m_test = " + str(m_test)): 这一行代码打印出测试样本数，使用了前面计算得到的m_test变量。

6. print ("每张图片的宽/高: num_px = " + str(num_px)): 这一行代码打印出每张图片的宽度（或高度），使用了前面计算得到的num_px变量。

这些信息对于了解数据集的规模和图像的尺寸非常重要，因为它们将在模型训练和预测中发挥关键作用。

#########################################

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 ("train_set_x_flatten shape: " + str(train_set_x_flatten.shape))
print ("test_set_x_flatten shape: " + str(test_set_x_flatten.shape))

#########################################

这些代码执行了数据的扁平化操作，并打印出扁平化后的数据集形状信息。

1. train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T: 这一行代码将训练数据集的特征集（原始图像）进行了扁平化操作，将每个图像展平为一个一维向量。具体来说：

   • train_set_x_orig.shape[0]：返回训练数据集中的样本数，这是第一个维度。
   • .reshape(train_set_x_orig.shape[0], -1): 使用reshape函数将数据集的维度调整为（样本数，-1），其中-1表示自动计算该维度的大小，以确保保持原始数据的总大小不变。
   • .T：最后，通过转置操作，将得到的二维数组的行和列交换，以便每一列表示一个扁平化的图像。结果存储在train_set_x_flatten中。

2. test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T: 这一行代码对测试数据集的特征集执行了与训练数据集相同的扁平化操作，结果存储在test_set_x_flatten中。

3. print ("train_set_x_flatten shape: " + str(train_set_x_flatten.shape)): 这一行代码打印出训练数据集扁平化后的形状信息，以便查看扁平化后的特征向量的维度。

4. print ("test_set_x_flatten shape: " + str(test_set_x_flatten.shape)): 这一行代码打印出测试数据集扁平化后的形状信息，以便查看扁平化后的特征向量的维度。

扁平化操作将图像数据从三维矩阵（样本数，图像宽度，图像高度）转换为二维矩阵（特征数，样本数），其中每一列表示一个扁平化的图像。这种形式的数据通常更适合输入到机器学习模型中进行训练。

#########################################

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

#########################################

这些代码用于对训练数据集和测试数据集进行特征缩放，将像素值从整数范围[0, 255]缩放到浮点数范围[0, 1]。

1. train_set_x = train_set_x_flatten/255.: 这一行代码将训练数据集的扁平化特征集（原始图像像素值）除以255。这样做的目的是将像素值从0到255的范围缩放到0到1的范围。这种缩放通常有助于模型更好地进行训练，因为它将特征值限制在较小的范围内，有助于梯度下降等优化算法更快地收敛。

2. test_set_x = test_set_x_flatten/255.: 这一行代码对测试数据集的扁平化特征集执行与训练数据集相同的缩放操作，确保训练和测试数据都经过相同的预处理。

这种特征缩放通常是图像处理中的常见预处理步骤之一，以确保图像数据具有合适的范围，有助于模型的训练和性能提升。

#########################################

def sigmoid(z):
"""
参数:
z -- 一个数值或者一个numpy数组.
返回值:
s -- 经过sigmoid算法计算后的值，在[0,1]范围内
"""
s = 1 / (1 + np.exp(-z))
return s

#########################################

这个函数实现了Sigmoid函数，也称为逻辑S函数。Sigmoid函数是一种常用的激活函数，通常用于二分类问题中的逻辑回归模型。

• z 是输入参数，可以是一个实数，一个向量或一个矩阵。

• np.exp(-z) 计算输入的负指数。

• 1 / (1 + np.exp(-z)) 计算Sigmoid函数的输出，这是一个介于0和1之间的值。

• 最后，函数返回Sigmoid函数的输出 s。

Sigmoid函数的输出范围在0到1之间，通常用于将线性模型的输出映射到概率值，例如，在逻辑回归中，Sigmoid函数将线性组合的输入映射到一个表示正类别概率的值。

#########################################

def initialize_with_zeros(dim):
"""
这个函数用于初始化权重数组w和偏置/阈值b.

参数:
dim -- w的大小，看上面的神经网络模型图可知，dim在本例中是12288，因为一个特征输入对应一个权重。

返回值:
w -- 权重数组
b -- 偏置bias
"""

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

return w, b

#########################################

这个函数用于初始化一个维度为 dim 的权重向量 w 和偏置项 b，并将它们的初始值设置为零。这通常是在构建一个简单的线性模型时的初始步骤。

• dim 是一个整数参数，表示要初始化的权重向量的维度。

• w = np.zeros((dim, 1)) 创建一个维度为 (dim, 1) 的全零权重向量，其中每个元素都初始化为零。这个权重向量通常用于存储模型的参数。

• b = 0 初始化偏置项 b 为零。偏置项是一个标量，通常与权重向量一起用于构建线性模型的输出。

最终，函数返回了初始化后的权重向量 w 和偏置项 b。

这个函数的作用是为了提供一个合适的初始参数值，以便后续进行模型训练。

#########################################

def propagate(w, b, X, Y):
"""
参数:
w -- 权重数组，维度是(12288, 1)
b -- 偏置bias
X -- 图片的特征数据，维度是 (12288, 209)
Y -- 图片对应的标签，0或1，0是无猫，1是有猫，维度是(1,209)

返回值:
cost -- 成本
dw -- w的梯度
db -- b的梯度
"""

m = X.shape[1]

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

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

# 将dw和db保存到字典里面
grads = {"dw": dw,
"db": db}

return grads, cost

#########################################

这个函数实现了神经网络中的前向传播和反向传播过程，用于计算损失函数的梯度。

• w 和 b 是模型的权重和偏置项，分别代表前向传播过程中的参数。

• X 是输入特征的矩阵，每列代表一个训练样本。

• Y 是真实标签的向量，与训练样本一一对应。

• m 是训练样本的数量。

在函数内部：

• 首先，进行前向传播，计算激活值 A，使用了前面定义的 sigmoid 函数，并计算交叉熵损失函数 cost。

• 然后，进行反向传播，计算梯度。dZ 是激活值与真实标签之间的差异，dw 是权重的梯度，db 是偏置项的梯度。

• 最后，将梯度和损失函数的值封装在一个字典 grads 中，并返回。

这个函数的目的是计算模型的梯度，以便后续使用梯度下降等优化算法来更新模型参数。

#########################################

def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
"""
参数:
w -- 权重数组，维度是 (12288, 1)
b -- 偏置bias
X -- 图片的特征数据，维度是 (12288, 209)
Y -- 图片对应的标签，0或1，0是无猫，1是有猫，维度是(1,209)
num_iterations -- 指定要优化多少次
learning_rate -- 学习步进，是我们用来控制优化步进的参数
print_cost -- 为True时，每优化100次就把成本cost打印出来,以便我们观察成本的变化

返回值:
params -- 优化后的w和b
costs -- 每优化100次，将成本记录下来，成本越小，表示参数越优化
"""

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:
print ("优化%i次后成本是: %f" %(i, cost))

params = {"w": w,
"b": b}
return params, costs

#########################################

这个函数实现了参数优化的过程，通常使用梯度下降算法来更新模型的参数，以最小化损失函数。

• w 和 b 是模型的权重和偏置项，它们将在每次迭代中更新。

• X 是输入特征的矩阵，每列代表一个训练样本。

• Y 是真实标签的向量，与训练样本一一对应。

• num_iterations 是迭代的次数，即要执行多少次梯度下降更新步骤。

• learning_rate 是学习率，控制了每次参数更新的步长大小。

• print_cost 是一个布尔值，用于控制是否打印每100次迭代后的损失值。

在函数内部：

• 迭代 num_iterations 次，每次迭代都计算梯度和损失，并使用梯度下降算法来更新参数 w 和 b。

• 如果 print_cost 为真，那么会打印每100次迭代后的损失值，这有助于监视训练过程。

• 最后，将更新后的参数封装在字典 params 中，并返回。

这个函数的目的是通过梯度下降来优化模型的参数，以减小损失函数的值，从而提高模型的性能。

#########################################

def predict(w, b, X):
'''
参数:
w -- 权重数组，维度是 (12288, 1)
b -- 偏置bias
X -- 图片的特征数据，维度是 (12288, 图片张数)

返回值:
Y_prediction -- 对每张图片的预测结果
'''
m = X.shape[1]
Y_prediction = np.zeros((1,m))

A = sigmoid(np.dot(w.T, X) + b) # 通过这行代码来对图片进行预测

# 上面得出的预测结果是小数的形式，为了方便后面显示，我们将其转换成0和1的形式（大于等于0.5就是1/有猫，小于0.5就是0/无猫）
for i in range(A.shape[1]):
if A[0,i] >= 0.5:
Y_prediction[0,i] = 1

return Y_prediction

#########################################

这个函数用于使用训练好的模型参数 w 和 b 来进行预测。具体来说，它将输入特征矩阵 X 中的每个样本作为输入，通过模型进行前向传播，然后根据模型输出的概率值进行二分类预测。

• w 和 b 是已经训练好的模型参数，用于进行预测。

• X 是输入特征的矩阵，每列代表一个样本。

• m 是输入特征矩阵中的样本数。

在函数内部：

• 首先，通过前向传播计算模型输出的概率值 A，使用了前面定义的 sigmoid 函数。

• 然后，对每个样本的概率值进行判断，如果概率值大于等于0.5，则将预测结果设为1（正类别），否则设为0（负类别）。

• 最后，将预测结果存储在 Y_prediction 中，它是一个形状为 (1, m) 的NumPy数组，每列代表一个样本的预测结果。

这个函数的目的是使用训练好的模型来进行预测，从而对新的样本进行分类。

#########################################

def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):
"""
参数:
X_train -- 训练图片,维度是(12288, 209)
Y_train -- 训练图片对应的标签,维度是 (1, 209)
X_test -- 测试图片,维度是(12288, 50)
Y_test -- 测试图片对应的标签,维度是 (1, 50)
num_iterations -- 需要训练/优化多少次
learning_rate -- 学习步进，是我们用来控制优化步进的参数
print_cost -- 为True时，每优化100次就把成本cost打印出来,以便我们观察成本的变化

返回值:
d -- 返回一些信息
"""

# 初始化待训练的参数
w, b = initialize_with_zeros(X_train.shape[0])

# 使用训练数据来训练/优化参数
parameters, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)

# 从字典中分别取出训练好的w和b
w = parameters["w"]
b = parameters["b"]

# 使用训练好的w和b来分别对训练图片和测试图片进行预测
Y_prediction_train = predict(w, b, X_train)
Y_prediction_test = predict(w, b, X_test)

# 打印出预测的准确率
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_iterations}

return d

#########################################

这个函数用于构建整个二分类模型，包括初始化参数、模型训练、预测和性能评估等步骤。

这个函数执行以下关键步骤：

1. 初始化参数 w 和 b。

2. 使用 optimize 函数进行模型训练，获得训练后的参数 w 和 b，以及损失值的变化列表 costs。

3. 使用训练后的模型参数进行训练集和测试集的预测，得到预测结果 Y_prediction_train 和 Y_prediction_test。

4. 计算并打印模型在训练集和测试集上的准确率。

5. 构建包含关键信息的字典 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)

这段代码使用了您定义的 model 函数来训练和评估一个二分类模型，使用了训练集和测试集的数据。

• train_set_x 和 train_set_y 是训练集的特征和标签数据。

• test_set_x 和 test_set_y 是测试集的特征和标签数据。

• num_iterations 设置了迭代次数，指定模型训练的迭代次数。

• learning_rate 设置了学习率，控制了参数更新的步长大小。

• print_cost 是一个布尔值，如果设置为 True，则会在每100次迭代后打印成本值。

函数 model 将执行以下步骤：

1. 初始化模型参数。

2. 使用梯度下降算法对模型进行训练，根据训练集计算参数 w 和 b，并记录成本函数的变化。

3. 使用训练后的参数对训练集和测试集进行预测。

4. 打印训练集和测试集上的准确率。

5. 返回一个字典 d，其中包含训练过程中的成本值、训练集和测试集上的预测结果以及其他关键信息。

您可以通过查看 d 中的内容来进一步分析模型的性能以及训练过程中的成本变化。

#########################################

index = 8
plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))
print ("这张图的标签是 " + str(test_set_y[0,index]) + ", 预测结果是 " + str(int(d["Y_prediction_test"][0,index])))

#########################################

这段代码用于显示测试集中的一张图像，并展示其真实标签和模型的预测结果。

index = 8 # 选择要显示的图像的索引
plt.imshow(test_set_x[:, index].reshape((num_px, num_px, 3))) # 显示图像

# 打印图像的真实标签和模型的预测结果
print("这张图的标签是 " + str(test_set_y[0, index]) + ", 预测结果是 " + str(int(d["Y_prediction_test"][0, index])))

• index 是要显示的测试集图像的索引，这里选择了第9张图像（Python索引从0开始）。

• plt.imshow(test_set_x[:, index].reshape((num_px, num_px, 3))) 用于显示图像，test_set_x[:, index] 是图像数据，reshape 函数将图像数据重新排列成 (num_px, num_px, 3) 的形状，其中 num_px 是图像的宽度和高度，3 表示图像通道数（通常是RGB图像）。

• 最后，使用 print 语句打印出图像的真实标签和模型的预测结果。这里通过 test_set_y 获取了真实标签，通过 d["Y_prediction_test"] 获取了模型的预测结果。

这段代码有助于可视化模型对单个图像的预测效果，以及模型是否能够正确地将图像分类。如果需要查看其他图像的预测结果，只需更改 index 的值即可。

#########################################

costs = np.squeeze(d['costs'])
plt.plot(costs)
plt.ylabel('cost') # 成本
plt.xlabel('iterations (per hundreds)') # 横坐标为训练次数，以100为单位
plt.title("Learning rate =" + str(d["learning_rate"]))
plt.show()

#########################################

这段代码用于绘制模型在训练过程中成本函数的变化曲线，以帮助您可视化模型的训练进展和学习率的影响。

 

costs = np.squeeze(d['costs']) # 从字典中获取成本值，并将其转换为NumPy数组

plt.plot(costs) # 绘制成本值的曲线
plt.ylabel('cost') # 设置y轴标签为"成本"
plt.xlabel('iterations (per hundreds)') # 设置x轴标签为"训练次数（以100为单位）"
plt.title("Learning rate =" + str(d["learning_rate"])) # 设置图标题，包括学习率信息
plt.show() # 显示绘制的曲线图

• costs 是包含成本函数值的NumPy数组，这些成本函数值在模型训练过程中记录下来，用于表示模型的性能。

• plt.plot(costs) 用于绘制成本值的曲线。

• plt.ylabel('cost') 设置y轴的标签为 "成本"，以表示y轴的含义。

• plt.xlabel('iterations (per hundreds)') 设置x轴的标签为 "训练次数（以100为单位）"，以表示x轴的含义。

• plt.title("Learning rate =" + str(d["learning_rate"])) 设置图的标题，包括学习率的信息。

• 最后，plt.show() 用于显示绘制的曲线图。

这个曲线图可以帮助您了解模型在训练过程中成本函数的变化情况，通常希望成本值随着训练次数的增加而逐渐减小。如果成本函数值在训练中不断减小，说明模型正在收敛。

#########################################

learning_rates = [0.01, 0.001, 0.0001]
models = {}
for i in learning_rates:
print ("学习率为: " + 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 (hundreds)')

legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
plt.show()

#########################################

这段代码用于比较不同学习率下模型的训练效果，以及不同学习率下成本函数的变化曲线。

learning_rates = [0.01, 0.001, 0.0001] # 不同的学习率值
models = {} # 用于存储不同学习率下的模型和结果

# 针对每个学习率值进行模型训练
for i in learning_rates:
print("学习率为: " + 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') # y轴标签为"成本"
plt.xlabel('iterations (hundreds)') # x轴标签为"训练次数（以100为单位）"

# 添加图例
legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')

plt.show() # 显示绘制的曲线图

• learning_rates 是一个包含不同学习率值的列表，用于比较不同学习率下的模型性能。

• models 是一个字典，用于存储不同学习率下的模型和训练结果。

在第一个循环中，对于每个学习率值，执行以下操作：

• 使用 model 函数进行模型训练，得到不同学习率下的模型和结果，并存储在 models 字典中。

在第二个循环中，绘制不同学习率下成本函数的变化曲线：

• plt.plot(np.squeeze(models[str(i)]["costs"]), label=str(models[str(i)]["learning_rate"])) 绘制每个学习率下成本函数的曲线，并添加相应的标签。

• plt.ylabel('cost') 设置y轴标签为 "成本"，以表示y轴的含义。

• plt.xlabel('iterations (hundreds)') 设置x轴标签为 "训练次数（以100为单位）"，以表示x轴的含义。

• 最后，使用 plt.legend 添加图例，以显示不同学习率下的曲线对应的学习率。

这个代码片段的目的是帮助您比较不同学习率下的模型性能和成本函数的变化趋势，以选择最合适的学习率来训练模型。

#########################################

my_image = "my_image1.jpg"
fname = "images/" + my_image

image = np.array(plt.imread(fname))
my_image = tf.resize(image,(num_px,num_px), mode='reflect').reshape((1, num_px*num_px*3)).T
my_predicted_image = predict(d["w"], d["b"], my_image)

plt.imshow(image)
print("预测结果为 " + str(int(np.squeeze(my_predicted_image))))

#########################################

这段代码用于对一张自定义图像进行预测，并显示该图像以及模型的预测结果。

my_image = "my_image1.jpg" # 自定义图像文件名
fname = "images/" + my_image # 图像文件的路径

# 读取自定义图像文件并处理成模型需要的格式
image = np.array(plt.imread(fname))
my_image = tf.resize(image, (num_px, num_px), mode='reflect').reshape((1, num_px * num_px * 3)).T

# 使用模型进行预测
my_predicted_image = predict(d["w"], d["b"], my_image)

# 显示图像
plt.imshow(image)
print("预测结果为 " + str(int(np.squeeze(my_predicted_image))))

• my_image 是自定义图像的文件名，您需要将图像文件放在 images/ 目录下，并将文件名指定为 my_image1.jpg 或其他文件名。

• fname 是完整的图像文件路径，用于读取图像文件。

• 使用 plt.imread(fname) 读取图像文件，然后使用 skimage.transform.resize 将图像调整为模型需要的大小（num_px x num_px），并将其重新排列成形状为 (1, num_px * num_px * 3) 的向量。

• 使用训练好的模型参数 d["w"] 和 d["b"] 对自定义图像进行预测，并将结果存储在 my_predicted_image 中。

• 最后，使用 plt.imshow(image) 显示自定义图像，并使用 print 打印模型的预测结果。

这段代码的目的是演示如何使用训练好的模型来对自定义图像进行分类

 

标签：set,程序,print,shape,train,简单,test,识别,orig
From： https://www.cnblogs.com/wzbzk/p/17666744.html