[人工智能]纵横交错：Inception

Inception v1(GoogLeNet)

一般来说，增加网络的深度与宽度可以提升网络的性能，但是这样做也会带来参数量的大幅度增加，同时较深的网络需要较多的数据，否则容易产生过拟合现象。除此之外，增加神经网络的深度容易带来梯度消失的现象，Inception网络较好地解决了这个问题
Inception v1 网络是一个精心设计的22层卷积网络，并提出了具有良好局部特征结构的Inception模块，即对特征并行地执行多个大小不同的卷积运算与池化，最后再拼接到一起。由于1×1、3×3和5×5的卷积运算对应不同的特征图区域，因此这样做的好处是可以得到更好的图像表征信息。
Inception模块如下图所示，使用了三个不同大小的卷积核进行卷积运算，同时还有一个最大池化，然后将这4部分级联起来(拼接通道)，送入下一层

在上述模块的基础上，为进一步降低网络参数量，Inception又增加了多个1×1的卷积模块，这种1×1的模块可以先将特征图降维，再送给3×3和5×5大小的卷积核，由于通道数的降低，参数量也有了较大的减少，用1×1卷积核实现降维的思想，在多个轻量化网络中都会使用到

Inception v1网络一共有9个上述堆叠的模块，共有22层，在最后的Inception模块处使用了全局平均池化。为了避免深层网络训练时带来的梯度消失问题，作者还引入了两个辅助的分类器，在第3个与第6个Inception模块输出后执行Softmax并计算损失，在训练时和最后的损失一并回传
Inception v1的参数量是AlexNet的1/12，VGGNet的1/3，适合处理大规模数据，尤其是对于计算机资源有限的平台，代码如下：

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


#首先定义一个包含conv与ReLU的基础卷积类
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)

    def forward(self, x):
        x = self.conv(x)
        return F.relu(x, inplace=True)


#Inceptionv1的类，初始化时需要提供各个子模块的通道数大小
class Inceptionv1(nn.Module):
     def __init__(self, in_dim, hid_1_1, hid_2_1, hid_2_3, hid_3_1, out_3_5, out_4_1):
          super(Inceptionv1, self).__init__()
          #下面分别是4个子模块各自的网络定义
          self.branch1x1 = BasicConv2d(in_dim, hid_1_1, 1)
          self.branch3x3 = nn.Sequential(
               BasicConv2d(in_dim, hid_2_1, 1),
               BasicConv2d(hid_2_1, hid_2_3, 3, padding=1)
          )
          self.branch5x5 = nn.Sequential(
               BasicConv2d(in_dim, hid_3_1, 1),
               BasicConv2d(hid_3_1, out_3_5, 5, padding=2)
          )
          self.branch_pool = nn.Sequential(
               nn.MaxPool2d(3, stride=1, padding=1),
               BasicConv2d(in_dim, out_4_1, 1)
          )

     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

调用：

>>> import torch
>>> from v1 import Inceptionv1
>>> #网络实例化，输入模块通道数，添加.cuda()转移到GPU上
>>> net_inceptionv1 = Inceptionv1(3, 64, 32, 64, 64, 96, 32)
>>> net_inceptionv1
Inceptionv1(
  #第一个分支，使用1×1卷积，输出通道数为64
  (branch1x1): BasicConv2d(
    (conv): Conv2d(3, 64, kernel_size=(1, 1), stride=(1, 1))
  )
  #第二个分支，使用1×1卷积与3×3卷积，输出通道数为64
  (branch3x3): Sequential(
    (0): BasicConv2d(
      (conv): Conv2d(3, 32, kernel_size=(1, 1), stride=(1, 1))
    )
    (1): BasicConv2d(
      (conv): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    )
  )
  #第三个分支，使用1×1卷积与5×5卷积，输出通道数为96
  (branch5x5): Sequential(
    (0): BasicConv2d(
      (conv): Conv2d(3, 64, kernel_size=(1, 1), stride=(1, 1))
    )
    (1): BasicConv2d(
      (conv): Conv2d(64, 96, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    )
  )
  #第四个分支，使用最大池化与1×1卷积，输出通道数为32
  (branch_pool): Sequential(
    (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
    (1): BasicConv2d(
      (conv): Conv2d(3, 32, kernel_size=(1, 1), stride=(1, 1))
    )
  )
)
>>> input = torch.randn(1, 3, 256, 256)
>>> input.shape
torch.Size([1, 3, 256, 256])
>>> output = net_inceptionv1(input)
>>> #可以看到输出的通道数是输入通道数的和，即256=64+64+96+32
>>> output.shape
torch.Size([1, 256, 256, 256])

Inception v2

在Inception v1网络基础上，随后又出现了多个Inception版本。Inception v2进一步通过卷积分解与正则化实现更高效的计算，增加了BN层，同时利用两个级联的3×3卷积取代了Inception v1版本中的5×5卷积，如下图，这种方式既减少了卷积参数量，也增加了网络的非线性能力

代码如下：

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


#构建基础的卷积模块，与Inception v1的基础模块相比，增加了BN层
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):
        super(Inceptionv2, self).__init__()
        self.branch1 = BasicConv2d(192, 96, 1, 0)    #对应1×1卷积分支
        #对应1×1卷积与3×3卷积分支
        self.branch2 = nn.Sequential(
            BasicConv2d(192, 48, 1, 0),
            BasicConv2d(48, 64, 3, 1)
        )
        #对应1×1卷积、3×3卷积与3×3卷积分支
        self.branch3 = nn.Sequential(
            BasicConv2d(192, 64, 1, 0),
            BasicConv2d(64, 96, 3, 1),
            BasicConv2d(96, 96, 3, 1)
        )
        #对应3×3平均池化与1×1卷积分支
        self.branch4 = nn.Sequential(
            nn.AvgPool2d(3, stride=1, padding=1, count_include_pad=False),
            BasicConv2d(192, 64, 1, 0)
        )

    #前向过程，将4个分支进行torch.cat()拼接起来
    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

调用：

>>> import torch
>>> from v2 import Inceptionv2
>>> net_inceptionv2 = Inceptionv2()
>>> net_inceptionv2
Inceptionv2(
  #第1个分支，使用1×1卷积，输出通道数为96
  (branch1): BasicConv2d(
    (conv): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1))
    (bn): BatchNorm2d(96, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
  )
  #第2个分支，使用1×1卷积与3×3卷积，输出通道数为64
  (branch2): Sequential(
    (0): BasicConv2d(
      (conv): Conv2d(192, 48, kernel_size=(1, 1), stride=(1, 1))
      (bn): BatchNorm2d(48, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicConv2d(
      (conv): Conv2d(48, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (bn): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  第3个分支，使用1×1卷积与两个连续的3×3卷积，输出通道数为96
  (branch3): Sequential(
    (0): BasicConv2d(
      (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))
      (bn): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicConv2d(
      (conv): Conv2d(64, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (bn): BatchNorm2d(96, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
    )
    (2): BasicConv2d(
      (conv): Conv2d(96, 96, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (bn): BatchNorm2d(96, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  #第4个分支，使用平均池化与1×1卷积，输出通道数为64
  (branch4): Sequential(
    (0): AvgPool2d(kernel_size=3, stride=1, padding=1)
    (1): BasicConv2d(
      (conv): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))
      (bn): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
)
>>> input = torch.randn(1, 192, 32, 32)
>>> input.shape
torch.Size([1, 192, 32, 32])
>>> output = net_inceptionv2(input)    #将输入传入实例的网络
>>> output.shape    #输出特征图的通道数为：96+64+96+64=320
torch.Size([1, 320, 32, 32])

Inception v2将n×n的卷积运算分解为1×n与n×1两个卷积，如下图所示，这种分解方式可以使计算成本降低33%

此外，Inception v2还将模块中的卷积核变得更宽而不是更深，形成第三个模块，以解决表征能力瓶颈的问题，其计算更加高效
Inception v3在Inception v2的基础上，使用了RMSProp优化器，在辅助的分类器部分增加了7×7的卷积，并且使用了标签平滑技术
Inception v4则是将Inception的思想与残差网络进行了结合，显著提升了训练速度与模型准确率
Inception v1整体结构(LocalRespNorm已经被BN层所替代)：