mmdetection3.2.0之RetinaNet源码解读

毕设快快过

于 2024-01-12 20:18:24 发布

阅读量1.2k

点赞数 24

文章标签： python 深度学习人工智能机器学习

本文链接：https://blog.csdn.net/mengsheng12/article/details/135502460

版权

该片解读在官网的这篇文章的基础之上对细节进行补充，仅供自己学习使用，不足之处请在评论区指出。轻松掌握 MMDetection 中常用算法(一)：RetinaNet 及配置详解 - 知乎 (zhihu.com)

本文是结合上面官方提供的文章和b站噼里啪啦博主的讲解结合起来学习的。

解读总共包含两部分，第一部分是对代码含义解读，第二部分就是对代码debug进行调试，了解数据流。

本文不同于官方提供的解读文章共有两点：debug调试和3.2.0版本的代码位置说明。

1.RetinaNet网络结构图

该图片引用B站噼里啪啦博主。该网络的创新点是提出Focal Loss焦点损失函数。从而使得一阶段检测器的精度能够超过二阶段检测器。

1.retinanet整体网络结构图

2.retinanet分类回归分支图

2.RetinaNet代码详解

2.1Backbone

这里我选用的配置文件位置在configs/retinanet/retinanet_r18_fpn_1x_coco.py。配置文件的含义如下。

retinanet表示算法名称
r18表示骨干网络名
caffe和PyTorch是指Bottleneck模块的区别，省略情况下是PyTorch
fpn表示Neck模块采用了FPN结构
mstrain表示多尺度训练，一般对应pipeline中的resize类
1X表示1倍数的epoch训练，即12个epoch
coco表示在COCO数据集上训练

以Resnet18为例，骨干网络配置如下。

    backbone=dict(
#表示使用resnet18
        depth=18,
#表示固定stem+第一个stage的权重，不进行训练
        frozen_stages=1,
#使用pytorch提供的在imagenet上面训练过的权重作为预训练权重
        init_cfg=dict(checkpoint='torchvision://resnet18', type='Pretrained'),
#所有BN层的可学习参数都需要梯度更新
        norm_cfg=dict(requires_grad=True, type='BN'),
#backbone所有的BN层的均值和方差都直接采用全局预训练值，不进行更新
        norm_eval=True,
#Resnet系列包含stem+4个stage输出
        num_stages=4,
#表示四个stage的输出索引
        out_indices=(
            0,
            1,
            2,
            3,
        ),
#默认采用pytorch模式
        style='pytorch',
#骨架网络名
        type='ResNet'),

3.retinanet骨干网络配置

在训练过程中stem+第一个stage不进行训练即参数不更新。BN层的均值和方差不更新，但β和γ这些可学习参数进行更新。尽量不更改上面的设置，效果更稳定。

2.1.1out_indices

resnet提出了骨架网络设计范式即stem+ n个stage+cls head,其forward流程是stem->4个stage->分类head，stem的输出stride是4，而4个stage的输出stride是4，8，16，32。这里的stride指的是下采样率。因为retinanet后面需要接FPN，故需要输出4个尺度特征图，因此四个stage的索引都需要。

以下代码位置：mmdet/models/backbones/resnet.py的641行左右。简要代码如下

        for i, layer_name in enumerate(self.res_layers):
            res_layer = getattr(self, layer_name)
            x = res_layer(x)
#如果i在out_incices中才保留
            if i in self.out_indices:
                outs.append(x)
        return tuple(outs)

4.out_indices代码

首先由下图可以看出，该骨干网络由stem+4个layer和分类head构成，其中每个layer又包含2个basicblock，接下来debug看一下self的属性构成是否和分析一样。

5.resnet18网络结构图

按照以下操作可以查看backbone网络结构。

6.debug backbone

操作4及可以看到backbone网络构成和分析一致。

7.backbone 的调试结果图

接着继续往下debug。循环四轮后结果如下，可以看出此时已经将layer0~layer3的输出均已添加至outs列表中。

8.呼应图4所需的outs输出层

2.1.2frozen_stages

该参数表示你想冻结前几个stages的权重，Resnet结构包括stem+4个stage。

frozen_stages=-1,表示全部可学习。
frozen_stages=0,表示stem权重固定。
frozen_stages=1,表示stem+第一个stage权重固定
frozen_stages=2,表示stem和前两个stage权重固定

以下代码所在位置mmdet/models/backbones/resnet.py的613行左右。

#固定权重，需要两个步骤：1，设置eval模式； 2.requires_grad=False 
   def _freeze_stages(self):
        if self.frozen_stages >= 0:
#固定stem权重
            if self.deep_stem:
                self.stem.eval()
                for param in self.stem.parameters():
                    param.requires_grad = False
            #上面的if条件不懂，直接跳到这里
            else:
            #将stem中的BN层和卷积层都设置为eval模式
                self.norm1.eval()
            #遍历stem中的BN层和卷积层
                for m in [self.conv1, self.norm1]:
            #遍历stem中的BN层和卷积层的参数
                    for param in m.parameters():
            #设置上面遍历的参数不需要梯度更新
                        param.requires_grad = False
#固定stage权重
        for i in range(1, self.frozen_stages + 1):
            m = getattr(self, f'layer{i}')
            m.eval()
            for param in m.parameters():
                param.requires_grad = False

9.frozen_stages代码

（1）debug调试查看stem的权重如何固定

由图7我们可以看出stem的构成包含conv1+bn1+relu+maxpool。这里只需要更新stem中的conv1+bn1的参数即可。

由以下debug图得知，m参数遍历conv1+bn1两大层（不遍历里面的具体参数），当m遍历到conv1时，conv1内包含的参数如绿色箭头2所示。然后param再遍历conv1内的参数，如绿色箭头3所指。

10.stem权重固定数据流

（2）debug调试查看stage权重如何固定

由图7我们可知backbone由stem+4个layer+分类head构成,而每个layer又包含一个ResLayer，每个ResLayer又包含两个BasicBlock。理解这里的stage指的是layer，

在627行调试，可以看到m的结果如绿色箭头1，点击右侧的“视图”如绿色箭头2所示，页面就会呈现绿色箭头3的画面。debug调试后可以看出，m取出layer1的所有属性，而param则是依次取出绿色箭头所指的conv1->bn1->conv2...。

11.stage权重固定数据流

（3）train处的设置

需要特别注意的是：上述函数不能仅仅在类初始化的时候调用，因为在训练模式下，运行时候会调用model.train（）导致BN层又进入train模式，最终BN没有固定，故需要在resnet中重写train方法。

以下代码的位置mmdet/models/backbones/resnet.py的648行左右。

    def train(self, mode=True):
        """Convert the model into training mode while keep normalization layer
        freezed."""
#这行代码会导致BN进入train模式
        super(ResNet, self).train(mode)
#再次调用，固定stem和前n个stage的BN
        self._freeze_stages()
#如果所有的BN都采用全局均值和方差，则需要对整个网络的BN都开启eval模式
        if mode and self.norm_eval:
            for m in self.modules():
                # trick: eval have effect on BatchNorm only
                if isinstance(m, _BatchNorm):
                    m.eval()

12.train处设置BN冻结

2.1.3norm_cfg和norm_eval

norm_cfg表示所采用的归一化算子，一般是BN或者GN，而requires_grad表示该算子是否需要梯度，也就是是否进行参数更新，而布尔参数norm_eval是用于控制整个骨架网络的归一化算子是否需要变成eval模式。

RetinaNet中用法是norm_cfg=dict（type='BN',requires_grad=True),表示通过Registry模式实例化BN类，并且设置为参数可学习。在MMdetection中会常看到通过字典配置方式来实例化某个类的做法，底层是采用了装饰器模式进行构建，最大好处是扩展性极强，类和类之间的耦合度降低。

2.1.4style

style='caffe'和style='pytorch'的差别就在Bottleneck模块中

13.Bottleneck模块图

Bottleneck是标准的1X1-3X3-1X1结构，考虑stride=2下采样的场景，caffe模式下，stride参数放置在第一个1X1卷积上，而Pytorch模式下，strde放在第二个3X3卷积上。

以下代码的位置：mmdet/models/backbones/resnet.py的154行左右。

        if self.style == 'pytorch':
            self.conv1_stride = 1
            self.conv2_stride = stride
        else:
            self.conv1_stride = stride
            self.conv2_stride = 1

14 .style代码

出现两种模式的原因是因为 ResNet 本身就有不同的实现，torchvision 的 resnet 和早期 release 的 resnet 版本不一样，使得目标检测框架在使用 Backbone 的时候有两种不同的配置，不过目前新网络都是采用 PyTorch 模式。

2.2Neck

Neck模块即为FPN，其简要结构如下所示。

15.FPN简要结构图

MMdetection中对应的配置为：

    neck=dict(
#额外输出层的特征图来源
        add_extra_convs='on_input',
#resnet模块输出的4个尺度特征图通道数
        in_channels=[
            64,
            128,
            256,
            512,
        ],
#FPN输出特征图个数
        num_outs=5,
#FPN输出的每个尺度特征图通道数
        out_channels=256,
#从输入多尺度特征图的第几个开始计算
        start_level=1,
        type='FPN')

16.neck配置文件

前面说过 ResNet 输出 4 个不同尺度特征图 (c2,c3,c4,c5)，stride 分别是 (4,8,16,32)，通道数为 (256,512,1024,2048),通过配置文件我们可以知道：

start_level=1 说明虽然输入是 4 个特征图，但是实际上 FPN 中仅仅用了后面三个，可见图一，只用了C3,C4,C5。
num_outs=5 说明 FPN 模块虽然是接收 3 个特征图，但是输出 5 个特征图
add_extra_convs='on_input' 说明额外输出的 2 个特征图的来源是骨架网络输出，而不是 FPN 层本身输出又作为后面层的输入
out_channels=256 说明了 5 个输出特征图的通道数都是 256。

总结：FPN 模块接收 c3, c4, c5 三个特征图，输出 P3-P7 五个特征图，通道数都是 256, stride 为 (8,16,32,64,128)，其中大 stride (特征图小)用于检测大物体，小 stride (特征图大)用于检测小物体。

2.3Head

Head的结构图可参见图2。

RetinaNet的Head包括分类和检测两个分支，且每个分支都包括4个卷积层，不进行参数共享，分类Head输出通道是num_class*K,检测head输出通道是4*K，K是anchor个数，虽然每个Head的分类和回归分支权重不共享，但5个输出特征图的Head模块权重是共享的。

其完整配置如下：

    bbox_head=dict(
        anchor_generator=dict(
            octave_base_scale=4,
            ratios=[
                0.5,
                1.0,
                2.0,
            ],
            scales_per_octave=3,
            strides=[
                8,
                16,
                32,
                64,
                128,
            ],
            type='AnchorGenerator'),
        bbox_coder=dict(
            target_means=[
                0.0,
                0.0,
                0.0,
                0.0,
            ],
            target_stds=[
                1.0,
                1.0,
                1.0,
                1.0,
            ],
            type='DeltaXYWHBBoxCoder'),
#中间特征图通道数
        feat_channels=256,
#FPN层输出特征图通道数
        in_channels=256,
        loss_bbox=dict(loss_weight=1.0, type='L1Loss'),
        loss_cls=dict(
            alpha=0.25,
            gamma=2.0,
            loss_weight=1.0,
            type='FocalLoss',
            use_sigmoid=True),
#自己数据集类别个数
        num_classes=4,
#每个分支堆叠4层卷积
        stacked_convs=4,
        type='RetinaHead'),

17.head配置文件

2.3.1 head网络构建

以下代码位置mmdet/models/dense_heads/retina_head.py的64行左右。以下代码结合图2 和debug调试即可读懂。

    def _init_layers(self):
        """Initialize layers of the head."""
        self.relu = nn.ReLU(inplace=True)
        self.cls_convs = nn.ModuleList()
        self.reg_convs = nn.ModuleList()
        in_channels = self.in_channels
        for i in range(self.stacked_convs):
            self.cls_convs.append(
                ConvModule(
                    in_channels,
                    self.feat_channels,
                    3,
                    stride=1,
                    padding=1,
                    conv_cfg=self.conv_cfg,
                    norm_cfg=self.norm_cfg))
            self.reg_convs.append(
                ConvModule(
                    in_channels,
                    self.feat_channels,
                    3,
                    stride=1,
                    padding=1,
                    conv_cfg=self.conv_cfg,
                    norm_cfg=self.norm_cfg))
            in_channels = self.feat_channels
        self.retina_cls = nn.Conv2d(
            in_channels,
            self.num_base_priors * self.cls_out_channels,
            3,
            padding=1)
        reg_dim = self.bbox_coder.encode_size
        self.retina_reg = nn.Conv2d(
            in_channels, self.num_base_priors * reg_dim, 3, padding=1)

18.head层构建代码

在下图的位置处调试，

19.head层构建代码调试点

如图20可以看出，此时代码仅仅运行到64行，所以head内部的结构并没有堆叠的4个卷积快。

20.还未构建卷积块时head的网络结构

由图21可以看出，随着代码的一行又一行的运行，head的内部结构正在逐步增添新的子模块。

21.构建了分类和回归分支的head内部结构

由图22可以得知，此时的head内部已经是分类和回归分支上分别堆叠了4个卷积块。

22.构建完毕后的head内部结构

2.3.2单张特征图的forward流程

以下代码的位置：mmdet/models/dense_heads/retina_head.py的112行左右。

#x是p3-p7中的某个特征图
        cls_feat = x
        reg_feat = x
        #4层不共享卷积参数
        for cls_conv in self.cls_convs:
            cls_feat = cls_conv(cls_feat)
        for reg_conv in self.reg_convs:
            reg_feat = reg_conv(reg_feat)
#输出特征图
        cls_score = self.retina_cls(cls_feat)
        bbox_pred = self.retina_reg(reg_feat)
        return cls_score, bbox_pred

23.单张图forward代码

debug后的得分矩阵如绿色箭头所示。

24.单张图forward调试

2.4BBox Assigner

2.4.1AnchorGeneratior

RetinaNet属于Anchor-based算法，在运行bbox属性分配前需要得到每个输出特征图位置的anchor列表，故在分析BBox Assigner前，需要先详细说明下anchor生成过程，其配置文件如下:

        anchor_generator=dict(
#特征图anchor的base scale，值越大，所有的anchor的尺度会越大
            octave_base_scale=4,
#每个特征图有3个高宽比例
            ratios=[
                0.5,
                1.0,
                2.0,
            ],
#每个特征图有3个尺度，octave_base_scaleXstridesX(2**0, 2**(1/3), 2**(2/3))
            scales_per_octave=3,
#特征图对应的stride，必须与特征图stride一致，不可以随意更改。
            strides=[
                8,
                16,
                32,
                64,
                128,
            ],
            type='AnchorGenerator'),

25.anchor Generator配置

从上面配置可以看出：RetinaNet一共5个输出特征图，每个特征图上有3种尺度和3种宽高比，每个位置（每个像素）一共9个anchor，并且通过octave_base_scale参数来控制全局anchor的base scales，如果自定义数据集中普遍都是大物体或者小物体，则可以修改octave_base_scale参数。

（1）先对单个位置（0，0）生成base anchors

以下代码所在位置：mmdet/models/task_modules/prior_generators/anchor_generator.py的715行左右。

        w = base_size
        h = base_size
#检查center变量是否为None，是则计算中心点，否则采用所传中心点
        if center is None:
            x_center = self.center_offset * (w - 1)
            y_center = self.center_offset * (h - 1)
        else:
            x_center, y_center = center
#计算特征图相对于原图的高宽比例，可以理解为特征图的缩小倍数
        h_ratios = torch.sqrt(ratios)
        w_ratios = 1 / h_ratios
#base_size 乘上宽高比例乘上尺度，就可以得到 n 个 anchor 的原图尺度wh值
        if self.scale_major:
            ws = (w * w_ratios[:, None] * scales[None, :]).view(-1)
            hs = (h * h_ratios[:, None] * scales[None, :]).view(-1)
        else:
            ws = (w * scales[:, None] * w_ratios[None, :]).view(-1)
            hs = (h * scales[:, None] * h_ratios[None, :]).view(-1)

        # use float anchor and the anchor's center is aligned with the
        # pixel center
# 得到 x1y1（左上角坐标）x2y2（右下角坐标） 格式的 base_anchor 坐标值
        base_anchors = [
            x_center - 0.5 * (ws - 1), y_center - 0.5 * (hs - 1),
            x_center + 0.5 * (ws - 1), y_center + 0.5 * (hs - 1)
        ]
        base_anchors = torch.stack(base_anchors, dim=-1).round()

26.base_anchor生成代码

（2）利用输入特征图尺寸加上base anchors,得到每个特征图位置的对于原图的anchors

以下代码位置：mmdet/models/task_modules/prior_generators/anchor_generator.py的398行左右。

        #从特征图的大小中获取高度和宽度。
        feat_h, feat_w = featmap_size
        #根据特征图的宽度和高度以及步长计算出在原图上的x轴和y轴方向上的偏移量
        shift_x = torch.arange(0, feat_w, device=device) * stride[0]
        shift_y = torch.arange(0, feat_h, device=device) * stride[1]
        #使用_meshgrid方法生成一个网格，该网格的每个点的坐标都是其在x轴和y轴方向上的偏移量。
        shift_xx, shift_yy = self._meshgrid(shift_x, shift_y)
        #将x轴和y轴方向上的偏移量堆叠在一起，形成一个形状为(K, 1, 4)的张量，其中K是锚点的数量。
        shifts = torch.stack([shift_xx, shift_yy, shift_xx, shift_yy], dim=-1)
        #将偏移量张量的类型设置为与基础锚点相同。
        shifts = shifts.type_as(base_anchors)
        # first feat_w elements correspond to the first row of shifts
        # add A anchors (1, A, 4) to K shifts (K, 1, 4) to get
        # shifted anchors (K, A, 4), reshape to (K*A, 4)
        #将基础锚点和偏移量相加，得到所有可能的锚点。
        all_anchors = base_anchors[None, :, :] + shifts[:, None, :]
        #将所有可能的锚点展平成一维张量
        all_anchors = all_anchors.view(-1, 4)
        # first A rows correspond to A anchors of (0, 0) in feature map,
        # then (0, 1), (0, 2), ...
        return all_anchors

27.映射到原图上的anchor

简单来说就是：假设一共m个输出特征图

遍历m个输出特征图，在每个特征图的（0，0）或者说原图的（0，0）坐标位置生成base_anchors,注意base_anchors不是特征图尺寸，而是原图尺寸。
遍历m个输出特征图中每个特征图上每个坐标点，将其映射到原图坐标上
原图坐标加上base_anchors，就可以得到特征图每个位置的对应到原图尺度的anchor列表，anchor列表长度为m。

2.4.2 BBox Assigner

计算得到输出特征图上面每个点对应原图anchor坐标后，就可以和gt信息计算每个anchor的正负样本属性，对应配置如下

        assigner=dict(
        #忽略bboxes的阈值，-1表示不忽略
            ignore_iof_thr=-1,
        #正样本阈值下限
            min_pos_iou=0,
        #负样本阈值
            neg_iou_thr=0.4,
        #正样本阈值
            pos_iou_thr=0.5,
        #最大iou原则分配器
            type='MaxIoUAssigner'),

28.bbox assigner配置

（1）初始化所有anchor为忽略样本

假设所有输出特征的所有anchor总数一共n个，对应某张图片中gt bbox个数为m，首先初始化长度为n的assigned_gt_inds，全部赋值为-1，表示当前全部设置为忽略样本。

以下代码位置：mmdet/models/task_modules/assigners/max_iou_assigner.py的257行左右。

        # 1. assign -1 by default
        assigned_gt_inds = overlaps.new_full((num_bboxes, ),
                                             -1,
                                             dtype=torch.long)

29.初始anchor索引代码

由下图可以看出，该张图片的所有特征图的anchor一共有193374个，gt一共有两个。

30.debug图片anchor数量

由下图可以看出已经将该张图片的193374个anchor的对应索引全部赋值为-1。

31.初始anchor索引值为-1

（2）计算背景样本

将每个anchor与所有gt bbox计算iou，找到最大iou，如果该iou小于neg_iou_thr或者在背景样本阈值范围内，则该anchor对应索引位置的assigned_gt_inds设置为0，表示负样本（背景样本）

以下代码位置：mmdet/models/task_modules/assigners/max_iou_assigner.py的278行左右。

        # for each anchor, which gt best overlaps with it
        # for each anchor, the max iou of all gts
        max_overlaps, argmax_overlaps = overlaps.max(dim=0)
        # for each gt, which anchor best overlaps with it
        # for each gt, the max iou of all proposals
        gt_max_overlaps, gt_argmax_overlaps = overlaps.max(dim=1)

        # 2. assign negative: below
        # the negative inds are set to be 0
        if isinstance(self.neg_iou_thr, float):
            assigned_gt_inds[(max_overlaps >= 0)
                             & (max_overlaps < self.neg_iou_thr)] = 0
        elif isinstance(self.neg_iou_thr, tuple):
            assert len(self.neg_iou_thr) == 2
        #可以设置一个范围
            assigned_gt_inds[(max_overlaps >= self.neg_iou_thr[0])
                             & (max_overlaps < self.neg_iou_thr[1])] = 0

32.计算背景样本代码实现

（3）计算高质量正样本

将每个anchor和所有的gt bbox计算iou，找出最大iou，如果当前iou大于等于pos_iou_thr，则设置该anchor对应所有的assigner_gt_inds设置为当前匹配gt bbox的编号+1（后面会减掉1），表示该anchor负责预测该gt bbox,且是高质量anchor,之所以要加一，是为了区分背景样本（背景样本的assigned_gt_inds值为0），这里建议看b站霹雳巴拉博主讲的faster rcnn的那一块。

以下代码位置：mmdet/models/task_modules/assigners/max_iou_assigner.py的294行左右。

        pos_inds = max_overlaps >= self.pos_iou_thr
        assigned_gt_inds[pos_inds] = argmax_overlaps[pos_inds] + 1

（4）适当增加更多正样本

在第三步计算高质量正样本中可能会出现某些 gt bbox 没有分配给任何一个 anchor (由于 iou 低于 pos_iou_thr)，导致该 gt bbox 不被认为是前景物体，此时可以通过 self.match_low_quality=True 配置进行补充正样本。

对于每个 gt bbox 需要找出和其最大 iou 的 anchor 索引，如果其 iou 大于 min_pos_iou，则将该 anchor 对应索引的 assigned_gt_inds 设置为正样本，表示该 anchor 负责预测对应的 gt bbox。通过本步骤，可以最大程度保证每个 gt bbox 都有相应的 anchor 负责预测，但是如果其最大 iou 值还是小于 min_pos_iou，则依然不被认为是前景物体。

代码位置：mmdet/models/task_modules/assigners/max_iou_assigner.py的297行。

        if self.match_low_quality:
            # Low-quality matching will overwrite the assigned_gt_inds assigned
            # in Step 3. Thus, the assigned gt might not be the best one for
            # prediction.
            # For example, if bbox A has 0.9 and 0.8 iou with GT bbox 1 & 2,
            # bbox 1 will be assigned as the best target for bbox A in step 3.
            # However, if GT bbox 2's gt_argmax_overlaps = A, bbox A's
            # assigned_gt_inds will be overwritten to be bbox 2.
            # This might be the reason that it is not used in ROI Heads.
            for i in range(num_gts):
                if gt_max_overlaps[i] >= self.min_pos_iou:
                    if self.gt_max_assign_all:
                        max_iou_inds = overlaps[i, :] == gt_max_overlaps[i]
                        assigned_gt_inds[max_iou_inds] = i + 1
                    else:
                        assigned_gt_inds[gt_argmax_overlaps[i]] = i + 1

此时可以可以得到如下总结：

如果 anchor 和所有 gt bbox 的最大 iou 值小于 0.4，那么该 anchor 就是背景样本
如果 anchor 和所有 gt bbox 的最大 iou 值大于等于 0.5，那么该 anchor 就是高质量正样本
如果 gt bbox 和所有 anchor 的最大 iou 值大于等于 0(可以看出每个 gt bbox 都一定有至少一个 anchor 匹配)，那么该 gt bbox 所对应的 anchor 也是正样本
其余样本全部为忽略样本即 anchor 和所有 gt bbox 的最大 iou 值处于 [0.4,0.5) 区间的 anchor 为忽略样本，不计算 loss

2.5BBox Encoder Decoder

在anchor-based算法中，为了利用anchor信息进行更快更好的收敛，一般会对head输出的 bbox分支4个值进行编解码操作，作用有两个：

1.更好的平衡分类和回归loss，以及平衡bbox四个预测值的loss

2.训练过程中引入anchor信息，加快收敛。

RetinaNet采用的编解码函数是主流的DeltaXYWHBBoxCoder,其配置如下：

        bbox_coder=dict(
            target_means=[
                0.0,
                0.0,
                0.0,
                0.0,
            ],
            target_stds=[
                1.0,
                1.0,
                1.0,
                1.0,
            ],
            type='DeltaXYWHBBoxCoder'),

编解码具体步骤和公式参考官网轻松掌握 MMDetection 中常用算法(一)：RetinaNet 及配置详解 - 知乎 (zhihu.com)

这段设计的代码位置：mmdet/models/task_modules/coders/delta_xywh_bbox_coder.py

2.6Loss

依然是参考原文。同时推荐去b站噼里啪啦博主的yolov3第三小节的讲解处观看理解。

2.7测试流程

对应的配置如下所示。更多调试过程和faster-rcnn差不多。mmdetection3.2.0之faster-rcnn源码解读-CSDN博客

    test_cfg=dict(
#最终输出的每张图片最多bbox个数
        max_per_img=100,
#过滤掉最小的bbpx尺寸
        min_bbox_size=0,
#nms方法和nms阈值
        nms=dict(iou_threshold=0.5, type='nms'),
#nms前每个输出层最多保留1K个proposal
        nms_pre=1000,
#分值阈值
        score_thr=0.05),

毕设快快过

关注

24
点赞
踩
25

收藏

觉得还不错? 一键收藏
1
评论
mmdetection3.2.0之RetinaNet源码解读

该片解读在官网的这篇文章的基础之上对细节进行补充，使用，不足之处请在评论区指出。本文是结合上面官方提供的文章和b站噼里啪啦博主的讲解结合起来学习的。解读总共包含两部分，第一部分是对代码含义解读，第二部分就是对代码debug进行调试，了解数据流。本文和的说明。
复制链接

扫一扫