mmcv-full support

Author: jbwang1997

README.md

@@ -30,6 +30,7 @@ This project is released under the [Apache 2.0 license](LICENSE).
 
 ## Update
 
+- (**2021-11-29**) Discard mmcv-0.6.2 and support mmcv-full.
 - (**2021-09-18**) Implement [Double Head OBB](configs/obb/double_heads_obb) in the OBBDetection.
 - (**2021-09-01**) Implement [FCOS OBB](configs/obb/fcos_obb) in the OBBDetection.
 - (**2021-08-21**) Reimplement the [PolyIoULoss](configs/obb/poly_iou_loss).

docs/install.md

@@ -7,7 +7,7 @@
 - PyTorch 1.3+
 - CUDA 9.2+ (If you build PyTorch from source, CUDA 9.0 is also compatible)
 - GCC 5+
-- [mmcv 0.6.2](https://github.com/open-mmlab/mmcv)
+- [mmcv > 1.3](https://github.com/open-mmlab/mmcv)
 - [BboxToolkit 1.0](https://github.com/jbwang1997/BboxToolkit)
 
 ### Install OBBDetection
@@ -54,16 +54,28 @@ cd OBBDetection
 
 d. Install build requirements and then install OBBDetection.
 
+- install the BboxToolkit
+
 ```shell
-# install the BboxToolkit
 cd BboxToolkit
 pip install -v -e .  # or "python setup.py develop"
 cd ..
+```
+
+- install mmcv-full
+
+Please refer to [mmcv-full](https://github.com/open-mmlab/mmcv) to select a compatible version of mmcv-full 
+```shell
+# example
+pip install mmcv-full==1.3.9 -f https://download.openmmlab.com/mmcv/dist/cu111/torch1.9.0/index.html
+# Here, the version of cuda and torch should be the same with your environment.
+```
 
-# install the OBBDetection
+- install OBBDetection
+
+```
 pip install -r requirements/build.txt
 pip install mmpycocotools
-pip install mmcv==0.6.2
 pip install -v -e .  # or "python setup.py develop"
 ```
 
@@ -106,4 +118,4 @@ However some functionality is gone in this mode:
 - sigmoid_focal_loss_cuda
 
 So if you try to run inference with a model containing deformable convolution you will get an error.
-Note: We set `use_torchvision=True` on-the-fly in CPU mode for `RoIPool` and `RoIAlign`
+Note: We set `use_torchvision=True` on-the-fly in CPU mode for `RoIPool` and `RoIAlign`

mmdet/models/dense_heads/fovea_head.py

@@ -3,7 +3,7 @@
 from mmcv.cnn import ConvModule, normal_init
 
 from mmdet.core import multi_apply, multiclass_nms
-from mmdet.ops import DeformConv
+from mmcv.ops import DeformConv2d
 from ..builder import HEADS
 from .anchor_free_head import AnchorFreeHead
 
@@ -21,12 +21,12 @@ def __init__(self,
         offset_channels = kernel_size * kernel_size * 2
         self.conv_offset = nn.Conv2d(
             4, deformable_groups * offset_channels, 1, bias=False)
-        self.conv_adaption = DeformConv(
+        self.conv_adaption = DeformConv2d(
             in_channels,
             out_channels,
             kernel_size=kernel_size,
             padding=(kernel_size - 1) // 2,
-            deformable_groups=deformable_groups)
+            deform_groups=deformable_groups)
         self.relu = nn.ReLU(inplace=True)
 
     def init_weights(self):

mmdet/models/dense_heads/guided_anchor_head.py

@@ -6,7 +6,7 @@
                         build_assigner, build_bbox_coder, build_sampler,
                         calc_region, force_fp32, images_to_levels, multi_apply,
                         multiclass_nms, unmap)
-from mmdet.ops import DeformConv, MaskedConv2d
+from mmcv.ops import DeformConv2d, MaskedConv2d
 from ..builder import HEADS, build_loss
 from .anchor_head import AnchorHead
 
@@ -34,12 +34,12 @@ def __init__(self,
         offset_channels = kernel_size * kernel_size * 2
         self.conv_offset = nn.Conv2d(
             2, deformable_groups * offset_channels, 1, bias=False)
-        self.conv_adaption = DeformConv(
+        self.conv_adaption = DeformConv2d(
             in_channels,
             out_channels,
             kernel_size=kernel_size,
             padding=(kernel_size - 1) // 2,
-            deformable_groups=deformable_groups)
+            deform_groups=deformable_groups)
         self.relu = nn.ReLU(inplace=True)
 
     def init_weights(self):

mmdet/models/dense_heads/reppoints_head.py

@@ -5,7 +5,7 @@
 
 from mmdet.core import (PointGenerator, build_assigner, build_sampler,
                         images_to_levels, multi_apply, multiclass_nms, unmap)
-from mmdet.ops import DeformConv
+from mmcv.ops import DeformConv2d
 from ..builder import HEADS, build_loss
 from .anchor_free_head import AnchorFreeHead
 
@@ -130,20 +130,20 @@ def _init_layers(self):
                     conv_cfg=self.conv_cfg,
                     norm_cfg=self.norm_cfg))
         pts_out_dim = 4 if self.use_grid_points else 2 * self.num_points
-        self.reppoints_cls_conv = DeformConv(self.feat_channels,
-                                             self.point_feat_channels,
-                                             self.dcn_kernel, 1, self.dcn_pad)
+        self.reppoints_cls_conv = DeformConv2d(self.feat_channels,
+                                               self.point_feat_channels,
+                                               self.dcn_kernel, 1, self.dcn_pad)
         self.reppoints_cls_out = nn.Conv2d(self.point_feat_channels,
                                            self.cls_out_channels, 1, 1, 0)
         self.reppoints_pts_init_conv = nn.Conv2d(self.feat_channels,
                                                  self.point_feat_channels, 3,
                                                  1, 1)
         self.reppoints_pts_init_out = nn.Conv2d(self.point_feat_channels,
                                                 pts_out_dim, 1, 1, 0)
-        self.reppoints_pts_refine_conv = DeformConv(self.feat_channels,
-                                                    self.point_feat_channels,
-                                                    self.dcn_kernel, 1,
-                                                    self.dcn_pad)
+        self.reppoints_pts_refine_conv = DeformConv2d(self.feat_channels,
+                                                      self.point_feat_channels,
+                                                      self.dcn_kernel, 1,
+                                                      self.dcn_pad)
         self.reppoints_pts_refine_out = nn.Conv2d(self.point_feat_channels,
                                                   pts_out_dim, 1, 1, 0)
 

mmdet/models/necks/fpn_carafe.py

@@ -1,7 +1,7 @@
 import torch.nn as nn
 from mmcv.cnn import ConvModule, build_upsample_layer, xavier_init
 
-from mmdet.ops.carafe import CARAFEPack
+from mmcv.ops.carafe import CARAFEPack
 from ..builder import NECKS
 
 

mmdet/models/roi_heads/mask_heads/fcn_mask_head.py

@@ -8,7 +8,7 @@
 from mmdet.core import auto_fp16, force_fp32, mask_target
 from mmdet.models.builder import HEADS, build_loss
 from mmdet.ops import Conv2d
-from mmdet.ops.carafe import CARAFEPack
+from mmcv.ops.carafe import CARAFEPack
 
 BYTES_PER_FLOAT = 4
 # TODO: This memory limit may be too much or too little. It would be better to

mmdet/ops/__init__.py

@@ -1,10 +1,5 @@
 from .context_block import ContextBlock
-from .conv_ws import ConvWS2d, conv_ws_2d
 from .corner_pool import CornerPool
-from .dcn import (DeformConv, DeformConvPack, DeformRoIPooling,
-                  DeformRoIPoolingPack, ModulatedDeformConv,
-                  ModulatedDeformConvPack, ModulatedDeformRoIPoolingPack,
-                  deform_conv, deform_roi_pooling, modulated_deform_conv)
 from .generalized_attention import GeneralizedAttention
 from .masked_conv import MaskedConv2d
 from .nms import batched_nms, nms, nms_match, soft_nms
@@ -14,7 +9,6 @@
                            rel_roi_point_to_rel_img_point)
 from .roi_align import RoIAlign, roi_align
 from .roi_pool import RoIPool, roi_pool
-from .saconv import SAConv2d
 from .sigmoid_focal_loss import SigmoidFocalLoss, sigmoid_focal_loss
 from .utils import get_compiler_version, get_compiling_cuda_version
 from .wrappers import Conv2d, ConvTranspose2d, Linear, MaxPool2d
@@ -26,16 +20,11 @@
 
 __all__ = [
     'nms', 'soft_nms', 'RoIAlign', 'roi_align', 'RoIPool', 'roi_pool',
-    'DeformConv', 'DeformConvPack', 'DeformRoIPooling', 'DeformRoIPoolingPack',
-    'ModulatedDeformRoIPoolingPack', 'ModulatedDeformConv',
-    'ModulatedDeformConvPack', 'deform_conv', 'modulated_deform_conv',
-    'deform_roi_pooling', 'SigmoidFocalLoss', 'sigmoid_focal_loss',
-    'MaskedConv2d', 'ContextBlock', 'GeneralizedAttention', 'NonLocal2D',
-    'get_compiler_version', 'get_compiling_cuda_version', 'ConvWS2d',
-    'conv_ws_2d', 'build_plugin_layer', 'batched_nms', 'Conv2d',
+    'SigmoidFocalLoss', 'sigmoid_focal_loss', 'MaskedConv2d', 'ContextBlock',
+    'GeneralizedAttention', 'NonLocal2D', 'get_compiler_version',
+    'get_compiling_cuda_version', 'build_plugin_layer', 'batched_nms', 'Conv2d',
     'ConvTranspose2d', 'MaxPool2d', 'Linear', 'nms_match', 'CornerPool',
     'point_sample', 'rel_roi_point_to_rel_img_point', 'SimpleRoIAlign',
-    'SAConv2d',
 
     'roi_align_rotated', 'RoIAlignRotated', 'obb_nms', 'BT_nms',
     'arb_batched_nms', 'obb_overlaps', 'convex_sort'