自定义的卷积神经网络模型CNN,对图片进行分类并使用图片进行测试模型-适合入门,从模型到训练再到测试:开源项目
开源项目完整代码及基础教程:
资料获取:
链接:https://pan.baidu.com/s/1HTuaxJaiQ28M3Zmb9wp7tA
提取码:6666
--来自百度网盘超级会员V5的分享
设计的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):打印模型的输出,这是一个包含了不同类别的分数的张量。