《动手学深度学习》7.4. 含并行连结的网络（GoogLeNet）

1.训练部分

导入功能包

import torch
from torch import nn
from torch.nn import functional as F
from torchsummary import summary
import MyFunction as MF

Inception块的定义

# Inception块的定义，四个并行线路
class Inception(nn.Module):
    """
    一个inception模块的四个并行线路如下:
    1.一个1x1的卷积，一个小的感受野进行卷积提取特征
    2.一个1x1的卷积加上一个3x3的卷积，1x1的卷积降低输入的特征通道，减少参数计算量，然后接一个3x3的卷积做一个较大感受野的卷积
    3.—个1x1的卷积加上一个5x5的卷积，作用和第二个一样
    4.一个3×3的最大池化加上1x1的卷积，最大池化改变输入的特征排列，1x1的卷积进行特征提取
    最后将四个并行线路得到的特征在通道这个维度上拼接在一起
   """
    # `c1`--`c4` 是每条路径的输出通道数，**kwargs为关键字参数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单1 x 1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2，1 x 1卷积层后接3 x 3卷积层
        self.p2_1 = nn.Conv2d(in_channels, 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_channels, 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_channels, 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)))
        #  # 在通道维度上连结输出，不同尺度的特征在此融合
        # [N,C1+C2[1]+C3[1]+C4,H,W]
        return torch.cat((p1, p2, p3, p4), dim=1)

GoogLeNet模型

# GoogLeNet模型: 5段，9个Inception块
# 第一个模块使用 64 个通道、  7×7 卷积层
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个通道、 1×1 卷积层；
# 第二个卷积层使用将通道数量增加三倍的 3×3 卷积层
b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

# 第三个模块串联两个完整的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))


# 第五模块包含两个Inception块。
b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
                   Inception(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))

参数设置

lr, num_epochs, batch_size = 0.1, 10, 128

获取数据

train_iter, test_iter = MF.load_data_fashion_mnist(batch_size, resize=96)

训练模型

# 训练模型
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
MF.train_ch7(net, train_iter, test_iter, num_epochs, lr, device=device)

训练结果

2.预测部分

导入功能包

import torch
from torch import nn
from torch.nn import functional as F
import MyFunction as MF
import os
import matplotlib.pyplot as plt

创建模型

# Inception块的定义，四个并行线路
class Inception(nn.Module):
    # `c1`--`c4` 是每条路径的输出通道数，**kwargs为关键字参数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单1 x 1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2，1 x 1卷积层后接3 x 3卷积层
        self.p2_1 = nn.Conv2d(in_channels, 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_channels, 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_channels, 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)))
        #  # 在通道维度上连结输出，不同尺度的特征在此融合
        # [N,C1+C2[1]+C3[1]+C4,H,W]
        return torch.cat((p1, p2, p3, p4), dim=1)



# GoogLeNet模型: 5段，9个Inception块
# 第一个模块使用 64 个通道、  7×7 卷积层
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个通道、 1×1 卷积层；
# 第二个卷积层使用将通道数量增加三倍的 3×3 卷积层
b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

# 第三个模块串联两个完整的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))


# 第五模块包含两个Inception块。
b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
                   Inception(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))

加载模型参数

# 模型参数位置
filename = r'./data/GoogLeNet-9.pth'
# 判断模型参数是否存在
if os.path.exists(filename):
    # 加载模型参数
    net.load_state_dict(torch.load(filename))
else:
    print(f"No such file or directory: '{filename}'")

预测

# 预测
lr, num_epochs, batch_size = 0.1, 10, 128
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_iter, test_iter = MF.load_data_fashion_mnist(batch_size, resize=96)
MF.predict_ch7(net, test_iter)
plt.show()