• vision transformer

     

     

    一、网络构建
     

    1.  
    2. import torch
    3. from torch import nn
    4. from functools import partial
    5.  
    6. # --------------------------------------- #
    7. # （1）patch embedding
    8. '''
    9. img_size=224 : 输入图像的宽高
    10. patch_size=16 ： 每个patch的宽高，也是卷积核的尺寸和步长
    11. in_c=3 ： 输入图像的通道数
    12. embed_dim=768 ： 卷积输出通道数
    13. '''
    14.  
    15.  
    16. # --------------------------------------- #
    17. class patchembed(nn.Module):
    18.     # 初始化
    19.     def __init__(self, img_size=224, patch_size=16, in_c=3, embed_dim=768):
    20.         super(patchembed, self).__init__()
    21.  
    22.         # 输入图像的尺寸224*224
    23.         self.img_size = (img_size, img_size)
    24.         # 每个patch的大小16*16
    25.         self.patch_size = (patch_size, patch_size)
    26.         # 将输入图像划分成14*14个patch
    27.         self.grid_size = (img_size // patch_size, img_size // patch_size)
    28.         # 一共有14*14个patch      224/16  *  224/16
    29.         self.num_patches = self.grid_size[0] * self.grid_size[1]
    30.  
    31.         # 使用16*16的卷积切分图像，将图像分成14*14个
    32.         self.proj = nn.Conv2d(in_channels=in_c, out_channels=embed_dim,
    33.                               kernel_size=patch_size, stride=patch_size)
    34.  
    35.         # 定义标准化方法，给LN传入默认参数eps
    36.         norm_layer = partial(nn.LayerNorm, eps=1e-6)
    37.         self.norm = norm_layer(embed_dim)#  标准化是什么
    38.  
    39.  
    40.     # 前向传播
    41.     def forward(self, inputs):
    42.         # 获得输入图像的shape
    43.         B, C, H, W = inputs.shape
    44.  
    45.         # 如果输入图像的宽高不等于224*224就报错
    46.         '''
    47.         重要写法   inputshape！=224就会报错误
    48.         '''
    49.         assert H == self.img_size[0] and W == self.img_size[1], 'input shape does not match 224*224'
    50.  
    51.         # 卷积层切分patch [b,3,224,224]==>[b,768,14,14]
    52.         x = self.proj(inputs)
    53.         # 展平 [b,768,14,14]==>[b,768,14*14]
    54.         x = x.flatten(start_dim=2, end_dim=-1)  # 将索引为 start_dim 和 end_dim 之间（包括该位置）的数量相乘
    55.         # 维度调整 [b,768,14*14]==>[b,14*14,768]
    56.         x = x.transpose(1, 2)  # 实现一个张量的两个轴之间的维度转换
    57.         # 标准化
    58.         x = self.norm(x)
    59.  
    60.         return x
    61.  
    62.  
    63. # --------------------------------------- #
    64. # （2）类别标签和位置标签
    65. '''
    66. embed_dim : 代表patchembed层输出的通道数
    67. '''
    68.  
    69.  
    70. # --------------------------------------- #
    71. class class_token_pos_embed(nn.Module):
    72.     # 初始化
    73.     def __init__(self, embed_dim):
    74.         super(class_token_pos_embed, self).__init__()
    75.  
    76.         # patchembed层将图像划分的patch个数==14*14
    77.         num_patches = patchembed().num_patches
    78.  
    79.         self.num_tokens = 1  # 类别标签
    80.  
    81.         # 创建可学习的类别标签 [1,1,768]
    82.         self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
    83.         # 创建可学习的位置编码 [1,196+1,768]
    84.         self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_tokens, embed_dim))
    85.  
    86.         # 权重以正态分布初始化
    87.         nn.init.trunc_normal_(self.pos_embed, std=0.02)
    88.         nn.init.trunc_normal_(self.cls_token, std=0.02)
    89.  
    90.     # 前向传播
    91.     def forward(self, x):  # 输入特征图的shape=[b,196,768]
    92.  
    93.         # 类别标签扩充维度 [1,1,768]==>[b,1,768]
    94.         cls_token = self.cls_token.expand(x.shape[0], -1, -1)
    95.  
    96.         # 将类别标签添加到特征图中 [b,1,768]+[b,196,768]==>[b,197,768]
    97.         x = torch.cat((cls_token, x), dim=1)
    98.  
    99.         # 添加位置编码 [b,197,768]+[1,197,768]==>[b,197,768]
    100.         x = x + self.pos_embed
    101.  
    102.         return x
    103.  
    104.  
    105. # --------------------------------------- #
    106. # （3）多头注意力模块
    107. '''
    108. dim : 代表输入特征图的通道数
    109. num_heads : 多头注意力中heads的个数
    110. qkv_bias ： 生成qkv时是否使用偏置 
    111. atten_drop_ratio ：qk计算完之后的dropout层
    112. proj_drop_ratio ： qkv计算完成之后的dropout层
    113. '''
    114.  
    115.  
    116. # --------------------------------------- #
    117. class attention(nn.Module):
    118.     # 初始化
    119.     def __init__(self, dim, num_heads=12, qkv_bias=False, atten_drop_ratio=0., proj_drop_ratio=0.):
    120.         super(attention, self).__init__()
    121.  
    122.         # 多头注意力的数量
    123.         self.num_heads = num_heads
    124.         # 将生成的qkv均分成num_heads个。得到每个head的qkv对应的通道数。
    125.         head_dim = dim // num_heads
    126.         print(dim)
    127.         # 公式中的分母
    128.         self.scale = head_dim ** -0.5
    129.  
    130.         # 通过一个全连接层计算qkv
    131.         self.qkv = nn.Linear(in_features=dim, out_features=dim * 3, bias=qkv_bias)
    132.         # dropout层
    133.         self.atten_drop = nn.Dropout(atten_drop_ratio)
    134.  
    135.         # 再qkv计算完之后通过一个全连接提取特征
    136.         self.proj = nn.Linear(in_features=dim, out_features=dim)
    137.         # dropout层
    138.         self.proj_drop = nn.Dropout(proj_drop_ratio)
    139.  
    140.     # 前向传播
    141.     def forward(self, inputs):
    142.         # 获取输入图像的shape=[b,197,768]
    143.         B, N, C = inputs.shape
    144.  
    145.         # 将输入特征图经过全连接层生成qkv [b,197,768]==>[b,197,768*3]
    146.         qkv = self.qkv(inputs)
    147.  
    148.         # 维度调整 [b,197,768*3]==>[b, 197, 3, 12, 768//12]
    149.         qkv = qkv.reshape(B, N, 3, self.num_heads, C // self.num_heads)
    150.         # 维度重排==> [3, B, 12, 197, 768//12]
    151.         qkv = qkv.permute(2, 0, 3, 1, 4)
    152.         # 切片提取q、k、v的值，单个的shape=[B, 12, 197, 768//12]
    153.         q, k, v = qkv[0], qkv[1], qkv[2]
    154.  
    155.         # 针对每个head计算 ==> [B, 12, 197, 197]
    156.         atten = (q @ k.transpose(-2, -1)) * self.scale  # @ 代表在多维tensor的最后两个维度矩阵相乘
    157.         # 对计算结果的每一行经过softmax
    158.         atten = atten.softmax(dim=-1)
    159.         # dropout层
    160.         atten = self.atten_drop(atten)
    161.  
    162.         # softmax后的结果和v加权 ==> [B, 12, 197, 768//12]
    163.         x = atten @ v
    164.         # 通道重排 ==> [B, 197, 12, 768//12]
    165.         x = x.transpose(1, 2)
    166.         # 维度调整 ==> [B, 197, 768]
    167.         x = x.reshape(B, N, C)
    168.  
    169.         # 通过全连接层融合特征 ==> [B, 197, 768]
    170.         x = self.proj(x)
    171.         # dropout层
    172.         x = self.proj_drop(x)
    173.  
    174.         return x
    175.  
    176.  
    177. # --------------------------------------- #
    178. # （4）MLP多层感知器
    179. '''
    180. in_features : 输入特征图的通道数
    181. hidden_features : 第一个全连接层上升通道数
    182. out_features : 第二个全连接层的下降的通道数
    183. drop : 全连接层后面的dropout层的杀死神经元的概率
    184. '''
    185.  
    186.  
    187. # --------------------------------------- #
    188. class MLP(nn.Module):
    189.     # 初始化
    190.     def __init__(self, in_features, hidden_features, out_features=None, drop=0.):
    191.         super(MLP, self).__init__()
    192.  
    193.         # MLP的输出通道数默认等于输入通道数
    194.         out_features = out_features or in_features
    195.         # 第一个全连接层上升通道数
    196.         self.fc1 = nn.Linear(in_features=in_features, out_features=hidden_features)
    197.         # GeLU激活函数
    198.         self.act = nn.GELU()
    199.         # 第二个全连接下降通道数
    200.         self.fc2 = nn.Linear(in_features=hidden_features, out_features=out_features)
    201.         # dropout层
    202.         self.drop = nn.Dropout(drop)
    203.  
    204.     # 前向传播
    205.     def forward(self, inputs):
    206.         # [b,197,768]==>[b,197,3072]
    207.         x = self.fc1(inputs)
    208.         x = self.act(x)
    209.         x = self.drop(x)
    210.  
    211.         # [b,197,3072]==>[b,197,768]
    212.         x = self.fc2(x)
    213.         x = self.drop(x)
    214.  
    215.         return x
    216.  
    217.  
    218. # --------------------------------------- #
    219. # （5）Encoder Block
    220. '''
    221. dim : 该模块的输入特征图个数
    222. mlp_ratio ： MLP中第一个全连接层上升的通道数
    223. drop_ratio : 该模块的dropout层的杀死神经元的概率
    224. '''
    225.  
    226.  
    227. # --------------------------------------- #
    228. class encoder_block(nn.Module):
    229.     # 初始化
    230.     def __init__(self, dim, mlp_ratio=4., drop_ratio=0.):
    231.         super(encoder_block, self).__init__()
    232.  
    233.         # LayerNormalization层
    234.         self.norm1 = nn.LayerNorm(dim)
    235.         # 实例化多头注意力
    236.         self.atten = attention(dim)
    237.         # dropout
    238.         self.drop = nn.Dropout()
    239.  
    240.         # LayerNormalization层
    241.         self.norm2 = nn.LayerNorm(dim)
    242.         # MLP中第一个全连接层上升的通道数
    243.         hidden_features = int(dim * mlp_ratio)
    244.         # MLP多层感知器
    245.         self.mlp = MLP(in_features=dim, hidden_features=hidden_features)
    246.  
    247.     # 前向传播
    248.     def forward(self, inputs):
    249.         # [b,197,768]==>[b,197,768]
    250.         x = self.norm1(inputs)
    251.         x = self.atten(x)
    252.         x = self.drop(x)
    253.         feat1 = x + inputs  # 残差连接
    254.  
    255.         # [b,197,768]==>[b,197,768]
    256.         x = self.norm2(feat1)
    257.         x = self.mlp(x)
    258.         x = self.drop(x)
    259.         feat2 = x + feat1  # 残差连接
    260.  
    261.         return feat2
    262.  
    263.  
    264. # --------------------------------------- #
    265. # （6）主干网络
    266. '''
    267. num_class: 分类数
    268. depth : 重复堆叠encoder_block的次数
    269. drop_ratio : 位置编码后的dropout层
    270. embed_dim : patchembed层输出通道数
    271. '''
    272.  
    273.  
    274. # --------------------------------------- #
    275. class VIT(nn.Module):
    276.     # 初始化
    277.     def __init__(self, num_classes=1000, depth=12, drop_ratio=0., embed_dim=768):
    278.         super(VIT, self).__init__()
    279.  
    280.         self.num_classes = num_classes  # 分类类别数
    281.  
    282.         # 实例化patchembed层
    283.         self.patchembed = patchembed()
    284.  
    285.         # 实例化类别标签和位置编码
    286.         self.cls_pos_embed = class_token_pos_embed(embed_dim=embed_dim)
    287.  
    288.         # 位置编码后做dropout
    289.         self.pos_drop = nn.Dropout(drop_ratio)
    290.  
    291.         # 在列表中添加12个encoder_block
    292.         self.blocks = nn.Sequential(*[encoder_block(dim=embed_dim) for _ in range(depth)])
    293.  
    294.         # 定义LayerNormalization标准化方法
    295.         norm_layer = partial(nn.LayerNorm, eps=1e-6)
    296.         # 经过12个encoder之后的标准化层
    297.         self.norm = norm_layer(embed_dim)
    298.  
    299.         # 分类层
    300.         self.head = nn.Linear(in_features=embed_dim, out_features=num_classes)
    301.  
    302.         # 权值初始化
    303.         for m in self.modules():
    304.             # 对卷积层使用kaiming初始化
    305.             if isinstance(m, nn.Conv2d):
    306.                 nn.init.kaiming_normal_(m.weight, mode='fan_out')
    307.                 # 对偏置初始化
    308.                 if m.bias is not None:
    309.                     nn.init.zeros_(m.bias)
    310.             # 对标准化层初始化
    311.             elif isinstance(m, nn.LayerNorm):
    312.                 nn.init.ones_(m.weight)
    313.                 nn.init.zeros_(m.bias)
    314.             # 对全连接层初始化
    315.             elif isinstance(m, nn.Linear):
    316.                 nn.init.normal_(m.weight, 0, 0.01)
    317.                 if m.bias is not None:
    318.                     nn.init.zeros_(m.bias)
    319.  
    320.     # 前向传播
    321.     def forward(self, inputs):
    322.  
    323.         # 先将输入传递给patchembed [b,3,224,224]==>[b,196,768]
    324.         x = self.patchembed(inputs)
    325.  
    326.         # 对特征图添加类别标签和位置编码
    327.         x = self.cls_pos_embed(x)
    328.  
    329.         # dropout层
    330.         x = self.pos_drop(x)
    331.  
    332.         # 经过12个encoder层==>[b,197,768]
    333.         x = self.blocks(x)
    334.  
    335.         # LN标准化层
    336.         x = self.norm(x)
    337.  
    338.         # 提取类别标签的输出,因为在cat时将类别标签放在最前面
    339.         x = x[:, 0]  # [b,197,768]==>[b,768]
    340.  
    341.         # 全连接层分类 [b,768]==>[b,1000]
    342.         x = self.head(x)
    343.  
    344.         return x
    345.  
    346. if __name__=="__main__":
    347.     model=VIT(10,3)
    348.     image=torch.randn((1,3,224,224))
    349.     print(model(image).shape)
     

    二、读取数据并训练
     

    1、修改参数
     

            batchsize：是每批次处理的图片数量
     

            epochs：是图片总共的训练次数
     

            bestloss：小于1时保存权重
     

            filepath：数据集的路径，修改为自己的路径
     

    路径格式为：
     

            --dataset（文件夹）
     

                   --类别1（文件夹）
     

                            --1.jpg(图片文件)
     

                            --2.jpg（图片文件）
     

                    --类别2（文件夹）
     

                            --1.jpg(图片文件)
     

                     ......
     

                     ......
     

            weightpath：预训练模型加载权重的路径
     

            savepath：保存权重的路径
     

    1. batch_size = 16  # 每个step处理16张图片
    2. epochs = 10  # 训练10轮
    3. best_loss = 1.0  # 当验证集损失小于1时才保存权重
    4.  
    5. # 数据集目录位置
    6. filepath = 'E:\ZZZZZZZZZ删除\服饰识别\dataset'
    7. # 预训练权重位置
    8. #weightpath = 'D:/deeplearning/imgnet/pytorchimgnet/pretrained_weights/vit_base_patch16_224.pth'
    9. # 训练时保存权重文件的位置
    10. savepath = 'E:\A_pytorch\\transformer'
     

    2、构建数据集并数据增强
     

            data_transform 是定义数据增强方法，此处运用的图像增强方法较少，大家可以自定义
     

            dataset 加载数据集
     

            dataloader 将数据分批次构建数据集
     

    1. # --------------------------------------------- #
    2. # （1）数据集处理
    3. # --------------------------------------------- #
    4. # 定义预处理方法
    5. data_transform = {
    6.     # 训练集预处理方法
    7.     'train': transforms.Compose([
    8.         transforms.Resize((224, 224)),  # 将原始图片缩放至224*224大小
    9.         transforms.RandomHorizontalFlip(),  # 随机水平翻转
    10.         transforms.ToTensor(),  # numpy类型变tensor，维度调整，数据归一化
    11.         transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 对图像的三个通道分别做标准化
    12.     ]),
    13.  
    14.     # 验证集预处理方法
    15.     'val': transforms.Compose([
    16.         transforms.Resize((224, 224)),  # 将输入图像缩放至224*224大小
    17.         transforms.ToTensor(),
    18.         transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    19.     ])
    20. }
    21.  
    22. # 加载数据集
    23.  
    24. datasets = {
    25.     'train': datasets.ImageFolder(filepath , transform=data_transform['train']),  # 读取训练集
    26.     'val': datasets.ImageFolder(filepath, transform=data_transform['val'])  # 读取验证集
    27. }
    28.  
    29.  
    30. # datasets = {
    31. #     'train': datasets.ImageFolder(filepath + 'train', transform=data_transform['train']),  # 读取训练集
    32. #     'val': datasets.ImageFolder(filepath + 'val', transform=data_transform['val'])  # 读取验证集
    33. # }
    34.  
    35. # 构造数据集
    36. dataloader = {
    37.     'train': DataLoader(datasets['train'], batch_size=batch_size, shuffle=True),  # 构造训练集
    38.     'val': DataLoader(datasets['val'], batch_size=batch_size, shuffle=True)  # 构造验证集
    39. }
     

    3、设置损失函数、优化器
     

            loss_function设置为交叉熵损失函数
     

            optimizer 优化器定义为SGD优化器
     

    1. # --------------------------------------------- #
    2. # （5）网络编译
    3. # --------------------------------------------- #
    4. # 将模型搬运至GPU上
    5. model.to(device)
    6. # 定义交叉熵损失
    7. loss_function = nn.CrossEntropyLoss()
    8.  
    9. # 获取所有需要梯度更新的权重参数
    10. params_optim = []
    11. # 遍历网络的所有权重
    12. for p in model.parameters():
    13.     if p.requires_grad is True:  # 查看权重是否需要更新
    14.         params_optim.append(p)  # 保存所有需要更新的权重
    15.  
    16. print('训练参数：', len(params_optim))
    17.  
    18. # 定义优化器，定义学习率，动量，正则化系数
    19. optimizer = optim.SGD(params_optim, lr=0.001, momentum=0.9, weight_decay=3e-4)
     

    4、训练和验证
     

    1. # --------------------------------------------- #
    2. # （6）训练阶段
    3. # --------------------------------------------- #
    4. for epoch in range(epochs):
    5.  
    6.     print('=' * 30)  # 显示当前是第几个epoch
    7.  
    8.     # 将模型设置为训练模式
    9.     model.train()
    10.     # 记录一个epoch的训练集总损失
    11.     total_loss = 0.0
    12.  
    13.     # 每个step训练一个batch，每次取出一个数据集及其标签
    14.     for step, (images, labels) in enumerate(dataloader['train']):
    15.  
    16.         # 将数据集搬运到GPU上
    17.         images, labels = images.to(device), labels.to(device)
    18.         # 梯度清零，因为梯度是累加的
    19.         optimizer.zero_grad()
    20.         # 前向传播==>[b,3]
    21.         logits = model(images)  # 得到每张图属于3个类别的分数
    22.  
    23.         # （1）损失计算
    24.         # 计算每个step的预测值和真实值的交叉熵损失
    25.         loss = loss_function(logits, labels)
    26.         # 累加每个step的损失
    27.         total_loss += loss
    28.  
    29.         # （2）反向传播
    30.         # 梯度计算
    31.         loss.backward()
    32.         # 梯度更新
    33.         optimizer.step()
    34.  
    35.         # 每50个epoch打印一次损失值
    36.         if step % 50 == 0:
    37.             print(f'step:{step}, train_loss:{loss}')
    38.  
    39.     # 计算一个epoch的训练集平均损失
    40.     train_loss = total_loss / len(dataloader['train'])
    41.  
    42.     # --------------------------------------------- #
    43.     # （7）验证训练
    44.     # --------------------------------------------- #
    45.     model.eval()  # 切换到验证模式
    46.  
    47.     total_val_loss = 0.0  # 记录一个epoch的验证集总损失
    48.     total_val_correct = 0  # 记录一个epoch中验证集一共预测对了几个
    49.  
    50.     with torch.no_grad():  # 接下来不计算梯度
    51.         # 每个step验证一个batch
    52.         for (images, labels) in dataloader['val']:
    53.             # 将数据集搬运到GPU上
    54.             images, labels = images.to(device), labels.to(device)
    55.             # 前向传播[b,c,h,w]==>[b,3]
    56.             logits = model(images)
    57.  
    58.             # （1）计算损失
    59.             # 计算每个batch的预测值和真实值的交叉熵损失
    60.             loss = loss_function(logits, labels)
    61.             # 累加每个batch的损失，得到一个epoch的总损失
    62.             total_val_loss += loss
    63.  
    64.             # （2）计算准确率
    65.             # 找到预测值对应的最大索引，即该图片对应的类别
    66.             pred = logits.argmax(dim=1)  # [b,3]==>[b]
    67.             # 比较预测值和标签值，计算每个batch有多少预测对了
    68.             val_correct = torch.eq(pred, labels).float().sum()
    69.             # 累加每个batch的正确个数，计算整个epoch的正确个数
    70.             total_val_correct += val_correct
    71.  
    72.         # 计算一个epoch的验证集的平均损失和平均准确率
    73.         val_loss = total_val_loss / len(dataloader['val'])
    74.         val_acc = total_val_correct / val_num
    75.  
    76.         # 打印每个epoch的训练集平均损失，验证集平均损失和平均准确率
    77.         print('-' * 30)
    78.         print(f'train_loss:{train_loss}, val_loss:{val_loss}, val_acc:{val_acc}')
    79.  
    80.         # --------------------------------------------- #
    81.         # （8）保存权重
    82.         # --------------------------------------------- #
    83.         # 保存最小损失值对应的权重文件
    84.         if val_loss < best_loss:
    85.             # 权重文件名称
    86.             savename = savepath + f'epoch{epoch}_valacc{round(val_acc.item() * 100)}%_' + 'VIT.pth'
    87.             # 保存该轮次的权重
    88.             torch.save(model.state_dict(), savename)
    89.             # 切换最小损失值
    90.             best_loss = val_loss
    91.             # 打印结果
    92.             print(f'weights has been saved, best_loss has changed to {val_loss}')
     

     

    5、全部代码
     

    1. import torch
    2. from torch import nn, optim
    3. from torchvision import transforms, datasets
    4. from torch.utils.data import DataLoader
    5. from VisionTransformer_model import VIT  # 导入我们之前定义的 VIT B-16 模型
    6. import numpy as np
    7. import matplotlib.pyplot as plt
    8.  
    9. plt.rcParams['font.sans-serif'] = ['SimHei']  # 绘图显示中文
    10.  
    11. # --------------------------------------------- #
    12. # （0）参数设置
    13. # --------------------------------------------- #
    14. batch_size = 16  # 每个step处理16张图片
    15. epochs = 10  # 训练10轮
    16. best_loss = 1.0  # 当验证集损失小于1时才保存权重
    17.  
    18. # 数据集目录位置
    19. filepath = 'E:\ZZZZZZZZZ删除\服饰识别\dataset'
    20. # 预训练权重位置
    21. #weightpath = 'D:/deeplearning/imgnet/pytorchimgnet/pretrained_weights/vit_base_patch16_224.pth'
    22. # 训练时保存权重文件的位置
    23. savepath = 'E:\A_pytorch\\transformer'
    24.  
    25. # 获取GPU设备，检测到了就用GPU，检测不到就用CPU
    26. if torch.cuda.is_available():
    27.     device = torch.device('cuda:0')
    28. else:
    29.     device = torch.device('cpu')
    30.  
    31. # --------------------------------------------- #
    32. # （1）数据集处理
    33. # --------------------------------------------- #
    34. # 定义预处理方法
    35. data_transform = {
    36.     # 训练集预处理方法
    37.     'train': transforms.Compose([
    38.         transforms.Resize((224, 224)),  # 将原始图片缩放至224*224大小
    39.         transforms.RandomHorizontalFlip(),  # 随机水平翻转
    40.         transforms.ToTensor(),  # numpy类型变tensor，维度调整，数据归一化
    41.         transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 对图像的三个通道分别做标准化
    42.     ]),
    43.  
    44.     # 验证集预处理方法
    45.     'val': transforms.Compose([
    46.         transforms.Resize((224, 224)),  # 将输入图像缩放至224*224大小
    47.         transforms.ToTensor(),
    48.         transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    49.     ])
    50. }
    51.  
    52. # 加载数据集
    53.  
    54. datasets = {
    55.     'train': datasets.ImageFolder(filepath , transform=data_transform['train']),  # 读取训练集
    56.     'val': datasets.ImageFolder(filepath, transform=data_transform['val'])  # 读取验证集
    57. }
    58.  
    59.  
    60. # datasets = {
    61. #     'train': datasets.ImageFolder(filepath + 'train', transform=data_transform['train']),  # 读取训练集
    62. #     'val': datasets.ImageFolder(filepath + 'val', transform=data_transform['val'])  # 读取验证集
    63. # }
    64.  
    65. # 构造数据集
    66. dataloader = {
    67.     'train': DataLoader(datasets['train'], batch_size=batch_size, shuffle=True),  # 构造训练集
    68.     'val': DataLoader(datasets['val'], batch_size=batch_size, shuffle=True)  # 构造验证集
    69. }
    70.  
    71. # --------------------------------------------- #
    72. # （2）查看数据集信息
    73. # --------------------------------------------- #
    74. train_num = len(datasets['train'])  # 查看训练集数量
    75. val_num = len(datasets['val'])  # 查看验证集数量
    76.  
    77. # 查看分类类别及其索引  {0: 'cats', 1: 'dogs', 2: 'panda'}
    78. class_names = dict((v, k) for k, v in datasets['train'].class_to_idx.items())
    79. print(class_names)
    80.  
    81. # 从训练集中取出一个batch，接收图片及其标签
    82. train_imgs, train_labels = next(iter(dataloader['train']))
    83. # 查看图像的标签及其shape  [32, 3, 224, 224]  [32]
    84. print('img:', train_imgs.shape, 'labels:', train_labels.shape)
    85.  
    86. # --------------------------------------------- #
    87. # （3）数据可视化
    88. # --------------------------------------------- #
    89. # 从数据集中取出12张图及其标签
    90. frames = train_imgs[:12]
    91. frames_labels = train_labels[:12]
    92.  
    93. # 将数据类型从tensor变回numpy
    94. frames = frames.numpy()
    95. # 维度调整 [b,c,h,w]==>[b,h,w,c]
    96. frames = np.transpose(frames, [0, 2, 3, 1])
    97.  
    98. # 对图像做反标准化处理
    99. mean = [0.485, 0.456, 0.406]  # 均值
    100. std = [0.229, 0.224, 0.225]  # 标准化
    101. # 图像的每个通道的特征图乘标准化加均值
    102. frames = frames * std + mean
    103.  
    104. # 将像素值限制在0-1之间
    105. frames = np.clip(frames, 0, 1)
    106.  
    107. # 绘制12张图像及其标签
    108. plt.figure()  # 创建画板
    109. for i in range(12):
    110.     plt.subplot(3, 4, i + 1)
    111.     plt.imshow(frames[i])
    112.     plt.axis('off')  # 不显示坐标刻度
    113.     plt.title(class_names[frames_labels[i].item()])  # 显示每张图片的标签
    114. plt.tight_layout()  # 轻量化布局
    115. plt.show()
    116.  
    117.  
    118.  
    119. # --------------------------------------------- #
    120. # （4）模型加载，迁移学习
    121. # --------------------------------------------- #
    122. # 接收VIT模型，三分类
    123. model = VIT(num_classes=3)
    124.  
    125. # 加载预训练权重文件，文件中的分类层神经元个数是1k
    126. #pre_weights = torch.load(weightpath, map_location=device)
    127.  
    128. # 删除权重文件中不需要的层，保留除了分类层以外的所有层的权重
    129. # del_keys = ['head.weight', 'head.bias']
    130. #
    131. # # 删除字典中的对应key
    132. # for k in del_keys:
    133. #     del pre_weights[k]
    134. #
    135. # # 将修改后的权重加载到模型上
    136. # # 当strict=True,要求预训练权重层数的键值与新构建的模型中的权重层数名称完全吻合
    137. # missing_keys, unexpected_keys = model.load_state_dict(pre_weights, strict=False)
    138. # print('miss:', len(missing_keys), 'unexpected:', len(unexpected_keys))
    139.  
    140. # model.parameters() 代表网络的所有参数
    141. for params in model.parameters():
    142.     params.requires_grad = True  # 所有权重参与训练可以更新
    143.  
    144. # --------------------------------------------- #
    145. # （5）网络编译
    146. # --------------------------------------------- #
    147. # 将模型搬运至GPU上
    148. model.to(device)
    149. # 定义交叉熵损失
    150. loss_function = nn.CrossEntropyLoss()
    151.  
    152. # 获取所有需要梯度更新的权重参数
    153. params_optim = []
    154. # 遍历网络的所有权重
    155. for p in model.parameters():
    156.     if p.requires_grad is True:  # 查看权重是否需要更新
    157.         params_optim.append(p)  # 保存所有需要更新的权重
    158.  
    159. print('训练参数：', len(params_optim))
    160.  
    161. # 定义优化器，定义学习率，动量，正则化系数
    162. optimizer = optim.SGD(params_optim, lr=0.001, momentum=0.9, weight_decay=3e-4)
    163.  
    164. # --------------------------------------------- #
    165. # （6）训练阶段
    166. # --------------------------------------------- #
    167. for epoch in range(epochs):
    168.  
    169.     print('=' * 30)  # 显示当前是第几个epoch
    170.  
    171.     # 将模型设置为训练模式
    172.     model.train()
    173.     # 记录一个epoch的训练集总损失
    174.     total_loss = 0.0
    175.  
    176.     # 每个step训练一个batch，每次取出一个数据集及其标签
    177.     for step, (images, labels) in enumerate(dataloader['train']):
    178.  
    179.         # 将数据集搬运到GPU上
    180.         images, labels = images.to(device), labels.to(device)
    181.         # 梯度清零，因为梯度是累加的
    182.         optimizer.zero_grad()
    183.         # 前向传播==>[b,3]
    184.         logits = model(images)  # 得到每张图属于3个类别的分数
    185.  
    186.         # （1）损失计算
    187.         # 计算每个step的预测值和真实值的交叉熵损失
    188.         loss = loss_function(logits, labels)
    189.         # 累加每个step的损失
    190.         total_loss += loss
    191.  
    192.         # （2）反向传播
    193.         # 梯度计算
    194.         loss.backward()
    195.         # 梯度更新
    196.         optimizer.step()
    197.  
    198.         # 每50个epoch打印一次损失值
    199.         if step % 50 == 0:
    200.             print(f'step:{step}, train_loss:{loss}')
    201.  
    202.     # 计算一个epoch的训练集平均损失
    203.     train_loss = total_loss / len(dataloader['train'])
    204.  
    205.     # --------------------------------------------- #
    206.     # （7）验证训练
    207.     # --------------------------------------------- #
    208.     model.eval()  # 切换到验证模式
    209.  
    210.     total_val_loss = 0.0  # 记录一个epoch的验证集总损失
    211.     total_val_correct = 0  # 记录一个epoch中验证集一共预测对了几个
    212.  
    213.     with torch.no_grad():  # 接下来不计算梯度
    214.         # 每个step验证一个batch
    215.         for (images, labels) in dataloader['val']:
    216.             # 将数据集搬运到GPU上
    217.             images, labels = images.to(device), labels.to(device)
    218.             # 前向传播[b,c,h,w]==>[b,3]
    219.             logits = model(images)
    220.  
    221.             # （1）计算损失
    222.             # 计算每个batch的预测值和真实值的交叉熵损失
    223.             loss = loss_function(logits, labels)
    224.             # 累加每个batch的损失，得到一个epoch的总损失
    225.             total_val_loss += loss
    226.  
    227.             # （2）计算准确率
    228.             # 找到预测值对应的最大索引，即该图片对应的类别
    229.             pred = logits.argmax(dim=1)  # [b,3]==>[b]
    230.             # 比较预测值和标签值，计算每个batch有多少预测对了
    231.             val_correct = torch.eq(pred, labels).float().sum()
    232.             # 累加每个batch的正确个数，计算整个epoch的正确个数
    233.             total_val_correct += val_correct
    234.  
    235.         # 计算一个epoch的验证集的平均损失和平均准确率
    236.         val_loss = total_val_loss / len(dataloader['val'])
    237.         val_acc = total_val_correct / val_num
    238.  
    239.         # 打印每个epoch的训练集平均损失，验证集平均损失和平均准确率
    240.         print('-' * 30)
    241.         print(f'train_loss:{train_loss}, val_loss:{val_loss}, val_acc:{val_acc}')
    242.  
    243.         # --------------------------------------------- #
    244.         # （8）保存权重
    245.         # --------------------------------------------- #
    246.         # 保存最小损失值对应的权重文件
    247.         if val_loss < best_loss:
    248.             # 权重文件名称
    249.             savename = savepath + f'epoch{epoch}_valacc{round(val_acc.item() * 100)}%_' + 'VIT.pth'
    250.             # 保存该轮次的权重
    251.             torch.save(model.state_dict(), savename)
    252.             # 切换最小损失值
    253.             best_loss = val_loss
    254.             # 打印结果
    255.             print(f'weights has been saved, best_loss has changed to {val_loss}')
     

    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
认识BIOS基本输入输出系统                            
    
【Git】Git 快照 Snapshot                            
    
Ansible离线部署 之 Zabbix                            
    
Python 的安装                            
    
基于springboot的社区疫情管理系统源码                            
    
Linux项目实训一                            
    
算法题解记录29+++全排列（百日筑基）                            
    
Springboot使用AOP                            
    
链表经典面试题（三）                            
    
Nuxt.js头部魔法：轻松自定义页面元信息，提升用户体验                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/qq_46644680/article/details/133096070
                
    •