FastInst 之 Backbone：ResNet-vd-dcn

于 2024-06-11 16:55:49 发布
阅读量146 收藏 2
点赞数 7
文章标签： 深度学习 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46158001/article/details/139602504
版权

结合了经典ResNet结构的残差块（Bottleneck）概念与可形变卷积（Deformable Convolution）技术：

  1. 低级特征提取（conv1层）
    起点：初始卷积层以较小的滤波器（如3x3）扫描图像，寻找基本的视觉线索。
    功能：识别图像的最基本元素，如边缘、纹理、色彩变化和亮度变化。

  2. 特征细化与通道调整（layer1）
    过渡： 经过初始的低级特征提取后，网络进入更深层次的特征细化阶段，通常通过残差结构（如Bottleneck）实现。
    通道调整：通过1x1卷积减少通道数，随后3x3卷积进行特征提取，再通过另一次1x1卷积增加通道数，这一系列操作在控制计算成本的同时增强了特征表达力。

  3. 空间下采样与特征聚合（layer2及以后）
    目的： 随着网络深度增加，降低特征图的空间分辨率成为关键，这不仅减少了计算负担，而且促进了对更大上下文的理解。
    操作：使用步长大于1的卷积或池化（如Max/Avg Pooling）进行空间下采样，特征图的尺寸减小，但每个特征覆盖了更大的图像区域，有利于捕获全局结构和上下文信息。

  4. 可形变卷积的引入（layer3和layer4）
    创新点： 在网络的较深层次，引入可形变卷积（Deformable Convolution）是提升对复杂形变性和尺度不变性的关键步骤。
    动态性： 通过在执行卷积前预测偏移量，可形变卷积的采样点可以根据输入特征动态调整，更好地适应对象的形状变化和位置变动，这在目标检测、分割等任务中尤为重要。

那是不是就说明 我们可以在某个层做一些改动作为创新点呢？？？
可以怎么改呢？？
在这里插入图片描述

(backbone): ResNet(
(conv1): Sequential(
  (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
  (1): FrozenBatchNorm2d(num_features=32, eps=1e-05)
  (2): ReLU(inplace=True)
  (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (4): FrozenBatchNorm2d(num_features=32, eps=1e-05)
  (5): ReLU(inplace=True)
  (6): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
)
(bn1): FrozenBatchNorm2d(num_features=64, eps=1e-05)
(act1): 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): FrozenBatchNorm2d(num_features=64, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=64, eps=1e-05)
    (drop_block): Identity()
    (act2): ReLU(inplace=True)
    (aa): Identity()
    (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act3): ReLU(inplace=True)
    (downsample): Sequential(
      (0): Identity()
      (1): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (2): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    )
  )
  (1): Bottleneck(
    (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=64, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=64, eps=1e-05)
    (drop_block): Identity()
    (act2): ReLU(inplace=True)
    (aa): Identity()
    (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (2): Bottleneck(
    (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=64, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=64, eps=1e-05)
    (drop_block): Identity()
    (act2): ReLU(inplace=True)
    (aa): Identity()
    (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
)
  
(layer2): Sequential(
  (0): Bottleneck(
    (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (drop_block): Identity()
    (act2): ReLU(inplace=True)
    (aa): Identity()
    (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act3): 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): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    )
  )
  (1): Bottleneck(
    (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (drop_block): Identity()
    (act2): ReLU(inplace=True)
    (aa): Identity()
    (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (2): Bottleneck(
    (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (drop_block): Identity()
    (act2): ReLU(inplace=True)
    (aa): Identity()
    (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (3): Bottleneck(
    (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
    (bn2): FrozenBatchNorm2d(num_features=128, eps=1e-05)
    (drop_block): Identity()
    (act2): ReLU(inplace=True)
    (aa): Identity()
    (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
)
  
(layer3): Sequential(
  (0): DeformableBottleneck(
    (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(256, 18, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
    (conv2): DeformConv(in_channels=256, out_channels=256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
    (act3): 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): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
    )
  )
  (1): DeformableBottleneck(
    (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(256, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): DeformConv(in_channels=256, out_channels=256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (2): DeformableBottleneck(
    (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(256, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): DeformConv(in_channels=256, out_channels=256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (3): DeformableBottleneck(
    (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(256, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): DeformConv(in_channels=256, out_channels=256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (4): DeformableBottleneck(
    (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(256, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): DeformConv(in_channels=256, out_channels=256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (5): DeformableBottleneck(
    (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(256, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): DeformConv(in_channels=256, out_channels=256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=256, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=1024, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
)
  
(layer4): Sequential(
  (0): DeformableBottleneck(
    (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(512, 18, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
    (conv2): DeformConv(in_channels=512, out_channels=512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
    (act3): 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): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
    )
  )
  (1): DeformableBottleneck(
    (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(512, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): DeformConv(in_channels=512, out_channels=512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
  (2): DeformableBottleneck(
    (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn1): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act1): ReLU(inplace=True)
    (conv2_offset): Conv2d(512, 18, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (conv2): DeformConv(in_channels=512, out_channels=512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), dilation=(1, 1), groups=1, deformable_groups=1, bias=False)
    (bn2): FrozenBatchNorm2d(num_features=512, eps=1e-05)
    (act2): ReLU(inplace=True)
    (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (bn3): FrozenBatchNorm2d(num_features=2048, eps=1e-05)
    (act3): ReLU(inplace=True)
  )
)

)

快快涨点️吧
关注
【目标检测-YOLO】博客阅读：Introduction to the YOLO Family
博观约取，厚积薄发
04-07 1825
介绍YOLO家族 目标检测是计算机视觉研究的重要课题之一。大多数计算机视觉问题都涉及到检测视觉对象类别，如行人、汽车、公共汽车、人脸等。这一领域不仅局限于学术界，而且在视频监控、医疗保健、车载传感和自动驾驶等领域具有潜在的现实商业用例。 许多用例，特别是自主驾驶，都要求高精度和实时推理速度。因此，选择一个对象检测器，适合的速度和准确性成为必不可少的法案。YOLO (You Only Look Once)是一个单级对象检测器，用于实现两个目标(即速度和准确性)。今天，我们将通过涵盖所有YOLO变体(如
【目标检测-YOLO】PP-YOLO(v3版本)
博观约取，厚积薄发
03-31 744
本文下载的论文是 arXiv:2007.12099v3 [cs.CV] 3 Aug 2020 PP-YOLO: An Effective and Effificient Implementation of Object Detector 百度 摘要 Due to limitation of hardware, it is often necessary to sacrififice(牺牲)accuracy to ensure the infer speed of the detector in p.
PaddleClas：ResNet_vd结构
微风❤水墨
07-05 649
而且，在这个模块中将feature size缩小了两倍，所以在conv3_x中的第一个basicBlock中，使用了stride=2，此时feature map的size也已经缩小了，所以需要在shortcut中添加1*1卷积，并且stride=2，让输入和输出具有相同的形状，从而可以相加。根据上面表格中的表述，可以将整个网络的主体部分分为4块，conv2_x，conv3_x，conv4_x，conv5_x，在所有的结构中conv2_x这一部分都没有对的大小做改变feature map。
重读残差网络——resnet(对百度vd模型解读)
TEDDY的博客
05-02 2044
resnet 解决了随着CNN网络深度的加深，网络性能退化的一个问题。 具体解释见 （11：20）：飞桨开发者live：手把手教你玩转工业质检_哔哩哔哩_bilibili一分钟带你认识残差模块 对百度vd模型解读（14：40）：飞桨开发者live：手把手教你玩转工业质检_哔哩哔哩_bilibili 很好的解释：深度学习经典网络（4）ResNet深度残差网络结构详解_青衫憶笙-CSDN博客_resnet网络结构 论文翻译中文版 2. 怎么解决退化问题？ ...
基于图像分类网络ResNet50_vd实现桃子分类
m0_63642362的博客
12-12 1233
本教程利用PaddleHub搭建图像分类网络ResNet50_vd，实现桃子分类，助力搭建完整的智能水果分拣系统。
大话深度残差网络（DRN）ResNet
跟着大数据和AI去旅行
04-21 1308
论文地址：Deep Residual Learning for Image Recognition 一、引言 深度残差网络（Deep residual network, ResNet）的提出是CNN图像史上的一件里程碑事件，让我们先看一下ResNet在ILSVRC和COCO 2015上的战绩： ResNet取得了5项第一，并又一次刷新了CNN模型在ImageNet上的历史： ResNet的作者...
ResNet变种
00000cj的博客
01-01 616
Bag of Tricks for Image Classification with Convolutional Neural Networks 3. Efficient Traning Larget-batch training Linear scaling learning rate Learning rate warmup Zeroγ No bias decay Low-precision traning The evaluation results for ResNet-50 a.
【动手学PaddlePaddle2.0系列】PP-YOLO详解（1）-- backbone
小鸭学院的博客
12-29 1969
PP-YOLO详解（1）-- backbone 大家好，本次教程将带领大家开启PP-YOLO学习。通过前面一系列学习，相信大家已经掌握了图像分类任务的基本概念以及相关实践，下面将带大家实战目标检测任务中经典的YOLO系列算法：PP-YOLO。 本次将对使用的backbone网络：ResNet50-vd-dcn，进行讲解。 1 ResNet_D Resnet_vd最早是在Bag of Tricks for Image Classification with Convolutional Neural Netwo
8-1高效且有效的实用目标检测技术.pdf
03-18
基础网络结构方面，PP-YOLO借鉴了YOLOv3的设计，包括Darknet53、ResNet50-vd-dcn作为Backbone，YOLOv3的FPN（Feature Pyramid Network）作为Neck，以及YOLOv3的Head用于预测边界框和类别概率。Darknet53是一个轻量级...
PP-YOLO超越YOLOv4-目标检测的进步
TensorFlowNews
10-16 1122
作者|Jacob Solawetz 编译|Flin 来源|towardsdatascience PP-YOLO评估指标比现有最先进的对象检测模型YOLOv4表现出更好的性能。然而，百度的作者写道： 本文不打算介绍一种新型的目标检测器。它更像是一个食谱，告诉你如何逐步建立一个更好的探测器。 让我们一起看看。 YOLO发展史 YOLO最初是由Joseph Redmon编写的，用于检测目标。目标检测是一种计算机视觉技术，它通过在目标周围画一个边界框来定位和标记对象，并确定一个给定的框所属的类标签。和大型NLP
ResNet模型实验
07-05
本实验使用了ResNet模型，实验中包含了模型结构、网络训练和测试，以及预测部分。文件太大，没有上传数据集。请自行下载
resnet预训练模型_23个系列分类网络,10万分类预训练模型,这是飞桨PaddleClas百宝箱...
weixin_39984201的博客
11-21 686
机器之心发布机器之心编辑部如何训练出优秀的图像分类模型？飞桨图像分类套件 PaddleClas 来助力。今天咱们来聊聊计算机视觉领域最核心的技术之一——图像分类。顾名思义图像分类是指根据图像信息把不同类别的图像自动区分开来，并能指出图像类别信息。如图 1 所示，当前图像分类技术有着非常广泛的应用场景。图 1 图像分类技术应用此外图像分类技术在计算机视觉各类任务中堪称「基石」，这和人类的视觉方面的技...
使用MindStudio完成StarNet_MobileNetV3模型开发
qq_37435386的博客
11-19 625
MindStudio是一套基于华为昇腾AI处理器开发的AI全栈开发平台，包括基于芯片的算子开发、以及自定义算子开发，同时还包括网络层的网络移植、优化和分析，另外在业务引擎层提供了一套可视化的AI引擎拖拽式编程服务，极大的降低了AI引擎的开发门槛。MindStudio功能框架如图1所示。图1首次启动MindStudio会提示是否导入配置，如图2所示，可以选择不导入配置，点击OK进入MindStudio主界面。
图像分类常见问题汇总（一）
mjiansun的专栏
11-07 1591
转自：https://github.com/PaddlePaddle/PaddleClas/blob/master/docs/zh_CN/faq_series/faq_2020_s1.md 图像分类常见问题汇总 Q1.1: PaddleClas可以用来做什么? A：PaddleClas是飞桨为工业界和学术界所准备的一个图像分类任务的工具集，助力使用者训练出更好的视觉模型和应用落地。PaddleClas提供了基于图像分类的模型训练、评估、预测、部署全流程的服务，方便大家更加高效地学习图像分类。具体地，P
23个系列分类网络，10万分类预训练模型，这是飞桨PaddleClas百宝箱
百度大脑
04-27 3164
如何训练出优秀的图像分类模型？飞桨图像分类套件 PaddleClas 来助力。今天咱们来聊聊计算机视觉领域最核心的技术之一——图像分类。顾名思义图像分类是指根据图像信息把不同类别的图像自...
PaddleHub一键动物识别
与其在风雨中逃避，不如在雷电中舞蹈
05-02 1385
使用PaddleHub现有的两个动物识别模型resnet50_vd_animals和mobilenet_v2_animals进行百度自制数据集进行动物识别
【机器学习】详解 ResNeSt
热门推荐
闻韶
10-19 1万+
【机器学习】详解 ResNeSt
来聊聊ResNet及其变种
AI算法修炼营的博客
05-10 3067
点击上方“AI算法修炼营”，选择“星标”公众号精选作品，第一时间送达01ResNet网络结构2015 年，ResNet 横空出世，一举斩获 CVPR 2016 最佳论文奖，而且在 Ima...
解释这段代码# ema use_ema: False # Threshold confidence_threshold: 0.98 # Criterion criterion: confidence-cross-entropy criterion_kwargs: apply_class_balancing: True # Model backbone: resnet18 num_heads: 1 # Dataset train_db_name: cifar-10 val_db_name: cifar-10 num_classes: 10 # Transformations augmentation_strategy: ours augmentation_kwargs: crop_size: 32 normalize: mean: [0.4914, 0.4822, 0.4465] std: [0.2023, 0.1994, 0.2010] num_strong_augs: 4 cutout_kwargs: n_holes: 1 length: 16 random: True transformation_kwargs: #resize: 40 crop_size: 32 normalize: mean: [0.4914, 0.4822, 0.4465] std: [0.2023, 0.1994, 0.2010] # Hyperparameters epochs: 200 batch_size: 1000 num_workers: 8 optimizer: adam optimizer_kwargs: lr: 0.00005 weight_decay: 0.0001 # Scheduler scheduler: constant
最新发布
07-11
这段代码是一个配置文件，用于训练一个模型。下面是对每个部分的解释： - `use_ema: False`：是否使用指数移动平均（Exponential Moving Average，EMA）来更新模型参数。 - `confidence_threshold: 0.98`：置信度阈值，用于在预测时确定模型对结果的信心度。 - `criterion: confidence-cross-entropy`：损失函数的选择，此处为置信度交叉熵（Confidence Cross Entropy）。 - `criterion_kwargs`：损失函数的参数设置，此处包括应用类别平衡（Class Balancing）。 - `backbone: resnet18`：模型的主干网络，这里使用的是ResNet-18。 - `num_heads: 1`：注意力头的数量。 - `train_db_name: cifar-10`：训练数据集的名称，这里使用CIFAR-10数据集。 - `val_db_name: cifar-10`：验证数据集的名称，也是CIFAR-10数据集。 - `num_classes: 10`：类别数量，CIFAR-10数据集有10个类别。 - `augmentation_strategy: ours`：数据增强策略的选择，此处为我们自己定义的策略。 - `augmentation_kwargs`：数据增强策略的参数设置，包括裁剪尺寸、归一化以及剪切参数等。 - `transformation_kwargs`：变换参数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值