CIFAR-10数据集的分类

安装conda并使用pytorch库进行操作：引用核心库torch、图像数据集常用的torchvision、torchvision中用于数据预处理的transforms、构建神经网络模块的torch.nn、优化算法的torch.optim、在训练完成后展示结果的绘图库pyplot、数据转换常用的numpy、加载数据集的dataloader。3.对于每个批次的测试数据，模型会进行预测，并与真实标签进

努力去见宝石盒！！

997人浏览 · 2024-11-11 20:36:16

努力去见宝石盒！！ · 2024-11-11 20:36:16 发布

一、相关库的安装与使用

安装anacoda教程：anacoda安装教程

安装之后使用上篇文章的pip install -i +清华镜像源地址+所要安装的库的名称进行库的安装

二、数据的预处理

1.使用compose将多个数据转换操作按顺序组合在一起，首先将图像数据转化为tensor形式（通道数、高度、宽度），然后对每个通道进行归一化处理，此处均值和标准差我都使用了0.5

数据集地址

2.接着从官网上下载数据集，并存储在电脑当中。加载图像分类的训练集和测试集（使用torchvision中的CIFAR-10数据集），并使用上行定义的transform来进行预处理，True是训练集，False是测试集

3.使用dataloader来加载训练集和测试集，并对数据进行批处理和排序，这里的样本数可以是任何正整数（通常会选择64），我选择了64和32分别进行测试

对于样本数为64：

可以对比出，样本数为32的准确度在测试集上优于样本数为64的，在训练集上表现差不多，缺点在于32的运行时间长于样本数64

shuffle=True: 每个epoch开始时，数据会被随机打乱，这样可以增加训练的随机性，避免模型对数据的顺序产生依赖

注意：为了确保评估的一致性和可重复性，测试集通常保持原顺序不打乱，训练集则需要打乱

防止模型过度依赖数据的顺序，从而提高模型的泛化能力

4.分类：

就这样分为十个类别，每个类别对应相应的标签

三、网络结构选择

据了解，适合图像分类的网络结构，最基础的是CNN，其次还有transformers、GANs等

我选择了CNN进行研究

1.定义CNN模型，构造一个初始化函数，使用super调用初始化方法，定义三个卷积层，定义池化层、定义全连接层

nn.module类：是pytorch中所有神经网络模块的基础类，所有自定义的模型都要继承这个类

-init-是类的初始化函数，首先要初始化模型中的各个层

必须步骤：super（自定义模型.self）-init-：确保自定义模型可以正确的初始化nn.module的内部机制

卷积层（conv）的定义：

第1层通常会选择32或者64

池化层：第1个数字代表池化窗口，第2个数字代表步长

输出数一层比一层多，经验为32-64-128-256

三层池化，每一次都变为一半，最后变为4*4

512又又又是经验数字

2.定义一个向前传播的函数forward：卷积-激活-池化操作

使用relu激活函数

展平操作：

3.将cnn赋值给model，通过model来操作这个网络

4.设备配置（是CPU还是GPU）、损失函数的定义、优化器的选择（学习率的选择）

关于学习率的选择，我也同样测试了学习率为0.01、0.001、0.0001，其中0.001表现最好

四、定义训练模型函数

1.定义一个训练循环模型，输入上述定义的网络结构、加载的trainloader、损失函数bz、优化器、还有训练的轮数epoch，并且每一个epoch结束之后都会保存模型

2.初始化epoch的总损失值、正确分类的样本数、总共分类的样本数

3.打印训练过程中的损失和准确率，这样可以了解训练的效果如何

4.训练模型

5.继续训练

五、评估测试

1.设置模型为评估模式

2.遍历整个测试集，使用模型进行预测，统计正确预测的样本数量，并计算准确率

3.对于每个批次的测试数据，模型会进行预测，并与真实标签进行比较，统计正确预测的样本数量，最终输出整体测试集上的准确率

六、显示图像的真实类别与模型的预测类别

1.从testloader中获取一批次图像

2.显示第一张图像

3.输出真实类别

4.使用模型进行预测

5.输出预测结果

import torch
import torchvision
import torchvision.transforms as tsf
import torch.nn as nn
import torch.optim as op
import matplotlib.pyplot as plt
import numpy as np
from torch.utils.data import DataLoader

transform=tsf.Compose([tsf.ToTensor(),tsf.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])

trainset=torchvision.datasets.CIFAR10(root=r"D:\picture fenlei\cifar-10-batches-py",train=True,download=True,transform=transform)
testset=torchvision.datasets.CIFAR10(root=r"D:\picture fenlei\cifar-10-batches-py",train=False,download=True,transform=transform)

trainloader=DataLoader(trainset,batch_size=32,shuffle=True)
testloader=DataLoader(testset,batch_size=32,shuffle=False)

classes=['airplane','automobile','bird','cat','deer','dog','frog','horse','ship','truck']

class CNN(nn.Module):
    def __init__(self):
        super(CNN,self).__init__()

        self.conv1=nn.Conv2d(3,32,3,padding=1)
        self.pool=nn.MaxPool2d(2,2)
        self.conv2=nn.Conv2d(32,64,3,padding=1)
        self.conv3=nn.Conv2d(64,128,3,padding=1)
        self.fc1=nn.Linear(128*4*4, 512)
        self.fc2=nn.Linear(512, 10)

    def forward(self, x):
        x=self.pool(torch.relu(self.conv1(x)))
        x=self.pool(torch.relu(self.conv2(x)))
        x=self.pool(torch.relu(self.conv3(x)))
        x=x.view(x.size(0),-1)
        x=torch.relu(self.fc1(x))
        x=self.fc2(x)
        return x

model=CNN()

device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

bz=nn.CrossEntropyLoss()
optimizer=op.Adam(model.parameters(),lr=0.001)

def train_model(model,trainloader,bz,optimizer,epochs=10):
    best=0.0
    for epoch in range(epochs):
        model.train()
        running_loss=0.0
        correct=0
        total=0

        for inputs,labels in trainloader:
            inputs,labels=inputs.to(device),labels.to(device)

            optimizer.zero_grad()
            outputs=model(inputs)
            loss=bz(outputs, labels)

            loss.backward()
            optimizer.step()

            running_loss+=loss.item()
            _,predicted=torch.max(outputs, 1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
            accuracy=100*correct/total

        print(f"Epoch_{epoch + 1},Loss: {running_loss/len(trainloader):.4f},Accuracy: {accuracy:.2f}%")
        torch.save(model.state_dict(), f'model_epoch_{epoch + 1}.pth')
        print(f'Epoch_{epoch + 1}结果保存')
        if accuracy > best:
            best = accuracy
            name = f'{accuracy:.2f}%.pth'
            torch.save(model.state_dict(), name)
            print(f"当前Epoch_{epoch + 1}是最好的模型，best准确率保存为{accuracy:.2f}%")

train_model(model,trainloader,bz,optimizer,epochs=10)

model = CNN()
model.load_state_dict(torch.load('model_epoch_5.pth', map_location=device))
model.to(device)
train_model(model, trainloader, bz, optimizer, epochs=10)

def evaluate(model,testloader):
    model.eval()
    correct=0
    total=0
    with torch.no_grad():
        for inputs,labels in testloader:
            inputs,labels=inputs.to(device), labels.to(device)
            outputs=model(inputs)
            _,predicted=torch.max(outputs,1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()

    print(f'测试准确度为: {100*correct/total:.2f}%')


evaluate(model,testloader)

def show(img):
    img=img/2+0.5
    np_img=img.numpy()
    plt.imshow(np.transpose(np_img,(1, 2, 0)))
    plt.show()

for images,labels in testloader:
    show(images[0])
    print(f'真实结果: {classes[labels[0]]}')
    outputs=model(images.to(device))
    _,predicted=torch.max(outputs, 1)
    print(f'预测结果: {classes[predicted[0]]}')