GoogLenet网络解读及代码实现（Pytorch）

论文题目：Going deeper with convolutions

论文链接：https://arxiv.org/abs/1409.4842

论文研究目标

利用赫布理论和多尺度处理直觉设计一种增加深度和宽度的提高内部计算资源利用率的（同时保持了计算预算不变）网络。

网络主要结构

                                                      图一  网络总体架构

上图为主要包含Inception块+辅助分类器的GoogLeNet结构示意图。

Inception模块

上图为Inception块示意图 (a)为普通的Inception块；(b)为带有1×1卷积的，可以对输入通道降维的Inception块

 Inception模块特点 

1. 由Inception基础块组成。
2. Inception块相当于⼀个有4条线路的⼦⽹络。它通过不同窗口形状的卷积层和最⼤池化层来并⾏抽取信息，并使⽤1×1卷积层减少通道数从而降低模型复杂度。
3. 可以⾃定义的超参数是每个层的输出通道数，我们以此来控制模型复杂度。

针对同一个输入层，在Inception块中有四条并行的线路，其中前1~3个是1×1卷积层，第4个是一个MaxPooling池化层，这四条线路最后的输出拥有相同的shape和不同的channel通道数。于是，这些输出最后可在channel维度进行合并。 例如：28×28×64，28×28×128，28×28×32，28×28×32。 通道合并层的shape:28×28×256(64+128+32+32)。

举例分析加入1*1卷积核设计的好处：
假设输入时256个feature map进来，256个feature map输出，假设Inception层只执行3x3的卷积，那么这就需要执行 (256x256) x (3x3) 次乘法（大约589,000次计算操作）。现在Bottleneck layer的思想是先来减少特征的数量，我们首先执行256 -> 64 的1×1卷积，然后在所有Bottleneck layer的分支上对64大小的feature map进行卷积，最后再64 -> 256 1x1卷积。
操作量是：
256×64 × 1×1 = 16,384      64x1x1卷积核对上一层输出卷积计算
64×256 × 3×3= 147456      256x3x3卷积核对1x1卷积输出进行卷积计算
总共约163840，而我们以前有近600,000。减少3倍多的操作。

 layer设计

GoogLeNet是作者团队在参加2014大规模视觉挑战赛时送去参加的几种Inception结构的模型之一。该网络设计时考虑了计算效率和实用性，故可以在单个设备上运行推理，对低内存设备比较友好。 整个网络使用了9个Inception块，结构排布如表格中所示：

训练方法

模型训练采用了DistBelief分布式机器学习系统对GoogleNet进行了训练（Cpu）。论文表示使用高端GPU，可以在1周内完成模型的训练。训练采用了0.9动量的异步随机梯度下降，固定学习率(每8个迭代学习率降低4%)，另外使用各个各个尺寸的图片(数据增强)对于降低过拟合很有用。

总结

作者在论文中表示，用现有的dense结构来组合构建出最佳的稀疏结构，是改善计算机视觉神经网络的可行方法。与较浅和较窄的网络结构相比，该方法的优点在于计算量适度增加的情况下显著提高网络效果。在目标检测领域，尽管没有利用上下文和bounding box回归，我们的效果还是很好，进一步表面Inception结构的优越性，未来将在此基础上继续研究更加精细和自动化地方式来创造稀疏结构用以促进各领域的工作。

代码实现如下图的GoogLenet网络

构建Inception基本模块

class Inception(nn.Module):
    # c1 - c4为每条线路里的层的输出通道数
    def __init__(self, in_c, c1, c2, c3, c4):
        super(Inception, self).__init__()
        # 线路1，单1 x 1卷积层
        self.p1_1 = nn.Conv2d(in_c, c1, kernel_size=1)
        # 线路2，1 x 1卷积层后接3 x 3卷积层
        self.p2_1 = nn.Conv2d(in_c, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        # 线路3，1 x 1卷积层后接5 x 5卷积层
        self.p3_1 = nn.Conv2d(in_c, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        # 线路4，3 x 3最大池化层后接1 x 1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_c, c4, kernel_size=1)

    def forward(self, x):
        p1 = F.relu(self.p1_1(x))
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        return torch.cat((p1, p2, p3, p4), dim=1)  # 在通道维上连结输出

总体实现

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
                   Inception(256, 128, (128, 192), (32, 96), 64),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
                   Inception(512, 160, (112, 224), (24, 64), 64),
                   Inception(512, 128, (128, 256), (24, 64), 64),
                   Inception(512, 112, (144, 288), (32, 64), 64),
                   Inception(528, 256, (160, 320), (32, 128), 128),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
                   Inception(832, 384, (192, 384), (48, 128), 128),
                   d2l.GlobalAvgPool2d())

net = nn.Sequential(b1, b2, b3, b4, b5, 
                    d2l.FlattenLayer(), nn.Linear(1024, 10))

net = nn.Sequential(b1, b2, b3, b4, b5, d2l.FlattenLayer(), nn.Linear(1024, 10))

X = torch.rand(1, 1, 96, 96)

for blk in net.children(): 
    X = blk(X)
    print('output shape: ', X.shape)

#batchsize=128
batch_size = 16
# 如出现“out of memory”的报错信息，可减小batch_size或resize
#train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)

lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)