Inception-ResNet模型框架（PyTorch）

最新推荐文章于 2023-11-21 16:11:09 发布
最新推荐文章于 2023-11-21 16:11:09 发布
阅读量2.7k 收藏 40
点赞数 4
分类专栏： 常见CNN模型框架 文章标签： 深度学习 卷积神经网络 cv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41978493/article/details/107712663
版权

I. 前言

在Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning一文中，除了提出Inception Network的v4版本，还与ResNet进行结合，提出了Inception-ResNet-v1及Inception-ResNet-v2两个模型.

II. 模型构架图

在这里插入图片描述
【注】Inception-ResNet-v1及Inception-ResNet-v2的总体构架一致，但各部分的结构不尽相同，现予以说明.

1. Inception-ResNet-v1

1.1 Stem

在这里插入图片描述

1.2 Inception-ResNet-A

在这里插入图片描述

1.3 Inception-ResNet-B

在这里插入图片描述

1.4 Inception-ResNet-C

在这里插入图片描述

1.5 Reduction-A

在这里插入图片描述

1.6 Reduction-B

在这里插入图片描述

2. Inception-ResNet-v2

2.1 Stem

在这里插入图片描述

2.2 Inception-ResNet-A

在这里插入图片描述

2.3 Inception-ResNet-B

在这里插入图片描述

2.4 Inception-ResNet-C

在这里插入图片描述

2.5 Reduction-A

在这里插入图片描述

2.6 Reduction-B

在这里插入图片描述

III. 代码复现

import torch
import torch.nn as nn
import torch.nn.functional as F

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.bn = nn.BatchNorm2d(out_channels)
        
    def forward(self, x):
        out = self.conv(x)
        out = self.bn(out)
        return out

class InceptionResNetA(nn.Module):
    def __init__(self, in_channels):
        super(InceptionResNetA, self).__init__()
        #branch1: conv1*1(32)
        self.b1 = BasicConv2d(in_channels, 32, kernel_size=1)
        
        #branch2: conv1*1(32) --> con3*3(32)
        self.b2_1 = BasicConv2d(in_channels, 32, kernel_size=1)
        self.b2_2 = BasicConv2d(32, 32, kernel_size=3, padding=1)
        
        #branch3: conv1*1(32) --> conv3*3(32) --> conv3*3(32)
        self.b3_1 = BasicConv2d(in_channels, 32, kernel_size=1)
        self.b3_2 = BasicConv2d(32, 32, kernel_size=3, padding=1)
        self.b3_3 = BasicConv2d(32, 32, kernel_size=3, padding=1)
        
        #totalbranch: conv1*1(256)
        self.tb = BasicConv2d(96, 256, kernel_size=1)
        
    def forward(self, x):
        x = F.relu(x)
        b_out1 = F.relu(self.b1(x))
        b_out2 = F.relu(self.b2_2(F.relu(self.b2_1(x))))
        b_out3 = F.relu(self.b3_3(F.relu(self.b3_2(F.relu(self.b3_1(x))))))
        b_out = torch.cat([b_out1, b_out2, b_out3], 1)
        b_out = self.tb(b_out)
        y = b_out + x
        out = F.relu(y)
                           
        return out

class InceptionResNetB(nn.Module):
    def __init__(self, in_channels):
        super(InceptionResNetB, self).__init__()
        #branch1: conv1*1(128)
        self.b1 = BasicConv2d(in_channels, 128, kernel_size=1)
        
        #branch2: conv1*1(128) --> con1*7(128) --> conv7*1(128)
        self.b2_1 = BasicConv2d(in_channels, 128, kernel_size=1)
        self.b2_2 = BasicConv2d(128, 128, kernel_size=(1,7), padding=(0,3))
        self.b2_3 = BasicConv2d(128, 128, kernel_size=(7,1), padding=(3,0))
    
        #totalbranch: conv1*1(896)
        self.tb = BasicConv2d(256, 896, kernel_size=1)
        
    def forward(self, x):
        x = F.relu(x)
        b_out1 = F.relu(self.b1(x))
        b_out2 = F.relu(self.b2_3(F.relu(self.b2_2(F.relu(self.b2_1(x))))))
        b_out = torch.cat([b_out1, b_out2], 1)
        b_out = self.tb(b_out)
        y = b_out + x
        out = F.relu(y)
                           
        return out

class InceptionResNetC(nn.Module):
    def __init__(self, in_channels):
        super(InceptionResNetC, self).__init__()
        #branch1: conv1*1(192)
        self.b1 = BasicConv2d(in_channels, 192, kernel_size=1)
        
        #branch2: conv1*1(192) --> con1*3(192) --> conv3*1(192)
        self.b2_1 = BasicConv2d(in_channels, 192, kernel_size=1)
        self.b2_2 = BasicConv2d(192, 192, kernel_size=(1,3), padding=(0,1))
        self.b2_3 = BasicConv2d(192, 192, kernel_size=(3,1), padding=(1,0))
    
        #totalbranch: conv1*1(1792)
        self.tb = BasicConv2d(384, 1792, kernel_size=1)
        
    def forward(self, x):
        x = F.relu(x)
        b_out1 = F.relu(self.b1(x))
        b_out2 = F.relu(self.b2_3(F.relu(self.b2_2(F.relu(self.b2_1(x))))))
        b_out = torch.cat([b_out1, b_out2], 1)
        b_out = self.tb(b_out)
        y = b_out + x
        out = F.relu(y)
                           
        return out

class ReductionA(nn.Module):
    def __init__(self, in_channels, k, l, m, n):
        super(ReductionA, self).__init__()
        #branch1: maxpool3*3(stride2 valid)
        self.b1 = nn.MaxPool2d(kernel_size=3, stride=2)
        
        #branch2: conv3*3(n stride2 valid)
        self.b2 = BasicConv2d(in_channels, n, kernel_size=3, stride=2)
        
        #branch3: conv1*1(k) --> conv3*3(l) --> conv3*3(m stride2 valid)
        self.b3_1 = BasicConv2d(in_channels, k, kernel_size=1)
        self.b3_2 = BasicConv2d(k, l, kernel_size=3, padding=1)
        self.b3_3 = BasicConv2d(l, m, kernel_size=3, stride=2)
        
    def forward(self, x):
        y1 = self.b1(x)
        y2 = F.relu(self.b2(x))
        y3 = F.relu(self.b3_3(F.relu(self.b3_2(F.relu(self.b3_1(x))))))
        
        outputsRedA = [y1, y2, y3]
        return torch.cat(outputsRedA, 1)

class ReductionB(nn.Module):
    def __init__(self, in_channels):
        super(ReductionB, self).__init__()
        #branch1: maxpool3*3(stride2 valid)
        self.b1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        
        #branch2: conv1*1(256) --> conv3*3(384 stride2 valid)
        self.b2_1 = BasicConv2d(in_channels, 256, kernel_size=1)
        self.b2_2 = BasicConv2d(256, 384, kernel_size=3, stride=2)
        
        #branch3: conv1*1(256) --> conv3*3(256 stride2 valid)
        self.b3_1 = BasicConv2d(in_channels, 256, kernel_size=1)
        self.b3_2 = BasicConv2d(256, 256, kernel_size=3, stride=2)
        
        #branch4: conv1*1(256) --> conv3*3(256) --> conv3*3(256 stride2 valid)
        self.b4_1 = BasicConv2d(in_channels, 256, kernel_size=1)
        self.b4_2 = BasicConv2d(256, 256, kernel_size=3, padding=1)
        self.b4_3 = BasicConv2d(256, 256, kernel_size=3, stride=2)
        
    def forward(self, x):
        y1 = self.b1(x)
        y2 = F.relu(self.b2_2(F.relu(self.b2_1(x))))
        y3 = F.relu(self.b3_2(F.relu(self.b3_1(x))))
        y4 = F.relu(self.b4_3(F.relu(self.b4_2(F.relu(self.b4_1(x))))))
        
        outputsRedB = [y1, y2, y3, y4]
        return torch.cat(outputsRedB, 1)

class StemForIR1(nn.Module):
    def __init__(self, in_channels):
        super(StemForIR1, self).__init__()
        #conv3*3(32 stride2 valid)
        self.conv1 = BasicConv2d(in_channels, 32, kernel_size=3, stride=2)
        #conv3*3(32 valid)
        self.conv2 = BasicConv2d(32, 32, kernel_size=3)
        #conv3*3(64)
        self.conv3 = BasicConv2d(32, 64, kernel_size=3, padding=1)
        #maxpool3*3(stride2 valid)
        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        #conv1*1(80)
        self.conv4 = BasicConv2d(64, 80, kernel_size=1)
        #conv3*3(192 valid)
        self.conv5 = BasicConv2d(80, 192, kernel_size=3)
        #conv3*3(256, stride2 valid)
        self.conv6 = BasicConv2d(192, 256, kernel_size=3, stride=2)
        
    def forward(self, x):
        out = F.relu(self.conv1(x))
        out = F.relu(self.conv2(out))
        out = F.relu(self.conv3(out))
        out = self.maxpool1(out)
        out = F.relu(self.conv4(out))
        out = F.relu(self.conv5(out))
        out = F.relu(self.conv6(out))
        
        return out

class InceptionResNetv1(nn.Module):
    def __init__(self):
        super(InceptionResNetv1, self).__init__()
        self.stem = StemForIR1(3)
        self.irA = InceptionResNetA(256)
        self.redA = ReductionA(256, 192, 192, 256, 384)
        self.irB = InceptionResNetB(896)
        self.redB = ReductionB(896)
        self.irC = InceptionResNetC(1792)
        self.avgpool = nn.MaxPool2d(kernel_size=8)
        self.dropout = nn.Dropout(p=0.8)
        self.linear = nn.Linear(1792, 1000)
        
    def forward(self, x):
        n = [5, 10, 5]
        out = self.stem(x)
        
        if n[0] > 0:
            out = self.irA(out)
            n[0] -= 1
        out = self.redA(out)
        
        if n[1] > 0:
            out = self.irB(out)
            n[1] -= 1
        out = self.redB(out)
        
        if n[2] > 0:
            out = self.irC(out)
            n[2] -= 1
            
        out = self.avgpool(out)
        out = self.dropout(out)
        out = out.view(out.size(0), -1)
        out = self.linear(out)
        
        return out
Leung WaiHo
关注
  • 4
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
inception-resnet-v1-part3
07-11
tensorflow, models, slim pre-trained model: inception-resnet-v1-201608-30.tar.gz
tensorflow-model-zoo.torch：用于Torch7和PyTorch的InceptionV3，InceptionV4，Inception-Resnet预训练模型
02-06
适用于Torch7和PyTorch的Tensorflow模型动物园（已淘汰） ：请使用新的repo ，其中包含带有更好API的inceptionv4和inceptionresnetv2。 这是和制作的张量流预训练模型的移植。 特别感谢MoustaphaCissé。 所有型号...
Inception系列和ResNet的成长之路
IT荻的博客
12-06 8357
小总结一下Inception v1——Inception v4的发展历程 1.Inception V1 通过设计一个系数网络结构，但是能够产生稠密的数据，既能增加神经网络的表现，又能保证计算资源的使用效率。 通过Split-Merge包含了1 * 1,3 * 3,5 * 5的卷积，3*3的池化，可以增加网络对多尺度的适应性，当然，增加了网络的宽度。 这里v1网络给人眼前一亮的是有一个Bottlen...
深度学习之Inception-ResNet
Ton的博客
03-21 1万+
这篇文章由谷歌在17年提出，收启发于何凯明提出的ResNet在深度网络上较好的表现影响，作者将Residual connection加入到Inception结构中形成2个Inception-ResNet版本的网络以及一个纯Inception-v4网络。 参考目录： ①：论文补充版本(主要是补充一些图) ②：从Inception v1到Inception-ResNet，一文概览Inception家族的「奋斗史」 ③：论文笔记1 ④：论文笔记2 截至这篇文章发表，谷歌提出的关于Inception块组成的Goog
基于PyTorch实现 Inception-ResNet-v1
weixin_49252254的博客
04-26 2027
基于PyTorch实现 Inception-ResNet-V1 1、论文地址 Inception-ResNet and the Impact of Residual Connections on Learning 2 、网络框架 本文github链接 Stem 1.框架图 2.代码实现 因为要经常用，所以先定义一个3x3卷积，1x1卷积 class conv3x3(nn.Module): def __init__(self, in_planes, out_channels, stride=1,
深度学习课程--ResNet 模型 + Inception模型的简单介绍
Jiana_Feng的博客
11-28 1260
这里将会介绍近年来最火的模型 ResNet 模型-残差神经网络（2014） ResNet 是因为对神经网络深度的观察，而提出的一个模型。之前人们观察到，为什么非常深度的网络在增加更多层的时候，表现会变差？ 按直觉，越深的网络理应效果更好，或者至少不变差。 假设我们已经构建了一个N层的网络，实现了一定的精度，那么在这个基础上，再建立一层，即N+1层的网络模型，按理说，应该也会有差不多的精度，但是实际上，表现会更差。所以有人提出，这是因为直接映射是难以学习的，即x–>H(x)中会损失很多信息。于是有人提出
【图像分类】【深度学习】【Pytorch版本】Inception-ResNet模型算法详解
yangyu0515的博客
11-21 2011
【图像分类】【深度学习】【Pytorch版本】Inception-ResNet模型算法详解
Multi-Scale-1D-ResNet:多尺度一维Resnet的pytorch代码，希望对您的研究有所帮助
05-02
多尺度一维ResNet 这是我们的变型，但它是一种超轻加权分类网络用于与1D卷积操作，其中1D与时间轴沿内核扫描时间串行数据。 多刻度设置受Inception启发，我们发现它很有用。 经过测试的环境 python 3.6 火炬0.4.1 ...
ython-GradCAM的Pytorch实现
最新发布
03-27
1. **模型选择和预处理**：首先，你需要一个预训练的CNN模型，例如ResNet、VGG或Inception。模型应已加载预训练权重，以便在未知数据上进行预测。同时，对输入图像进行必要的预处理，如调整尺寸、归一化等，使其符合...
inception-resnet-v1-part1
07-11
tensorflow, models, slim pre-trained model: inception-resnet-v1-201608-30.tar.gz
facenet-pytorch:预训练的Pytorch人脸检测（MTCNN）和识别（InceptionResnet）模型
05-13
使用Pytorch进行人脸识别 Python 3.7 3.6 3.5 地位 这是pytorch中Inception Resnet（V1）模型的存储库，已在VGGFace2和CASIA-Webface上进行了预训练。 使用从David Sandberg的移植的参数来初始化Pytorch模型权重。 此回购中还包括用于推理之前的人脸检测的MTCNN的有效pytorch实现。 这些模型也经过预训练。 据我们所知，这是最快的MTCNN实现。 目录 视频流中的人脸跟踪 使用新数据微调预训练模型 Facenet-PyTorch中的MTCNN指南 人脸检测套件的性能比较 FastMTCNN算法 与Docker一起运行 在您自己的git项目中使用此仓库 将参数从Tensorflow转换为Pytorch 参考 快速开始 安装： # With pip: pip install facene
action-recognition-models-pytorch:pytorch的动作识别模型
05-10
- `action-recognition-models-pytorch-master` 文件夹包含各个模型的实现代码，每个模型可能有单独的子文件夹，包括网络结构定义、训练脚本、数据预处理等部分。 - 数据预处理通常涉及视频剪辑、帧采样、颜色归一...
深度神经网络中Inception-ResNet模块介绍
网络资源是无限的
02-28 3863
之前在https://blog.csdn.net/fengbingchun/article/details/113482036 介绍了Inception，在https://blog.csdn.net/fengbingchun/article/details/114167581 介绍了ResNet，这里介绍下深度神经网络中的Inception-ResNet模块。 介绍Inception-ResNet的论文名为：《Inception-v4, Inception-ResNet and the Impact of
深度学习卷积神经网络——经典网络GoogLeNet(Inception V3)网络的搭建与实现
热门推荐
loveliuzz的博客
01-23 9万+
一、Inception网络（google公司）——GoogLeNet网络的综述 获得高质量模型最保险的做法就是增加模型的深度（层数）或者是其宽度（层核或者神经元数）， 但是这里一般设计思路的情况下会出现如下的缺陷： 1.参数太多，若训练数据集有限，容易过拟合； 2.网络越大计算复杂度越大，难以应用； 3.网络越深，梯度越往后穿越容易消失，难以优化模型。  解决上述两个缺点的根本
Inception-v4, Inception-ResNet论文综述
qq_42575422的博客
06-10 879
Inception-v4, Inception-ResNet论文综述 为什么要做这个研究（理论走向和目前缺陷） ? 就是想结合resnet和inception的好处，resnet训练的很快，inception检测结果很准。 他们怎么做这个研究 （方法，尤其是与之前不同之处） ? 做很多实验，设计了inception-resnet-v1/v2和inception-v4网络模型。训练时遇到了一些问题...
【深度学习基础】基于PyTorch实现Inception-v4, Inception-ResNet-v1, Inception-ResNet-v2亲身实践
Cai Yichao的博客
09-11 6421
这篇博客主要介绍了几种新的Inception block结构，以及论文如何结合Residual block的思想优化网络，并基于PyTorch实现了Inception-v4，Inception-ResNet的网络结构。
学习参考文章_Inception-ResNet
qq_43038592的博客
11-10 232
ResNet Inception V4 Inception模块介绍 1.了解到batchnorm构成的ResNet残差结构可以加快网络收敛 2.inception的不同感受野可以充分提取抽象特征，且在层数更高处（特征越抽象）使用，效果越好 3.将1和2结合起来组成一个模块，相当于构成Inception-ResNet-v1的Stem和Inception-resnet-A组合模块 4.组合模块间用ma...
深度学习--Inception-ResNet-v1网络结构
TiRan_Yang
01-10 2万+
　　Inception V4的网络结构如下： 　　 　　从图中可以看出，输入部分与V1到V3的输入部分有较大的差别，这样设计的目的为了：使用并行结构、不对称卷积核结构，可以在保证信息损失足够小的情况下，降低计算量。结构中1*1的卷积核也用来降维，并且也增加了非线性。 　　Inception-ResNet-v2与Inception-ResNet-v1的结构类似，除了stem部分。Ince...
便携使用pytorch对Inception-Resnet-V2进行剪枝的代码
03-06
以下是使用 PyTorch 对 Inception-Resnet-V2 进行剪枝的代码： ```python import torch import torch.nn as nn import torch.nn.utils.prune as prune import torchvision.models as models # 加载 Inception-Resnet-V2 模型 model = models.inceptionresnetv2(pretrained=True) # 定义剪枝比例 pruning_perc = .2 # 获取 Inception-Resnet-V2 模型的 Conv2d 层 conv2d_layers = [] for name, module in model.named_modules(): if isinstance(module, nn.Conv2d): conv2d_layers.append((name, module)) # 对 Conv2d 层进行剪枝 for name, module in conv2d_layers: prune.l1_unstructured(module, name='weight', amount=pruning_perc) # 打印剪枝后的模型 print(model) ``` 希望这个代码对你有帮助！
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值