pytorch复现4_Resnet

news2024/11/28 17:43:10

ResNet在《Deep Residual Learning for Image Recognition》论文中提出，是在CVPR 2016发表的一种影响深远的网络模型，由何凯明大神团队提出来，在ImageNet的分类比赛上将网络深度直接提高到了152层，前一年夺冠的VGG只有19层。ImageNet的目标检测以碾压的优势成功夺得了当年识别和目标检测的冠军，COCO数据集的目标检测和图像分割比赛上同样碾压夺冠，可以说ResNet的出现对深度神经网络来说具有重大的历史意义。

在这里插入图片描述
在resnet出现之前，网络层数的增加会导致梯度消失或者梯度爆炸
在ResNet网络中有如下几个亮点：
（1）提出residual结构（残差结构），并搭建超深的网络结构(突破1000层)
（2）使用Batch Normalization加速训练(丢弃dropout)

残差结构（residual）

下图是论文中给出的两种残差结构。左边的残差结构是针对层数较少网络，例如ResNet18层和ResNet34层网络。
右边是针对网络层数较多的网络，例如ResNet101，ResNet152等。
为什么深层网络要使用右侧的残差结构呢。因为，右侧的残差结构能够减少网络参数与运算量。同样输入、输出一个channel为256的特征矩阵，如果使用左侧的残差结构需要大约1170648个参数，但如果使用右侧的残差结构只需要69632个参数。明显搭建深层网络时，使用右侧的残差结构更合适。

在这里插入图片描述
代码：

class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_channel, out_channel, stride=1, downsample=None, **kwargs):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channel)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channel)
        self.downsample = downsample

    def forward(self, x):
        identity = x
        if self.downsample is not None:
            identity = self.downsample(x)

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        out += identity
        out = self.relu(out)

        return out


class Bottleneck(nn.Module):
    """
    注意：原论文中，在虚线残差结构的主分支上，第一个1x1卷积层的步距是2，第二个3x3卷积层步距是1。
    但在pytorch官方实现过程中是第一个1x1卷积层的步距是1，第二个3x3卷积层步距是2，
    这么做的好处是能够在top1上提升大概0.5%的准确率。
    可参考Resnet v1.5 https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch
    """
    expansion = 4

    def __init__(self, in_channel, out_channel, stride=1, downsample=None,
                 groups=1, width_per_group=64):
        super(Bottleneck, self).__init__()

        width = int(out_channel * (width_per_group / 64.)) * groups

        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width,
                               kernel_size=1, stride=1, bias=False)  # squeeze channels
        self.bn1 = nn.BatchNorm2d(width)
        # -----------------------------------------
        self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, groups=groups,
                               kernel_size=3, stride=stride, bias=False, padding=1)
        self.bn2 = nn.BatchNorm2d(width)
        # -----------------------------------------
        self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel*self.expansion,
                               kernel_size=1, stride=1, bias=False)  # unsqueeze channels
        self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample

    def forward(self, x):
        identity = x
        if self.downsample is not None:
            identity = self.downsample(x)

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        out += identity
        out = self.relu(out)

        return out

完整代码：

import torch.nn as nn
import torch


class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_channel, out_channel, stride=1, downsample=None, **kwargs):
        super(BasicBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channel)
        self.relu = nn.ReLU()
        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channel)
        self.downsample = downsample

    def forward(self, x):
        identity = x
        if self.downsample is not None:
            identity = self.downsample(x)

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        out += identity
        out = self.relu(out)

        return out


class Bottleneck(nn.Module):
    """
    注意：原论文中，在虚线残差结构的主分支上，第一个1x1卷积层的步距是2，第二个3x3卷积层步距是1。
    但在pytorch官方实现过程中是第一个1x1卷积层的步距是1，第二个3x3卷积层步距是2，
    这么做的好处是能够在top1上提升大概0.5%的准确率。
    可参考Resnet v1.5 https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch
    """
    expansion = 4

    def __init__(self, in_channel, out_channel, stride=1, downsample=None,
                 groups=1, width_per_group=64):
        super(Bottleneck, self).__init__()

        width = int(out_channel * (width_per_group / 64.)) * groups

        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width,
                               kernel_size=1, stride=1, bias=False)  # squeeze channels
        self.bn1 = nn.BatchNorm2d(width)
        # -----------------------------------------
        self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, groups=groups,
                               kernel_size=3, stride=stride, bias=False, padding=1)
        self.bn2 = nn.BatchNorm2d(width)
        # -----------------------------------------
        self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel*self.expansion,
                               kernel_size=1, stride=1, bias=False)  # unsqueeze channels
        self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample

    def forward(self, x):
        identity = x
        if self.downsample is not None:
            identity = self.downsample(x)

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        out += identity
        out = self.relu(out)

        return out


class ResNet(nn.Module):

    def __init__(self,
                 block,
                 blocks_num,
                 num_classes=1000,
                 include_top=True,
                 groups=1,
                 width_per_group=64):
        super(ResNet, self).__init__()
        self.include_top = include_top
        self.in_channel = 64

        self.groups = groups
        self.width_per_group = width_per_group

        self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,
                               padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(self.in_channel)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self._make_layer(block, 64, blocks_num[0])
        self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)
        self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)
        self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)
        if self.include_top:
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # output size = (1, 1)
            self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')

    def _make_layer(self, block, channel, block_num, stride=1):
        downsample = None
        if stride != 1 or self.in_channel != channel * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(channel * block.expansion))

        layers = []
        layers.append(block(self.in_channel,
                            channel,
                            downsample=downsample,
                            stride=stride,
                            groups=self.groups,
                            width_per_group=self.width_per_group))
        self.in_channel = channel * block.expansion

        for _ in range(1, block_num):
            layers.append(block(self.in_channel,
                                channel,
                                groups=self.groups,
                                width_per_group=self.width_per_group))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        if self.include_top:
            x = self.avgpool(x)
            x = torch.flatten(x, 1)
            x = self.fc(x)

        return x


def resnet34(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnet34-333f7ec4.pth
    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)


def resnet50(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnet50-19c8e357.pth
    return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)


def resnet101(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnet101-5d3b4d8f.pth
    return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes, include_top=include_top)


def resnext50_32x4d(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth
    groups = 32
    width_per_group = 4
    return ResNet(Bottleneck, [3, 4, 6, 3],
                  num_classes=num_classes,
                  include_top=include_top,
                  groups=groups,
                  width_per_group=width_per_group)


def resnext101_32x8d(num_classes=1000, include_top=True):
    # https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth
    groups = 32
    width_per_group = 8
    return ResNet(Bottleneck, [3, 4, 23, 3],
                  num_classes=num_classes,
                  include_top=include_top,
                  groups=groups,
                  width_per_group=width_per_group)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1160128.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

为什么需要企业云性能监控?

为什么需要企业云性能监控?

云计算已经成为企业信息技术的核心组成部分，提供了灵活性、可扩展性和成本效益。然而，随着企业的应用程序和数据迁移到云中，监控和管理云性能变得至关重要。在这篇文章中，我们将探讨企业云性能监控的重要性是什么! 为什么需要企业…
阅读更多...
瞄准一款好用到爆的在线数据库设计工具Itbuilder，被惊艳了！

瞄准一款好用到爆的在线数据库设计工具Itbuilder，被惊艳了！

在线数据库设计工具都不陌生，这与日常开发工作息息相关，每天都会用到。一款好用的在线数据库设计工具可以帮我们省去很多事情，Itbuilder在线数据库设计工具简单工作台，有利于新手操作，丰富的功能，可以满足开…
阅读更多...
RHCSA -- VMware虚拟机配置及破解密码

RHCSA -- VMware虚拟机配置及破解密码

一、配置虚拟机 1、开启VMware（自定义） 2、设置虚拟机硬件兼容性（默认） 3、稍后安装虚拟机操作系统 4、选择为Linux的虚拟机 5、虚拟机机名 6、设置虚拟机处理器 7、设置虚拟机所连接的网络类型 8、选择磁盘类型 9、设置所选磁…
阅读更多...
【Liunx应用市场】yum

【Liunx应用市场】yum

【Liunx应用市场】yum 1. Linux 软件包管理器 yum2. yum源3. yum的使用3.1 yum查找3.2 yum安装3.3 yum删除 所属专栏：Linux学习❤️ 🚀 >博主首页：初阳785❤️ 🚀 >代码托管：chuyang785❤️ 🚀 >感…
阅读更多...
【Qt控件之QInputDialog】详解

【Qt控件之QInputDialog】详解

Qt控件之QInputDialog 概述常用函数枚举成员方法信号 示例使用场景问题：使用QInputDialog是否可以使用正则表达式验证示例 概述 QInputDialog类提供了一个简单方便的对话框，用于从用户获取单个值。 输入值可以是字符串、数字或列表中的项。必须设置一个…
阅读更多...
X64指令基本格式

X64指令基本格式

X64指令基本格式 1 REX Prefix结构2 REX prefix扩展位2.1 第一种，无SIB字节的内存寻址（mod !11 ）2.2 第二种，寄存器到寄存器的寻址（无内存操作数，mod11）2.3 第三种，带SIB字节的内存寻…
阅读更多...
JVM虚拟机：JVM的垃圾回收清除算法（GC）有哪些

JVM虚拟机：JVM的垃圾回收清除算法（GC）有哪些

垃圾回收清除算法 引用计数法 标记清除 拷贝算法 标记压缩 引用计数法 有一个引用指向对象，那么引用计数就加1，少一个引用指向，那么引用计数就减1，这种方法了解一下就好，JVM机会不会使用这种方法，因为它在每次对象赋值的时候都要维护引用计数器，且计数器本身也有一定的…
阅读更多...
智能座舱中的人工智能数据

智能座舱中的人工智能数据

智能汽车——推动变革与盈利的利刃 对于汽车公司而言，投资于人工智能解决方案从未显得如此关键。据 Tractica 预测，到 2025 年，汽车 AI 硬件、软件和服务的市场规模将从 2017 年的 12 亿美元上升至 265 亿美元。该行业具有巨大的变革潜力&am…
阅读更多...
高等数学啃书汇总重难点（十一）曲线积分与曲面积分

高等数学啃书汇总重难点（十一）曲线积分与曲面积分

依旧是公式极其复杂恶心的一章，建议是：掌握两种线面积分的计算套路即可，和第8章一样属于同济版教材中最不重要的章节，不会对底层理解做过多考察~ 1.弧长曲线积分的几何意义 2.弧长曲线积分的定义和性质 3.弧长曲线积分的计算方式 …
阅读更多...
GitHub项目监控

GitHub项目监控

目录 github开放平台接口限流 监控某个仓库的更新状态 对于常用Github的用户来说，经常有一些自动化的需求。比如监控某些项目的更新情况并实时拉取，比如监控github全网上传的代码是否携带了公司的APIKEY，SECRETKEY等… github开放平台 gith…
阅读更多...
【代码数据】2023粤港澳大湾区金融数学建模B题分享

【代码数据】2023粤港澳大湾区金融数学建模B题分享

基于中国特色估值体系的股票模型分析和投资策略 首先非常建议大家仔细的阅读这个题的题目介绍，还有附赠的就是那个附件里的那几篇材料，我觉得你把这些内容读透理解了，就可以完成大部分内容。然后对于题目里它主要第一部分给出了常用的估值模…
阅读更多...
阿里云无影升级2.0 云电脑解决方案时代到来

阿里云无影升级2.0 云电脑解决方案时代到来

10月31日，杭州云栖大会上，阿里云宣布无影全新升级2.0：从云电脑到云上解决方案，帮助中小企业更便捷地构建云上办公，并开放无影产品及解决方案能力，为生态合作伙伴提供企业云平台，帮助其打造定制化…
阅读更多...
四川达州-全国先进计算创新大赛总结

四川达州-全国先进计算创新大赛总结

目录 四川达州-全国先进计算创新大赛 1.三个算法，第三个原创的？（国内对比） 2.方案的实际落地应用？（落地应用） 3.农业数据采集有问题（数据采集汇总），很难…
阅读更多...
【JS】this指向

【JS】this指向

一、this指向的四种规则 1.默认绑定规则 对象指向，比较的是引用地址。 console.log(this window); //true console.log({} {}); //false //函数的独立调用 function test(){console.log(this window); //true } test(); 2.隐式绑定规则 谁调用…
阅读更多...
从中序和后序遍历序列构造二叉树

从中序和后序遍历序列构造二叉树

注意&#xff1a;该解法是基于二叉树中的值不存在重复所写的。 代码如下&#xff0c;可开袋即食 class Solution {private Map<Integer,Integer> map;public TreeNode buildTree(int[] inorder, int[] postorder) {map new HashMap<>();for(int i 0; i < in…
阅读更多...
Mysql数据库 6.SQL语言 分组、分页查询

Mysql数据库 6.SQL语言 分组、分页查询

分组查询—group by 分组——就是将数据表中的记录按照指定的类进行分组 关键字——group by 语法 语法中加[]的是可有可无的&#xff0c;group by一般和having一起使用 select 分组字段/聚合函数 from 表名 [where 条件] group by 分组列名 [having 条件] [order by …
阅读更多...
3DEXPERIENCE云端项目管理小工具--Project Planner项目策划者角色

3DEXPERIENCE云端项目管理小工具--Project Planner项目策划者角色

云端3DEXPERIENCE平台提供了一个协作环境&#xff0c;使企业和个人能够以全新的方式实现创新。它将人员、创意、数据和解决方案连接到一个始终在线且可用的协作和交互环境中&#xff0c;可以帮助您的企业提高执行力、生产率并加速创新。 3DEXPERIENCE中的Project Planner项目策…
阅读更多...
操作系统 day02（特征和发展历程）

操作系统 day02（特征和发展历程）

一&#xff0c;操作系统的特征 并发和并行 共享 并发和共享互为存在条件 虚拟 异步 综上所述&#xff1a; 二&#xff0c;操作系统的发展历程
阅读更多...
基于图神经网络的联邦学习跨企业推荐

基于图神经网络的联邦学习跨企业推荐

Federated Learning-Based Cross-Enterprise Recommendation With Graph Neural Networks 论文试图解决什么问题 该论文试图解决跨企业推荐系统中存在的数据共享和用户隐私保护的问题。在许多小型和中型企业中&#xff0c;由于资源有限&#xff0c;无法提供足够的数据来进行大…
阅读更多...
FreeRTOS_信号量之优先级翻转

FreeRTOS_信号量之优先级翻转

目录 1. 优先级翻转 2. 优先级翻转实验 2.1 实验目的 2.2 实验设计 2.3 实验程序 2.4 现象 1. 优先级翻转 在使用二值信号量的时候会遇到一个很常见的问题——优先级翻转。优先级翻转在可剥夺内核中是非常常见的&#xff0c;在实时系统中不允许出现这种现象&#xff0c;这…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023