7.4 含并行连接的网络GooLeNet

7.4.1 Inception块

在GoogleNet中，基本的卷积块称为Inception块，很可能得名于电影盗梦空间，因为电影中有一句台词，我们需要走的更。

图7-5所示，Inception块由4条并行路径组成，前3条路径使用窗口大小为1x1,3x3和5x5的卷积层，从不同空间大小中提取信息。中间的2条路径在输入上执行1x1卷积，以减少通道数，从而降低模型的复杂度。第4条路径使用3x3最大汇聚层，然后使用1x1卷积层来改变通道数。这4条路径都使用合适的填充以使得输入与输出的高度和宽度一致，最后我们将每条路径的输出在通道维度上合并，构成Inception块的输出，在Inception块中，通常调整的超参数时每层输出的通道数。

1x1卷积层 通道合并层

3x3 卷积层 填充1， 5x5卷积层 填充2 ，1x1卷积层

1x1卷积层， 1x1卷积层 3x3最大汇聚层 填充1

输入

图7-5 Inception块的架构

import torch

from torch import nn

from torch.nn functional as F

from d2l import torch as d2l

class Inception(nn.Module)

#c1 --c4时每条路径的输出通道数

def __init__(self, in_channels, c1,c2,c3,c4, **kwargs):

super(Inception, self).__init__(**kwargs)

#路径1，单1x1卷积层

self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)

#路径2，1x1卷积层后接3x3卷积层

self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_szie=1)

self.p2_1 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)

#路径3， 1x1卷积层后接5x5卷积层

self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)

self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_szie=3, padding=2)

#路径4 3x3最大汇聚层后接1x1卷积层

self.p4_1 = nn.MaxPool2d(kernel_szie=3,stride=1,padding=1)

self.p4_2= nn.Conv2d(in_channels, c4, kernel_szie=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

那么为什么googleNet 这个网络如此有效呢？考虑一下滤波器组合，可以用各种滤波器尺寸探索图像，意味着不同尺寸的滤波器可以有效的识别不同范围的图像细节，同时，我们可以为不同的滤波器分配不同数量的参数。

7.4.2 GoogleNet模型

如图7-6所示，GoogleNet一共使用9个Inception块和全局平均汇聚层的堆叠来生成其估计值，Inception块之间的最大汇聚层可以降低维度。第一个模块类似于AlexNet和LeNet Inception块的组合从VGG继承，全局平均汇聚层避免了在最后使用全连接层。

现在，我们逐一实现GoogleNet的每个模块，第一个模块使用64个通道，7x7卷积层

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

nn.ReLU(),

nn.MaxPool2d(kernel_size=3, stirde=2,padding=1))

第二个模块使用两个卷积层，第一个卷积层是64个通道，1x1卷积层，第二个卷积层使用将通道数增加为3倍的3x3卷积层，这对英语Inception 块中的第二条路径。

b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_szie=1),nn.ReLU(),

nn.Conv2d(64, 192, kernel_szie=3,padding=1),

nn.RelU(),nn.MaxPool2d(kernel_szie=3, stride=2, padding=1))

全连接层

全局平均汇聚层

2X

3x3最大汇聚层

5x

3x3最大汇聚层

2x

3x3最大汇聚层

3x3卷积层

1x1卷积层

3x3最大汇聚层

7x7卷积层

第三个模块串联两个完整的Inception块，第一个Inception 块的输出通道数为64+128+32+32 = 256。4条路径的输出通道数之比为64:128:32:32 = 2:4:1:1/第二条和第三条路径首先将输入通道数分别减少到96/192 = 1/12，然后连接第二个卷积层。第二个Inception 块的输出通道数增加到128 + 192 + 96 +64 = 480，4条路径的输出通道数之比为128:192:96:64 = 4:6:3:2。第二条路径和第三条路径先将输入通道数分别减少到128/256=1/2和32/256=1/8

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))

第四个模块更加复杂，串联了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 这些路径通道数的分配和第三个模块中的类似，首先是输出通道数最多的含3x3卷积层的第二条路径，其次是仅含有1x1卷积层的第一条路径，最后是含有5x5 卷积层的第三条路径和含油3x3最大汇聚层的第四条路径，其中第二条路径和第三条路径都会按比例减少通道数，这些比例在各个Inception块中略有不同。

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))

第五个模块包含输出通道数为256 + 320 + 128 + 128 = 832和384 + 384 + 128 + 128 = 1024的两个Inception块，其中每条路径通道数的分配思路和第三个模块和第四个模块中的一致，只是在具体数值上有所不同，需要注意的是，第五个模块的后面紧跟输出层，该模块同NiN一样使用全局平均汇聚层，将每个通道的高度和宽度变成1，最后我们将输出变成二维数组，再连接一个输出个数为标签类别数的全连接层。

b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),

Inceotion(832, 384, (192, 384), (48, 128), 128),

nn.AdaptiveAvgPool2d(1,1),

nn.Flatten())

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

GoogleNet模型的计算复杂，而且不如VGG那样便于修改通道数，为了使FashionMNIST上的训练短小精悍，我们将输入的高度和宽度从224降低到96，这简化了计算，下面演示各个模块输出的形状变化。

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

for layer in net:

X = layer(x)

7.4.3 训练模型

和之前一样，我们使用FashionMNIST 数据集来训练模型。在训练之前，我们将图像分辨率转换为96像素x96像素。

lr, num_epochs, batch_szie = 0.1, 10, 128

tran_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)

d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())