ResNet模型框架（PyTorch）

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

I. 前言

ResNet，论文地址：Deep Residual Learning for Image Recognition，该论文提出了一种残差网络结构，将网络每一部分的输入经shortcut connection，与第二（三）个卷积核的结果相加，然后一并进行ReLU生成总的激活值. 每一部分的残差网络结构如下图所示.
在这里插入图片描述
【注】左侧的building block是RestNet-34的， 右侧的是ResNet-50/101/152. 其中，shortcut connection有三种方案，A）在维度上升的情况下使用Zero-padding；B）在维度上升的情况下使用projection shortcut，其余直接使用identity shortcut；C）所有的shortcut都是projection shortcut. 在本文中，ResNet-34将使用B）C）两种方案，而ResNet-50/101/152则全部使用B）一种方案.

II. 模型框架图

在这里插入图片描述
【注】conv3_1、conv4_1以及conv5_1使用的是步长为2的downsampling，即下采样模块，首先通过一个kernel_size为1且步长为2的卷积运算，然后进行BatchNormalization. （此处令我想不通的是ResNet-50/101/152怎么从maxpool的64channels变成256channels，然后与conv2_1的输出进行相加）

III. 代码复现

1. ResNet-34

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

class ResModule(nn.Module):
    def __init__(self, in_channels, first3x3, second3x3):
        super(ResModule, self).__init__()
        self.forward_prop = nn.Sequential(
            nn.Conv2d(in_channels, first3x3, kernel_size=3, padding=1),
            nn.BatchNorm2d(first3x3),
            nn.ReLU(True),
            nn.Conv2d(first3x3, second3x3, kernel_size=3, padding=1),
            nn.BatchNorm2d(second3x3),
        )
        
    def forward(self, x):
        out = self.forward_prop(x)
        out += x
        
        return F.relu(out)

class ResModuleOptB(nn.Module):
    def __init__(self, in_channels, first3x3, second3x3):
        super(ResModuleOptB, self).__init__()
        
        self.forward_prop = nn.Sequential(
            nn.Conv2d(in_channels, first3x3, kernel_size=3, stride=2, padding=1),
            nn.BatchNorm2d(first3x3),
            nn.ReLU(True),
            nn.Conv2d(first3x3, second3x3, kernel_size=3, padding=1),
            nn.BatchNorm2d(second3x3),
        )
        
        self.downsample = nn.Sequential(
            nn.Conv2d(in_channels, second3x3, kernel_size=1, stride=2),
            nn.BatchNorm2d(second3x3)
        )
        
    def forward(self, x):
        out = self.forward_prop(x)
        match = self.downsample(x)
        out += match
        
        return F.relu(out)

class ResNet34B(nn.Module):
    def __init__(self):
        super(ResNet34B, self).__init__()
        self.first_layer = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
        )
        
        self.conv2x = ResModule(64, 64, 64)
        
        self.conv3x_1 = ResModuleOptB(64, 128, 128)
        self.conv3x_2 = ResModule(128, 128, 128)
        
        self.conv4x_1 = ResModuleOptB(128, 256, 256)
        self.conv4x_2 = ResModule(256, 256, 256)
        
        self.conv5x_1 = ResModuleOptB(256, 512, 512)
        self.conv5x_2 = ResModule(512, 512, 512)
        
        self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1)
        self.fc = nn.Linear(512, 1000)
        
    def forward(self, x):
        out = self.first_layer(x)
        out = self.conv2x(self.conv2x(self.conv2x(out)))
        out = self.conv3x_2(self.conv3x_2(self.conv3x_2(self.conv3x_1(out))))
        out = self.conv4x_2(self.conv4x_2(self.conv4x_2(self.conv4x_2(self.conv4x_2(self.conv4x_1(out))))))
        out = self.conv5x_2(self.conv5x_2(self.conv5x_1(out)))
        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        
        return out

class ResNet34C(nn.Module):
    def __init__(self):
        super(ResNet34C, self).__init__()
        self.first_layer = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
        )
        
        self.conv2x = ResModule(64, 64, 64)
        
        self.conv3x_1 = ResModuleOptB(64, 128, 128)
        self.conv3x_2 = ResModule(128, 128, 128)
        
        self.conv4x_1 = ResModuleOptB(128, 256, 256)
        self.conv4x_2 = ResModule(256, 256, 256)
        
        self.conv5x_1 = ResModuleOptB(256, 512, 512)
        self.conv5x_2 = ResModule(512, 512, 512)
        
        self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1)
        self.fc = nn.Linear(512, 1000)
        
    def forward(self, x):
        out = self.first_layer(x)
        out = self.conv2x(self.conv2x(self.conv2x(out)))
        out = self.conv3x_1(self.conv3x_1(self.conv3x_1(self.conv3x_1(out))))
        out = self.conv4x_1(self.conv4x_1(self.conv4x_1(self.conv4x_1(self.conv4x_1(self.conv4x_1(out))))))
        out = self.conv5x_1(self.conv5x_1(self.conv5x_1(out)))
        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        
        return out

2. ResNet-50/101/152

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

class ResModule(nn.Module):
    def __init__(self, in_channels, first1x1, n3x3, second1x1):
        super(ResModule, self).__init__()
        self.forward_prop = nn.Sequential(
	        nn.Conv2d(in_channels, first1x1, kernel_size=1)
        	nn.BatchNorm2d(first1x1)
        	nn.ReLU(True)
        	nn.Conv2d(first1x1, n3x3, kernel_size=3, padding=1)
        	nn.BatchNorm2d(n3x3)
        	nn.Conv2d(n3x3, second1x1, kernel_size=1)
        	nn.BatchNorm2d(second1x1)
        
    def forward(self, x):
        out = self.forward_prop(x)
        out = out + x
        
        return F.relu(out)

class ResModuleOptB(nn.Module):
    def __init__(self, in_channels, first1x1, n3x3, second1x1):
        super(ResModuleOptB, self).__init__()
        
        self.forward_prop = nn.Sequential(
            nn.Conv2d(in_channels, first1x1, kernel_size=1, stride=2),
            nn.BatchNorm2d(first1x1),
            nn.ReLU(True),
            nn.Conv2d(first1x1, n3x3, kernel_size=3, padding=1),
            nn.BatchNorm2d(n3x3),
            nn.ReLU(True),
            nn.Conv2d(n3x3, second1x1, kernel_size=1),
            nn.BatchNorm2d(second1x1),
            nn.ReLU(True)
        )
        
        self.downsample = nn.Sequential(
            nn.Conv2d(in_channels, second1x1, kernel_size=1, stride=2),
            nn.BatchNorm2d(second1x1)
        )
        
    def forward(self, x):
        out = self.forward_prop(x)
        match = self.downsample(x)
        out += match
        
        return F.relu(out)

class ResNet50(nn.Module):
    def __init__(self):
        super(ResNet50, self).__init__()
        self.first_layer = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.Conv2d(64, 256, kernel_size=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
        )
        
        self.conv2x = ResModule(256, 64, 64, 256)
        
        self.conv3_1 = ResModuleOptB(256, 128, 128, 512)
        self.conv3_res = ResModule(512, 128, 128, 512)
        
        self.conv4_1 = ResModuleOptB(512, 256, 256, 1024)
        self.conv4_res = ResModule(1024, 256, 256, 1024)
        
        self.conv5_1 = ResModuleOptB(1024, 512, 512, 2048)
        self.conv5_res = ResModule(2048, 512, 512, 2048)
        
        self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1)
        self.fc = nn.Linear(2048, 1000)
        
    def forward(self, x):
        out = self.first_layer(x)
        
        net = [0, 0, 3, 4, 6, 3]
        if net[2] > 0:
            out = self.conv2x(out)
            net[2] -= 1
        
        out = self.conv3_1(out)
        if net[3] > 1:
            out = self.conv3_res(out)
            net[3] -= 1
        
        out = self.conv4_1(out)
        if net[4] > 1:
            out = self.conv4_res(out)
            net[4] -= 1
        
        out = self.conv5_1(out)
        if net[5] > 1:
            out = self.conv5_res(out)
            net[5] -= 1
        
        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        
        return out

class ResNet101(nn.Module):
    def __init__(self):
        super(ResNet101, self).__init__()
        self.first_layer = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.Conv2d(64, 256, kernel_size=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
        )
        
        self.conv2x = ResModule(256, 64, 64, 256)
        
        self.conv3_1 = ResModuleOptB(256, 128, 128, 512)
        self.conv3_res = ResModule(512, 128, 128, 512)
        
        self.conv4_1 = ResModuleOptB(512, 256, 256, 1024)
        self.conv4_res = ResModule(1024, 256, 256, 1024)
        
        self.conv5_1 = ResModuleOptB(1024, 512, 512, 2048)
        self.conv5_res = ResModule(2048, 512, 512, 2048)
        
        self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1)
        self.fc = nn.Linear(2048, 1000)
        
    def forward(self, x):
        out = self.first_layer(x)
        
        net = [0, 0, 3, 4, 23, 3]
        if net[2] > 0:
            out = self.conv2x(out)
            net[2] -= 1
        
        out = self.conv3_1(out)
        if net[3] > 1:
            out = self.conv3_res(out)
            net[3] -= 1
        
        out = self.conv4_1(out)
        if net[4] > 1:
            out = self.conv4_res(out)
            net[4] -= 1
        
        out = self.conv5_1(out)
        if net[5] > 1:
            out = self.conv5_res(out)
            net[5] -= 1
        
        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        
        return out

class ResNet152(nn.Module):
    def __init__(self):
        super(ResNet152, self).__init__()
        self.first_layer = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            nn.Conv2d(64, 256, kernel_size=1),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),
        )
        
        self.conv2x = ResModule(256, 64, 64, 256)
        
        self.conv3_1 = ResModuleOptB(256, 128, 128, 512)
        self.conv3_res = ResModule(512, 128, 128, 512)
        
        self.conv4_1 = ResModuleOptB(512, 256, 256, 1024)
        self.conv4_res = ResModule(1024, 256, 256, 1024)
        
        self.conv5_1 = ResModuleOptB(1024, 512, 512, 2048)
        self.conv5_res = ResModule(2048, 512, 512, 2048)
        
        self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1)
        self.fc = nn.Linear(2048, 1000)
        
    def forward(self, x):
        out = self.first_layer(x)
        
        net = [0, 0, 3, 8, 36, 3]
        if net[2] > 0:
            out = self.conv2x(out)
            net[2] -= 1
        
        out = self.conv3_1(out)
        if net[3] > 1:
            out = self.conv3_res(out)
            net[3] -= 1
        
        out = self.conv4_1(out)
        if net[4] > 1:
            out = self.conv4_res(out)
            net[4] -= 1
        
        out = self.conv5_1(out)
        if net[5] > 1:
            out = self.conv5_res(out)
            net[5] -= 1
        
        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        
        return out
Leung WaiHo
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【深度学习】ResNet网络详解
1900的博客
10-16 2万+
ResNet
[ 图像分类 ] 经典网络模型4——ResNet 详解与复现
A_John 的博客
04-12 1万+
[ 图像分类 ] 经典网络模型4——ResNet 详解与复现 1、Residual Network 2、残差网络 3、Residual Block 4、ResNet50 详解 5、ResNet50 复现 6、ResNet50 结构框图 Residual Network 简称 ResNet (残差网络)，何凯明团队于2015年提出的一种网络； 在 ImageNet 比赛 classification 任务上获得第一名； 目前在检测，分割，识别等领域里得到了广泛的应用；...
分类神经网络2：ResNet模型复现
最新发布
悠眠小虫的博客
04-21 573
在构建神经网络时，首先采用了步长为2的卷积层进行图像尺寸缩减，即下采样操作，紧接着是多个残差结构，在网络架构的末端，引入了一个全局平均池化层，用于整合特征信息，最后是一个包含1000个类别的全连接层，并在该层后应用了softmax激活函数以进行多分类任务。：由2个3x3卷积层堆叠而成，当输入和输出维度一致时，可以直接将输入加到输出上，这相当于简单执行了同等映射，不会产生额外的参数，也不会增加计算复杂度（随着网络深度的加深，这种残差模块在实践中并不十分有效）；希望对大家能够有所帮助呀！ResNet网络通过。
写一下ResNet的原理和结构图
weixin_35755188的博客
01-04 951
好的，ResNet(Residual Network)是由微软的研究人员提出的一种深度卷积神经网络架构。它是在2015年ImageNet比赛中取得冠军的一个模型。 ResNet的主要思想是使用残差学习来解决深度卷积神经网络中的梯度消失问题。在训练深度卷积神经网络时，随着层数的增加，梯度会变得非常小，这就导致了训练效率的降低。ResNet通过将网络的每一层的输入与输出相加来解决这个问题。这样，在传递...
适合新手搭建ResNet50残差网络的架构图（最全）
qq_44697987的博客
12-04 4842
适合新手搭建ResNet50残差网络的架构图+代码（最全），全网最简单详细
深度学习卷积神经网络CNN之ResNet模型网络详解说明（超详细理论篇）
热门推荐
qq_55433305的博客
06-11 1万+
ResNet背景、ResNet论文、ResNet模型结构、ResNeResNet 在2015 年由微软研究院提出的一种深度卷积神经网络结构，主要的创新是在网络中引入了残差模块（residual block），其中输入和输出之间添加了一个跳跃连接（skip connection），将输入直接加到输出上。这种跳跃连接的设计使得网络可以更轻松地学习残差，从而解决了梯度消失和模型退化的问题。ResNet-18、ResNet-34、ResNet-50、ResNet-101和ResNet-152等
resnet-使用resnet34+Pytorch实现鸟类分类-算法项目.zip
03-08
在项目实施过程中，我们需要对这些图片进行预处理，包括缩放、归一化等操作，以便输入到ResNet模型中。 训练过程通常包括前向传播、损失计算、反向传播和参数更新等步骤。在PyTorch中，我们可以使用`nn.Module`定义...
ResNet-classification ResNet网络在pytorch框架下实现图像分类，拿走即用，包含批量化测试验证
03-29
ResNet网络在pytorch框架下实现图像分类，拿走即用，包含批量化测试验证。该文件包含ResNet18、ResNet50、ResNet101等网络实现图像分类的代码及对训练好的模型进行单一测试和批量测试的代码。ResNet网络是参考了VGG...
人工智能-深度学习-ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别-Pytorch
03-16
在人脸识别任务中，通常会使用预训练的ResNet模型，如ImageNet数据集上的预训练模型，然后根据特定任务进行微调。跨年龄识别的难点在于理解和捕捉面部随时间的演变特征，因此可能需要额外的数据增强策略和损失函数...
pytorch resnet 152 模型参数数据
10-24
总的来说，PyTorch中的ResNet 152模型是一个强大的工具，能够处理各种复杂的图像识别任务，而`resnet152-b121ed2d.pth` 文件则是实现这一功能的关键，它承载了模型的全部学习成果，使得我们可以直接利用这些预训练的...
ResNet-101 网络的深度学习工具箱模型：用于图像分类的预训练 Resnet-101 网络模型-matlab开发
05-31
ResNet-101 是一个预训练模型，已经在 ImageNet 数据库的一个子集上进行了训练。 该模型在超过一百万张图像上进行训练，共有 347 层，对应于 101 层残差网络，可以将图像分为 1000 个对象类别（例如键盘、鼠标、铅笔和许多动物）。 从您的操作系统或 MATLAB 中打开 resnet101.mlpkginstall 文件将启动您拥有的版本的安装过程。 该mlpkginstall文件可用于R2017b及更高版本。 用法示例： % 访问训练好的模型净 = resnet101(); % 查看架构细节网络层% 读取图像进行分类I = imread('peppers.png'); % 调整图片大小sz = net.Layers(1).InputSize I = I(1:sz(1),1:sz(2),1:sz(3)); % 使用 Resnet-101 对图像进行分类标签 = 分类（
py-R-FCN的ResNet50和ResNet101预训练模型
02-21
就是两个预训练模型，分别是ResNet-50的和ResNet-101的预训练模型。直接下载解压就行了。对了，是原版的RFCN哦，就是Caffe+Python的，不是tensorflow的model。
经典网络结构总结–ResNet系列
01-06
ResNet 论文：Deep Residual Learning for Image Recognition Motivation：网络越深，能获取的信息越多，而且特征也越丰富。但是根据实验表明，随着网络的加深，优化效果反而越差，测试数据和训练数据的准确率反而降低了（网络退化）。为了让更深的网络也能训练出好的效果，何凯明大神提出了一个新的网络结构——ResNet。这个网络结构的想法主要源于VLAD（残差的想法来源）和Highway Network（跳跃连接的想法来源）。 ResNet Block 残差学习模块包括identity mapping和residual mapping，其中前者指的
pytorch-resnet18和resnet50官方预训练模型
08-22
pytroch官网提供的预训练模型：resnet18：resnet18-5c106cde.pth和resnet50：resnet50-19c8e357.pth（两个文件打包在一起）
renet-50的caffemodel与deploy.ptototxt
09-24
下载地址：https://github.com/KaimingHe/deep-residual-networks中的onedrive链接
ResNet-50模型图像分类示例
吴建明wujianming_110117
02-25 4941
ResNet-50模型图像分类示例 概述 计算机视觉是当前深度学习研究最广泛、落地最成熟的技术领域，在手机拍照、智能安防、自动驾驶等场景有广泛应用。从2012年AlexNet在ImageNet比赛夺冠以来，深度学习深刻推动了计算机视觉领域的发展，当前最先进的计算机视觉算法几乎都是深度学习相关的。深度神经网络可以逐层提取图像特征，并保持局部不变性，被广泛应用于分类、检测、分割、检索、识别、提升、重建等视觉任务中。 本文结合图像分类任务，介绍MindSpore如何应用于计算机视觉场景。 图像分类 图像分类是最基
人工智能(Pytorch)搭建模型6-使用Pytorch搭建卷积神经网络ResNet模型
weixin_42878111的博客
05-25 2388
大家好，我是微学AI，今天给大家介绍一下人工智能(Pytorch)搭建模型6-使用Pytorch搭建卷积神经网络ResNet模型，在本文中，我们将学习如何使用PyTorch搭建卷积神经网络ResNet模型，并在生成的假数据上进行训练和测试。本文将涵盖这些内容：ResNet模型简介、ResNet模型结构、生成假数据、实现ResNet模型、训练与测试模型。
pytorch ResNet网络模型
12-15 439
网络中的亮点 网络深度超过1000层 提出残差模块,（不使用残差块，堆叠一定层，出现梯度消失） 使用BN(Batch Normalization)加速训练（丢弃dropout） 残差结构块如下 import torch.nn as nn import torch #18层 34层 class BasicBlock(nn.Module): expansion = 1 # def __init__(self, in_channel, out_channel, stride=1,.
resnet预训练模型pytorch
03-16
ResNet的预训练模型可以在PyTorch中使用，可以通过导入预训练模型来加速模型训练和优化。在PyTorch中，可以使用torchvision库中的预训练模型，例如resnet18、resnet34、resnet50等。这些预训练模型可以用于图像分类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值