PyTorch 实现 GoogleNet 用于图像分类

2025-05-27
上海
本文字数：5758 字
阅读完需：约 19 分钟

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 torchimport torch.nn as nnclass 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_npufrom torch_npu.contrib import transfer_to_npu

复制代码

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

import torchvisionimport torchvision.transforms as transformsfrom 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 optimdevice = '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.

发布于: 2025-05-27阅读数: 2

永荣带你玩转昇腾

关注

还未添加个人签名 2024-12-19 加入

还未添加个人简介

发布

暂无评论

创作场景

PyTorch 实现 GoogleNet 用于图像分类

PyTorch 实现 GoogleNet 用于图像分类

GoogleNet 网络模型创新点介绍

GoogleNet 的网络架构剖析

Inception 模块

GoogleNet 网络代码实现分析

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

Reference

永荣带你玩转昇腾

评论