GoogLeNet详解

入门小菜鸟，希望像做笔记记录自己学的东西，也希望能帮助到同样入门的人，更希望大佬们帮忙纠错啦~侵权立删。

✨完整代码在我的github上，有需要的朋友可以康康✨

https://github.com/tt-s-t/Deep-Learning.git

目录

一、GoogLeNet网络的背景

二、GooLeNet网络结构

1、Inception模块

2、辅助分类器

3、GooLeNet网络

 三、GooLeNet的亮点

 1、引入Inception结构

 2、使用1x1的卷积核进行降维映射处理

3、添加两个辅助分类器帮助训练

4、使用全局平均池化

5、1*n和n*1卷积核并联代替n*n卷积核

 四、GooLeNet代码实现

---

一、GoogLeNet网络的背景

想要更好的预测效果，就要从网络深度和网络宽度两个角度出发增加网络的复杂度。

但这个思路有两个较为明显的问题：

首先，更复杂的网络意味着更多的参数，也很容易过拟合；

其次，更复杂的网络会消耗更多的计算资源，而且卷积核个数设计不合理，导致了卷积核中参数没有被完全利用(多数权重都趋近0)时，会造成大量计算资源的浪费。

因此GoogLeNet在专注于加深网络结构的同时，引入了新的基本结构——Inception模块，以增加网络的宽度。GoogLeNet一共22层，没有全连接层，在2014年的ImageNet图像识别挑战赛中获得了冠军。

---

二、GooLeNet网络结构

1、Inception模块

 Inception模块的基本组成结构有四个：1x1卷积，3x3卷积，5x5卷积，3x3最大池化。

最后再对四个成分运算结果进行通道上组合。

这就是Naive Inception(上图a)的核心思想：利用不同大小的卷积核实现不同尺度的感知，最后进行融合，可以得到图像更好的表征（即探索特征图上不同邻域内的“相关性”）。

Note：每个分支得到的特征矩阵高和宽必须相同。

但Naive Inception有两个缺点：

（1）所有卷积层直接和前一层输入的数据对接，所以卷积层中的计算量会很大（一变四）；

（2）在这个单元中使用的最大池化层保留了输入数据的特征图的深度，所以在最后进行合并后总输出的特征图的深度一定会增加，这样增加了该单元之后的网络结构的计算量。

所以多加使用了1x1 卷积核主要目的是进行压缩降维，减少参数量（即上图b），从而让网络更深、更宽，更好的提取特征，这种思想也称为Pointwise Conv（逐点卷积），简称PW。

压缩降维：通过卷积层的输出通道数来调整这很好理解；

减少参数量：假设输入通道数为Cin，原本是直接要使用输出通道数为Cout的N*N卷积层来进行卷积，那么所需参数量为Cin*Cout*N*N；如果加上输出通道数为k的1*1卷积核的话，所需参数量为：Cin*k+N*N*Cout*k，只要k足够小就能使参数量大幅度下降了。

2、辅助分类器

因为神经网络的中间层也具有很强的识别能力，因此GooLeNet在一些中间层中添加了含有多层的分类器。

GoogLeNet中共增加了两个辅助的softmax分支。

网络结构如下图所示（其中的红圈圈就是辅助的分类器）

作用：

（1）为了避免梯度消失，用于向前传导梯度（反向传播时如果有一层求导为0，链式求导结果则为0）—— 最主要的原因；

（2）将中间某一层输出用作分类，起到模型融合作用（最终的分类结果以及这两个辅助分类器的结果（辅助分类按一个较小的权重加到最终分类结果中）一同决判出最终训练得到的分类结果）。但实际测试时，这两个辅助softmax分支会被去掉（因为辅助的主要原因是为了向前传导梯度，因此训练完后就没有价值了，理应扔掉）。

（3）正则化作用：

      在后续的研究中，Google团队研究人员发现辅助分类器在训练早期并没有改善收敛：在两个模型达到高精度之前，两种网络的训练进度看起来几乎相同；接近训练结束，有辅助分支的网络才开始超越没有任何分支的网络的准确性，达到了更高的稳定水平，因此辅助分类器更多的还是起到了一个正则化的作用（防止过拟合）。

3、GooLeNet网络

这是最初GooLeNet论文中展示的网络参数

 以下展示的是torchvision.models.GoogLeNet()的网络结构：

 其中Inception发生变化，将5*5卷积核部分也替换成了3*3卷积。

以下展示Inception3a：

---

 三、GooLeNet的亮点

 1、引入Inception结构

引入的Inception融合了不同尺度的特征信息，能得到更好的特征表征。

更意味着提高准确率，不一定需要堆叠更深的层或者增加神经元个数等，可以转向研究更稀疏但是更精密的结构同样可以达到很好的效果。

 2、使用1x1的卷积核进行降维映射处理

 降低了维度也减少了参数量（NiN是用于代替全连接层）。

3、添加两个辅助分类器帮助训练

避免梯度消失，用于向前传导梯度，也有一定的正则化效果，防止过拟合。

4、使用全局平均池化

用全局平均池化代替全连接层大大减少了参数量（与NiN一致）

5、1*n和n*1卷积核并联代替n*n卷积核

在InceptionV3中，在不改变感受野同时减少参数的情况下，采用1*n和n*1的卷积核并联来代替InceptionV1-V2中n*n的卷积核（发掘特征图的高的特征，以及特征图的宽的特征）。

这种方法在大维度的特征图上表现不好，在特征图12-20维度上表现好，若这种叠加的不对称分解卷积走高维路线，则更易训练（深层网络适合）。

降低了计算量和减少了参数量。

---

 四、GooLeNet代码实现

完整代码可以在我的github上看https://github.com/tt-s-t/Deep-Learning.git

在里面的GooLeNet文件夹中，分有调用torchvision.module.goolenet()实现的和自行搭建实现的

这里展示模型搭建代码

import torch
import torch.nn as nn
import torch.nn.functional as F
 
#conv+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()
 
    def forward(self, x):
        x = self.conv(x)
        x = self.relu(x)
        return x
 
#前部
class Front(nn.Module):
    def __init__(self):
        super(Front, self).__init__()
 
        self.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)
 
    def forward(self,input):
        #输入：(N,3,224,224)
        x = self.conv1(input)#(N,64,112,112)
        x = self.maxpool1(x)#(N,64,56,56)
        x = self.conv2(x)#(N,64,56,56)
        x = self.conv3(x)#(N,192,56,56)
        x = self.maxpool2(x)#(N,192,28,28)
        return x
 
class Inception(nn.Module):
    def __init__(self, in_channels, ch1x1, ch3x3_1_1, ch3x3_1, ch3x3_2_1, ch3x3_2, pool_ch):
        super(Inception, self).__init__()
 
        self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1)
 
        self.branch2 = nn.Sequential(
            BasicConv2d(in_channels, ch3x3_1_1, kernel_size=1),
            BasicConv2d(ch3x3_1_1, ch3x3_1, kernel_size=3, padding=1)
        )
 
        self.branch3 = nn.Sequential(
            BasicConv2d(in_channels, ch3x3_2_1, kernel_size=1),
            BasicConv2d(ch3x3_2_1, ch3x3_2, kernel_size=3, padding=1)
        )
        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            BasicConv2d(in_channels, pool_ch, kernel_size=1)
        )
 
    def forward(self, x):
        #输入(N,Cin,Hin,Win)
        branch1 = self.branch1(x)#(N,C1,Hin,Win)
        branch2 = self.branch2(x)#(N,C2,Hin,Win)
        branch3 = self.branch3(x)#(N,C3,Hin,Win)
        branch4 = self.branch4(x)#(N,C4,Hin,Win)
        outputs = [branch1, branch2, branch3, branch4]
        return torch.cat(outputs, 1)#(N,C1+C2+C3+C4,Hin,Win)
 
#辅助分类器
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)
 
        self.fc1 = nn.Linear(2048, 1024)
        self.fc2 = nn.Linear(1024, num_classes)
 
    def forward(self, x):
        # 输入：aux1:(N,512,14,14), aux2: (N,528,14,14)
        x = self.averagePool(x)# aux1:(N,512,4,4), aux2: (N,528,4,4)
        x = self.conv(x)# (N,128,4,4)
        x = torch.flatten(x, 1)# (N,2048)
        x = F.dropout(x, 0.5, training=self.training)
        x = F.relu(self.fc1(x))# (N,1024)
        x = F.dropout(x, 0.5, training=self.training)
        x = self.fc2(x)# (N,num_classes)
        return x
 
# GooLeNet网络主体
class GoogLeNet(nn.Module):
    def __init__(self, num_classes=1000, aux_logits=True):
        super(GoogLeNet, self).__init__()
        self.aux_logits = aux_logits
 
        self.front = Front()
 
        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)
 
    def forward(self, x):
        #输入：(N,3,224,224)
        x = self.front(x)#(N,192,28,28)
        x = self.inception3a(x)#(N,256,28,28)
        x = self.inception3b(x)#(N,480,28,28)
        x = self.maxpool3(x)#(N,480,14,14)
        x = self.inception4a(x)#(N,512,14,14)
        if self.training and self.aux_logits:
            aux1 = self.aux1(x)
 
        x = self.inception4b(x)#(N,512,14,14)
        x = self.inception4c(x)#(N,512,14,14)
        x = self.inception4d(x)#(N,528,14,14)
        if self.training and self.aux_logits:
            aux2 = self.aux2(x)
 
        x = self.inception4e(x)#(N,832,14,14)
        x = self.maxpool4(x)#(N,832,7,7)
        x = self.inception5a(x)#(N,832,7,7)
        x = self.inception5b(x)#(N,1024,7,7)
 
        x = self.avgpool(x)#(N,1024,1,1)
        x = torch.flatten(x, 1)#(N,1024)
        x = self.dropout(x)
        x = self.fc(x)#(N,num_classes)
        if self.training and self.aux_logits:
            return x, aux2, aux1
        return x

---

欢迎大家在评论区批评指正，谢谢~