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

ResNet训练四种天气分类模型_识别图片季节和白天或晚上的大模型

作者：2023面试高手 | 2024-05-17 04:23:02

赞

踩

识别图片季节和白天或晚上的大模型

任务：训练图片分类模型，将雨，雪，雾，晴天四种天气图像分类

参考文章：CNN经典网络模型（五）：ResNet简介及代码实现（PyTorch超详细注释版）

目录

1.数据集准备

2.模型

3.训练

4.测试

1.数据集准备

数据集中有四种天气图像，每一类都有10000张图片，将其分好类放在不同的文件夹下。建立image文件夹如下：

  • spilit_data.py：划分给定的数据集为训练集和测试集
  1. import os
  2. from shutil import copy, rmtree
  3. import random
  4.  
  5.  
  6. def mk_file(file_path: str):
  7.     if os.path.exists(file_path):
  8.         # 如果文件夹存在，则先删除原文件夹再重新创建
  9.         rmtree(file_path)
  10.     os.makedirs(file_path)
  11.  
  12.  
  13. def main():
  14.     # 保证随机可复现
  15.     random.seed(0)
  16.  
  17.     # 将数据集中10%的数据划分到验证集中
  18.     split_rate = 0.1
  19.  
  20.     # 指向解压后的flower_photos文件夹
  21.     # getcwd()：该函数不需要传递参数，获得当前所运行脚本的路径
  22.     cwd = os.getcwd()
  23.     # join()：用于拼接文件路径，可以传入多个路径
  24.     data_root = os.path.join(cwd, "")
  25.     origin_flower_path = os.path.join(data_root, "image")
  26.     # 确定路径存在，否则反馈错误
  27.     assert os.path.exists(origin_flower_path), "path '{}' does not exist.".format(origin_flower_path)
  28.     # isdir()：判断某一路径是否为目录
  29.     # listdir()：返回指定的文件夹包含的文件或文件夹的名字的列表
  30.     flower_class = [cla for cla in os.listdir(origin_flower_path)
  31.                     if os.path.isdir(os.path.join(origin_flower_path, cla))]
  32.  
  33.     # 创建训练集train文件夹，并由类名在其目录下创建子目录
  34.     train_root = os.path.join(data_root, "/data/train")
  35.     mk_file(train_root)
  36.     for cla in flower_class:
  37.         # 建立每个类别对应的文件夹
  38.         mk_file(os.path.join(train_root, cla))
  39.  
  40.     # 创建验证集val文件夹，并由类名在其目录下创建子目录
  41.     val_root = os.path.join(data_root, "/data/val")
  42.     mk_file(val_root)
  43.     for cla in flower_class:
  44.         # 建立每个类别对应的文件夹
  45.         mk_file(os.path.join(val_root, cla))
  46.  
  47.     # 遍历所有类别的图像并按比例分成训练集和验证集
  48.     for cla in flower_class:
  49.         cla_path = os.path.join(origin_flower_path, cla)
  50.         # iamges列表存储了该目录下所有图像的名称
  51.         images = os.listdir(cla_path)
  52.         num = len(images)
  53.         # 随机采样验证集的索引
  54.         # 从images列表中随机抽取k个图像名称
  55.         # random.sample：用于截取列表的指定长度的随机数，返回列表
  56.         # eval_index保存验证集val的图像名称
  57.         eval_index = random.sample(images, k=int(num*split_rate))
  58.         for index, image in enumerate(images):
  59.             if image in eval_index:
  60.                 # 将分配至验证集中的文件复制到相应目录
  61.                 image_path = os.path.join(cla_path, image)
  62.                 new_path = os.path.join(val_root, cla)
  63.                 copy(image_path, new_path)
  64.             else:
  65.                 # 将分配至训练集中的文件复制到相应目录
  66.                 image_path = os.path.join(cla_path, image)
  67.                 new_path = os.path.join(train_root, cla)
  68.                 copy(image_path, new_path)
  69.                 # '\r'回车，回到当前行的行首，而不会换到下一行，如果接着输出，本行以前的内容会被逐一覆盖
  70.                 # end=""：将print自带的换行用end中指定的str代替
  71.             print("\r[{}] processing [{}/{}]".format(cla, index+1, num), end="")
  72.         print()
  73.  
  74.     print("processing done!")
  75.  
  76.  
  77. if __name__ == '__main__':
  78.     main()

 运行后得到划分好的训练集和测试集

2.模型

  • model.py ：定义ResNet网络模型
  1. import torch.nn as nn
  2. import torch
  3.  
  4.  
  5. # 定义ResNet18/34的残差结构，为2个3x3的卷积
  6. class BasicBlock(nn.Module):
  7.     # 判断残差结构中，主分支的卷积核个数是否发生变化，不变则为1
  8.     expansion = 1
  9.  
  10.     # init()：进行初始化，申明模型中各层的定义
  11.     # downsample=None对应实线残差结构，否则为虚线残差结构
  12.     def __init__(self, in_channel, out_channel, stride=1, downsample=None, **kwargs):
  13.         super(BasicBlock, self).__init__()
  14.         self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
  15.                                kernel_size=3, stride=stride, padding=1, bias=False)
  16.         # 使用批量归一化
  17.         self.bn1 = nn.BatchNorm2d(out_channel)
  18.         # 使用ReLU作为激活函数
  19.         self.relu = nn.ReLU()
  20.         self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
  21.                                kernel_size=3, stride=1, padding=1, bias=False)
  22.         self.bn2 = nn.BatchNorm2d(out_channel)
  23.         self.downsample = downsample
  24.  
  25.     # forward()：定义前向传播过程,描述了各层之间的连接关系
  26.     def forward(self, x):
  27.         # 残差块保留原始输入
  28.         identity = x
  29.         # 如果是虚线残差结构，则进行下采样
  30.         if self.downsample is not None:
  31.             identity = self.downsample(x)
  32.  
  33.         out = self.conv1(x)
  34.         out = self.bn1(out)
  35.         out = self.relu(out)
  36.         # -----------------------------------------
  37.         out = self.conv2(out)
  38.         out = self.bn2(out)
  39.         # 主分支与shortcut分支数据相加
  40.         out += identity
  41.         out = self.relu(out)
  42.  
  43.         return out
  44.  
  45.  
  46. # 定义ResNet50/101/152的残差结构，为1x1+3x3+1x1的卷积
  47. class Bottleneck(nn.Module):
  48.     # expansion是指在每个小残差块内，减小尺度增加维度的倍数，如64*4=256
  49.     # Bottleneck层输出通道是输入的4倍
  50.     expansion = 4
  51.  
  52.     # init()：进行初始化，申明模型中各层的定义
  53.     # downsample=None对应实线残差结构，否则为虚线残差结构，专门用来改变x的通道数
  54.     def __init__(self, in_channel, out_channel, stride=1, downsample=None,
  55.                  groups=1, width_per_group=64):
  56.         super(Bottleneck, self).__init__()
  57.  
  58.         width = int(out_channel * (width_per_group / 64.)) * groups
  59.  
  60.         self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width,
  61.                                kernel_size=1, stride=1, bias=False)
  62.         # 使用批量归一化
  63.         self.bn1 = nn.BatchNorm2d(width)
  64.         # -----------------------------------------
  65.         self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, groups=groups,
  66.                                kernel_size=3, stride=stride, bias=False, padding=1)
  67.         self.bn2 = nn.BatchNorm2d(width)
  68.         # -----------------------------------------
  69.         self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel * self.expansion,
  70.                                kernel_size=1, stride=1, bias=False)
  71.         self.bn3 = nn.BatchNorm2d(out_channel * self.expansion)
  72.         # 使用ReLU作为激活函数
  73.         self.relu = nn.ReLU(inplace=True)
  74.         self.downsample = downsample
  75.  
  76.     # forward()：定义前向传播过程,描述了各层之间的连接关系
  77.     def forward(self, x):
  78.         # 残差块保留原始输入
  79.         identity = x
  80.         # 如果是虚线残差结构，则进行下采样
  81.         if self.downsample is not None:
  82.             identity = self.downsample(x)
  83.  
  84.         out = self.conv1(x)
  85.         out = self.bn1(out)
  86.         out = self.relu(out)
  87.  
  88.         out = self.conv2(out)
  89.         out = self.bn2(out)
  90.         out = self.relu(out)
  91.  
  92.         out = self.conv3(out)
  93.         out = self.bn3(out)
  94.         # 主分支与shortcut分支数据相加
  95.         out += identity
  96.         out = self.relu(out)
  97.  
  98.         return out
  99.  
  100.  
  101. # 定义ResNet类
  102. class ResNet(nn.Module):
  103.     # 初始化函数
  104.     def __init__(self,
  105.                  block,
  106.                  blocks_num,
  107.                  num_classes=4,
  108.                  include_top=True,
  109.                  groups=1,
  110.                  width_per_group=64):
  111.         super(ResNet, self).__init__()
  112.         self.include_top = include_top
  113.         # maxpool的输出通道数为64，残差结构输入通道数为64
  114.         self.in_channel = 64
  115.  
  116.         self.groups = groups
  117.         self.width_per_group = width_per_group
  118.  
  119.         self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,
  120.                                padding=3, bias=False)
  121.         self.bn1 = nn.BatchNorm2d(self.in_channel)
  122.         self.relu = nn.ReLU(inplace=True)
  123.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
  124.         # 浅层的stride=1，深层的stride=2
  125.         # block：定义的两种残差模块
  126.         # block_num：模块中残差块的个数
  127.         self.layer1 = self._make_layer(block, 64, blocks_num[0])
  128.         self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)
  129.         self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)
  130.         self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)
  131.         if self.include_top:
  132.             # 自适应平均池化，指定输出（H，W），通道数不变
  133.             self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
  134.             # 全连接层
  135.             self.fc = nn.Linear(512 * block.expansion, num_classes)
  136.         # 遍历网络中的每一层
  137.         # 继承nn.Module类中的一个方法:self.modules(), 他会返回该网络中的所有modules
  138.         for m in self.modules():
  139.             # isinstance(object, type)：如果指定对象是指定类型，则isinstance()函数返回True
  140.             # 如果是卷积层
  141.             if isinstance(m, nn.Conv2d):
  142.                 # kaiming正态分布初始化，使得Conv2d卷积层反向传播的输出的方差都为1
  143.                 # fan_in：权重是通过线性层（卷积或全连接）隐性确定
  144.                 # fan_out：通过创建随机矩阵显式创建权重
  145.                 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
  146.  
  147.     # 定义残差模块，由若干个残差块组成
  148.     # block：定义的两种残差模块，channel：该模块中所有卷积层的基准通道数。block_num：模块中残差块的个数
  149.     def _make_layer(self, block, channel, block_num, stride=1):
  150.         downsample = None
  151.         # 如果满足条件，则是虚线残差结构
  152.         if stride != 1 or self.in_channel != channel * block.expansion:
  153.             downsample = nn.Sequential(
  154.                 nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),
  155.                 nn.BatchNorm2d(channel * block.expansion))
  156.  
  157.         layers = []
  158.         layers.append(block(self.in_channel,
  159.                             channel,
  160.                             downsample=downsample,
  161.                             stride=stride,
  162.                             groups=self.groups,
  163.                             width_per_group=self.width_per_group))
  164.         self.in_channel = channel * block.expansion
  165.  
  166.         for _ in range(1, block_num):
  167.             layers.append(block(self.in_channel,
  168.                                 channel,
  169.                                 groups=self.groups,
  170.                                 width_per_group=self.width_per_group))
  171.         # Sequential：自定义顺序连接成模型，生成网络结构
  172.         return nn.Sequential(*layers)
  173.  
  174.     # forward()：定义前向传播过程,描述了各层之间的连接关系
  175.     def forward(self, x):
  176.         # 无论哪种ResNet，都需要的静态层
  177.         x = self.conv1(x)
  178.         x = self.bn1(x)
  179.         x = self.relu(x)
  180.         x = self.maxpool(x)
  181.         # 动态层
  182.         x = self.layer1(x)
  183.         x = self.layer2(x)
  184.         x = self.layer3(x)
  185.         x = self.layer4(x)
  186.  
  187.         if self.include_top:
  188.             x = self.avgpool(x)
  189.             x = torch.flatten(x, 1)
  190.             x = self.fc(x)
  191.  
  192.         return x
  193.  
  194. # ResNet()中block参数对应的位置是BasicBlock或Bottleneck
  195. # ResNet()中blocks_num[0-3]对应[3, 4, 6, 3]，表示残差模块中的残差数
  196. # 34层的resnet
  197. def resnet34(num_classes=1000, include_top=True):
  198.     # https://download.pytorch.org/models/resnet34-333f7ec4.pth
  199.     return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)
  200.  
  201.  
  202. # 50层的resnet
  203. def resnet50(num_classes=1000, include_top=True):
  204.     # https://download.pytorch.org/models/resnet50-19c8e357.pth
  205.     return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)
  206.  
  207.  
  208. # 101层的resnet
  209. def resnet101(num_classes=1000, include_top=True):
  210.     # https://download.pytorch.org/models/resnet101-5d3b4d8f.pth
  211.     return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes, include_top=include_top)

3.训练

  • train.py：加载数据集并训练，计算loss和accuracy，保存训练好的网络参数
  1. import os
  2. import sys
  3. import json
  4.  
  5. import torch
  6. import torch.nn as nn
  7. import torch.optim as optim
  8. from torchvision import transforms, datasets
  9. from tqdm import tqdm
  10. # 训练resnet34
  11. from model import resnet34
  12.  
  13.  
  14. def main():
  15.     # 如果有NVIDA显卡，转到GPU训练，否则用CPU
  16.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  17.     print("using {} device.".format(device))
  18.  
  19.     data_transform = {
  20.         # 训练
  21.         # Compose()：将多个transforms的操作整合在一起
  22.         "train": transforms.Compose([
  23.             # RandomResizedCrop(224)：将给定图像随机裁剪为不同的大小和宽高比，然后缩放所裁剪得到的图像为给定大小
  24.             transforms.RandomResizedCrop(224),
  25.             # RandomVerticalFlip()：以0.5的概率竖直翻转给定的PIL图像
  26.             transforms.RandomHorizontalFlip(),
  27.             # ToTensor()：数据转化为Tensor格式
  28.             transforms.ToTensor(),
  29.             # Normalize()：将图像的像素值归一化到[-1,1]之间，使模型更容易收敛
  30.             transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
  31.         # 验证
  32.         "val": transforms.Compose([transforms.Resize(256),
  33.                                    transforms.CenterCrop(224),
  34.                                    transforms.ToTensor(),
  35.                                    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
  36.     # abspath()：获取文件当前目录的绝对路径
  37.     # join()：用于拼接文件路径，可以传入多个路径
  38.     # getcwd()：该函数不需要传递参数，获得当前所运行脚本的路径
  39.     data_root = os.path.abspath(os.getcwd())
  40.     # 得到数据集的路径
  41.     image_path = os.path.join(data_root, "flower_data")
  42.     # exists()：判断括号里的文件是否存在，可以是文件路径
  43.     # 如果image_path不存在，序会抛出AssertionError错误，报错为参数内容“ ”
  44.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
  45.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
  46.                                          transform=data_transform["train"])
  47.     # 训练集长度
  48.     train_num = len(train_dataset)
  49.  
  50.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
  51.     # class_to_idx：获取分类名称对应索引
  52.     flower_list = train_dataset.class_to_idx
  53.     # dict()：创建一个新的字典
  54.     # 循环遍历数组索引并交换val和key的值重新赋值给数组，这样模型预测的直接就是value类别值
  55.     cla_dict = dict((val, key) for key, val in flower_list.items())
  56.     # 把字典编码成json格式
  57.     json_str = json.dumps(cla_dict, indent=4)
  58.     # 把字典类别索引写入json文件
  59.     with open('class_indices.json', 'w') as json_file:
  60.         json_file.write(json_str)
  61.  
  62.     # 一次训练载入16张图像
  63.     batch_size = 16
  64.     # 确定进程数
  65.     # min()：返回给定参数的最小值，参数可以为序列
  66.     # cpu_count()：返回一个整数值，表示系统中的CPU数量，如果不确定CPU的数量，则不返回任何内容
  67.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])
  68.     print('Using {} dataloader workers every process'.format(nw))
  69.     # DataLoader：将读取的数据按照batch size大小封装给训练集
  70.     # dataset (Dataset)：输入的数据集
  71.     # batch_size (int, optional)：每个batch加载多少个样本，默认: 1
  72.     # shuffle (bool, optional)：设置为True时会在每个epoch重新打乱数据，默认: False
  73.     # num_workers(int, optional): 决定了有几个进程来处理，默认为0意味着所有的数据都会被load进主进程
  74.     train_loader = torch.utils.data.DataLoader(train_dataset,
  75.                                                batch_size=batch_size, shuffle=True,
  76.                                                num_workers=nw)
  77.     # 加载测试数据集
  78.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
  79.                                             transform=data_transform["val"])
  80.     # 测试集长度
  81.     val_num = len(validate_dataset)
  82.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
  83.                                                   batch_size=batch_size, shuffle=False,
  84.                                                   num_workers=nw)
  85.  
  86.     print("using {} images for training, {} images for validation.".format(train_num,
  87.                                                                            val_num))
  88.  
  89.     # 模型实例化
  90.     net = resnet34()
  91.     net.to(device)
  92.     # 加载预训练模型权重
  93.     # model_weight_path = "./resnet34-pre.pth"
  94.     # exists()：判断括号里的文件是否存在，可以是文件路径
  95.     # assert os.path.exists(model_weight_path), "file {} does not exist.".format(model_weight_path)
  96.     # net.load_state_dict(torch.load(model_weight_path, map_location='cpu'))
  97.     # 输入通道数
  98.     # in_channel = net.fc.in_features
  99.     # 全连接层
  100.     # net.fc = nn.Linear(in_channel, 5)
  101.  
  102.     # 定义损失函数（交叉熵损失）
  103.     loss_function = nn.CrossEntropyLoss()
  104.  
  105.     # 抽取模型参数
  106.     params = [p for p in net.parameters() if p.requires_grad]
  107.     # 定义adam优化器
  108.     # params(iterable)：要训练的参数，一般传入的是model.parameters()
  109.     # lr(float)：learning_rate学习率，也就是步长，默认：1e-3
  110.     optimizer = optim.Adam(params, lr=0.0001)
  111.  
  112.     # 迭代次数（训练次数）
  113.     epochs = 3
  114.     # 用于判断最佳模型
  115.     best_acc = 0.0
  116.     # 最佳模型保存地址
  117.     save_path = './resNet34.pth'
  118.     train_steps = len(train_loader)
  119.     for epoch in range(epochs):
  120.         # 训练
  121.         net.train()
  122.         running_loss = 0.0
  123.         # tqdm：进度条显示
  124.         train_bar = tqdm(train_loader, file=sys.stdout)
  125.         # train_bar: 传入数据（数据包括：训练数据和标签）
  126.         # enumerate()：将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中
  127.         # enumerate返回值有两个：一个是序号，一个是数据（包含训练数据和标签）
  128.         # x：训练数据（inputs）(tensor类型的），y：标签（labels）(tensor类型）
  129.         for step, data in enumerate(train_bar):
  130.             # 前向传播
  131.             images, labels = data
  132.             # 计算训练值
  133.             logits = net(images.to(device))
  134.             # 计算损失
  135.             loss = loss_function(logits, labels.to(device))
  136.             # 反向传播
  137.             # 清空过往梯度
  138.             optimizer.zero_grad()
  139.             # 反向传播，计算当前梯度
  140.             loss.backward()
  141.             optimizer.step()
  142.  
  143.             # item()：得到元素张量的元素值
  144.             running_loss += loss.item()
  145.  
  146.             # 进度条的前缀
  147.             # .3f：表示浮点数的精度为3（小数位保留3位）
  148.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
  149.                                                                      epochs,
  150.                                                                      loss)
  151.  
  152.         # 测试
  153.         # eval()：如果模型中有Batch Normalization和Dropout，则不启用，以防改变权值
  154.         net.eval()
  155.         acc = 0.0
  156.         # 清空历史梯度，与训练最大的区别是测试过程中取消了反向传播
  157.         with torch.no_grad():
  158.             val_bar = tqdm(validate_loader, file=sys.stdout)
  159.             for val_data in val_bar:
  160.                 val_images, val_labels = val_data
  161.                 outputs = net(val_images.to(device))
  162.                 # torch.max(input, dim)函数
  163.                 # input是具体的tensor，dim是max函数索引的维度，0是每列的最大值，1是每行的最大值输出
  164.                 # 函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引
  165.                 predict_y = torch.max(outputs, dim=1)[1]
  166.                 # 对两个张量Tensor进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False
  167.                 # .sum()对输入的tensor数据的某一维度求和
  168.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
  169.  
  170.                 val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1,
  171.                                                            epochs)
  172.  
  173.         val_accurate = acc / val_num
  174.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
  175.               (epoch + 1, running_loss / train_steps, val_accurate))
  176.  
  177.         # 保存最好的模型权重
  178.         if val_accurate > best_acc:
  179.             best_acc = val_accurate
  180.             # torch.save(state, dir)保存模型等相关参数，dir表示保存文件的路径+保存文件名
  181.             # model.state_dict()：返回的是一个OrderedDict，存储了网络结构的名字和对应的参数
  182.             torch.save(net.state_dict(), save_path)
  183.  
  184.     print('Finished Training')
  185.  
  186.  
  187. if __name__ == '__main__':
  188.     main()

4.测试

  • predict.py：用自己的数据集进行分类测试
  1. import os
  2. import sys
  3. import json
  4.  
  5. import torch
  6. import torch.nn as nn
  7. import torch.optim as optim
  8. from torchvision import transforms, datasets
  9. from tqdm import tqdm
  10. # 训练resnet34
  11. from model import resnet34
  12.  
  13.  
  14. def main():
  15.     # 如果有NVIDA显卡，转到GPU训练，否则用CPU
  16.     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  17.     print("using {} device.".format(device))
  18.  
  19.     data_transform = {
  20.         # 训练
  21.         # Compose()：将多个transforms的操作整合在一起
  22.         "train": transforms.Compose([
  23.             # RandomResizedCrop(224)：将给定图像随机裁剪为不同的大小和宽高比，然后缩放所裁剪得到的图像为给定大小
  24.             transforms.RandomResizedCrop(224),
  25.             # RandomVerticalFlip()：以0.5的概率竖直翻转给定的PIL图像
  26.             transforms.RandomHorizontalFlip(),
  27.             # ToTensor()：数据转化为Tensor格式
  28.             transforms.ToTensor(),
  29.             # Normalize()：将图像的像素值归一化到[-1,1]之间，使模型更容易收敛
  30.             transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
  31.         # 验证
  32.         "val": transforms.Compose([transforms.Resize(256),
  33.                                    transforms.CenterCrop(224),
  34.                                    transforms.ToTensor(),
  35.                                    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])}
  36.     # abspath()：获取文件当前目录的绝对路径
  37.     # join()：用于拼接文件路径，可以传入多个路径
  38.     # getcwd()：该函数不需要传递参数，获得当前所运行脚本的路径
  39.     data_root = os.path.abspath(os.getcwd())
  40.     # 得到数据集的路径
  41.     image_path = os.path.join(data_root, "data")
  42.     # exists()：判断括号里的文件是否存在，可以是文件路径
  43.     # 如果image_path不存在，序会抛出AssertionError错误，报错为参数内容“ ”
  44.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
  45.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
  46.                                          transform=data_transform["train"])
  47.     # 训练集长度
  48.     train_num = len(train_dataset)
  49.  
  50.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
  51.     # class_to_idx：获取分类名称对应索引
  52.     flower_list = train_dataset.class_to_idx
  53.     # dict()：创建一个新的字典
  54.     # 循环遍历数组索引并交换val和key的值重新赋值给数组，这样模型预测的直接就是value类别值
  55.     cla_dict = dict((val, key) for key, val in flower_list.items())
  56.     # 把字典编码成json格式
  57.     json_str = json.dumps(cla_dict, indent=4)
  58.     # 把字典类别索引写入json文件
  59.     with open('class_indices.json', 'w') as json_file:
  60.         json_file.write(json_str)
  61.  
  62.     # 一次训练载入16张图像
  63.     batch_size = 16
  64.     # 确定进程数
  65.     # min()：返回给定参数的最小值，参数可以为序列
  66.     # cpu_count()：返回一个整数值，表示系统中的CPU数量，如果不确定CPU的数量，则不返回任何内容
  67.     nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])
  68.     print('Using {} dataloader workers every process'.format(nw))
  69.     # DataLoader：将读取的数据按照batch size大小封装给训练集
  70.     # dataset (Dataset)：输入的数据集
  71.     # batch_size (int, optional)：每个batch加载多少个样本，默认: 1
  72.     # shuffle (bool, optional)：设置为True时会在每个epoch重新打乱数据，默认: False
  73.     # num_workers(int, optional): 决定了有几个进程来处理，默认为0意味着所有的数据都会被load进主进程
  74.     train_loader = torch.utils.data.DataLoader(train_dataset,
  75.                                                batch_size=batch_size, shuffle=True,
  76.                                                num_workers=nw)
  77.     # 加载测试数据集
  78.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
  79.                                             transform=data_transform["val"])
  80.     # 测试集长度
  81.     val_num = len(validate_dataset)
  82.     validate_loader = torch.utils.data.DataLoader(validate_dataset,
  83.                                                   batch_size=batch_size, shuffle=False,
  84.                                                   num_workers=nw)
  85.  
  86.     print("using {} images for training, {} images for validation.".format(train_num,
  87.                                                                            val_num))
  88.  
  89.     # 模型实例化
  90.     net = resnet34()
  91.     net.to(device)
  92.     # 加载预训练模型权重
  93.     # model_weight_path = "./resnet34-pre.pth"
  94.     # exists()：判断括号里的文件是否存在，可以是文件路径
  95.     # assert os.path.exists(model_weight_path), "file {} does not exist.".format(model_weight_path)
  96.     # net.load_state_dict(torch.load(model_weight_path, map_location='cpu'))
  97.     # 输入通道数
  98.     # in_channel = net.fc.in_features
  99.     # 全连接层
  100.     # net.fc = nn.Linear(in_channel, 5)
  101.  
  102.     # 定义损失函数（交叉熵损失）
  103.     loss_function = nn.CrossEntropyLoss()
  104.  
  105.     # 抽取模型参数
  106.     params = [p for p in net.parameters() if p.requires_grad]
  107.     # 定义adam优化器
  108.     # params(iterable)：要训练的参数，一般传入的是model.parameters()
  109.     # lr(float)：learning_rate学习率，也就是步长，默认：1e-3
  110.     optimizer = optim.Adam(params, lr=0.0001)
  111.  
  112.     # 迭代次数（训练次数）
  113.     epochs = 100
  114.     # 用于判断最佳模型
  115.     best_acc = 0.0
  116.     # 最佳模型保存地址
  117.     save_path = './resNet34.pth'
  118.     train_steps = len(train_loader)
  119.     for epoch in range(epochs):
  120.         # 训练
  121.         net.train()
  122.         running_loss = 0.0
  123.         # tqdm：进度条显示
  124.         train_bar = tqdm(train_loader, file=sys.stdout)
  125.         # train_bar: 传入数据（数据包括：训练数据和标签）
  126.         # enumerate()：将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中
  127.         # enumerate返回值有两个：一个是序号，一个是数据（包含训练数据和标签）
  128.         # x：训练数据（inputs）(tensor类型的），y：标签（labels）(tensor类型）
  129.         for step, data in enumerate(train_bar):
  130.             # 前向传播
  131.             images, labels = data
  132.             # 计算训练值
  133.             logits = net(images.to(device))
  134.             # 计算损失
  135.             loss = loss_function(logits, labels.to(device))
  136.             # 反向传播
  137.             # 清空过往梯度
  138.             optimizer.zero_grad()
  139.             # 反向传播，计算当前梯度
  140.             loss.backward()
  141.             optimizer.step()
  142.  
  143.             # item()：得到元素张量的元素值
  144.             running_loss += loss.item()
  145.  
  146.             # 进度条的前缀
  147.             # .3f：表示浮点数的精度为3（小数位保留3位）
  148.             train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
  149.                                                                      epochs,
  150.                                                                      loss)
  151.  
  152.         # 测试
  153.         # eval()：如果模型中有Batch Normalization和Dropout，则不启用，以防改变权值
  154.         net.eval()
  155.         acc = 0.0
  156.         # 清空历史梯度，与训练最大的区别是测试过程中取消了反向传播
  157.         with torch.no_grad():
  158.             val_bar = tqdm(validate_loader, file=sys.stdout)
  159.             for val_data in val_bar:
  160.                 val_images, val_labels = val_data
  161.                 outputs = net(val_images.to(device))
  162.                 # torch.max(input, dim)函数
  163.                 # input是具体的tensor，dim是max函数索引的维度，0是每列的最大值，1是每行的最大值输出
  164.                 # 函数会返回两个tensor，第一个tensor是每行的最大值；第二个tensor是每行最大值的索引
  165.                 predict_y = torch.max(outputs, dim=1)[1]
  166.                 # 对两个张量Tensor进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False
  167.                 # .sum()对输入的tensor数据的某一维度求和
  168.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
  169.  
  170.                 val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1,
  171.                                                            epochs)
  172.  
  173.         val_accurate = acc / val_num
  174.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
  175.               (epoch + 1, running_loss / train_steps, val_accurate))
  176.  
  177.         # 保存最好的模型权重
  178.         if val_accurate > best_acc:
  179.             best_acc = val_accurate
  180.             # torch.save(state, dir)保存模型等相关参数，dir表示保存文件的路径+保存文件名
  181.             # model.state_dict()：返回的是一个OrderedDict，存储了网络结构的名字和对应的参数
  182.             torch.save(net.state_dict(), save_path)
  183.  
  184.     print('Finished Training')
  185.  
  186.  
  187. if __name__ == '__main__':
  188.     main()

5.模型对比

ResNet34

训练了140轮，但其实在50轮的时候就已经达到了0.9的accuracy，后面收敛缓慢，于是想换模型。训练时间为一分钟一轮。

ResNet50

训练时间大概两分钟一轮

 

50确实比34情况要好，但还是同样的问题，前期收敛到0.955之后就一直摇摆，也没有突破

这个时候还在想换模型，于是换了152

ResNet152

 现在感觉不是模型的问题了，应该是数据集哪里出了问题，想寻找新数据集。模型的话ResNet50就够用了，因为152训练时间太长了，大概5分钟才一轮。

6.新数据集训练

持续更新中

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