自定义的卷积神经网络模型CNN，对图片进行分类并使用图片进行测试模型-适合入门，从模型到训练再到测试：开源项目
开源项目完整代码及基础教程：
https://mbd.pub/o/bread/ZZWclp5x

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)：打印模型的输出，这是一个包含了不同类别的分数的张量。

测试结果：