PyTorch 实现GoogleNet用于图像分类

本实验主要介绍了如何在昇腾上，使用pytorch对经典的GoogleNet模型在公开的CIFAR10数据集进行分类训练的实战讲解。内容包括GoogleNet模型创新点介绍 、GoogleNet网络架构剖析 与GoogleNet网络模型代码实战分析等等。

本实验的目录结构安排如下所示：

• GoogleNet网络模型创新点介绍
• GoogleNet的网络架构剖析
• GoogleNet网络模型代码实现分析
• GoogleNet网络用于cifar数据集分类实战

GoogleNet网络模型创新点介绍

• 引入了Inception模块，该模块使用不同大小的卷积核和池化层来捕获不同尺度的特征。

Inception模块内部通过多个并行的卷积层和池化层来处理输入数据，然后将它们的输出进行拼接，从而增加了网络对不同尺度特征的感知能力。这种结构有助于提高网络的表达能力，同时减少了参数数量。

• 在Inception模块中广泛使用了1x1卷积；1x1卷积可以用来进行特征的线性组合，从而降低特征维度，减少计算负担。

这种技术被称为"瓶颈结构"，可以在不引入过多计算负担的情况下增加网络的深度和宽度。

• 使用全局平均池化替代全连接层，减少参数量，防止过拟合。

在传统的卷积神经网络中，通常使用全连接层来进行分类，这会导致大量的参数和计算量。GoogLeNet使用了全局平均池化来替代全连接层，通过对特征图的所有通道进行平均池化，生成一个特征向量，然后使用一个softmax分类器进行分类。这种做法减少了参数数量，防止过拟合，并降低了计算复杂性。

• 为于缓解梯度消失问题，促进梯度在网络中的传播，引入了两个辅助分类器，分别连接到中间层的不同位置。

这些辅助分类器在训练过程中引入了额外的损失函数，帮助网络更快地进行训练。在测试阶段，这些辅助分类器不起作用，只有主分类器的输出被使用。

GoogleNet的网络架构剖析

从Lent、Alexnet到VGG网络，随着网络的层数不断的增加，模型的表达能力也在不断的增强，但是也带来了参数过大的问题。而解决这一问题的根本方法就是将全连接转到到稀疏矩阵的架构。这是因为神经网络的雏形是参照人类神经元而设计的，而现实生物神经系统的连接也是稀疏的，此外对于大规模稀疏的神经网络，可以通过分析激活值的统计特性和对高度相关的输出进行聚类来逐层构建出一个最优网络。

因此，为了既能保持网络结构的稀疏性，又能利用密集矩阵的高计算性能。GoogleNet通过使用Inception结构将稀疏矩阵聚类为较为密集的子矩阵来提高计算性能的同时又能够将相关性强的特征汇聚到一起。

Inception模块

论文中提出了两种形式的Inception结构，分别是'Inception module'与'Inception module with dimensionality reduction'版本。其主要作用是怎样用密集成分来近似最优的局部稀疏结构。

通过对输入进行多尺度并行卷积、池化并结合1×1、3×3与5×5的卷积核用来提取不同尺度的特征，此外，根据卷积层输入输出shape的计算公式
我们只需要将令卷积步长stride=1，并且分别将1×1、3×3与5×5的卷积核中的pad值分别设置为0、1、2，那么通过这三个卷积核之后便可以得到相同维度的特征，与此同时在网络的最右侧加了一个3×3的最大池化，最后将这些特征图concat在一起即可得到不同维度的特征图。

上述Inception模块模块虽然能够有效的提取到不同尺度的特征，但是网络越往后特征越抽象且3x3和5x5卷积的比例也要增加，这就会导致随着网络深度加深会导致大量的计算。此外，由于pooling层不改变其通道数，因此通道特征图会变得很大。

针对上述基础Inception模块面临的问题，GoogleNet中通过采用大量的1×1的卷积来解决上述问题，改进后的结构如图中'Inception module with dimensionality reduction所示，图中在1×1、3×3与5×5卷积核之前与3×3的最大池化与1x1的卷积串联，这样不仅能够使得计算量大大减少，而且还能够组合出更多的非线性特征。

import torch
import torch.nn as nn
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_size=1)
        self.p2_2 = 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_size=5, padding=2)
        # 线路4，3x3最大汇聚层后接1x1卷积层
        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)))
        # 在通道维度上连结输出
        return torch.cat((p1, p2, p3, p4), dim=1)

GoogleNet网络代码实现分析

整个GoogleNet网络是由若干个Inception模块堆叠而成，此外由于此处是10分类任务且LRN操作对分类任务无明显提升效果，因此本实验在实现时只搭建了input-> softmax2主通路网络(没有实现的部分均在图中用x标记，如有兴趣可以尝试改动实现)。网络通过实现定义GoogLeNet类实现，整个网络结构被分成了5个阶段，经过5阶段后通过一个Fc层得到预测10个类别信息。

class GoogLeNet(nn.Module):
    def __init__(self, in_channels=3, num_classes=1000):
        super(GoogLeNet, self).__init__()

        # 第一阶段
        self.stage1 = nn.Sequential(
            nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

        # 第二阶段
        self.stage2 = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 192, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

        # 第三阶段
        self.stage3 = nn.Sequential(
            Inception(in_channels=192, c1=64, c2=(96, 128), c3=(16, 32), c4=32),#64+128+32+32=256
            Inception(256, 128, (128, 192), (32, 96), 64),#128+192+96+64=480
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

        # 第四阶段
        self.stage4 = 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)
        )

        # 第五阶段
        self.stage5 = nn.Sequential(
            Inception(832, 256, (160, 320), (32, 128), 128),
            Inception(832, 384, (192, 384), (48, 128), 128),
            nn.AdaptiveAvgPool2d((1, 1)),
            nn.Flatten())

        # 全连接层
        self.fc = nn.Linear(1024, num_classes)

    def forward(self, x):
        x = self.stage1(x)
        x = self.stage2(x)
        x = self.stage3(x)
        x = self.stage4(x)
        x = self.stage5(x)
        x = self.fc(x)
        return x

GoogleNet网络用于cifir数据集分类实战

基于上述搭建好的网络模型，我们现在就可以正式来使用该模型开始训练cifir数据集。

导入昇腾npu相关库transfer_to_npu、该模块可以使能模型自动迁移至昇腾上。

import torch_npu
from torch_npu.contrib import transfer_to_npu

torchvision模块中集成了一些当今比较流行的数据集、模型架构和用于计算机视觉的常见图像转换功能，torchvision模块中含有本次实验所需要的CIFAR数据集，因此导入该模块用于数据集的下载。tqdm是用于训练过程中训练进度条，便于我们能够清晰的看到整个训练过程。

import torchvision
import torchvision.transforms as transforms
from tqdm import tqdm

数据集预处理功能定义： 对图像数据集进行不同程度的变化，包括裁剪、翻转等方式增加数据的多样性，防止过拟合现象的出现，以增强模型的泛化能力。

调用了torchvision中的transform库中的compose方法，使用裁剪（RandomCrop）、翻转（RandomHorizontalFlip）等组合成tensor形式后并对tensor进行正则化（Normalize）。

transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])

cifar数据集共有60000张彩色图像，这些图像是32*32，分为10个类，每类6000张图。有50000张用于训练，构成了5个训练批，每一批10000张图；另外10000用于测试，单独构成一批。测试批的数据里，取自10类中的每一类，每一类随机取1000张。抽剩下的就随机排列组成了训练批。注意一个训练批中的各类图像并不一定数量相同，总的来看训练批，每一类都有5000张图。

数据集加载： torchvision中集成了一些通用的开源数据集，其中也包含cifar，此处通过torchvision函数加载cifar数据集到工作目录上的指定路径，如果已经下载好了，会直接校验通过，不会二次进行下载。

trainset = torchvision.datasets.CIFAR10(
    root='/home/ma-user/work/resnet50Experiments/dataset/cifar-10-batches-py', train=True, download=True, transform=transform_train)
trainloader = torch.utils.data.DataLoader(
    trainset, batch_size=128, shuffle=True)
testset = torchvision.datasets.CIFAR10(
    root='/home/ma-user/work/resnet50Experiments/dataset/cifar-10-batches-py', train=False, download=True, transform=transform_test)
testloader = torch.utils.data.DataLoader(
    testset, batch_size=100, shuffle=False)
classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')

训练模块: 根据传入的迭代次数'epoch'开始训练网络模型，这里需要在model开始前加入'net.train()'，使用随机梯度下降算法是将梯度值初始化为0（'zero_grad()'），计算梯度、通过梯度下降算法更新模型参数的值以及统计每次训练后的loss值（每隔100次打印一次）。

def train(epoch):
    net.train()
    train_loss = 0.0
    epoch_loss = 0.0
    for batch_idx, (inputs, targets) in enumerate(tqdm(trainloader, 0)):
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        lr_scheduler.step()

        train_loss += loss.item()
        epoch_loss += loss.item()

        if batch_idx % 100 == 99:  # 每100次迭代打印一次损失
            print(f'[Epoch {epoch + 1}, Iteration {batch_idx + 1}] loss: {train_loss / 100:.3f}')
            train_loss = 0.0
    return epoch_loss / len(trainloader)

测试模块: 每训练一轮将会对最新得到的训练模型效果进行测试，使用的是数据集准备时期划分得到的测试集，每类约为1000张。

def test():
    net.eval()
    test_loss = 0
    correct = 0
    total = 0
    with torch.no_grad():
        for batch_idx, (inputs, targets) in enumerate(tqdm(testloader)):
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = net(inputs)
            loss = criterion(outputs, targets)

            test_loss += loss.item()
            _, predicted = outputs.max(1)
            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()
    return 100 * correct / total

主功能调用模块： 该模块用于开启模型在指定数据集（cifar）上训练，其中定义了硬件设备为昇腾npu（device = 'npu'），定义了损失函数为交叉熵损失'CrossEntropyLoss()'，梯度下降优化算法为SGD并同时指定了学习率等参数。

import torch.optim as optim
device = 'npu'
net = GoogleNet()
net = net.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=1.0, weight_decay=5e-4)
lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer,0.1,steps_per_epoch=len(trainloader),
                                                   epochs=150,div_factor=25,final_div_factor=10000,pct_start=0.3)

训练与测试的次数为60次，这里用户可以根据需要自行选择设置更高或更低，每个epoch的测试准确率都会被打印出来，如果不需要将代码注释掉即可。

for epoch in range(60):
    epoch_loss = train(epoch)
    test_accuray = test()
    print(f'\nTest accuracy for AlexNet at epoch {epoch + 1}: {test_accuray:.2f}%')
    print(f'Epoch loss for AlexNet at epoch {epoch + 1}: {epoch_loss:.3f}')

Reference

[1] Szegedy C, Liu W, Jia Y, et al. Going deeper with convolutions[C]//Proceedings of the IEEE conference on computer vision and pattern recognition. 2015: 1-9.