12.8深度学习_经典神经网络_GoogleNet

一、1×1卷积

1. 1×1卷积由来

卷积核的尺寸等于1的特例，来自《Network in Network》。

2. 1×1卷积作用

2.1 实现通道间特征的融合

常规转换公式：0.2989R + 0.5870G + 0.1140B

2.2 瓶颈结构设计

两头宽，中间窄的网络结构。

• 如果一个输入特征大小为N1×H×W， 使用N1×N2个1×1卷积，就可以将其 映射为N2×H×W大小的特征。
• 当N1>N2，就实现了通道降维。

2.3 瓶颈结构的参数压缩效果

• 输入通道数为192，输出通道数为128
• 普通3×3卷积，参数量为128×192×3×3=221184
• 1×1卷积进行降维到96个通道，然后再用3×3升维到128 ，则参数量为：96×192×1×1+128×96×3×3=129024

2.4 纺锤型结构设计

二、GoogleNet

1. 铭记历史

​ GoogLeNet(InceptionNet)取得了2014年ImageNet分类大赛的冠军，参数量远小于VGG系列网络，而精度和速度则超越了VGG系列。

​ GoogLeNet的主要特点是采用了一种名为"Inception"模块的结构，该模块可以有效地捕捉图像中的多尺度特征 。

在Inception模块中，网络结构被分成多个并行的分支，每个分支都用于捕捉不同尺度的特征。这样，GoogLeNet网络就可以更有效地学习图像的特征，并且还可以减少网络的体积。

​ GoogLeNet还采用了一种名为"平均池化"的技术，该技术可以在不改变图像尺寸的情况下对图像进行降采样。这样，GoogLeNet网络就可以更快地处理图像，并且还可以提高网络的鲁棒性。

2. 网络结构

​

多尺度，更宽，分组的网络设计

3. 基本单元Inception Module

​ Inception结构由谷歌的研究人员在2014年提出，它的名字来源于电影《盗梦空间》，因为它设计时使用了多个并行的卷积神经网络模块，这些模块之间形成了一个嵌套的结构，就像人在梦中穿梭于不同场景中一样。

​ Inception结构的思想和之前的卷积思想不同，LeNet-5模型是将不同的卷积层通过串联连接起来的，但是Inception结构是通过串联+并联的方式将卷积层连接起来的。

​ Inception结构是对输入图像并行地执行多个卷积运算或池化操作，并将所有输出结果拼接为一个非常深的特征图，且不同大小卷积核的卷积运算可以得到图像中的不同信息，处理获取到的图像中的不同信息可以得到更好的图像特征，一个Inception结构如下图所示。

​ Inception结构通常用于图像分类和识别任务，因为它能够有效地捕捉图像中的细节信息。它的主要优势在于能够以高效的方式处理大量的数据，并且模型的参数量相对较少，这使得它能够在不同的设备上运行。

3.1 1×1卷积位置

​ 放置在前，通道降维；

​ 放置在后，更好地维持性能；

4. GoogLeNet模型结构

在paper中给出了网络结构的图，如下图所示：

5. 模型训练

​ 辅助分类器通常与主要的分类器结合使用，以帮助模型更好地理解图像中的细节和复杂模式。这种技术可以提高模型的泛化能力，使其更准确地预测未知的图像。

​ 在GoogLeNet中有两个辅助分类器，分别在Inception4a和Inception4d，它们的结构如下图所示：

训练时，额外的两个分类器的损失权重为0.3，推理时去除。

6. 性能表现

ILSVRC 2014竞赛中获得第一名。

7. 代码实现

下面是使用PyTorch搭建GoogLeNet（Inception v1）网络模型的代码。GoogLeNet是一种深度卷积神经网络，具有Inception模块结构，这种结构通过不同大小的卷积核提取多尺度特征。

import torch
import torch.nn as nn
import torch.nn.functional as F

class Inception(nn.Module):
    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
        super(Inception, self).__init__()
        self.branch1 = nn.Conv2d(in_channels, ch1x1, kernel_size=1)

        self.branch2 = nn.Sequential(
            nn.Conv2d(in_channels, ch3x3red, kernel_size=1),
            nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1)
        )

        self.branch3 = nn.Sequential(
            nn.Conv2d(in_channels, ch5x5red, kernel_size=1),
            nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2)
        )

        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(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)


class GoogLeNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(GoogLeNet, self).__init__()

        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.conv2 = nn.Conv2d(64, 192, kernel_size=3, padding=1)
        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
        self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
        self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        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(kernel_size=3, stride=2, padding=1)

        self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
        self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.dropout = nn.Dropout(0.4)
        self.fc = nn.Linear(1024, num_classes)

    def forward(self, x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)

        x = self.inception3a(x)
        x = self.inception3b(x)
        x = self.maxpool3(x)

        x = self.inception4a(x)
        x = self.inception4b(x)
        x = self.inception4c(x)
        x = self.inception4d(x)
        x = self.inception4e(x)
        x = self.maxpool4(x)

        x = self.inception5a(x)
        x = self.inception5b(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.dropout(x)
        x = self.fc(x)
        return x

# Example of creating a GoogLeNet instance and printing its architecture
model = GoogLeNet(num_classes=1000)
print(model)