本文参考CSDN博主「何宽」的文章， 原文链接：https://blog.csdn.net/u013733326/article/details/79639509

1、删除无用的虚拟环境test

首先，在Windows PowerShell里，退出当前虚拟环境：
(base) PS D:\anaconda\envs> conda deactivate
查看conda的所有虚拟环境：
image.png

现要删除test：
image.png
查看是否删除成功：
image.png

2、导入配套文件

将训练集和lr_utils模块添加到路径中：
image.png

3、创建新项目

在Pycharm里，选择anaconda文件夹下的envs文件夹，其中包含已配置好的deep-learning环境，在deep-learning环境中创建新项目CatImages。
image.png

4、导入代码

-- coding: utf-8 --

import numpy as np
import matplotlib.pyplot as plt
import h5py
from lr_utils import load_dataset

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

m_train = train_set_y.shape[1] # 训练集里图片的数量。
m_test = test_set_y.shape[1] # 测试集里图片的数量。
num_px = train_set_x_orig.shape[1] # 训练、测试集里面的图片的宽度和高度（均为64x64）。

现在看一看我们加载的东西的具体情况
print(“训练集的数量: mtrain = “ + 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(trainset_x_orig.shape))
print(“训练集标签的维数 : “ + str(trainset_y.shape))
print(“测试集图片的维数: “ + str(testset_x_orig.shape))
print(“测试集标签的维数: “ + str(test_set_y.shape))

将训练集的维度降低并转置。
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(trainset_x_flatten.shape))
print(“训练集标签的维数 : “ + str(trainset_y.shape))
print(“测试集降维之后的维度: “ + str(test_set_x_flatten.shape))
print(“测试集标签的维数 : “ + str(test_set_y.shape))

train_set_x = train_set_x_flatten / 255
test_set_x = test_set_x_flatten / 255

def sigmoid(z):
_”””
参数：
z - 任何大小的标量或numpy数组。

  1. 返回：<br />        s  -  sigmoid（z）<br />    """<br />    _s = 1 / (1 + np.exp(-z))<br />    return s

def initializewith_zeros(dim):
“””
此函数为w创建一个维度为（dim，1）的0向量，并将b初始化为0。

  1.     参数：<br />            dim  - 我们想要的w矢量的大小（或者这种情况下的参数数量）
  3.     返回：<br />            w  - 维度为（dim，1）的初始化向量。<br />            b  - 初始化的标量（对应于偏差）<br />    """<br />    _w = np.zeros(shape=(dim, 1))<br />    b = 0<br />    # 使用断言来确保我要的数据是正确的<br />    assert (w.shape == (dim, 1))  # w的维度是(dim,1)<br />    assert (isinstance(b, float) or isinstance(b, int))  # b的类型是float或者是int
  5. return (w, b)

def propagate(w, b, X, Y):
_”””
实现前向和后向传播的成本函数及其梯度。
参数：
w - 权重，大小不等的数组（num_px num_px 3，1）
b - 偏差，一个标量
X - 矩阵类型为（num_px num_px 3，训练数量）
Y - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据数量)

  1. 返回：<br />        cost- 逻辑回归的负对数似然成本<br />        dw  - 相对于w的损失梯度，因此与w相同的形状<br />        db  - 相对于b的损失梯度，因此与b的形状相同<br />    """<br />    _m = X.shape[1]
  3. # 正向传播<br />    A = sigmoid(np.dot(w.T, X) + b)  # 计算激活值，请参考公式2。<br />    cost = (- 1 / m) * np.sum(Y * np.log(A) + (1 - Y) * (np.log(1 - A)))  # 计算成本，请参考公式3和4。
  5. # 反向传播<br />    dw = (1 / m) * np.dot(X, (A - Y).T)  # 请参考视频中的偏导公式。<br />    db = (1 / m) * np.sum(A - Y)  # 请参考视频中的偏导公式。
  7. # 使用断言确保我的数据是正确的<br />    assert (dw.shape == w.shape)<br />    assert (db.dtype == float)<br />    cost = np.squeeze(cost)<br />    assert (cost.shape == ())
  9. # 创建一个字典，把dw和db保存起来。<br />    grads = {<br />        "dw": dw,<br />        "db": db<br />    }<br />    return (grads, cost)

def optimize(w, b, X, Y, numiterations, learning_rate, print_cost=False):
“””
此函数通过运行梯度下降算法来优化w和b

  1. 参数：<br />        w  - 权重，大小不等的数组（num_px * num_px * 3，1）<br />        b  - 偏差，一个标量<br />        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数组。<br />        Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据的数量)<br />        num_iterations  - 优化循环的迭代次数<br />        learning_rate  - 梯度下降更新规则的学习率<br />        print_cost  - 每100步打印一次损失值
  3. 返回：<br />        params  - 包含权重w和偏差b的字典<br />        grads  - 包含权重和偏差相对于成本函数的梯度的字典<br />        成本 - 优化期间计算的所有成本列表，将用于绘制学习曲线。
  5. 提示：<br />    我们需要写下两个步骤并遍历它们：<br />        1）计算当前参数的成本和梯度，使用propagate（）。<br />        2）使用w和b的梯度下降法则更新参数。<br />    """
  7. _costs = []
  9. for i in range(num_iterations):
  11.     grads, cost = propagate(w, b, X, Y)
  13.     dw = grads["dw"]<br />        db = grads["db"]
  15.     w = w - learning_rate * dw<br />        b = b - learning_rate * db
  17.     # 记录成本<br />        if i % 100 == 0:<br />            costs.append(cost)<br />        # 打印成本数据<br />        if (print_cost) and (i % 100 == 0):<br />            print("迭代的次数: %i ， 误差值： %f" % (i, cost))
  19. params = {<br />        "w": w,<br />        "b": b}<br />    grads = {<br />        "dw": dw,<br />        "db": db}<br />    return (params, grads, costs)

def predict(w, b, X):
_”””
使用学习逻辑回归参数logistic （w，b）预测标签是0还是1，

  1. 参数：<br />        w  - 权重，大小不等的数组（num_px * num_px * 3，1）<br />        b  - 偏差，一个标量<br />        X  - 维度为（num_px * num_px * 3，训练数据的数量）的数据
  3. 返回：<br />        Y_prediction  - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组（向量）
  5. """
  7. _m = X.shape[1]  # 图片的数量<br />    Y_prediction = np.zeros((1, m))<br />    w = w.reshape(X.shape[0], 1)
  9. # 计预测猫在图片中出现的概率<br />    A = sigmoid(np.dot(w.T, X) + b)<br />    for i in range(A.shape[1]):<br />        # 将概率a [0，i]转换为实际预测p [0，i]<br />        Y_prediction[0, i] = 1 if A[0, i] > 0.5 else 0<br />    # 使用断言<br />    assert (Y_prediction.shape == (1, m))
  11. return Y_prediction

def model(Xtrain, Y_train, X_test, Y_test, num_iterations=2000, learning_rate=0.5, print_cost=False):
“””
通过调用之前实现的函数来构建逻辑回归模型

  1. 参数：<br />        X_train  - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集<br />        Y_train  - numpy的数组,维度为（1，m_train）（矢量）的训练标签集<br />        X_test   - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集<br />        Y_test   - numpy的数组,维度为（1，m_test）的（向量）的测试标签集<br />        num_iterations  - 表示用于优化参数的迭代次数的超参数<br />        learning_rate  - 表示optimize（）更新规则中使用的学习速率的超参数<br />        print_cost  - 设置为true以每100次迭代打印成本
  3. 返回：<br />        d  - 包含有关模型信息的字典。<br />    """<br />    _w, b = initialize_with_zeros(X_train.shape[0])
  5. parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)
  7. # 从字典“参数”中检索参数w和b<br />    w, b = parameters["w"], parameters["b"]
  9. # 预测测试/训练集的例子<br />    Y_prediction_test = predict(w, b, X_test)<br />    Y_prediction_train = predict(w, b, X_train)
  11. # 打印训练后的准确性<br />    print("训练集准确性：", format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100), "%")<br />    print("测试集准确性：", format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100), "%")
  13. d = {<br />        "costs": costs,<br />        "Y_prediction_test": Y_prediction_test,<br />        "Y_prediciton_train": Y_prediction_train,<br />        "w": w,<br />        "b": b,<br />        "learning_rate": learning_rate,<br />        "num_iterations": num_iterations}<br />    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)

绘制图
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()

5、具体

5.1 引入库

首先，需要引入库：
image.png
numpy ：是用Python进行科学计算的基本软件包。
h5py：是与H5文件中存储的数据集进行交互的常用软件包。
matplotlib：是一个著名的库，用于在Python中绘制图表。
lr_utils ：在本文的资料包里，一个加载资料包里面的数据的简单功能的库。

导入模块步骤如下：
image.png
在Pycharm的File下的Setting里，找到Python Interpreter，通过左边加号，输入模块名字，Pycharm将自行安装。

5.2 lr_utils.py代码

image.png
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’]

对于训练集的标签而言，对于猫，标记为1，否则标记为0。
每一个图像的维度都是(num_px, num_px, 3)，其中，长宽相同，3表示是RGB图像。
train_set_x_orig和test_set_x_orig中，包含_orig是由于我们稍候需要对图像进行预处理，预处理后的变量将会命名为train_set_x和train_set_y。

将以上数据加载到主程序中：
image.png

5.2.1 h5py.File（）

image.png
HDF（Hierarchical Data Format）指一种为存储和处理大容量科学数据设计的文件格式及相应库文件。
最早由美国国家超级计算应用中心 NCSA 研究开发，目前在非盈利组织HDF Group维护下继续发展。
HDF支持多种商业及非商业的软件平台，包括MATLAB、Java、Python、R 和 Julia 、Spark 。
其版本包括了 HDF4 和 HDF5 ，当前流行的版本是 HDF5。
Python 中有一系列的工具可以操作和使用 HDF5 数据，其中最常用的是 h5py 和 PyTables。

HDF5文件是一种存储dataset 和 group 两类数据对象的容器，其操作类似 python 标准的文件操作；File 实例对象本身就是一个组，以 / 为名，是遍历文件的入口。

dataset：数据集，可类比为 Numpy 数组，每个数据集都有一个名字（name）、形状（shape） 和类型（dtype），支持切片操作；
group：组，可以类比为字典，它是一种像文件夹一样的容器；group 中可以存放 dataset 或者其他的 group，键就是组成员的名称，值就是组成员对象本身(组或者数据集)。


创建h5py文件：
image.png
参数说明：
第一个参数：文件名，可以是字节字符串或 unicode 字符串；
第二个参数：mode；
image.png

5.2.2 numpy.array()

image.png

5.2.3 .reshape()

image.png
在不改变数据内容的情况下，改变一个数组的格式，参数及返回值。
此时取出的数据是n行一列的，将标签变为一行n列

reshape(1,-1)：

转换成一行，如：
image.png

reshape(2,-1)：

转换成两行：
image.png

reshape(-1,1)：

转换成1列：
image.png

reshape(-1,2)：

转化成两列：
image.png

5.3 查看Label

5.3.1 输出标签值

image.png可训练集中测试前30张图片的标签。
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.
y = [0], it’s a ‘non-cat’ picture.
y = [1], it’s a ‘cat’ picture.

5.3.2 画出图像

画不出来
可以查看加载的文件里面的图片，如训练集里面的第26张图片：
image.png
结果是：
image.png