GoogLeNet

GoogLeNet是2014年ImageNet比赛的冠军，它的主要特点是网络不仅有深度，还在横向上具有“宽度”。由于图像信息在空间尺寸上的巨大差异，如何选择合适的卷积核大小来提取特征就显得比较困难了。空间分布范围更广的图像信息适合用较大的卷积核来提取其特征，而空间分布范围较小的图像信息则适合用较小的卷积核来提取其特征。为了解决这个问题，GoogLeNet提出了一种被称为Inception模块的方案。如 图4 所示：

说明：

  • Google的研究人员为了向LeNet致敬，特地将模型命名为GoogLeNet
  • Inception一词来源于电影《盗梦空间》（Inception）

GoogLeNet - 图1

图4：Inception模块结构示意图

图4(a)是Inception模块的设计思想，使用3个不同大小的卷积核对输入图片进行卷积操作，并附加最大池化，将这4个操作的输出沿着通道这一维度进行拼接，构成的输出特征图将会包含经过不同大小的卷积核提取出来的特征。Inception模块采用多通路(multi-path)的设计形式，每个支路使用不同大小的卷积核，最终输出特征图的通道数是每个支路输出通道数的总和，这将会导致输出通道数变得很大，尤其是使用多个Inception模块串联操作的时候，模型参数量会变得非常巨大。为了减小参数量，Inception模块使用了图(b)中的设计方式，在每个3x3和5x5的卷积层之前，增加1x1的卷积层来控制输出通道数；在最大池化层后面增加1x1卷积层减小输出通道数。基于这一设计思想，形成了上图(b)中所示的结构。下面这段程序是Inception块的具体实现方式，可以对照图(b)和代码一起阅读。

提示：

可能有读者会问，经过3x3的最大池化之后图像尺寸不会减小吗，为什么还能跟另外3个卷积输出的特征图进行拼接？这是因为池化操作可以指定窗口大小

GoogLeNet - 图2 ，pool_stride=1和pool_padding=1，输出特征图尺寸可以保持不变。

Inception模块的具体实现如下代码所示：

  1. class Inception(fluid.dygraph.Layer):
  2.     def __init__(self, name_scope, c1, c2, c3, c4, **kwargs):
  3.         '''
  4.         Inception模块的实现代码，
  5.         name_scope, 模块名称，数据类型为string
  6.         c1,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数
  7.         c2，图(b)中第二条支路卷积的输出通道数，数据类型是tuple或list, 
  8.                其中c2[0]是1x1卷积的输出通道数，c2[1]是3x3
  9.         c3，图(b)中第三条支路卷积的输出通道数，数据类型是tuple或list, 
  10.                其中c3[0]是1x1卷积的输出通道数，c3[1]是3x3
  11.         c4,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数
  12.         '''
  13.         super(Inception, self).__init__(name_scope)
  14.         # 依次创建Inception块每条支路上使用到的操作
  15.         self.p1_1 = Conv2D(self.full_name(), num_filters=c1, 
  16.                            filter_size=1, act='relu')
  17.         self.p2_1 = Conv2D(self.full_name(), num_filters=c2[0], 
  18.                            filter_size=1, act='relu')
  19.         self.p2_2 = Conv2D(self.full_name(), num_filters=c2[1], 
  20.                            filter_size=3, padding=1, act='relu')
  21.         self.p3_1 = Conv2D(self.full_name(), num_filters=c3[0], 
  22.                            filter_size=1, act='relu')
  23.         self.p3_2 = Conv2D(self.full_name(), num_filters=c3[1], 
  24.                            filter_size=5, padding=2, act='relu')
  25.         self.p4_1 = Pool2D(self.full_name(), pool_size=3, 
  26.                            pool_stride=1,  pool_padding=1, 
  27.                            pool_type='max')
  28.         self.p4_2 = Conv2D(self.full_name(), num_filters=c4, 
  29.                            filter_size=1, act='relu')
  31.     def forward(self, x):
  32.         # 支路1只包含一个1x1卷积
  33.         p1 = self.p1_1(x)
  34.         # 支路2包含 1x1卷积 + 3x3卷积
  35.         p2 = self.p2_2(self.p2_1(x))
  36.         # 支路3包含 1x1卷积 + 5x5卷积
  37.         p3 = self.p3_2(self.p3_1(x))
  38.         # 支路4包含 最大池化和1x1卷积
  39.         p4 = self.p4_2(self.p4_1(x))
  40.         # 将每个支路的输出特征图拼接在一起作为最终的输出结果
  41.         return fluid.layers.concat([p1, p2, p3, p4], axis=1)

GoogLeNet的架构如 图5 所示，在主体卷积部分中使用5个模块（block），每个模块之间使用步幅为2的3 ×3最大池化层来减小输出高宽。

  • 第一模块使用一个64通道的7 × 7卷积层。
  • 第二模块使用2个卷积层:首先是64通道的1 × 1卷积层，然后是将通道增大3倍的3 × 3卷积层。
  • 第三模块串联2个完整的Inception块。
  • 第四模块串联了5个Inception块。
  • 第五模块串联了2 个Inception块。
  • 第五模块的后面紧跟输出层，使用全局平均池化 层来将每个通道的高和宽变成1，最后接上一个输出个数为标签类别数的全连接层。

说明： 在原作者的论文中添加了图中所示的softmax1和softmax2两个辅助分类器，如下图所示，训练时将三个分类器的损失函数进行加权求和，以缓解梯度消失现象。这里的程序作了简化，没有加入辅助分类器。

GoogLeNet - 图3

图5：GoogLeNet模型网络结构示意图

GoogLeNet的具体实现如下代码所示：

  1. # -*- coding:utf-8 -*-
  3. # GoogLeNet模型代码
  4. import numpy as np
  5. import paddle
  6. import paddle.fluid as fluid
  7. from paddle.fluid.layer_helper import LayerHelper
  8. from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear
  9. from paddle.fluid.dygraph.base import to_variable
  11. # 定义Inception块
  12. class Inception(fluid.dygraph.Layer):
  13.     def __init__(self, name_scope, c0,c1, c2, c3, c4, **kwargs):
  14.         '''
  15.         Inception模块的实现代码，
  16.         name_scope, 模块名称，数据类型为string
  17.         c1,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数
  18.         c2，图(b)中第二条支路卷积的输出通道数，数据类型是tuple或list, 
  19.                其中c2[0]是1x1卷积的输出通道数，c2[1]是3x3
  20.         c3，图(b)中第三条支路卷积的输出通道数，数据类型是tuple或list, 
  21.                其中c3[0]是1x1卷积的输出通道数，c3[1]是3x3
  22.         c4,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数
  23.         '''
  24.         super(Inception, self).__init__(name_scope)
  25.         # 依次创建Inception块每条支路上使用到的操作
  26.         self.p1_1 = Conv2D(num_channels=c0, num_filters=c1, 
  27.                            filter_size=1, act='relu')
  28.         self.p2_1 = Conv2D(num_channels=c0, num_filters=c2[0], 
  29.                            filter_size=1, act='relu')
  30.         self.p2_2 = Conv2D(num_channels=c2[0], num_filters=c2[1], 
  31.                            filter_size=3, padding=1, act='relu')
  32.         self.p3_1 = Conv2D(num_channels=c0, num_filters=c3[0], 
  33.                            filter_size=1, act='relu')
  34.         self.p3_2 = Conv2D(num_channels=c3[0], num_filters=c3[1], 
  35.                            filter_size=5, padding=2, act='relu')
  36.         self.p4_1 = Pool2D(pool_size=3, 
  37.                            pool_stride=1,  pool_padding=1, 
  38.                            pool_type='max')
  39.         self.p4_2 = Conv2D(num_channels=c0, num_filters=c4, 
  40.                            filter_size=1, act='relu')
  42.     def forward(self, x):
  43.         # 支路1只包含一个1x1卷积
  44.         p1 = self.p1_1(x)
  45.         # 支路2包含 1x1卷积 + 3x3卷积
  46.         p2 = self.p2_2(self.p2_1(x))
  47.         # 支路3包含 1x1卷积 + 5x5卷积
  48.         p3 = self.p3_2(self.p3_1(x))
  49.         # 支路4包含 最大池化和1x1卷积
  50.         p4 = self.p4_2(self.p4_1(x))
  51.         # 将每个支路的输出特征图拼接在一起作为最终的输出结果
  52.         return fluid.layers.concat([p1, p2, p3, p4], axis=1)  
  54. class GoogLeNet(fluid.dygraph.Layer):
  55.     def __init__(self, name_scope):
  56.         super(GoogLeNet, self).__init__(name_scope)
  57.         # GoogLeNet包含五个模块，每个模块后面紧跟一个池化层
  58.         # 第一个模块包含1个卷积层
  59.         self.conv1 = Conv2D(num_channels=3, num_filters=64, filter_size=7, 
  60.                             padding=3, act='relu')
  61.         # 3x3最大池化
  62.         self.pool1 = Pool2D(pool_size=3, pool_stride=2,  
  63.                             pool_padding=1, pool_type='max')
  64.         # 第二个模块包含2个卷积层
  65.         self.conv2_1 = Conv2D(num_channels=64, num_filters=64, 
  66.                               filter_size=1, act='relu')
  67.         self.conv2_2 = Conv2D(num_channels=64, num_filters=192, 
  68.                               filter_size=3, padding=1, act='relu')
  69.         # 3x3最大池化
  70.         self.pool2 = Pool2D(pool_size=3, pool_stride=2,  
  71.                             pool_padding=1, pool_type='max')
  72.         # 第三个模块包含2个Inception块
  73.         self.block3_1 = Inception(self.full_name(), 192, 64, (96, 128), (16, 32), 32)
  74.         self.block3_2 = Inception(self.full_name(), 256, 128, (128, 192), (32, 96), 64)
  75.         # 3x3最大池化
  76.         self.pool3 = Pool2D(pool_size=3, pool_stride=2,  
  77.                                pool_padding=1, pool_type='max')
  78.         # 第四个模块包含5个Inception块
  79.         self.block4_1 = Inception(self.full_name(), 480, 192, (96, 208), (16, 48), 64)
  80.         self.block4_2 = Inception(self.full_name(), 512, 160, (112, 224), (24, 64), 64)
  81.         self.block4_3 = Inception(self.full_name(), 512, 128, (128, 256), (24, 64), 64)
  82.         self.block4_4 = Inception(self.full_name(), 512, 112, (144, 288), (32, 64), 64)
  83.         self.block4_5 = Inception(self.full_name(), 528, 256, (160, 320), (32, 128), 128)
  84.         # 3x3最大池化
  85.         self.pool4 = Pool2D(pool_size=3, pool_stride=2,  
  86.                                pool_padding=1, pool_type='max')
  87.         # 第五个模块包含2个Inception块
  88.         self.block5_1 = Inception(self.full_name(), 832, 256, (160, 320), (32, 128), 128)
  89.         self.block5_2 = Inception(self.full_name(), 832, 384, (192, 384), (48, 128), 128)
  90.         # 全局池化，尺寸用的是global_pooling，pool_stride不起作用
  91.         self.pool5 = Pool2D(pool_stride=1, 
  92.                                global_pooling=True, pool_type='avg')
  93.         self.fc = Linear(input_dim=1024, output_dim=1, act=None)
  95.     def forward(self, x):
  96.         x = self.pool1(self.conv1(x))
  97.         x = self.pool2(self.conv2_2(self.conv2_1(x)))
  98.         x = self.pool3(self.block3_2(self.block3_1(x)))
  99.         x = self.block4_3(self.block4_2(self.block4_1(x)))
  100.         x = self.pool4(self.block4_5(self.block4_4(x)))
  101.         x = self.pool5(self.block5_2(self.block5_1(x)))
  102.         x = fluid.layers.reshape(x, [x.shape[0], -1])
  103.         x = self.fc(x)
  104.         return x
  1. with fluid.dygraph.guard():
  2.     model = GoogLeNet("GoogLeNet")
  4. train(model)

通过运行结果可以发现，使用GoogLeNet在眼疾筛查数据集iChallenge-PM上，loss能有效的下降，经过5个epoch的训练，在验证集上的准确率可以达到95%左右。