devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用pytorch实现预训练模型迁移学习中的图像分类_pytorch迁移学习中的多分类算法图

作者：酷酷是懒虫 | 2024-08-03 14:47:40

赞

踩

pytorch迁移学习中的多分类算法图

目录

相关知识点

1.加载分类网络模型

（1）加载网络模型

（2）查看网络模型和模型参数

（3）读取ImageNet.txt分类文件

（4）使用预训练模型预测一张图片

（5）加载CIFAR10数据集

（6）对网络输出修改

2.完整迁移学习实例1

首先导入相关的包：

（1）CIFAR10数据集类别

（2）加载预训练模型

（3）数据变换

（4）获取数据集

（5）模型修改

（6）模型冻结

（7）加载数据集

（8）定义损失函数

（9）定义优化器

（10） 模型的保存和加载

（11）训练开始

（12）加载模型预测

（13）打开tensorboard查看训练的过程 

（14）训练好的模型下载

3.完整迁移学习实例2

导入相关的包

（1）加载数据集

（2）加载预训练模型

（3）模型修改

（4）模型冻结

（5）定义损失函数

（6）定义优化器

（7）模型保存和加载

（8）训练开始

（9）预测图片和实时检测

（10）打开tensorboard查看训练的过程

（11）训练好的模型下载

提示：

第一：由于我们在搭建自己的网络来训练模型时，总是在准确率上达不到要求，最后导致训练出来的模型对图像的预测效果不怎么好；

第二：由于我们本身电脑的配置，对于一些小伙伴来说，可能电脑配置并没有像常见的GPU之类的加速器，所以导致在数据集上选择不能太大，不然电脑承受不了太长时间的训练，也就是我们电脑本身的资源不够，也会导致训练的模型效果不好。

基于上面一些比较常见的问题，我们可以采用已经训练好的预训练模型来实现，在别人训练好的模型基础上进行训练，数据集上不需要很多，也能在资源有限的情况下达到比较好的效果。以下主要是采用pytorch中的预训练模型来对图形进行分类和目标检测。

相关知识点

  • 预训练模型是一个之前基于大型数据集（通常是大型图像分类任务）训练的已保存网络。可以按原样使用预训练模型，也可以使用迁移学习针对给定任务自定义此模型。
  • 用于图像分类的迁移学习背后的理念是，如果一个模型是基于足够大且通用的数据集训练的，那么该模型将有效地充当视觉世界的通用模型。随后，您可以利用这些学习到的特征映射，而不必通过基于大型数据集训练大型模型而从头开始。
  • 通过以下两种方式来自定义预训练模型：
    • 方式一：
      • 特征提取：使用先前网络学习的表示从新样本中提取有意义的特征。您只需在预训练模型上添加一个将从头开始训练的新分类器，这样便可重复利用先前针对数据集学习的特征映射。
    • 无需（重新）训练整个模型。基础卷积网络已经包含通常用于图片分类的特征。但是，预训练模型的最终分类部分特定于原始分类任务，随后特定于训练模型所使用的类集。
    • 方式二：
      • 微调：解冻已冻结模型库的一些顶层，并共同训练新添加的分类器层和基础模型的最后几层。这样，我们便能“微调”基础模型中的高阶特征表示，以使其与特定任务更相关。
  • 通用的机器学习工作流。
  • 检查并理解数据
  • 构建输入流水线，在本例中使用 Keras ImageDataGenerator
  • 构成模型
    • 加载预训练的基础模型（和预训练权重）
    • 将分类层堆叠在顶部
  • 训练模型
  • 评估模型

1.加载分类网络模型

这里以ResNet50为例子，之所以选择这个模型，主要是在精度和参数量上进行权衡的。

（1）加载网络模型

官网地址：https://pytorch.org/vision/stable/models/generated/torchvision.models.resnet50.html#torchvision.models.resnet50

  1. import os
  2. import cv2
  3. import torch
  4. from PIL import Image
  5. from torchvision.models import resnet50
  6. from torchvision import datasets,transforms
  7. from torchstat import stat,stat_tree,statistics
  8. from torch.utils.data import DataLoader,Dataset
  9.  
  10. #加载resNet50预训练模型
  11. # https://pytorch.org/vision/stable/models/generated/torchvision.models.resnet50.html#torchvision.models.resnet50
  12. # pretrained (bool): If True, returns a model pre-trained on ImageNet(如果设置为True的话，表示返回一个在ImageNet上训练的模型)
  13. # progress (bool): If True, displays a progress bar of the download to stderr(如果为True，表示在下载的过程显示进度条)
  14. modelResNet50=resnet50(pretrained=True,progress=True)

（2）查看网络模型和模型参数

深度学习模型的参数、计算量和推理速度统计

  1. #查看网络模型的结构
  2. print(modelResNet50)
  3. #查看模型的参数量
  4. print('modelParameters: {}'.format(stat(modelResNet50,(3,224,224))))

（3）读取ImageNet.txt分类文件

ImageNet.txt分类文件下载：

链接：https://pan.baidu.com/s/1YAIACNbo9IcLeP1Fb8o8kQ 
提取码：equ2 

  1. #读取类别文件
  2. def readClasses():
  3.     classes=[]
  4.     with open('tempData/imageNet_1.txt','r') as fp:
  5.         readlines=fp.read().strip().split('\n')
  6.         #遍历每一行
  7.         for line in readlines:
  8.             #读取编号后面的类别名,这里的line表示在一行类别中找到第一个空格，取第一个空格之后的所有字符串，
  9.             # 使用split以","作为分割目标，并且获取第一个字符串，也就是类别名
  10.             classes.append(line[line.find(' ')+1:].split(',')[0])
  11.  
  12.     print('classSize: {}'.format(len(classes)))
  13.     for className in classes:
  14.         print(className)
  15.     return classes

（4）使用预训练模型预测一张图片

提示：意思是说，对于输入网络模型的图片预处理要求是：

  • 第一步：接收的是Image读取的读取的类型图片（Image.open(img_path)）,如果是批量输入的话，输入格式为[N,C,H,W]；但是如果输入的是单张的图片的话，输入格式为：[C,H,W]；
  • 第二步：将读取图片的类型转换为tensor类型；
    • transforms.ToTensor()；
  • 第三步：将图片缩放至[256,256]大小并且使用的线性插值为：InterpolationMode.BILINEAR;
    • transforms.Resize(size=(232,232),interpolation=transforms.InterpolationMode.BILINEAR)；
  • 第四步：将图片中心裁剪到[224,224]；
    • transforms.CenterCrop(size=(224,224))；
  • 第五步：将像素值缩放至[0-1]之间；
  • 第六步：对图片进行标准化处理，平均值=[0.485,0.456,0.406],标准差=[0.229,0.224,0.225]。 
    • transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])

  1. """
  2. @Author : Keep_Trying_Go
  3. @Major  : Computer Science and Technology
  4. @Hobby  : Computer Vision
  5. @Time   : 2023-01-04 10:05
  6. """
  7.  
  8. import os
  9. import cv2
  10. import torch
  11. import numpy as np
  12. from PIL import Image
  13. from torchvision.models import resnet50
  14. from torchvision import datasets,transforms
  15. from torchstat import stat,stat_tree,statistics
  16. from torch.utils.data import DataLoader,Dataset
  17.  
  18.  
  19. #读取类别文件
  20. def readClasses():
  21.     classes=[]
  22.     with open('tempData/imageNet_1.txt','r') as fp:
  23.         readlines=fp.read().strip().split('\n')
  24.         #遍历每一行
  25.         for line in readlines:
  26.             #读取编号后面的类别名,这里的line表示在一行类别中找到第一个空格，取第一个空格之后的所有字符串，
  27.             # 使用split以","作为分割目标，并且获取第一个字符串，也就是类别名
  28.             classes.append(line[line.find(' ')+1:].split(',')[0])
  29.  
  30.     print('classSize: {}'.format(len(classes)))
  31.     for className in classes:
  32.         print(className)
  33.     return classes
  34.  
  35. def Model(classes):
  36.     #加载resNet50预训练模型
  37.     # https://pytorch.org/vision/stable/models/generated/torchvision.models.resnet50.html#torchvision.models.resnet50
  38.     # pretrained (bool): If True, returns a model pre-trained on ImageNet(如果设置为True的话，表示返回一个在ImageNet上训练的模型)
  39.     # progress (bool): If True, displays a progress bar of the download to stderr(如果为True，表示在下载的过程显示进度条)
  40.     modelResNet50=resnet50(pretrained=True,progress=True)
  41.     #查看网络模型的结构
  42.     # print(modelResNet50)
  43.     # #查看模型的参数量
  44.     # print('modelParameters: {}'.format(stat(modelResNet50,(3,224,224))))
  45.  
  46.     #加载CIFAR10数据https://mydreamambitious.blog.csdn.net/article/details/128482455
  47.     #数据变换
  48.     transform=transforms.Compose([
  49.         transforms.Resize(size=(232,232),interpolation=transforms.InterpolationMode.BILINEAR),
  50.         transforms.CenterCrop(size=(224,224)),
  51.         transforms.ToTensor(),
  52.         transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])
  53.     ])
  54.   
  55.     #预测一张图片的位置
  56.     img_path='data/dog.4356.jpg'
  57.     img=Image.open(img_path)
  58.     imgPerprocess=transform(img=img)
  59.     # print(type(imgPerprocess))
  60.     # print(imgPerprocess.shape)
  61.     imgPerprocess=torch.unsqueeze(imgPerprocess,dim=0)
  62.     #将modelResNet50模型设置为eval模式
  63.     modelResNet50.eval()
  64.     ResOutput=modelResNet50(imgPerprocess)
  65.     #从行上找到最大值
  66.     print(ResOutput.shape)
  67.     _,index=torch.max(input=ResOutput,dim=1)
  68.     #获取类别概率值
  69.     confidence=torch.nn.functional.softmax(ResOutput,dim=1)[0]
  70.     #取概率值的小数后四位
  71.     class_id=confidence.argmax()
  72.     print('class_id: {}'.format(class_id))
  73.     print('index: {}'.format(index))
  74.     print('confidence.shape: {}'.format(confidence.shape))
  75.     #获取概率最大值
  76.     print('预测概率: {:.4f}'.format(confidence[index].item()))
  77.     print('预测类别: {}'.format(classes[class_id]))
  78.  
  79.  
  80. if __name__ == '__main__':
  81.     # readClasses()
  82.     classes=readClasses()
  83.     Model(classes=classes)

（5）加载CIFAR10数据集

推荐博客：https://mydreamambitious.blog.csdn.net/article/details/128482455

  1. #加载CIFAR10数据https://mydreamambitious.blog.csdn.net/article/details/128482455
  2. #数据变换
  3. transform=transforms.Compose([
  4.     transforms.ToTensor()
  5. ])
  6. dataset=datasets.CIFAR10(root='tempData/CIFAR10',train=True,transform=transform,download=False)

这里读者也可以不用使用CIFAR10数据集，也可以使用其他的数据集。

（6）对网络输出修改

  1. 方式一：
  2. #由于CIFAR10数据集是10分类的，所以需要对网络输出进行修改(resnet50网络的输出为1000分类)
  3. modelResNet50.add_module(name='outputLayer',module=torch.nn.Linear(in_features=1000,out_features=10,bias=False))
  4. print(modelResNet50)
  5.  
  6. 方式二：
  7. #或者修改最后的全连接的输出特征个数为10
  8. fc_features=modelResNet50.fc.in_features
  9. modelResNet50.fc=torch.nn.Linear(fc_features,10)

2.完整迁移学习实例1

提示：我们这里训练以CIFAR10数据集为例子。对于以下的迁移学习过程其实只是加载了一个预训练模型新，如果读者在搭建自己的模型进行训练也是同样的步骤，只是换了一下模型。

首先导入相关的包：

  1. """
  2. @Author : Keep_Trying_Go
  3. @Major  : Computer Science and Technology
  4. @Hobby  : Computer Vision
  5. @Time   : 2023-01-04 10:05
  6. """
  7.  
  8. import os
  9. import cv2
  10. import torch
  11. import numpy as np
  12. from PIL import Image
  13. import matplotlib.pyplot as plt
  14. from torchvision.models import resnet50
  15. from torchvision import datasets,transforms
  16. from torchstat import stat,stat_tree,statistics
  17. from torch.utils.data import DataLoader,Dataset
  18. from torch.utils.tensorboard import SummaryWriter

（1）CIFAR10数据集类别

  1.  #CIFAR10数据集的类别名
  2.     classes=['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
  3.     classToIdx={'airplane': 0, 'automobile': 1, 'bird': 2, 'cat': 3, 'deer': 4, 'dog': 5, 'frog': 6, 'horse': 7,
  4.                  'ship': 8, 'truck': 9}

（2）加载预训练模型

  1. modelResNet50 = resnet50(pretrained=True, progress=True)
  2. # 查看网络模型的结构
  3. # print(modelResNet50)
  4. # #查看模型的参数量
  5. # print('modelParameters: {}'.format(stat(modelResNet50,(3,224,224))))

（3）数据变换

  1. # 数据变换
  2.     transform = transforms.Compose([
  3.         transforms.Resize(size=(232, 232), interpolation=transforms.InterpolationMode.BILINEAR),
  4.         transforms.CenterCrop(size=(224, 224)),
  5.         transforms.ToTensor(),
  6.         transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
  7.     ])

（4）获取数据集

  1.  #获取数据集
  2.     trainDataset = datasets.CIFAR10(root='tempData/CIFAR10', train=True, transform=transform, download=False)
  3.     testDataset=datasets.CIFAR10(root='tempData/CIFAR10',train=False,transform=transform,download=False)
  1.  #获取数据集的相关属性
  2.     print('trainDatasetSize: {}'.format(len(trainDataset)))
  3.     print('testDatasetSize: {}'.format(len(testDataset)))
  4.     print('classToIdx: {}'.format(trainDataset.class_to_idx))
  5.     print('classes: {}'.format(trainDataset.classes))
  6.     print('targetLabel: {}'.format(trainDataset.targets))
  7.     print('transform: {}'.format(trainDataset.transform))
  8.     print('transforms: {}'.format(trainDataset.transforms))
  9.     img,target=trainDataset[0]
  10.     print('trainDataset[0].shape: {}'.format(img.shape))
  11.     print('type(trainDataset[0]): {}'.format(type(img)))
  1. #将tensor=>numpy
  2.     img=np.array(img)
  3.     #对于opencv读取的图像格式为[H,W,C]，所以需要将img：[C,H,W]=>[H,W,C]
  4.     img=np.transpose(img,(1,2,0))
  5.     cv2.imshow('img',img)
  6.     cv2.waitKey(0)
  7.     cv2.destroyAllWindows()

（5）模型修改

  1.  # 由于CIFAR10数据集是10分类的，所以需要对网络输出进行修改(resnet50网络的输出为1000分类)
  2.     #方式一：
  3.     fc_in_features=modelResNet50.fc.in_features
  4.     fc_out_features=modelResNet50.fc.out_features
  5.     #PyTorch中nn.ReLU(inplace=True)中inplace的作用:https://blog.csdn.net/AugustMe/article/details/92589979
  6.     modelResNet50.add_module(name='fc',module=torch.nn.Sequential(
  7.         torch.nn.Linear(in_features=fc_in_features, out_features=fc_out_features, bias=True),
  8.         torch.nn.ReLU(inplace=False),
  9.         torch.nn.Dropout(p=0.5,inplace=False),
  10.         torch.nn.Linear(in_features=fc_out_features, out_features=10,bias=True)
  11.     ))
  12.     #方式二：或者修改最后的全连接的输出特征个数为10
  13.     # fc_features=modelResNet50.fc.in_features
  14.     # modelResNet50.fc=torch.nn.Linear(fc_features,10)
  15.     # print(modelResNet50)

（6）模型冻结

  1. # 提取模型的layer4,avgpool,fc,Classifer层的参数，其他层冻结
  2.     #https://blog.csdn.net/Wind_2028/article/details/120541017
  3.      for name,child in modelResNet50.named_children():
  4.         if name in ['layer4','avgpool','fc']:
  5.             for param in child.parameters():
  6.                 param.requires_grad=True
  7.         else:
  8.             for param in child.parameters():
  9.                 param.requires_grad=False
  10.     # print(modelResNet50)
  11.  
  12.  #查看冻结的层
  13.     for name,param in modelResNet50.named_parameters():
  14.         if param.requires_grad==False:
  15.             print(name)

提示：关于使用预训练模型的时候进行微调训练，那么该怎么进行微调训练呢？

  • 第一：如果是我们准备的数据集和预训练模型的数据集差不多，也就是图像中的内容是差不多的，那么 只需要修改最后的输出类别，微调训练最后一层的全连接参数，其他层冻结，比如下面这样做：
    •  

      model = models.resnet50(pretrained=True) 

      # 修改全连接层最后的输出类别，使得全连接层的输出与当前数据集类别数对应
      # 新建的层默认 requires_grad=True

    • model.fc = nn.Linear(model.fc.in_features, n_class)

    • # 只微调训练最后一层全连接层的参数，其他层冻结
      optimizer = optim.Adam(model.fc.parameters())

  •  第二：如果我们准备的数据集和与训练模型的数据集相差比较多的话，那么这个时候可以微调训练所有的层，但是还是载入预训练模型的参数，比如下面这样做：

    •  

      model = models.resnet18(pretrained=True) 

    • model.fc = nn.Linear(model.fc.in_features, n_class)

    • optimizer = optim.Adam(model.parameters())

  • 第三：如果我们准备的数据集和预训练模型的数据集完全不一样的话，那么就不需要载入训练模型的参数，使用预训练模型结构进行权重初始化，微调训练所有的层，比如下面这样做：

    • model = models.resnet18(pretrained=False) # 只载入模型结构，不载入预训练权重参数

    • model.fc = nn.Linear(model.fc.in_features, n_class)

    • optimizer = optim.Adam(model.parameters())

       

（7）加载数据集

  1.  # #加载数据集  https://mydreamambitious.blog.csdn.net/article/details/128482455
  2.     batch_size=4
  3.     trainDataLoader=DataLoader(dataset=trainDataset,batch_size=batch_size,shuffle=True,num_workers=0,drop_last=False)
  4.     testDataLoader=DataLoader(dataset=testDataset,batch_size=batch_size,shuffle=True,num_workers=0,drop_last=False)

（8）定义损失函数

  1.  # #损失函数的定义
  2.     lossCIFAR10=torch.nn.CrossEntropyLoss()

（9）定义优化器

  1. # #定义优化器 https://blog.csdn.net/Wind_2028/article/details/120541017
  2.     learing_rate=0.001
  3.     optimizer=torch.optim.SGD([
  4.         {'params':modelResNet50.layer4.parameters(),'lr':learing_rate},
  5.         {'params':modelResNet50.avgpool.parameters(),'lr':learing_rate},
  6.         {'params':modelResNet50.fc.parameters(),'lr':learing_rate}
  7.     ],lr=learing_rate)

（10） 模型的保存和加载

  • 模型的保存方式：
    • 方式一：模型的结构+模型的参数
      • torch.save(modelResNet50,'modelName.pth');
    • 方式二：模型的参数
      • torch.save(modelResNet50.state_dict(),'modelName.pth');
  • 对应的模型加载方式：
    • 对应模型保存方式一：
      • model=torch.load('modeName.pth');
    • 对应模型保存方式二：
      • modelResNet50=torchvision.models.resnet50(pretrained=False);
      • modelResNet50.load_state_dict(torch.load('modeName.pth'));

（11）训练开始

提示：训练模型中使用：model.train()和model.eval()的具体作用：分别设置为训练模型和验证模型。但是这仅对某些模块有任何影响，比如： Dropout, BatchNorm。

https://pytorch.org/docs/stable/generated/torch.nn.Module.html#torch.nn.Module

  1. # #迭代的次数
  2.     epoches=10
  3.  
  4.     #使用tensorboard显示训练过程
  5.     writer=SummaryWriter('logs')
  6.     #将损失值和准确率保存起来，用于最后画出图形
  7.     PlotTestLoss=[]
  8.     PlotTestCorrect=[]
  9.     PlotTrainLoss=[]
  10.     PlotTrainCorrect=[]
  11.  
  12.     for i in range(epoches):
  13.         # 训练的次数
  14.         trainStep = 0
  15.         #训练集上的准确率
  16.         trainCorrect=0
  17.         #训练集上的损失
  18.         trainLoss=0
  19.         traintotal=0
  20.         print('-----------------------第{}轮的训练--------------------------'.format(i+1))
  21.         #每一次迭代的训练
  22.         modelResNet50.train()
  23.         for traindata in trainDataLoader:
  24.             imgs,targets=traindata
  25.             # print(type(imgs)) =><class 'torch.Tensor'>
  26.             #输入模型，进行训练
  27.             output=modelResNet50(imgs)
  28.             # print(output)
  29.             # print(output.shape)
  30.             # 计算损失值
  31.             loss=lossCIFAR10(output,targets)
  32.             #优化器清零
  33.             optimizer.zero_grad()
  34.             #反向传播
  35.             loss.backward()
  36.             #梯度更新
  37.             optimizer.step()
  38.             #步数加一
  39.             trainStep=trainStep+1
  40.             with torch.no_grad():
  41.                 #获取预测概率最大值索引(按行计算最大)
  42.                 output=torch.argmax(input=output,dim=1)
  43.                 # print(output)=>tensor([2, 9, 6, 0])
  44.                 # print(output[0].item())=>2
  45.                 #计算准确率
  46.                 trainCorrect+=(output==targets).sum().item()
  47.                 traintotal+=imgs.shape[0]
  48.                 #计算总的损失
  49.                 trainLoss+=loss.item()
  50.                 if trainStep%100==0:
  51.                     print('-----------step: {}--------loss: {:.6f}---------correct: {:.6f}'.format(trainStep,trainLoss*1.0/traintotal,trainCorrect*1.0/traintotal))
  52.         writer.add_scalar(tag='trainLoss',scalar_value=trainLoss*1.0/traintotal,global_step=i+1)
  53.         writer.add_scalar(tag='correct',scalar_value=trainCorrect*1.0/traintotal,global_step=i+1)
  54.         #在tensorboard中绘制预测最优一步训练的output[0]结果图
  55.         writer.add_image(tag='train----{}.{:.4f}'.format(classes[output[0].item()],trainCorrect/traintotal),img_tensor=imgs[0],global_step=i+1)
  56.  
  57.         PlotTrainLoss.append(trainLoss * 1.0 / traintotal)
  58.         PlotTrainCorrect.append(trainCorrect * 1.0 / traintotal)
  59.         #在测试数据集上进行测试
  60.         testTotal=0
  61.         testCorrect=0
  62.         testLoss=0
  63.         #测试集上不需要梯度更新
  64.         modelResNet50.eval()
  65.         with torch.no_grad():
  66.             for data in testDataLoader:
  67.                 imgs,targets=data
  68.                 # 输入模型，进行训练
  69.                 output = modelResNet50(imgs)
  70.                 # 计算损失值
  71.                 loss = lossCIFAR10(output, targets)
  72.                 # 获取预测概率最大值索引(按行计算最大)
  73.                 output = torch.argmax(input=output, dim=1)
  74.                 # 计算准确率
  75.                 testCorrect += (output == targets).sum().item()
  76.                 testTotal += imgs.shape[0]
  77.                 # 计算总的损失
  78.                 testLoss += loss.item()
  79.             print('-----------test:--------loss: {:.6f}---------correct: {:.6f}'.format(testLoss * 1.0 / testTotal,
  80.                                                          testCorrect * 1.0 / testTotal))
  81.         writer.add_scalar(tag='testLoss', scalar_value=testLoss * 1.0 / testTotal, global_step=i + 1)
  82.         writer.add_image(tag='test----{}.{:.6f}'.format(classes[output[0].item()], testCorrect / testTotal),
  83.                          img_tensor=imgs[0], global_step=i + 1)
  84.  
  85.         PlotTestLoss.append(testLoss * 1.0 / testTotal)
  86.         PlotTestCorrect.append(testCorrect * 1.0 / testTotal)
  87.         #保运模型
  88.         torch.save(modelResNet50,'models/modelResNet50_{}.pth'.format(i))
  89.  
  90.     #使用matplotlib绘制图形
  91.     plt.plot(range(1,epoches+1),PlotTestLoss,label='trainLoss')
  92.     plt.plot(range(1, epoches + 1), PlotTestLoss, label='testLoss')
  93.     plt.legend()
  94.     plt.show()
  95.  
  96.     plt.plot(range(1, epoches + 1), PlotTrainCorrect, label='trainAcc')
  97.     plt.plot(range(1, epoches + 1), PlotTestCorrect, label='testAcc')
  98.     plt.legend()
  99.     plt.show()
  100.     writer.close()

（12）加载模型预测

  1. import os
  2. import cv2
  3. import time
  4. import torch
  5. import numpy as np
  6. from PIL import Image
  7. from torchvision import datasets
  8. from torchvision import transforms
  9. from torch.utils.data import DataLoader,Dataset
  10.  
  11.  
  12. # CIFAR10数据集的类别名
  13. classes = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
  14. classToIdx = {'airplane': 0, 'automobile': 1, 'bird': 2, 'cat': 3, 'deer': 4, 'dog': 5, 'frog': 6, 'horse': 7,
  15.               'ship': 8, 'truck': 9}
  16.  
  17. # 数据变换
  18. transform = transforms.Compose([
  19.     transforms.Resize(size=(232, 232), interpolation=transforms.InterpolationMode.BILINEAR),
  20.     transforms.CenterCrop(size=(224, 224)),
  21.     transforms.ToTensor(),
  22.     transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
  23. ])
  24.  
  25. def predictImage(img_path):
  26.     """
  27.     :param img_path: 图片的路径
  28.     :return:
  29.     """
  30.     #读取图片
  31.     img=Image.open(img_path)
  32.     #图像处理
  33.     img_Transform=transform(img)
  34.     #对图像进行升维
  35.     img_Transform=torch.unsqueeze(input=img_Transform,dim=0)
  36.     #加载模型
  37.     modelResNet50=torch.load('modelResNet50_0.pth')
  38.     # print(modelResNet50)
  39.     #预测图片
  40.     predicts=modelResNet50(img_Transform)
  41.     #获取类别概率值
  42.     predicts=torch.nn.functional.softmax(predicts,dim=1)[0]
  43.     class_id=predicts.argmax()
  44.     print('predicts: {}'.format(predicts))
  45.     print('class_id: {}'.format(class_id))
  46.     print('预测概率: {:.4f}'.format(predicts[class_id].item()))
  47.     print('预测类别: {}'.format(classes[class_id]))
  48.  
  49. def timeDetect():
  50.     """
  51.     :return:
  52.     """
  53.     # 加载模型
  54.     modelResNet50 = torch.load('modelResNet50_0.pth')
  55.  
  56.     img1=cv2.imread('tempData/cat.64.jpg')
  57.     print('img1.shape: {}'.format(img1.shape))
  58.     print('img1.type: {}'.format(type(img1)))
  59.     img2=Image.open('tempData/cat.64.jpg')
  60.     print('img2.shape: {}'.format(np.shape(img2)))
  61.     print('img3.type: {}'.format(type(img2)))
  62.  
  63.     #计算开始时间
  64.     start_time=time.time()
  65.     #计算帧率
  66.     countFPS=0
  67.     #开启摄像头
  68.     cap = cv2.VideoCapture(0)
  69.     while cap.isOpened():
  70.         ret, frame = cap.read()
  71.         frame = cv2.resize(src=frame, dsize=(520, 520))
  72.         frame = cv2.flip(src=frame, flipCode=2)
  73.         frame_PIL=Image.fromarray(frame)
  74.         img_transform=transform(frame_PIL)
  75.         # 对图像进行升维
  76.         img_Transform = torch.unsqueeze(input=img_transform, dim=0)
  77.         # 预测图片
  78.         predicts = modelResNet50(img_Transform)
  79.         # 获取类别概率值
  80.         predicts = torch.nn.functional.softmax(predicts, dim=1)[0]
  81.         class_id = predicts.argmax()
  82.         end_time=time.time()
  83.         countFPS+=1
  84.         FPS=round(countFPS/(end_time-start_time),0)
  85.         text = classes[class_id] + ': ' + str('{:.4f}'.format(predicts[class_id].item())) + '%'
  86.         cv2.putText(img=frame, text='FPS: '+str(FPS), org=(10, 50),
  87.                     fontFace=cv2.FONT_HERSHEY_SIMPLEX,
  88.                     fontScale=1.0, color=(0, 255, 0), thickness=2)
  89.         cv2.putText(img=frame, text=text, org=(10, 80),
  90.                     fontFace=cv2.FONT_HERSHEY_SIMPLEX,
  91.                     fontScale=1.0, color=(0, 255, 0), thickness=2)
  92.         cv2.imshow('img', frame)
  93.         key = cv2.waitKey(1)
  94.         if key == 27:
  95.             break
  96.     cap.release()
  97.     cv2.destroyAllWindows()
  98.  
  99.  
  100. if __name__ == '__main__':
  101.     # predictImage(img_path='tempData/cat.64.jpg')
  102.     timeDetect()

实时检测：

（13）打开tensorboard查看训练的过程 

在pycharm的terminal命令行窗口输入：tensorboard --logdir=logs --host=127.0.0.1 --port=8008。

 

（14）训练好的模型下载

提示：由于我把训练的每一代模型都保存了，但是我这里只给出第一代，第五代和第十代训练的结果模型。

下载地址如下：读者自行使用上面的代码尝试一下下面训练的这个几个模型效果如何：

链接：modelResNet50_0.pth
提取码：e375

链接：modelResNet50_4.pth
提取码：nwh0

链接：modelResNet50_9.pth
提取码：sthx

提示：由于训练的时间非常的长（CPU上差不多训练两天），读者也可以使用Google Colab上的GPU进行训练：

https://mydreamambitious.blog.csdn.net/article/details/125774545

3.完整迁移学习实例2

由于我们在pytorch中加载数据集的时候 ，比如下面：

trainDataset = datasets.CIFAR10(root='tempData/CIFAR10', train=True, transform=transform, download=False)
testDataset=datasets.CIFAR10(root='tempData/CIFAR10',train=False,transform=transform,download=False)

但是这里img,label=trainDataset[0],也就是说我们加载的训练数据集和测试数据集已将得到了对应的图片和标签， 可是如果我们要使用pytorch来训练我们自己处理的数据集，该怎么处理呢？比如下面这种数据集文件格式：

该数据集包含测试集，训练集和验证集，其中测试集，训练集和验证集文件夹下面分别对应的数据集包含：Mask（有口罩）和Non Mask（无口罩）两种类别的数据集。其实使用pytorch框架和使用tensorflow框架导入该数据集差不多一样：

使用Tensorflow训练检测口罩模型完整实例

下面我们使用pytorch框架训练检测口罩的模型，并使用训练的模型进行检测：

导入相关的包

  1. """
  2. @Author : Keep_Trying_Go
  3. @Major  : Computer Science and Technology
  4. @Hobby  : Computer Vision
  5. @Time   : 2023-01-07 20:50
  6. """
  7.  
  8. import os
  9. import cv2
  10. import torch
  11. import numpy as np
  12. from PIL import Image
  13. import matplotlib.pyplot as plt
  14. from torchvision.models import resnet50
  15. from torchvision import datasets,transforms
  16. from torch.utils.data import Dataset,DataLoader
  17. from torchstat import stat,stat_tree,statistics
  18. from torch.utils.tensorboard import SummaryWriter

（1）加载数据集

定义数据集路径

  1. #训练集数据集路径
  2. trainDataPath='myDataset/New Masks Dataset/Train'
  3. #测试集数据集路径
  4. testDataPath='myDataset/New Masks Dataset/Test'
  5.  
  6. #数据集对应的类别
  7. classes=['Mask', 'Non Mask']
  8. class_to_idx={'Mask': 0, 'Non Mask': 1}

对数据集进行变换

  1. #对数据集进行变换
  2. # 数据变换
  3. transform = transforms.Compose([
  4.     transforms.Resize(size=(232, 232), interpolation=transforms.InterpolationMode.BILINEAR),
  5.     transforms.CenterCrop(size=(224, 224)),
  6.     transforms.ToTensor(),
  7.     transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
  8. ])

查看数据集相关属性

  1. #载入训练和测试集数据集
  2. trainDataset=datasets.ImageFolder(root=trainDataPath,transform=transform)
  3. testDataset=datasets.ImageFolder(root=testDataPath,transform=transform)
  4.  
  5. #查看数据集的属性
  6. print('trainSize: {}'.format(len(trainDataset)))
  7. print('testSize: {}'.format(len(testDataset)))
  8. print('train.class: {}'.format(trainDataset.classes))
  9. print('class:index: {}'.format(trainDataset.class_to_idx))
  10. #类别索引
  11. class_to_idxs={y:x for x,y in trainDataset.class_to_idx.items()}
  12. print(class_to_idxs)

  显示图片

  1. img,target=trainDataset[0]
  2. print('trainDataset[0].shape: {}'.format(img.shape))
  3. print('type(trainDataset[0]): {}'.format(type(img)))
  4.  
  5. #将tensor=>numpy
  6. img=np.array(img)
  7. #对于opencv读取的图像格式为[H,W,C]，所以需要将img：[C,H,W]=>[H,W,C]
  8. img=np.transpose(img,(1,2,0))
  9. cv2.imshow('img',img)
  10. cv2.waitKey(0)
  11. cv2.destroyAllWindows()

   

加载数据集

  1. #加载数据集
  2. batch_size=4
  3. trainDataLoader=DataLoader(
  4.     dataset=trainDataset,
  5.     batch_size=batch_size,
  6.     shuffle=True,
  7.     num_workers=0
  8. )
  9. testDataLoader=DataLoader(
  10.     dataset=testDataset,
  11.     batch_size=batch_size,
  12.     shuffle=True,
  13.     num_workers=0
  14. )

（2）加载预训练模型

  1. modelResNet50 = resnet50(pretrained=True, progress=True)
  2. # 查看网络模型的结构
  3. # print(modelResNet50)
  4. # #查看模型的参数量
  5. # print('modelParameters: {}'.format(stat(modelResNet50,(3,224,224))))

（3）模型修改

  1. # 由于检测口罩数据集是2分类的，所以需要对网络输出进行修改(resnet50网络的输出为1000分类)
  2. # 方式一：
  3. fc_in_features = modelResNet50.fc.in_features
  4. fc_out_features = modelResNet50.fc.out_features
  5. # PyTorch中nn.ReLU(inplace=True)中inplace的作用:https://blog.csdn.net/AugustMe/article/details/92589979
  6. modelResNet50.add_module(name='fc', module=torch.nn.Sequential(
  7.     torch.nn.Linear(in_features=fc_in_features, out_features=fc_out_features, bias=True),
  8.     torch.nn.ReLU(inplace=False),
  9.     torch.nn.Dropout(p=0.5, inplace=False),
  10.     torch.nn.Linear(in_features=fc_out_features, out_features=2, bias=True)
  11. ))
  12. # 方式二：或者修改最后的全连接的输出特征个数为2
  13. # fc_features=modelResNet50.fc.in_features
  14. # modelResNet50.fc=torch.nn.Linear(fc_features,2)
  15. # print(modelResNet50)

（4）模型冻结

  1. # 提取模型的layer4,avgpool,fc,Classifer层的参数，其他层冻结
  2.     #https://blog.csdn.net/Wind_2028/article/details/120541017
  3.     for name,child in modelResNet50.named_children():
  4.         if name in ['layer4','avgpool','fc']:
  5.             for param in child.parameters():
  6.                 param.requires_grad=True
  7.         else:
  8.             for param in child.parameters():
  9.                 param.requires_grad=True
  10.     # print(modelResNet50)
  11.  
  12.  #查看冻结的层
  13.     for name,param in modelResNet50.named_parameters():
  14.         if param.requires_grad==False:
  15.             print(name)

（5）定义损失函数

  1.  # #损失函数的定义
  2.     lossCIFAR10=torch.nn.CrossEntropyLoss()

（6）定义优化器

  1. # #定义优化器 https://blog.csdn.net/Wind_2028/article/details/120541017
  2.     learing_rate=0.001
  3.     optimizer=torch.optim.SGD([
  4.         {'params':modelResNet50.layer4.parameters(),'lr':learing_rate},
  5.         {'params':modelResNet50.avgpool.parameters(),'lr':learing_rate},
  6.         {'params':modelResNet50.fc.parameters(),'lr':learing_rate}
  7.     ],lr=learing_rate)

（7）模型保存和加载

  • 模型的保存方式：
    •  方式一：模型的结构+模型的参数
      •  torch.save(modelResNet50,'modelName.pth');
    •  方式二：模型的参数
      •  torch.save(modelResNet50.state_dict(),'modelName.pth');
  •   对应的模型加载方式：
    •  对应模型保存方式一：
      •  model=torch.load('modeName.pth');
    •  对应模型保存方式二：
      •  modelResNet50=torchvision.models.resnet50(pretrained=False);
        modelResNet50.load_state_dict(torch.load('modeName.pth'));
         

（8）训练开始

  1. # #迭代的次数
  2.     epoches=10
  3.  
  4.     #使用tensorboard显示训练过程
  5.     writer=SummaryWriter('logs')
  6.     #将损失值和准确率保存起来，用于最后画出图形
  7.     PlotTestLoss=[]
  8.     PlotTestCorrect=[]
  9.     PlotTrainLoss=[]
  10.     PlotTrainCorrect=[]
  11.  
  12.     for i in range(epoches):
  13.         # 训练的次数
  14.         trainStep = 0
  15.         #训练集上的准确率
  16.         trainCorrect=0
  17.         #训练集上的损失
  18.         trainLoss=0
  19.         traintotal=0
  20.         print('-----------------------第{}轮的训练--------------------------'.format(i+1))
  21.         #每一次迭代的训练
  22.         modelResNet50.train()
  23.         for traindata in trainDataLoader:
  24.             imgs,targets=traindata
  25.             # print(type(imgs)) =><class 'torch.Tensor'>
  26.             #输入模型，进行训练
  27.             output=modelResNet50(imgs)
  28.             # print(output)
  29.             # print(output.shape)
  30.             # 计算损失值
  31.             loss=lossCIFAR10(output,targets)
  32.             #优化器清零
  33.             optimizer.zero_grad()
  34.             #反向传播
  35.             loss.backward()
  36.             #梯度更新
  37.             optimizer.step()
  38.             #步数加一
  39.             trainStep=trainStep+1
  40.             with torch.no_grad():
  41.                 #获取预测概率最大值索引(按行计算最大)
  42.                 output=torch.argmax(input=output,dim=1)
  43.                 # print(output)=>tensor([2, 9, 6, 0])
  44.                 # print(output[0].item())=>2
  45.                 #计算准确率
  46.                 trainCorrect+=(output==targets).sum().item()
  47.                 traintotal+=imgs.shape[0]
  48.                 #计算总的损失
  49.                 trainLoss+=loss.item()
  50.                 if trainStep%50==0:
  51.                     print('-----------step: {}--------loss: {:.6f}---------correct: {:.6f}'.format(trainStep,trainLoss*1.0/traintotal,trainCorrect*1.0/traintotal))
  52.         writer.add_scalar(tag='trainLoss',scalar_value=trainLoss*1.0/traintotal,global_step=i+1)
  53.         writer.add_scalar(tag='correct',scalar_value=trainCorrect*1.0/traintotal,global_step=i+1)
  54.         #在tensorboard中绘制预测最优一步训练的output[0]结果图
  55.         writer.add_image(tag='train----{}.{:.4f}'.format(classes[output[0].item()],trainCorrect/traintotal),img_tensor=imgs[0],global_step=i+1)
  56.  
  57.         PlotTrainLoss.append(trainLoss * 1.0 / traintotal)
  58.         PlotTrainCorrect.append(trainCorrect * 1.0 / traintotal)
  59.         #在测试数据集上进行测试
  60.         testTotal=0
  61.         testCorrect=0
  62.         testLoss=0
  63.         #测试集上不需要梯度更新
  64.         modelResNet50.eval()
  65.         with torch.no_grad():
  66.             for data in testDataLoader:
  67.                 imgs,targets=data
  68.                 # 输入模型，进行训练
  69.                 output = modelResNet50(imgs)
  70.                 # 计算损失值
  71.                 loss = lossCIFAR10(output, targets)
  72.                 # 获取预测概率最大值索引(按行计算最大)
  73.                 output = torch.argmax(input=output, dim=1)
  74.                 # 计算准确率
  75.                 testCorrect += (output == targets).sum().item()
  76.                 testTotal += imgs.shape[0]
  77.                 # 计算总的损失
  78.                 testLoss += loss.item()
  79.             print('-----------test:--------loss: {:.6f}---------correct: {:.6f}'.format(testLoss * 1.0 / testTotal,
  80.                                                          testCorrect * 1.0 / testTotal))
  81.         writer.add_scalar(tag='testLoss', scalar_value=testLoss * 1.0 / testTotal, global_step=i + 1)
  82.         writer.add_image(tag='test----{}.{:.6f}'.format(classes[output[0].item()], testCorrect / testTotal),
  83.                          img_tensor=imgs[0], global_step=i + 1)
  84.  
  85.         PlotTestLoss.append(testLoss * 1.0 / testTotal)
  86.         PlotTestCorrect.append(testCorrect * 1.0 / testTotal)
  87.         #保运模型
  88.         torch.save(modelResNet50,'model/modelResNet50_{}.pth'.format(i))
  89.  
  90.     #使用matplotlib绘制图形
  91.     plt.plot(range(1,epoches+1),PlotTestLoss,label='trainLoss')
  92.     plt.plot(range(1, epoches + 1), PlotTestLoss, label='testLoss')
  93.     plt.legend()
  94.     plt.show()
  95.  
  96.     plt.plot(range(1, epoches + 1), PlotTrainCorrect, label='trainAcc')
  97.     plt.plot(range(1, epoches + 1), PlotTestCorrect, label='testAcc')
  98.     plt.legend()
  99.     plt.show()
  100.     writer.close()

（9）预测图片和实时检测

  

  1. """
  2. @Author : Keep_Trying_Go
  3. @Major  : Computer Science and Technology
  4. @Hobby  : Computer Vision
  5. @Time   : 2023-01-08 10:18
  6. """
  7.  
  8. import os
  9. import cv2
  10. import time
  11. import torch
  12. import numpy as np
  13. from PIL import Image
  14. from torchvision import datasets
  15. from torchvision import transforms
  16. from torch.utils.data import DataLoader,Dataset
  17.  
  18.  
  19. # 口罩数据集的类别名
  20. classes=['Mask', 'Non Mask']
  21. class_to_idx={'Mask': 0, 'Non Mask': 1}
  22.  
  23. # 数据变换
  24. transform = transforms.Compose([
  25.     transforms.Resize(size=(232, 232), interpolation=transforms.InterpolationMode.BILINEAR),
  26.     transforms.CenterCrop(size=(224, 224)),
  27.     transforms.ToTensor(),
  28.     transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
  29. ])
  30.  
  31. def predictImage(img_path):
  32.     """
  33.     :param img_path: 图片的路径
  34.     :return:
  35.     """
  36.     #读取图片
  37.     img=Image.open(img_path)
  38.     #图像处理
  39.     img_Transform=transform(img)
  40.     #对图像进行升维
  41.     img_Transform=torch.unsqueeze(input=img_Transform,dim=0)
  42.     #加载模型
  43.     modelResNet50=torch.load('model/modelResNet50_0.pth')
  44.     # print(modelResNet50)
  45.     #预测图片
  46.     predicts=modelResNet50(img_Transform)
  47.     #获取类别概率值
  48.     predicts=torch.nn.functional.softmax(predicts,dim=1)[0]
  49.     class_id=predicts.argmax()
  50.     print('predicts: {}'.format(predicts))
  51.     print('class_id: {}'.format(class_id))
  52.     print('预测概率: {:.4f}'.format(predicts[class_id].item()))
  53.     print('预测类别: {}'.format(classes[class_id]))
  54.  
  55. def timeDetect():
  56.     """
  57.     :return:
  58.     """
  59.     # 加载模型
  60.     modelResNet50 = torch.load('model/modelResNet50_0.pth')
  61.  
  62.     img1=cv2.imread('myDataset/real_00018.jpg')
  63.     print('img1.shape: {}'.format(img1.shape))
  64.     print('img1.type: {}'.format(type(img1)))
  65.     img2=Image.open('myDataset/real_00018.jpg')
  66.     print('img2.shape: {}'.format(np.shape(img2)))
  67.     print('img3.type: {}'.format(type(img2)))
  68.  
  69.     #计算开始时间
  70.     start_time=time.time()
  71.     #计算帧率
  72.     countFPS=0
  73.     #开启摄像头
  74.     cap = cv2.VideoCapture(0)
  75.     while cap.isOpened():
  76.         ret, frame = cap.read()
  77.         frame = cv2.resize(src=frame, dsize=(520, 520))
  78.         frame = cv2.flip(src=frame, flipCode=2)
  79.         frame_PIL=Image.fromarray(frame)
  80.         img_transform=transform(frame_PIL)
  81.         # 对图像进行升维
  82.         img_Transform = torch.unsqueeze(input=img_transform, dim=0)
  83.         # 预测图片
  84.         predicts = modelResNet50(img_Transform)
  85.         # 获取类别概率值
  86.         predicts = torch.nn.functional.softmax(predicts, dim=1)[0]
  87.         class_id = predicts.argmax()
  88.         end_time=time.time()
  89.         countFPS+=1
  90.         FPS=round(countFPS/(end_time-start_time),0)
  91.         text = classes[class_id] + ': ' + str('{:.4f}'.format(predicts[class_id].item()))
  92.         cv2.putText(img=frame, text='FPS: '+str(FPS), org=(10, 50),
  93.                     fontFace=cv2.FONT_HERSHEY_SIMPLEX,
  94.                     fontScale=1.0, color=(0, 255, 0), thickness=2)
  95.         cv2.putText(img=frame, text=text, org=(10, 80),
  96.                     fontFace=cv2.FONT_HERSHEY_SIMPLEX,
  97.                     fontScale=1.0, color=(0, 255, 0), thickness=2)
  98.         cv2.imshow('img', frame)
  99.         key = cv2.waitKey(1)
  100.         if key == 27:
  101.             break
  102.     cap.release()
  103.     cv2.destroyAllWindows()
  104.  
  105.  
  106. if __name__ == '__main__':
  107.     predictImage(img_path='myDataset/real_00018.jpg')
  108.     # timeDetect()

   

   

（10）打开tensorboard查看训练的过程

  

  

  

（11）训练好的模型下载

提示：以下三个模型是训练好的口罩检测的模型，读者可以自行下载模型，并使用上面给出的预测代码进行测试：

链接：modelResNet50_0.pth
提取码：uyu9

链接：modelResNet50_4.pth
提取码：8cnz

链接：modelResNet50_9.pth
提取码：p6wp

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/923438
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号