• 使用GoogleNet网络实现花朵分类

    一.数据集准备

    新建一个项目文件夹GoogleNet，并在里面建立data_set文件夹用来保存数据集，在data_set文件夹下创建新文件夹"flower_data"，点击链接下载花分类数据集https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz，会下载一个压缩包，将它解压到flower_data文件夹下，执行"split_data.py"脚本自动将数据集划分成训练集train和验证集val。

     split.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.     cwd = os.getcwd()
    22.     data_root = os.path.join(cwd, "flower_data")
    23.     origin_flower_path = os.path.join(data_root, "flower_photos")
    24.     assert os.path.exists(origin_flower_path), "path '{}' does not exist.".format(origin_flower_path)
    25.  
    26.     flower_class = [cla for cla in os.listdir(origin_flower_path)
    27.                     if os.path.isdir(os.path.join(origin_flower_path, cla))]
    28.  
    29.     # 建立保存训练集的文件夹
    30.     train_root = os.path.join(data_root, "train")
    31.     mk_file(train_root)
    32.     for cla in flower_class:
    33.         # 建立每个类别对应的文件夹
    34.         mk_file(os.path.join(train_root, cla))
    35.  
    36.     # 建立保存验证集的文件夹
    37.     val_root = os.path.join(data_root, "val")
    38.     mk_file(val_root)
    39.     for cla in flower_class:
    40.         # 建立每个类别对应的文件夹
    41.         mk_file(os.path.join(val_root, cla))
    42.  
    43.     for cla in flower_class:
    44.         cla_path = os.path.join(origin_flower_path, cla)
    45.         images = os.listdir(cla_path)
    46.         num = len(images)
    47.         # 随机采样验证集的索引
    48.         eval_index = random.sample(images, k=int(num*split_rate))
    49.         for index, image in enumerate(images):
    50.             if image in eval_index:
    51.                 # 将分配至验证集中的文件复制到相应目录
    52.                 image_path = os.path.join(cla_path, image)
    53.                 new_path = os.path.join(val_root, cla)
    54.                 copy(image_path, new_path)
    55.             else:
    56.                 # 将分配至训练集中的文件复制到相应目录
    57.                 image_path = os.path.join(cla_path, image)
    58.                 new_path = os.path.join(train_root, cla)
    59.                 copy(image_path, new_path)
    60.             print("\r[{}] processing [{}/{}]".format(cla, index+1, num), end="")  # processing bar
    61.         print()
    62.  
    63.     print("processing done!")
    64.  
    65.  
    66. if __name__ == '__main__':
    67.     main()

    之后会在文件夹下生成train和val数据集，到此，完成了数据集的准备。

    二.定义网络

    新建model.py，参照GoogleNet的网络结构和pytorch官方给出的代码，对代码进行略微的修改即可，在他的代码里首先定义了三个类BasicConv2d、Inception、InceptionAux，即基础卷积、Inception模块、辅助分类器三个部分，接着定义了GoogleNet类，对上述三个类进行调用，完成前向传播。

    pytorch官方示例GoogleNet代码

    1. import warnings
    2. from collections import namedtuple
    3. from functools import partial
    4. from typing import Any, Callable, List, Optional, Tuple
    5.  
    6. import torch
    7. import torch.nn as nn
    8. import torch.nn.functional as F
    9. from torch import Tensor
    10.  
    11.  
    12. class GoogLeNet(nn.Module):
    13.     def __init__(self, num_classes = 1000, aux_logits = True, transform_input = False, init_weights = True):
    14.         super(GoogLeNet,self).__init__()
    15.  
    16.         self.aux_logits = aux_logits
    17.         self.transform_input = transform_input
    18.  
    19.         self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3)   #3为输入通道数，64为输出通道数
    20.         self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
    21.         self.conv2 = BasicConv2d(64, 64, kernel_size=1)
    22.         self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1)
    23.         self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
    24.  
    25.         self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
    26.         self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
    27.         self.maxpool3 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
    28.  
    29.         self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)
    30.         self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)
    31.         self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)
    32.         self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)
    33.         self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)
    34.         self.maxpool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
    35.  
    36.         self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
    37.         self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)
    38.  
    39.         if aux_logits:
    40.             self.aux1 = InceptionAux(512, num_classes)
    41.             self.aux2 = InceptionAux(528, num_classes)
    42.  
    43.         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))   #自适应平均池化下采样，对于任意尺寸的特征向量，都得到1*1特征矩阵
    44.         self.dropout = nn.Dropout(0.4)
    45.         self.fc = nn.Linear(1024, num_classes)
    46.  
    47.         if init_weights:
    48.             for m in self.modules():
    49.                 if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
    50.                     torch.nn.init.trunc_normal_(m.weight, mean=0.0, std=0.01, a=-2, b=2)
    51.                 elif isinstance(m, nn.BatchNorm2d):
    52.                     nn.init.constant_(m.weight, 1)
    53.                     nn.init.constant_(m.bias, 0)
    54.  
    55.     def _transform_input(self, x):
    56.         if self.transform_input:
    57.             x_ch0 = torch.unsqueeze(x[:, 0], 1) * (0.229 / 0.5) + (0.485 - 0.5) / 0.5
    58.             x_ch1 = torch.unsqueeze(x[:, 1], 1) * (0.224 / 0.5) + (0.456 - 0.5) / 0.5
    59.             x_ch2 = torch.unsqueeze(x[:, 2], 1) * (0.225 / 0.5) + (0.406 - 0.5) / 0.5
    60.             x = torch.cat((x_ch0, x_ch1, x_ch2), 1)
    61.         return x
    62.         
    63.     def forward(self, x):
    64.         x = self._transform_input(x)
    65.  
    66.         # N x 3 x 224 x 224 ---- batch_size cahnnel height width
    67.         x = self.conv1(x)
    68.         # N x 64 x 112 x 112
    69.         x = self.maxpool1(x)
    70.         # N x 64 x 56 x 56
    71.         x = self.conv2(x)
    72.         # N x 64 x 56 x 56
    73.         x = self.conv3(x)
    74.         # N x 192 x 56 x 56
    75.         x = self.maxpool2(x)
    76.  
    77.         # N x 192 x 28 x 28
    78.         x = self.inception3a(x)
    79.         # N x 256 x 28 x 28
    80.         x = self.inception3b(x)
    81.         # N x 480 x 28 x 28
    82.         x = self.maxpool3(x)
    83.         # N x 480 x 14 x 14
    84.         x = self.inception4a(x)
    85.          # N x 512 x 14 x 14
    86.         if self.training and self.aux_logits:
    87.             aux1 = self.aux1(x)
    88.  
    89.         x = self.inception4b(x)
    90.         # N x 512 x 14 x 14
    91.         x = self.inception4c(x)
    92.         # N x 512 x 14 x 14
    93.         x = self.inception4d(x)
    94.         # N x 528 x 14 x 14
    95.         if self.training and self.aux_logits:
    96.             aux2 = self.aux2(x)
    97.  
    98.         x = self.inception4e(x)
    99.         # N x 832 x 14 x 14
    100.         x = self.maxpool4(x)
    101.         # N x 832 x 7 x 7
    102.         x = self.inception5a(x)
    103.         # N x 832 x 7 x 7
    104.         x = self.inception5b(x)
    105.         # N x 1024 x 7 x 7
    106.  
    107.         x = self.avgpool(x)
    108.         # N x 1024 x 1 x 1
    109.         x = torch.flatten(x, 1)
    110.         # N x 1024
    111.         x = self.dropout(x)
    112.         x = self.fc(x)
    113.         # N x 1000 (num_classes)
    114.         if self.training and self.aux_logits:
    115.             return x, aux2, aux1
    116.         return x
    117.  
    118.  
    119. class Inception(nn.Module):
    120.     def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
    121.         super(Inception, self).__init__()
    122.         self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1)
    123.  
    124.         self.branch2 = nn.Sequential(
    125.             BasicConv2d(in_channels, ch3x3red, kernel_size=1), 
    126.             BasicConv2d(ch3x3red, ch3x3, kernel_size=3, padding=1)  # 保证输出大小等于输入大小
    127.         )
    128.  
    129.         self.branch3 = nn.Sequential(
    130.             BasicConv2d(in_channels, ch5x5red, kernel_size=1),
    131.             BasicConv2d(ch5x5red, ch5x5, kernel_size=3, padding=1),  # 保证输出大小等于输入大小
    132.         )
    133.  
    134.         self.branch4 = nn.Sequential(
    135.             nn.MaxPool2d(kernel_size=3, stride=1, padding=1, ceil_mode=True),
    136.             BasicConv2d(in_channels, pool_proj, kernel_size=1),
    137.         )
    138.  
    139.     def forward(self, x):
    140.         branch1 = self.branch1(x)
    141.         branch2 = self.branch2(x)
    142.         branch3 = self.branch3(x)
    143.         branch4 = self.branch4(x)
    144.  
    145.         outputs = [branch1, branch2, branch3, branch4]
    146.         return torch.cat(outputs, 1)   #batch channel hetght width，在channel上拼接
    147.  
    148.  
    149. class InceptionAux(nn.Module):
    150.     def __init__(self, in_channels, num_classes):
    151.         super(InceptionAux, self).__init__()
    152.         self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)
    153.         self.conv = BasicConv2d(in_channels, 128, kernel_size=1)  # output[batch, 128, 4, 4]
    154.  
    155.         self.fc1 = nn.Linear(2048, 1024)
    156.         self.fc2 = nn.Linear(1024, num_classes)
    157.  
    158.     def forward(self, x):
    159.         # aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14
    160.         x = self.averagePool(x)
    161.         # aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4
    162.         x = self.conv(x)
    163.         # N x 128 x 4 x 4
    164.         x = torch.flatten(x, 1)
    165.         x = F.dropout(x, 0.5, training=self.training)
    166.         # N x 2048
    167.         x = F.relu(self.fc1(x), inplace=True)
    168.         x = F.dropout(x, 0.5, training=self.training)
    169.         # N x 1024
    170.         x = self.fc2(x)
    171.         # N x 1000 (num_classes)
    172.  
    173.         return x
    174.  
    175.  
    176. class BasicConv2d(nn.Module):
    177.     def __init__(self, in_channels, out_channels, **kwargs):
    178.         super(BasicConv2d, self).__init__()
    179.         self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
    180.         self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
    181.  
    182.     def forward(self, x):
    183.         x = self.conv(x)
    184.         x = self.bn(x)
    185.         return F.relu(x, inplace=True)
    186.  
    187. if __name__ == "__main__":
    188.     googlenet = GoogLeNet(num_classes = 3, aux_logits = True, transform_input = False, init_weights = True)
    189.     in_data = torch.randn(1, 3, 224, 224)
    190.     out = googlenet(in_data)
    191.     print(out)

    完成网络的定义之后，可以单独执行一下这个文件，用来验证网络定义的是否正确。如果可以正确输出，就没问题。

    三.开始训练

     加载数据集

    首先定义一个字典，用于用于对train和val进行预处理，包括裁剪成224*224大小，训练集随机水平翻转（一般验证集不需要此操作），转换成张量，图像归一化。

    然后利用DataLoader模块加载数据集，并设置batch_size为32，同时，设置数据加载器的工作进程数nw，加快速度。

    1. data_transform = {
    2.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    3.                                      transforms.RandomHorizontalFlip(),
    4.                                      transforms.ToTensor(),
    5.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    6.         "val": transforms.Compose([transforms.Resize((224, 224)),
    7.                                    transforms.ToTensor(),
    8.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    9.  
    10.     # 获取数据集路径
    11.     image_path = os.path.join(os.getcwd(), "data_set", "flower_data")  # flower data set path
    12.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    13.     # 加载数据集，准备读取
    14.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),transform=data_transform["train"])
    15.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"), transform=data_transform["val"])
    16.  
    17.     nw = min([os.cpu_count(), 32 if 32 > 1 else 0, 8])  # number of workers
    18.     print(f'Using {nw} dataloader workers every process')
    19.     # 加载数据集
    20.     train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=nw)
    21.     validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=32, shuffle=False, num_workers=nw)
    22.     train_num = len(train_dataset)
    23.     val_num = len(validate_dataset)
    24.     print(f"using {train_num} images for training, {val_num} images for validation.")

    生成json文件

    将训练数据集的类别标签转换为字典格式，并将其写入名为'class_indices.json'的文件中。

    1. 从train_dataset中获取类别标签到索引的映射关系，存储在flower_list变量中。
    2. 使用列表推导式将flower_list中的键值对反转，得到一个新的字典cla_dict，其中键是原始类别标签，值是对应的索引。
    3. 使用json.dumps()函数将cla_dict转换为JSON格式的字符串，设置缩进为4个空格。
    4. 使用with open()语句以写入模式打开名为'class_indices.json'的文件，并将JSON字符串写入文件。
    1. # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4} 雏菊 蒲公英 玫瑰 向日葵 郁金香
    2.     # 从训练集中获取类别标签到索引的映射关系，存储在flower_list变量
    3.     flower_list = train_dataset.class_to_idx
    4.     # 使用列表推导式将flower_list中的键值对反转，得到一个新的字典cla_dict
    5.     cla_dict = dict((val, key) for key, val in flower_list.items())
    6.     # write dict into json file，将cla_dict转换为JSON格式的字符串
    7.     json_str = json.dumps(cla_dict, indent=4)
    8.     with open('class_indices.json', 'w') as json_file:
    9.         json_file.write(json_str)

    定义网络，开始训练

    首先定义网络对象net，传入要分类的类别数为5，使用辅助分类器并初始化权重；在这里训练30轮，并使用train_bar = tqdm(train_loader, file=sys.stdout)来可视化训练进度条，loss计算采用了GoogleNet原论文的方法，进行加权计算，之后再进行反向传播和参数更新;同时，每一轮训练完成都要进行学习率更新；之后开始对验证集进行计算精确度，完成后保存模型。

    1.     net = GoogLeNet(num_classes=5, aux_logits=True, init_weights=True)
    2.     net.to(device)
    3.     loss_function = nn.CrossEntropyLoss()
    4.     optimizer = optim.Adam(net.parameters(), lr=0.0003)
    5.     sculer = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1)
    6.     
    7.  
    8.     epochs = 30
    9.     best_acc = 0.0
    10.     train_steps = len(train_loader)
    11.     for epoch in range(epochs):
    12.         # train
    13.         net.train()
    14.         running_loss = 0.0
    15.         train_bar = tqdm(train_loader, file=sys.stdout)
    16.         for step, data in enumerate(train_bar):
    17.             imgs, labels = data
    18.             optimizer.zero_grad()
    19.             logits, aux_logits2, aux_logits1 = net(imgs.to(device))
    20.             loss0 = loss_function(logits, labels.to(device))
    21.             loss1 = loss_function(aux_logits1, labels.to(device))
    22.             loss2 = loss_function(aux_logits2, labels.to(device))
    23.             loss = loss0 + loss1 * 0.3 + loss2 * 0.3
    24.             loss.backward()
    25.             optimizer.step()
    26.  
    27.             # print statistics
    28.             running_loss += loss.item()
    29.  
    30.             train_bar.desc = f"train epoch[{epoch+1}/{epochs}] loss:{loss:.3f}"
    31.  
    32.         sculer.step()
    33.  
    34.         # validate
    35.         net.eval()
    36.         acc = 0.0  # accumulate accurate number / epoch
    37.         with torch.no_grad():
    38.             val_bar = tqdm(validate_loader, file=sys.stdout)
    39.             for val_data in val_bar:
    40.                 val_imgs, val_labels = val_data
    41.                 outputs = net(val_imgs.to(device))  # eval model only have last output layer
    42.                 predict_y = torch.max(outputs, dim=1)[1]
    43.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
    44.  
    45.         val_accurate = acc / val_num
    46.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
    47.               (epoch + 1, running_loss / train_steps, val_accurate))
    48.  
    49.         if val_accurate > best_acc:
    50.             best_acc = val_accurate
    51.             torch.save(net,"./googleNet.pth")
    52.  
    53.     print('Finished Training')

    最后对代码进行整理，完整的train.py如下

    1. import os
    2. import sys
    3. import json
    4.  
    5. import torch
    6. import torch.nn as nn
    7. from torchvision import transforms, datasets
    8. from torch.utils.data import DataLoader
    9. import torch.optim as optim
    10. from tqdm import tqdm
    11.  
    12. from model import GoogLeNet
    13.  
    14.  
    15. def main():
    16.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    17.     print(f"using {device} device.")
    18.  
    19.     data_transform = {
    20.         "train": transforms.Compose([transforms.RandomResizedCrop(224),
    21.                                      transforms.RandomHorizontalFlip(),
    22.                                      transforms.ToTensor(),
    23.                                      transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
    24.         "val": transforms.Compose([transforms.Resize((224, 224)),
    25.                                    transforms.ToTensor(),
    26.                                    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}
    27.  
    28.     # 获取数据集路径
    29.     image_path = os.path.join(os.getcwd(), "data_set", "flower_data")  # flower data set path
    30.     assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    31.     # 加载数据集，准备读取
    32.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),transform=data_transform["train"])
    33.     validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"), transform=data_transform["val"])
    34.  
    35.     nw = min([os.cpu_count(), 32 if 32 > 1 else 0, 8])  # number of workers
    36.     print(f'Using {nw} dataloader workers every process')
    37.     # 加载数据集
    38.     train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=nw)
    39.     validate_loader = torch.utils.data.DataLoader(validate_dataset, batch_size=32, shuffle=False, num_workers=nw)
    40.     train_num = len(train_dataset)
    41.     val_num = len(validate_dataset)
    42.     print(f"using {train_num} images for training, {val_num} images for validation.") 
    43.  
    44.     # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4} 雏菊 蒲公英 玫瑰 向日葵 郁金香
    45.     # 从训练集中获取类别标签到索引的映射关系，存储在flower_list变量
    46.     flower_list = train_dataset.class_to_idx
    47.     # 使用列表推导式将flower_list中的键值对反转，得到一个新的字典cla_dict
    48.     cla_dict = dict((val, key) for key, val in flower_list.items())
    49.     # write dict into json file，将cla_dict转换为JSON格式的字符串
    50.     json_str = json.dumps(cla_dict, indent=4)
    51.     with open('class_indices.json', 'w') as json_file:
    52.         json_file.write(json_str)
    53.  
    54.  
    55.     """如果要使用官方的预训练权重，注意是将权重载入官方的模型，不是我们自己实现的模型
    56.     官方的模型中使用了bn层以及改了一些参数，不能混用
    57.     import torchvision
    58.     net = torchvision.models.googlenet(num_classes=5)
    59.     model_dict = net.state_dict()
    60.     # 预训练权重下载地址: https://download.pytorch.org/models/googlenet-1378be20.pth
    61.     pretrain_model = torch.load("googlenet.pth")
    62.     del_list = ["aux1.fc2.weight", "aux1.fc2.bias",
    63.                 "aux2.fc2.weight", "aux2.fc2.bias",
    64.                 "fc.weight", "fc.bias"]
    65.     pretrain_dict = {k: v for k, v in pretrain_model.items() if k not in del_list}
    66.     model_dict.update(pretrain_dict)
    67.     net.load_state_dict(model_dict)"""
    68.     net = GoogLeNet(num_classes=5, aux_logits=True, init_weights=True)
    69.     net.to(device)
    70.     loss_function = nn.CrossEntropyLoss()
    71.     optimizer = optim.Adam(net.parameters(), lr=0.0003)
    72.     sculer = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1)
    73.     
    74.  
    75.     epochs = 30
    76.     best_acc = 0.0
    77.     train_steps = len(train_loader)
    78.     for epoch in range(epochs):
    79.         # train
    80.         net.train()
    81.         running_loss = 0.0
    82.         train_bar = tqdm(train_loader, file=sys.stdout)
    83.         for step, data in enumerate(train_bar):
    84.             imgs, labels = data
    85.             optimizer.zero_grad()
    86.             logits, aux_logits2, aux_logits1 = net(imgs.to(device))
    87.             loss0 = loss_function(logits, labels.to(device))
    88.             loss1 = loss_function(aux_logits1, labels.to(device))
    89.             loss2 = loss_function(aux_logits2, labels.to(device))
    90.             loss = loss0 + loss1 * 0.3 + loss2 * 0.3
    91.             loss.backward()
    92.             optimizer.step()
    93.  
    94.             # print statistics
    95.             running_loss += loss.item()
    96.  
    97.             train_bar.desc = f"train epoch[{epoch+1}/{epochs}] loss:{loss:.3f}"
    98.  
    99.         sculer.step()
    100.  
    101.         # validate
    102.         net.eval()
    103.         acc = 0.0  # accumulate accurate number / epoch
    104.         with torch.no_grad():
    105.             val_bar = tqdm(validate_loader, file=sys.stdout)
    106.             for val_data in val_bar:
    107.                 val_imgs, val_labels = val_data
    108.                 outputs = net(val_imgs.to(device))  # eval model only have last output layer
    109.                 predict_y = torch.max(outputs, dim=1)[1]
    110.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
    111.  
    112.         val_accurate = acc / val_num
    113.         print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
    114.               (epoch + 1, running_loss / train_steps, val_accurate))
    115.  
    116.         if val_accurate > best_acc:
    117.             best_acc = val_accurate
    118.             torch.save(net,"./googleNet.pth")
    119.  
    120.     print('Finished Training')
    121.  
    122.  
    123. if __name__ == '__main__':
    124.     main()

    四.模型预测

    新建一个predict.py文件用于预测，将输入图像处理后转换成张量格式，img = torch.unsqueeze(img, dim=0)是在输入图像张量 img 的第一个维度上增加一个大小为1的维度，因此将图像张量的形状从 [通道数， 高度， 宽度 ] 转换为 [1, 通道数， 高度， 宽度]。然后加载模型进行预测，并打印出结果，同时可视化。

    1. import os
    2. import json
    3.  
    4. import torch
    5. from PIL import Image
    6. from torchvision import transforms
    7. import matplotlib.pyplot as plt
    8.  
    9. from model import GoogLeNet
    10.  
    11.  
    12. def main():
    13.     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    14.  
    15.     data_transform = transforms.Compose(
    16.         [transforms.Resize((224, 224)),
    17.          transforms.ToTensor(),
    18.          transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    19.  
    20.     # load image
    21.     img = Image.open("./2678588376_6ca64a4a54_n.jpg")
    22.     plt.imshow(img)
    23.     # [N, C, H, W]
    24.     img = data_transform(img)
    25.     # expand batch dimension
    26.     img = torch.unsqueeze(img, dim=0)
    27.  
    28.     # read class_indict
    29.     with open("./class_indices.json", "r") as f:
    30.         class_indict = json.load(f)
    31.  
    32.     # create model
    33.     model = GoogLeNet(num_classes=5, aux_logits=False).to(device)
    34.     model=torch.load("/home/lm/GoogleNet/googleNet.pth")
    35.  
    36.     model.eval()
    37.     with torch.no_grad():
    38.         # predict class
    39.         output = torch.squeeze(model(img.to(device))).cpu()
    40.         predict = torch.softmax(output, dim=0)
    41.         predict_class = torch.argmax(predict).numpy()
    42.  
    43.     print_result = f"class: {class_indict[str(predict_class)]}   prob: {predict[predict_class].numpy():.3}"
    44.                                              
    45.     plt.title(print_result)
    46.     for i in range(len(predict)):
    47.         print(f"class: {class_indict[str(i)]:10}   prob: {predict[i].numpy():.3}")
    48.     plt.show()
    49.  
    50.  
    51. if __name__ == '__main__':
    52.     main()

    预测结果

    五.模型可视化

    将生成的pth文件导入netron工具，可视化结果为

    发现很不清晰，因此将它转换成多用于嵌入式设备部署的onnx格式

    编写onnx.py

    1. import torch
    2. import torchvision
    3. from model import GoogLeNet
    4.  
    5. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    6. model = GoogLeNet(num_classes=5, aux_logits=False).to(device)
    7. model=torch.load("/home/lm/GoogleNet/googleNet.pth")
    8. model.eval()
    9. example = torch.ones(1, 3, 244, 244)
    10. example = example.to(device)
    11. torch.onnx.export(model, example, "googleNet.onnx", verbose=True, opset_version=11)

     将生成的onnx文件导入，这样的可视化清晰了许多

    六.模型改进

    发现去掉学习率更新会提高准确率（从70%提升到83%），因此把train.py里面对应部分删掉。

    还有其他方法会在之后进行补充。

    源码地址：链接: https://pan.baidu.com/s/1FGcGwrNAZZSEocPORD3bZg 提取码: xsfn 复制这段内容后打开百度网盘手机App，操作更方便哦

  • 相关阅读:
    开源数字基础设施 项目 -- Speckle
    《吐血整理》高级系列教程-吃透Fiddler抓包教程(29)-Fiddler如何抓取Android7.0以上的Https包-终篇
    Android 固定WIFI热点路由IP
    国庆day3---网络编程知识点脑图整合
    既然有HTTP协议，为什么还要有RPC
    Auto.js中的悬浮窗
    如何减少电气设备漏电问题，其解决方案有哪些？
    消息队列-RabbitMQ-消息确认机制
    Spring Cloud Consul
    数据可视化（箱线图、直方图、散点图、联合分布图）
  • 原文地址：https://blog.csdn.net/qq_46454669/article/details/133960577