Pytorch实现InceptionV1模型（GoogLeNet）

最新推荐文章于 2024-04-27 12:07:25 发布
最新推荐文章于 2024-04-27 12:07:25 发布
阅读量1.2k 收藏 18
点赞数 8
文章标签： 深度学习 神经网络 pytorch 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsjjason/article/details/113620606
版权

Pytorch实现InceptionV1模型

模型简介

论文链接：https://arxiv.org/pdf/1409.4842v1.pdf
模型提出时间：2014年9月
参数量：5M
Top1准确率：69.8%

    模型基本思想：同时使用1×1、3×3和5×5的卷积核对图像进行特征提取，充分增加了模型的宽度，从而提高模型对图像不同尺度特征的适应能力。其中，1×1的卷积核实际是对图像进行缩放，这对识别精度的提升也有一定帮助。

模型结构及源码

InceptionV1模块

    InceptionV1模块由下图中的基本模块构成，其中每个子模块的stride均为1，padding均为⌊kernel_size/2⌋，通过这样设置stride和padding的大小，每个模块在处理图片时不会改变图片的大小，而只改变通道数目。由下图可见，InceptionV1模型的输出是四个卷积核的输出叠加的结果，即InceptionV1并没有改变图片的大小，而只改变了通道数目。

    InceptionV1模块中的每个卷积模块由三部分构成：卷积、批标准化和激活。
    InceptionV1模块中的卷积模块源码如下：

# InceptionV1的卷积模块：卷积 + 批标准化 + 激活
def ConvBNReLU(in_channels,out_channels,kernel_size):
    return nn.Sequential(
        # 卷积核的stride=1， padding=kernel_size//2
        nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=1,padding=kernel_size//2),
        nn.BatchNorm2d(out_channels),
        nn.ReLU6(inplace=True)
    )

    InceptionV1模块的源码如下：

# InceptionV1模块
class InceptionV1Module(nn.Module):
    def __init__(self, inchannel, outchannel1, outchannel2_1, outchannel2_2, outchannel3_1, outchannel3_2, outchannel4):
        super(InceptionV1Module, self).__init__()
        # 1*1卷积模块
        self.block1 =  ConvBNRelu(inchannel, outchannel1, 1)
        # 1*1卷积模块 + 3*3卷积模块
        self.block2_1 = ConvBNRelu(inchannel, outchannel2_1, 1)
        self.block2_2 = ConvBNRelu(outchannel2_1, outchannel2_2, 3)
        # 1*1卷积模块 + 5*5卷积模块
        self.block3_1 = ConvBNRelu(inchannel, outchannel3_1, 1)
        self.block3_2 = ConvBNRelu(outchannel3_1, outchannel3_2, 5)     
        # 3*3池化模块 + 1*1卷积模块
        self.block4_1 = nn.MaxPool2d(kernel_size = 3, stride = 1, padding = 1)
        self.block4_2 = ConvBNRelu(inchannel, outchannel4, 1)
    def forward(self, x):
        x1 = self.block1(x)      # output1
        x2 = self.block2_1(x)
        x2 = self.block2_2(x2)   # output2
        x3 = self.block3_1(x)
        x3 = self.block3_2(x3)   # output3
        x4 = self.block4_1(x)
        x4 = self.block4_2(x4)   # output4
        x = torch.cat([x1, x2, x3, x4], dim=1)    # 四个模块的输出叠加
        return x

全连接模块

    经过多个Inception模块处理后，可将Inception模块的输出通过一个全连接模块得到最终输出，全连接模块的基本构架如下图所示。全连接模块的输入是14×14的矩阵，而输出是待分类类别个数。全连接模块的结构和源码如下：

# 全连接模块
class InceptionAux(nn.Module):
    def __init__(self, in_channels,out_channels):
        super(InceptionAux, self).__init__()
        # 5*5平均池化
        self.auxiliary_avgpool = nn.AvgPool2d(kernel_size=5, stride=3)
        # 1*1卷积模块
        self.auxiliary_conv1 = ConvBNReLU(in_channels=in_channels, out_channels=128, kernel_size=1)
        # 全连接1 + 激活 + dropout
        self.auxiliary_linear1 = nn.Linear(in_features=128 * 4 * 4, out_features=1024)
        self.auxiliary_relu = nn.ReLU6(inplace=True)
        self.auxiliary_dropout = nn.Dropout(p=0.7)
        # 全连接2
        self.auxiliary_linear2 = nn.Linear(in_features=1024, out_features=out_channels)
    def forward(self, x):
        x = self.auxiliary_conv1(self.auxiliary_avgpool(x))
        x = x.view(x.size(0), -1)
        x= self.auxiliary_relu(self.auxiliary_linear1(x))
        out = self.auxiliary_linear2(self.auxiliary_dropout(x))
        return out

GoogLeNet模型

    GoogLeNet实际上就是多个InceptionV1模块和全连接模块的组合，其模型框架图如下图所示。

    GoogLeNet接受的输入图片大小为224×224，可将其分解为几个子模块进行分析。其中，子模块1由多个卷积和池化操作构成，子模块2由三个InceptionV1模块构成，子模块3由三个InceptionV1模块和一个全连接模块构成，子模块4由三个InceptionV1模块和两个全连接模块构成。各模块的细节如下图所示：

    GoogLeNet模型的源码如下：

# GoogLeNet模型
class GoogLeNet(nn.Module):
    def __init__(self, num_classes=1000, stage='train'):
        super(InceptionV1, self).__init__()
        self.stage = stage
        # 子模块1：一系列卷积池化操作
        self.block1 = nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=7,stride=2,padding=3),
            nn.BatchNorm2d(64),
            nn.MaxPool2d(kernel_size=3,stride=2, padding=1),
            nn.Conv2d(in_channels=64, out_channels=64, kernel_size=1, stride=1),
            nn.BatchNorm2d(64),
            nn.Conv2d(in_channels=64, out_channels=192, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(192),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
        )
        # 子模块2：三个InceptionV1模块
        self.block2 = nn.Sequential(
            InceptionV1Module(in_channels=192,out_channels1=64, out_channels2reduce=96, out_channels2=128, 
                              out_channels3reduce = 16, out_channels3=32, out_channels4=32),
            InceptionV1Module(in_channels=256, out_channels1=128, out_channels2reduce=128, out_channels2=192,
                              out_channels3reduce=32, out_channels3=96, out_channels4=64),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
            InceptionV1Module(in_channels=480, out_channels1=192, out_channels2reduce=96, out_channels2=208,
                              out_channels3reduce=16, out_channels3=48, out_channels4=64)
        )
        # 子模块3：三个InceptionV1模块 + 一个全连接模块
        if self.stage == 'train':
            self.aux_logits1 = InceptionAux(in_channels=512,out_channels=num_classes)
        self.block3 = nn.Sequential(
            InceptionV1Module(in_channels=512, out_channels1=160, out_channels2reduce=112, out_channels2=224,
                              out_channels3reduce=24, out_channels3=64, out_channels4=64),
            InceptionV1Module(in_channels=512, out_channels1=128, out_channels2reduce=128, out_channels2=256,
                              out_channels3reduce=24, out_channels3=64, out_channels4=64),
            InceptionV1Module(in_channels=512, out_channels1=112, out_channels2reduce=144, out_channels2=288,
                              out_channels3reduce=32, out_channels3=64, out_channels4=64),
        )
        # 子模块4：三个InceptionV1模块 + 两个全连接模块
        if self.stage == 'train':
            self.aux_logits2 = InceptionAux(in_channels=528,out_channels=num_classes)
        self.block4 = nn.Sequential(
            InceptionV1Module(in_channels=528, out_channels1=256, out_channels2reduce=160, out_channels2=320,
                              out_channels3reduce=32, out_channels3=128, out_channels4=128),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
            InceptionV1Module(in_channels=832, out_channels1=256, out_channels2reduce=160, out_channels2=320,
                              out_channels3reduce=32, out_channels3=128, out_channels4=128),
            InceptionV1Module(in_channels=832, out_channels1=384, out_channels2reduce=192, out_channels2=384,
                              out_channels3reduce=48, out_channels3=128, out_channels4=128),
        )
        self.block4_1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=7,stride=1),
            nn.Dropout(p=0.4),
            nn.Linear(in_features=1024,out_features=num_classes)
        )
    def forward(self, x):
        x = self.block1(x)
        aux1 = x = self.block2(x)
        aux2 = x = self.block3(x)
        x = self.block4(x)
        out = self.block4_1(x)
        if self.stage == 'train':
            aux1 = self.aux_logits1(aux1)
            aux2 = self.aux_logits2(aux2)
            return aux1, aux2, out
        else:
            return out

完整源码

    InceptionV1模型（GoogLeNet模型）的完整代码如下：

import torch
import torch.nn as nn
import torchvision
# InceptionV1的卷积模块：卷积 + 批标准化 + 激活
def ConvBNReLU(in_channels,out_channels,kernel_size):
    return nn.Sequential(
        # 卷积核的stride=1， padding=kernel_size//2
        nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=1,padding=kernel_size//2),
        nn.BatchNorm2d(out_channels),
        nn.ReLU6(inplace=True)
    )
# InceptionV1模块
class InceptionV1Module(nn.Module):
    def __init__(self, inchannel, outchannel1, outchannel2_1, outchannel2_2, outchannel3_1, outchannel3_2, outchannel4):
        super(InceptionV1Module, self).__init__()
        # 1*1卷积模块
        self.block1 =  ConvBNRelu(inchannel, outchannel1, 1)
        # 1*1卷积模块 + 3*3卷积模块
        self.block2_1 = ConvBNRelu(inchannel, outchannel2_1, 1)
        self.block2_2 = ConvBNRelu(outchannel2_1, outchannel2_2, 3)
        # 1*1卷积模块 + 5*5卷积模块
        self.block3_1 = ConvBNRelu(inchannel, outchannel3_1, 1)
        self.block3_2 = ConvBNRelu(outchannel3_1, outchannel3_2, 5)     
        # 3*3池化模块 + 1*1卷积模块
        self.block4_1 = nn.MaxPool2d(kernel_size = 3, stride = 1, padding = 1)
        self.block4_2 = ConvBNRelu(inchannel, outchannel4, 1)
    def forward(self, x):
        x1 = self.block1(x)      # output1
        x2 = self.block2_1(x)
        x2 = self.block2_2(x2)   # output2
        x3 = self.block3_1(x)
        x3 = self.block3_2(x3)   # output3
        x4 = self.block4_1(x)
        x4 = self.block4_2(x4)   # output4
        x = torch.cat([x1, x2, x3, x4], dim=1)    # 四个模块的输出叠加
        return x
# 全连接模块
class InceptionAux(nn.Module):
    def __init__(self, in_channels,out_channels):
        super(InceptionAux, self).__init__()
        # 5*5平均池化
        self.auxiliary_avgpool = nn.AvgPool2d(kernel_size=5, stride=3)
        # 1*1卷积模块
        self.auxiliary_conv1 = ConvBNReLU(in_channels=in_channels, out_channels=128, kernel_size=1)
        # 全连接1 + 激活 + dropout
        self.auxiliary_linear1 = nn.Linear(in_features=128 * 4 * 4, out_features=1024)
        self.auxiliary_relu = nn.ReLU6(inplace=True)
        self.auxiliary_dropout = nn.Dropout(p=0.7)
        # 全连接2
        self.auxiliary_linear2 = nn.Linear(in_features=1024, out_features=out_channels)
    def forward(self, x):
        x = self.auxiliary_conv1(self.auxiliary_avgpool(x))
        x = x.view(x.size(0), -1)
        x= self.auxiliary_relu(self.auxiliary_linear1(x))
        out = self.auxiliary_linear2(self.auxiliary_dropout(x))
        return out
# GoogLeNet模型
class GoogLeNet(nn.Module):
    def __init__(self, num_classes=1000, stage='train'):
        super(InceptionV1, self).__init__()
        self.stage = stage
        # 子模块1：一系列卷积池化操作
        self.block1 = nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=7,stride=2,padding=3),
            nn.BatchNorm2d(64),
            nn.MaxPool2d(kernel_size=3,stride=2, padding=1),
            nn.Conv2d(in_channels=64, out_channels=64, kernel_size=1, stride=1),
            nn.BatchNorm2d(64),
            nn.Conv2d(in_channels=64, out_channels=192, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(192),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
        )
        # 子模块2：三个InceptionV1模块
        self.block2 = nn.Sequential(
            InceptionV1Module(in_channels=192,out_channels1=64, out_channels2reduce=96, out_channels2=128, 
                              out_channels3reduce = 16, out_channels3=32, out_channels4=32),
            InceptionV1Module(in_channels=256, out_channels1=128, out_channels2reduce=128, out_channels2=192,
                              out_channels3reduce=32, out_channels3=96, out_channels4=64),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
            InceptionV1Module(in_channels=480, out_channels1=192, out_channels2reduce=96, out_channels2=208,
                              out_channels3reduce=16, out_channels3=48, out_channels4=64)
        )
        # 子模块3：三个InceptionV1模块 + 一个全连接模块
        if self.stage == 'train':
            self.aux_logits1 = InceptionAux(in_channels=512,out_channels=num_classes)
        self.block3 = nn.Sequential(
            InceptionV1Module(in_channels=512, out_channels1=160, out_channels2reduce=112, out_channels2=224,
                              out_channels3reduce=24, out_channels3=64, out_channels4=64),
            InceptionV1Module(in_channels=512, out_channels1=128, out_channels2reduce=128, out_channels2=256,
                              out_channels3reduce=24, out_channels3=64, out_channels4=64),
            InceptionV1Module(in_channels=512, out_channels1=112, out_channels2reduce=144, out_channels2=288,
                              out_channels3reduce=32, out_channels3=64, out_channels4=64),
        )
        # 子模块4：三个InceptionV1模块 + 两个全连接模块
        if self.stage == 'train':
            self.aux_logits2 = InceptionAux(in_channels=528,out_channels=num_classes)
        self.block4 = nn.Sequential(
            InceptionV1Module(in_channels=528, out_channels1=256, out_channels2reduce=160, out_channels2=320,
                              out_channels3reduce=32, out_channels3=128, out_channels4=128),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
            InceptionV1Module(in_channels=832, out_channels1=256, out_channels2reduce=160, out_channels2=320,
                              out_channels3reduce=32, out_channels3=128, out_channels4=128),
            InceptionV1Module(in_channels=832, out_channels1=384, out_channels2reduce=192, out_channels2=384,
                              out_channels3reduce=48, out_channels3=128, out_channels4=128),
        )
        self.block4_1 = nn.Sequential(
            nn.AvgPool2d(kernel_size=7,stride=1),
            nn.Dropout(p=0.4),
            nn.Linear(in_features=1024,out_features=num_classes)
        )
    def forward(self, x):
        x = self.block1(x)
        aux1 = x = self.block2(x)
        aux2 = x = self.block3(x)
        x = self.block4(x)
        out = self.block4_1(x)
        if self.stage == 'train':
            aux1 = self.aux_logits1(aux1)
            aux2 = self.aux_logits2(aux2)
            return aux1, aux2, out
        else:
            return out
宇宙超级无敌小菜鸡
关注
  • 8
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Inceptionv1v2v3v4的pytorch实现
08-05
Inceptionv1v2v3v4的pytorch实现
pytorch实战4：基于pytorch复现GoogLeNet-v1
weixin_46676835的博客
01-21 395
pytorch实战4：基于pytorch复现GoogLeNet-v1
经典神经网络论文超详细解读（三）——GoogLeNet InceptionV1学习笔记（翻译＋精读+代码复现）
路人贾的博客
12-11 5448
GoogLeNet InceptionV1论文（Going deeper with convolutions）超详细解读。翻译＋总结。文末有代码复现
TensorFlow1.0系统学习（七）————inception-v3模型的下载和使用
qq_36414085的博客
01-05 845
文章目录一、inception-v3模型的下载二、使用inception-v3模型做各种图像的识别 一、inception-v3模型的下载 import tensorflow as tf import os import tarfile import requests #inception模型下载地址 inception_pretrain_model_url = 'http://download...
解决基于keras的inception_v3预训练模型无法下载问题并进行简单调用
qinchaoxia的博客
06-06 629
解决基于keras的inception_v3预训练模型无法下载问题并进行简单调用
pytorch实现InceptionV1模型（小白学习，详细讲解）
m0_50127633的博客
05-21 1165
Incepti## InceptionV1的模型 首先我们需要把流程图和表中数据对应起来，后续我们实现InceptionV1的时候，需要用到表中的数据。 代码实现 import torch import torch.nn as nn import torch.nn.functional as F class GlobalAvgPool2d(nn.Module): def __init__(self): super(GlobalAvgPool2d, self).__init__()
GoogLeNet（Inception V1）论文笔记及Pytorch代码解析
charles_zhang_的博客
12-29 3585
注： 本文仅供自己学习记录 感谢良心up同济子豪兄精彩讲解 【精读AI论文】GoogLeNet（Inception V1）深度学习图像分类算法_哔哩哔哩_bilibili GoogLeNe（Inception V1）论文笔记 论文概要 WE NEED TO GO DEEPER Inception的技术演变 Inception不同于其他大型网络模型，可以方便的部署任何地方（边缘计算设备） Inception原理图 将数据进行四路处理（不同尺度的卷积和一个池化），之后再汇总到cin
Inception V1理解及pytorch实现
方悔读书迟
07-29 2462
一、Inception V1 用全局平均池化层代替了最后的全连接层 全连接层几乎占据了中大部分的参数量，会引起过拟合，去除全连接层之后模型可以训练的更快且避免了过拟合的情况。 在Inception v1中1*1卷积用于降维，减少参数量和feature map维度。 输入28 * 28 * 192的图像，如果直接通过3 * 3 * 256的滤波器（padding=1，stride=1），输出数据是28 * 28 * 256，参数量是192 * 3 * 3 * 256=44w；如果我们在3*3的滤波器前插入
Pytorch 实现Inception v1模块与 Inception v2模块
乐亦亦乐的博客
10-28 1309
import torch from torch import nn import torch.nn.functional as F #首先定义一个包含conv与ReLu的基础卷积类 class BasicConv2d(nn.Module): def __init__(self,in_channels,out_channels,kernel_size,padding=0): super(BasicConv2d,self).__init__() self.conv=...
PyTorch实现的GoogLeNet (InceptionV1)
mingo_敏
08-11 3938
PyTorch实现的GoogLeNet PyTorch: https://github.com/shanglianlm0525/ClassicNetwork Inceptionv1 module PyTorch代码:
inception_v1.pytorch:pytorch中具有预训练权重的inception_v1的实现
05-14
inception_v1.pytorch 在pytorch上使用预训练的权重实现inception_v1。 这段代码是soumith火炬仓库的pytorch翻译： : 它实现了初始架构的原始版本； 众所周知的是GoogLeNet。 可以在找到预训练的权重 免责声明 imagenet上预训练模型的测试精度仅为26.38％。 如果我没记错的话，这是原始火炬回购的问题-数据加载正确完成。 如果您训练此模型的准确性更高，我希望获得新的权重！ 执照 该代码是根据MIT许可证获得许可的。 有关详细信息，请参见文件。
Python-基于CNNInceptionV1STFT的鲸鱼检测算法
08-11
CNN (InceptionV1) STFT based Whale Detection Algorithm
Pytorch实现GoogLeNet的方法
09-18
今天小编就为大家分享一篇Pytorch实现GoogLeNet的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
pytorch实现GoogLeNet-InceptionV1
01-06
GoogLeNet Inception v1 结构 及 pytorch、tensorflow、keras、paddle实现ImageNet识别 环境 python3.6， torch 1.0.1, torchvision 0.4.0, torchsummary 1.5.1 代码 # -*- coding: utf-8 -*- # @Time : 2020/2/...
【深度学习实战】使用PyTorch 实现 GoogLeNet模型（含完整代码、数据集及详细注释）
06-26
如标题所述，这是一个完整的深度学习模型实战的案例（内附带完整的源代码+数据集+详细注释），该内容已经在博客中记录，详见：https://xiexu.blog.csdn.net/article/details/131389831，建议结合本博客学习，效果会...
基于Pytorch实现的Bert模型
08-27
基于PyTorch实现的BERT模型。BERT（Bidirectional Encoder Representations from Transformers）是一种预训练的自然语言处理模型，它在大规模文本数据上进行预训练，然后可以通过微调适应各种NLP任务，如文本分类、...
【深度学习】YOLOv5，金属表面的缺陷检测，GC10-DET数据集
q742971636的博客
04-26 407
数据集的lable文件夹下是每个图片的框和类别标记，是xml格式。
深度学习突破：LLaMA-MoE模型的高效训练策略
人工智能前沿分享
04-26 1331
在人工智能领域，大模型（LLM）的崛起带来了前所未有的进步，但随之而来的是巨大的计算资源需求。为了解决这一问题，Mixture-of-Expert（MoE）模型架构应运而生，而LLaMA-MoE正是这一架构下的重要代表。LLaMA-MoE是一种基于LLaMA系列和SlimPajama的MoE模型，它通过将LLaMA的前馈网络（FFNs）划分为稀疏专家，并为每层专家插入top-K个门，从而显著减小模型大小，降低训练成本。这种方法不仅保持了模型的语言能力，同时实现了输入的高效处理。
基于自注意力机制的长短期记忆神经网络(LSTM-SelfAttention)的回归预测
最新发布
沅的博客
04-27 1011
它结合了LSTM和自注意力机制的优势，可以有效地处理时序数据中的长期依赖关系和关键部分。这个模型结合了两个不同的结构，即长短期记忆网络（LSTM）和自注意力机制，从而在时序数据预测中发挥各自的优势。LSTM-SelfAttention模型的优势在于它既能捕捉到时序数据中的长期依赖关系（通过LSTM），又能关注输入数据中的关键部分（通过自注意力机制）。LSTM在时序数据预测中表现出色，因为它可以捕捉到数据中的长期依赖关系。自注意力层：在LSTM层之后，引入自注意力机制，以关注时序数据中的不同部分。
pytorch创建inceptionv1神经网络
02-21
用PyTorch创建Inception V1神经网络可以通过定义和训练模型来实现，可以使用PyTorch的nn.Module，nn.Conv2d，nn.MaxPool2d，nn.Linear，nn.Dropout等API来设计和实现Inception V1神经网络。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值