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

【Pytorch神经网络实战案例】25 （带数据增强）基于迁移学习识别多种鸟类（CUB-200数据集）_randaugmen 是什么

作者：知新_RL | 2024-03-16 10:46:32

赞

踩

randaugmen 是什么

1 数据增强

在目前分类效果最好的EficientNet系列模型中，EfficientNet-B7版本的模型就是使用随机数据增强方法训练而成的。

RandAugment方法也是目前主流的数据增强方法，用RandAugment方法进行训练，会使模型的精度得到提升。

2 RandAugment

2.1 RandAugment方法简介

RandAugment方法是一种新的数据增强方法，它比自动数据增强（AutOAugment）方法更简单、更好用。它可以在原有的训练框架中，直接对AutoAugment方法进行替换。

2.1.1 Tip

AuoAugment方法包含30多个参数，可以对图片数据进行各种变换（参见arXiv网站上编号为1805.09501的论文)。

2.2 RandAugment方法的构成

RandAugment方法是在AutoAugment方法的基础之上，将30多个参数进行策略级的优化管理，使这30多个参数被简化成两个参数：图片的N次变换和每次变换的强度M。其中每次变换的强度M，取值为0～10（只取整数)，表示使原有图片增强失真的大小。

RandAugment方法以结果为导向，使数据增强过程更加面向用。在减少AutoAugment的运算消耗的同时，又使增强的效果变得可控。详细内容可以参考相关论文(参见arXⅳ网站上编号为1909.13719的论文)。

2.2 代码获取

  1. https://github.com/heartInsert/randaugment
  2. # 只有一个代码文件Rand_Augment，py，将其下载后，直接引入代码即可使用。

3 本节案例（带有数据增强的识别）

3.1 案例简介

使用迁移学习对预训练模型进行微调的基础上实现数据增强，让其学习鸟类数据集，实现对多种鸟类进行识别。

3.2 代码实现：load_data函数加载图片名称与标签的加载----Transfer_bird2_Augmentation.py（第1部分）

  1. import glob
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt #plt 用于显示图片
  5. import torch
  6. import torch.nn as nn
  7. import torch.optim as optim
  8. from torch.optim import lr_scheduler
  9. from torch.utils.data import Dataset,DataLoader
  10. import torchvision
  11. import torchvision.models as model
  12. from torchvision.transforms import ToPILImage
  13. import torchvision.transforms as transforms
  14. import os
  15. os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
  16.  
  17. # 1.1 实现load_data函数加载图片名称与标签的加载，并使用torch.utils.data接口将其封装成程序可用的数据集类OwnDataset。
  18. def load_dir(directory,labstart=0): # 获取所有directory中的所有图与标签
  19.     # 返回path指定的文件夹所包含的文件或文件名的名称列表
  20.     strlabels = os.listdir(directory)
  21.     # 对标签进行排序，以便训练和验证按照相同的顺序进行:在不同的操作系统中，加载文件夹的顺序可能不同。目录不同的情况会导致在不同的操作系统中，模型的标签出现串位的现象。所以需要对文件夹进行排序，保证其顺序的一致性。
  22.     strlabels.sort()
  23.     # 创建文件标签列表
  24.     file_labels = []
  25.     for i,label in enumerate(strlabels):
  26.         print(label)
  27.         jpg_names = glob.glob(os.path.join(directory,label,"*.jpg"))
  28.         print(jpg_names)
  29.         # 加入列表
  30.         file_labels.extend(zip(jpg_names, [i + labstart] * len(jpg_names)))
  31.     return file_labels,strlabels
  32.  
  33. def load_data(dataset_path): # 定义函数load_data函数完成对数据集中图片文件名称和标签的加载。
  34.     # 该函数可以实现两层文件夹的嵌套结构。其中，外层结构使用load_data函数进行遍历，内层结构使用load_dir函进行遍历。
  35.     sub_dir = sorted(os.listdir(dataset_path)) # 跳过子文件夹:在不同的操作系统中，加载文件夹的顺序可能不同。目录不同的情况会导致在不同的操作系统中，模型的标签出现串位的现象。所以需要对文件夹进行排序，保证其顺序的一致性。
  36.     start = 1 # 第0类是none
  37.     tfile_lables,tstrlabels = [],['none'] # 在制作标签时，人为地在前面添加了一个序号为0的none类。这是一个训练图文类模型的技巧，为了区分模型输出值是0和预测值是0这两种情况。
  38.     for i in sub_dir:
  39.         directory = os.path.join(dataset_path,i)
  40.         if os.path.isdir(directory) == False: # 只处理文件夹中的数据
  41.             print(directory)
  42.             continue
  43.         file_labels,strlables = load_dir(directory,labstart=start)
  44.         tfile_lables.extend(file_labels)
  45.         tstrlabels.extend(strlables)
  46.         start = len(strlables)
  47.     # 将数据路径与标签解压缩,把数据路径和标签解压缩出来
  48.     filenames,labels = zip(*tfile_lables)
  49.     return filenames, labels, tstrlabels

3.3 代码实现：自定义数据集类OwnDataset----Transfer_bird2_Augmentation.py（第2部分）

  1. # 1.2 实现自定义数据集OwnDataset
  2. def default_loader(path) : # 定义函数加载图片
  3.     return Image.open(path).convert('RGB')
  4.  
  5. class OwnDataset(Dataset): # 复用性较强，可根据自己的数据集略加修改使用
  6.     # 在PyTorch中，提供了一个torch.utis.data接口，可以用来对数据集进行封装。在实现时，只需要继承torch.utis.data.Dataset类，并重载其__gettem__方法。
  7.     # 在使用时，框架会向__gettem__方法传入索引index，在__gettem__方法内部根据指定index加载数据，并返回。
  8.     def __init__(self,img_dir,labels,indexlist=None,transform=transforms.ToTensor(),loader=default_loader,cache=True): # 初始化
  9.         self.labels = labels # 存放标签
  10.         self.img_dir = img_dir # 样本图片文件名
  11.         self.transform = transform # 预处理方法
  12.         self.loader = loader # 加载方法
  13.         self.cache = cache # 缓存标志
  14.         if indexlist is None: # 要加载的数据序列
  15.             self.indexlist = list(range(len(self.img_dir)))
  16.         else:
  17.             self.indexlist = indexlist
  18.         self.data = [None] * len(self.indexlist) # 存放样本图片
  19.  
  20.     def __getitem__(self, idx): # 加载指定索引数据
  21.         if self.data[idx] is None: # 第一次加载
  22.             data = self.loader(self.img_dir[self.indexlist[idx]])
  23.             if self.transform:
  24.                 data = self.transform(data)
  25.         else:
  26.             data = self.data[idx]
  27.         if self.cache: # 保存到缓存里
  28.             self.data[idx] = data
  29.         return data,self.labels[self.indexlist[idx]]
  30.  
  31.     def __len__(self): # 计算数据集长度
  32.         return len(self.indexlist)

3.4 代码实战：测试数据集----Transfer_bird2_Augmentation.py（第3部分）【数据增强模块】

  1. # 1.3 测试数据集：在完成数据集的制作之后，编写代码对其进行测试。
  2. # 数据增强模块
  3. from Rand_Augment import  Rand_Augment
  4. data_transform = { #定义数据的预处理方法
  5.     'train':transforms.Compose([
  6.         Rand_Augment(), # 数据增强的方法带入 仅此一处修改
  7.         transforms.RandomResizedCrop(224),
  8.         transforms.RandomHorizontalFlip(),
  9.         transforms.ToTensor(),
  10.         transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
  11.     ]),
  12.     'val':transforms.Compose([
  13.         transforms.Resize(256),
  14.         transforms.CenterCrop(224),
  15.         transforms.ToTensor(),
  16.         transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
  17.     ]),
  18. }
  19. def Reduction_img(tensor,mean,std): #还原图片，实现了图片归一化的逆操作，显示数据集中的原始图片。
  20.     dtype = tensor.dtype
  21.     mean = torch.as_tensor(mean,dtype=dtype,device=tensor.device)
  22.     std = torch.as_tensor(std,dtype=dtype,device=tensor.device)
  23.     tensor.mul_(std[:,None,None]).add_(mean[:,None,None]) # 还原操作
  24.  
  25. dataset_path = r'./data/cub200/' # 加载数据集路径
  26. filenames,labels,classes = load_data(dataset_path) # 调用load_data函数对数据集中图片文件名称和标签进行加载，其返回对象classes中包含全部的类名。
  27. # 打乱数据顺序
  28. # 110-115行对数据文件列表的序号进行乱序划分，分为测试数据集和训练数集两个索引列表。该索引列表会传入OwnDataset类做成指定的数据集。
  29. np.random.seed(0)
  30. label_shuffle_index = np.random.permutation(len(labels))
  31. label_train_num = (len(labels)//10) * 8 # 划分训练数据集和测试数据集
  32. train_list = label_shuffle_index[0:label_train_num]
  33. test_list = label_shuffle_index[label_train_num:] # 没带：
  34.  
  35. train_dataset = OwnDataset(filenames,labels,train_list,data_transform['train'])# 实例化训练数据集
  36. val_dataset = OwnDataset(filenames,labels,test_list,data_transform['val']) # 实例化测试数据集
  37. # 实例化批次数据集：OwnDataset类所定义的数据集，其使用方法与PyTorch中的内置数据集的使用方法完全一致，配合DataLoader接口即可生成可以进行训练或测试的批次数据。具体代码如下。
  38. train_loader = DataLoader(dataset=train_dataset,batch_size=32,shuffle=True)
  39. val_loader = DataLoader(dataset=val_dataset,batch_size=32,shuffle=True)
  40.  
  41. sample = iter(train_loader) # 获取一批次数据，进行测试
  42. images,labels = sample.next()
  43. print("样本形状",np.shape(images))
  44. print("标签个数",len(classes))
  45. mulimgs = torchvision.utils.make_grid(images[:10],nrow=10) # 拼接多张图片
  46. Reduction_img(mulimgs,[0.485,0.456,0.406],[0.229,0.224,0.225])
  47. _img = ToPILImage()(mulimgs) # 将张量转化为图片
  48. plt.axis('off')
  49. plt.imshow(_img) # 显示
  50. plt.show()
  51. print(','.join('%5s' % classes[labels[j]] for j in range(len(images[:10]))))

输出：

样本形状 torch.Size([32, 3, 224, 224])
标签个数 6

输出数据集中的10个图片

3.5 代码实战：获取并改造ResNet模型----Transfer_bird2_Augmentation.py（第4部分）

  1. # 1.4 获取并改造ResNet模型：获取ResNet模型，并加载预训练模型的权重。将其最后一层（输出层）去掉，换成一个全新的全连接层，该全连接层的输出节点数与本例分类数相同。
  2. # 指定设备
  3. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  4. print(device)
  5. # get_ResNet函数，获取预训练模型，可指定pretrained=True来实现自动下载预训练模型，也可指定loadfile来从本地路径加载预训练模型。
  6. def get_ResNet(classes,pretrained=True,loadfile=None):
  7.     ResNet = model.resnet101(pretrained) # 自动下载官方的预训练模型
  8.     if loadfile != None:
  9.         ResNet.load_state_dict(torch.load(loadfile)) # 加载本地模型
  10.     # 将所有的参数层进行冻结：设置模型仅最后一层可以进行训练，使模型只针对最后一层进行微调。
  11.     for param in ResNet.parameters():
  12.         param.requires_grad = False
  13.     # 输出全连接层的信息
  14.     print(ResNet.fc)
  15.     x = ResNet.fc.in_features # 获取全连接层的输入
  16.     ResNet.fc = nn.Linear(x,len(classes)) # 定义一个新的全连接层
  17.     print(ResNet.fc) # 最后输出新的模型
  18.     return ResNet
  19. ResNet = get_ResNet(classes) # 实例化模型
  20. ResNet.to(device=device)

3.6 代码实战：定义损失函数、训练函数及测试函数，对模型的最后一层进行微调----Transfer_bird2_Augmentation.py（第5部分）

  1. # 1.5 定义损失函数、训练函数及测试函数，对模型的最后一层进行微调。
  2. criterion = nn.CrossEntropyLoss()
  3. # 指定新加的全连接层的学习率
  4. optimizer = torch.optim.Adam([{'params':ResNet.fc.parameters()}],lr=0.01)
  5. def train(model,device,train_loader,epoch,optimizer): # 定义训练函数
  6.     model.train()
  7.     allloss = []
  8.     for batch_idx,data in enumerate(train_loader):
  9.         x,y = data
  10.         x = x.to(device)
  11.         y = y.to(device)
  12.         optimizer.zero_grad()
  13.         y_hat = model(x)
  14.         loss = criterion(y_hat,y)
  15.         loss.backward()
  16.         allloss.append(loss.item())
  17.         optimizer.step()
  18.     print('Train Epoch:{}\t Loss:{:.6f}'.format(epoch,np.mean(allloss))) # 输出训练结果
  19.  
  20. def test(model,device,val_loader): # 定义测试函数
  21.     model.eval()
  22.     test_loss = []
  23.     correct = []
  24.     with torch.no_grad(): # 使模型在运行时不进行梯度跟踪，可以减少模型运行时对内存的占用。
  25.         for i,data in enumerate(val_loader):
  26.             x, y = data
  27.             x = x.to(device)
  28.             y = y.to(device)
  29.             y_hat = model(x)
  30.             test_loss.append(criterion(y_hat,y).item()) # 收集损失函数
  31.             pred = y_hat.max(1,keepdim=True)[1] # 获取预测结果
  32.             correct.append(pred.eq(y.view_as(pred)).sum().item()/pred.shape[0]) # 收集精确度
  33.     print('\nTest:Average loss:{:,.4f},Accuracy:({:,.0f}%)\n'.format(np.mean(test_loss),np.mean(correct)*100)) # 输出测试结果
  34.  
  35. # 迁移学习的两个步骤如下
  36. if __name__ == '__main__':
  37. # 迁移学习步骤①：固定预训练模型的特征提取部分，只对最后一层进行训练，使其快速收敛。
  38.     firstmodepth = './data/cub200/firstmodepth_1.pth' # 定义模型文件的地址
  39.     if os.path.exists(firstmodepth) == False:
  40.         print("—————————固定预训练模型的特征提取部分，只对最后一层进行训练，使其快速收敛—————————")
  41.         for epoch in range(1,2): # 迭代两次
  42.             train(ResNet,device,train_loader,epoch,optimizer)
  43.             test(ResNet,device,val_loader)
  44.         # 保存模型
  45.         torch.save(ResNet.state_dict(),firstmodepth)

3.7 代码实战：使用退化学习率对模型进行全局微调----Transfer_bird2_Augmentation.py（第6部分）

  1. # 1.6 使用退化学习率对模型进行全局微调
  2. #迁移学习步骤②：使用较小的学习率，对全部模型进行训练，并对每层的权重进行细微的调节，即将模型的每层权重都设为可训练，并定义带有退化学习率的优化器。（1.6部分）
  3.     secondmodepth = './data/cub200/firstmodepth_2.pth'
  4.     optimizer2 = optim.SGD(ResNet.parameters(),lr=0.001,momentum=0.9) # 第198行代码定义带有退化学习率的SGD优化器。该优化器常用来对模型进行手动微调。有实验表明，使用经过手动调节的SGD优化器，在训练模型的后期效果优于Adam优化器。
  5.     exp_lr_scheduler = lr_scheduler.StepLR(optimizer2,step_size=2,gamma=0.9) # 由于退化学习率会在训练过程中不断地变小，为了防止学习率过小，最终无法进行权重需要对其设置最小值。当学习率低于该值时，停止对退化学习率的操作。
  6.     for param in ResNet.parameters(): # 所有参数设计为可训练
  7.         param.requires_grad = True
  8.     if os.path.exists(secondmodepth):
  9.         ResNet.load_state_dict(torch.load(secondmodepth)) # 加载本地模型
  10.     else:
  11.         ResNet.load_state_dict(torch.load(firstmodepth)) # 加载本地模型
  12.     print("____使用较小的学习率，对全部模型进行训练，定义带有退化学习率的优化器______")
  13.     for epoch in range(1,100):
  14.         train(ResNet,device,train_loader,epoch,optimizer2)
  15.         if optimizer2.state_dict()['param_groups'][0]['lr'] > 0.00001:
  16.             exp_lr_scheduler.step()
  17.             print("___lr:",optimizer2.state_dict()['param_groups'][0]['lr'])
  18.         test(ResNet,device,val_loader)
  19.     # 保存模型
  20.     torch.save(ResNet.state_dict(),secondmodepth)

4 代码总览Transfer_bird2_Augmentation.py

  1. import glob
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt #plt 用于显示图片
  5. import torch
  6. import torch.nn as nn
  7. import torch.optim as optim
  8. from torch.optim import lr_scheduler
  9. from torch.utils.data import Dataset,DataLoader
  10. import torchvision
  11. import torchvision.models as model
  12. from torchvision.transforms import ToPILImage
  13. import torchvision.transforms as transforms
  14. import os
  15. os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
  16.  
  17. # 1.1 实现load_data函数加载图片名称与标签的加载，并使用torch.utils.data接口将其封装成程序可用的数据集类OwnDataset。
  18. def load_dir(directory,labstart=0): # 获取所有directory中的所有图与标签
  19.     # 返回path指定的文件夹所包含的文件或文件名的名称列表
  20.     strlabels = os.listdir(directory)
  21.     # 对标签进行排序，以便训练和验证按照相同的顺序进行:在不同的操作系统中，加载文件夹的顺序可能不同。目录不同的情况会导致在不同的操作系统中，模型的标签出现串位的现象。所以需要对文件夹进行排序，保证其顺序的一致性。
  22.     strlabels.sort()
  23.     # 创建文件标签列表
  24.     file_labels = []
  25.     for i,label in enumerate(strlabels):
  26.         print(label)
  27.         jpg_names = glob.glob(os.path.join(directory,label,"*.jpg"))
  28.         print(jpg_names)
  29.         # 加入列表
  30.         file_labels.extend(zip(jpg_names, [i + labstart] * len(jpg_names)))
  31.     return file_labels,strlabels
  32.  
  33. def load_data(dataset_path): # 定义函数load_data函数完成对数据集中图片文件名称和标签的加载。
  34.     # 该函数可以实现两层文件夹的嵌套结构。其中，外层结构使用load_data函数进行遍历，内层结构使用load_dir函进行遍历。
  35.     sub_dir = sorted(os.listdir(dataset_path)) # 跳过子文件夹:在不同的操作系统中，加载文件夹的顺序可能不同。目录不同的情况会导致在不同的操作系统中，模型的标签出现串位的现象。所以需要对文件夹进行排序，保证其顺序的一致性。
  36.     start = 1 # 第0类是none
  37.     tfile_lables,tstrlabels = [],['none'] # 在制作标签时，人为地在前面添加了一个序号为0的none类。这是一个训练图文类模型的技巧，为了区分模型输出值是0和预测值是0这两种情况。
  38.     for i in sub_dir:
  39.         directory = os.path.join(dataset_path,i)
  40.         if os.path.isdir(directory) == False: # 只处理文件夹中的数据
  41.             print(directory)
  42.             continue
  43.         file_labels,strlables = load_dir(directory,labstart=start)
  44.         tfile_lables.extend(file_labels)
  45.         tstrlabels.extend(strlables)
  46.         start = len(strlables)
  47.     # 将数据路径与标签解压缩,把数据路径和标签解压缩出来
  48.     filenames,labels = zip(*tfile_lables)
  49.     return filenames, labels, tstrlabels
  50.  
  51. # 1.2 实现自定义数据集OwnDataset
  52. def default_loader(path) : # 定义函数加载图片
  53.     return Image.open(path).convert('RGB')
  54.  
  55. class OwnDataset(Dataset): # 复用性较强，可根据自己的数据集略加修改使用
  56.     # 在PyTorch中，提供了一个torch.utis.data接口，可以用来对数据集进行封装。在实现时，只需要继承torch.utis.data.Dataset类，并重载其__gettem__方法。
  57.     # 在使用时，框架会向__gettem__方法传入索引index，在__gettem__方法内部根据指定index加载数据，并返回。
  58.     def __init__(self,img_dir,labels,indexlist=None,transform=transforms.ToTensor(),loader=default_loader,cache=True): # 初始化
  59.         self.labels = labels # 存放标签
  60.         self.img_dir = img_dir # 样本图片文件名
  61.         self.transform = transform # 预处理方法
  62.         self.loader = loader # 加载方法
  63.         self.cache = cache # 缓存标志
  64.         if indexlist is None: # 要加载的数据序列
  65.             self.indexlist = list(range(len(self.img_dir)))
  66.         else:
  67.             self.indexlist = indexlist
  68.         self.data = [None] * len(self.indexlist) # 存放样本图片
  69.  
  70.     def __getitem__(self, idx): # 加载指定索引数据
  71.         if self.data[idx] is None: # 第一次加载
  72.             data = self.loader(self.img_dir[self.indexlist[idx]])
  73.             if self.transform:
  74.                 data = self.transform(data)
  75.         else:
  76.             data = self.data[idx]
  77.         if self.cache: # 保存到缓存里
  78.             self.data[idx] = data
  79.         return data,self.labels[self.indexlist[idx]]
  80.  
  81.     def __len__(self): # 计算数据集长度
  82.         return len(self.indexlist)
  83.  
  84. # 1.3 测试数据集：在完成数据集的制作之后，编写代码对其进行测试。
  85. # 数据增强模块
  86. from Rand_Augment import  Rand_Augment
  87. data_transform = { #定义数据的预处理方法
  88.     'train':transforms.Compose([
  89.         Rand_Augment(), # 数据增强的方法带入 仅此一处修改
  90.         transforms.RandomResizedCrop(224),
  91.         transforms.RandomHorizontalFlip(),
  92.         transforms.ToTensor(),
  93.         transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
  94.     ]),
  95.     'val':transforms.Compose([
  96.         transforms.Resize(256),
  97.         transforms.CenterCrop(224),
  98.         transforms.ToTensor(),
  99.         transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
  100.     ]),
  101. }
  102. def Reduction_img(tensor,mean,std): #还原图片，实现了图片归一化的逆操作，显示数据集中的原始图片。
  103.     dtype = tensor.dtype
  104.     mean = torch.as_tensor(mean,dtype=dtype,device=tensor.device)
  105.     std = torch.as_tensor(std,dtype=dtype,device=tensor.device)
  106.     tensor.mul_(std[:,None,None]).add_(mean[:,None,None]) # 还原操作
  107.  
  108. dataset_path = r'./data/cub200/' # 加载数据集路径
  109. filenames,labels,classes = load_data(dataset_path) # 调用load_data函数对数据集中图片文件名称和标签进行加载，其返回对象classes中包含全部的类名。
  110. # 打乱数据顺序
  111. # 110-115行对数据文件列表的序号进行乱序划分，分为测试数据集和训练数集两个索引列表。该索引列表会传入OwnDataset类做成指定的数据集。
  112. np.random.seed(0)
  113. label_shuffle_index = np.random.permutation(len(labels))
  114. label_train_num = (len(labels)//10) * 8 # 划分训练数据集和测试数据集
  115. train_list = label_shuffle_index[0:label_train_num]
  116. test_list = label_shuffle_index[label_train_num:] # 没带：
  117.  
  118. train_dataset = OwnDataset(filenames,labels,train_list,data_transform['train'])# 实例化训练数据集
  119. val_dataset = OwnDataset(filenames,labels,test_list,data_transform['val']) # 实例化测试数据集
  120. # 实例化批次数据集：OwnDataset类所定义的数据集，其使用方法与PyTorch中的内置数据集的使用方法完全一致，配合DataLoader接口即可生成可以进行训练或测试的批次数据。具体代码如下。
  121. train_loader = DataLoader(dataset=train_dataset,batch_size=32,shuffle=True)
  122. val_loader = DataLoader(dataset=val_dataset,batch_size=32,shuffle=True)
  123.  
  124. sample = iter(train_loader) # 获取一批次数据，进行测试
  125. images,labels = sample.next()
  126. print("样本形状",np.shape(images))
  127. print("标签个数",len(classes))
  128. mulimgs = torchvision.utils.make_grid(images[:10],nrow=10) # 拼接多张图片
  129. Reduction_img(mulimgs,[0.485,0.456,0.406],[0.229,0.224,0.225])
  130. _img = ToPILImage()(mulimgs) # 将张量转化为图片
  131. plt.axis('off')
  132. plt.imshow(_img) # 显示
  133. plt.show()
  134. print(','.join('%5s' % classes[labels[j]] for j in range(len(images[:10]))))
  135.  
  136. # 1.4 获取并改造ResNet模型：获取ResNet模型，并加载预训练模型的权重。将其最后一层（输出层）去掉，换成一个全新的全连接层，该全连接层的输出节点数与本例分类数相同。
  137. # 指定设备
  138. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  139. print(device)
  140. # get_ResNet函数，获取预训练模型，可指定pretrained=True来实现自动下载预训练模型，也可指定loadfile来从本地路径加载预训练模型。
  141. def get_ResNet(classes,pretrained=True,loadfile=None):
  142.     ResNet = model.resnet101(pretrained) # 自动下载官方的预训练模型
  143.     if loadfile != None:
  144.         ResNet.load_state_dict(torch.load(loadfile)) # 加载本地模型
  145.     # 将所有的参数层进行冻结：设置模型仅最后一层可以进行训练，使模型只针对最后一层进行微调。
  146.     for param in ResNet.parameters():
  147.         param.requires_grad = False
  148.     # 输出全连接层的信息
  149.     print(ResNet.fc)
  150.     x = ResNet.fc.in_features # 获取全连接层的输入
  151.     ResNet.fc = nn.Linear(x,len(classes)) # 定义一个新的全连接层
  152.     print(ResNet.fc) # 最后输出新的模型
  153.     return ResNet
  154. ResNet = get_ResNet(classes) # 实例化模型
  155. ResNet.to(device=device)
  156.  
  157. # 1.5 定义损失函数、训练函数及测试函数，对模型的最后一层进行微调。
  158. criterion = nn.CrossEntropyLoss()
  159. # 指定新加的全连接层的学习率
  160. optimizer = torch.optim.Adam([{'params':ResNet.fc.parameters()}],lr=0.01)
  161. def train(model,device,train_loader,epoch,optimizer): # 定义训练函数
  162.     model.train()
  163.     allloss = []
  164.     for batch_idx,data in enumerate(train_loader):
  165.         x,y = data
  166.         x = x.to(device)
  167.         y = y.to(device)
  168.         optimizer.zero_grad()
  169.         y_hat = model(x)
  170.         loss = criterion(y_hat,y)
  171.         loss.backward()
  172.         allloss.append(loss.item())
  173.         optimizer.step()
  174.     print('Train Epoch:{}\t Loss:{:.6f}'.format(epoch,np.mean(allloss))) # 输出训练结果
  175.  
  176. def test(model,device,val_loader): # 定义测试函数
  177.     model.eval()
  178.     test_loss = []
  179.     correct = []
  180.     with torch.no_grad(): # 使模型在运行时不进行梯度跟踪，可以减少模型运行时对内存的占用。
  181.         for i,data in enumerate(val_loader):
  182.             x, y = data
  183.             x = x.to(device)
  184.             y = y.to(device)
  185.             y_hat = model(x)
  186.             test_loss.append(criterion(y_hat,y).item()) # 收集损失函数
  187.             pred = y_hat.max(1,keepdim=True)[1] # 获取预测结果
  188.             correct.append(pred.eq(y.view_as(pred)).sum().item()/pred.shape[0]) # 收集精确度
  189.     print('\nTest:Average loss:{:,.4f},Accuracy:({:,.0f}%)\n'.format(np.mean(test_loss),np.mean(correct)*100)) # 输出测试结果
  190.  
  191. # 迁移学习的两个步骤如下
  192. if __name__ == '__main__':
  193. # 迁移学习步骤①：固定预训练模型的特征提取部分，只对最后一层进行训练，使其快速收敛。
  194.     firstmodepth = './data/cub200/firstmodepth_1.pth' # 定义模型文件的地址
  195.     if os.path.exists(firstmodepth) == False:
  196.         print("—————————固定预训练模型的特征提取部分，只对最后一层进行训练，使其快速收敛—————————")
  197.         for epoch in range(1,2): # 迭代两次
  198.             train(ResNet,device,train_loader,epoch,optimizer)
  199.             test(ResNet,device,val_loader)
  200.         # 保存模型
  201.         torch.save(ResNet.state_dict(),firstmodepth)
  202. # 1.6 使用退化学习率对模型进行全局微调
  203. #迁移学习步骤②：使用较小的学习率，对全部模型进行训练，并对每层的权重进行细微的调节，即将模型的每层权重都设为可训练，并定义带有退化学习率的优化器。（1.6部分）
  204.     secondmodepth = './data/cub200/firstmodepth_2.pth'
  205.     optimizer2 = optim.SGD(ResNet.parameters(),lr=0.001,momentum=0.9) # 第198行代码定义带有退化学习率的SGD优化器。该优化器常用来对模型进行手动微调。有实验表明，使用经过手动调节的SGD优化器，在训练模型的后期效果优于Adam优化器。
  206.     exp_lr_scheduler = lr_scheduler.StepLR(optimizer2,step_size=2,gamma=0.9) # 由于退化学习率会在训练过程中不断地变小，为了防止学习率过小，最终无法进行权重需要对其设置最小值。当学习率低于该值时，停止对退化学习率的操作。
  207.     for param in ResNet.parameters(): # 所有参数设计为可训练
  208.         param.requires_grad = True
  209.     if os.path.exists(secondmodepth):
  210.         ResNet.load_state_dict(torch.load(secondmodepth)) # 加载本地模型
  211.     else:
  212.         ResNet.load_state_dict(torch.load(firstmodepth)) # 加载本地模型
  213.     print("____使用较小的学习率，对全部模型进行训练，定义带有退化学习率的优化器______")
  214.     for epoch in range(1,100):
  215.         train(ResNet,device,train_loader,epoch,optimizer2)
  216.         if optimizer2.state_dict()['param_groups'][0]['lr'] > 0.00001:
  217.             exp_lr_scheduler.step()
  218.             print("___lr:",optimizer2.state_dict()['param_groups'][0]['lr'])
  219.         test(ResNet,device,val_loader)
  220.     # 保存模型
  221.     torch.save(ResNet.state_dict(),secondmodepth)

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

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

  

闽ICP备14008679号