Backbone-GoogLeNet

最新推荐文章于 2023-10-20 21:14:04 发布
最新推荐文章于 2023-10-20 21:14:04 发布
阅读量166 收藏 1
点赞数
分类专栏： backbone 文章标签： 卷积神经网络 深度学习 cv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43329242/article/details/119389706
版权

Backbone-GoogLeNet

为什么不写成GoogleNet？因为这是在向LeNet致敬！

1.介绍

GoogLeNet有三个版本，其中v1出现在出现在2014年的《Going deeper with convolutions》中，在ILSVRC比赛中一骑绝尘，获得了的冠军。在赛后Google对其进行改进，提出了v2-v4。其有以下几个特点：

  1. GoogLeNet引入了Inceoption结构，融合不同尺度的特征信息，这是其最重要的创新点；
  2. 使用了1*1的卷积核进行降维以及映射处理，相当于把一个像素不同通道的值加权融合；
  3. 添加两个辅助分类器帮助训练。论文第六页下方提到，由于网络较深，梯度反向传导的效果可能不够好，故在网络中间引出了两个辅助分类器，把他们的loss加到总loss上进行训练；
  4. 丢弃全连接层，使用平均池化层，大大减少模型参数。

2.网络结构

GoogLeNet最核心的就是图1中的Inceoption结构了，将Previous layer分成四个通道，最后把四道通道的结果合并到一起。

在这里插入图片描述

图2是信息量最大的图了，和图3的结构一一对应，下面通过图2中inception(3a)来解释一下这个表格的含义。根据inception(3a)的上一层(max pool)的信息，知道max pool的输出大小为28*28*192，即有192个通道，长宽均为28。现在来看inception(3a)的信息：

  1. output size是inception(3a)的输出尺寸；
  2. depth代表inception(3a)的深度为2，从图1可以看出来；
  3. #1*1为64指的是1*1 convolutions层有64个卷积核，即经过这层卷积后，输出尺寸为64*28*28;
  4. #1*1reduce为96指的是3*3 convolutions层前面的1*1 convolutions层有96个卷积核;
  5. #3*3为128指的是3*3 convolutions层有128个卷积核;
  6. #5*5reduce为16指的是5*5 convolutions层前面的1*1 convolutions层有16个卷积核;
  7. #5*5为32指的是5*5 convolutions层有32个卷积核;
  8. pool proj为32指的是max pooling后的1*1 convolutions层有32个卷积核；
  9. 从output size可以看出来，inception(3a)输出通道数为256，刚好等于inception(3a)中各个路径输出的通道数之和，即256=64+128+32+32。

在这里插入图片描述

在这里插入图片描述

3.实现

相比于AlexNet和VGG，GooLeNet在工程多了一个Inception层，如何实现Inception层是问题的关键。实现过程部分参考了这个视频。

import torch.nn as nn
import torch

class GoogLeNet_V1(nn.Module):
    def __init__(self, num_classes=1000, aux_logits=False):
        super(GoogLeNet_V1, self).__init__()
        self.aux_logits = aux_logits

        self.pre = nn.Sequential(
            BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3),     #112,112,64
            nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),      #(112-3)/2+1=56                      #56,56,64
            BasicConv2d(64, 64, kernel_size=1, stride=1, padding=1),    #(56-1+2)/1+1=56                        #56,64,64
            BasicConv2d(64, 192, kernel_size=3, stride=1, padding=1),   #(56-3+2)/1+1=56                     #192,56,56
            nn.MaxPool2d(kernel_size=3, stride=2)                       #(56-3)/2+1=28  #192,28,28
        )
        self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)  #28,28,256
        self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)    #28,28,480
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)  #(28-3)/2+1=14 #14,14,480
        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)  #14,14,832
        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True)       #(14-3)/2+1=7#7,7,832
        self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
        self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)  #7,7,1024
        self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1)    #1,1,1024
        if aux_logits == True:
            self.aux1 = Inception(512, num_classes)
            self.aux2 = Inception(528, num_classes)
        self.classifier = nn.Sequential(
            nn.Dropout(0.4),
            nn.Linear(1024, num_classes),
            nn.Softmax(dim=1),
        )

    def forward(self, x):
        x = self.pre(x)
        x = self.inception3a(x)
        x = self.inception3b(x)
        x = self.maxpool1(x)
        x = self.inception4a(x)
        if self.training and self.aux_logits:
            aux1 = self.aux1(x)
        x = self.inception4b(x)
        x = self.inception4c(x)
        x = self.inception4d(x)
        if self.training and self.aux_logits:
            aux2 = self.aux2(x)
        x = self.inception4e(x)
        x = self.maxpool2(x)
        x = self.inception5a(x)
        x = self.inception5b(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)
        if self.training and self.aux_logits:
            return x, aux2, aux1
        return x

class Inception(nn.Module):
    def __init__(self, in_channels, ch11, ch33reduce, ch33, ch55reduce, ch55, pool_proj):
        super(Inception, self).__init__()
        self.bran1 = BasicConv2d(in_channels, ch11, kernel_size=1)
        self.bran2 = nn.Sequential(
            BasicConv2d(in_channels, ch33reduce, kernel_size=1),
            BasicConv2d(ch33reduce, ch33, kernel_size=3, stride=1, padding=1),
        )
        self.bran3 = nn.Sequential(
            BasicConv2d(in_channels, ch55reduce, kernel_size=1),
            BasicConv2d(ch55reduce, ch55, kernel_size=5, stride=1, padding=2),
        )
        self.bran4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            BasicConv2d(in_channels, pool_proj, kernel_size=1, stride=1),
        )

    def forward(self, x):
        branch1 = self.bran1(x)
        branch2 = self.bran2(x)
        branch3 = self.bran3(x)
        branch4 = self.bran4(x)
        return torch.cat((branch1, branch2, branch3, branch4), dim=1)

class Aux(nn.Module):
    def __init__(self, inchannels, num_classes=1000):
        super(Aux, self).__init__()
        self.cov = nn.Sequential(
            nn.AvgPool2d(kernel_size=5, stride=3, padding=2),
            BasicConv2d(inchannels, out_channels=128, kernel_size=1, stride=1),  #[batch, 128, 4, 4]

        )
        self.linear = nn.Sequential(
            nn.Linear(2048, 1024),
            nn.ReLU(),
            nn.Dropout(0.7),
            nn.Linear(1024, num_classes),
        )

    def forward(self, x):
        x = self.cov(x)
        x = torch.flatten(x, 1)
        x = self.linear(x)
        return x




## 每个卷积都有一个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)
        x = self.relu(x)
        return x

if __name__ == '__main__':
    # Example
    net = GoogLeNet_V1()
    x = torch.rand(1, 3, 224, 224)
    out = net.forward(x)
    print(out.size())
    print(out)

4.注意

  1. 网络结构调试的方法：如果网络结构报错了，在forward函数中注释掉全部代码，然后一行一行解除注释并运行，直到报错。以后养成标准代码习惯，将网络的输出尺寸批注在forward函数中。
  2. nn.Sequential也能包含自定义层，当然这个自定义层要继承nn.Module
  3. 辅助器的处理：这里定义的两个辅助器，在训练的时候也有输出，加上主要结构的输出，一共三个输出。这对应了3个loss，总的loss就是将这三个loss按照1、0.3、0.3（主、辅、辅）加权。
  4. 加上softmax层之后，输出全部为0.001是怎么回事？仔细看，并不是全部为0.001，还有极少数0.0011和0.0009。这是因为计算ex时，由于这里的x都很小，只比0大一点，所以ex基本上很接近于1。一共1000个类别，所以每个类别为1/1000=0.001。
  5. torch.cat((branch1, branch2, branch3, branch4), dim=1)，这句话指的是将branch1-4这四个tensor按照第二通道合并。举个例子，如果四个变量尺寸分别为[1,10,7,7]、[1,20,7,7]、[1,30,7,7]、[1,40,7,7]，那么输出储存为[1,100,7,7]，其中100=10+20+30+40。
随风行Zack
关注
专栏目录
RT-DETR改进策略：BackBone改进|Swin Transformer，最强主干改进RT-DETR
m0_47867638的博客
09-16 1143
计算机视觉建模长期以来一直由卷积神经网络 (CNN) 主导。从 AlexNet [38] 及其在 ImageNet 图像分类挑战中的革命性表现开始，CNN 架构通过更大的规模 [29, 73]、更广泛的连接 [33] 和更复杂的卷积形式 [67, 17, 81]。随着 CNN 作为各种视觉任务的骨干网络，这些架构的进步导致了性能改进，从而广泛提升了整个领域。另一方面，自然语言处理 (NLP) 中网络架构的演变采取了不同的路径，如今流行的架构是 Transformer [61]。
Res2Net: 一种新的多尺度主干体系结构(Res2Net: A New Multi-scale Backbone Architecture )
qq_40107571的博客
10-31 2236
Res2Net: 一种新的多尺度主干体系结构
CV 经典主干网络 (Backbone) 系列: GoogLeNet（InceptionNet）
生命在于折腾！
03-18 1002
CV 经典主干网络 (Backbone) 系列: GoogLeNet（InceptionNet） GoogLeNet 有多个版本（V1到V4），这里讲的仅仅是 V1。如果想全面了解可以参考 图像分类丨Inception家族进化史「GoogleNet、Inception、Xception」。 GoogLeNet 也叫 Inception net, 因为 GoogLeNet 中的核心组成部分就是 inception module.另外值得一提的是 GoogLeNet 的名字有向 LeNet 致敬的意思. Goo
GoogLeNet和Inception v1、v2、v3、v4网络介绍
记忆碎片的博客
05-16 8563
文章目录CNN神经网络的演化过程GoogLeNet原始版本GoogLeNet Inception V1GoogLeNet Inception V2GoogLeNet Inception V3GoogLeNet Inception V4 CNN神经网络的演化过程 Hubel&Wiesel | Neocognitron | LeCun1989 | LeNe...
GoogLeNet的不同版本
小蒋的博客
10-20 193
了解了GoogLeNet的不同版本设计思想
GoogLenet网络详解
fakerth的博客
11-17 7250
GoogLenet网络详解
GoogLeNet（从Inception v1到v4的演进）
一行一生
05-28 681
Inception网络结构 就是构造一种“基础神经元”结构，来搭建一个稀疏性、高计算性能的网络结构. Inception V1 该结构将CNN中常用的卷积（1x1，3x3，5x5）、池化操作（3x3）堆叠在一起（卷积、池化后的尺寸相同，将通道相加），一方面增加了网络的宽度，另一方面也增加了网络对尺度的适应性。 网络卷积层中的网络能够提取输入的每一个细节信息，同...
DenseNet算法详解(目标检测backbone)
woduitaodong2698的博客
04-23 2683
DenseNet结构详解算法背景算法简介 算法背景 论文名称：Densely Connected Convolutional Networks 论文链接：ttps://arxiv.org/abs/1608.06993 论文日期：2018.01.28 代码：https://github.com/liuzhuang13/DenseNet 若在输入层与输出层之间包含更短的连接，那么更深的神经网络结构会训...
将fastbev的backbone修改为j5中的efficientb0 fps和时间延迟的关系
最新发布
02-23
在这个场景中，我们将FastBEV的原始backbone替换为EfficientNet-B0，探讨这种替换对模型性能的影响，特别是针对帧率（FPS）和时间延迟的关系。 首先，我们要理解FastBEV的核心功能。FastBEV是为自动驾驶和3D感知...
BackBone—Resnet
qq_36326840的博客
04-01 5466
在介绍之前首先理解一下BackBone的含义。 backbone这个单词原意指的是人的脊梁骨，后来引申为支柱，核心的意思。 在CV领域，一般先对图像进行特征提取（常见的有vggnet，resnet，因为这些网络对于特征提取的效果比较好），这一部分是整个CV任务的根基，在通过BackBone生成的featmap的基础上再进行语义分割任务，本人觉得可以简单将BackBone理解为encode，对于图像进行特征编码，后面接上不同的encode进行所需任务，简单看了一下目前mmsegmentation里面的Ba
【笔记】Backbone（经典主干网络）：VGGNet、GoogLeNet、ResNet、ResNet变种、SENet、SKNet、DarkNet-19、DarkNet-53、EfficientNet
nyist_yangguang的博客
10-16 2014
CV 经典主干网络 (Backbone) 系列: 开篇 这篇是 深度学习中的经典基础网络结构（backbone）总结 的下篇。上篇中从大的发展趋势介绍了下主干网络的发展，而这篇主要是对一些比较经典的主干网络进行简单梳理。 目录CV 经典主干网络 (Backbone) 系列: VGGNet （2014年） CV 经典主干网络 (Backbone) 系列: GoogLeNet（InceptionNet） （2014年） CV 经典主干网络 (Backbone) 系列: ResNet家族（2015年） ..
网络骨架：Backbone(神经网络基本组成——卷积层)
weixin_42782833的博客
06-26 1万+
利用卷积神经网络处理输入图像，生成深层的特征图，再利用各种算法完成区域生成与损失计算，这部分卷积神经网络数整个检测算法的“骨架”，也被称为Backbone Backbone是物体检测技术的基础，其中也涌现除了多种经典结构，如VGGNet、ResNet和DenseNet等 卷积网络的经典Backbone： VGGNet：走向深度 Inception：纵横交错 ResNet：里程碑的残差结构 DenseNet：多重残差 FPN：特征金字塔 DetNet：为检测而生 神经网络的基本组成 物体检测算法使用的通常
深度学习中的经典基础网络结构（backbone）总结
热门推荐
生命在于折腾！
10-28 3万+
深度学习中的经典基础网络结构总结 1. 深度学习发展历史回顾 在开始正式内容之前，首先回顾下深度学习发展史，这将使整体内容更为连贯。 上图主要展示了深度学习的 “史前文明”（这里仅仅是开玩笑的说法）。从图中可以看到整个历史始于1943年，有三个发展繁荣期和两个低谷。 1943年，心理学家麦卡洛克和数学逻辑学家皮兹发表论文《神经活动中内在思想的逻辑演算》，提出了MP模型。 1960年，...
googLeNet四个版本介绍
baidu_36535885的博客
03-21 903
http://www.chinacion.cn/article/2774.html
GoogleNet的几个版本整理
u011489887的专栏
12-13 4771
Google一系列深度学习网络发展的整理
GoogLeNet学习心得
weixin_33739646的博客
09-02 322
转自：http://blog.csdn.net/liumaolincycle/article/details/50471289#t0 综述： http://blog.csdn.net/sunbaigui/article/details/50807362 googlenet和vgg是2014年imagenet竞赛的双雄，这两类模型结构有一个共同特点是go deeper。跟vgg不同的是，goo...
深度学习网络中backbone是什么意思
weixin_47658790的博客
04-03 4637
主干网络，用来做特征提取的网络，代表网络的一部分，一般是用于前端提取图片信息，生成特征图feature map,供后面的网络使用。通常用VGGNet或者Resnet，因为这些backbone特征提取能力是很强，并且可以加载官方在大型数据集(Pascal 、Imagenet)上训练好的模型参数，然后接自己的网络，进行微调finetune即可。 ...
深度学习中的网络结构backbone汇总
soohoo
03-29 4618
1、LeNet5 2、AlexNet 2012年， AlexNet来源于论文 “ImageNet Classification with Deep Convolutional Neural Networks” AlexNet优点： 3、VGG 4、GoodLeNet/Inception 5、ResNet 6、SqueezeNet 7、MobileNet V1 8、ShuffleNet V1 9、
GoogLeNet
郭云飞的专栏
10-30 1万+
GoogLeNet最早出现在2014年的《Going deeper with convolutions》，之所以叫GoogLeNet，而不是GoogleNet，文章说是为了向早期的LeNet致敬。GoogLeNet是谷歌团队为了参加ILSVRC 2014（ImageNet Large Scale Visual Recognition Challenge）比赛而精心准备的。GoogLeNet,在
Backbone-Marionette框架初探与基础设置
资源摘要信息:"Backbone-Marionette 入门是木偶+骨干技术的学习资源，主要针对JavaScript开发者，用于介绍Backbone框架结合Marionette扩展库的初级使用方法。" 知识点详细说明: Backbone-Marionette介绍: Backbone...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值