自定义的卷积神经网络模型CNN,对图片进行分类并使用图片进行测试模型-适合入门,从模型到训练再到测试,完全开源

作品简介

 自定义的卷积神经网络模型CNN,对图片进行分类并使用图片进行测试模型-适合入门,从模型到训练再到测试:


1.导入必要的库和模块:

torch:PyTorch深度学习框架。

torchvision:PyTorch的计算机视觉库,用于处理图像数据。

transforms:包含数据预处理的模块。

nn:PyTorch的神经网络模块。

F:PyTorch的函数模块,包括各种激活函数等。

optim:优化算法模块。

 

2.数据预处理:

transforms.Compose:将一系列数据预处理步骤组合在一起。

transforms.ToTensor():将图像数据转换为张量。

transforms.Normalize:对图像数据进行归一化处理,以均值0.5和标准差0.5。

定义批处理大小:

batch_size:每个训练批次包含的图像数量。

加载训练集:

trainset:使用CIFAR-10数据集,设置训练标志为True。

torch.utils.data.DataLoader:创建用于加载训练数据的数据加载器,指定批处理大小和其他参数。

加载测试集:

testset:使用CIFAR-10数据集,设置训练标志为False。

torch.utils.data.DataLoader:创建用于加载测试数据的数据加载器,指定批处理大小和其他参数。

定义CNN模型:

My_CNN:自定义的卷积神经网络模型,包括卷积层、池化层和全连接层。

创建CNN模型、损失函数和优化器:

model:创建My_CNN模型的实例。

nn.CrossEntropyLoss():定义用于多分类问题的交叉熵损失函数。

optim.SGD:使用随机梯度下降优化器,指定学习率和动量。

训练模型:

epochs:指定训练轮数。

循环中的嵌套循环:迭代训练数据批次,进行前向传播、反向传播和参数优化。

保存模型:

model_path:指定模型保存的路径。

torch.save:保存训练后的模型。

在测试集上评估模型性能:

计算模型在测试集上的准确率。

计算每个类别的准确率。

 

 

具体代码来说:

transform = transforms.Compose(

    [transforms.ToTensor(),

     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

解释:

transforms.Compose:这是一个用于组合多个数据预处理步骤的函数。它允许你按顺序应用多个转换,以便将原始数据转换为最终的形式。

transforms.ToTensor():这是一个数据预处理步骤,将图像数据转换为张量(tensor)的格式。在深度学习中,张量是常用的数据表示方式,因此需要将图像数据从常见的图像格式(如JPEG或PNG)转换为张量。

transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)):这是另一个数据预处理步骤,用于对图像进行归一化处理。归一化的目的是将图像的像素值缩放到一个特定的范围,以便神经网络更容易学习。在这里,均值和标准差都被设置为0.5,这将使图像像素值在-1到1之间。

 

batch_size = 4

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,

                                        download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,

                                          shuffle=True, num_workers=0)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,

                                       download=True, transform=transform)

testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,

                                         shuffle=False, num_workers=0)

解释:

batch_size = 4:定义了每个训练和测试批次中包含的图像数量。在深度学习中,通常将数据分成小批次进行训练,以便更有效地使用计算资源。

 

trainset 和 testset 的定义:这两行代码加载了CIFAR-10数据集的训练集和测试集,并进行了如下操作:

torchvision.datasets.CIFAR10:使用CIFAR-10数据集,它包括一组包含10个不同类别的图像数据,适用于图像分类任务。

root='./data':指定数据集的存储目录,可以根据需要更改。

train=True 和 train=False:这两个参数分别用于加载训练集和测试集。

download=True:如果数据集尚未下载,会自动下载。

transform=transform:指定了前面定义的数据预处理管道,将在加载数据时应用。

trainloader 和 testloader 的定义:这两行代码创建了数据加载器,将数据集划分为批次以进行训练和测试。

torch.utils.data.DataLoader:这是PyTorch提供的用于加载数据的工具,可以自动处理数据的分批和洗牌等任务。

batch_size=batch_size:指定了每个批次的大小,即每次加载多少图像数据。

shuffle=True 和 shuffle=False:shuffle参数指定是否在每个epoch(训练轮次)之前对数据进行洗牌,以增加数据的随机性。通常在训练时进行洗牌,而在测试时不进行洗牌。

num_workers=0:这个参数指定用于数据加载的线程数。在此代码中,设置为0表示不使用多线程加载数据。如果有多个CPU核心可用,可以将其设置为大于0的值以加速数据加载。

 

class My_CNN(nn.Module):

    def __init__(self):

        super().__init__()

省略部分代码

    def forward(self, x):

  省略部分代码

        return x

model = My_CNN()

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

解释:

这部分代码定义了一个卷积神经网络(CNN)模型,并创建了用于训练该模型的损失函数和优化器。让我们逐步解释每一部分:

class My_CNN(nn.Module)::这是一个自定义的CNN模型类的定义。这个类继承自nn.Module,这是PyTorch中构建神经网络模型的基本方式。

def __init__(self)::这是构造函数,用于初始化CNN模型的各个层。

super().__init__():调用父类nn.Module的构造函数以确保正确初始化模型。

self.conv1 和 self.conv2:这是两个卷积层的定义,分别具有不同数量的输入和输出通道以及卷积核的大小。

self.pool:这是最大池化层的定义,用于减小特征图的空间尺寸。

self.fc1、self.fc2 和 self.fc3:这是三个全连接层(也称为线性层),用于将卷积层的输出转换为最终的分类结果。

def forward(self, x)::这是前向传播函数,定义了模型的前向传播过程。

在前向传播中,输入x经过卷积层、激活函数(F.relu)、池化层以及全连接层,最终输出分类结果。

torch.flatten(x, 1):这一步将卷积层的输出扁平化,以便将其输入到全连接层。

返回值是模型的输出,表示对输入数据的分类预测。

model = My_CNN():创建了My_CNN类的一个实例,即CNN模型。

criterion = nn.CrossEntropyLoss():定义了损失函数,这里使用的是交叉熵损失函数。它用于衡量模型的预测与实际标签之间的差距,是一个用于监督学习任务的常见损失函数。

optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9):定义了优化器,这里使用的是随机梯度下降(SGD)。优化器负责更新模型的参数,以减小损失函数的值。学习率(lr)和动量(momentum)是优化算法的超参数,影响了参数更新的速度和方向。

 

epochs=5

for epoch in range(epochs):  # loop over the dataset multiple times

    running_loss = 0.0

    for i, data in enumerate(trainloader, 0):

        # get the inputs; data is a list of [inputs, labels]

        inputs, labels = data

        # zero the parameter gradients

        optimizer.zero_grad()

        # forward + backward + optimize

        outputs = model(inputs)

        loss = criterion(outputs, labels)

        loss.backward()

        optimizer.step()

        # print statistics

        running_loss += loss.item()

        if i % 2000 == 1999:    # print every 2000 mini-batches

            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')

            running_loss = 0.0

print('Finished Training')

name_path = './cnn_model_model.pth'

torch.save(model,name_path)

解释:

epochs=5:定义了训练的轮次(epochs),也就是模型将遍历整个训练数据集的次数。

for epoch in range(epochs)::这是一个循环,遍历每个训练轮次。

running_loss = 0.0:用于追踪每个训练轮次的累积损失。

for i, data in enumerate(trainloader, 0)::这个嵌套循环遍历训练数据集的小批次。

i 表示当前批次的索引。

data 包含了当前批次的输入数据和标签。

optimizer.zero_grad():在每个批次开始时,将优化器的梯度清零,以便准备计算新的梯度。

outputs = model(inputs):进行前向传播,将输入数据传递给模型,得到模型的输出。

loss = criterion(outputs, labels):计算损失,衡量模型的预测与实际标签之间的差距。使用了前面定义的交叉熵损失函数。

loss.backward():进行反向传播,计算模型参数相对于损失的梯度。

optimizer.step():根据计算得到的梯度,更新模型的参数,以减小损失函数的值。

running_loss += loss.item():累积当前批次的损失值,用于后续打印统计信息。

if i % 2000 == 1999::每经过2000个小批次,打印一次统计信息。这是为了跟踪训练进度,查看损失是否在逐渐减小。

print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}'):打印当前训练轮次和批次的损失值。

running_loss = 0.0:重置累积损失值,以便下一个统计周期。

print('Finished Training'):当所有轮次的训练完成后,打印 "Finished Training" 以指示训练结束。

name_path = './cnn_model_model.pth':指定模型的保存路径。

torch.save(model, name_path):将训练好的模型保存到指定路径。这样可以在之后的任务中加载和使用该模型,而不需要重新训练。

 

这段代码执行了模型的训练过程,循环遍历多个轮次,每轮次内遍历训练数据的小批次。在每个小批次中,进行前向传播、计算损失、反向传播以及参数更新。训练的目标是通过调整模型参数,减小损失函数的值,从而提高模型的性能。同时,每隔一定数量的小批次,打印训练统计信息以监视训练进度。最后,训练完成后,模型被保存到文件以备将来使用。


classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')

# prepare to count predictions for each class

correct_pred = {classname: 0 for classname in classes}

total_pred = {classname: 0 for classname in classes}

# again no gradients needed

with torch.no_grad():

    for data in testloader:

        images, labels = data

        outputs = model(images)

        _, predictions = torch.max(outputs, 1)

        # collect the correct predictions for each class

        for label, prediction in zip(labels, predictions):

            if label == prediction:

                correct_pred[classes[label]] += 1

            total_pred[classes[label]] += 1

# print accuracy for each class

for classname, correct_count in correct_pred.items():

    accuracy = 100 * float(correct_count) / total_pred[classname]

    print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')

解释:

classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck'):这是数据集中的类别标签,它们代表CIFAR-10数据集中的10个不同类别,分别是飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、船和卡车。

correct_pred 和 total_pred:这两个字典用于跟踪每个类别的正确预测数量和总预测数量,初始化为零。

with torch.no_grad()::这个语句块指示在此之后的计算不需要梯度信息。这是因为在测试阶段,我们不需要计算梯度,只是进行前向传播和计算准确度。

for data in testloader::遍历测试数据集的小批次。

images, labels = data:将小批次数据分成图像和对应的标签。

outputs = model(images):使用训练好的模型对图像进行预测,得到模型的输出。

_, predictions = torch.max(outputs, 1):通过 torch.max 函数找到每个样本预测的类别,即具有最高预测分数的类别。

for label, prediction in zip(labels, predictions)::通过 zip 函数,将实际标签和预测标签一一对应起来,以便比较它们。

if label == prediction::比较实际标签和预测标签,如果它们相等,表示模型做出了正确的预测。

 

correct_pred[classes[label]] += 1:对应类别的正确预测数量加一。

total_pred[classes[label]] += 1:对应类别的总预测数量加一。

for classname, correct_count in correct_pred.items()::遍历每个类别和其正确预测数量。

accuracy = 100 * float(correct_count) / total_pred[classname]:计算每个类别的准确度,即正确预测数量除以总预测数量,以百分比表示。

print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %'):打印每个类别的准确度,格式化输出。

总结:这段代码的目标是计算并打印出每个类别的分类准确度,以便评估模型在不同类别上的性能。这是在测试阶段对模型性能进行评估的一种方式。

 

 

 

测试模型的代码:

import torch

from PIL import Image

from torch import nn

import torch

import torchvision

import torch.nn.functional as F

device = torch.device('cuda')

image_path="plane.png"

image =Image.open(image_path)

print(image)

image=image.convert('RGB')

transform=torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),torchvision.transforms.ToTensor()])

image=transform(image)

print(image.shape)

class My_CNN(nn.Module):

    def __init__(self):

        super().__init__()

     省略部分代码        return x

#加载模型

model = torch.load("cnn_net_model.pth",map_location=torch.device('cuda'))#加载完成网络模型,映射

print(model)#维数不够

image = torch.reshape(image,(1,3,32,32))#这一个很重要,要满足四个通道

image=image.to(device)#做cuda变换,不然报错

model.eval()

with torch.no_grad():#节约内存性能

    output=model(image)

#识别类别,数字最大的就是我们的结果

print(output)

解释:

导入必要的库和模块:

torch:PyTorch库,用于构建和运行深度学习模型。

PIL:Python Imaging Library,用于处理图像。

nn:PyTorch的神经网络模块。

F:PyTorch的函数模块。

device:将模型加载到GPU设备。

image_path:待分类的图像文件路径。

Image.open(image_path):使用PIL库打开图像文件。

图像的预处理:

image.convert('RGB'):将图像转换为RGB模式,以确保图像通道数为3。

transform:定义了一系列的图像预处理操作,包括将图像缩放到32x32像素大小并将其转换为PyTorch的Tensor数据类型。

image = transform(image):应用上述的预处理操作,将图像准备好以供模型处理。

定义神经网络模型:

 

My_CNN 类:这是一个自定义的卷积神经网络模型,包括两个卷积层,两个池化层,以及三个全连接层。这个模型与之前训练的CNN模型相似,用于图像分类任务。

加载预训练模型:

model = torch.load("cnn_net_model.pth", map_location=torch.device('cuda')):加载之前训练并保存的CNN模型。map_location 参数指定了模型的加载位置,这里指定为CUDA/GPU。

调整输入图像的维度和数据类型:

image = torch.reshape(image, (1, 3, 32, 32)):将输入的图像数据调整为适合模型的维度(1个样本,3个通道,32x32像素大小)。

image = image.to(device):将图像数据移动到GPU设备,以便进行GPU上的推理。

模型推理和分类:

 

model.eval():将模型切换到推理模式,这意味着模型不再更新梯度。

with torch.no_grad()::在这个块中,不会计算或保存梯度信息,以提高性能和节省内存。

output = model(image):对输入的图像进行前向传播,得到模型的输出。

print(output):打印模型的输出,这是一个包含了不同类别的分数的张量。

 

测试结果:





创作时间:2023-10-31 16:10:01