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

图像分类学习笔记（四）——GooLeNet_googlenet辅助分类器

作者：正经夜光杯 | 2024-08-21 15:18:27

赞

踩

googlenet辅助分类器

GooLeNet在2014年由Google团队提出，斩获当年ImageNet竞赛中Classification Task（分类任务）第一名。GoogLeNet在专注于加深网络结构的同时，引入了新的基本结构——Inception模块，在某种意义上更直接的增加了网络的深度。GoogLeNet一共22层，没有全连接层。

一、要点

  • 引入了Inception结构（融合不同尺度的特征信息），意味着提高准确率，不一定需要堆叠更深的层或者增加神经元个数等，可以转向研究更稀疏但是更精密的结构同样可以达到很好的效果。
  • 使用1×1的卷积核进行降维以及映射处理
  • 添加两个辅助分类器帮助训练
  • 丢弃全连接层，使用平均池化层（大大减少模型参数）

AlexNet和VGG都只有一个输出层，GooLeNet有三个输出层（其中两个辅助分类层）

 二、Inception结构

Inception模块的基本组成结构有四个：1x1卷积，3x3卷积，5x5卷积，3x3最大池化。最后再对四个成分运算结果在深度上进行拼接

核心思想：利用不同大小的卷积核实现不同尺度的感知，最后进行融合，可以探索特征图上不同邻域内的“相关性” 。

注意：每个分支所得的特征矩阵高和宽必须相同，否则无法沿深度方向进行拼接

（a）有两个缺点：

  • 所有卷积层直接和前一层输入的数据对接，所以卷积层中的计算量会很大；
  • 在这个单元中使用的最大池化层保留了输入数据的特征图的深度，所以在最后进行合并后总输出的特征图的深度一定会增加，这样增加了该单元之后的网络结构的计算量。

（b）改进了：

使用1x1 卷积核主要目的是进行压缩降维（调整输出通道数，即卷积核的个数），减少参数量（Pointwise Convolution（逐点卷积），简称PW卷积）

        假设输入通道数为Cin，原本是直接使用输出通道数为Cout的N*N卷积层来进行卷积，那么所需参数量为Cin×N×N×Cout；

        如果加上输出通道数为k的1×1卷积核的话，所需参数量为：Cin×k+k×N×N×Cout，只要k足够小就能使参数量大幅度下降了。

三、辅助分类器

因为神经网络的中间层也具有很强的识别能力，因此GoogLeNet中增加了两个辅助的softmax分支。

  • 第一层是平均池化下采样操作 ，池化核大小是5×5，步长为3，inception(4a)的辅助分类器输出大小是4×4×512，inception(4d)的辅助分类器的输出大小是4×4×528（有两个辅助分类器，分别在inception(4a)和inception(4d)）
  • 采用128个1×1的卷积核进行卷积处理，目的是降维，并且使用ReLU激活函数
  • 采用节点个数为1024的全连接层，使用ReLU激活函数
  • 在全连接层和全连接层之间使用dropout函数，以70%的比例随机失活神经元
  • 输出层，节点个数对应着类别个数（1000个），再通过softmax激活函数得到概率分布

作用：

  • 最主要的原因：为了避免梯度消失，用于向前传导梯度（反向传播时如果有一层求导为0，链式求导结果则为0）；
  • 将中间某一层的输出用作分类，起到模型融合作用。最终的分类结果以及这两个辅助分类器的结果（辅助分类按一个较小的权重加到最终分类结果中）一同决判出最终训练得到的分类结果。但在实际测试时，这两个辅助softmax分支会被去掉（因为辅助的主要原因是为了向前传导梯度，因此训练完后就没有价值了，理应扔掉）
  • 正则化的作用：防止过拟合

四、网络模型架构

LocalRespNorm层在AlexNet和VGG出现过，作用不大，在搭建过程中可以舍弃

 

 五、使用PyTorch搭建

（一）model.py

  1. import torch.nn as nn
  2. import torch
  3. import torch.nn.functional as F
  4.  
  5.  
  6. class GoogLeNet(nn.Module):
  7.     def __init__(self, num_classes=1000, aux_logits=True, init_weights=False):
  8.         super(GoogLeNet, self).__init__()
  9.         self.aux_logits = aux_logits
  10.  
  11.         self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3)
  12.         self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
  13.  
  14.         self.conv2 = BasicConv2d(64, 64, kernel_size=1)
  15.         self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1)
  16.         self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
  17.  
  18.         self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
  19.         self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
  20.         self.maxpool3 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
  21.  
  22.         self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)
  23.         self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)
  24.         self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)
  25.         self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)
  26.         self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)
  27.         self.maxpool4 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
  28.  
  29.         self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
  30.         self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)
  31.  
  32.         if self.aux_logits:
  33.             self.aux1 = InceptionAux(512, num_classes)
  34.             self.aux2 = InceptionAux(528, num_classes)
  35.  
  36.         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
  37.         self.dropout = nn.Dropout(0.4)
  38.         self.fc = nn.Linear(1024, num_classes)
  39.         if init_weights:
  40.             self._initialize_weights()
  41.  
  42.     def forward(self, x):
  43.         # N x 3 x 224 x 224
  44.         x = self.conv1(x)
  45.         # N x 64 x 112 x 112
  46.         x = self.maxpool1(x)
  47.         # N x 64 x 56 x 56
  48.         x = self.conv2(x)
  49.         # N x 64 x 56 x 56
  50.         x = self.conv3(x)
  51.         # N x 192 x 56 x 56
  52.         x = self.maxpool2(x)
  53.  
  54.         # N x 192 x 28 x 28
  55.         x = self.inception3a(x)
  56.         # N x 256 x 28 x 28
  57.         x = self.inception3b(x)
  58.         # N x 480 x 28 x 28
  59.         x = self.maxpool3(x)
  60.         # N x 480 x 14 x 14
  61.         x = self.inception4a(x)
  62.         # N x 512 x 14 x 14
  63.         if self.training and self.aux_logits:    # eval model lose this layer
  64.             aux1 = self.aux1(x)
  65.  
  66.         x = self.inception4b(x)
  67.         # N x 512 x 14 x 14
  68.         x = self.inception4c(x)
  69.         # N x 512 x 14 x 14
  70.         x = self.inception4d(x)
  71.         # N x 528 x 14 x 14
  72.         if self.training and self.aux_logits:    # eval model lose this layer
  73.             aux2 = self.aux2(x)
  74.  
  75.         x = self.inception4e(x)
  76.         # N x 832 x 14 x 14
  77.         x = self.maxpool4(x)
  78.         # N x 832 x 7 x 7
  79.         x = self.inception5a(x)
  80.         # N x 832 x 7 x 7
  81.         x = self.inception5b(x)
  82.         # N x 1024 x 7 x 7
  83.  
  84.         x = self.avgpool(x)
  85.         # N x 1024 x 1 x 1
  86.         x = torch.flatten(x, 1)
  87.         # N x 1024
  88.         x = self.dropout(x)
  89.         x = self.fc(x)
  90.         # N x 1000 (num_classes)
  91.         if self.training and self.aux_logits:   # eval model lose this layer
  92.             return x, aux2, aux1
  93.         return x
  94.  
  95.     def _initialize_weights(self):
  96.         for m in self.modules():
  97.             if isinstance(m, nn.Conv2d):
  98.                 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
  99.                 if m.bias is not None:
  100.                     nn.init.constant_(m.bias, 0)
  101.             elif isinstance(m, nn.Linear):
  102.                 nn.init.normal_(m.weight, 0, 0.01)
  103.                 nn.init.constant_(m.bias, 0)
  104.  
  105.  
  106. class Inception(nn.Module):
  107.     def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
  108.         super(Inception, self).__init__()
  109.  
  110.         self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1)
  111.  
  112.         self.branch2 = nn.Sequential(
  113.             BasicConv2d(in_channels, ch3x3red, kernel_size=1),
  114.             BasicConv2d(ch3x3red, ch3x3, kernel_size=3, padding=1)   # padding=1保证输出大小等于输入大小
  115.         )
  116.  
  117.         self.branch3 = nn.Sequential(
  118.             BasicConv2d(in_channels, ch5x5red, kernel_size=1),
  119.             # 在官方的实现中，其实是3x3的kernel并不是5x5，这里我也懒得改了，具体可以参考下面的issue
  120.             # Please see https://github.com/pytorch/vision/issues/906 for details.
  121.             BasicConv2d(ch5x5red, ch5x5, kernel_size=5, padding=2)   # 保证输出大小等于输入大小
  122.         )
  123.  
  124.         self.branch4 = nn.Sequential(
  125.             nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
  126.             BasicConv2d(in_channels, pool_proj, kernel_size=1)
  127.         )
  128.  
  129.     def forward(self, x):
  130.         branch1 = self.branch1(x)
  131.         branch2 = self.branch2(x)
  132.         branch3 = self.branch3(x)
  133.         branch4 = self.branch4(x)
  134.  
  135.         outputs = [branch1, branch2, branch3, branch4]
  136.         return torch.cat(outputs, 1)
  137.  
  138.  
  139. # 辅助分类器
  140. class InceptionAux(nn.Module):
  141.     def __init__(self, in_channels, num_classes):
  142.         super(InceptionAux, self).__init__()
  143.         self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)
  144.         self.conv = BasicConv2d(in_channels, 128, kernel_size=1)  # output[batch, 128, 4, 4]
  145.  
  146.         self.fc1 = nn.Linear(2048, 1024)
  147.         self.fc2 = nn.Linear(1024, num_classes)
  148.  
  149.     def forward(self, x):
  150.         # aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14
  151.         x = self.averagePool(x)
  152.         # aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4
  153.         x = self.conv(x)
  154.         # N x 128 x 4 x 4
  155.         x = torch.flatten(x, 1)
  156.         x = F.dropout(x, 0.5, training=self.training)
  157.         # N x 2048
  158.         x = F.relu(self.fc1(x), inplace=True)
  159.         x = F.dropout(x, 0.5, training=self.training)
  160.         # N x 1024
  161.         x = self.fc2(x)
  162.         # N x num_classes
  163.         return x
  164.  
  165.  
  166. class BasicConv2d(nn.Module):
  167.     def __init__(self, in_channels, out_channels, **kwargs):
  168.         super(BasicConv2d, self).__init__()
  169.         self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)
  170.         self.relu = nn.ReLU(inplace=True)
  171.  
  172.     def forward(self, x):
  173.         x = self.conv(x)
  174.         x = self.relu(x)
  175.         return x
  • output=torch.cat(inputs,dim=?)
    •  为了把多个Tensor进行拼接
    • inputs : 待连接的张量序列，可以是任意相同Tensor类型的python 序列
    • dim : 选择的扩维, 必须在0到len(inputs[0])之间，沿着此维连接张量序列
    • 代码中torch.cat(outputs, 1)，dim=1的原因是要在channel(深度)维度上合并，在pytorch中Tensor数据类型的通道排列顺序是batch,channels,height,width
      1. x1 = torch.tensor([[11,21,31],[21,31,41]],dtype=torch.int)
      2. x1.shape # torch.Size([2, 3])
      3.  
      4. x2 = torch.tensor([[12,22,32],[22,32,42]],dtype=torch.int)
      5. x2.shape  # torch.Size([2, 3])
      6.  
      7. inputs = [x1, x2]
      8. print(inputs)
      9. '打印查看'
      10. [tensor([[11, 21, 31],
      11.          [21, 31, 41]], dtype=torch.int32),
      12.  tensor([[12, 22, 32],
      13.          [22, 32, 42]], dtype=torch.int32)]
      14.  
      15.  
      16. In    [1]: torch.cat(inputs, dim=0).shape
      17. Out[1]: torch.Size([4,  3])
      18.  
      19. In    [2]: torch.cat(inputs, dim=1).shape
      20. Out[2]: torch.Size([2, 6])
      21.  
      22. In    [3]: torch.cat(inputs, dim=2).shape
      23. IndexError: Dimension out of range (expected to be in range of [-2, 1], but got 2)
  •  training=self.training
    • 当我们实例化一个模型model后，可以通过model.train()和model.eval()来控制模型的状态，在model.train()模式下self.training=True，在model.eval()模式下self.training=False
  • self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3)
    self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
    • 为了将特征矩阵的高和宽缩减为原来的一半，所以padding设为了3（(224-7+2×3)/2+1=112.5，在pytorch中默认向下取整，也就是112）
  • self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
    • 自适应的平均池化下采样的好处：无论输入的特征矩阵的尺寸大小，都能得到所指定的尺寸大小，这样就不用限定输入的尺寸了

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

  • 训练比较漫长，霹雳吧啦训练最好的结果达到了86.3%（迭代了30epoch）

（三）predict.py

  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:0" 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_path = "tulip.jpg"
  22.     assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
  23.     img = Image.open(img_path)
  24.     plt.imshow(img)
  25.     # [N, C, H, W]
  26.     img = data_transform(img)
  27.     # expand batch dimension
  28.     img = torch.unsqueeze(img, dim=0)
  29.  
  30.     # read class_indict
  31.     json_path = './class_indices.json'
  32.     assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
  33.  
  34.     with open(json_path, "r") as f:
  35.         class_indict = json.load(f)
  36.  
  37.     # create model
  38.     model = GoogLeNet(num_classes=5, aux_logits=False).to(device)
  39.  
  40.     # load model weights
  41.     weights_path = "./googleNet.pth"
  42.     assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
  43.     missing_keys, unexpected_keys = model.load_state_dict(torch.load(weights_path, map_location=device),
  44.                                                           strict=False)
  45.  
  46.     model.eval()
  47.     with torch.no_grad():
  48.         # predict class
  49.         output = torch.squeeze(model(img.to(device))).cpu()
  50.         predict = torch.softmax(output, dim=0)
  51.         predict_cla = torch.argmax(predict).numpy()
  52.  
  53.     print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
  54.                                                  predict[predict_cla].numpy())
  55.     plt.title(print_res)
  56.     for i in range(len(predict)):
  57.         print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
  58.                                                   predict[i].numpy()))
  59.     plt.show()
  60.  
  61.  
  62. if __name__ == '__main__':
  63.     main()
  • model = GoogLeNet(num_classes=5, aux_logits=False).to(device)
    • 在预测的时候，载入模型不需要辅助分类器，所以aux_logits设置为False
  • missing_keys, unexpected_keys = model.load_state_dict(torch.load(weights_path, map_location=device), strict=False)
    • 因为在训练过程中也会把辅助分类器的权重保存在文件中，所以将strict参数设置为False（默认是为True，会精准匹配当前模型和所需要载入的权重模型的结构），预测过程搭建的模型是没有辅助分类器的
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/1012355
推荐阅读
相关标签

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

  

闽ICP备14008679号