1. Johngo学长首页
  2. 技术点详细复盘专题
  3. Python

Pytorch—- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释—–学习笔记

• Python • 阅读 53

文章目录

*
– CIFAR10数据集准备、加载
– 搭建神经网络
– 损失函数和优化器
– 训练集
– 测试集
–
+ 关于argmax:
– 使用tensorboard可视化训练过程。
– 完整代码(训练集+测试集):
–
+ 程序结果:
– 验证集
–
+ 完整代码(验证集):

CIFAR10数据集准备、加载

解释一下里面的参数 root=数据放在哪。 train=是否为训练集 。 download=是否去网上下载。
里面的那个 transform 就是转换数据类型为Tensor类型。

准备一个测试集 一个训练集 自动从网上下载好。 大概160MB左右。图片大小是32*32的RGB格式。

train_data = torchvision.datasets.CIFAR10(root='../data', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='../data', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)

然后我们加载数据集，使用DataLoader。
设置 mini-batch为64.

然后再看一下训练集和测试集的数据集个数。


train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
print("训练集的长度:{}".format(len(train_data)))
print("测试集的长度:{}".format(len(test_data)))

搭建神经网络

使用网上给的图片搭建神经网络，下图。
使用Sequential组合的方法写每个网络。

Pytorch---- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释-----学习笔记 

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),
            nn.Linear(64, 10),
        )

    def forward(self, x):
        x = self.model(x)
        return x

损失函数和优化器

使用交叉熵做为损失函数，并且放到GPU上一会做训练。


loss = nn.CrossEntropyLoss().cuda()

optimizer  = torch.optim.SGD(model.parameters(),lr=0.01,)

训练集

这里的训练集开头有一个 model.train() 就是训练集循环开头写这个。也可以不写，不过规范要写上。

    model.train()
    for data in train_dataloader:

        imgs,targets = data
        imgs = imgs.cuda()
        targets = targets.cuda()

        output = model(imgs)

        loss_in = loss(output,targets)

        optimizer.zero_grad()

        loss_in.backward()
        optimizer.step()

测试集

也和上面一样。测试集前面加了一句 model.eval() 就是表明这是测试集，也可以不写，规范就写上。
这里我们使用了accurate记录当前正确的个数。然后除以总个数就是正确率了。

    accurate = 0
    model.eval()
    with torch.no_grad():
        for data in test_dataloader:

            imgs , targets = data
            imgs = imgs.cuda()
            targets = targets.cuda()
            output = model(imgs)
            loss_in = loss(output,targets)

            sum_loss += loss_in
            accurate += (output.argmax(1) == targets).sum()

其中的 sum() 就是 计算其中每一个概率是否和我们的targets，即真实值相等，sum() 将batch里面64个数据的判断结果相加。

关于argmax:

这里的output.argmax(1) 就是求output 在 axis=1方向上的最大值，返回其索引。
可以打印输出看一下output的值，由于这是在for循环里面的output所以output肯定就是我们设置的batch的大小 一共64个。每一个都应该是有10个数据组成的一维数组，这十个数代表十个分类的概率。
我们打印看一下:
找到最大值是1.2819，然后返回他的索引值5。

[-0.98575, 0.32747, 0.52469, 1.0626, 0.09937, 1.2819, 0.7109, -0.34366, -1.4924, -1.4262]

使用tensorboard可视化训练过程。

使用SummaryWriter:


writer = SummaryWriter('../logs_tensorboard')

在训练集里添加:

if num_time % 100 == 0:
       writer.add_scalar('看一下训练集损失值',loss_in.item(),num_time)

在测试集里添加:

writer.add_scalar('看一下测试集损失',sum_loss,i)
    writer.add_scalar('看一下当前测试集正确率',accurate/len(test_data)*100,i)
    i +=1

别忘了 writer.close() 关闭tensorboard。

最后使用 torch.save保存训练结果。

完整代码(训练集+测试集):

import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

train_data = torchvision.datasets.CIFAR10(root='../data', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='../data', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)

print("训练集的长度:{}".format(len(train_data)))
print("测试集的长度:{}".format(len(test_data)))

train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),
            nn.Linear(64, 10),
        )

    def forward(self, x):
        x = self.model(x)
        return x

model = Model().cuda()

writer = SummaryWriter('../logs_tensorboard')

loss = nn.CrossEntropyLoss().cuda()

optimizer  = torch.optim.SGD(model.parameters(),lr=0.01,)

i = 1

for epoch in range(30):
    num_time = 0
    print('开始第{}轮训练'.format(epoch+1))
    model.train()
    for data in train_dataloader:

        imgs,targets = data
        imgs = imgs.cuda()
        targets = targets.cuda()

        output = model(imgs)

        loss_in = loss(output,targets)

        optimizer.zero_grad()

        loss_in.backward()
        optimizer.step()
        num_time +=1

        if num_time % 100 == 0:
            writer.add_scalar('看一下训练集损失值',loss_in.item(),num_time)

    sum_loss = 0

    accurate = 0
    model.eval()
    with torch.no_grad():
        for data in test_dataloader:

            imgs , targets = data
            imgs = imgs.cuda()
            targets = targets.cuda()
            output = model(imgs)
            loss_in = loss(output,targets)

            sum_loss += loss_in
            print('这里是output',output)
            accurate += (output.argmax(1) == targets).sum()

    print('第{}轮测试集的正确率:{:.2f}%'.format(epoch+1,accurate/len(test_data)*100))

    writer.add_scalar('看一下测试集损失',sum_loss,i)
    writer.add_scalar('看一下当前测试集正确率',accurate/len(test_data)*100,i)
    i +=1

    torch.save(model,'../model_pytorch/model_{}.pth'.format(epoch+1))
    print("第{}轮模型训练数据已保存".format(epoch+1))

writer.close()

程序结果:

可以看到训练30轮之后的正确率逼近64%。

Pytorch---- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释-----学习笔记

也可以看到每次训练的模型数据都保存了起来，方便后面验证。

Pytorch---- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释-----学习笔记

; 验证集

Pytorch---- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释-----学习笔记
首先PIL方法导入图片。 image = Image.open('../data/plane.png')

这里其实可以看一下图片格式数据:

可以看到 是 RGBA的格式 并且图片尺寸是719 * 719的。
我们需要转换成 RGB格式 大小是32 * 32的。

转换成RGB格式:

image = image.convert('RGB')

然后使用Compose组合改变数据类型：

先变成32*32 再变成tensor类型数据。


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

image = transform(image)

放入我们要验证的数据:
这里使用了 torch.no_grad() 表示 后面的过程不需要梯度等优化数据。

with torch.no_grad():
   image = image.cuda()
   output = model(image)

print(output.argmax(1))

可以看到输出结果。表示验证结果是第0个类型。

Pytorch---- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释-----学习笔记
我们可以调试看一下CIFAR10的数据集数字对应的图片是什么图片。
Pytorch---- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释-----学习笔记
显然第0个就是代表飞机。验证成功。

后面我们又换了一个猫的图片，然后验证出来是5号dog，验证出错了。毕竟正确率只有64%。
我训练了30轮，用笔记本的GPU跑的，1650的GPU，那风扇咔咔转，最近梯子用不了了，就不上云了。

完整代码(验证集):

import torchvision
from torch import nn
import torch
from  PIL import Image

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),
            nn.Linear(64, 10),
        )

    def forward(self, x):
        x = self.model(x)
        return x

image = Image.open('../data/plane.png')

image = image.convert('RGB')

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

image = transform(image)
model = torch.load('../model_pytorch/model_30.pth')

image = torch.reshape(image,(1,3,32,32))
print(image.shape)

model.eval()
with torch.no_grad():
    image = image.cuda()
    output = model(image)

print(output.argmax(1))

这里有个小坑。使用save保存的网络模型，加载的时候必须吧网络模型类定义也写出来，不然会直接报错。

还有一个字典形式保存模型的方法那个就不用再写一遍定义，不过字典这个方法不是很熟。

Original: https://blog.csdn.net/qq_38737428/article/details/121931464
Author: 深度不学习！！
Title: Pytorch—- CIFAR10实战(训练集+测试集+验证集)完整版，逐行注释—–学习笔记

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/729439/

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
0

【自取】最近整理的，有需要可以领取学习：



Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言 刷题答案下载！

大家都在看

亲爱的 Coder【最近整理，可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球