• GoogLeNet网络

    目录

    1. 创新点

    1.1 引入Inception结构

    1.2 1×1卷积降维

    1.3 两个辅助分类器 

    1.4 丢弃全连接层，使用平均池化层

    2. 网络结构

    3. 知识点

    3.1 torch.cat

    3.2 关于self.training

    3.3 关于load_state_dict中的strict

    4. 代码 

    4.1 model.py

    4.2 train.py

    4.3 predict.py

    5. 结果

    1. 创新点

    1.1 引入Inception结构

    作用：融合不同尺度的特征信息

    注意：每个分支所得特征矩阵的宽、高必须相同

    下图来自：Going deeper with convolutions

    1.2 1×1卷积降维

    channels: 512

    a.不使用1×1卷积核降维

    使用：64个5×5卷积核进行卷积

    参数：5×5×512×64=819,200

    b.使用1×1卷积核降维

    使用：24个1×1卷积核进行卷积

    1.3 两个辅助分类器 

    内容：GoogLeNet有三个输出层（两个为辅助分类层）

     Going deeper with convolutions文章里：

    • An average pooling layer with 5×5 filter size and stride 3, resulting in an 4×4×512 output for the (4a), and 4×4×528 for the (4d) stage.
    • A 1×1 convolution with 128 filters for dimension reduction and rectified linear activation.
    • A fully connected layer with 1024 units and rectified linear activation.
    • A dropout layer with 70% ratio of dropped outputs.
    • A linear layer with softmax loss as the classifier (predicting the same 1000 classes as the main classifier, but removed at inference time).

    1.4 丢弃全连接层，使用平均池化层

    作用：大大减少模型的参数

    2. 网络结构

    Inception层太多，列出几个：

    3. 知识点

    3.1 torch.cat

    1. import torch
    2.  
    3. a = torch.Tensor([1, 2, 3])
    4. b = torch.Tensor([4, 5, 6])
    5. c = [a, b]
    6. print(torch.cat(c))
    7. # tensor([1., 2., 3., 4., 5., 6.])

    3.2 关于self.training

    使用model.train()和model.eval()控制模型的状态

    在model.train()模式下self.training=True

    在model.eval()模式下self.training=False

    3.3 关于load_state_dict中的strict

    为True：有什么要什么，每一个键都有（默认为True）

    为False：有什么要什么，没有的就不要

    missing_keys和unexpected_keys：缺失的、不期望的键

    4. 代码 

    4.1 model.py

    1. import torch
    2. import torch.nn as nn
    3. import torch.nn.functional as F
    4.  
    5. class GoogLeNet(nn.Module):
    6.     def __init__(self, num_classes=1000, aux_use=True, init_weight=False):
    7.         super(GoogLeNet, self).__init__()
    8.         self.aux_use = aux_use
    9.         self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3)
    10.         self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)  # ceil_mode默认向下取整 True为向上取整
    11.         self.conv2 = BasicConv2d(64, 64, kernel_size=1)
    12.         self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1)
    13.         self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)
    14.         self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
    15.         self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
    16.         self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)
    17.         self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)
    18.         self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)
    19.         self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)
    20.         self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)
    21.         self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)
    22.         self.maxpool4 = nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)
    23.         self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
    24.         self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)
    25.  
    26.         if self.aux_use:
    27.             self.aux1 = InceptionAux(512, num_classes)
    28.             self.aux2 = InceptionAux(528, num_classes)
    29.  
    30.         self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # 自适应平均池化 指定输出（H,W）
    31.         self.dropout = nn.Dropout(0.4)
    32.         self.fc = nn.Linear(1024, num_classes)
    33.         if init_weight:
    34.             self._initialize_weights_()
    35.  
    36.     def forward(self, x):
    37.         # N×3×224×224
    38.         x = self.conv1(x)
    39.         x = self.maxpool1(x)
    40.         x = self.conv2(x)
    41.         x = self.conv3(x)
    42.         x = self.maxpool2(x)
    43.         x = self.inception3a(x)
    44.         x = self.inception3b(x)
    45.         x = self.maxpool3(x)
    46.         x = self.inception4a(x)
    47.         if self.training and self.aux_use:
    48.             aux1 = self.aux1(x)
    49.         x = self.inception4b(x)
    50.         x = self.inception4c(x)
    51.         x = self.inception4d(x)
    52.         if self.training and self.aux_use:
    53.             aux2 = self.aux2(x)
    54.         x = self.inception4e(x)
    55.         x = self.maxpool4(x)
    56.         x = self.inception5a(x)
    57.         x = self.inception5b(x)
    58.         x = self.avgpool(x)
    59.         x = torch.flatten(x, start_dim=1)
    60.         x = self.dropout(x)
    61.         x = self.fc(x)
    62.         if self.training and self.aux_use:
    63.             return x, aux1, aux2
    64.         return x;
    65.  
    66.     def _initialize_weights_(self):
    67.         for v in self.modules():
    68.             if isinstance(v, nn.Conv2d):
    69.                 nn.init.xavier_uniform_(v.weight)
    70.                 if v.bias is not None:
    71.                     nn.init.constant_(v.bias, 0)
    72.             if isinstance(v, nn.Linear):
    73.                 nn.init.xavier_uniform_(v.weight)
    74.                 if v.bias is not None:
    75.                     nn.init.constant_(v.bias, 0)
    76.  
    77.  
    78. # set BasicConv2d class
    79. class BasicConv2d(nn.Module):
    80.     def __init__(self, in_channels, out_channels, **kwargs):
    81.         super(BasicConv2d, self).__init__()
    82.         self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)
    83.         self.relu = nn.ReLU(inplace=True)
    84.  
    85.     def forward(self, x):
    86.         x = self.conv(x)
    87.         x = self.relu(x)
    88.         return x;
    89.  
    90.  
    91. # set Inception class
    92. class Inception(nn.Module):
    93.     # 各分支最后的输出宽高要一样
    94.     def __init__(self, in_channels, ch11, ch33_reduce, ch33, ch55_reduce, ch55, pool_proj):
    95.         super(Inception, self).__init__()
    96.         self.branch1 = BasicConv2d(in_channels, ch11, kernel_size=1)
    97.         self.branch2 = nn.Sequential(
    98.             BasicConv2d(in_channels, ch33_reduce, kernel_size=1),
    99.             BasicConv2d(ch33_reduce, ch33, kernel_size=3, padding=1)
    100.         )
    101.         self.branch3 = nn.Sequential(
    102.             BasicConv2d(in_channels, ch55_reduce, kernel_size=1),
    103.             BasicConv2d(ch55_reduce, ch55, kernel_size=5, padding=2)
    104.         )
    105.         self.branch4 = nn.Sequential(
    106.             nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
    107.             BasicConv2d(in_channels, pool_proj, kernel_size=1)
    108.         )
    109.  
    110.     def forward(self, x):
    111.         branch1 = self.branch1(x)
    112.         branch2 = self.branch2(x)
    113.         branch3 = self.branch3(x)
    114.         branch4 = self.branch4(x)
    115.         outputs = [branch1, branch2, branch3, branch4]
    116.         return torch.cat(outputs, dim=1)
    117.  
    118.  
    119. # set InceptionAux class
    120. class InceptionAux(nn.Module):
    121.     def __init__(self, in_channels, num_classes):
    122.         super(InceptionAux, self).__init__()
    123.         self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)
    124.         self.conv = BasicConv2d(in_channels, 128, kernel_size=1)  # output:[batch,128,4,4]
    125.         self.fc1 = nn.Linear(2048, 1024)
    126.         self.fc2 = nn.Linear(1024, num_classes)
    127.  
    128.     def forward(self, x):
    129.         # Input: Aux1(batch,512,14,14) Aux2(batch,528,14,14)
    130.         x = self.averagePool(x)
    131.         # output: Aux1(batch,512,4,4) Aux2(batch,528,4,4)
    132.         x = self.conv(x)
    133.         # output:Aux1、Aux2(batch,128,4,4)
    134.         x = torch.flatten(x, start_dim=1)
    135.         x = F.dropout(x, 0.5, training=self.training)
    136.         # batch × 2048
    137.         x = F.relu(self.fc1(x), inplace=True)
    138.         x = F.dropout(x, 0.5, training=self.training)
    139.         # batch × 1024
    140.         x = self.fc2(x)
    141.         # batch × num_classes
    142.         return x

    4.2 train.py

    1. import os
    2. import sys
    3.  
    4. import torch
    5. import torch.nn as nn
    6. import torchvision
    7. from torchvision import transforms, datasets
    8. import json
    9. from model import GoogLeNet
    10. import torch.optim as optim
    11. from tqdm import tqdm
    12.  
    13. def main():
    14.     device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    15.     data_transform = {
    16.         'train': transforms.Compose([
    17.             transforms.RandomResizedCrop(224),
    18.             transforms.RandomHorizontalFlip(),
    19.             transforms.ToTensor(),
    20.             transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    21.         ]),
    22.         'val': transforms.Compose([
    23.             transforms.Resize((224, 224)),
    24.             transforms.ToTensor(),
    25.             transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    26.         ])
    27.     }
    28.     data_root = os.path.abspath(os.getcwd())
    29.     image_path = os.path.join(data_root, 'data_set', 'flower_data')
    30.     assert os.path.exists(image_path), 'file:{} is not exist!'.format(image_path)
    31.  
    32.     # set dataset
    33.     train_dataset = datasets.ImageFolder(root=os.path.join(image_path, 'train'), transform=data_transform['train'])
    34.     val_dataset = datasets.ImageFolder(root=os.path.join(image_path, 'val'), transform=data_transform['val'])
    35.     train_num = len(train_dataset)
    36.     val_num = len(val_dataset)
    37.  
    38.     # write dict into file
    39.     flower_list = train_dataset.class_to_idx
    40.     class_dict = dict((k, v) for v, k in flower_list.items())
    41.     json_str = json.dumps(class_dict, indent=4)
    42.     with open('./class_indices.json', 'w') as file:
    43.         file.write(json_str)
    44.  
    45.     # set dataloader
    46.     batch_size = 32
    47.     train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
    48.     val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=0)
    49.     print('using {} images for training, {} images for validation.'.format(train_num, val_num))
    50.  
    51.     net = GoogLeNet(num_classes=5, aux_use=True, init_weight=True)
    52.     net.to(device)
    53.     loss_function = nn.CrossEntropyLoss()
    54.     optimizer = optim.Adam(net.parameters(), lr=0.0003)
    55.  
    56.     epochs = 30
    57.     best_acc = 0.0
    58.     save_path = './GoogLeNet.pth'
    59.     train_steps = len(train_loader)
    60.     for epoch in range(epochs):
    61.         # train
    62.         net.train()
    63.         epoch_loss = 0.0
    64.         train_bar = tqdm(train_loader)
    65.         for step, data in enumerate(train_bar):
    66.             images, labels = data
    67.             optimizer.zero_grad()
    68.             output, aux1_output, aux2_output = net(images.to(device))
    69.             loss0 = loss_function(output, labels.to(device))
    70.             loss1 = loss_function(aux1_output, labels.to(device))
    71.             loss2 = loss_function(aux2_output, labels.to(device))
    72.             loss = loss0 + 0.3 * loss1 + 0.3 * loss2
    73.             loss.backward()
    74.             optimizer.step()
    75.             # print statistics
    76.             epoch_loss += loss.item()
    77.             train_bar.desc = 'train epoch[{}/{}] loss:{:.3f}'.format(epoch + 1, epochs, loss)
    78.  
    79.         # validate
    80.         net.eval()
    81.         acc = 0.0
    82.         with torch.no_grad():
    83.             val_bar = tqdm(val_loader)
    84.             for step, data in enumerate(val_bar):
    85.                 val_images, val_labels = data
    86.                 outputs = net(val_images.to(device))
    87.                 predict_y = torch.argmax(outputs, dim=1)
    88.                 acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
    89.         val_acc = acc / val_num
    90.         print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' % (epoch + 1, epoch_loss / train_steps, val_acc))
    91.  
    92.         if val_acc > best_acc:
    93.             best_acc = val_acc
    94.             torch.save(net.state_dict(), save_path)
    95.     print('Finished Training!')
    96.  
    97.  
    98. if __name__ == '__main__':
    99.     main()

    4.3 predict.py

    1. import os
    2. import torch
    3. import torchvision
    4. from torchvision import transforms
    5. from PIL import Image
    6. import matplotlib.pyplot as plt
    7. import json
    8. from model import GoogLeNet
    9.  
    10. def main():
    11.     device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
    12.     transform = transforms.Compose([
    13.         transforms.Resize((224, 224)),
    14.         transforms.ToTensor(),
    15.         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    16.     ])
    17.  
    18.     img_path = './sunflower.jpg'
    19.     assert os.path.exists(img_path), 'file:{} is not exist!'.format(img_path)
    20.     img = Image.open(img_path)
    21.     plt.imshow(img)
    22.  
    23.     # [N,C,H,W]
    24.     img = transform(img)
    25.     img = torch.unsqueeze(img, dim=0)
    26.  
    27.     # read class_dict
    28.     json_path = './class_indices.json'
    29.     assert os.path.exists(json_path), 'file:{} is not exist!'.format(json_path)
    30.     with open(json_path, 'r') as file:
    31.         class_dict = json.load(file)
    32.  
    33.     # create model
    34.     net = GoogLeNet(num_classes=5, aux_use=False).to(device)
    35.  
    36.     # load model weights
    37.     weight_path = './GoogLeNet.pth'
    38.     assert os.path.exists(weight_path), 'file:{} is not exist!'.format(weight_path)
    39.     # unexpected_keys里面存放的是辅助分类器aux1与aux2的权重
    40.     missing_keys, unexpected_keys = net.load_state_dict(torch.load(weight_path, map_location=device), strict=False)
    41.     net.eval()
    42.     with torch.no_grad():
    43.         outputs = torch.squeeze(net(img.to(device))).cpu()
    44.         predict = torch.softmax(outputs, dim=0)
    45.         predict_class = torch.argmax(predict).numpy()
    46.  
    47.     print_res = 'class:{} probability:{:.3f}'.format(class_dict[str(predict_class)], predict[predict_class])
    48.     plt.title(print_res)
    49.     for i in range(len(predict)):
    50.         print('class:{:10} probability:{:.3f}'.format(class_dict[str(i)], predict[i]))
    51.     plt.show()
    52.  
    53.  
    54. if __name__ == '__main__':
    55.     main()

    5. 结果

  • 相关阅读:
    JVM篇---第一篇
    有氧运动与无氧运动的区别
    《AI聊天类工具之五——Copilot》
    面试算法39：直方图最大矩形面积
    计算params的参数两和flops
    JAVA中类和对象的认识
    JavaScript:实现ExponentialSearch指数搜索算法（附完整源码）
    AtCoder Beginner Contest 212 E(DP)
    登录界面代码
    快速上手SpringBoot
  • 原文地址：https://blog.csdn.net/qq_61706112/article/details/133135548