GoogleNet網絡分析與demo實例

參考自?

up主的b站鏈接：霹靂吧啦Wz的個人空間-霹靂吧啦Wz個人主頁-嗶哩嗶哩視頻
這位大佬的博客?Fun'_機器學習,pytorch圖像分類,工具箱-CSDN博客

1. GoogLeNet網絡詳解

GoogLeNet在2014年由Google團隊提出（與VGG網絡同年，注意GoogLeNet中的L大寫是為了致敬LeNet），斬獲當年ImageNet競賽中Classification Task (分類任務) 第一名。

原論文地址：深度學習面試題20：GoogLeNet(Inception V1) - 黎明程序員 - 博客園 (cnblogs.com)

GoogLeNet 的創新點：

1.引入了 Inception 結構（融合不同尺度的特征信息）
2.使用1x1的卷積核進行降維以及映射處理（雖然VGG網絡中也有，但該論文介紹的更詳細）
3.添加兩個輔助分類器幫助訓練
4.丟棄全連接層，使用平均池化層（大大減少模型參數，除去兩個輔助分類器，網絡大小只有vgg的1/20）
?

inception 結構

傳統的CNN結構如AlexNet、VggNet（下圖）都是串聯的結構，即將一系列的卷積層和池化層進行串聯得到的結構

這里GoogleNet提出了并聯的思路

將特征矩陣同時輸入到多個分支進行處理，并將輸出的特征矩陣按深度進行拼接，得到最終輸出

inception的作用：增加網絡深度和寬度的同時減少參數

在 inception 的基礎上，還可以加上降維功能的結構，如下圖所示，在原始 inception 結構的基礎上，在分支2，3，4上加入了卷積核大小為1x1的卷積層，目的是為了降維（減小深度），減少模型訓練參數，減少計算量。

1×1卷積核的降維功能
同樣是對一個深度為512的特征矩陣使用64個大小為5x5的卷積核進行卷積，不使用1x1卷積核進行降維的話一共需要819200個參數，如果使用1x1卷積核進行降維一共需要50688個參數，明顯少了很多。

輔助分類器（Auxiliary Classifier）
AlexNet 和 VGG 都只有1個輸出層，GoogLeNet 有3個輸出層，其中的兩個是輔助分類層。

如下圖所示，網絡主干右邊的兩個分支就是輔助分類器，其結構一模一樣。
在訓練模型時，將兩個輔助分類器的損失乘以權重（論文中是0.3）加到網絡的整體損失上，再進行反向傳播。
?

輔助分類器的作用：

作用一：可以把他看做inception網絡中的一個小細節，它確保了即便是隱藏單元和中間層也參與了特征計算，他們也能預測圖片的類別，他在inception網絡中起到一種調整的效果，并且能防止網絡發生過擬合。

作用二：給定深度相對較大的網絡，有效傳播梯度反向通過所有層的能力是一個問題。通過將輔助分類器添加到這些中間層，可以期望較低階段分類器的判別力。在訓練期間，它們的損失以折扣權重（輔助分類器損失的權重是0.3）加到網絡的整個損失上。
?

GoogLeNet 網絡參數

pytorch搭建GoogLeNet

相比于 AlexNet 和 VggNet 只有卷積層和全連接層這兩種結構，GoogLeNet多了 inception 和輔助分類器（Auxiliary Classifier），而 inception 和輔助分類器也是由多個卷積層和全連接層組合的，因此在定義模型時可以將卷積、inception 、輔助分類器定義成不同的類，調用時更加方便。
?

import torch.nn as nn
import torch
import torch.nn.functional as Fclass GoogLeNet(nn.Module):# 傳入的參數中aux_logits=True表示訓練過程用到輔助分類器，aux_logits=False表示驗證過程不用輔助分類器def __init__(self, num_classes=1000, aux_logits=True, init_weights=False):super(GoogLeNet, self).__init__()self.aux_logits = aux_logitsself.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3)self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)self.conv2 = BasicConv2d(64, 64, kernel_size=1)self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1)self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True)self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)self.maxpool3 = nn.MaxPool2d(3, stride=2, ceil_mode=True)self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)self.maxpool4 = nn.MaxPool2d(3, stride=2, ceil_mode=True)self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)if self.aux_logits:self.aux1 = InceptionAux(512, num_classes)self.aux2 = InceptionAux(528, num_classes)self.avgpool = nn.AdaptiveAvgPool2d((1, 1))self.dropout = nn.Dropout(0.4)self.fc = nn.Linear(1024, num_classes)if init_weights:self._initialize_weights()def forward(self, x):# N x 3 x 224 x 224x = self.conv1(x)# N x 64 x 112 x 112x = self.maxpool1(x)# N x 64 x 56 x 56x = self.conv2(x)# N x 64 x 56 x 56x = self.conv3(x)# N x 192 x 56 x 56x = self.maxpool2(x)# N x 192 x 28 x 28x = self.inception3a(x)# N x 256 x 28 x 28x = self.inception3b(x)# N x 480 x 28 x 28x = self.maxpool3(x)# N x 480 x 14 x 14x = self.inception4a(x)# N x 512 x 14 x 14if self.training and self.aux_logits:    # eval model lose this layeraux1 = self.aux1(x)x = self.inception4b(x)# N x 512 x 14 x 14x = self.inception4c(x)# N x 512 x 14 x 14x = self.inception4d(x)# N x 528 x 14 x 14if self.training and self.aux_logits:    # eval model lose this layeraux2 = self.aux2(x)x = self.inception4e(x)# N x 832 x 14 x 14x = self.maxpool4(x)# N x 832 x 7 x 7x = self.inception5a(x)# N x 832 x 7 x 7x = self.inception5b(x)# N x 1024 x 7 x 7x = self.avgpool(x)# N x 1024 x 1 x 1x = torch.flatten(x, 1)# N x 1024x = self.dropout(x)x = self.fc(x)# N x 1000 (num_classes)if self.training and self.aux_logits:   # eval model lose this layerreturn x, aux2, aux1return xdef _initialize_weights(self):for m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')if m.bias is not None:nn.init.constant_(m.bias, 0)elif isinstance(m, nn.Linear):nn.init.normal_(m.weight, 0, 0.01)nn.init.constant_(m.bias, 0)# Inception結構
class Inception(nn.Module):def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):super(Inception, self).__init__()self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1)self.branch2 = nn.Sequential(BasicConv2d(in_channels, ch3x3red, kernel_size=1),BasicConv2d(ch3x3red, ch3x3, kernel_size=3, padding=1)   # 保證輸出大小等于輸入大小)self.branch3 = nn.Sequential(BasicConv2d(in_channels, ch5x5red, kernel_size=1),BasicConv2d(ch5x5red, ch5x5, kernel_size=5, padding=2)   # 保證輸出大小等于輸入大小)self.branch4 = nn.Sequential(nn.MaxPool2d(kernel_size=3, stride=1, padding=1),BasicConv2d(in_channels, pool_proj, kernel_size=1))def forward(self, x):branch1 = self.branch1(x)branch2 = self.branch2(x)branch3 = self.branch3(x)branch4 = self.branch4(x)outputs = [branch1, branch2, branch3, branch4]return torch.cat(outputs, 1) # 按 channel 對四個分支拼接  # 輔助分類器
class InceptionAux(nn.Module):def __init__(self, in_channels, num_classes):super(InceptionAux, self).__init__()self.averagePool = nn.AvgPool2d(kernel_size=5, stride=3)self.conv = BasicConv2d(in_channels, 128, kernel_size=1)  # output[batch, 128, 4, 4]self.fc1 = nn.Linear(2048, 1024)self.fc2 = nn.Linear(1024, num_classes)def forward(self, x):# aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14x = self.averagePool(x)# aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4x = self.conv(x)# N x 128 x 4 x 4x = torch.flatten(x, 1)x = F.dropout(x, 0.5, training=self.training)# N x 2048x = F.relu(self.fc1(x), inplace=True)x = F.dropout(x, 0.5, training=self.training)# N x 1024x = self.fc2(x)# N x num_classesreturn x# 基礎卷積層（卷積+ReLU）
class BasicConv2d(nn.Module):def __init__(self, in_channels, out_channels, **kwargs):super(BasicConv2d, self).__init__()self.conv = nn.Conv2d(in_channels, out_channels, **kwargs)self.relu = nn.ReLU(inplace=True)def forward(self, x):x = self.conv(x)x = self.relu(x)return x

train.py

實例化網絡時的參數

net = GoogLeNet(num_classes=5, aux_logits=True, init_weights=True)

GoogLeNet的網絡輸出 loss 有三個部分，分別是主干輸出loss、兩個輔助分類器輸出loss（權重0.3）

logits, aux_logits2, aux_logits1 = net(images.to(device))
loss0 = loss_function(logits, labels.to(device))
loss1 = loss_function(aux_logits1, labels.to(device))
loss2 = loss_function(aux_logits2, labels.to(device))
loss = loss0 + loss1 * 0.3 + loss2 * 0.3

predict

# create model
model = GoogLeNet(num_classes=5, aux_logits=False)# load model weights
model_weight_path = "./googleNet.pth"

但是在加載訓練好的模型參數時，由于其中是包含有輔助分類器的，需要設置strict=False

missing_keys, unexpected_keys = model.load_state_dict(torch.load(model_weight_path), strict=False)