【深度学习-第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_predstrain_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深度学习环境和框架全过程

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/564838.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【linux】软件工具安装 + vim 和 gcc 使用(上)

目录 1. linux 安装软件途径 2. rzsz 命令 3. vim 和 gcc 使用 a. vim的基本概念 b. 命令模式下的指令 c. 底行模式下的指令 1. linux 安装软件途径 源代码安装rpm安装 -- linux安装包yum安装(最好,可以解决安装源,安装版本&#xff0…

实战 | 无视杀软使用远控工具进行横向移动Tips

实战 | 无视杀软使用远控工具进行横向移动Tips。 在有杀软拦截,CS无法上线的情况下,经常用到todesk和向日葵这两个远控工具进行横向移动。不过这两个工具现在好像不怎么好用了。不过无所谓,用其他的就是了,听说最近GotoHTTP很火&…

手拉手安装Kafka2.13发送和消费消息

Kafka是一种高吞吐量的分布式发布订阅消息系统,它可以处理消费者在网站中的所有动作流数据。 Kafka启动方式有Zookeeper和Kraft,两种方式只能选择其中一种启动,不能同时使用。 Kafka下载https://downloads.apache.org/kafka/3.7.0/kafka_2.…

四川易点慧电子商务抖音小店:安全正规,购物新选择

在当今互联网高速发展的时代,电子商务已经成为人们日常购物的重要组成部分。四川易点慧电子商务抖音小店作为新兴的电商平台,凭借其安全正规的经营理念和便捷高效的购物体验,正逐渐赢得消费者的信赖和喜爱。 一、平台背景实力雄厚 四川易点慧…

【Linux系统化学习】线程控制

目录 前言 POSIX线程库 线程控制 创建线程 线程终止 pthread_exit()函数 pthread_cancel()函数(会在下面线程等待部分详解) 线程等待 pthread_join()函数 获取线程退出码 分离线程 线程取消(pthread_cancel()函数) 线程ID及进程…

Scikit-Learn支持向量机分类

Scikit-Learn 支持向量机分类 1、支持向量机(SVM)1.1、SVM概述1.2、SVM原理1.3、SVM的损失函数1.4、支持向量机分类的优缺点 2、Scikit-Learn支持向量机分类2.1、Scikit-Learn支持向量机分类API2.2、支持向量机分类初体验(手写数字识别&#…

【工具-PyCharm】

工具-PyCharm ■ PyCharm-简介■ PyCharm-安装■ PyCharm-使用■ 修改主题■ 设置字体■ 代码模板■ 解释器配置■ 文件默认编码■ 快捷键■ 折叠■ 移动■ 注释■ 编辑■ 删除■ 查看■ 缩进■ 替换 ■ PyCharm-简介 官方下载地址 Professional:专业版&#xff0…

头脑风暴法的四个原则,设计师必看!

俗话说 “三个臭皮匠超越诸葛亮”,这在工作场景中也是如此。最常见的工作场景是会议。会议的目的很多,如工作报告、产品宣传等。头脑风暴是一种工作会议。其目的是集思广益,充分发挥团队的智慧。有效的头脑风暴不仅考验组织者的会议控制能力&…

【前端Vue】Vue3+Pinia小兔鲜电商项目第6篇:整体认识和路由配置,本资源由 收集整理【附代码文档】

Vue3ElementPlusPinia开发小兔鲜电商项目完整教程(附代码资料)主要内容讲述:认识Vue3,使用create-vue搭建Vue3项目1. Vue3组合式API体验,2. Vue3更多的优势,1. 认识create-vue,2. 使用create-vue创建项目,1. setup选项的写法和执行…

【机器学习-17】数据变换---小波变换特征提取及应用案列介绍

引言 在机器学习领域,数据变换是一种常见且重要的预处理步骤。通过对原始数据进行变换,我们可以提取出更有意义的特征,提高模型的性能。在众多数据变换方法中,小波变换是一种非常有效的方法,尤其适用于处理非平稳信号和…

实战解析:SpringBoot接口防抖机制与防重复提交技巧

目录 前言 啥是防抖 思路解析 哪一类接口需要防抖? 如何确定接口是重复的? 分布式部署下如何做接口防抖? 使用共享缓存 使用分布式锁 Spring Boot与Redis深度整合入口:实战指南 具体实现 请求锁 唯一key生成 重复提交判断 Red…

scipy.sparse.csr_matrix 中的 indptr indices data

# ------------------------------------------------------------------------------- # Description: 分析理解 scipy.sparse.csr_matrix 中的 indptr & indices & data # Reference: https://blog.csdn.net/bymaymay/article/details/81389722 # Author: Sophia…

Win 进入桌面黑屏,只有鼠标

大家好,我叫秋意零。 今天,遇到一个同事电脑进入桌面黑屏,只有鼠标。经过询问沟通,说是 Windows 突然进行了自动更新,更新之后桌面就黑了屏。经过查询是一个桌面进程没启动才会导致桌面黑屏。首先分两种情况&#xff0…

STL Array、ForwardList源码剖析

STL Array、ForwardList源码剖析 参考文章: https://blog.csdn.net/weixin_45389639/article/details/121618243 array 源代码 template<typename _Tp,std::size_t _Nm> struct array {typedef _Tp value_type;typedef _Tp* pointer;typedef value_type* iterator;// Su…

【看不懂命令行、.yaml?】Hydra 库极速入门

Hydra 是一个开源的 Python 框架&#xff0c;可以简化研究和其他复杂应用程序的开发。其核心功能是通过组合动态创建层次化的配置&#xff0c;并可以通过配置文件和命令行进行覆盖。Hydra 的名字来源于它能够运行多个类似的作业 - 就像一个多头的水怪一样。 主要特性: 从多个…

首发!Llama3纯本地部署攻略!中文方法!

引言 llama3在4月19日刚刚发布&#xff0c;官方的对比结果中在开源模型中堪称世界第一&#xff0c;整好周六日有时间&#xff0c;在魔搭社区上测试一下 一、启动环境 登录魔搭社区&#xff0c;到自己的机器资源&#xff0c;可以看到&#xff0c;可选的机器配置&#xff0c; …

YOLOv9改进策略 | Conv篇 | 利用 Haar 小波的下采样HWD替换传统下采样(改变YOLO传统的Conv下采样)

一、本文介绍 本文给大家带来的改进机制是Haar 小波的下采样HWD替换传统下采样&#xff08;改变YOLO传统的Conv下采样&#xff09;在小波变换中&#xff0c;Haar小波作为一种基本的小波函数&#xff0c;用于将图像数据分解为多个层次的近似和细节信息&#xff0c;这是一种多分…

什么是自动化测试?如何做自动化测试?

前面介绍了功能测试和接口测试&#xff0c;在介绍接口测试时提到了实现API自动化。那具体什么是自动化&#xff0c;为什么要做自动化&#xff0c;这里我们集中总结。 一. 什么是自动化&#xff1f; 顾名思义&#xff0c;自动化测试是相对人工测试而言的&#xff0c;它是指把人…

以太网帧格式解析

以太网的正式标准是IEEE802.3&#xff0c;它规定了以太网传输的帧结构。 以太网帧格式如下图所示&#xff1a; 以太网传输数据时&#xff0c;是按照上图的格式&#xff0c;自左到右依次传输的。需要注意的是前导码和SFD不属于以太网协议的内容&#xff0c;应该是属于物理层数据…

AI检索增强生成引擎-RAGFlow-深度理解知识文档,提取真知灼见

&#x1f4a1; RAGFlow 是什么&#xff1f; RAGFlow是一款基于深度文档理解构建的开源RAG&#xff08;Retrieval-Augmented Generation&#xff09;引擎。RAGFlow个人可以为各种规模的企业及提供一套专业的RAG工作流程&#xff0c;结合针对用户群体的大语言模型&#xff08;LL…