ResNeSt——ResNet最强改进版

最新推荐文章于 2024-08-08 08:14:58 发布
置顶 最新推荐文章于 2024-08-08 08:14:58 发布
阅读量2w 收藏 217
点赞数 32
分类专栏： ResNeSt pytorch 文章标签： 神经网络 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Guo_Python/article/details/105646838
版权

论文地址:https://hangzhang.org/files/resnest.pdf

github：https://github.com/zhanghang1989/ResNeSt

 

1. 先来看看作者，都是大牛，感谢给我们提供优越的网络，并且开源

Caption

 

2. 再来看看网络的性能

        在图像识别，目标检测和图像分割都有长点，说明网络的泛化能力极强。

Caption

        ResNeSt在图像分类上中ImageNet数据集上超越了其前辈ResNet、ResNeXt、SENet以及EfficientNet。使用ResNeSt-50为基本骨架的Faster-RCNN比使用ResNet-50的mAP要高出3.08%。使用ResNeSt-50为基本骨架的DeeplabV3比使用ResNet-50的mIOU要高出3.02%。涨点效果非常明显。

 

3. 直接看重点，Split-Attention模块

Caption

       从左到右分别是SENet, SKNet, ResNeSt的网络结构，Split-Attention其本质可理解为切片的注意力监督机制。

Caption

         每个Cardinal的实现细节，悄悄告诉你，看代码会更加清楚哦!像不像多个SENet的组合?哈哈哈。。。

 

4. 开源的模型是从ResNeSt50开始的，怎么用ResNeSt18呢? 博主给你答案

       在官方代码中添加下面的一段代码，就可以调用ResNeSt18了，是不是很简单。

def resnest18(pretrained=False, root='~/.encoding/models', **kwargs):
    model = ResNet(Bottleneck, [2, 2, 2, 2],
                   radix=2, groups=1, bottleneck_width=64,
                   deep_stem=True, stem_width=32, avg_down=True,
                   avd=True, avd_first=False, **kwargs)
   
    if pretrained:
        # 官方没有提供resnest18的预训练模型，我这里用resnest50的预训练模型加载
        weight = torch.hub.load_state_dict_from_url(
            resnest_model_urls['resnest50'], progress=True, check_hash=True)
        model_dict = model.state_dict()
        for k,v  in weight.items():
            if k in model_dict.keys():
                model_dict[k] = v
        model.load_state_dict(model_dict)
    return model

5. 测试一下

   整体代码是这样的

##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
## Created by: Hang Zhang
## Email: zhanghang0704@gmail.com
## Copyright (c) 2020
##
## LICENSE file in the root directory of this source tree 
##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
"""ResNeSt models"""

import torch
from resnet import ResNet, Bottleneck

__all__ = ['resnest50', 'resnest101', 'resnest200', 'resnest269']

_url_format = 'https://hangzh.s3.amazonaws.com/encoding/models/{}-{}.pth'

_model_sha256 = {name: checksum for checksum, name in [
    ('528c19ca', 'resnest50'),
    ('22405ba7', 'resnest101'),
    ('75117900', 'resnest200'),
    ('0cc87c48', 'resnest269'),
    ]}



def short_hash(name):
    if name not in _model_sha256:
        raise ValueError('Pretrained model for {name} is not available.'.format(name=name))
    return _model_sha256[name][:8]

resnest_model_urls = {name: _url_format.format(name, short_hash(name)) for
    name in _model_sha256.keys()
}


# 博主添加的
def resnest18(pretrained=False, root='~/.encoding/models', **kwargs):
    model = ResNet(Bottleneck, [2, 2, 2, 2],
                   radix=2, groups=1, bottleneck_width=64,
                   deep_stem=True, stem_width=32, avg_down=True,
                   avd=True, avd_first=False, **kwargs)
   
    if pretrained:
        # 官方没有提供resnest18的预训练模型，我这里用resnest50的预训练模型加载
        weight = torch.hub.load_state_dict_from_url(
            resnest_model_urls['resnest50'], progress=True, check_hash=True)
        model_dict = model.state_dict()
        for k,v  in weight.items():
            if k in model_dict.keys():
                model_dict[k] = v
        model.load_state_dict(model_dict)
    return model



def resnest50(pretrained=False, root='~/.encoding/models', **kwargs):
    model = ResNet(Bottleneck, [3, 4, 6, 3],
                   radix=2, groups=1, bottleneck_width=64,
                   deep_stem=True, stem_width=32, avg_down=True,
                   avd=True, avd_first=False, **kwargs)
    if pretrained:
        model.load_state_dict(torch.hub.load_state_dict_from_url(
            resnest_model_urls['resnest50'], progress=True, check_hash=True))
    return model

def resnest101(pretrained=False, root='~/.encoding/models', **kwargs):
    model = ResNet(Bottleneck, [3, 4, 23, 3],
                   radix=2, groups=1, bottleneck_width=64,
                   deep_stem=True, stem_width=64, avg_down=True,
                   avd=True, avd_first=False, **kwargs)
    if pretrained:
        model.load_state_dict(torch.hub.load_state_dict_from_url(
            resnest_model_urls['resnest101'], progress=True, check_hash=True))
    return model

def resnest200(pretrained=False, root='~/.encoding/models', **kwargs):
    model = ResNet(Bottleneck, [3, 24, 36, 3],
                   radix=2, groups=1, bottleneck_width=64,
                   deep_stem=True, stem_width=64, avg_down=True,
                   avd=True, avd_first=False, **kwargs)
    if pretrained:
        model.load_state_dict(torch.hub.load_state_dict_from_url(
            resnest_model_urls['resnest200'], progress=True, check_hash=True))
    return model

def resnest269(pretrained=False, root='~/.encoding/models', **kwargs):
    model = ResNet(Bottleneck, [3, 30, 48, 8],
                   radix=2, groups=1, bottleneck_width=64,
                   deep_stem=True, stem_width=64, avg_down=True,
                   avd=True, avd_first=False, **kwargs)
    if pretrained:
        model.load_state_dict(torch.hub.load_state_dict_from_url(
            resnest_model_urls['resnest269'], progress=True, check_hash=True))
    return model



if __name__ == "__main__":
    net = resnest18(pretrained=True)
    print(net)

        运行一下，加载了预训练模型，ResNeSt18的网络结构如下:

ResNet(
  (conv1): Sequential(
    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU(inplace=True)
    (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (5): ReLU(inplace=True)
    (6): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  )
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): SplAtConv2d(
        (conv): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(32, 128, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): AvgPool2d(kernel_size=1, stride=1, padding=0)
        (1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): SplAtConv2d(
        (conv): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(32, 128, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer2): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (avd_layer): AvgPool2d(kernel_size=3, stride=2, padding=1)
      (conv2): SplAtConv2d(
        (conv): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): AvgPool2d(kernel_size=2, stride=2, padding=0)
        (1): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): SplAtConv2d(
        (conv): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer3): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (avd_layer): AvgPool2d(kernel_size=3, stride=2, padding=1)
      (conv2): SplAtConv2d(
        (conv): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): AvgPool2d(kernel_size=2, stride=2, padding=0)
        (1): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): SplAtConv2d(
        (conv): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer4): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (avd_layer): AvgPool2d(kernel_size=3, stride=2, padding=1)
      (conv2): SplAtConv2d(
        (conv): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): AvgPool2d(kernel_size=2, stride=2, padding=0)
        (1): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (2): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): SplAtConv2d(
        (conv): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2, bias=False)
        (bn0): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (fc1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (fc2): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1))
      )
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (avgpool): GlobalAvgPool2d()
  (fc): Linear(in_features=2048, out_features=1000, bias=True)
)

 

就是这么简单，替换掉你的ResNet吧! 如果喜欢就给博主点个赞吧。。。

 

如果预训练模型找不到，请用该地址：https://s3.us-west-1.wasabisys.com/resnest/torch/resnest50-528c19ca.pth

相关: https://www.cnblogs.com/xiximayou/p/12728644.html

          机器之心

CV-deeplearning
关注
专栏目录
ResNet改进版来了！可训练网络超过3000层！相同深度精度更高
我爱计算机视觉
04-16 1364
来自阿联酋起源人工智能研究院（IIAI）的研究人员公布了一篇论文Improved Residual Networksfor Image and Video Recognition，深入...
ResNeSt 模型分析和代码详解 (拆组和通道注意力ResNet)
Forrest97的博客
10-13 1万+
ResNeSt: Split-Attention Networks模型的拆分注意力网络，最近特别火，主要是作为深度学习的backbone模型，ResNeSt在不同的图像任务中都有效提高了模型的预测精度。 因此今天分享下，最近两天学习的心得体会，参考资料如下： ResNeSt: Split-Attention Networks github官网 B站作者讲解 张航主页 文章目录安装使用ResNeSt创新点split(multi-brach)Channel attention代码详解resnest.pyresn
【机器学习】详解 ResNeSt
闻韶
10-19 1万+
【机器学习】详解 ResNeSt
ResNeSt 开源项目教程
最新发布
gitblog_00506的博客
08-08 736
ResNeSt 开源项目教程 ResNeStResNeSt: Split-Attention Networks项目地址:https://gitcode.com/gh_mirrors/re/ResNeSt 1. 项目介绍 ResNeSt（Split-Attention Networks）是由 Zhang 等人提出的一种新颖的深度学习网络结构，它以 ResNet为基础并引入了分裂注意力机制。这个机制...
ResNet再进化！重新思考ResNet：采用高阶方案的改进堆叠策略
阿木寺的博客
04-11 1840
点击下方卡片，关注“CVer”公众号AI/CV重磅干货，第一时间送达本文转载自：AI人工智能初学者Rethinking ResNets: Improved Stacking Strateg...
论文导读 | 基于注意力机制对齐增强预训练语言模型
weixin_48167662的博客
11-03 1243
这篇文章通过提出了一种注意力机制对齐的方法，为预训练语言模型在 fine-tuning阶段引入了多源分词信息外部知识，从而提升了预训练语言模型在各个子任务上的效果。本文收录于 2020 年 ACL。 问题背景 BERT 出现后，预训练语言模型统治了大多数的NLP应用任务，预训练-微调这一2-stage 模式成为了主流。随着预训练语言模型的不断发展，预训练任务和模型结构被不断改进，以让模型适配更大量的数据的数据，以及从更多途径获取各种外部知识。 对于中文预训练语言模型来说，最实用、直接的方法便是引入..
ResNet改进原理介绍论文笔记
charles_zhang_的博客
05-12 2147
ResNet改进原理介绍论文笔记 Identity Mappings in Deep Residual Networks Abstract 深度剩余网络是一系列极深的体系结构，显示出令人信服的准确性和良好的收敛行为。在本文中，我们分析了剩余构建块背后的传播公式，这表明在使用身份映射作为跳过连接和加法激活后，前向和后向信号可以直接从一个块传播到任何其他块。一系列消融实验证明了这些恒等式映射的重要性。这促使我们提出了一种新的残差单元，它使训练更容易，提高了泛化能力。我们报告了使用CIF AR10上的1001层
深度学习网络篇——ResNet
热门推荐
PRIS-SCMonkey的博客
12-17 8万+
ResNet 作者：Kaiming He ，Xiangyu Zhang ，Shaoqing Ren ，Jian Sun 研究机构：Microsoft Research About Kaiming He: 2003年广东省理科高考状元，清华基础科学班，香港中文大学攻读研究生，微软亚研院实习，现在FAIR工作 主要文献: ResNet，Faster-RCNN（Shaoqing Ren一作）, S...
MNIST手写数字识别 —— ResNet-经典卷积神经网络
m0_54776464的博客
07-30 2574
resnet
卷积神经网络——ResNet论文翻译
itlilyer的博客
03-18 4233
ResNet论文翻译
ResNet网络的改进版：ResNeXt
qq_41387508的博客
12-04 2773
之前的文章讲过ResNet网络的基本架构，其本质就是让网络的学习目的从学习转为学习，也就是学习输入和输出之间的残差信息，从而缓解了梯度消失和网络退化问题。 本文讲下ResNet网络的改进版：ResNeXt。 架构 下面是ResNet和ResNeXt的架构对比： 引用自参考1 从上图中便可以看到ResNeXt的核心：用了类似于Inception的思想，把残差块的一条路径变成多条路径。 如果看原文也可以发现，其实作者最主要的对标就是Inception的模块。在Inception中，作者设计了4个不同的路径来从数
卷积神经网络的网络结构——ResNet
qq_45252740的博客
06-21 705
卷积神经网络的网络结构——ResNet
基于mmclassification框架，ResNeSt-50网络训练标牌细分类模型
工地搬砖第一年的博客
08-05 1814
项目地址：https://github.com/open-mmlab/mmclassification 参考1：https://blog.csdn.net/weixin_34910922/article/details/107801656 参考2：https://blog.csdn.net/weixin_43216130/article/details/115312600 这两篇博文都写的很仔细，谢谢这两位同学 一、环境安装 1、首先查看python的版本 2、再查看cuda和pytorch的版本，是否对应
U-Net论文学习与理解
weixin_41936775的博客
09-12 3992
简介 论文信息 U-Net出自2015年Olaf Ronneberger等人的论文 《U-Net: Convolutional Networks for Biomedical Image Segmentation 》，该论文可在IEEE explore中检索到。 U-Net提出背景 在过去几年里，深度卷积网络不仅广泛地应用于各种视觉识别任务，同时也达到了非常好的效果，尤其是在医学图像分割任务方面。然而由于医学图像可用训练集大小的限制以及考虑到网络大小，卷积网络难以取得更好的成果，幸运的是Hence, Cir
ResNeSt 之我见
Enjoy_endless
10-08 2727
今天是10.8号，国庆假期的最后一天，终于可以静下来看一篇文章了。最近很茫 (是茫然的茫)、正值秋招见尾，今年cv领域的算法岗位确实是不太好找，好多公司企业最低要求都是博士起步了，当然自己能力不足确是原罪。大部分cv的同学、能找到cv岗位的已经比较少了、要不转了搜广推(偏nlp)、要不就只能是AI算法、或者开发等岗位了。搜广推这一块岗位多、工资高，确实不知道自己将会如何选择了，可能明年这个时候就去搞npl了。虽然cv也好、nlp也罢，最终都还是围着dnn或者机器学习转，本质上没有太大区别，但是对于相关知识领
ResNet全家桶
如果想成为中心，那么就到中心去吧。
06-29 1162
文章目录ResNetResNet中的Bottleneck结构和1*1卷积ResNet的网络设计规律ResNextResNeStRes2NetPyConvResNet参考 ResNet 2015 年，ResNet 横空出世，一举斩获 CVPR 2016 最佳论文奖，而且在 Imagenet 比赛的三个任务以及 COCO 比赛的检测和分割任务上都获得了第一名。四年过去，这一论文的被引量已超 40000 次.。 我们知道，增加网络深度后，网络可以进行更加复杂的特征提取，因此更深的模型可以取得更好的结果。但事实并非
ResNet改进之ResNext学习笔记 （附代码）
PLANTTHESON的博客
10-02 854
ResNet改进之ResNext学习笔记 （附代码）
如何使ResNet优于EfficientNet？改进训练方法和扩展策略就可以
小白学视觉
10-16 436
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达作者：Edison_G架构变化、训练方法和扩展策略是影响模型性能的不可或缺的重要因素，而当前的研究只侧重架构的变化。谷歌大脑和 UC 伯克利的一项最新研究重新审视了 ResNet 架构，发现对于提升模型性能而言，改进训练和扩展策略或许比架构变化更重要。他们提出了 ResNet 的变体架构 ResNet-RS，其使用的内存不仅更少...
【最强ResNet改进系列】Res2Net：一种新的多尺度网络结构，性能提升显著
深度学习技术前沿
08-08 1万+
点击上方，选择星标或置顶，不定期资源大放送！阅读大概需要15分钟Follow小博主，每天更新前沿干货【导读】2020年，在各大CV顶会上又出现了许多基于ResNet改进的工作，比如:Re...
resnet50改进
09-04
ResNet-50是一个非常经典的深度残差网络，但也有一些改进的方法可以尝试。以下是一些常见的改进方法： 1. 更深的网络结构：可以尝试增加网络的层数，例如使用ResNet-101或ResNet-152。更深的网络可以提供更强大的表达能力，并且可能达到更好的性能。 2. 瓶颈结构：在ResNet中，瓶颈结构被用于减少计算量。可以尝试改进瓶颈结构，例如使用更大的卷积核或调整通道数，以进一步提升性能。 3. 激活函数的改进：可以尝试使用其他激活函数替代ResNet中使用的ReLU函数。例如，使用LeakyReLU、PReLU或ELU等激活函数，可能会带来更好的效果。 4. 改进的初始化方法：尝试使用其他初始化方法，例如Xavier或He等，可以帮助网络更好地收敛并提高性能。 5. 正则化技术：添加正则化技术，如Dropout、Batch Normalization或Weight Decay等，有助于防止过拟合并提高模型的泛化能力。 6. 数据增强：使用更多和更复杂的数据增强技术，如随机裁剪、旋转、翻转等，可以增加模型的鲁棒性和泛化能力。 以上是一些对ResNet-50进行改进的方法，当然还有其他更多的改进方式可以尝试，具体的选择可以根据具体任务和数据集来进行调整。
评论 39
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值