0
0

SOLOv2（NeurIPS 2020）论文与代码解读

paper：SOLOv2: Dynamic and Fast Instance Segmentation

official implementation：AdelaiDet/configs/SOLOv2/README.md at master · aim-uofa/AdelaiDet · GitHub

third-party implementation：mmdetection/mmdet/models/dense_heads/solov2_head.py at main · open-mmlab/mmdetection · GitHub

存在的问题

作者指出在SOLO中，有三个主要的瓶颈限制了它的性能：

  1. 低效的mask表示和学习
  2. 没有足够大的分辨率来进行更精细的mask预测
  3. mask NMS速度慢

创新点

针对上述三个问题，本文提出了对应的解决方法，并将新的框架称为SOLO v2：

  • 动态实例分割：SOLOv2将掩码学习过程分为卷积核学习和特征学习。通过动态预测卷积核，掩码生成变得更灵活和高效。
  • 掩码核（Mask Kernel）：在每个特征金字塔级别上预测掩码核，采用坐标卷积（CoordConv）添加空间功能。输出的卷积核权重根据位置进行预测。
  • 掩码特征（Mask Feature）：统一预测所有FPN级别的掩码特征表示，通过特征金字塔融合构建高分辨率的掩码特征表示。
  • Matrix NMS：引入矩阵NMS，通过并行矩阵操作一次性进行NMS，减少重复预测，提高速度和精度。

方法介绍

在SOLO v1中，输入图片被划分为 (S\times S) 个网格，如果一个目标的中心点落入某个网格中，该网格负责该目标的binary mask的预测。因此模型一共输出 (S^2) 个mask，表示为 (M\in \mathbb{R}^{H\times W\times S^2})。第 (k) 个通道负责分割位置 ((i,j)) 的实例，其中 (k=i\cdot S+j)，如图2(a)所示。

这种范式可以优雅地生成实例分割结果，但有三个瓶颈限制了其性能：a）低效的掩码表示和学习。预测具有 (S^2) 个通道的输出张量 (M) 需要大量的内存和计算。此外，由于不同FPN level的 (S) 不同，每个level的最后一层是单独学习的不共享，这就导致了训练效率低下。b）不准确的mask预测。更精细的预测需要高分辨率的mask来处理物体边缘上的细节。但大分辨率大大增加了计算成本。c）maks NMS速度慢。和box NMS相比，mask NMS需要更多的处理时间导致开销更大。

Dynamic Instance Segmentation

在SOLO v1中，为了生成对应 (S\times S) 个网格的具有 (S^2) 个通道的instance mask，最后一层以FPN一个level的特征 (F\in \mathbb{R}^{H\times W\times E}) 为输入，并通过一个卷积层得到 (S^2) 通道的输出

其中 (G_{i,j}\in \mathbb{R}^{1\times 1\times E}) 是卷积核，(M_{i,j}\in \mathbb{R}^{H\times W}) 是最终的mask只包含一个instance其中心在位置 ((i,j))。

换句话说我们需要两个输入 (F) 和 (G) 来生成最终的掩码 (M)。SOLO输出整个 (M) 用于训练和推理，(M) 非常大，直接预测 (M) 对于内存和计算效率都是低下的。在大多数情况下，目标在图像中是稀疏的，因此 (M) 冗余的，因为在一次推理中 (S^2) 个kernel中只有一小部分起作用。

因此本文提出分别学习 (F) 和 (G)，这样就可以从预测的 (S^2) 个kernel中选择有效的然后动态地执行卷积。

Mask Kernel G

给定backbone和FPN，我们在每个pyramid level预测mask kernel。首先将输入特征 (F_I\in\mathbb{R}^{H_I\times W_I\times C}) resize成shape (S\times S\times C)，然后4个卷积和最后一个 (3\times 3\times D) 的卷积用来生成kernel (G)。其中和SOLO一样通过CoordConv向输入特征中添加坐标信息。

对于每个网格，kernel branch预测 (D) 维的输出作为卷积核参数 。(D) 是参数数量，对于输入通道数为 (E) 的1x1卷积 (D) 等于 (E)，对于3x3卷积 (D) 等于 (9E)。

Mask Feature F

由于mask feature和mask kernel解耦了是分别预测的，有两种方法构建mask feature。一是把它和kernel branch一起放到head部分，这意味着我们对每个FPN level分别预测mask feature。另一种是对所有的FPN level预测一个统一的mask representation，作者通过实验比较了两者的效果，最终决定采用后者。

为了学习一个统一的高分辨率的mask特征表示，作者应用了特征金字塔融合。在若干3x3卷积、group norm、ReLU和2x的上采样后，P2到P5的FPN特征融合成一个单独的1/4大小的特征。在elment-wise求和之后最后一层由一个1x1卷积、group norm和ReLU组成。

Matrix NMS

Matrix NMS的具体介绍可参考Fast NMS和Matrix NMS解读-CSDN博客。

代码解析

这里以mmdetection中的实现为例讲解一下代码。输入shape=(1, 3, 736, 1344)，其中batch_size=1。然后进入solov2_head.py中的forward函数，这里输入x就是经过backbone和neck后的输出，是一个列表，包含5个FPN level的输出特征。代码如下

  1.     def forward(self, x):
  2.         """Forward features from the upstream network.
  4.         Args:
  5.             x (tuple[Tensor]): Features from the upstream network, each is
  6.                 a 4D-tensor.
  8.         Returns:
  9.             tuple: A tuple of classification scores, mask prediction,
  10.             and mask features.
  12.                 - mlvl_kernel_preds (list[Tensor]): Multi-level dynamic kernel
  13.                   prediction. The kernel is used to generate instance
  14.                   segmentation masks by dynamic convolution. Each element in
  15.                   the list has shape
  16.                   (batch_size, kernel_out_channels, num_grids, num_grids).
  17.                 - mlvl_cls_preds (list[Tensor]): Multi-level scores. Each
  18.                   element in the list has shape
  19.                   (batch_size, num_classes, num_grids, num_grids).
  20.                 - mask_feats (Tensor): Unified mask feature map used to
  21.                   generate instance segmentation masks by dynamic convolution.
  22.                   Has shape (batch_size, mask_out_channels, h, w).
  23.         """
  24.         assert len(x) == self.num_levels
  25.         # [(1,256,184,336),
  26.         #  (1,256,92,168),
  27.         #  (1,256,46,84),
  28.         #  (1,256,23,42),
  29.         #  (1,256,12,21)]
  30.         mask_feats = self.mask_feature_head(x)  # (1,256,184,336)
  31.         ins_kernel_feats = self.resize_feats(x)
  32.         # [(1,256,92,168),
  33.         #  (1,256,92,168),
  34.         #  (1,256,46,84),
  35.         #  (1,256,23,42),
  36.         #  (1,256,23,42)]
  37.         mlvl_kernel_preds = []
  38.         mlvl_cls_preds = []
  39.         for i in range(self.num_levels):
  40.             ins_kernel_feat = ins_kernel_feats[i]
  41.             # ins branch
  42.             # concat coord
  43.             coord_feat = generate_coordinate(ins_kernel_feat.size(),
  44.                                              ins_kernel_feat.device)
  45.             ins_kernel_feat = torch.cat([ins_kernel_feat, coord_feat], 1)  # (1,256,92,168), (1,2,92,168) -> (1,258,92,168)
  47.             # kernel branch
  48.             kernel_feat = ins_kernel_feat  # (1,258,92,168)
  49.             kernel_feat = F.interpolate(
  50.                 kernel_feat,
  51.                 size=self.num_grids[i],
  52.                 mode='bilinear',
  53.                 align_corners=False)  # (1,258,40,40)
  55.             cate_feat = kernel_feat[:, :-2, :, :]  # (1,256,40,40)
  57.             kernel_feat = kernel_feat.contiguous()
  58.             for i, kernel_conv in enumerate(self.kernel_convs):  # 所有level共享kernel_convs
  59.                 kernel_feat = kernel_conv(kernel_feat)  # (1,512,40,40)
  61.             kernel_pred = self.conv_kernel(kernel_feat)  # (1,256,40,40)
  63.             # cate branch
  64.             cate_feat = cate_feat.contiguous()
  65.             for i, cls_conv in enumerate(self.cls_convs):
  66.                 cate_feat = cls_conv(cate_feat)  # (1,512,40,40)
  67.             cate_pred = self.conv_cls(cate_feat)  # (1,1,40,40)
  69.             mlvl_kernel_preds.append(kernel_pred)
  70.             mlvl_cls_preds.append(cate_pred)
  72.         # [(1,256,40,40),
  73.         #  (1,256,36,36),
  74.         #  (1,256,24,24),
  75.         #  (1,256,16,16),
  76.         #  (1,256,12,12)]
  77.         ##########
  78.         # [(1,1,40,40),
  79.         #  (1,1,36,36),
  80.         #  (1,1,24,24),
  81.         #  (1,1,16,16),
  82.         #  (1,1,12,12)]
  83.         ##########
  84.         # (1,256,184,336)
  85.         return mlvl_kernel_preds, mlvl_cls_preds, mask_feats

其中

  1. self.mask_feature_head

就是上面提到的对不同的PFN level特征进行融合得到一个统一特征，这里不贴原始代码了，直接print出module的结构如下。包含0-3共4个module，即不对最小的FPN特征处理。可以看到对于最大的特征就是一个简单的conv-gn-relu，对于1/2大的特征是一个conv-gn-relu再加一个2x上采样然后与第一层的特征进行element-wise相加，对于1/4大的特征则进行两次2x上采样，每个上采样前都是conv-gn-relu，而对于最后一个1/8大的特征则是经过三次2x上采样，注意最后一个module第一层卷积的输入通道数为258是因为通过coordconv加上了xy坐标信息。将4个不同大小的FPN level的特征通过上采样得到相同大小的特征后相加求和，最后通过一个1x1 conv得到输出。

  1. MaskFeatModule(
  2.   (convs_all_levels): ModuleList(
  3.     (0): Sequential(
  4.       (conv0): ConvModule(
  5.         (conv): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  6.         (gn): GroupNorm(32, 128, eps=1e-05, affine=True)
  7.         (activate): ReLU()
  8.       )
  9.     )
  10.     (1): Sequential(
  11.       (conv0): ConvModule(
  12.         (conv): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  13.         (gn): GroupNorm(32, 128, eps=1e-05, affine=True)
  14.         (activate): ReLU()
  15.       )
  16.       (upsample0): Upsample(scale_factor=2.0, mode=bilinear)
  17.     )
  18.     (2): Sequential(
  19.       (conv0): ConvModule(
  20.         (conv): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  21.         (gn): GroupNorm(32, 128, eps=1e-05, affine=True)
  22.         (activate): ReLU()
  23.       )
  24.       (upsample0): Upsample(scale_factor=2.0, mode=bilinear)
  25.       (conv1): ConvModule(
  26.         (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  27.         (gn): GroupNorm(32, 128, eps=1e-05, affine=True)
  28.         (activate): ReLU()
  29.       )
  30.       (upsample1): Upsample(scale_factor=2.0, mode=bilinear)
  31.     )
  32.     (3): Sequential(
  33.       (conv0): ConvModule(
  34.         (conv): Conv2d(258, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  35.         (gn): GroupNorm(32, 128, eps=1e-05, affine=True)
  36.         (activate): ReLU()
  37.       )
  38.       (upsample0): Upsample(scale_factor=2.0, mode=bilinear)
  39.       (conv1): ConvModule(
  40.         (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  41.         (gn): GroupNorm(32, 128, eps=1e-05, affine=True)
  42.         (activate): ReLU()
  43.       )
  44.       (upsample1): Upsample(scale_factor=2.0, mode=bilinear)
  45.       (conv2): ConvModule(
  46.         (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  47.         (gn): GroupNorm(32, 128, eps=1e-05, affine=True)
  48.         (activate): ReLU()
  49.       )
  50.       (upsample2): Upsample(scale_factor=2.0, mode=bilinear)
  51.     )
  52.   )
  53.   (conv_pred): ConvModule(
  54.     (conv): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
  55.     (gn): GroupNorm(32, 256, eps=1e-05, affine=True)
  56.     (activate): ReLU(inplace=True)
  57.   )
  58. )

再看回forward函数，接下来

  1. self.resize_feats

对FPN最大的特征下采样2x对最小的特征上采样2x，和SOLOv1一样。然后进入kernel branch，这里的输入是每个level的特征，且都concat了归一化坐标，然后通过插值F.interpolate resize到 (S^2) 大小。然后

  1. self.kernel_convs

是四层卷积，最后通过

  1. self.conv_kernel

得到卷积核的参数，这里self.kernel_convs和self.conv_kernel对不同level的特征都是共享的，self.conv_kernel的输出为256，表示卷积核的输入通道数为256，大小为1x1。这样就得到了mask feat和mask kernel。

然后看函数

  1. loss_by_feat

，其中根据模型输出和ground truth计算损失。这里只看下将mask_feat和mask kernel相乘得到最终预测mask的代码如下，这里卷积核本来的个数应该是 (S^2)，但在label assignment过程中根据gt的中心点落入的grid和以及这一层level负责预测的实例大小范围得到这一层level的正样本个数为8，因此根据对应的正样本index提取出有用的8个卷积核，然后对mask_feat进行卷积得到8个实例分割的binary mask。

  1. img_lvl_mask_pred = F.conv2d(
  2.     img_mask_feats,  # (1,256,184,336)
  3.     img_lvl_pos_kernel_pred.permute(1, 0).view(
  4.         num_kernel, -1, self.dynamic_conv_size,
  5.         self.dynamic_conv_size),  # (256,8)->(8,256,1,1)
  6.     stride=1).view(-1, h, w)  # (1,8,184,336)->(8,184,336)
  7. # 和v1的主要区别就在这,这里只有8个grid负责检测目标，因此只产生8个mask，而不是像v1里所有grid都生成一个mask有冗余

实验结果

在COCO测试集上和其它实例分割SOTA方法的性能对比如表1所示，可以看到SOLOv2超越了SOLOv1和其它方法。

精度-速度的对比如图1所示，可以看到SOLOv2的精度-速度trade-off是最优的。

标签： 深度学习 人工智能 计算机视觉
本文转载自: https://blog.csdn.net/ooooocj/article/details/140995320
版权归原作者 00000cj 所有， 如有侵权，请联系我们删除。
登录后发布评论

“SOLOv2（NeurIPS 2020）论文与代码解读”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？