【深度学习-第5篇】使用Python快速实现CNN分类（模式识别）任务，含一维、二维、三维数据演示案例（使用pytorch框架）

在之前的文章中介绍了CNN的图解入门，CNN的MATLAB分类实现，CNN的MATLAB回归实现。

卷积神经网络(Convolutional Neural Networ，简称CNN)是一种广泛应用于图像识别领域的深度学习算法。它通过模拟人类视觉系统的层次结构，可以自动提取和学习图像的特征,在图像分类、目标检测、人脸识别等任务上取得了巨大成功。

当然了，CNN也可以扩展到非图像领域使用，比如对一组一维数据，也是同样可以实现分类的。本篇文章是之前CNN分类的MATLAB实现那篇文章的姊妹篇，通过这篇文章，大家将会快速掌握使用pytorch框架进行CNN分类的编程方法，另外对于主体代码流程，我也做了傻瓜化使用的封装，方便大家使用。

一、环境搭建

本篇使用的是Win10系统搭建VSCode+Anaconda+Pytorch+CUDA环境，当然如果你是用的是其他编辑器，没有使用anaconda，或者没有独立显卡，本文的程序也都是可以实现的（不过也需要正确配置好了相关环境）。

如果你还没有配置环境，或者配置的环境运行后边的代码有错误，那么推荐大家按照我之前的这篇文章操作来重新进行配置：

Mr.看海：【深度学习-番外1】Win10系统搭建VSCode+Anaconda+Pytorch+CUDA深度学习环境和框架全过程

环境搭建中遇到的问题，大家可以集中在上边这篇文章中留言反映。

二、一个简单的案例

这里我们以最常用的MNIST 数据集作为分类对象。MNIST 数据集包含 70,000 张手写数字的灰度图像 (0-9)。

0. 安装必要的库并导入

如果大家使用上述环境搭建方法，使用了conda的环境，则不需要再额外安装库。如果不是的话，你可能会需要安装numpy，torch和sklearn。

安装好之后，代码中导入必要的库：

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, recall_score, precision_score

1. 加载数据和预处理

1.1 加载数据

加载mnist.npz数据文件（这个文件文末可以获取），然后读取其中的输入和输出数据。输入就是手写图片数据，输出是标签，也就是图片中的真实数值。

# 1.1 加载MNIST数据集,并预处理
data = np.load('mnist.npz')
xdata, ydata = data['x_train'], data['y_train']

1.2 数据预处理

使用reshape()函数将xdata的形状调整为(样本数, 通道数, 高度, 宽度)的格式，以符合PyTorch中卷积神经网络的输入要求。这里的-1表示自动计算样本数，1表示单通道灰度图像，28表示图像的高度和宽度。

# 1.2 数据预处理:将图像数据reshape为(样本数, 通道数, 高度, 宽度)的形状
xdata = xdata.reshape(-1, 1, 28, 28)

1.3 将数据转换为PyTorch张量

使用torch.tensor()函数将NumPy数组xdata和ydata转换为PyTorch张量，并指定数据类型。

之所以为了转化为张量，是因为PyTorch的模型和计算操作都基于PyTorch张量(torch.Tensor)进行，此步骤是必须的。

# 1.3 将NumPy数组转换为PyTorch张量,并指定数据类型
xdata = torch.tensor(xdata, dtype=torch.float32)
ydata = torch.tensor(ydata, dtype=torch.long)

2. 数据集划分

2.1 划分

使用train_test_split()函数将数据集划分为训练集和测试集,其中test_size=0.2表示测试集占总数据的20%,random_state=42用于固定随机种子以保证结果的可重复性。

将划分后的数据分别赋值给train_data(训练集图像)、test_data(测试集图像)、train_labels(训练集标签)和test_labels(测试集标签)。

# 2.1 使用train_test_split函数划分训练集和测试集
train_data, test_data, train_labels, test_labels = train_test_split(xdata, ydata, test_size=0.2, random_state=42)

2.2 创建数据加载器

数据划分完成后我们创建一下数据加载器，这么做的主要意义在于实现高效的数据批处理和数据迭代。数据加载器将数据集封装成可迭代的对象，并提供了许多有用的功能（比如数据打乱等），使得数据的读取、处理和输入到模型中更加方便和高效。具体到代码实现说明如下：

使用TensorDataset()函数将训练集的图像和标签数据打包成数据集对象train_dataset，同样地，创建测试集数据集对象test_dataset。
使用DataLoader()函数创建数据加载器train_loader和test_loader，用于批量加载和迭代数据。
batch_size=128表示每个批次包含128个样本，shuffle=True表示在每个epoch开始时打乱训练数据的顺序,以减少过拟合。

# 2.2 创建数据加载器DataLoader,用于批量加载数据
train_dataset = TensorDataset(train_data, train_labels)
test_dataset = TensorDataset(test_data, test_labels)

train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=128)

3. 定义CNN模型

我们在这里定义一个名为CNN的类，继承自nn.Module，这是一个PyTorch的神经网络模块。

# 3. 定义卷积神经网络(CNN)模型
class CNN(nn.Module):
    def __init__(self, num_classes):
        super(CNN, self).__init__()
        # 第一个卷积层:输入通道数为1,输出通道数为16,卷积核大小为3x3,步长为1,填充为1
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)
        self.relu1 = nn.ReLU()  # ReLU激活函数
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化层,池化核大小为2x2,步长为2
        
        # 第二个卷积层:输入通道数为16,输出通道数为32,卷积核大小为3x3,步长为1,填充为1
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
        self.relu2 = nn.ReLU()  # ReLU激活函数
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化层,池化核大小为2x2,步长为2
        
        # 全连接层:输入特征向量大小为32*7*7(经过卷积和池化后的特征图大小),输出大小为num_classes
        self.fc = nn.Linear(32 * 7 * 7, num_classes)

    def forward(self, x):
        # 前向传播过程:依次经过卷积层、ReLU激活函数、最大池化层,最后通过全连接层得到输出
        x = self.conv1(x)
        x = self.relu1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.relu2(x)
        x = self.pool2(x)
        x = x.view(x.size(0), -1)  # 将特征图展平成一维向量
        x = self.fc(x)
        return x

# 计算数据集中的类别数
num_classes = ydata.max().item() + 1
# 创建CNN模型实例
model = CNN(num_classes)

作为代码的核心部分，下边我详细讲解一下：

3.1 __init__(self, num_classes)部分

__init__(self, num_classes)部分实现CNN类的构造函数，在创建CNN实例时调用该方法。num_classes入口参数表示最终分类的类别数，即模型需要预测的不同类别的数量。

self.conv1 = nn.Conv2d(1,16, kernel_size=3, stride=1, padding=1)

定义了第一个卷积层conv1,使用nn.Conv2d类。
参数含义:输入通道数为1(灰度图像),输出通道数为16,卷积核大小为3x3,步长为1,填充为1。
卷积层用于提取图像的局部特征,通过卷积操作将输入图像转换为特征图。

self.relu1 = nn.ReLU()

定义了第一个ReLU激活函数relu1,使用nn.ReLU类。
ReLU激活函数用于引入非线性,提高模型的表达能力。

self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)

定义了第一个最大池化层pool1,使用nn.MaxPool2d类。
参数含义:池化核大小为2x2,步长为2。
最大池化层用于降低特征图的空间维度,同时保留最显著的特征。

self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
self.relu2 = nn.ReLU()
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)

上边这三行定义了第二个卷积层、激活函数和池化层。

self.fc = nn.Linear(32 * 7 * 7, num_classes)

定义了全连接层fc,使用nn.Linear类。
参数含义:输入特征向量的大小为32 * 7 * 7(经过卷积和池化后的特征图大小)，输出大小为num_classes。
全连接层用于将提取的特征映射到最终的分类结果。

上述是一个简单的CNN网络结构，大家还可以根据实际需要，添加层或者修改其中的参数，如果不知道怎么修改，对CNN结构不熟悉，或者最后全连接层的特征图大小不知道怎么计算，都可以看这篇文章的讲解：

Mr.看海：【深度学习-第2篇】CNN卷积神经网络30分钟入门！足够通俗易懂了吧（图解）

CNN网络通用架构，来自上边的文章

3.2 forward(self, x)部分

forward(self, x)定义了前向传播的过程，描述了输入数据经过CNN的各个层的顺序和操作。x表示输入的图像数据。

x = self.conv1(x)
x = self.relu1(x)
x = self.pool1(x)
x = self.conv2(x)
x = self.relu2(x)
x = self.pool2(x)

依次将输入数据x通过第一个卷积层、ReLU激活函数和最大池化层,得到第一次处理后的特征图。
然后依次通过第二个卷积层、ReLU激活函数和最大池化层,得到进一步提取的特征图。

x = x.view(x.size(0), -1)

将经过卷积和池化后的特征图展平成一个一维向量,以便输入到全连接层。
x.size(0)表示当前批次的样本数量,-1表示自动计算展平后的特征向量长度。

x = self.fc(x)

将展平后的特征向量通过全连接层,得到最终的预测结果。

4. 训练模型

# 4. 训练模型
criterion = nn.CrossEntropyLoss()  # 定义交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 定义Adam优化器,学习率为0.001
num_epochs = 10  # 训练的总轮数

for epoch in range(num_epochs):
    train_loss = 0.0
    train_preds = []
    train_true = []
    for data, labels in train_loader:
        optimizer.zero_grad()  # 梯度清零
        outputs = model(data)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新模型参数
        train_loss += loss.item() * data.size(0)  # 累计训练损失
        _, preds = torch.max(outputs, 1)  # 获取预测结果
        train_preds.extend(preds.numpy())  # 收集训练集的预测结果
        train_true.extend(labels.numpy())  # 收集训练集的真实标签
    train_loss /= len(train_loader.dataset)  # 计算平均训练损失
    train_acc = accuracy_score(train_true, train_preds)  # 计算训练准确率
    
    print(f"Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Acc: {train_acc:.4f}")

这一步将正式开始执行模型训练，其中比较关键的部分我详细讲解一下。

前三行是对损失函数、优化器、初始化学习率、总迭代次数的设定。这些参数很重要，不过相对比较容易理解，这里不再赘述。

我们主要看for循环里的内容：

 train_loss = 0.0
 train_preds = []
 train_true = []

初始化变量,用于记录当前epoch的训练损失、预测结果和真实标签。

optimizer.zero_grad()# 梯度清零

将优化器的梯度清零,以避免梯度累积。
在每个批次开始前,需要清除上一批次的梯度信息,以确保每个批次的梯度计算是独立的。

outputs = model(data) # 前向传播

将当前批次的数据data输入到模型中,进行前向传播,得到模型的预测输出outputs。

loss = criterion(outputs, labels) # 计算损失

使用损失函数criterion计算模型预测输出outputs和真实标签labels之间的损失。
损失函数衡量了模型预测结果与真实标签之间的差异,用于指导模型参数的更新。

loss.backward() # 反向传播

对损失函数进行反向传播,计算模型参数的梯度。
反向传播算法通过链式法则,将损失函数对模型参数的梯度传递回网络的每一层,以便后续的参数更新。

optimizer.step() # 更新模型参数

根据计算得到的梯度,使用优化器optimizer更新模型的参数。
优化器根据梯度信息和学习率,调整模型参数的值,以最小化损失函数。

train_loss += loss.item() * data.size(0) # 累计训练损失

累计当前批次的训练损失,用于后续计算平均训练损失。
loss.item()返回损失函数的标量值,data.size(0)表示当前批次的样本数。

_, preds = torch.max(outputs, 1) # 获取预测结果

获取当前批次的预测结果,通过在维度1上取最大值得到预测的类别索引。
_表示忽略第一个返回值(最大值),preds表示预测的类别索引。

train_preds.extend(preds.numpy())  # 收集训练集的预测结果
train_true.extend(labels.numpy())  # 收集训练集的真实标签

将当前批次的预测结果preds和真实标签labels分别添加到train_preds和train_true列表中。
这些列表用于收集整个epoch的预测结果和真实标签,以便后续计算训练准确率。

train_loss /= len(train_loader.dataset)  # 计算平均训练损失
train_acc = accuracy_score(train_true, train_preds)  # 计算训练准确率

计算当前epoch的平均训练损失,将累计的训练损失除以训练数据集的样本总数。
使用accuracy_score函数计算当前epoch的训练准确率。
训练准确率表示模型在训练数据集上的预测正确率,用于评估模型在训练过程中的表现。

5. 训练模型

# 5. 在测试集上评估模型
test_preds = []
test_true = []
with torch.no_grad():  # 禁用梯度计算
    for data, labels in test_loader:
        outputs = model(data)  # 前向传播
        _, preds = torch.max(outputs, 1)  # 获取预测结果
        test_preds.extend(preds.numpy())  # 收集测试集的预测结果
        test_true.extend(labels.numpy())  # 收集测试集的真实标签

accuracy = accuracy_score(test_true, test_preds)  # 计算测试准确率
recall = recall_score(test_true, test_preds, average='weighted')  # 计算加权平均召回率
precision = precision_score(test_true, test_preds, average='weighted')  # 计算加权平均精确率

print(f"测试集准确率: {accuracy:.4f}, 召回率: {recall:.4f}, 精确率: {precision:.4f}")

这部分是使用训练好的模型model实现对测试集数据的分类验证。

如果第4部分你看懂了，这部分一定也没啥问题。所以这部分不展开讲了。

运行上述全部程序，将会得到以下结果：

测试集准确率98.52%，这个数值不算特别高，因为上述仅仅作为算法流程的示例，没有专门对CNN网络参数进行调试，大家感兴趣的话，可以通过调整CNN网络结构、初始化学习率、迭代次数等参数，实现更高的分类准确率。

三、“一行代码”实现CNN分类任务（pytorch框架）

上边章节演示了使用pytorch实现CNN分类的基础代码演示，不过说实话，对于新手来说使用起来还是有一定难度的。而且我们在实际研究中可能会面临更为复杂的困境：

导入自己的数据后，网络结构一改就频频报错
代码被改得乱七八糟，看的头大
不知道该画哪些图、怎么画图
一维数据分类不知道怎么搞
……

按照本专栏的惯例，笔者参照MATLAB封装函数的样式，封装了pytorch快速实现CNN分类的函数，在设定好相关参数后，只需要一行代码，就可以实现数据集训练集/验证集/测试集快速划分、绘制混淆矩阵、计算分类准确度、自动选取GPU/CPU训练、导出训练过程数据等等常用功能，而且这个封装函数可以适用于一维/二维/三维数据，这个函数的介绍如下：

def FunClassCNNs(dataX, dataY, divideR, cLayer, poolingLayer, fcLayer, options, setting):
    """
    使用CNN进行模式识别(分类)的快速实现函数,程序会优先使用GPU进行加速,如果没有GPU则使用CPU
    
    参数:
    - dataX: 输入数据,形状为(num_samples, num_channels, height, width)的numpy数组
    - dataY: 标签值,形状为(num_samples,)的numpy数组,可以是向量型或索引型
    - divideR: 数据集划分比例,形如[train_ratio, val_ratio, test_ratio]的列表
    - cLayer: 卷积层结构,形状为(num_conv_layers, 5)的numpy数组,每一行代表一个卷积层的参数[filter_height, filter_width, num_filters, stride, padding]
    - poolingLayer: 池化层结构,形状为(num_conv_layers, 5)的列表,每一行代表一个池化层的参数['pool_type', pool_height, pool_width, stride, padding],其中pool_type可以是'maxPooling2dLayer'或'averagePooling2dLayer'或'none'
    - fcLayer: 全连接层结构,形状为(num_fc_layers,)的列表,每一个元素代表一个全连接层的输出维度,如果为空列表则只有一个输出维度等于类别数的全连接层
    - options: 网络训练相关的选项,字典类型,包含以下键值对:
      - 'solverName': 优化器类型,可以是'sgdm'或'rmsprop'或'adam',默认为'adam'
      - 'MaxEpochs': 最大迭代次数,默认为30
      - 'MiniBatchSize': 批量大小,默认为128
      - 'InitialLearnRate': 初始学习率,默认为0.005
      - 'ValidationFrequency': 验证频率,即每多少次迭代进行一次验证,默认为50
      - 'LearnRateSchedule': 学习率调度方式,可以是'piecewise'或'none',默认为'none'
      - 'LearnRateDropPeriod': 学习率下降周期,默认为10
      - 'LearnRateDropFactor': 学习率下降因子,默认为0.95
    - setting: 其他选项,字典类型,包含以下键值对:
      - figflag: 是否绘制图像,'on'为绘制,'off'为不绘制
      - deviceSel: 训练设备选择,可以是'cpu'或'gpu',默认为'gpu',当设置为'gpu'时,如果gpu硬件不可用,则会自动切换到cpu
      - seed: 随机种子,整数,设置为0时不启用,设置为其他整数时启用,不同的整数为不同的种子值,变换种子值会影响结果,相同种子的计算结果是一致的,缺省时为不设置随机种子
      - minmax: 是否进行归一化,布尔值,默认为True
      
    返回值:
    - accuracy: 测试集上的准确率
    - recall: 测试集上的召回率
    - precision: 测试集上的精确率
    - model: 训练好的PyTorch模型
    - info: 包含训练过程中的损失和准确率信息的字典
    """

看注释写的蛮多的似乎有点唬人，其实使用起来蛮简单。

下边我使用三个公开数据集，分别演示这个函数在一维、二维、三维数据中的应用效果，以及能够得出的一系列有用的图片和其他结果。

1.MNIST手写数据集

这就是上个章节中用到过的数据集。

MNIST手写数据集，每张图片是28*28的数据矩阵

现在我们实现分类任务，只需要执行下边这些代码即可（全套运行程序下载链接见文末）：

import numpy as np
from khCNN import FunClassCNNs

# 1.加载MNIST数据集
data = np.load('mnist.npz')  # 从文件中加载MNIST数据集
xData, yData = data['x_train'], data['y_train']  # 获取训练集的特征和标签
xData= xData.reshape(-1, 1, 28, 28)  # 将训练集特征重塑为(样本数, 通道数, 高度, 宽度)的形状

# 2. 调用方法进行分类
# 2.1 设置数据集划分比例
divideR = [0.8, 0.1, 0.1]  # 训练集:验证集:测试集 = 8:1:1
# 2.2 设置卷积层参数
cLayer = np.array([
    [3, 3, 16, 1, 1],  # 第一个卷积层: 卷积核大小为3x3, 16个卷积核, 步长为1, 填充为1
    [3, 3, 32, 1, 0]   # 第二个卷积层: 卷积核大小为3x3, 32个卷积核, 步长为1, 填充为0
])
# 2.3 设置池化层参数
poolingLayer = [
    ['maxPooling2dLayer', 2, 2, 2, 0],  # 第一个池化层: 最大池化, 池化核大小为2x2, 步长为2, 填充为0
    ['averagePooling2dLayer', 2, 2, 2, 0]  # 第二个池化层: 平均池化, 池化核大小为2x2, 步长为2, 填充为0
]
# 2.4 设置全连接层参数
fcLayer = [128, 64]  # 两个全连接层, 输出维度分别为128和64
# 2.5 设置训练选项
options = {
    'MaxEpochs': 30,  # 最大迭代次数为30
    'MiniBatchSize': 128,  # 批量大小为128
    'InitialLearnRate': 0.001,  # 初始学习率为0.001
    'ValidationFrequency': 3,  # 每3次迭代进行一次验证
    'LearnRateSchedule': 'piecewise',  # 学习率调度方式为分段常数衰减
    'LearnRateDropPeriod': 10,  # 学习率下降周期为10
    'LearnRateDropFactor': 0.95  # 学习率下降因子为0.95
}
# 2.6 设置随机种子和设备选择
setting = {
    'seed': 42,  # 随机种子为42
    'deviceSel': 'gpu',  # 优先使用GPU进行训练
    'figflag': 'on',  # 绘制图像
    'minmax': True  # 进行归一化
}

# 2.7 调用函数“一行代码”实现训练和测试
accuracy, recall, precision, model, info = FunClassCNNs(dataX=xData, dataY=yData, divideR=divideR, cLayer=cLayer, poolingLayer=poolingLayer,  fcLayer=fcLayer, options=options, setting=setting )

上述代码在保留了比较丰富且必要的设置的前提下，基本已经精简得无法再精简了。

运行完上述代码后，可以得到以下结果：

（1）混淆矩阵图片。

混淆矩阵（Confusion Matrix）是一种常用的评估分类模型性能的工具。就像下图，结果是一个正方形矩阵。其中每一行对应一个实际类别，每一列对应一个预测类别。对角线部分代表预测结果与实际类别相同（即预测正确）的数量，其余部分则代表预测错误的数量。

比如第3行第4列方框中的数字3，代表对于本次分类，有3个手写数字“3”被错误分类成了“2”。

解读混淆矩阵的关键是观察对角线元素和非对角线元素。在对角线上的元素表示正确分类的样本数量，而非对角线上的元素表示被误分类的样本数量。

需要注意的是，这个图针对的是测试集数据。

混淆矩阵可以全面地描述分类网络的特性，属于写论文必备图片。

混淆矩阵

下边这张图可以反应预测标签被错误分类的整体态势，图中蓝色点是真实标签，红色标签是预测标签。完美情况是预测标签与真实标签完全重合，如果有被错误分类的情况，就会像下图这样出现很多散点。这张图现在在论文中也比较常见。

（2）训练过程图。

下边两张图分别是loss值和分类准确度的收敛过程。其中蓝色线条是训练集结果，橙色线条是验证集结果。

此图也是论文必画图之一。

（3）网络结构图、表。

网络结构图中有每层网络的类型、输入和输出数据尺寸、网络结构等信息，方便大家论文中使用。

网络结构表中有网络中各个层的类型以及尺寸等信息，写论文时也用得到。

（4）训练过程表。

在模型的训练过程中，将在终端打印出训练集和测试集的实时Loss值和准确率值，就像下边这样：

上边这个MNIST数据集测试集正确率是98.7%，这个是随意调了调网络和参数的结果，如果花时间进一步优化网络，可以得到更好的结果。

2.猫狗大战数据集

猫狗大战数据集中包含了不同尺寸的猫、狗彩色图像。

类别只有猫和狗两类。

下图是其中随机抽取的一些示意图片：

这个数据集比较大，完整的有将近1G的图片，本案例中为了轻量化程序文件，从其中选取了2000张图片（猫、狗各1000）。

这个案例主要是为了向大家展示，如果数据文件是图片（而不是数据文件），要怎样加载图片并导入程序；并且演示图片大小不同的时候应该怎么处理。

这里我们同样调用封装好的函数。

此时我们只需要运行以下这段代码（全套运行程序下载链接见文末）：

import os
import numpy as np
import torch
from PIL import Image
from torchvision import transforms
from sklearn.model_selection import train_test_split
from khCNN import FunClassCNNs

## 1. 加载图片数据
# 1.1 设置数据集路径
data_dir = 'catdogFig'

# 1.2 定义图像预处理操作
transform = transforms.Compose([
    transforms.Resize((224, 224)),  # 调整图片大小为224x224
    transforms.ToTensor(),  # 将图片转换为张量
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 归一化
])

# 1.3 加载图片数据
def load_data(data_dir):
    images = []
    labels = []
    for label in ['cat', 'dog']:
        label_dir = os.path.join(data_dir, label)
        for filename in os.listdir(label_dir):
            if filename.endswith('.jpg') or filename.endswith('.png'):  # 支持.jpg和.png格式的图片
                image_path = os.path.join(label_dir, filename)
                image = Image.open(image_path).convert('RGB')  # 打开图片并转换为RGB模式
                image = transform(image)  # 对图片进行预处理
                images.append(image)
                labels.append(0 if label == 'cat' else 1)  # 猫的标签为0,狗的标签为1
    return torch.stack(images), torch.tensor(labels)  # 将图片和标签转换为张量

# 加载数据集
dataX, dataY = load_data(data_dir)

# 将dataX转换为NumPy数组
dataX = dataX.numpy()

# 2. 调用方法进行分类
# 2.1 划分数据集
divideR = [0.7, 0.15, 0.15]  # 训练集、验证集、测试集的比例

# 2.2 定义CNN模型结构
cLayer = np.array([[8, 8, 16, 1, 1], [6, 6, 32, 1, 1], [4, 4, 64, 1, 1]])  # 卷积层结构
poolingLayer = [['maxPooling2dLayer', 2, 2, 2, 0], ['maxPooling2dLayer', 2, 2, 2, 0], ['maxPooling2dLayer', 2, 2, 2, 0]]  # 池化层结构
fcLayer = [128, 64]  # 全连接层结构

# 2.3 设置训练选项
options = {
    'MaxEpochs': 20,  # 最大训练轮数
    'MiniBatchSize': 64,  # 小批量数据大小
    'InitialLearnRate': 0.001,  # 初始学习率
    'ValidationFrequency': 5  # 验证频率
}

# 2.4 设置其他选项
setting = {
    'figflag': 'on',  # 是否显示图形
    'deviceSel': 'gpu'  # 设备选择(gpu或cpu)
}

# 进行训练和测试
accuracy, recall, precision, model, info = FunClassCNNs(dataX, dataY, divideR, cLayer, poolingLayer, fcLayer, options, setting)

运行程序，可以得到如下结果，这个和MNIST数据集类似，就不展开说了。

大致调了调，得到的正确率大概在68%，这个结果比较差强人意，主要是因为我们的数据集比较小，难以很好地泛化模型，如果用完整数据集结果就不一样了。

3.iris鸢尾花数据集

这里介绍一下鸢尾花数据集，鸢尾花在机器学习里是常客之一。数据集由具有150个实例组成，其特征数据包括四个：萼片长、萼片宽、花瓣长、花瓣宽。数据集中一共包括三种鸢尾花，分别叫做Setosa、Versicolor、Virginica，就像下图：

鸢尾花

也就是说这组数据每组的维度是1*4，也就是一维数据，总共有150组数据。

在这个例子里我们还演示了当数据文件为表格（CSV）时的处理方法。

此时我们只需要运行以下这段代码（全套运行程序下载链接见文末）：

from sklearn.datasets import load_iris
import numpy as np
import pandas as pd
from khCNN import FunClassCNNs

# 加载鸢尾花数据集
# 从CSV文件中读取数据
data = pd.read_csv('iris.csv')
X = data.iloc[:, :-1].values  # 提取特征数据
y = data.iloc[:, -1].values   # 提取标签数据

# 将数据转换为(num_samples, num_channels, height, width)的形状
X = X.reshape(X.shape[0], 1, 1, X.shape[1])

# 设置网络结构参数
cLayer = np.array([[1, 3, 8, 1, 0]])  # 卷积层参数

poolingLayer = [['maxPooling2dLayer', 1, 2, 2, 0]]  # 池化层参数

fcLayer = [32]  # 全连接层参数

options = {
    'solverName': 'adam',  # 优化器名称
    'MaxEpochs': 50,  # 最大训练轮数
    'MiniBatchSize': 16,  # 小批量数据大小
    'InitialLearnRate': 0.005,  # 初始学习率
    'ValidationFrequency': 10,  # 验证频率
    'LearnRateSchedule': 'piecewise',  # 学习率调度方式
    'LearnRateDropPeriod': 20,  # 学习率下降周期
    'LearnRateDropFactor': 0.5  # 学习率下降因子
}

setting = {
    'figflag': 'on',  # 是否显示图形
    'deviceSel': 'gpu',  # 设备选择(gpu或cpu)
    'seed': 42,  # 随机种子
    'minmax': True  # 数据已经标准化,不需要再进行归一化
}

# 调用函数进行训练和评估
accuracy, recall, precision, model, info = FunClassCNNs(
    dataX=X,  # 输入特征数据
    dataY=y,  # 输入标签数据
    divideR=[0.7, 0.15, 0.15],  # 数据划分比例(训练集、验证集、测试集)
    cLayer=cLayer,  # 卷积层参数
    poolingLayer=poolingLayer,  # 池化层参数
    fcLayer=fcLayer,  # 全连接层参数
    options=options,  # 训练选项
    setting=setting  # 设置参数
)

需要注意此时，设置滤波器的高与宽，方向要与输入数据dataX保持一致。也就是说dataX的维度是150*1*1*4，滤波器就得设置成1*3，而不能是3*1，池化层也同理。

这个数据集运行得到的准确率是99%。

三、总结

总的来说，自己编程的方法可以快速实现简单的功能，但是用于工程和研究还是欠缺一些必要的图表。

使用封装函数对复杂的CNN训练和评估流程进行了高度封装，大家只需要提供数据和指定参数，就可以轻松进行模型的训练和评估，大大减轻了同学们负担；另外函数接收多个参数作为输入，包括网络结构和训练选项等，使得用户可以根据自己的需求灵活地定制和配置模型，适应各种不同的应用场景；此函数不仅实现了CNN模型的训练，还对模型的性能进行了全面评估，包括准确度等指标，并返回了训练过程中的详细信息，助力用户快速理解模型的性能，并进行后续的优化调整。

需要上述三个案例的代码和封装函数的代码，同学们可以在公众号 khscience（看海的城堡）中回复“CNN分类”获取。

扩展阅读：

3.1 Mr.看海：神经网络15分钟入门！足够通俗易懂了吧

3.2 Mr.看海：神经网络15分钟入门！——反向传播到底是怎么传播的？

3.3 Mr.看海：神经网络15分钟入门！使用python从零开始写一个两层神经网络

3.4 Mr.看海：用深度学习做了下中国股市预测，结果是...

3.5 Mr.看海：使用MATLAB快速搭建神经网络实现分类任务（模式识别）

3.6 Mr.看海：【深度学习-第1篇】深度学习是什么、能干什么、要怎样学？

3.7 Mr.看海：【深度学习-第2篇】CNN卷积神经网络30分钟入门！足够通俗易懂了吧（图解）

3.8 Mr.看海：【深度学习-第3篇】使用MATLAB快速实现CNN分类（模式识别）任务，含一维、二维、三维数据演示案例

3.9 Mr.看海：【深度学习-第4篇】使用MATLAB快速实现CNN多变量回归预测

3.10 Mr.看海：【深度学习-番外1】Win10系统搭建VSCode+Anaconda+Pytorch+CUDA深度学习环境和框架全过程