Pytorch图像分类：04使用PyTorch搭建GoogLeNet模型

心之所向h

已于 2024-08-12 11:34:49 修改

阅读量565

点赞数 28

分类专栏： Pytorch图像分类文章标签： pytorch 分类人工智能

于 2024-08-07 10:42:12 首次发布

本文链接：https://blog.csdn.net/qq_54695558/article/details/140903874

版权

Pytorch图像分类专栏收录该内容

5 篇文章 0 订阅

订阅专栏

【简介】：基于flower_data使用PyTorch搭建GoogleLeNet模型进行图片分类
【参考】：4.1 VGG网络详解及感受野的计算_哔哩哔哩_bilibili
【代码完整版】：04 GoogLeNet(github.com)

注：本人还在学习初期，此文是为了梳理自己所学整理的，有些说法是自己的理解，不一定对，如有差错，请批评指正！

一、基础知识

1.背景

GoogLeNet在2014年由Google团队提出，斩获当年ImageNet竞赛中Classification Task (分类任务)第一名。

2.网络的亮点

网络中的亮点包括:

引入了Inception结构（融合不同尺度的特征信息)
使用1x1的卷积核进行降维以及映射处理
添加两个辅助分类器帮助训练
丢弃全连接层，使用平均池化层（大大减少模型参数)

AlexNet和VGG只有一个输出层，而GoogleLeNet有三个输出层（其中有两个是辅助分类层）
在这里插入图片描述

Inception模块

之前我们学到的网络结构都是串联的，而Inception结构是并联的，如下图(a)，将上一层的输出同时输入到4个分支中进行处理，处理之后将这四个特征矩阵按深度进行拼接，得到一个输出特征矩阵，需要注意的是，每个每支所得到的特征矩阵宽高必须相同，否则无法沿深度方向进行拼接。

对于图(b)，它是Inception结构加了一个降维的功能，以减少模型训练参数，减少计算量，起这个降维功能的，就是3个1x1的卷积层。
🤔那1x1卷积层是如何起到降维的作用的呢？
直观上讲，由于特征矩阵的深度由卷积核的个数所决定,所以原来m×m×C1的矩阵，经1×1×C2的卷积层后，它的形状变为m×m×C2，只要C2<C1，它的维度就降低了。为了便于理解，这里放一张别人的图：参考链接

具体来说，对一个深度为512的特征矩阵使用64个大小为5x5的卷积核进行卷积，不使用1x1卷积核进行降维话一共需要819200个参数，如果使用1x1卷积核进行降维一共需要50688个参数，明显少了很多。
🤔这里的819200是如何计算出来的呢？即如何计算卷积过程中的参数量？

见下图
在这里插入图片描述
参数量指的是模型可学习的参数量，它只存在于卷积层、全连接层中，对于池化层、输出层，是没有的；而在卷积层中，它指的是权重weights和偏置bias。
假设输入特征图有C1=32个，输出特征图有C2=64个，卷积核的宽高为“ n * m ”=3x3 ，由于传统卷积核的深度（channel）与当前图像的深度相（channel）同，所以我们卷积核的尺寸为3 * 3* 32，对于第一层的输出，我们学习了64个不同的3 * 3 * 32卷积核，总权重为“ C1 * n * m * C2 ”。然后，每个特征图都有一个称为“偏差”的术语。因此，参数总数为“( C1 * n * m + 1) * C2 ”。

要是还不能理解，请看下面的示例：
单个卷积核多通道的卷积操作：

单个卷积核多通道：在反向传播过程中“蓝色框”里面的卷积核的所有参数都是可以更新的，这些参数即可学习的参数，对于单个卷积核是C1 * m * n，那对于C2个卷积核，就是“ C1 * n * m * C2 ”了。
在这里插入图片描述

辅助分类器

在这里插入图片描述
两个辅助分类器的输入分别来自Inception(4a)和Inception(4d)。

第一层是一个平均池化下采样层，池化核大小为5x5，stride=3
第二层是卷积层，卷积核大小为1x1，stride=1，卷积核个数是128
第三层是全连接层，节点个数是1024
第四层是全连接层，节点个数是1000（对应分类的类别个数）

3.网络结构

下面是原论文中给出的参数列表，对于我们搭建的Inception模块，所需要使用到参数有#1x1, #3x3reduce, #3x3, #5x5reduce, #5x5, poolproj，这6个参数，分别对应着所使用的卷积核个数。
在这里插入图片描述
#1x1表示1x1的卷积核的个数，#3x3reduce表示在3x3卷积核之前的1x1卷积核的个数，poolproj表示在池化层之后的1x1卷积核的个数。

以下是googleNet的网络结构图：

二、搭建模型

1.搭建GoogLeNet模型

由于每次Conv2d之后都会使用ReLU()激活函数，故将它们合在一起：

class BasicConv2d(nn.Module):
    def __init__(self,in_channels,out_channels,**kwargs):
        super(BasicConv2d,self).__init__()
        self.conv=nn.Conv2d(in_channels,out_channels,**kwargs)
        self.relu=nn.ReLU(inplace=True)
        
    def forward(self,x):
        x=self.conv()
        x=self.relu()
        return x

搭建Inception模块：

class Inception(nn.Module):
    def __init__(self,in_channels,ch1x1,ch3x3red,ch3x3,ch5x5red,ch5x5,pool_proj):
        super(Inception,self).__init__()
        self.branch1=BasicConv2d(in_channels,ch1x1,kernel_size=1)

        self.branch2=nn.Sequential(
            BasicConv2d(in_channels,ch3x3red,kernel_size=1),
            BasicConv2d(ch3x3red,ch3x3,kernel_size=3,padding=1)#保证输出大小为1x1
        )

        self.branch3=nn.Sequential(
            BasicConv2d(in_channels,ch5x5red,kernel_size=1),
            BasicConv2d(ch5x5red,ch5x5,kernel_size=5,padding=2)
        )

        self.branch4=nn.Sequential(
            nn.MaxPool2d(kernel_size=3,stride=1,padding=1),
            BasicConv2d(in_channels,pool_proj,kernel_size=1)
        )
    def forward(self,x):
        branch1=self.branch1(x)
        branch2=self.branch2(x)
        branch3=self.branch3(x)
        branch4=self.branch4(x)
        
        outputs=[branch1,branch2,branch3,branch4]
        return torch.cat(outputs,1)#按深度展开

搭建辅助分类器：

class InceptionAux(nn.Module):
    def __init__(self,in_channels,num_classes):
        super(InceptionAux,self).__init__()
        self.averagePool=nn.AvgPool2d(kernel_size=5,stride=3)
        self.conv=BasicConv2d(in_channels,out_channels=128,kernel_size=1)#output[batch,128,4,4]
        self.fc1=nn.Linear(2048,1024 )
        self.fc2 = nn.Linear(1024, num_classes)
    def forward(self,x):
        # aux1(4a): N x 512 x 14 x 14, aux2(4d): N x 528 x 14 x 14
        x=self.averagePool(x)
        # aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4
        x=self.conv(x)
        
        # N x 128 x 4 x 4
        x=torch.flatten(x,1)#[N,C,H,W],按深度展开
        
        # N x 2048
        x=F.dropout(p=0.7,training=self.training)#训练模式下（model.train()）,training自动设置为true
        x=self.fc1(x)
        x=F.relu(x,inplace=True)
        # N x 1024
        x=F.dropout(p=0.7,training=self.training)#评估模式下（model.eval()）,training自动设置为false
        x=self.fc2(x)
        # N x num_classes

        return x

搭建GoogLeNet网络：

class GoogLeNet(nn.Module):
    def __init__(self,num_classes=1000,aux_logits=True,init_weights=False):#aux_logits数字分类器
        super(GoogLeNet,self).__init__()
        self.aux_logits=aux_logits
        #input=224,output=112,公式：(224-7+2p)/2+1=112-->p=2.5,但如果p取2，output=111.5,pytorch里面是向下取整，为111，不行
        self.conv1=BasicConv2d(3,out_channels=64,kernel_size=7,stride=2,padding=3)
        self.maxpool1=nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode=True)#ceil_mode=True表示对求出的特征图上取整
        # nn.LocalResponseNorm #在maxpool之后的localRespNorm没啥用，这里就不写上去

        self.conv2=BasicConv2d(in_channels=64,out_channels=64,kernel_size=1,stride=1)
        self.conv3=BasicConv2d(in_channels=64,out_channels=192,kernel_size=3,stride=1,padding=1)
        self.maxpool2=nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode=True)

        self.inception3a=Inception(192,64,96,128,16,32,32)
        self.inception3b=Inception(256,128,128,192,32,96,64)
        self.maxpool3=nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode=True)

        self.inception4a=Inception(480,192,96,208,16,48,64)
        self.inception4b=Inception(512,160,112,224,24,64,64)
        self.inception4c=Inception(512,128,128,256,24,64,64)
        self.inception4d=Inception(512,112,144,288,32,64,64)
        self.inception4e=Inception(528,256,160,320,32,128,128)
        self.maxpool4=nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode=True)

        self.inception5a=Inception(832,256,160,320,32,128,128)
        self.inception5b=Inception(832,384,192,384,48,128,128)

        self.avg=nn.AvgPool2d(kernel_size=7,stride=1)

        if aux_logits:
            self.aux1=InceptionAux(512,num_classes)#辅助分类器1是从4a接出来的，所以in_channels为4a的输出
            self.aux2=InceptionAux(528,num_classes)#辅助分类器2是从4d接出来的，所以in_channels为4d的输出
            
        self.avgpool=nn.AdaptiveAvgPool2d((1,1))#自适应宽高为1x1
        self.dropout=nn.Dropout(p=0.4)
        self.fc=nn.Linear(1024,num_classes)

        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        # N x 3 x 224 x 224
        x = self.conv1(x)
        # N x 64 x 112 x 112
        x = self.maxpool1(x)
        # N x 64 x 56 x 56
        x = self.conv2(x)
        # N x 64 x 56 x 56
        x = self.conv3(x)
        # N x 192 x 56 x 56
        x = self.maxpool2(x)

        # N x 192 x 28 x 28
        x = self.inception3a(x)
        # N x 256 x 28 x 28
        x = self.inception3b(x)
        # N x 480 x 28 x 28
        x = self.maxpool3(x)
        # N x 480 x 14 x 14
        x = self.inception4a(x)
        # N x 512 x 14 x 14
        if self.training and self.aux_logits:  # eval model lose this layer
            aux1 = self.aux1(x)

        x = self.inception4b(x)
        # N x 512 x 14 x 14
        x = self.inception4c(x)
        # N x 512 x 14 x 14
        x = self.inception4d(x)
        # N x 528 x 14 x 14
        if self.training and self.aux_logits:  # eval model lose this layer
            aux2 = self.aux2(x)

        x = self.inception4e(x)
        # N x 832 x 14 x 14
        x = self.maxpool4(x)
        # N x 832 x 7 x 7
        x = self.inception5a(x)
        # N x 832 x 7 x 7
        x = self.inception5b(x)
        # N x 1024 x 7 x 7

        x = self.avgpool(x)
        # N x 1024 x 1 x 1
        x = torch.flatten(x, 1)
        # N x 1024
        x = self.dropout(x)
        x = self.fc(x)
        # N x 1000 (num_classes)
        if self.training and self.aux_logits:  # eval model lose this layer
            return x, aux2, aux1
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)

2.训练

和之前训练AlexNet、VGG的步骤差不多，只需要修改少部分内容，如下：

1）定义模型

from model import GoogLeNet

net=GoogLeNet(num_classes=5,aux_logits=True,init_weights=True)
save_path='./GoogLeNet.pth'

2）训练时损失函数部分

        # outputs=net(images.to(device))
        # loss = loss_fn(outputs, labels.to(device))
        logits,aux_logits2,aux_logits1=net(images.to(device))#有三个输出
        loss0=loss_fn(logits,labels.to(device))
        loss1=loss_fn(aux_logits1,labels.to(device))
        loss2=loss_fn(aux_logits2,labels.to(device))
        loss=loss0+0.3*loss1+0.3*loss2#对于辅助分类器的损失，按0.3的权重加入到总损失中

3.预测

预测也和之前训练AlexNet、VGG的步骤差不多，只需要修改少部分内容，如下：

在预测过程中不需要3个分类器，故在创建模型时将aux_logits设置为False，并且不需要初始化；
但是之前保存的模型中有辅助分类器，这里将strict设置为False，为True则表示它会将当前模型与载入权重精准匹配，为False则不会，所以这里unexpected_keys就是辅助分类器的一些参数，无用。

    # create model
    model = GoogLeNet(num_classes=5, aux_logits=False).to(device)

    # load model weights
    weights_path = "./googleNet.pth"
    assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    missing_keys, unexpected_keys = model.load_state_dict(torch.load(weights_path, map_location=device),strict=False)

输出>:

class: daisy        prob: 0.00997
class: dandelion    prob: 0.00101
class: roses        prob: 0.177
class: sunflowers   prob: 0.00127
class: tulips       prob: 0.811

result

心之所向h

关注

28
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
Pytorch图像分类：04使用PyTorch搭建GoogLeNet模型

【简介】：基于flower_data使用PyTorch搭建GoogleLeNet模型进行图片分类【参考】：4.1 VGG网络详解及感受野的计算_哔哩哔哩_bilibili【代码完整版】：04 GoogLeNet(github.com)注：本人还在学习初期，此文是为了梳理自己所学整理的，有些说法是自己的理解，不一定对，如有差错，请批评指正！GoogLeNet在2014年由Google团队提出，斩获当年ImageNet竞赛中Classification Task (分类任务)第一名。网络中的亮点包括:Ale
复制链接

扫一扫

专栏目录