• PyTorch实战：实现Cifar10彩色图片分类

    目录

    前言

    一、Cifar10数据集

    class torch.utils.data.Dataset

     torch.utils.data.DataLoader

    二、定义神经网络

    普通神经网络:

    定义损失函数和优化器

     训练网络-Net

    CPU训练

    模型准确率

    ​编辑

    GPU训练

    训练网络-LeNet

    模型准确率

    点关注，防走丢，如有纰漏之处，请留言指教，非常感谢

    前言

    PyTorch可以说是三大主流框架中最适合初学者学习的了，相较于其他主流框架，PyTorch的简单易用性使其成为初学者们的首选。这样我想要强调的一点是，框架可以类比为编程语言，仅为我们实现项目效果的工具，也就是我们造车使用的轮子，我们重点需要的是理解如何使用Torch去实现功能而不要过度在意轮子是要怎么做出来的，那样会牵扯我们太多学习时间。以后就出一系列专门细解深度学习框架的文章，但是那是较后期我们对深度学习的理论知识和实践操作都比较熟悉才好开始学习，现阶段我们最需要的是学会如何使用这些工具。

    深度学习的内容不是那么好掌握的，包含大量的数学理论知识以及大量的计算公式原理需要推理。且如果不进行实际操作很难够理解我们写的代码究极在神经网络计算框架中代表什么作用。不过我会尽可能将知识简化，转换为我们比较熟悉的内容，我将尽力让大家了解并熟悉神经网络框架，保证能够理解通畅以及推演顺利的条件之下，尽量不使用过多的数学公式和专业理论知识。以一篇文章快速了解并实现该算法，以效率最高的方式熟练这些知识。


    博主专注数据建模四年，参与过大大小小数十来次数学建模，理解各类模型原理以及每种模型的建模流程和各类题目分析方法。此专栏的目的就是为了让零基础快速使用各类数学模型、机器学习和深度学习以及代码，每一篇文章都包含实战项目以及可运行代码。博主紧跟各类数模比赛，每场数模竞赛博主都会将最新的思路和代码写进此专栏以及详细思路和完全代码。希望有需求的小伙伴不要错过笔者精心打造的专栏:一文速学-数学建模常用模型

    一、Cifar10数据集

    CIFAR-10是一个广泛用于测试和验证图像分类算法的基准数据集之一，因其相对较小的规模和丰富的多样性而备受研究者关注。在深度学习领域，许多研究和论文都会以CIFAR-10作为测试数据集，以评估他们的模型性能。这些类别分别是：

    1. 飞机（airplane）
    2. 汽车（automobile）
    3. 鸟类（bird）
    4. 猫（cat）
    5. 鹿（deer）
    6. 狗（dog）
    7. 青蛙（frog）
    8. 马（horse）
    9. 船（ship）
    10. 卡车（truck）

    数据集被分为训练集和测试集，其中训练集包含50,000张图片，测试集包含10,000张图片。每张图片都是3*32*32，也即3-通道彩色图片，分辨率为32*32。此外，还有一个CIFAR-100的数据集，由于CIFAR-10和CIFAR-100除了分类类别数不一样外，其他差别不大，此处仅拿CIFAR-10这个相对小点的数据集来进行介绍，介绍用pytorch来进行图像分类的一般思路和方法。

    官方下载网址：CIFAR-10 and CIFAR-100 datasets

    使用torch.utils.data加载数据：

    1. import numpy as np
    2. import torch
    3. import torchvision.transforms as transforms
    4. import os
    5. from torch.utils.data import DataLoader
    6. from torchvision.transforms import ToPILImage
    7. show = ToPILImage() # 可以把Tensor转成Image，方便可视化
    8. import torchvision.datasets as dsets
    9. batch_size = 100
    10. os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
    11.  
    12. # 定义对数据的预处理
    13. transform = transforms.Compose([
    14.         transforms.ToTensor(), # 转为Tensor
    15.         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), # 归一化 先将输入归一化到(0,1)，再使用公式”(x-mean)/std”，将每个元素分布到(-1,1) 
    16.                              ])
    17.  
    18. #Cifar110 dataset
    19. train_dataset = dsets.CIFAR10(root='/ml/pycifar',
    20.                               train = True,
    21.                               download = True,
    22.                               transform=transform
    23.                              )
    24. test_dataset = dsets.CIFAR10(root='/ml/pycifar',
    25.                              train = False,
    26.                              download = True,
    27.                              transform=transform
    28.                             )
    29. #加载数据
    30. train_loader=torch.utils.data.DataLoader(dataset=train_dataset,
    31.                                          batch_size = batch_size,
    32.                                          shuffle = True
    33.                                         )
    34. test_loader = torch.utils.data.DataLoader(dataset = test_dataset,
    35.                                           batch_size=batch_size,
    36.                                           shuffle=True
    37.                                          )

    数据展示：

    1. import matplotlib.pyplot as plt
    2. fig = plt.figure()
    3. classes=['plane','car','bird','cat','deer','dog','frog','horse','ship','truck']
    4. for i in range(12):
    5.     plt.subplot(3, 4, i+1)
    6.     plt.tight_layout()
    7.     (_, label) = train_dataset[i] 
    8.     plt.imshow(train_loader.dataset.data[i],cmap=plt.cm.binary)
    9.     plt.title("Labels: {}".format(classes[label]))
    10.     plt.xticks([])
    11.     plt.yticks([])
    12. plt.show()

     

     数据集分为五个训练批次和一个测试批次，每个批次有10000张图像。测试批次包含从每个类别中随机选择的1000幅图像。训练批包含随机顺序的剩余图像，但一些训练批可能包含一个类中的图像多于另一个类的图像。在它们之间，训练批次包含每个类别的正好5000个图像。

    数据集我们已经导入成功，需要说明的是我们之前已经对数据进行了预处理，并使数据归一化，补充一下两个需要了解的数据加载基类Dataset和DataLoader：

    class torch.utils.data.Dataset

    PyTorch的Dataset是一个抽象类，用于表示数据集。它允许你自定义数据集的加载方式，以便于在训练和测试过程中使用。

    1. 数据加载与预处理： Dataset允许你自定义数据的加载方式，可以从文件、数据库、网络等来源加载数据。你可以在__getitem__方法中实现数据的预处理、转换等操作，以满足模型的输入要求。

    2. 支持索引： 通过实现__getitem__方法，Dataset可以通过索引（如dataset[i]）获取数据样本。这允许你按需读取数据，适用于大规模数据集，避免一次性加载所有数据。

    3. 返回样本总数： len(dataset)返回数据集中样本的总数，便于在训练过程中设置合适的迭代次数。

    4. 可迭代： Dataset可以像Python列表一样进行迭代，这意味着你可以在数据集上使用for循环。

    5. 与DataLoader结合使用： Dataset通常与PyTorch的DataLoader一起使用，DataLoader可以将数据批量加载到模型中，实现了数据的批处理。

    6. 实现自定义数据集： 你可以继承Dataset类，根据自己的需求创建自定义的数据集。

    可以重构为：

    1. from torch.utils.data import Dataset
    2.  
    3. class CustomDataset(Dataset):
    4.     def __init__(self, data):
    5.         self.data = data
    6.  
    7.     def __len__(self):
    8.         return len(self.data)
    9.  
    10.     def __getitem__(self, idx):
    11.         sample = self.data[idx]
    12.         # 这里可以进行数据预处理或转换
    13.         return sample
    14.  
    15. # 使用示例
    16. data = [1, 2, 3, 4, 5]
    17. custom_dataset = CustomDataset(data)
    18. print(len(custom_dataset))  # 输出: 5
    19. print(custom_dataset[2])  # 输出: 3

     torch.utils.data.DataLoader

     torch.utils.data.DataLoader比较复杂一点，torch提供了很多参数可以用，常用的参数需要掌握：

    1. dataset (Dataset): 要加载的数据集。通常是一个继承自 torch.utils.data.Dataset 的自定义数据集对象。

    2. batch_size (int, optional): 每个批次的样本数量。默认值为 1。

    3. shuffle (bool, optional): 是否在每个 epoch 开始时随机打乱数据。默认值为 False。

    4. sampler (Sampler, optional): 定义从数据集中采样样本的策略。如果指定了此参数，shuffle 参数将被忽略。

    5. batch_sampler (Sampler, optional): 与 sampler 相似，但返回的是一个 batch 的索引列表。

    6. num_workers (int, optional): 用于数据加载的子进程数量。默认值为 0，表示所有数据将在主进程中加载。设置为大于 0 的值将启动相应数量的子进程来加载数据，可以加速数据加载。

    7. collate_fn (callable, optional): 用于将一个个样本打包成一个 batch 的函数。通常在输入数据具有不同大小时使用。

    8. pin_memory (bool, optional): 如果为 True，则数据加载器会将数据存储在 CUDA 固定内存中，可以加速数据传输到 GPU。默认值为 False。

    9. drop_last (bool, optional): 如果为 True，则在最后一个 batch 的大小小于 batch_size 时，该 batch 将被丢弃。默认值为 False。

    10. timeout (numeric, optional): 在等待新数据时的超时时间（以秒为单位）。如果设置为 None，则会一直等待，直到数据准备好。默认值为 0。

    11. worker_init_fn (callable, optional): 每个 worker 在开始加载数据之前会调用此函数。可以用于在 worker 中初始化一些特定的设置。

    这些参数可以根据实际情况来调整，以满足数据集和模型训练的需求。例如，可以根据数据集大小、模型结构等来设置 batch_size、num_workers 等参数，以获得最佳的训练性能。

    二、定义神经网络

    我们可以用两种网络来对比其分类能力，一种是普通Net网络，另外用LeNet卷积网络来对比：

    普通神经网络:

    1. import torch.nn as nn
    2. import torch
    3. input_size = 3072 #3*32*32
    4. hidden_size1 = 500 #第一次隐藏层个数
    5. hidden_size2 = 200 #第二次隐藏层个数
    6. num_classes = 10 #分类个数
    7. num_epochs = 5 #批次次数
    8. batch_size = 100  #批次大小
    9. learning_rate =1e-3
    10. #定义两层神经网络
    11. class Net(nn.Module):
    12.     def __init__(self,input_size,hidden_size1,hidden_size2,num_classes):
    13.         super(Net,self).__init__()
    14.         self.layer1 = nn.Linear(input_size,hidden_size1)#输入
    15.         self.layer2 = nn.Linear(hidden_size1,hidden_size2)#两层隐藏层计算
    16.         self.layer3 = nn.Linear(hidden_size2,num_classes)#输出
    17.         
    18.     def forward(self,x):
    19.         out = torch.relu(self.layer1(x)) #隐藏层1
    20.         out = torch.relu(self.layer2(out)) #隐藏层2
    21.         out = self.layer3(out)
    22.         return out
    23.  
    24. net =Net(input_size,hidden_size1,hidden_size2,num_classes)

    Net(
  (layer1): Linear(in_features=3072, out_features=500, bias=True)
  (layer2): Linear(in_features=500, out_features=200, bias=True)
  (layer3): Linear(in_features=200, out_features=10, bias=True)
)

    定义损失函数和优化器

    1. from torch import optim
    2. criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
    3. optimizer = optim.SGD(net.parameters(), lr=learning_rate)

     训练网络-Net

    神经网络的训练流程基本都是类似的：

    • 输入数据
    • 前向传播+反向传播
    • 更新参数

    CPU训练

    Pytorch是默认在 CPU 上运行：

    1. batch_size = 1000  #批次大小
    2. for epoch in range(num_epochs):
    3.     print('current epoch + %d' % epoch)
    4.     running_loss = 0.0
    5.     for i ,(images,labels) in enumerate(train_loader,0):
    6.         images=images.view(images.size(0),-1)
    7.         labels = torch.tensor(labels, dtype=torch.long)
    8.         # 梯度清零
    9.         optimizer.zero_grad()
    10.         outputs = net(images) #将数据集传入网络做前向计算
    11.         loss = criterion(outputs ,labels)
    12.         loss.backward()
    13.         optimizer.step()
    14.         
    15.         running_loss += loss.item()
    16.         if i % 1000 == 0: # 每1000个batch打印一下训练状态
    17.             print('[%d, %5d] loss: %.3f' \
    18.                   % (epoch+1, i+1, running_loss))
    19.             running_loss = 0.0
    20. print('Finished Training')

    current epoch + 0
[1,     0] loss: 2.149
current epoch + 1
[2,     0] loss: 2.025
current epoch + 2
[3,     0] loss: 1.987
current epoch + 3
[4,     0] loss: 2.020
current epoch + 4
[5,     0] loss: 1.970
Finished Training

    模型准确率

    1. #prediction
    2. total = 0
    3. correct =0 
    4. acc_list_test = []
    5. for images,labels in test_loader:
    6.     images=images.view(images.size(0),-1)
    7.     outputs = net(images) #将数据集传入网络做前向计算
    8.     
    9.     _,predicts = torch.max(outputs.data,1)
    10.     total += labels.size(0)
    11.     correct += (predicts == labels).sum()
    12.     acc_list_test.append(100 * correct / total)
    13.     
    14. print('Accuracy = %.2f'%(100 * correct / total))
    15. plt.plot(acc_list_test)
    16. plt.xlabel('Epoch')
    17. plt.ylabel('Accuracy On TestSet')
    18. plt.show()

    准确率只有33.06%，实际上一张图片直接给我们人来猜的话有10%概率猜对，所以这样看来神经网络还是可以有所提升的，那我们再试试卷积网络看看。

    GPU训练

    使用GPU训练只需要将torch的驱动device切换为GPU，且将显式地将张量（Tensors）和模型（Models）移动到 GPU 上就可：

    1. batch_size = 1000  #批次大小
    2. net_gpu =Net(input_size,hidden_size1,hidden_size2,num_classes)
    3. net_gpu.cuda()
    4. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    5.  
    6. for epoch in range(num_epochs):
    7.     print('current epoch + %d' % epoch)
    8.     running_loss = 0.0
    9.     for i ,(images,labels) in enumerate(train_loader,0):
    10.         images = images.to(device)
    11.         labels = labels.to(device)
    12.         
    13.         images=images.view(images.size(0),-1)
    14.         labels = torch.tensor(labels, dtype=torch.long)
    15.         # 梯度清零
    16.         optimizer.zero_grad()
    17.         outputs = net_gpu(images) #将数据集传入网络做前向计算
    18.         loss = criterion(outputs ,labels)
    19.         loss.backward()
    20.         optimizer.step()
    21.         
    22.         running_loss += loss.item()
    23.         if i % 1000 == 0: # 每2000个batch打印一下训练状态
    24.             print('[%d, %5d] loss: %.3f' \
    25.                   % (epoch+1, i, running_loss ))
    26.             running_loss = 0.0
    27. print('Finished Training')

    效果是一样的，这里不再继续复写。

    训练网络-LeNet

    我们再来训练一个卷积网络再来看看效果，可能这里讲述卷积网络有点跳跃，之后我会详细讲述卷积神经网络的全部内容，这里大家只需要知道每个网络的性能是不同的。

    1. import torch.nn as nn
    2. import torch.nn.functional as F
    3. input_size = 3072 #3*32*32
    4. hidden_size1 = 500 #第一次隐藏层个数
    5. hidden_size2 = 200 #第二次隐藏层个数
    6. num_classes = 10 #分类个数
    7. num_epochs = 5 #批次次数
    8. batch_size = 100  #批次大小
    9. learning_rate =1e-3
    10.  
    11. class LeNet(nn.Module):
    12.     def __init__(self,input_size,hidden_size1,hidden_size2,num_classes):
    13.         super(LeNet, self).__init__()
    14.          # 卷积层 '1'表示输入图片为单通道, '6'表示输出通道数，'5'表示卷积核为5*5
    15.         self.conv1=nn.Conv2d(3,6,5)
    16.         # 卷积层
    17.         self.conv2 = nn.Conv2d(6, 16, 5) 
    18.         # 仿射层/全连接层，y = Wx + b
    19.         self.fc1   = nn.Linear(input_size, hidden_size1) 
    20.         self.fc2   = nn.Linear(hidden_size1, hidden_size2)
    21.         self.fc3   = nn.Linear(hidden_size2, num_classes)
    22.         
    23.     def forward(self,x):
    24.         # 卷积 -> 激活 -> 池化 
    25.         x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
    26.         x = F.max_pool2d(F.relu(self.conv2(x)), 2)   
    27.         # reshape，‘-1’表示自适应
    28.         x = x.view(x.size()[0], -1)    
    29.         x = F.relu(self.fc1(x))
    30.         x = F.relu(self.fc2(x))
    31.         x = self.fc3(x)        
    32.         return x
    33. net =LeNet(input_size,hidden_size1,hidden_size2,num_classes)

    LeNet(
  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
  (fc1): Linear(in_features=3072, out_features=500, bias=True)
  (fc2): Linear(in_features=500, out_features=200, bias=True)
  (fc3): Linear(in_features=200, out_features=10, bias=True)
)

    以上为整个卷积网络的结构，接下来直接训练看看效果：

    1. batch_size = 1000  #批次大小
    2. for epoch in range(num_epochs):
    3.     print('current epoch + %d' % epoch)
    4.     running_loss = 0.0
    5.     for i ,(images,labels) in enumerate(train_loader,0):
    6.         #images=images.view(images.size(0),-1) 单通道不需要
    7.         labels = torch.tensor(labels, dtype=torch.long)
    8.         # 梯度清零
    9.         optimizer.zero_grad()
    10.         outputs = net(images) #将数据集传入网络做前向计算
    11.         loss = criterion(outputs ,labels)
    12.         loss.backward()
    13.         optimizer.step()
    14.         
    15.         running_loss += loss.item()
    16.         if i % 1000 == 0: # 每1000个batch打印一下训练状态
    17.             print('[%d, %5d] loss: %.3f' \
    18.                   % (epoch+1, i, running_loss ))
    19.             running_loss = 0.0
    20. print('Finished Training')

    [1,     0] loss: 2.310
current epoch + 1
[2,     0] loss: 2.301
current epoch + 2
[3,     0] loss: 2.305
current epoch + 3
[4,     0] loss: 2.303
current epoch + 4
[5,     0] loss: 2.304
Finished Training

    模型准确率

    1. #prediction
    2. total = 0
    3. correct =0 
    4. acc_list_test = []
    5. for images,labels in test_loader:
    6.     #images=images.view(images.size(0),-1)
    7.     outputs = net(images) #将数据集传入网络做前向计算
    8.     
    9.     _,predicts = torch.max(outputs,1)
    10.     total += labels.size(0)
    11.     correct += (predicts == labels).sum()
    12.     acc_list_test.append(100 * correct / total)
    13.     
    14. print('Accuracy = %.2f'%(100 * correct / total))
    15. plt.plot(acc_list_test)
    16. plt.xlabel('Epoch')
    17. plt.ylabel('Accuracy On TestSet')
    18. plt.show()

     

     比普通的神经网络要好很多。

    点关注，防走丢，如有纰漏之处，请留言指教，非常感谢

    以上就是本期全部内容。我是fanstuck ，有问题大家随时留言讨论 ，我们下期见。

  • 相关阅读:
    cs224w（图机器学习）2021冬季课程学习笔记6
    闲谈：3AC到底发生了什么？
    SQL语句之like操作符
    TwinCAT3加不上路由ADS的几种可能
    JMM内存模型
    代码随想录一刷打卡——.二叉树的层次遍历（十题特别版）
    Jmeter接口测试， 快速完成一个单接口请求
    算法通关村——数字中的统计、溢出、进制转换处理模板
    微服务--限流
    Unity学习shader笔记[一百]简单焦散Caustic效果
  • 原文地址：https://blog.csdn.net/master_hunter/article/details/133064410