You Only Look One-level Feature

最新推荐文章于 2022-05-11 11:07:32 发布
最新推荐文章于 2022-05-11 11:07:32 发布
阅读量234 收藏 1
点赞数
文章标签： 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42385823/article/details/120257077
版权

You Only Look One-level Feature

摘要 ：

本文重新审视了用于一级检测器的特征金字塔网络 (FPN)，并指出 FPN 的成功在于其对目标检测中的优化问题的分而治之的解决方案，而不是多尺度特征融合。从优化的角度来看，我们引入了一种替代方法来解决问题，而不是采用复杂的特征金字塔——仅利用一层特征进行检测。基于简单高效的解决方案，我们提出了 You Only Look One-level Feature (YOLOF)。在我们的方法中，提出了两个关键组件，扩张编码器和均匀匹配，并带来了相当大的改进。在 COCO 基准上的大量实验证明了所提出模型的有效性。我们的 YOLOF 实现了与其特征金字塔对应的 RetinaNet 相当的结果，同时速度提高了 2.5 倍。在没有变换器层的情况下，YOLOF 可以以单级特征方式与 7×less 训练时期的 DETR 性能相匹配。在608×608的图像尺寸下，YOLOF在2080Ti上以60 fps运行达到44.3 mAP，比YOLOv4快13%

 

特征金字塔网络（FPN）的好处：

  • 多尺度特征融合：融合多个低分辨率和高分辨率特征输入以获得更好的表示;

  • 分而治之：根据对象的尺度检测不同级别的对象

NAS-FPN

 

SSD [26] 首先利用多尺度特征并在每个尺度上对不同尺度的对象进行对象检测。 FPN [22] 遵循 SSD [26] 和 UNet [33]，通过结合浅层特征和深层特征构建语义丰富的特征金字塔。

MIMO效果最好，其次SISO，MISO,SISO.

 

SISO编码的两个问题：

第一个问题是与 C5 特征的感受野匹配的尺度范围是有限的，这阻碍了对不同尺度的物体的检测性能。

第二个是单层特征中稀疏anchor提出的positive anchors的不平衡问题。

 

class Bottleneck(nn.Module):
​
    def __init__(self,
                 in_channels: int = 512,
                 mid_channels: int = 128,
                 dilation: int = 1,
                 norm_type: str = 'BN',
                 act_type: str = 'ReLU'):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(in_channels, mid_channels, kernel_size=1, padding=0),
            get_norm(norm_type, mid_channels),
            get_activation(act_type)
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(mid_channels, mid_channels,
                      kernel_size=3, padding=dilation, dilation=dilation),
            get_norm(norm_type, mid_channels),
            get_activation(act_type)
        )
        self.conv3 = nn.Sequential(
            nn.Conv2d(mid_channels, in_channels, kernel_size=1, padding=0),
            get_norm(norm_type, in_channels),
            get_activation(act_type)
        )
​
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        identity = x
        out = self.conv1(x)
        out = self.conv2(out)
        out = self.conv3(out)
        out = out + identity
        return out
​

Dilated Encoder。它包含两个主要组件：Projector 和 Residual Blocks。投影层首先应用一个 1×1 卷积层来降低通道维度，然后添加一个 3×3 卷积层来细化语义上下文，这与 FPN [22] 中的相同。之后，我们在 3×3 卷积层中堆叠四个具有不同扩张率的连续扩张残差块，以生成具有多个感受野的输出特征，覆盖所有对象的尺度。

扩张卷积是一种在目标检测中扩大特征感受野的常用策略.

Residual Blocks目的是在主干之外生成具有多个感受野的特征。

YOLOF

 

FFN层

 

前馈神经网络没法输入 8 个矩阵呀，这该怎么办呢？所以我们需要一种方式，把 8 个矩阵降为 1 个，首先，我们把 8 个矩阵连在一起，这样会得到一个大的矩阵，再随机初始化一个矩阵和这个组合好的矩阵相乘，最后得到一个最终的矩阵。

Group Normalization(GN)

批量归一化BN是计算机视觉发展中很重要的组成部分，BN是在一个batch中计算均值和方差，BN可以简化并优化使得非常深的网络能够收敛。但是BN却很受batch大小的影响，通过实验证明：BN需要一个足够大的批量，小的批量大小会导致对批统计数据的不准确率提高，显著增加模型的错误率。比如在检测、分割、视频识别等任务中，比如在faster R-cnn或mask R-cnn框架中使用一个batchsize为1或2的图像，因为分辨率更高，其中BN被“冻结”转换为线性层;在3D卷积的视频分类中，空间时间特征的存在引入了时间长度和批处理大小之间的权衡。BN的使用经常会使这些系统在模型符号和批量大小之间做出妥协。

在很宽的批处理大小中，GN表现很稳定，在一个2个样本的批量大小情况下。ImageNet的ResNet-50中，GN的错误比BN要低10.6%。使用常规的批处理大小，GN性能yuBN相当，并优于其他标准化的变体。

img

上图为四种归一化方法，其中N为批量，C为通道，(H,W)表示feature map，蓝色像素代表相同的均值和方差归一化。

 

 

如果我们将组号设置为G = C（即每组一个通道），则GN变为IN。 但是IN只能依靠空间维度来计算均值和方差，并且错过了利用信道依赖的机会。

注：四种归一化的理解

  • BatchNorm：batch方向做归一化，计算NHW的均值

  • LayerNorm：channel方向做归一化，计算CHW的均值

  • InstanceNorm：一个channel内做归一化，计算H*W的均值

  • GroupNorm：先将channel方向分group，然后每个group内做归一化，计算(C//G)HW的均值

  • GN与LN和IN有关，这两种标准化方法在训练循环（RNN / LSTM）或生成（GAN）模型方面特别成功。

    DETR [4] 是最近提出的检测器，它将变压器 [39] 引入对象检测。它在 COCO 基准测试 [24] 上取得了令人惊讶的结果，并证明仅采用单个 C5 特征，就可以与多级特征检测器（Faster R-CNN w/ FPN [22]）取得可比的结果。

DETR在定位上的误差比YOLOF大，这可能与其回归机制有关。 DETR 以完全无锚的方式回归对象并在图像中全局预测位置，这导致定位困难。相比之下，YOLOF 依赖于预定义的锚点，这在预测中导致比 DETR [4] 更高的丢失错误。根据4.2节的分析，YOLOF的anchors稀疏且在推理阶段不够灵活。

anchor-free 机制引入 YOLOF 可能有助于缓解这个问题，

在这项工作中，我们发现 FPN 的成功归功于它对密集目标检测中优化问题的分而治之的解决方案。

 

encoder

class DilatedEncoder(nn.Module):
    """
    Dilated Encoder for YOLOF.
​
    This module contains two types of components:
        - the original FPN lateral convolution layer and fpn convolution layer,
          which are 1x1 conv + 3x3 conv
        - the dilated residual block
    """
​
    def __init__(self, cfg, input_shape: List[ShapeSpec]):
        super(DilatedEncoder, self).__init__()
        # fmt: off
        self.backbone_level = cfg.MODEL.YOLOF.ENCODER.BACKBONE_LEVEL
        self.in_channels = cfg.MODEL.YOLOF.ENCODER.IN_CHANNELS
        self.encoder_channels = cfg.MODEL.YOLOF.ENCODER.NUM_CHANNELS
        self.block_mid_channels = cfg.MODEL.YOLOF.ENCODER.BLOCK_MID_CHANNELS
        self.num_residual_blocks = cfg.MODEL.YOLOF.ENCODER.NUM_RESIDUAL_BLOCKS
        self.block_dilations = cfg.MODEL.YOLOF.ENCODER.BLOCK_DILATIONS
        self.norm_type = cfg.MODEL.YOLOF.ENCODER.NORM
        self.act_type = cfg.MODEL.YOLOF.ENCODER.ACTIVATION
        # fmt: on
        assert input_shape[self.backbone_level].channels == self.in_channels
        assert len(self.block_dilations) == self.num_residual_blocks
​
        # init
        self._init_layers()
        self._init_weight()
​
    def _init_layers(self):
        self.lateral_conv = nn.Conv2d(self.in_channels,
                                      self.encoder_channels,
                                      kernel_size=1)
        self.lateral_norm = get_norm(self.norm_type, self.encoder_channels)
        self.fpn_conv = nn.Conv2d(self.encoder_channels,
                                  self.encoder_channels,
                                  kernel_size=3,
                                  padding=1)
        self.fpn_norm = get_norm(self.norm_type, self.encoder_channels)
        encoder_blocks = []
        for i in range(self.num_residual_blocks):
            dilation = self.block_dilations[i]
            encoder_blocks.append(
                Bottleneck(
                    self.encoder_channels,
                    self.block_mid_channels,
                    dilation=dilation,
                    norm_type=self.norm_type,
                    act_type=self.act_type
                )
            )
        self.dilated_encoder_blocks = nn.Sequential(*encoder_blocks)
​
    def _init_weight(self):
        c2_xavier_fill(self.lateral_conv)
        c2_xavier_fill(self.fpn_conv)
        for m in [self.lateral_norm, self.fpn_norm]:
            nn.init.constant_(m.weight, 1)
            nn.init.constant_(m.bias, 0)
        for m in self.dilated_encoder_blocks.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.normal_(m.weight, mean=0, std=0.01)
                if hasattr(m, 'bias') and m.bias is not None:
                    nn.init.constant_(m.bias, 0)
​
            if isinstance(m, (nn.GroupNorm, nn.BatchNorm2d, nn.SyncBatchNorm)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
​
    def forward(self, feature: torch.Tensor) -> torch.Tensor:
        out = self.lateral_norm(self.lateral_conv(feature))
        out = self.fpn_norm(self.fpn_conv(out))
        return self.dilated_encoder_blocks(out)

decoder

class Decoder(nn.Module):
    """
    Head Decoder for YOLOF.
​
    This module contains two types of components:
        - A classification head with two 3x3 convolutions and one
            classification 3x3 convolution
        - A regression head with four 3x3 convolutions, one regression 3x3
          convolution, and one implicit objectness 3x3 convolution
    """
​
    def __init__(self, cfg):
        super(Decoder, self).__init__()
        # fmt: off
        self.in_channels = cfg.MODEL.YOLOF.DECODER.IN_CHANNELS
        self.num_classes = cfg.MODEL.YOLOF.DECODER.NUM_CLASSES
        self.num_anchors = cfg.MODEL.YOLOF.DECODER.NUM_ANCHORS
        self.cls_num_convs = cfg.MODEL.YOLOF.DECODER.CLS_NUM_CONVS
        self.reg_num_convs = cfg.MODEL.YOLOF.DECODER.REG_NUM_CONVS
        self.norm_type = cfg.MODEL.YOLOF.DECODER.NORM
        self.act_type = cfg.MODEL.YOLOF.DECODER.ACTIVATION
        self.prior_prob = cfg.MODEL.YOLOF.DECODER.PRIOR_PROB
        # fmt: on
​
        self.INF = 1e8
        # init
        self._init_layers()
        self._init_weight()
​
    def _init_layers(self):
        cls_subnet = []
        bbox_subnet = []
        for i in range(self.cls_num_convs):
            cls_subnet.append(
                nn.Conv2d(self.in_channels,
                          self.in_channels,
                          kernel_size=3,
                          stride=1,
                          padding=1))
            cls_subnet.append(get_norm(self.norm_type, self.in_channels))
            cls_subnet.append(get_activation(self.act_type))
        for i in range(self.reg_num_convs):
            bbox_subnet.append(
                nn.Conv2d(self.in_channels,
                          self.in_channels,
                          kernel_size=3,
                          stride=1,
                          padding=1))
            bbox_subnet.append(get_norm(self.norm_type, self.in_channels))
            bbox_subnet.append(get_activation(self.act_type))
        self.cls_subnet = nn.Sequential(*cls_subnet)
        self.bbox_subnet = nn.Sequential(*bbox_subnet)
        self.cls_score = nn.Conv2d(self.in_channels,
                                   self.num_anchors * self.num_classes,
                                   kernel_size=3,
                                   stride=1,
                                   padding=1)
        self.bbox_pred = nn.Conv2d(self.in_channels,
                                   self.num_anchors * 4,
                                   kernel_size=3,
                                   stride=1,
                                   padding=1)
        self.object_pred = nn.Conv2d(self.in_channels,
                                     self.num_anchors,
                                     kernel_size=3,
                                     stride=1,
                                     padding=1)
​
    def _init_weight(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.normal_(m.weight, mean=0, std=0.01)
                if hasattr(m, 'bias') and m.bias is not None:
                    nn.init.constant_(m.bias, 0)
​
            if isinstance(m, (nn.GroupNorm, nn.BatchNorm2d, nn.SyncBatchNorm)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
​
        # Use prior in model initialization to improve stability
        bias_value = -math.log((1 - self.prior_prob) / self.prior_prob)
        torch.nn.init.constant_(self.cls_score.bias, bias_value)
​
    def forward(self,
                feature: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        cls_score = self.cls_score(self.cls_subnet(feature))
        N, _, H, W = cls_score.shape
        cls_score = cls_score.view(N, -1, self.num_classes, H, W)
​
        reg_feat = self.bbox_subnet(feature)
        bbox_reg = self.bbox_pred(reg_feat)
        objectness = self.object_pred(reg_feat)
​
        # implicit objectness
        objectness = objectness.view(N, -1, 1, H, W)
        normalized_cls_score = cls_score + objectness - torch.log(
            1. + torch.clamp(cls_score.exp(), max=self.INF) + torch.clamp(
                objectness.exp(), max=self.INF))
        normalized_cls_score = normalized_cls_score.view(N, -1, H, W)
        return normalized_cls_score, bbox_reg
ZF_YES
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CVPR 2021 | 没有FPN！中科院&旷视提出YOLOF：你只需看一层特征
阿木寺的博客
03-18 1280
没有FPN！更快更强，性能优于YOLOv4、DETR等网络，其中一版本性能44.3 mAP / 60 FPS，代码于12个小时前刚刚开源！ 注：文末附【目标检测】交流群 想看更多CVPR 2021论文和开源项目可以点击：CVPR2021-Papers-with-Code ​ You Only Look One-level Feature 作者单位：中科院, 国科大, 旷视科技 代码：https://github.com/megvii-model/YOLOF 论文下载链接：https://arxiv.org
You Only Look One-level Feature（YOLOF）
Suan2014的博客
03-23 406
paper code Motivation 目标检测中常用到特征金字塔（FPN），在各网络中证明FPN确实有效，通常认为其有效得益于两个方面：（1）多尺度特征融合：融合了多种高分辨率和低分辨率的特征获取到更好的特征表达；（2）分而治之：根据目标的大小在不同层进行目标检测。 目标检测的网络结构可以分为三大部分：backbone、encoder、decoder，如下所示： 对encoder设计如下结构Figure 1进行实验，验证FPN的有效性是得益于多特征融合还是分而治之 通过实验发现SiMo作为enc
[YOLOF] You Only Look One-level Feature (CVPR. 2021)
Ah丶Weii
03-21 1230
代码：https://github.com/megvii-model/YOLOF 文章目录1. Motivation2. Contribution3. Cost Analysis of MiMo Encoders4. Method4.1 Limited Scale Range4.2 Dilated Encoder4.3 Imbalance Problem on Positive Anchors4.4 Uniform Matching5. YOLOF6. Experiments6.1 Comparison..
YoloF you only look one level feature 详解
qq_38284961的博客
03-26 359
YOLOF 摘要 文中讨论FPN成功在于分而治之而不是特征融合。文中从另一个角度解决这个问题，只使用一层的特征信息。文中有两个主要因素扩张encoder、统一匹配。且608x608的图片在2080TI能够达到60fps。 为什么要去FPN, 因为造成显存冗余、检测器复杂、以及 降低推理速度。 对比flops（浮点运算数量）FPN有134G 和 一维特征6G. 显存冗余明显。推理速度为13FPS和34FPS对比。 但是一维特征会导致精度低，研究发现精度低的原因在于最后一层输出尺度小、以及单层anchor
yolov1、yolov2、yolov3、yolov4、yolov5、yolov6、yolov7等论文 1.zip
最新发布
07-03
5）You Only Look One-level Feature; 6)DetectoRS: Detecting Objects with Recursive Feature; 7)YOLOv6: A Single-Stage Object Detection Framework for Industrial Applications； 8）YOLOv7: Trainable bag-of...
yolov1、yolov2、yolov3、yolov4、yolov5、yolov6、yolov7等论文 .zip
07-03
5）You Only Look One-level Feature; 6)DetectoRS: Detecting Objects with Recursive Feature; 7)YOLOv6: A Single-Stage Object Detection Framework for Industrial Applications； 8）YOLOv7: Trainable bag-of...
yolov1、yolov2、yolov3、yolov4、yolov5、yolov6、yolov7等论文
04-28
5）You Only Look One-level Feature; 6)DetectoRS: Detecting Objects with Recursive Feature; 7)YOLOv6: A Single-Stage Object Detection Framework for Industrial Applications； 8）YOLOv7: Trainable bag-of...
php.ini-development
05-08
you may only use these constants *after* the line that loads the extension. ;;;;;;;;;;;;;;;;;;; ; About this file ; ;;;;;;;;;;;;;;;;;;; ; PHP comes packaged with two INI files. One that is ...
微软内部资料-SQL性能优化5
11-27
After the nonclustered key at the leaf level of the index is found, only one more page access is needed to find the data row. Searching for a single row using a nonclustered index is almost as ...
【YOLOF 解读】You Only Look One-level Feature（CVPR 2021）
不积跬步，无以至千里！
08-22 3389
本文发布于CVPR2021，作者分别来自中科院、国科大、旷视。本文最大的贡献在于指出了 FPN 中 divide and conquer 策略的重要性，并因此而提出了更加简单有效的基线 YOLOF。
论文阅读：You Only Look One-level Feature（YOLOF）
j879159541的博客
04-02 336
文章目录1、论文总述2、FPN的两大作用3、MiMo和SiMo结构的不同4、一个有争议的点5、topK的取值6、训练时的Other Details参考文献 1、论文总述 本篇论文针对FPN的作用进行了深入分析，认为主要有两个功能：特征融合和对不同尺度目标进行分而治之优化，然后作者发现这两个作用中比较重要的是分而治之思想，并不是特征融合，这就让人保持怀疑了。 作者分析完之后主要有两个工作：（1）去掉FPN，通过残差连接对两个不同感受野的feature map进行相加实现多种尺度感受野覆盖，详见论文中的fig
YOLOF：You Only Look One-level Feature
03-25 984
证明FPN的成功是得益于分而治之的策略，并非多尺度特征融合，融合带来的提升远不止带来的计算力收益高。相对的提出了代替方案YOLOF，只需要一层特征图，速度更快，且精度与FPN相匹配。
You Only Look One-level Feature论文阅读
Q1u1NG的博客
03-24 788
You Only Look One-level Feature论文阅读介绍贡献慨括相关工作MiMo的cost分析方法受限制的尺度范围positive anchors的不平衡YOLOF实验与DETR的比较与YOLOV4的比较消融实验错误分析结论 paper: https://arxiv.org/abs/2103.09460 code: https://github.com/megvii-model/YOLOF 介绍 FPN通过其多尺度融合和分而治之(多个输出)，能够大大提升检测器的精度； 作者将FPN看做
《You Only Look One-level Feature》论文阅读
qq_40269350的博客
08-12 707
文章下载： You Only Look One-level Feature.pdf 摘要 本篇论文重新讨论了特征金字塔网络（FPN）对于 one-stage 检测器的作用，并指出，在目标检测问题中，FPN的成功分治法（divide-and-conquer）而非多尺度特征融合。从优化的角度来讲，我们引入了一种替代方法来解决该问题，而不是采用复杂的特征金字塔 —— 仅仅使用 one-level 的特征来做检测。基于这种简单而又有效的方法，我们提出了 You Only Look One-Level Feat.
DCT-Mask(CVPR2021)核心代码解析
guhuoone的博客
05-11 1097
代码主要由两个重要组成部分，分别为dct_mask_head.py和mask_encoding.py dct_mask_head.py # dec_mask_head.py """ 类：MaskRCNNDCTHaed 方法： __init__()：初始化方法 from_config()：从配置文件中获取一些基本的配置信息 layers()：构建DCT-Mask的卷积层 forward(): 训练和测试内容 mask_rcnn_dct_loss()：dct损失 mask_rcnn_dct_inference(
you only look once
03-16
"你只需要看一次" (YOLO) 是一种物体检测算法。它提出了一种新的方法，使用卷积神经网络 (CNN) 在图像中识别和定位物体。YOLO 的优点在于它可以在实时的场景中使用，并且在识别速度和准确性上都表现良好。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值