【Pytorch】13.搭建完整的CIFAR10模型

已于 2024-05-21 12:18:11 修改
阅读量1.1k 收藏 17
点赞数 38
分类专栏： Pytorch 文章标签： pytorch 人工智能 深度学习 网络
于 2024-05-18 14:53:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Elephant_King/article/details/139022565
版权

项目源码

已上传至githubCIFAR10Model，如果有帮助可以点个star

简介

在前文【Pytorch】10.CIFAR10模型搭建我们学习了用Module来模拟搭建CIFAR10的训练流程
本节将会加入损失函数，梯度下降，TensorBoard来完整搭建一个训练的模型

基本步骤

搭建神经网络最主要的流程是

  • 导入数据集（包括训练集和测试集）
  • 创建DataLoader
  • 创建自定义的神经网络
  • 选择损失函数与梯度下降算法
  • 进行n轮训练
  • n轮训练完成后通过测试集进行验证
  • 引入TensorBoard进行可视化
  • 保存每轮训练好的模型
    接下来将逐步拆解这每一个步骤

1.导入数据集

因为我们本文是要训练CIFAR10的模型，所以我们导入CIFAR10的数据集

# 1.创建训练数据集
train_dataset = torchvision.datasets.CIFAR10(root='../dataset', train=True, download=True,
                                             transform=torchvision.transforms.ToTensor())
test_dataset = torchvision.datasets.CIFAR10(root='../dataset', train=False, download=True,
                                            transform=torchvision.transforms.ToTensor())
# 记录数据集大小
train_size = len(train_dataset)
test_size = len(test_dataset)

分别导入训练集与测试集，并且分别记录训练集与测试集的大小
对参数的解释可以看【Pytorch】4.torchvision.datasets的使用这篇文章

2.创建DataLoader

DataLoader主要定义了如何在数据集中取数据的规则，具体讲解可以看【Pytorch】5.DataLoder的使用

# 2.创建dataloader
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=True)

3.创建自定义的神经网络

在这里插入图片描述
我们可以在网上搜到CIFAR10的网络模型，通过网络模型来搭建网络，具体可以看【Pytorch】10.CIFAR10模型搭建

import torch
from torch import nn


class CIFAR10Model(nn.Module):
    def __init__(self):
        super(CIFAR10Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 5, padding=2)
        self.maxpool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 32, 5, padding=2)
        self.maxpool2 = nn.MaxPool2d(2, 2)
        self.conv3 = nn.Conv2d(32, 64, 5, padding=2)
        self.maxpool3 = nn.MaxPool2d(2, 2)
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(1024, 64)
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x = self.flatten(x)
        x = self.fc1(x)
        x = self.fc2(x)
        return x


if __name__ == '__main__':
    model = CIFAR10Model()
    input_test = torch.ones((64, 3, 32, 32))
    output_test = model(input_test)
    print(output_test.shape)

这里我们新创建了一个model.py用于专门存储网络结构，这样在我们的训练文件中，可以通过

from model import *

# 3.创建神经网络
model = CIFAR10Model()

来导入我们自定义的神经网络

4.选择损失函数和梯度下降的方法

我们选择了交叉熵损失函数与SGD的梯度下降算法，具体讲解可以看【Pytorch】11.损失函数与梯度下降

# 4.设置损失函数与梯度下降算法
loss_fn = nn.CrossEntropyLoss()

learn_rate = 1e-2
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)

5.开始进行训练

首先将模型设置为训练模式

    model.train()

具体的训练流程分为以下几部

  • 从DataLoader中获取图片以及对应的编号
  • 将图片传入神经网络并获取输出
  • 将优化器清零
  • 计算损失函数
  • 进行梯度下降
  • 调用优化器进行更新
    for data in train_loader:
        # 训练基本流程
        inputs, labels = data
        outputs = model(inputs)
        optimizer.zero_grad()
        loss = loss_fn(outputs, labels)
        loss.backward()
        optimizer.step()

在基础训练的基础上，还安排了每进行100次训练就将训练数据print出来，并且写入tensorboard

 # 第i轮训练次数加一
        pre_train_step += 1
        pre_train_loss += loss.item()
        total_train_step += 1
        # 每100次输出一下
        if pre_train_step % 100 == 0:
            end_train_time = time.time()
            print(f'当前为第{i+1}轮训练,当前训练轮数为:{pre_train_step},已经过时间为:{end_train_time-start_time},当前训练次数的平均损失为:{pre_train_loss / pre_train_step}')
            # 添加可视化
            writer.add_scalar('train_loss', pre_train_loss / pre_train_step, total_train_step)
    print(f"----------------------------第{i + 1}轮训练完成----------------------------")

6.测试集验证

首先将模型设置为测试集模式

    model.eval()

首先通过with关键字来创建一个没有梯度的上下文
验证方法与训练集类似，但是没有计算梯度与更新优化器的步骤

 with torch.no_grad():
        for data in test_loader:
            # 测试集流程
            inputs, labels = data
            outputs = model(inputs)
            loss = loss_fn(outputs, labels)

然后通过torch.argmax用于计算所有标签的最大值

  • 参数为1时代表横向判断
  • 参数为0的代表纵向判断
    计算当前模型在训练集中的正确次数
            pre_accuracy += outputs.argmax(1).eq(labels).sum().item()

7.引入TensorBoard进行可视化

我们主要是通过Summary中的add_scalar来建立可视化函数来进行可视化的，具体可以看【Pytorch】2.TensorBoard的运用

# 创建TensorBoard
writer = SummaryWriter('./CIFAR10_logs')

# 在训练集中，输出每一百次训练的损失函数平均值
 		# 每100次输出一下
        if pre_train_step % 100 == 0:
            end_train_time = time.time()
            print(f'当前为第{i+1}轮训练,当前训练轮数为:{pre_train_step},已经过时间为:{end_train_time-start_time},当前训练次数的平均损失为:{pre_train_loss / pre_train_step}')
            # 添加可视化
            writer.add_scalar('train_loss', pre_train_loss / pre_train_step, total_train_step)


# 在测试集中，输出模型在测试集中的正确率
pre_accuracy += outputs.argmax(1).eq(labels).sum().item()
    writer.add_scalar('test_accuracy', pre_accuracy / test_size, i)

8.保存模型

具体可以看【Pytorch】12.网络模型的加载、修改与保存

    # 保存每轮的训练模型
    torch.save(CIFAR10Model, f'./CIFAR10TrainModel{i}.pth')

完整代码

import time
import torch
import torchvision.transforms
from torch.utils.tensorboard import SummaryWriter

from model import *

# 1.创建训练数据集
train_dataset = torchvision.datasets.CIFAR10(root='../dataset', train=True, download=True,
                                             transform=torchvision.transforms.ToTensor())
test_dataset = torchvision.datasets.CIFAR10(root='../dataset', train=False, download=True,
                                            transform=torchvision.transforms.ToTensor())
# 记录数据集大小
train_size = len(train_dataset)
test_size = len(test_dataset)

# 2.创建dataloader
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=True)

# 3.创建神经网络
model = CIFAR10Model()

# 4.设置损失函数与梯度下降算法
loss_fn = nn.CrossEntropyLoss()

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

# 训练轮数
total_train_step = 0
total_test_step = 0

# 训练轮数
epoch = 20

# 创建TensorBoard
writer = SummaryWriter('./CIFAR10_logs')
# 5.开始训练
for i in range(epoch):
    # 将模型设置为训练模式
    print(f"----------------------------开启第{i+1}轮训练----------------------------")
    model.train()
    # 第i轮训练的次数
    pre_train_step = 0
    # 第i轮训练的总损失
    pre_train_loss = 0
    # 第i轮训练的起始时间
    start_time = time.time()
    for data in train_loader:
        # 训练基本流程
        inputs, labels = data
        outputs = model(inputs)
        optimizer.zero_grad()
        loss = loss_fn(outputs, labels)
        loss.backward()
        optimizer.step()

        # 第i轮训练次数加一
        pre_train_step += 1
        pre_train_loss += loss.item()
        total_train_step += 1
        # 每100次输出一下
        if pre_train_step % 100 == 0:
            end_train_time = time.time()
            print(f'当前为第{i+1}轮训练,当前训练轮数为:{pre_train_step},已经过时间为:{end_train_time-start_time},当前训练次数的平均损失为:{pre_train_loss / pre_train_step}')
            # 添加可视化
            writer.add_scalar('train_loss', pre_train_loss / pre_train_step, total_train_step)
    print(f"----------------------------第{i + 1}轮训练完成----------------------------")
    # 设置为测试模式
    model.eval()
    # 第i轮训练集的总损失
    pre_test_loss = 0
    # 第i轮训练集的总正确次数
    pre_accuracy = 0
    print(f"----------------------------开启第{i + 1}轮测试----------------------------")
    # 配置没有梯度下降的环境
    with torch.no_grad():
        for data in test_loader:
            # 测试集流程
            inputs, labels = data
            outputs = model(inputs)
            loss = loss_fn(outputs, labels)

            # 定义参数
            pre_test_loss += loss.item()
            # 记录训练集的总正确率
            # argmax(1)代表横向判断,argmax(0)代表纵向判断
            pre_accuracy += outputs.argmax(1).eq(labels).sum().item()
    # 记录测试集运行完后的事件
    end_test_time = time.time()
    print(f'当前为第{i + 1}轮测试,已经过时间:{end_test_time - start_time},当前测试集的平均损失为:{pre_test_loss / test_size},当前在测试集的正确率为:{pre_accuracy / test_size}')
    writer.add_scalar('test_accuracy', pre_accuracy / test_size, i)
    print(f"----------------------------第{i + 1}轮测试完成----------------------------")
    # 保存每轮的训练模型
    torch.save(CIFAR10Model, f'./CIFAR10TrainModel{i}.pth')
    print(f"----------------------------第{i + 1}轮模型保存完成----------------------------")

writer.close()

训练效果
在这里插入图片描述
在这里插入图片描述

Elephant_King
关注
  • 38
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从零开始大模型开发与微调：CIFAR10数据集简介
禅与计算机程序设计艺术
06-05 794
从零开始大模型开发与微调：CIFAR-10数据集简介 1.背景介绍 1.1 人工智能与深度学习的发展 近年来,人工智能(AI)和深度学习(Deep Learning)技术取得了长足的进步,在计算机视觉、自然语言处
pytorch 搭建 LeNet 网络对 CIFAR-10 图片分类
10-24
在本文中，我们将深入探讨如何使用PyTorch框架搭建经典的LeNet神经网络模型，并将其应用于CIFAR-10图像分类任务。CIFAR-10数据集包含10个类别的60,000张32x32彩色图片，是用于评估计算机视觉模型的常用数据集。LeNet...
Cifar10完整模型搭建
AllenMa的博客
03-21 1757
1.模型结构 # 搭建神经网络 import torch from torch import nn class Module(nn.Module): def __init__(self): super().__init__() self.model = nn.Sequential( nn.Conv2d(3, 32, kernel_size=(5, 5), padding=2, stride=1, dilation=1), .
[Pytorch] CIFAR-10数据集的训练和模型优化
qq_51533157的博客
01-30 7422
训练模型是个时间较长的过程，如果电脑中有cuda的支持，将可以使用GPU进行训练，减少一定的时间。在神经网络中，有三个部分可以放到GPU中分别是在模型、损失函数以及数据上。首先定义训练设备device然后在程序中模型、损失函数、和数据上使用to函数加入到GPU中。# 模型 model_u = model_u . to(device) # 损失函数 loss_fn = loss_fn . to(device) # 数据 imgs , targets = data。
Pytorch深度学习记录：对CIFAR-10的深度学习模型搭建与测试
m0_54567165的博客
10-03 1981
CIFAR-10 和 CIFAR-100 是 8000 万个微小图像数据集的标记子集。数据集分为五个训练批次和一个测试批次，每个批次有 10000 张图像。本文从数据集下载，导入、搭建用于识别分类的模型、训练与测试，进行了简单介绍与代码实现。
深度学习模型在图像识别中的应用：CIFAR-10数据集实践与准确率分析
全栈若城,专注知识分享
06-27 1439
本文介绍了如何使用深度学习模型对图像进行识别，并以CIFAR-10数据集为例，详细解释了代码中的每个步骤和功能。通过训练和评估模型，我们得出了令人满意的准确率。最后，通过一张图片的识别示例，展示了模型的预测能力。这篇文章将帮助您了解深度学习模型在图像识别领域的应用，并提供了实践代码和准确率分析。
CIFAR-10训练模型（ResNet18）
张小猪的家
06-04 5665
1.搭建环境 环境在实验进行时已经搭建完毕，具体步骤就不过多赘述（参考：https://blog.csdn.net/weixin_39574469/article/details/117454061） 接下来只需导入所需的包即可 import numpy as np import tensorflow as tf import matplotlib.pyplot as plt from PIL import Image from tensorflow.keras import layers,activati
pytorch资源.zip
03-08
9. ** torchvision库**：包含了常用的数据集如CIFAR10、ImageNet，以及预训练模型如ResNet、AlexNet，还提供了图像变换工具，如随机裁剪、翻转等。 10. **自定义模块(Custom Modules)**：用户可以创建自己的模块来...
pytorch1.2.0.rar
07-30
6. **torchvision**：这个子库包含了一些常见的数据集（如CIFAR、ImageNet）以及预处理工具和模型，尤其在图像识别任务中非常有用。在给定的描述中，"gpu_torchvision0.4.0"可能指的是GPU优化的torchvision版本。 ...
pytorch and-cifar10
最新发布
03-12
通过以上步骤，我们可以利用PyTorch和CIFAR-10数据集，构建并训练出一个高效且准确的图像分类模型。实践中，不断优化模型架构和超参数，可以进一步提升模型的性能。这个过程不仅可以深入理解PyTorch的运作机制，还能...
VGG卷积神经网络图像分类训练Pytorch代码 使用Cifar100数据集
01-28
# VGG卷积神经网络图像分类训练...1. VGG网络模型的Pytorch实现代码，包含特征提取器features和分类器classifier两部分，简明易懂； 2. 使用Cifar100数据集进行图像分类训练，初次训练自动下载数据集，无需另外下载。
CIFAR-10数据集详析：使用卷积神经网络训练图像分类模型
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！交流学习、商务合作：https://bbs.csdn.net/topics/614347534
02-06 3932
CIFAR-10 数据集由 10 个类的彩色图像组成，每类6000张图像。有50000张训练图像和10000张测试图像。数据集分为5个训练批次和1个测试批次，每个批次有10000张图像。测试批次正好包含从每个类中随机选择的 1000 张图像。训练批次以随机顺序包含剩余的图像，但某些训练批次可能包含来自一个类的图像多于另一个类的图像。在它们之间，训练批次正好包含来自每个类的 5000 张图像。32×32 RGB图像 ，数据集本身是 BGR 通道。
完整的神经网络模型训练步骤——以CIFAR10数据集为例（pytorch版本）
xinxin的博客
09-03 1993
文章主要以CIFAR10数据集为例，讲述了完整的神经网络模型训练思路。使用pytorch搭建CIFAR10网络模型结构，将该模型应用于CIFAR10数据集（包含训练集和测试集）上，使用训练集训练搭建好的模型，使用测试集测试训练好的模型，最后使用三张随机图片用来验证模型的性能优劣。
Pytorch之CIFAR10分类卷积神经网络
风间琉璃的博客
08-27 4454
在计算机视觉领域，图像分类是一个重要的问题。CIFAR-10是一个常用的图像分类数据集，包含10个类别的60000张32x32彩色图像。在本篇博客中，我们将使用PyTorch构建一个卷积神经网络（Convolutional Neural Network，CNN）来对CIFAR-10数据集中的图像进行分类。
PyTorch 修炼篇(一) : CIFAR-10 分类模型
干啥啥不行，摸鱼第一名。
03-04 1869
import os import time import torch import torch.nn as nn # 神经网络工具箱 import torch.nn.functional as F # functional中的函数是一个确定的不变的运算公式，输入数据产生输出就ok。 import numpy as np from torch.autograd import Variable f...
【神经网络与深度学习】CIFAR10数据集介绍，并使用卷积神经网络训练图像分类模型——[附完整训练代码]
热门推荐
weixin_45954454的博客
03-08 6万+
【神经网络与深度学习】CIFAR10数据集介绍，并使用卷积神经网络训练图像分类模型——[附完整训练代码]一、CIFAR10数据集介绍1.1 CIFAR10数据集的内容1.2 CIFAR10数据集的结构组成1.3 CIFAR10数据集与MNIST数据集对比二、卷积神经网络2.1卷积神经网络函数介绍三、模型训练思路四、代码实现——直接用五、训练好的模型文件——直接用 一、CIFAR10数据集介绍 1.1 CIFAR10数据集的内容 CIFAR10数据集共有60000个样本，每个样本都
CIFAR10模型代码详解——基于土堆教学的pytorch实现
weixin_49856935的博客
03-06 457
上传一下CIFAR10模型的pytorch代码，方便以后或者需要的人看。本文详细介绍了CIFAR10模型结构及其pytorch实现代码，有问题欢迎评论或私信联系。
基于 PyTorch 的 cifar-10 图像分类
西岸贤
06-13 2万+
本文的主要内容是基于 PyTorch 的 cifar-10 图像分类，文中包括 cifar-10 数据集介绍、环境配置、实验代码、运行结果以及遇到的问题这几个部分，本实验采用了基本网络和VGG加深网络模型，其中VGG加深网络模型的识别准确率是要优于基本网络模型的。......
CIFAR-10 识别模型
czp_374的博客
07-20 2613
1.首先要对数据集进行数据增强 深度学习通常会要求拥有充足数量的训练样本。一般来说，数据的总量越多， 训练得到的模型的效果就会越好。 在图像任务中，通常会观察到这样一种现象：对输入的图像进行一些简单的平移、缩放、颜色变换，并不会影响图像的类别。图2 -14 所示为翻转了位置的汽车图像，并适当降低了对比度和亮度，得到的图像当然还是汽车。它们都可以被用作是汽车的训练样本。 对于图像类型的训练、数...
pytorch环境下搭建CNN-LSTM模型
05-17
首先，你需要导入 PyTorch 库： ```python import torch import torch.nn as nn import torch.optim as optim ``` 然后，定义一个继承自 nn.Module 的 CNN-LSTM 模型类，该类由两个子模块组成：一个卷积神经网络和一个长短时记忆网络。 ```python class CNN_LSTM(nn.Module): def __init__(self, num_classes): super(CNN_LSTM, self).__init__() self.cnn = nn.Sequential( nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2), nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2) ) self.lstm = nn.LSTM(input_size=64, hidden_size=128, num_layers=2, batch_first=True) self.fc = nn.Linear(128, num_classes) def forward(self, x): x = self.cnn(x) x = x.reshape(x.size(0), -1, 64) out, (h_n, c_n) = self.lstm(x) out = self.fc(out[:, -1, :]) return out ``` 在上面的代码中，我们定义了一个 CNN_LSTM 类，该类包含三个主要的组件： 1. CNN：由三个卷积层和三个最大池化层组成的卷积神经网络，用于从图像中提取特征。 2. LSTM：一个具有两个隐藏层和 128 个隐藏单元的 LSTM，用于学习序列数据之间的依赖关系。 3. 全连接层：将 LSTM 输出转换成模型预测的类别。 最后，我们可以定义模型的超参数并进行训练。 ```python # 定义超参数 num_classes = 10 learning_rate = 0.001 batch_size = 64 num_epochs = 10 # 加载数据集 train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, transform=transforms.ToTensor(), download=True) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, transform=transforms.ToTensor()) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False) # 实例化模型 model = CNN_LSTM(num_classes) # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=learning_rate) # 训练模型 total_step = len(train_loader) for epoch in range(num_epochs): for i, (images, labels) in enumerate(train_loader): images = images.permute(0, 2, 3, 1) # 调整图像维度 outputs = model(images) loss = criterion(outputs, labels) optimizer.zero_grad() loss.backward() optimizer.step() if (i+1) % 100 == 0: print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, total_step, loss.item())) # 测试模型 model.eval() with torch.no_grad(): correct = 0 total = 0 for images, labels in test_loader: images = images.permute(0, 2, 3, 1) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the model on the test images: {} %'.format(100 * correct / total)) ``` 在上面的代码中，我们首先加载 CIFAR-10 数据集并实例化 CNN-LSTM 模型。然后，我们定义了损失函数和优化器，并在训练过程中进行了模型的优化。最后，我们使用测试数据集对模型进行评估并输出准确率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值