1、网络结构
2、Inception块
四个路径从不同层面抽取信息，然后再输出通道维合并。
4
条 线路都使⽤了合适的填充来使输⼊与输出的⾼和宽⼀致。
第一个Inception块，显示通道数，降低通道数来控制模型复杂度；每条路上通道数可能不同。
跟3x3或者5x5卷积层比，Inception块有更少的参数个数和计算复杂度。
3、GoogLenet5段，9个Inception块
（1）段1和2
更小的宽口，更多的通道。
（2）段3
通道数分配不同；输出通道增加。
（3）段4和5
增加通道数；1024维特征输出。
4、Inception有各种后续变种
Inception-v2（BN）：使用了batch normalization
Inception-v3：修改了Inception块
- 替换5x5为多个3x3卷积层
- 替换5x5为1x7和7x1卷积层
- 替换3x3为1x3和3x1卷积层
- 更深
Inception-v3块，段3：
Inception-v3块，段4：
Inception-v3块，段5：
Inception-v4：使用残差连接
5、总结
Inception块用四条有不同参数的卷积层和池化层的路来抽取不同的信息，他的主要的一个优点就是模型参数小，计算复杂度低；
GoogleNet使用9个Inception块，是第一个达到上百层的网络，后续有一个系列改进；
6、代码实现
import time
import torch
from torch import nn, optim
import torch.nn.functional as F
import sys
sys.path.append("..")
import d2lzh_pytorch as d2l
device = torch.device('cuda' if torch.cuda.is_available() else
'cpu')
"""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) # 在通道维上连结输出
"""GOOGLENET模型"""
#第一模块，使用64通道的7x7卷积层
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))
#第二个模块使用两个卷积层：首先是64通道的1x1卷积层，然后是将通道数增加3倍的3x3卷积层。
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))
#第三个模块串联2个完整的Inception块
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块
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)
"""获取数据和训练模型"""
batch_size = 128
# 如出现“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)