经典网络结构 (四)：GoogLeNet (Inception v1~v4)

最新推荐文章于 2023-03-13 15:18:31 发布

连理o

最新推荐文章于 2023-03-13 15:18:31 发布

阅读量567

点赞数 1

分类专栏：深度学习文章标签：人工智能机器学习

本文链接：https://blog.csdn.net/weixin_42437114/article/details/106987979

版权

深度学习专栏收录该内容

27 篇文章 14 订阅

订阅专栏

本文参考：
- 《深度学习之 PyTorch 物体检测实战》
- $D i v e$ $I n t o$ $D e e p$ $L e a r n i n g$
- 吴恩达深度学习视频

Inception v1

Inception 块

彩蛋：得名于同名电影《盗梦空间》(Inception) – “We need to go deeper”，GoogLenet 同时也向 Lenet 致敬

在这里插入图片描述

$\times 1$ / $\times 3$ / $5\times 5$ / $M a x P o o l$ 怎么选？ Inception：小孩子才做选择，我全都要

Inception 块里有4 条并行的线路。前 3 条线路使用窗口大小分别是 $1 \times 1 、 3 \times 3$ 和 $5 \times 5$ 的卷积层来抽取不同空间尺寸下的信息，其中中间 2 个线路会对输入先做 $1 \times 1$ 卷积来减少输入通道数 (即 bottleneck layer，相比其他大小的卷积核，利用 $1 \times 1$ 卷积来减少输入通道数能显著降低计算成本)，以降低模型复杂度, 在类似的测试精度下，GoogLenet 的计算复杂度往往更低。第四条线路则使用 $3 \times 3$ 最大池化层，后接 $1 \times 1$ 卷积层来改变通道数。4 条线路都使用了合适的填充来使输入与输出的高和宽一致。最后我们将每条线路的输出在通道维上连结，并输入接下来的层中去
Inception 块中可以自定义的超参数是每个层的输出通道数，我们以此来控制模型复杂度

class Inceptionv1(nn.Module):
    def __init__(self, in_dim, c1, c2, c3, c4):
        super(Inceptionv1, self).__init__()
        self.branch1x1 = nn.Sequential(
            nn.Conv2d(in_dim, c1, 1),
            nn.ReLU(inplace=True)
        )
        self.branch3x3 = nn.Sequential(
            nn.Conv2d(in_dim, c2[0], 1),
            nn.ReLU(inplace=True),
            nn.Conv2d(c2[0], c2[1], 3, padding=1),
            nn.ReLU(inplace=True)
        )
        self.branch5x5 = nn.Sequential(
            nn.Conv2d(in_dim, c3[0], 1),
            nn.ReLU(inplace=True),
            nn.Conv2d(c3[0], c3[1], 5, padding=2),
            nn.ReLU(inplace=True)
        )
        self.branch_pool = nn.Sequential(
            nn.MaxPool2d(3, stride=1, padding=1),
            nn.Conv2d(in_dim, c4, 1),
            nn.ReLU(inplace=True)
        )

    def forward(self, x):
        b1 = self.branch1x1(x)
        b2 = self.branch3x3(x)
        b3 = self.branch5x5(x)
        b4 = self.branch_pool(x)
        output = torch.cat((b1, b2, b3, b4), dim=1)
        return output

GoogLeNet 模型

在这里插入图片描述

GoogLeNet 跟 VGG 一样，在主体卷积部分中使用 5 个模块（block），每个模块之间使用步幅为 2 的 $3 \times 3$ 最大池化层来减小输出高宽
- 第一模块使用一个 64 通道的 $7 \times 7$ 卷积层
- 第二模块使用 2 个卷积层：首先是 64 通道的 $1 \times 1$ 卷积层，然后是将通道增大 3 倍的 $3 \times 3$ 卷积层。它对应 Inception 块中的第二条线路
- 第三模块串联 2 个完整的 Inception 块。第一个 Inception 块的输出通道数为 $64 + 128 + 32 + 32 = 256$ ，其中 4 条线路的输出通道数比例为 $64 : 128 : 32 : 32 = 2 : 4 : 1 : 1$ 。其中第二、第三条线路先分别将输入通道数减小至 $96 / 192 = 1 / 2$ 和 $16 / 192 = 1 / 12$ 后，再接上第二层卷积层。第二个 Inception 块输出通道数增至 $128 + 192 + 96 + 64 = 480$ ，每条线路的输出通道数之比为 $128 : 192 : 96 : 64 = 4 : 6 : 3 : 2$ 。其中第二、第三条线路先分别将输入通道数减小至 $128 / 256 = 1 / 2$ 和 $32 / 256 = 1 / 8$ (Inception 块的通道数分配之比是在 ImageNet 数据集上通过大量的实验得来的)
- 第四模块更加复杂。它串联了 5 个 Inception 块，其输出通道数分别是 $192 + 208 + 48 + 64 = 512$ 、 $160 + 224 + 64 + 64 = 512$ 、 $128 + 256 + 64 + 64 = 512$ 、 $112 + 288 + 64 + 64 = 528$ 和 $256 + 320 + 128 + 128 = 832$ 。这些线路的通道数分配和第三模块中的类似，首先是含 $3 \times 3$ 卷积层的第二条线路输出最多通道，其次是仅含 $1 \times 1$ 卷积层的第一条线路，之后是含 $5 \times 5$ 卷积层的第三条线路和含 $3 \times 3$ 最大池化层的第四条线路。其中第二、第三条线路都会先按比例减小通道数。这些比例在各个 Inception 块中都略有不同
- 第五模块有输出通道数为 $256 + 320 + 128 + 128 = 832$ 和 $384 + 384 + 128 + 128 = 1024$ 的两个 Inception 块。其中每条线路的通道数的分配思路和第三、第四模块中的一致，只是在具体数值上有所不同。需要注意的是，第五模块的后面紧跟输出层，该模块同 NiN 一样使用全局平均池化层来将每个通道的高和宽变成 1。最后我们将输出变成二维数组后接上一个输出个数为标签类别数的全连接层

在原论文中还有一个细节：如上图所示黄色后接白色的两个方框为全连接层接 softmax，可以看到除了最后的输出以外，从隐藏层中也引出了两个该结构，通过引入这两个辅助分类器 (Auxiliary Classifier)，在第3个与第6个 Inception 块输出后执行 softmax 并计算损失，在训练时和最后的损失一起回传。下面引用一下吴恩达在深度学习视频中的解释：
- It ensures that the features computed even in the hidden units are not too bad for predicting the output class of an image. (have a regularization effect and help prevent this network from overfitting)

class GoogLenetv1(nn.Module):
    def __init__(self, in_dim, class_num):
        super(GoogLenetv1, self).__init__()
        self.b1 = nn.Sequential(
            nn.Conv2d(in_dim, 64, kernel_size=7, stride=2, padding=3),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, stride=2, padding=1),
        )
        self.b2 = nn.Sequential(
            nn.Conv2d(64, 64, 1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 192, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(3, stride=2, padding=1),
        )
        self.b3 = nn.Sequential(
            Inceptionv1(192, 64, (96, 128), (16, 32), 32),
            Inceptionv1(256, 128, (128, 192), (32, 96), 64),
            nn.MaxPool2d(3, stride=2, padding=1),
        )
        self.b4 = nn.Sequential(
            Inceptionv1(480, 192, (96, 208), (16, 48), 64),
            Inceptionv1(512, 160, (112, 224), (24, 64), 64),
            Inceptionv1(512, 128, (128, 256), (24, 64), 64),
            Inceptionv1(512, 112, (144, 288), (32, 64), 64),
            Inceptionv1(528, 256, (160, 320), (32, 128), 128),
            nn.MaxPool2d(3, stride=2, padding=1),
        )
        self.b5 = nn.Sequential(
            Inceptionv1(832, 256, (160, 320), (32, 128), 128),
            Inceptionv1(832, 384, (192, 384), (48, 128), 128),
            nn.AdaptiveAvgPool2d(1),
        )
        self.net = nn.Sequential()
        for i in range(1, 6):
            exec('self.net.add_module(str(i), self.b' + str(i) + ')')
        self.fc = nn.Linear(1024, class_num)
        
    def forward(self, x):
        output = self.net(x)
        output = output.view(-1, 1024) 
        output = self.fc(output)
        
        return output

Inception v2

参考：https://www.jianshu.com/p/4e5b3e652639

Inception v2 的基础模块结构

Inception v2 基础模块结构与 Inception v1 相比，有下面几个改动：
- 在每个卷积层之后都加入了 BN 层，可以采用更大的学习率，能使学习更快地进行
- 将 $5\times5$ 卷积层换成了两个 $3\times3$ 卷积层，可以用更少的参数获得相同的感受野
- 将 Max 池化改为 Average 池化

下面再搭建一个 Inception v2 的基础模块结构：

class BasicConv2d(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, padding=0):
        super(BasicConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding)
        self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        return F.relu(x, inplace=True)

class Inceptionv2(nn.Module):
    def __init__(self, in_dim, c1, c2, c3, c4):
        super(Inceptionv2, self).__init__()
        self.branch1 = BasicConv2d(in_dim, c1, 1, 0)
        self.branch2 = nn.Sequential(
            BasicConv2d(in_dim, c2[0], 1, 0),
            BasicConv2d(c2[0], c2[1], 3, 1)
        )
        self.branch3 = nn.Sequential(
            BasicConv2d(in_dim, c3[0], 1, 0),
            BasicConv2d(c3[0], c3[1], 3, 1),
            BasicConv2d(c3[1], c3[2], 3, 1)
        )
        self.branch4 = nn.Sequential(
            nn.AvgPool2d(3, stride=1, padding=1, count_include_pad=False),
            BasicConv2d(in_dim, c4, 1, 0)
        )
    def forward(self, x):
        x0 = self.branch1(x)
        x1 = self.branch2(x)
        x2 = self.branch3(x)
        x3 = self.branch4(x)
        out = torch.cat((x0, x1, x2, x3), 1)
        return out

Inception v2 的改进模块结构

在上面所说的基础上，最终的 Inception v2 还进行了以下的改进：
将 $n\times n$ 的卷积运算分解为 $1\times n$ 和 $n\times 1$ 的两个卷积运算。按照这种思路将 $3\times 3$ 的卷积运算分解为 $1\times 3$ 和 $3\times 1$ 的两个卷积运算，这样就进一步将计算成本降低了 33%。作者通过测试发现非对称卷积用在网络中靠中间的层级才有较好的效果（特别是 feature map 的大小在 12x12~20x20 之间时），Inception v2 改进模块如下图所示

Inception v2 的并行结构

Inception v2 还使用并行结构来优化 Pooling，使卷积核变得更宽而不是更深，解决表征能力瓶颈问题

首先，作者在论文 Rethinking the Inception Architecture for Computer Vision 中提出了要按照一套合理的规则来优化 Inception 结构，具体如下：
- 规则1：要防止出现特征描述的瓶颈（representational bottleneck）。所谓特征描述的瓶颈就是中间某层对特征在空间维度进行较大比例的压缩（比如使用 pooling 时），导致很多特征丢失。虽然 Pooling 是 CNN 结构中必须的功能，但我们可以通过一些优化方法来减少 Pooling 造成的损失
- 规则2：特征的数目越多收敛的越快。相互独立的特征越多，输入的信息就被分解的越彻底，分解的子特征间相关性低，子特征内部相关性高，把相关性强的聚集在了一起会更容易收敛。规则2和规则1可以组合在一起理解，特征越多能加快收敛速度，但是无法弥补 Pooling 造成的特征损失， Pooling 造成的 representational bottleneck 要靠其他方法来解决。
- 规则3：可以压缩特征维度数，来减少计算量。inception-v1 中提出的用 $1\times 1$ 卷积先降维再作特征提取就是利用这点。不同维度的信息有相关性，降维可以理解成一种无损或低损压缩，即使维度降低了，仍然可以利用相关性恢复出原有的信息
- 规则4：整个网络结构的深度和宽度（特征维度数）要做到平衡。只有等比例的增大深度和维度才能最大限度的提升网络的性能
而使用并行结构来优化 Pooling 就是为了解决规则1中提到的 representational bottleneck。representational bottleneck 的一种解决办法就是在 Pooling 前用 $1\times1$ 卷积把特征数加倍（见下图右侧），这种加倍可以理解加入了冗余的特征，然后再作 Pooling 就只是把冗余的信息重新去掉，没有减少信息量。这种方法有很好的效果但因为加入了 $1\times1$ 卷积会极大的增大计算量

替代的方法是使用两个并行的支路，左路为 $3\times 3$ ，步长为 2 的卷积，右路是 Pooling，最后再在特征维度拼合到一起（见下图）也得到了两倍的通道数。这种方法既有很好的效果，又没有增大计算量

Inception v2 整体结构

在这里插入图片描述

Inception v3

参考：https://www.jianshu.com/p/4e5b3e652639

使用标签平滑 (label smoothing) 来对网络输出进行正则化

Softmax with Loss 层的输出可以用下面公式表示：
从上述公式可以反推出整个训练过程收敛时 Softmax 的正确分类的输入 $a_k$ 是无穷大，这是一种极其理想的情况，如果让所有的输入都产生这种极其理想的输出，就会造成 overfit（回想一下 overfit 的概念：能对所有的输入进行最理想的分类，鲁棒性差）
所以为了克服 overfit，防止最终出来的正确分类 $y_k=1$ ，在输出 $y_k$ 时加了个参数 $d e l t a$ ，生成新的 $y_k^{'}$ ，用 $y_k^{'}$ 来计算loss
$y_k^{'} = (1 - \epsilon)y_k + \frac{\epsilon}{K}$ $K为类别数，\epsilon可取0.1$
- 举个例子：假设输出概率值为 $[0, 0, 0, 1]$ ，那么在经过 label smoothing 之后，概率值就变成了 $[0.025, 0.025, 0.025, 0.925]$ ，相当于是施加了一个惩罚

关于分支分类器 Auxiliary Classifiers 的纠正

作者还对自己在 GoogLeNet 论文中提出的 分支分类器 Auxiliary Classifiers 的效果进行了纠正。Szegedy 认为自己当时的结论就是错误的，特别是靠近输入侧的那个 Auxiliary Classifier，加不加完全没区别，但如果在靠近输出的那个 Auxiliary Classifier 的全连接层后加个 BN，会起到正则化的作用，所以第二个 Auxiliary Classifier 还是可以保留。起正则化作用的原因 Szegedy 完全没解释

Inception v4

Inception v4 将 Inception 的思想与残差网络进行了结合，显著提升了训练速度与模型准确率. 论文中提出了三个网络，分别叫 Inception-v4、Inception-ResNet-v1 以及 Inception-ResNet-v2，其中 Inception-v4 中没有使用残差模块，但是网络深度比原来更深了。后两个网络则引入的残差模块，但是在设计上还是略有不同

Scaling of the Residuals

在与前一层激活层求和时，缩小残差有助于稳定训练过程。一般我们会选择固定的缩放因子，见图 20：

残差模块

在这里插入图片描述

Inception-v4

整体结构

在这里插入图片描述

网络中的各个模块

stem

在这里插入图片描述

Inception-A block

在这里插入图片描述

Inception-B block

在这里插入图片描述

Inception-C block

在这里插入图片描述

Reduction-A

在这里插入图片描述

Reduction-B

在这里插入图片描述

Inception-ResNet-V1

整体结构

在这里插入图片描述

网络中的各个模块

stem

在这里插入图片描述

Inception-ResNet-A

在这里插入图片描述

Inception-ResNet-B

在这里插入图片描述

Inception-ResNet-C

在这里插入图片描述

Reduction-A

在这里插入图片描述

Reduction-B

在这里插入图片描述

Inception-ResNet-V2

整体结构

在这里插入图片描述

网络中的各个模块

stem

在这里插入图片描述

Inception-ResNet-A

在这里插入图片描述

Inception-ResNet-B

在这里插入图片描述

Inception-ResNet-C

在这里插入图片描述

Reduction-A

在这里插入图片描述

Reduction-B

在这里插入图片描述

连理o

关注

1
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
经典网络结构 (四)：GoogLeNet (Inception v1~v4)

本节参考：《深度学习之PyTorch物体检测实战》《DIVE INTO DEEP LEARNING》、吴恩达深度学习视频目录Inceptionv1Inception块GoogLeNet模型Inceptionv2Inceptionv2的基础模块结构Inceptionv2的改进模块结构Inceptionv2的并行结构Inceptionv2整体结构Inceptionv3使用标签平滑(label smoothing)来对网络输出进行正则化关于分支分类器 Auxiliary Classifiers 的纠正Ince
复制链接

扫一扫