From cfe9d8e205e15fb267753ad56135d4c42c4c87e3 Mon Sep 17 00:00:00 2001 From: nerminsamet Date: Sun, 2 Aug 2020 15:29:52 +0300 Subject: [PATCH] first commit --- .github/ISSUE_TEMPLATE/error-report.md | 43 + .github/ISSUE_TEMPLATE/feature_request.md | 22 + .github/ISSUE_TEMPLATE/general_questions.md | 10 + .gitignore | 120 +++ .isort.cfg | 7 + .style.yapf | 4 + .travis.yml | 15 + INSTALL.md | 94 ++ LICENSE | 203 ++++ README.md | 79 ++ .../ppdet/ppdet_ms_r101_fpn_4gpu_2x_align.py | 118 +++ .../ppdet_ms_x101_64x4d_fpn_4gpu_2x_align.py | 120 +++ configs/ppdet/ppdet_r50_fpn_4gpu_1x.py | 117 +++ demo/inference_demo.ipynb | 92 ++ demo/ppdet.png | Bin 0 -> 335065 bytes demo/webcam_demo.py | 44 + mmdet/__init__.py | 3 + mmdet/apis/__init__.py | 9 + mmdet/apis/env.py | 69 ++ mmdet/apis/inference.py | 183 ++++ mmdet/apis/train.py | 225 +++++ mmdet/core/__init__.py | 7 + mmdet/core/anchor/__init__.py | 8 + mmdet/core/anchor/anchor_generator.py | 86 ++ mmdet/core/anchor/anchor_target.py | 186 ++++ mmdet/core/anchor/guided_anchor_target.py | 287 ++++++ mmdet/core/bbox/__init__.py | 22 + mmdet/core/bbox/assign_sampling.py | 33 + mmdet/core/bbox/assigners/__init__.py | 8 + .../bbox/assigners/approx_max_iou_assigner.py | 114 +++ mmdet/core/bbox/assigners/assign_result.py | 19 + mmdet/core/bbox/assigners/base_assigner.py | 8 + mmdet/core/bbox/assigners/max_iou_assigner.py | 153 ++++ mmdet/core/bbox/bbox_target.py | 73 ++ mmdet/core/bbox/geometry.py | 63 ++ mmdet/core/bbox/samplers/__init__.py | 14 + mmdet/core/bbox/samplers/base_sampler.py | 78 ++ mmdet/core/bbox/samplers/combined_sampler.py | 16 + .../samplers/instance_balanced_pos_sampler.py | 41 + .../bbox/samplers/iou_balanced_neg_sampler.py | 133 +++ mmdet/core/bbox/samplers/ohem_sampler.py | 73 ++ mmdet/core/bbox/samplers/pseudo_sampler.py | 26 + mmdet/core/bbox/samplers/random_sampler.py | 53 ++ mmdet/core/bbox/samplers/sampling_result.py | 24 + mmdet/core/bbox/transforms.py | 180 ++++ mmdet/core/evaluation/__init__.py | 18 + mmdet/core/evaluation/bbox_overlaps.py | 49 + mmdet/core/evaluation/class_names.py | 116 +++ mmdet/core/evaluation/coco_utils.py | 177 ++++ mmdet/core/evaluation/eval_hooks.py | 168 ++++ mmdet/core/evaluation/mean_ap.py | 379 ++++++++ mmdet/core/evaluation/recall.py | 185 ++++ mmdet/core/fp16/__init__.py | 4 + mmdet/core/fp16/decorators.py | 160 ++++ mmdet/core/fp16/hooks.py | 127 +++ mmdet/core/fp16/utils.py | 23 + mmdet/core/mask/__init__.py | 4 + mmdet/core/mask/mask_target.py | 38 + mmdet/core/mask/utils.py | 30 + mmdet/core/post_processing/__init__.py | 8 + mmdet/core/post_processing/bbox_nms.py | 106 +++ mmdet/core/post_processing/merge_augs.py | 95 ++ mmdet/core/utils/__init__.py | 7 + mmdet/core/utils/dist_utils.py | 58 ++ mmdet/core/utils/misc.py | 37 + mmdet/datasets/__init__.py | 20 + mmdet/datasets/builder.py | 41 + mmdet/datasets/cityscapes.py | 9 + mmdet/datasets/coco.py | 120 +++ mmdet/datasets/custom.py | 349 +++++++ mmdet/datasets/dataset_wrappers.py | 55 ++ mmdet/datasets/extra_aug.py | 163 ++++ mmdet/datasets/loader/__init__.py | 4 + mmdet/datasets/loader/build_loader.py | 48 + mmdet/datasets/loader/sampler.py | 159 ++++ mmdet/datasets/registry.py | 3 + mmdet/datasets/transforms.py | 166 ++++ mmdet/datasets/utils.py | 68 ++ mmdet/datasets/voc.py | 20 + mmdet/datasets/wider_face.py | 42 + mmdet/datasets/xml_style.py | 86 ++ mmdet/models/__init__.py | 19 + mmdet/models/anchor_heads/__init__.py | 14 + mmdet/models/anchor_heads/anchor_head.py | 270 ++++++ mmdet/models/anchor_heads/fcos_head.py | 392 ++++++++ mmdet/models/anchor_heads/ga_retina_head.py | 107 +++ mmdet/models/anchor_heads/ga_rpn_head.py | 127 +++ .../models/anchor_heads/guided_anchor_head.py | 609 ++++++++++++ mmdet/models/anchor_heads/ppdet_head.py | 497 ++++++++++ mmdet/models/anchor_heads/retina_head.py | 83 ++ mmdet/models/anchor_heads/rpn_head.py | 104 +++ mmdet/models/anchor_heads/ssd_head.py | 193 ++++ mmdet/models/backbones/__init__.py | 6 + mmdet/models/backbones/hrnet.py | 484 ++++++++++ mmdet/models/backbones/resnet.py | 525 +++++++++++ mmdet/models/backbones/resnext.py | 223 +++++ mmdet/models/backbones/ssd_vgg.py | 133 +++ mmdet/models/bbox_heads/__init__.py | 7 + mmdet/models/bbox_heads/bbox_head.py | 239 +++++ mmdet/models/bbox_heads/convfc_bbox_head.py | 185 ++++ mmdet/models/bbox_heads/double_bbox_head.py | 170 ++++ mmdet/models/builder.py | 43 + mmdet/models/detectors/__init__.py | 21 + mmdet/models/detectors/base.py | 142 +++ mmdet/models/detectors/cascade_rcnn.py | 415 +++++++++ mmdet/models/detectors/double_head_rcnn.py | 178 ++++ mmdet/models/detectors/fast_rcnn.py | 50 + mmdet/models/detectors/faster_rcnn.py | 27 + mmdet/models/detectors/fcos.py | 16 + mmdet/models/detectors/grid_rcnn.py | 229 +++++ mmdet/models/detectors/htc.py | 435 +++++++++ mmdet/models/detectors/mask_rcnn.py | 31 + mmdet/models/detectors/mask_scoring_rcnn.py | 200 ++++ mmdet/models/detectors/ppdet.py | 16 + mmdet/models/detectors/retinanet.py | 16 + mmdet/models/detectors/rpn.py | 97 ++ mmdet/models/detectors/single_stage.py | 108 +++ mmdet/models/detectors/test_mixins.py | 164 ++++ mmdet/models/detectors/two_stage.py | 272 ++++++ mmdet/models/losses/__init__.py | 19 + mmdet/models/losses/accuracy.py | 31 + mmdet/models/losses/balanced_l1_loss.py | 69 ++ mmdet/models/losses/cross_entropy_loss.py | 103 +++ mmdet/models/losses/focal_loss.py | 82 ++ mmdet/models/losses/ghm_loss.py | 167 ++++ mmdet/models/losses/iou_loss.py | 135 +++ mmdet/models/losses/mse_loss.py | 25 + mmdet/models/losses/smooth_l1_loss.py | 45 + mmdet/models/losses/utils.py | 97 ++ mmdet/models/mask_heads/__init__.py | 10 + mmdet/models/mask_heads/fcn_mask_head.py | 181 ++++ .../models/mask_heads/fused_semantic_head.py | 106 +++ mmdet/models/mask_heads/grid_head.py | 361 ++++++++ mmdet/models/mask_heads/htc_mask_head.py | 38 + mmdet/models/mask_heads/maskiou_head.py | 190 ++++ mmdet/models/necks/__init__.py | 5 + mmdet/models/necks/bfp.py | 102 +++ mmdet/models/necks/fpn.py | 139 +++ mmdet/models/necks/hrfpn.py | 100 ++ mmdet/models/plugins/__init__.py | 4 + mmdet/models/plugins/generalized_attention.py | 384 ++++++++ mmdet/models/plugins/non_local.py | 114 +++ mmdet/models/registry.py | 9 + mmdet/models/roi_extractors/__init__.py | 3 + mmdet/models/roi_extractors/single_level.py | 107 +++ mmdet/models/shared_heads/__init__.py | 3 + mmdet/models/shared_heads/res_layer.py | 72 ++ mmdet/models/utils/__init__.py | 12 + mmdet/models/utils/conv_module.py | 164 ++++ mmdet/models/utils/conv_ws.py | 46 + mmdet/models/utils/norm.py | 55 ++ mmdet/models/utils/scale.py | 12 + mmdet/models/utils/weight_init.py | 46 + mmdet/ops/__init__.py | 19 + mmdet/ops/context_block.py | 104 +++ mmdet/ops/dcn/__init__.py | 12 + mmdet/ops/dcn/deform_conv.py | 337 +++++++ mmdet/ops/dcn/deform_pool.py | 245 +++++ mmdet/ops/dcn/src/deform_conv_cuda.cpp | 695 ++++++++++++++ mmdet/ops/dcn/src/deform_conv_cuda_kernel.cu | 866 ++++++++++++++++++ mmdet/ops/dcn/src/deform_pool_cuda.cpp | 87 ++ mmdet/ops/dcn/src/deform_pool_cuda_kernel.cu | 364 ++++++++ mmdet/ops/masked_conv/__init__.py | 3 + mmdet/ops/masked_conv/masked_conv.py | 89 ++ .../masked_conv/src/masked_conv2d_cuda.cpp | 74 ++ .../masked_conv/src/masked_conv2d_kernel.cu | 112 +++ mmdet/ops/nms/__init__.py | 3 + mmdet/ops/nms/nms_wrapper.py | 78 ++ mmdet/ops/nms/src/nms_cpu.cpp | 71 ++ mmdet/ops/nms/src/nms_cuda.cpp | 17 + mmdet/ops/nms/src/nms_kernel.cu | 131 +++ mmdet/ops/nms/src/soft_nms_cpu.pyx | 127 +++ mmdet/ops/roi_align/__init__.py | 3 + mmdet/ops/roi_align/gradcheck.py | 30 + mmdet/ops/roi_align/roi_align.py | 87 ++ mmdet/ops/roi_align/src/roi_align_cuda.cpp | 85 ++ mmdet/ops/roi_align/src/roi_align_kernel.cu | 294 ++++++ mmdet/ops/roi_pool/__init__.py | 3 + mmdet/ops/roi_pool/gradcheck.py | 16 + mmdet/ops/roi_pool/roi_pool.py | 75 ++ mmdet/ops/roi_pool/src/roi_pool_cuda.cpp | 86 ++ mmdet/ops/roi_pool/src/roi_pool_kernel.cu | 156 ++++ mmdet/ops/sigmoid_focal_loss/__init__.py | 3 + .../sigmoid_focal_loss/sigmoid_focal_loss.py | 54 ++ .../src/sigmoid_focal_loss.cpp | 45 + .../src/sigmoid_focal_loss_cuda.cu | 171 ++++ mmdet/utils/__init__.py | 4 + mmdet/utils/flops_counter.py | 421 +++++++++ mmdet/utils/registry.py | 74 ++ setup.py | 201 ++++ tools/analyze_logs.py | 178 ++++ tools/coco_eval.py | 28 + tools/convert_datasets/pascal_voc.py | 141 +++ tools/detectron2pytorch.py | 88 ++ tools/dist_test.sh | 10 + tools/dist_train.sh | 9 + tools/get_flops.py | 52 ++ tools/publish_model.py | 35 + tools/robustness_eval.py | 256 ++++++ tools/slurm_test.sh | 23 + tools/slurm_train.sh | 23 + tools/test.py | 226 +++++ tools/test_robustness.py | 469 ++++++++++ tools/train.py | 108 +++ tools/upgrade_model_version.py | 42 + tools/voc_eval.py | 62 ++ 206 files changed, 23299 insertions(+) create mode 100644 .github/ISSUE_TEMPLATE/error-report.md create mode 100644 .github/ISSUE_TEMPLATE/feature_request.md create mode 100644 .github/ISSUE_TEMPLATE/general_questions.md create mode 100644 .gitignore create mode 100644 .isort.cfg create mode 100644 .style.yapf create mode 100644 .travis.yml create mode 100644 INSTALL.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 configs/ppdet/ppdet_ms_r101_fpn_4gpu_2x_align.py create mode 100644 configs/ppdet/ppdet_ms_x101_64x4d_fpn_4gpu_2x_align.py create mode 100644 configs/ppdet/ppdet_r50_fpn_4gpu_1x.py create mode 100644 demo/inference_demo.ipynb create mode 100644 demo/ppdet.png create mode 100644 demo/webcam_demo.py create mode 100644 mmdet/__init__.py create mode 100644 mmdet/apis/__init__.py create mode 100644 mmdet/apis/env.py create mode 100644 mmdet/apis/inference.py create mode 100644 mmdet/apis/train.py create mode 100644 mmdet/core/__init__.py create mode 100644 mmdet/core/anchor/__init__.py create mode 100644 mmdet/core/anchor/anchor_generator.py create mode 100644 mmdet/core/anchor/anchor_target.py create mode 100644 mmdet/core/anchor/guided_anchor_target.py create mode 100644 mmdet/core/bbox/__init__.py create mode 100644 mmdet/core/bbox/assign_sampling.py create mode 100644 mmdet/core/bbox/assigners/__init__.py create mode 100644 mmdet/core/bbox/assigners/approx_max_iou_assigner.py create mode 100644 mmdet/core/bbox/assigners/assign_result.py create mode 100644 mmdet/core/bbox/assigners/base_assigner.py create mode 100644 mmdet/core/bbox/assigners/max_iou_assigner.py create mode 100644 mmdet/core/bbox/bbox_target.py create mode 100644 mmdet/core/bbox/geometry.py create mode 100644 mmdet/core/bbox/samplers/__init__.py create mode 100644 mmdet/core/bbox/samplers/base_sampler.py create mode 100644 mmdet/core/bbox/samplers/combined_sampler.py create mode 100644 mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py create mode 100644 mmdet/core/bbox/samplers/iou_balanced_neg_sampler.py create mode 100644 mmdet/core/bbox/samplers/ohem_sampler.py create mode 100644 mmdet/core/bbox/samplers/pseudo_sampler.py create mode 100644 mmdet/core/bbox/samplers/random_sampler.py create mode 100644 mmdet/core/bbox/samplers/sampling_result.py create mode 100644 mmdet/core/bbox/transforms.py create mode 100644 mmdet/core/evaluation/__init__.py create mode 100644 mmdet/core/evaluation/bbox_overlaps.py create mode 100644 mmdet/core/evaluation/class_names.py create mode 100644 mmdet/core/evaluation/coco_utils.py create mode 100644 mmdet/core/evaluation/eval_hooks.py create mode 100644 mmdet/core/evaluation/mean_ap.py create mode 100644 mmdet/core/evaluation/recall.py create mode 100644 mmdet/core/fp16/__init__.py create mode 100644 mmdet/core/fp16/decorators.py create mode 100644 mmdet/core/fp16/hooks.py create mode 100644 mmdet/core/fp16/utils.py create mode 100644 mmdet/core/mask/__init__.py create mode 100644 mmdet/core/mask/mask_target.py create mode 100644 mmdet/core/mask/utils.py create mode 100644 mmdet/core/post_processing/__init__.py create mode 100644 mmdet/core/post_processing/bbox_nms.py create mode 100644 mmdet/core/post_processing/merge_augs.py create mode 100644 mmdet/core/utils/__init__.py create mode 100644 mmdet/core/utils/dist_utils.py create mode 100644 mmdet/core/utils/misc.py create mode 100644 mmdet/datasets/__init__.py create mode 100644 mmdet/datasets/builder.py create mode 100644 mmdet/datasets/cityscapes.py create mode 100644 mmdet/datasets/coco.py create mode 100644 mmdet/datasets/custom.py create mode 100644 mmdet/datasets/dataset_wrappers.py create mode 100644 mmdet/datasets/extra_aug.py create mode 100644 mmdet/datasets/loader/__init__.py create mode 100644 mmdet/datasets/loader/build_loader.py create mode 100644 mmdet/datasets/loader/sampler.py create mode 100644 mmdet/datasets/registry.py create mode 100644 mmdet/datasets/transforms.py create mode 100644 mmdet/datasets/utils.py create mode 100644 mmdet/datasets/voc.py create mode 100644 mmdet/datasets/wider_face.py create mode 100644 mmdet/datasets/xml_style.py create mode 100644 mmdet/models/__init__.py create mode 100644 mmdet/models/anchor_heads/__init__.py create mode 100644 mmdet/models/anchor_heads/anchor_head.py create mode 100644 mmdet/models/anchor_heads/fcos_head.py create mode 100644 mmdet/models/anchor_heads/ga_retina_head.py create mode 100644 mmdet/models/anchor_heads/ga_rpn_head.py create mode 100644 mmdet/models/anchor_heads/guided_anchor_head.py create mode 100644 mmdet/models/anchor_heads/ppdet_head.py create mode 100644 mmdet/models/anchor_heads/retina_head.py create mode 100644 mmdet/models/anchor_heads/rpn_head.py create mode 100644 mmdet/models/anchor_heads/ssd_head.py create mode 100644 mmdet/models/backbones/__init__.py create mode 100644 mmdet/models/backbones/hrnet.py create mode 100644 mmdet/models/backbones/resnet.py create mode 100644 mmdet/models/backbones/resnext.py create mode 100644 mmdet/models/backbones/ssd_vgg.py create mode 100644 mmdet/models/bbox_heads/__init__.py create mode 100644 mmdet/models/bbox_heads/bbox_head.py create mode 100644 mmdet/models/bbox_heads/convfc_bbox_head.py create mode 100644 mmdet/models/bbox_heads/double_bbox_head.py create mode 100644 mmdet/models/builder.py create mode 100644 mmdet/models/detectors/__init__.py create mode 100644 mmdet/models/detectors/base.py create mode 100644 mmdet/models/detectors/cascade_rcnn.py create mode 100644 mmdet/models/detectors/double_head_rcnn.py create mode 100644 mmdet/models/detectors/fast_rcnn.py create mode 100644 mmdet/models/detectors/faster_rcnn.py create mode 100644 mmdet/models/detectors/fcos.py create mode 100644 mmdet/models/detectors/grid_rcnn.py create mode 100644 mmdet/models/detectors/htc.py create mode 100644 mmdet/models/detectors/mask_rcnn.py create mode 100644 mmdet/models/detectors/mask_scoring_rcnn.py create mode 100644 mmdet/models/detectors/ppdet.py create mode 100644 mmdet/models/detectors/retinanet.py create mode 100644 mmdet/models/detectors/rpn.py create mode 100644 mmdet/models/detectors/single_stage.py create mode 100644 mmdet/models/detectors/test_mixins.py create mode 100644 mmdet/models/detectors/two_stage.py create mode 100644 mmdet/models/losses/__init__.py create mode 100644 mmdet/models/losses/accuracy.py create mode 100644 mmdet/models/losses/balanced_l1_loss.py create mode 100644 mmdet/models/losses/cross_entropy_loss.py create mode 100644 mmdet/models/losses/focal_loss.py create mode 100644 mmdet/models/losses/ghm_loss.py create mode 100644 mmdet/models/losses/iou_loss.py create mode 100644 mmdet/models/losses/mse_loss.py create mode 100644 mmdet/models/losses/smooth_l1_loss.py create mode 100644 mmdet/models/losses/utils.py create mode 100644 mmdet/models/mask_heads/__init__.py create mode 100644 mmdet/models/mask_heads/fcn_mask_head.py create mode 100644 mmdet/models/mask_heads/fused_semantic_head.py create mode 100644 mmdet/models/mask_heads/grid_head.py create mode 100644 mmdet/models/mask_heads/htc_mask_head.py create mode 100644 mmdet/models/mask_heads/maskiou_head.py create mode 100644 mmdet/models/necks/__init__.py create mode 100644 mmdet/models/necks/bfp.py create mode 100644 mmdet/models/necks/fpn.py create mode 100644 mmdet/models/necks/hrfpn.py create mode 100644 mmdet/models/plugins/__init__.py create mode 100644 mmdet/models/plugins/generalized_attention.py create mode 100644 mmdet/models/plugins/non_local.py create mode 100644 mmdet/models/registry.py create mode 100644 mmdet/models/roi_extractors/__init__.py create mode 100644 mmdet/models/roi_extractors/single_level.py create mode 100644 mmdet/models/shared_heads/__init__.py create mode 100644 mmdet/models/shared_heads/res_layer.py create mode 100644 mmdet/models/utils/__init__.py create mode 100644 mmdet/models/utils/conv_module.py create mode 100644 mmdet/models/utils/conv_ws.py create mode 100644 mmdet/models/utils/norm.py create mode 100644 mmdet/models/utils/scale.py create mode 100644 mmdet/models/utils/weight_init.py create mode 100644 mmdet/ops/__init__.py create mode 100644 mmdet/ops/context_block.py create mode 100644 mmdet/ops/dcn/__init__.py create mode 100644 mmdet/ops/dcn/deform_conv.py create mode 100644 mmdet/ops/dcn/deform_pool.py create mode 100644 mmdet/ops/dcn/src/deform_conv_cuda.cpp create mode 100644 mmdet/ops/dcn/src/deform_conv_cuda_kernel.cu create mode 100644 mmdet/ops/dcn/src/deform_pool_cuda.cpp create mode 100644 mmdet/ops/dcn/src/deform_pool_cuda_kernel.cu create mode 100644 mmdet/ops/masked_conv/__init__.py create mode 100644 mmdet/ops/masked_conv/masked_conv.py create mode 100644 mmdet/ops/masked_conv/src/masked_conv2d_cuda.cpp create mode 100644 mmdet/ops/masked_conv/src/masked_conv2d_kernel.cu create mode 100644 mmdet/ops/nms/__init__.py create mode 100644 mmdet/ops/nms/nms_wrapper.py create mode 100644 mmdet/ops/nms/src/nms_cpu.cpp create mode 100644 mmdet/ops/nms/src/nms_cuda.cpp create mode 100644 mmdet/ops/nms/src/nms_kernel.cu create mode 100644 mmdet/ops/nms/src/soft_nms_cpu.pyx create mode 100644 mmdet/ops/roi_align/__init__.py create mode 100644 mmdet/ops/roi_align/gradcheck.py create mode 100644 mmdet/ops/roi_align/roi_align.py create mode 100644 mmdet/ops/roi_align/src/roi_align_cuda.cpp create mode 100644 mmdet/ops/roi_align/src/roi_align_kernel.cu create mode 100644 mmdet/ops/roi_pool/__init__.py create mode 100644 mmdet/ops/roi_pool/gradcheck.py create mode 100644 mmdet/ops/roi_pool/roi_pool.py create mode 100644 mmdet/ops/roi_pool/src/roi_pool_cuda.cpp create mode 100644 mmdet/ops/roi_pool/src/roi_pool_kernel.cu create mode 100644 mmdet/ops/sigmoid_focal_loss/__init__.py create mode 100644 mmdet/ops/sigmoid_focal_loss/sigmoid_focal_loss.py create mode 100644 mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss.cpp create mode 100644 mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss_cuda.cu create mode 100644 mmdet/utils/__init__.py create mode 100644 mmdet/utils/flops_counter.py create mode 100644 mmdet/utils/registry.py create mode 100644 setup.py create mode 100644 tools/analyze_logs.py create mode 100644 tools/coco_eval.py create mode 100644 tools/convert_datasets/pascal_voc.py create mode 100644 tools/detectron2pytorch.py create mode 100755 tools/dist_test.sh create mode 100755 tools/dist_train.sh create mode 100644 tools/get_flops.py create mode 100644 tools/publish_model.py create mode 100644 tools/robustness_eval.py create mode 100755 tools/slurm_test.sh create mode 100755 tools/slurm_train.sh create mode 100644 tools/test.py create mode 100644 tools/test_robustness.py create mode 100644 tools/train.py create mode 100644 tools/upgrade_model_version.py create mode 100644 tools/voc_eval.py diff --git a/.github/ISSUE_TEMPLATE/error-report.md b/.github/ISSUE_TEMPLATE/error-report.md new file mode 100644 index 0000000..a5020bc --- /dev/null +++ b/.github/ISSUE_TEMPLATE/error-report.md @@ -0,0 +1,43 @@ +--- +name: Error report +about: Create a report to help us improve +title: '' +labels: '' +assignees: '' + +--- + +Thanks for your error report and we appreciate it a lot. + +**Checklist** +1. I have searched related issues but cannot get the expected help. +2. The bug has not been fixed in the latest version. + +**Describe the bug** +A clear and concise description of what the bug is. + +**Reproduction** +1. What command or script did you run? +``` +A placeholder for the command. +``` +2. Did you make any modifications on the code or config? Did you understand what you have modified? +3. What dataset did you use? + +**Environment** + - OS: [e.g., Ubuntu 16.04.6] + - GCC [e.g., 5.4.0] + - PyTorch version [e.g., 1.1.0] +- How you installed PyTorch [e.g., pip, conda, source] +- GPU model [e.g., 1080Ti, V100] +- CUDA and CUDNN version +- [optional] Other information that may be related (such as `$PATH`, `$LD_LIBRARY_PATH`, `$PYTHONPATH`, etc.) + +**Error traceback** +If applicable, paste the error trackback here. +``` +A placeholder for trackback. +``` + +**Bug fix** +If you have already identified the reason, you can provide the information here. If you are willing to create a PR to fix it, please also leave a comment here and that would be much appreciated! diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..33f9d5f --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,22 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: '' +labels: '' +assignees: '' + +--- + +**Describe the feature** + +**Motivation** +A clear and concise description of the motivation of the feature. +Ex1. It is inconvenient when [....]. +Ex2. There is a recent paper [....], which is very helpful for [....]. + +**Related resources** +If there is an official code release or third-party implementations, please also provide the information here, which would be very helpful. + +**Additional context** +Add any other context or screenshots about the feature request here. +If you would like to implement the feature and create a PR, please leave a comment here and that would be much appreciated. diff --git a/.github/ISSUE_TEMPLATE/general_questions.md b/.github/ISSUE_TEMPLATE/general_questions.md new file mode 100644 index 0000000..6211ca2 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/general_questions.md @@ -0,0 +1,10 @@ +--- +name: General questions +about: Ask general questions to get help +title: '' +labels: '' +assignees: '' + +--- + + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a827190 --- /dev/null +++ b/.gitignore @@ -0,0 +1,120 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +# cython generated cpp +mmdet/ops/nms/src/soft_nms_cpu.cpp +mmdet/version.py +data +.vscode +.idea + +# custom +*.pkl +*.pkl.json +*.log.json +work_dirs/ + +# Pytorch +*.pth diff --git a/.isort.cfg b/.isort.cfg new file mode 100644 index 0000000..c1684dd --- /dev/null +++ b/.isort.cfg @@ -0,0 +1,7 @@ +[isort] +line_length = 79 +multi_line_output = 0 +known_first_party = mmdet +known_third_party = mmcv,numpy,matplotlib,pycocotools,six,seaborn,terminaltables,torch,torchvision +no_lines_before = STDLIB,LOCALFOLDER +default_section = THIRDPARTY \ No newline at end of file diff --git a/.style.yapf b/.style.yapf new file mode 100644 index 0000000..286a3f1 --- /dev/null +++ b/.style.yapf @@ -0,0 +1,4 @@ +[style] +BASED_ON_STYLE = pep8 +BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF = true +SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN = true diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..35a68d7 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,15 @@ +dist: xenial +language: python + +install: + - pip install isort flake8 yapf + +python: + - "3.5" + - "3.6" + - "3.7" + +script: + - flake8 + - isort -rc --check-only --diff mmdet/ tools/ + - yapf -r -d --style .style.yapf mmdet/ tools/ \ No newline at end of file diff --git a/INSTALL.md b/INSTALL.md new file mode 100644 index 0000000..217b17e --- /dev/null +++ b/INSTALL.md @@ -0,0 +1,94 @@ +## Installation + +### Requirements + +- Linux (Windows is not officially supported) +- Python 3.5+ (Python 2 is not supported) +- PyTorch 1.1 or higher +- CUDA 9.0 or higher +- NCCL 2 +- GCC 4.9 or higher +- [mmcv](https://github.com/open-mmlab/mmcv) with version number 0.2.13 or 0.2.14 + +We have tested the following versions of OS and CUDA: + +- OS: Ubuntu 16.04/18.04 +- CUDA: 10.0 + + +### Install mmdetection + +a. Create a conda virtual environment and activate it. + +```shell +conda create -n ppdet python=3.7 -y +conda activate ppdet +``` + +b. Install PyTorch stable or nightly and torchvision following the [official instructions](https://pytorch.org/), e.g., + +```shell +conda install pytorch==1.1.0 torchvision==0.3.0 cudatoolkit=10.0 -c pytorch +``` + +c. Clone the PPDet repository. + +```shell +git clone https://github.com/nerminsamet/ppdet.git +cd ppdet +``` +d. Install mmcv + +```shell +pip install mmcv==0.2.13 +``` + +e. Install PPDet (other dependencies will be installed automatically). + +```shell +python setup.py develop +# or "pip install -v -e ." +``` + +Note: + +1. The git commit id will be written to the version number with step e, e.g. 1.0.rc. The version will also be saved in trained models. +It is recommended that you run step e each time you pull some updates from github. **If C/CUDA codes are modified, then step e is compulsory.** + +2. Following the above instructions, PPDet is installed on `dev` mode, **any local modifications made to the code will take effect without the need to reinstall it** (unless you submit some commits and want to update the version number). + + +### Prepare datasets + +It is recommended to symlink the dataset root to `$PPDet/data`. +If your folder structure is different, you may need to change the corresponding paths in config files. + +``` +COCO_DIR +├── annotations +├── images +│ ├── train2017 +│ ├── val2017 +│ ├── test2017 +``` + + +### Scripts + +[Here](https://gist.github.com/hellock/bf23cd7348c727d69d48682cb6909047) is +a script for setting up mmdetection with conda. + +### Multiple versions + +If there are more than one mmdetection on your machine, and you want to use them alternatively, the recommended way is to create multiple conda environments and use different environments for different versions. + +Another way is to insert the following code to the main scripts (`train.py`, `test.py` or any other scripts you run) +```python +import os.path as osp +import sys +sys.path.insert(0, osp.join(osp.dirname(osp.abspath(__file__)), '../')) +``` +or run the following command in the terminal of corresponding folder. +```shell +export PYTHONPATH=`pwd`:$PYTHONPATH +``` diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..04adf5c --- /dev/null +++ b/LICENSE @@ -0,0 +1,203 @@ +Copyright 2018-2019 Open-MMLab. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2018-2019 Open-MMLab. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..48ebf59 --- /dev/null +++ b/README.md @@ -0,0 +1,79 @@ +# Reducing Label Noise in Anchor-Free Object Detection + +Official PyTroch implementation of PPDet based on open-mmlab's mmdetection. + +> [**Reducing Label Noise in Anchor-Free Object Detection**](https://arxiv.org/abs/2007.02355), +> Nermin Samet, Samet Hicsonmez, [Emre Akbas](http://user.ceng.metu.edu.tr/~emre/), +> *BMVC 2020. ([arXiv pre-print](https://arxiv.org/abs/2007.02355))* + +## Summary +Current anchor-free detectors label all features within a ground-truth box as positive. However features within a ground-truth box may come from (i) the background, (ii) occluders or (iii) non-discriminatory parts of the object. PPDet avoids treating such features as positive. For example in the image below, the colored dots show the locations whose predictions are pooled to generate the final detection shown in the green bounding box. The color denotes the contribution weight. Highest contributions are coming from the objects and not occluders or background areas. + + + +Current anchor-free object detectors label all the features that spatially fall inside a predefined central region of a ground-truth box as positive. This approach causes la- bel noise during training, since some of these positively labeled features may be on the background or an occluder object, or they are simply not discriminative features. In this paper, we propose a new labeling strategy aimed to reduce the label noise in anchor-free detectors. We sum-pool predictions stemming from individual features into a single pre- diction. This allows the model to reduce the contributions of non-discriminatory features during training. We develop a new one-stage, anchor-free object detector, PPDet, to em- ploy this labeling strategy during training and a similar prediction pooling method during inference. On the COCO dataset, PPDet achieves the best performance among anchor- free top-down detectors and performs on-par with the other state-of-the-art methods. It also outperforms all state-of-the-art methods in the detection of small objects (APs 31.4). + +## Highlights +- PPDet is a new relaxed labelling strategy for anchor-free object detection. +- To reduce the contribution of non-discriminatory features during training, PPDet **sum-pool** predictions stemming from individual features into a single prediction. +- PPDet is uses a novel prediction pooling strategy in training and inference. +- PPDet is state-of-the-art method in the detection of small objects with APs 31.4. +- Our best model achieves *46.3* AP on COCO test-dev. + +## Results on COCO val2017 +| Backbone | Inf time (fps) | AP / AP50 | Multi-scale AP / AP50| Download | +|:---------:|:---------------:|:------:|:------:|:--------:| +| ResNet-50 | 8.7 | 36.3 / 54.3 | 39.9 / 56.9 | [model](https://drive.google.com/file/d/1z29WWEyF3_fcUYNZ4sluP_sRd95dJATL/view?usp=sharing) | +| ResNet-101 | 7.1 | 40.5 / 59.5 | 45.0 / 63.0 | [model](https://drive.google.com/file/d/1a2K4rUE7S9Bck2vqK7KENVq0cB1qI2Dv/view?usp=sharing) | +| ResNeXt-101-64x4d | 4.1 | 41.8 / 61.3 | 46.1 / 64.3 | [model](https://drive.google.com/file/d/1a58emT4Gw2ORdcF0MPVLJbx6JrkmJmxM/view?usp=sharing) | + + +- *For multi scale testing we used scales of (800, 480), (1067, 640), (1333, 800), (1600, 960), (1867, 1120) and (2133, 1280).* + +## Installation +PPDet is implemented on top of [mmdetection](https://github.com/open-mmlab/mmdetection). Therefore the installation is the same as original mmdetection. + +You could check [INSTALL.md](INSTALL.md) for installation instructions. + + +## Train and inference +The PPDet configs could be found in [configs/ppdet](configs/ppdet). + +### Inference + # single-gpu testing + python tools/test.py ${CONFIG_FILE} ${CHECKPOINT_FILE} [--out ${RESULT_FILE}] --eval bbox [--show] + + # multi-gpu testing + ./tools/dist_test.sh ${CONFIG_FILE} ${CHECKPOINT_FILE} ${GPU_NUM} [--out ${RESULT_FILE}] --eval bbox + +### Training + # single-gpu training + python tools/train.py ${CONFIG_FILE} + + # multi-gpu training + ./tools/dist_train.sh ${CONFIG_FILE} ${GPU_NUM} [optional arguments] + +## Acknowledgement + +This work was supported by the AWS Cloud Credits for Research program and by the Scientific and Technological Research Council of Turkey (TÜBİTAK) through the project titled "Object Detection in Videos with Deep Neural Networks" (grant number 117E054). The numerical calculations reported in this paper were partially performed at TÜBİTAK ULAKBİM, High Performance and Grid Computing Center (TRUBA resources). + +## License + +PPDet is released under the Apache License (refer to the [LICENSE](LICENSE) file for details). We developed PPDet on top of open-mmlab's [mmdetection](https://github.com/open-mmlab/mmdetection). Please refer to the License of [mmdetection](https://github.com/open-mmlab/mmdetection) for more detail. + +## Citation + +If you find PPDet useful for your research, please cite our paper as follows. + +> N. Samet, S. Hicsonmez, E. Akbas, "Reducing Label Noise in Anchor-Free Object Detection", +> In British Machine Vision Conference (BMVC), 2020. + +BibTeX entry: +``` +@inproceedings{PPDet, + authors = {Nermin Samet and Samet Hicsonmez and Emre Akbas}, + title = {Reducing Label Noise in Anchor-Free Object Detection}, + booktitle = {British Machine Vision Conference (BMVC)}, + year = {2020}, +} +``` diff --git a/configs/ppdet/ppdet_ms_r101_fpn_4gpu_2x_align.py b/configs/ppdet/ppdet_ms_r101_fpn_4gpu_2x_align.py new file mode 100644 index 0000000..3195b67 --- /dev/null +++ b/configs/ppdet/ppdet_ms_r101_fpn_4gpu_2x_align.py @@ -0,0 +1,118 @@ +# model settings +model = dict( + type='PPDet', + pretrained='torchvision://resnet101', + backbone=dict( + type='ResNet', + depth=101, + num_stages=4, + out_indices=(0, 1, 2, 3), # C2, C3, C4, C5 + frozen_stages=1, + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + num_outs=5, + add_extra_convs=True), + bbox_head=dict( + type='PPDetHead', + num_classes=81, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + base_edge_list=[16, 32, 64, 128, 256], + scale_ranges=((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048)), + sigma=0.4, + with_deform=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=1.50, + alpha=0.4, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=0.75), + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True) + )) +# training and testing settings +train_cfg = dict() +test_cfg = dict( + nms_pre=1000, + score_thr=0.05, + k=40, + agg_thr=0.6, + nms=dict(type='nms', iou_thr=0.6), + max_per_img=100) +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco' +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +data = dict( + imgs_per_gpu=4, + workers_per_gpu=4, + train=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_train2017.json', + img_prefix=data_root + 'images/train2017/', + img_scale=[(1333, 640), (1333, 800)], + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0.5, + with_mask=False, + with_crowd=False, + with_label=True), + val=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'images/val2017/', + img_scale=(1333, 800), + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0, + with_mask=False, + with_crowd=False, + with_label=True), + test=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', #image_info_test-dev2017.json + img_prefix=data_root + 'images/val2017/', + img_scale=(1333, 800), # single scale testing + # img_scale=[(800, 480), (1067, 640), (1333, 800), (1600, 960), (1867, 1120), (2133, 1280)], # ms scale testing + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0, + with_mask=False, + with_crowd=False, + with_label=False, + test_mode=True)) +# optimizer +optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001) +optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2)) +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=500, + warmup_ratio=1.0 / 3, + step=[16, 22]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=50, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 24 +device_ids = range(4) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = './work_dirs/ppdet_ms_r101_fpn_4gpu_2x_align' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/configs/ppdet/ppdet_ms_x101_64x4d_fpn_4gpu_2x_align.py b/configs/ppdet/ppdet_ms_x101_64x4d_fpn_4gpu_2x_align.py new file mode 100644 index 0000000..7641af8 --- /dev/null +++ b/configs/ppdet/ppdet_ms_x101_64x4d_fpn_4gpu_2x_align.py @@ -0,0 +1,120 @@ +# model settings +model = dict( + type='PPDet', + pretrained='open-mmlab://resnext101_64x4d', + backbone=dict( + type='ResNeXt', + depth=101, + groups=64, + base_width=4, + num_stages=4, + out_indices=(0, 1, 2, 3), # C2, C3, C4, C5 + frozen_stages=1, + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + num_outs=5, + add_extra_convs=True), + bbox_head=dict( + type='PPDetHead', + num_classes=81, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + base_edge_list=[16, 32, 64, 128, 256], + scale_ranges=((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048)), + sigma=0.4, + with_deform=True, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=1.50, + alpha=0.4, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=0.75), + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True) + )) +# training and testing settings +train_cfg = dict() +test_cfg = dict( + nms_pre=1000, + score_thr=0.05, + k=40, + agg_thr=0.6, + nms=dict(type='nms', iou_thr=0.6), + max_per_img=100) +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco' +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +data = dict( + imgs_per_gpu=2, + workers_per_gpu=4, + train=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_train2017.json', + img_prefix=data_root + 'images/train2017/', + img_scale=[(1333, 640), (1333, 800)], + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0.5, + with_mask=False, + with_crowd=False, + with_label=True), + val=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'images/val2017/', + img_scale=(1333, 800), + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0, + with_mask=False, + with_crowd=False, + with_label=True), + test=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'images/val2017/', + img_scale=(1333, 800), # single scale testing + # img_scale=[(800, 480), (1067, 640), (1333, 800), (1600, 960), (1867, 1120), (2133, 1280)], # ms scale testing + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0, + with_mask=False, + with_crowd=False, + with_label=False, + test_mode=True)) +# optimizer +optimizer = dict(type='SGD', lr=0.005, momentum=0.9, weight_decay=0.0001) +optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2)) +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=500, + warmup_ratio=1.0 / 3, + step=[11, 14]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=50, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 16 +device_ids = range(4) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = './work_dirs/ppdet_ms_x101_fpn_4gpu_1.3x_align' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/configs/ppdet/ppdet_r50_fpn_4gpu_1x.py b/configs/ppdet/ppdet_r50_fpn_4gpu_1x.py new file mode 100644 index 0000000..43c2731 --- /dev/null +++ b/configs/ppdet/ppdet_r50_fpn_4gpu_1x.py @@ -0,0 +1,117 @@ +# model settings +model = dict( + type='PPDet', + pretrained='torchvision://resnet50', + backbone=dict( + type='ResNet', + depth=50, + num_stages=4, + out_indices=(0, 1, 2, 3), # C2, C3, C4, C5 + frozen_stages=1, + style='pytorch'), + neck=dict( + type='FPN', + in_channels=[256, 512, 1024, 2048], + out_channels=256, + start_level=1, + num_outs=5, + add_extra_convs=True), + bbox_head=dict( + type='PPDetHead', + num_classes=81, + in_channels=256, + stacked_convs=4, + feat_channels=256, + strides=[8, 16, 32, 64, 128], + base_edge_list=[16, 32, 64, 128, 256], + scale_ranges=((1, 64), (32, 128), (64, 256), (128, 512), (256, 2048)), + sigma=0.4, + with_deform=False, + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=1.50, + alpha=0.4, + loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=0.11, loss_weight=0.75) + )) +# training and testing settings +train_cfg = dict() +test_cfg = dict( + nms_pre=1000, + score_thr=0.05, + nms=dict(type='nms', iou_thr=0.6), + max_per_img=100, + k=40, + agg_thr=0.6) +# dataset settings +dataset_type = 'CocoDataset' +data_root = 'data/coco' +img_norm_cfg = dict( + mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True) +data = dict( + imgs_per_gpu=4, + workers_per_gpu=8, + train=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'images/val2017/', + img_scale=(1333, 800), + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0.5, + with_mask=False, + with_crowd=False, + with_label=True), + val=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'images/val2017/', + img_scale=(1333, 800), + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0, + with_mask=False, + with_crowd=False, + with_label=True), + test=dict( + type=dataset_type, + ann_file=data_root + 'annotations/instances_val2017.json', + img_prefix=data_root + 'images/val2017/', + img_scale=(1333, 800), # single scale testing + # img_scale=[(800, 480), (1067, 640), (1333, 800), (1600, 960), (1867, 1120), (2133, 1280)], # ms scale testing + img_norm_cfg=img_norm_cfg, + size_divisor=32, + flip_ratio=0, + with_mask=False, + with_crowd=False, + with_label=False, + test_mode=True)) +# optimizer +optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001) +optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2)) +# learning policy +lr_config = dict( + policy='step', + warmup='linear', + warmup_iters=500, + warmup_ratio=1.0 / 3, + step=[8, 11]) +checkpoint_config = dict(interval=1) +# yapf:disable +log_config = dict( + interval=1, + hooks=[ + dict(type='TextLoggerHook'), + # dict(type='TensorboardLoggerHook') + ]) +# yapf:enable +# runtime settings +total_epochs = 12 +device_ids = range(4) +dist_params = dict(backend='nccl') +log_level = 'INFO' +work_dir = './work_dirs/ppdet_r50_fpn_4gpu_1x' +load_from = None +resume_from = None +workflow = [('train', 1)] diff --git a/demo/inference_demo.ipynb b/demo/inference_demo.ipynb new file mode 100644 index 0000000..ffe4765 --- /dev/null +++ b/demo/inference_demo.ipynb @@ -0,0 +1,92 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from mmdet.apis import init_detector, inference_detector, show_result_pyplot\n", + "import mmcv" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "config_file = '../configs/faster_rcnn_r50_fpn_1x.py'\n", + "# download the checkpoint from model zoo and put it in `checkpoints/`\n", + "checkpoint_file = '../checkpoints/faster_rcnn_r50_fpn_1x_20181010-3d1b3351.pth'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# build the model from a config file and a checkpoint file\n", + "model = init_detector(config_file, checkpoint_file, device='cuda:0')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# test a single image\n", + "img = 'demo.jpg'\n", + "result = inference_detector(model, img)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# show the results\n", + "show_result_pyplot(img, result, model.CLASSES)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/demo/ppdet.png b/demo/ppdet.png new file mode 100644 index 0000000000000000000000000000000000000000..51e0a0250cd953000d9e55f7d00cb9ea7f4e6aa5 GIT binary patch literal 335065 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�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 z z3TwOTkg9b@&hfZp6haQZF9*uH5I+G_XIWy`z!u_v0~#k4aN z82{Nx@x`?3+e-=82;hs|O1?oGBFZ-|Tf3^42<48K`tl=7b0YM$5*}J0rk%RtR;@Uy zMeDo!kjS%D>bipjx2n)+0vxXJOmis9&e!CmPURT33eEDuGFMb{LAj3%@U&!J)hfR* zSE^+_G_a-o*eGO!EsMic$lFC^f~7l-p1 zsY&B+L19UrzJO``GH*?anSaH^vR}3wQV0Uk&%aP_V3`oReq^xASf|md((K(;kc(>} zU6iSH2Ol8OZWB;RNXf5|Q;6Y(XMwYTsu$x^3phD%JZ)vjD55>U-?UNB9}tni!arx~ z$eM>JK?13QBSr~+{i&#moGnks73U7Qn4+cOO9QS#r9mU>Idbs0?9sd=cvAA3Ov zT>%gLmj;}((fs-$z!%ka9BThoh>ed{T7Q zFHE>0jpVV2OkJXS43QkWr{u|hl%cJWbd2klK$8L1>+CW{?;Oyh#2i{uu_-aY=HRNX z!*WDwH6(Ri9y`V6!nsNb#PQn2F=A4NG$m7hPGdSRX5}wyX>Puq6ukT|THxQE>c4Ob zr0~Z0huN1F!8OJwt>d1PMpeUCEd&*frbwZPVOj}6&r4v=Jv%!CoBF~DClC<~Zq2BH z9U01`!5oeLhhbKyBI;PpPJGBjr)6^JsdHGIQtf=zrM66~(d;@#;+l1L#I6#GjN=nMi*pszOXE zXPJAE$-Yk=Kb>iW%b$|n8;vNMwT~(qz`t2l?%unD-hMYo-@u13gc{*6*%#UtJMwEQ zAu6sF2d6q<)7wsmCopB4e7DMW3bH^fI4|AGw$=OHcwzM8zA~+#4pv112}Mj|vvH~l zYpPHiaC4Rs7i}mMYt0m&dMs2;)cl8&dIf^{AHc%#Um&1qw|D>1!dN_~1oi#GeOgvo zuDeK4s;4_1ufum^JBN6?hN(2xrfc@V=b=yP(q(eX`f83fzXVcC0pY};R;P!~D2K2_ z7E3>CL$w`LUCz$IV!F%CX6g|Mc*$Ep4D$T;@yNu;=-XZ8a6b^-jM^l!Sf?C3ExxNqKrv)me3y!7Lp4Z&VemvIiL#RKpl`>PXGw~&&>#qbB6(4XnJkgI7Dg@Xzi09$X=LGe z3^DZ#vC&uaUKR)$*)F{@m4E`ZBEZpuIWwp^z=!TGT&ybe6}+N>fnaijEdgr7w?Ti| zbwXe&)uznEKbgFxit{Z{6z_uxh7i>vXOEPL6ejA+yE0|AU}x~66A>YcMDJC>-`GW- z-!=RN-7v_`ee6pOVsb32|H3i+Gkcho$yeJU^i{D`GaSMa=uA->J67v%c!yg>HSM&j zL#l&0SL6!W^fbN}JU}_0ZBdHIKN`xq6753HkB}sGi>3xC)W|J1KZQ0eQH9wjZP$ zs_=0azg9d-a7pA}tb{FQCG)m=?oUSf(DYg1NL})n#wh&nDNnD4sWs%DR58^$rJ33@ zqY3+Urv*sb@(ky_(lKGxYL(~D<;YPSw+vkApAAR8E6?qzR-)QZPrALo=%{>~(mdj5 z_~Bvpol|QbJ;W>j8bPl(GbC5hrr!O!Da8ca_X=&-P~Od#)pd-5zP{=0>HnkYE5oYl zx_0UAmPQ(+8|m)ev~)KJNOws;ba#WKG)Onn4bt5$g36h`-*wi-|IJ=|tueiFqfg+P{&ZSD>x~~VqaFog*bICUQ8uFL$;1D^=yl}4=9}wAKvlt zHyf7uH}sEq9(yJUzS`Yt6Qp;RHt(ILRLMVT$hG|PY(MbH zVS+aau+Dq#a<94oYwY!w?KNan0xL~RCh*e-fIMRlur&>~c~pMRsHEGPx@K)Q){H$R zTrcV{Wc@D-8lg-73+U}ZWkCz9*J)H@;-=M=(CeY|?hqs&U_5*EfzFbLuV#JSxCO7?2 z@4OkI09iKfyxFBG05Jz!DRL1%FJPIzMeMG)q6&r*&=mp&nn@EVWU?-n%O1L9a^$V< z-9`XN%=p{@cORtq4|)R^*ieMU{a9TE)+EKVNH-#2L_*r;`6;=JRaaN{e^ggZxGg}! zLwaY|ZfMnDWhK9YR{D?_Ji!0%9F~p1pl%uMB-}e)Noy6yaReo8R`UJLxLdm)7}G)N zP9lu%Uj;$my-QmjWJ>rcqSv)3@iu*II^K`xtH6E4Ztm;Y7gxw7Xz8M=JHV|n2u}E& z;2@$HT%}S}RXq5M4!N3UwY2hWiW4L^<1^MkD+uzXUldt?mS7yW(G31vgKA;Q!bjs` zw(6)mmdgx@B<=XQ_R$CHS@*GnAocf18Vxc-lyqgZ?*YRKL05mpoK{v-@?h}^#;1c1 z8pI`K!|u5DZq-5`k*1hZJiamARRqXc9*6y{n(R!Lpv~#ZQ%_OwlxI>bI3i%WlzP!p z!~`5t^Vrai3PYQ(#ru|mH?(6RjyOslBp2F<-%`sZ=L)~d?JRZGatpJ@u8Cb>Br3O! zH|i*Mk!gi&%-G;m!i`Fa0!?IvHefxp!M4#`#aL@7q(Daz`g}BhoD_GnbHMY2_&ZNl zn8=?sr~i&zCRlpwLJ*7kZeWUX1E0X?w*`oyc4^iJQNy&ZNVjnuz~JG0FF_PR6o_vT z$`u(w#Q=yI(8d45Eq?+2W(*-4@C}0T=v(j#3>N?$N`&sv^t-Fq=G#(-0SjZnxr4b=tmsTb73WIfkj8x+`0d`#UkV zb&uQmC2v&@p^2-`?$Af+yyZ@zEVa5hU3b}eEF}H$nBpge>QGI=O0$SOxn^G$B*^qJpCOqr?lW!0API1V%DwVC0^d!h z3*LAODU-zXoV5kz- zXF39+0hbJ{lZ~kwg(*Qcf4_}amin%`$lVif|7V^Gef9FV0!Z^CH0=vMVa4dSa&jw< zYmLycL7I68U3=`s(`1=ix2uz2N*ixV3y(Ax+E>dQ8}sh>rvoszZY^yk|CAC(>-iGAw-a{&yr`aT2W zD6e$mqx4@A8fa9MXk5PP3+H`2Z4~H1F>NYPXPcXO?GIEw-$coKk3vIXi5z_~gV2qr zc@$aMeS#o2&(B$OLjV-FXbyTde(~63NRAYfAgGN9=L-wkb!E5NCAT2*{y5b(MDpq5 z5RtkmI(DZV=f$6K4=%|dn#u3=!9{d>1Or^cy&);Wk`vpn4D@zq+~ts4w_vEn;cOCnjcQQ!1)3AikgpzC1to zyPpNNufI8n_JKYNc+Z3_24laqx;{NcvE2TS-ngB`ArrP6fmJ^SN-MaKa(ihS8bHkk zO$8WvknAPQHyIXukEa184jy+B;>s0@{1-fG0e^oB#6Glfp;zVx#o71#^aEHFkgp^{ zmG=E<$k!OgGU@*de8gN>vQzUU$vVzD05rXKxN+kC49p(^A=(B|;qjri%azIVr3qBH zoKjvYk9GJyi>Ub*Cu<;l)l9ycW7TxEmom2%Jsh`YBC`>9cOKUTc9)-V*fhIG|2D9G zQ>=_Zz-ZZitntuONR8P|7fih6a^P%8u#o*CSGa%)X*ur3lR1L_!i4I}TBkXBNpEss zi1wW}d!^oHC?eGV!m@l)S{P#E5p`@@o=R7&p~41Vl0y+F+Yj);o_RDD|$W zPCOG&i#C7Hp*EaDJb8R_w<)x&7;>Q`4H#dtgpqB%RrInk*o~APT=+?4^Lu8vIv(gb z^uJTj^n>r|U~kt*vFt3zpC;#$XY2AP(=7&B)x3nrDJUpH%|ndcjYhV?S+~D$A()$m zi;f3DOb6LZYUnP!*@bCmYt_9+oVU^*0;Tj0d?)zgS_g5?jM#sbDin7=Xm)%EhL&B> zb3Lp?lUVrsv64vZgU1IzCJXTJkoK&(a)KMOQ^4;CFC(UexIU_JMA@};<|+ab1!;_MZr`$llTjM3-!;s@`O7<&DS zXurPf>PLV_`-o9wU1gZPULnMg64CP5_PLxzV9tD(T)UR?D@gF&ad~>_d41XX``G#l z!e<)<+w7`EFHTWic_20m=V>j+)(UioQW?B3HgEjkU+0{aIjEzOjGGPG@_^{t5jh)XL>S_r9HbmEL}L{_D;Jxzqv0f%Pz)~lo!XBEke?8R8)*{NAj_k zlUX~e9(e0Pdze&hg^7J3`~!=aK|E@g*&FMpvK}w;RIhUqRObkTeGhcfLf-Xf!Z&(b zzO>qRPiLDGGqQCEy_y3(qlQxX6_5&pLJe*BND|dwcclId*^VKm7xm8&QD>T_3qPjg zITgIa6QT+mMR-g|>q+2#jh%d2%f7S&zX68pgs!+2N$Q&_M5br&7o{qv&<#gPO2aSO zV0RB>+FQR5`HTSqTWjseFmi=L!G@;?-;?f(X6h_`@->I6NCe=l@TIGVcfahKVa$UB@LQG_ z?JWD<&0{MT5Dvp2(?A@DX8tyI;qI4TgKlqzmy3(ouZUX|6pWx`j%`Agupkz*mVj8- z23;FQ)p3KSRR`W|Q%`O>FwJqZZV*llgMhhT2t!N1!$VOD$j8 z`9*As=ryEzYpSITPYBW<0EB~mJ(x-=uAyR>s&N6E{v2)BPM!a4SWxF^{Z3a5n)Z+F z^qk%zl<+qMC`_1Yv(N!ZQ3%Oa^-L$!pU9sd9eDqJ&dEt-YR#0P*LSA?!T0Zdf8ElW zW%m4is4Gtaz)?a4L|?iY@oy=OxM`H!NUwaCVr~^q%l+~O&7rw8iTB5A8k^tiC|UUV zni%RQIToAedeSH#-Y3u4PEa55%3te%Sh=DsrY%~bp8>P-19S;>a59O(SJ#%?eXN4<2BNfk0 z4AIr`hQkMxnfxSKSzzzWJ?cpvi&&3pTrNR4)V>0UvS+fCfv_f3R4RP@cVIKvdtE;4 z8nPwEx?JWj<(lK%-1H+#M4jok#;cN1*IOUUiX1L4<0JUlsJz_B09ZL9LE=(U$n^_s zpC?!Y-1fB>C^SR@op3$S-ytLe^)Lg!xs{T4pOOi0e^}p0XRTyAz7Rq=byb6TTn+qm zb0}2=7I;9wFn)qFETPtz=B1VEK@cewzUDJiiCi*Xs^!>ksPFdSCO3{vJG6}RT%xb> zg2h3h@P{1DYWwZCJ`*U}cl^z#10>6}TJV1&H8gi!ScuBY5 zteG9tm6vfV_CED=%~L03&tc~atIhp(b;4fI5ahd9o30qI@pVK9Iz-&)I(^Ts85EV{ z*Uv*Yq>uRm(LN(8Rpl}} zP19eGivOj?MKs1z%D5)0c6Lxa=|kGtII&sly$P+L)_%v^48AWafd~6{=mAO(_~*4k?CKjr(wZQo!NbpvuT|S-Rj7<#P)t5BWbSFB%PRs#VjcT?S5~ zCw~5&y@|S|eh*_wDU2B~%S{KhGdL)!MP{ggTobs*d-}_1!$tU8oK1y44mB@%2l=J7 zS$C0Gj6F$TB^e(d#NP?#Jg&Ny?&G{xwe?yWNyKIqen%@%7cK|P=Ty%+Q)!aMo3TF> zfaTGrP46Q>I}xxp(zj1y8Bg*NIP!QsQO$8l8ZGg(H4a-^QvdT>wf=rxWW5L_O3$}+ zVLMGE4Thc1U*o`>lQN2NKn^;*B0YM+`B;?LPl1Hi;bZ**k6XPI;@`E7t+`8^aEzjp z9)^{8mH)#W*)#kZEtaT%j{O&q>lR$I@{*$8h^O54ae}!JwEhQF3(#V1SP}~0DgPA$ zT9wm9=Ft!!OJ=0q=py~CA5mS+oHC&3WF6_Y>G7lU>RTsRjd=aLqB0o>;f~)f?Sb;d zP-0fw1>YK=%}F5D3hEhxxbMfYP_KN1E-WJ^9n3s?th3Y1*_H;>z(-c=44?{8D>X^}!E~9)3aiv!&+nr#0 ztGZt{-7seW^4IUR?8&@)0qc+$<$Jj5NJM z)`NH>Y-cXl7-!M@_j?{;ezXdB4)^d4#KM|-+ebGF%3jQI{ABeuOT+|QTg^RNGZ}C?K%*wvjOJ{rVc3k1aoh3MmMV``bKP>5O#$Vh2X>LlG+$? z2X$9Ev@_K;CYvgP*i$^iP*jvEicYKb45=%Xrl)btmdqNEPpTuRKU1GYY+dII(MT!8#&=?H?SxUg>dmYI zls&N6nh;uQEcGS%S(sZDpvR(zDE(WO{=Yp>`wTxt7LSJLev)P1`QJA#XO%qdGjoQk zrUI04I`G)k&B&|)fLlV~)Akrs#h?f>0!*b53fog^{}LtZR}*z7=@v=NfAlTfDpkhF zV5ntt`p?a%^UZb2uAcWdJq=yF7Un!74(*RlwI5v74OIvjcgq-0+@6#zzwNU&Yec6` zvB&3)^TWd5qEI@^;udM7km#)oJ1-Y0>-8$bIu0J6a?uya4T?ddxxW7WQ(RmO7VThM z0X7|fNNNZ+N-2K}hb3z6e62`Zn!1ST?eb|dmL2_0`2I}Pr%yow%1l1Q-am+HP_#cR z?5Z*uP?g`q`2^wPlxgT<+Ny^`N2!NJ=`N5O5JSsLn$7~!3(z_}qE?Jpwdj8l`{s(7 zdg@!h4)Y&)%DmP==;!ToVMgU%2NP;QlH^?pllDb@ce+dM_mt=1(7VH>|p5nt(tZ5$GwU)s!ZWErvCE;W`6`C0Lca>^aDYOEb26~L`xmWewaCDHi zuA(FoJ6wU9?W0;T5%s&FdbI*9WT~C)gBS36gxNzD|S?1aI~Fx_RqR{!ua}sImH;>wn{m^_zy# z@9}&pW=;qCl%owjCTjT&u}ZO9d{xSJ2i137Yp@|4ipxJi;{(Qc6BY2BlZPs?d|iD7>n!5Rg! zbVC;Sk4(!M8X+WTCm2BU3f=Km0D_A%;hM2=S?X?k0slsyh%#5}xz0k!Yf8$^prxNA z040u~(1M=(S^iN?WHIwS8?r{Q;bMxy*RLHgOti!u^nSU5d7c>>5(Fx@LdsJ;;lDj8 zORZX`dn8&>a;vW%whR#Fc&f-`S^S?1*<#$Yb;CRc$7%2s*58WaqHbFuP*iqQsi1G+ zVzm3IK}E%Y^&?^RTg|HEu-yfIae?SdNxW%=cVuz+MhwkpZv&1oT<)u?Pk+4gPJcq{ ze~NSV+xy3I`PuX8za1~IeEHHzI-=2HpcZsN2Z!m_N;S>LcVHPx)LBhlBNTI59w%GJ zrf&;9Svn?0&_$-zAxmH!ZU0%#zeb-h zsH8FegeDo!$xii)zT$&Z_yki}H6LDFaYjjcu-Uzva}_ZFn(%D;-ZUGa%*BQs=)y@v z@A^zokPX0jEgClBsXJoEp83V%bKu}Xdgh&XzXoB*d4)v=kbHo5utftpwmkL2`Pj3t5Mnte^ zn*-C6aDAH+NZdhLI(|5qtJwGKlKdH!yjO@F+CP0;*}9IW#F zAJYp~k_NWTrH3WY`({@<*0tTRECmE9)D053mI6G4Lqnu}8j5Hk(*OCMF^?1@62Q#h zs;^HN*#n-%;n%PAKdpotNtfG?qeo90syeD7g%eZc<{PE-S}0dA!wT&uVA1y0L~n&Q zmwhh?VabDFi6R`u(l98II4u*C_#ND?^6XAe3z@hs2Sy%lCZcLKzrvGOdZb{+omNeb zM&UDS*E|dn!yNw$r}y(is}nA=@`+CU4VQ2ikE)^p9%R*@KYvn%b3}t*b=f%Z4`5`< zeN}KOe@$uLQRE5cq@{*cmFISZ+s)qG<$fg=jV#c{UJsx}3Cd!iXf|B1I)3Wa39Syz zu+|m}ev&6yrm7%LIic8pq+xAcN-aynYie;5V_^F1TjR0%n}+8G`}r%*_r3-xmzeOp zDkdR$0{_n4QNOFTL}cLFlL9FFn`+g>WTo9eNdGX$b}^ur1oETt)gXhAIRtRz5f_8wXGD^ z3)7C-nT4FpX!5j$D(#V1if@x-$&8_wGpJM^#*SZOpGTN{NNeb4#4ypkN8yCNw1PmC z>5@}$?EaG-16HSm2Ph4Wz+KvGqO+@O(AE56F|l5?;Rvkg0D_%(!QFtz9C?2F;B!2! z&spsfzoKuGjTq;b{PSKN4pfiY# zs@a`zuMWI_@*P`jpFIw*c-{ZSr;sD;OG98?dpNE^iyR|J_`&X~{5h>La-8YFWxP-? zJ)oNH^xShe%n+NF>k|kbr7uZk{pvgDa5N)mTk%uPr&r+%jqrz6tEG>*Tjw5MHMqis z?A3b44jVoe*-y8pvm6~`_$DKp${6n3FTk=L{AWPui&9pd4orQy6YyhPL3)>kSK%)hP&9{5ggguHQFF)Tp ze5z~qGT^VB(F0-A-QWD63K$%_EQDVuwyv&UZXE>1Zr;}rp2~;45|t-7ST2-SJoS^| zJD^M}D-%T%_Pt<2pFsJ6uo?m=MWWJ_Yf3YeptIQnE=|+V+}P^MdDYouu<$-c;_IYb zrB9&&fC_bV*PaQD9#+oMrM>ehbgBTL^&g%(crQCp@3C~*IdKxrpk4}KA>>`gz7FOG z>6wcj=sz{=F6>o57Psnkx^a+&Z}Y)TD}>Bu;EC;cp-lA@5UKAq>-fQ7kiG)K0= zdY2>O3fX1md2|~Y8yYTnbocZCx4Pp8G?PmuR5#Q1YMd;VzGohiEY&*t+;vUy8f7|{Trqz z{581$2J^Y(&EheLEG zMwtRV`?T(6PJ`eCN%RPUPSuq` z%R!MZfC2bS0i+$HcL)4zouF&t4o}?4Nz-IKk*+GrQyhHrAh1nLo=gqQMk|?sKG(v z&@MV<(T)@iu~Y)>9kMCrC!}tPz1Ojr$=S_vPsL6dg<=LZ_7FPJg#FOf?|$JT8u}-z zG)Zv+vcH?tqHt3K6riVUTS6_APkfe1+OT!0aN8JZ*jD-_kx0!J$%Q6<=*`x~Ql1mx zso2;6L<4+@KLPm%PATt7TB=wp>s!6ssu5hqJ{%B9l5lW{-?#)i9Eok08kB#QLB|mW zhv4+z^J$=i2Nh;Ak74jN@HkcEd!WRB{oY#bQdI%ZYJ^e0+BaJS`gNf3{w}nmreBRe z0czD0i4t6vh_pZ&#}|bjBJIaJE`wE=$C(AO#4!bO>#UkVKaC`kWU9N+L;bh>pmf+QfkNqhC9nn>9EVjO_pBHvWFo?m7_?7afuj(U&bmzN}MNGD)(jl>o#R9AwQDt zRUEyO(Hg!p7oE=?6{1B_{J=$eafU#ETtz@YpuMY0>Ujk8O8Z*yL?J{=4&T~}f6T8d zZTa>t*I_U2`Un)EpiNAwLH@aa93CFt-g1@>;<4*Ln%djPOch2^S$Z)3xP`9h`ww>u zNED!JEQI(mpp(4b6)Cz4fmq?wQvi)4M1C^$cl8gkXRafOl2EO`xkl*?1W<2B9&^Hv zVge!wCz3EwBKYcg%D1|@)uj11dDqK|>7)x~%>FO01FMyhoK0kml^e?(&FYnJVw z8g^M~QV6`Z1-MAHSe^{_H{R36&+(!%2OP3@qia~h6>Nx@w z9cr@vGFC=(#%1~zSYZQ^}BL%w|63lX)(hRIK~OUs1mg=+;#hVkI& z+9eqbh0pa;s`7otV;@Y+wVVJ)OrJF!uyz4AL@<}r4tSjd`+d+#lP7>%^Xr$lf-UgQ z4gSqo+Gpb8;o$++Kntwkw(@rjI4OQqA>{Xoq8+4XcH{t!UsQ!GcrPA#hg&Z@!vaJ>wt|2dhK)jGs~9ACG7M_qX#v_1&IEyei<0}$iSWTY%}F;KpYrJY#%720MgPP<`vm3}*SfTIkC|7C zf%q=_#Dh2N%aoX|TrWAkmiKajIjdZcNQg}87^j>Pw4Z!T_5`CBHmlt2QbrYW%5sfU zm3i`{82BgEeU%K{uHLJohMP%8fgrsXwlS+F2BzYlkYedxFvsr;H&tR^h_bzU%?k9qYyqsufk(;I#} zR#S(vOgIcGEE7i|miPYH!~$Q7-FIWNZEnAMll;^vl`FJ?h`VF@p7pFwd5JQ9HDCSS z7gs40pUJg3bI}`S&UJW_lQP9qH0>F$LpW4c=B}sr{*cX4JE%#q6Wb!tntoBjVJ!en z9X!m+B z1ezC7*8=b=t+*T{poS@LN?3f$PM3xJJfD03S=4ho&qz0XfzYl<%iJ~;i`eJOy& zWmU(bn*o~>Z;T2ZIe%* z_`;yt2#QL!uBh#qaz10}A*;ScfEk#;87<2!6d#N;f zM0Eyr1l`*26Gr0zhgquE|A)2|PE=gDJLXa@)fpse_zwM*XVyN{Vy@Szq7eg{b%SnFX9jSV0D(=6)Xa2+ zj*@8k>;Z@!fIpiud37R(yT{!{R~#o-R5pvw{mWHP!dqlJT{p^1!y;W9(x)<^)vw$s zxLVsZp9Zw@oU;xe9|>;63MXRAY0l3x8uM$L)q;lFvUW%5oB!N$qGEb{+JLHA~9VCwO%x4rkg?TWU@+j{BVdg;RqxZb09<PbL(k4 zBF70Po${WA-(0nFlY#`FPZ5T<(4}>h*z?X>v}-ZAjdL;82ohSYUZ{lV8YCUNE%jL` zr*5TFuibatE?TNSInxyr3v|nU3q@?T0YD#qWHmOuzddt+$NQs7kJ&iB^!chS3-f7h zLzfM9->#EeQfup_Gmm?%;I{k%Xks{wf=Jr&xfGI(AhY!!oGr!Z$31rd+gRs!%LPfmoJBFvqA{zHK*9ieO55EIk%GZ7nJ6?D zro>`&sv3J*kJIRJ*f-4RXow)=6{X|g?r7TB|6vg8^O2N<)MdW8H4JTe^Y|LW|XJ2&i+vTeTX8)t4 z151+O8_pbt2Gib6*hfT`H_QY-f>sfvagF2(pdwV&kUwLXJoi`54=(H8eJwiJ4kp6# z4%&CIKFJTUBAE_=nhip{nFDYmxOQAtu72(agmW6YV8et2wHEj*=x%%#fh`_Mq5b&) zn+%mRM6zt8jk7ow@}A$s?wWsPaWaIS1^yiMEmZE277Qg69NG%@y?h?Y=wuMyj3bIl z-~DJr;F1mZt{%ZLCKd%FJm}&d9v(n&s98gSF}?%Mvt%a2w;av_w0&r?mF=D6WZV)) zz<}N^O-@b*CQ!d8qAkW;SN8KJ7-=Jradn1%!L20KSMIVA=^%`=$C$N9^CS&YHnW)_ zQo{78=S&RpHEF$zO5`-%mTp6Gjq?u$+#q zW5HSl6ege?0C)m5A8Cp7C;d91d$<>3Lb-cITBbf_1t^(@W6pg)X!`JqqZW-R>Pk}$ z9uWhwr_?-tD}+dGX$f%)BuAVai6FV-f1Z+c0T0#uI@wBeAmrh7$|rBtRDKW99Ia7Z zU8&K9a+Yjy^{6BFODF03gO*13`**Zm!3kotKxPAC=^U+mr4sil8ePBX)2r0!dd1(N zgpZZu@Q?2#PLa{4e}N<&QGJzseDeIO>`1~H^`;VUUd8IY`hBu!IKT4LFlUwv-ymPF zQu|x4sklH$zs1EzgJ1;9MprdFG5BUrgzIgcVcT5aXbi({P5Iw$&gcPAMNI=3y(wO| z`(yd9zks7qGB~6^rtgzvU#tDlA3wMj__RsKgGa64?Jq=taYA=D^o(wqKDxi=(EeL_ zDLlaVGIcx*AfIepdQ%6fUw$@X${X@<{W5MDQ=Wgd_j5{ z7nwo}y{9nS7sxj@?J(MGkxw7V?Uq;d6(Vk3#AJOd%Q%3a>$l8mz$|L<^V)7Bztyz| zi?>!WX)D=%oOjh{-=HnDKDKGIIG$46ttnBG6JwvxT|-^gT*dx&53(|Q(64?|Yn-)! zvUGE+ccCG(uY{-Tt9}=uL>mA^!@$vC8E|G=w*p8W-&3+7^k@01!ZK4P+*};A=r)eS ze)~pwd{^jnXqAtv4hV0{%gZ`CI%D>aeX32^TbZEiKRdHu!q9(55TyJcBZc+_l zv@;uSL4N+A@pvW2(Rd#)Jb7W1>qfP0t*?jfS@djCB#Z!2^%F4-#_kN5;k2*J8o^o2{{H~v3pZyW5reKTyQ%M?h$eE75#J@fbbgyK)%P*>bl35KR}0& zAo@2Wjf811^G&QZWtGPVK=yvpd3#G{B;*nRw?HBx#wySoBbKR-Of0kJCldJ)iwxu< zq*j`%LnGfI1?FSH%yAYlu5?qutrR6)|_H z!2SpfMlnMntG3K+!Eq2JVwe*d2K)P6cA*t0o+osCco+DObS`}Tz28mAETCwLq9w5< zFynMkn_K4eyvvYW*jB}O$PH6VV3%ZUO7sjGdf&;qRv?G`s`?Nu%gLvz7UViU%du33 z&RWh}lm)lF9a7}DfmDNL+V<$+L)TH)ERNzCfx?|2-|OXtk{$6fYVn8yAun`2p_@*f}?^pZ&AzIx0KubiM$bVn}X)oRfCdqhan%c}Uar zej8@|NE^?#t~)>JTU>_tRTt0j`k;kWEOd%CrlwhG0j;P@yWkknO8gR-lAM~Er6KRi z{T-S{c*u9I!@kQP^sG;{+SPS_2h9J3_mAhm7xZQG=eM6ft^!&g*CLdv%&p}7gRY?4 z&D4UX7*T2*$*;Fm#J-%jH)=nk%PK%8vEXvUFG?J-W)tK0KNs+p`XiZPxT208s*p@V zA^EFcAcx~|mk1?XaAD3xMp<8<|H}E%Jx*VEAyh4@M|hp}U#>)+b3%Y+0n^pH z1JA^6Rc|rlLcW4rG_*y%iKUR{PYgz@Su7)|G?3QEe2OP#x|=T`5e`g{|45hrm5-Lz z`@1ZcQ5~097~hK9At`v@wmXg%*6e>Luv(=}C9>#uqdH@5oX&o(GiIW8^kGWwpmk-q z&w6a|XQYBSrI76rNv`8^ovAJn4@r1(_0XFyUwCHvXIkH^R4dcxCs35smBWU6gClir|9XR)8^)BN zDvcMKH|>nchG(U%bME|*?g zyU_*m!U+bYIHE&66P)kb@0B#>bKpdRYEsqIT&LjjTdJx6lcyQnxrxbduYayyfn9rB zM@L8zsz1>eXcpw9B&tF+YA&jI#xwGj2YZVD+nLeJZo4C`0*?^@-OAeaa`!Fu`nPl? zVLkzGe6va@Y7_sj$H=oYFg;;smV1?o%&LR(3t<02!RpbR-pz?9lE{kdPmYFg{QCVn z5dVaWV1-BWXnG^lndtUflhpag!okeKo-G+wR;Cqk>n4vPqFB#?>aii9iTwiE}V&eE*KVf-r|3ik?@2(T~@uKF=-0 zJunr#+vjzY;z}oKtK%Rx7%^%W6USGGx+1{@#-8?%;9Ts3z>Q|D{-tRW7s@)Rb!}I zFk4~=!PW%;W&{KRmiH!&_q4Jtde^)ae54qze~0-%ody{yx939`{6O(w$B5%glW9Hpxj#iR9Cb zrY7%a^87(cdB-QQR+sn>g>y7=;s~%%AwZ3)Ou?CU zu8=WUzosrXU0n9)?(9?)#uR<%@*#iF+O4u+XIicDlpNa6oCmzwU9`hH@4Dpyc_N(3 z>^CZZ0da~TMtXXpd58!Y{s9_WsqDR+@Zg#xig=0I-+LizGkJN|*5e13rp#TKee@28 zrm;ENdfVs5)@qZJ6y$6#w2$9cF0f#V<$)h=$Xf}a-ToSJIxQp5+hkRdVEzzdvA@uh zYf-BHGQt-h=RNnwO7wyNemnpSs^371^pZXlJv?F>%GS`CP$^WqSW8U!mI|S z1*dt)J55&gITNe{Azj(m*~nZesRW?OZnyG9|5S%o z>br3(OKT16FNP?N-x!L;818c%{=?ZiN|U0_inF%iltyPQt!iEkU8~7D%I(keg^uOX z6$EE1u+xZpy5x3T{-97rlZH_sykhnn2kKyHX~~5@>_<241J|-qTq2{fO-I#x9VFJtUA))Uwo>hXHBFE{G0U~CfI<} zpkw5H0J;tUDgi-@4J9{u&9G4&Vvm3e2|G`%WKJP;d+0pHe>`wf19~|2$ZEtQlDqdp z`L_2i^!gc6^xx5p0<0qHkB#cU8*a~r55JI*sT)kd!J(J(d=Ax=G!V$2E(aqsNJJG6 zWa*2Gi|&H(A%?%;KjHAxnDI!2VXGg&zi7@U?=2RH{>C~nn9^+Cj^L0|{jdzY)s9r6 zSo4+WGN^kk4hwLS=j?RQ@w*~!G_TJ6wOI#&JVzC0zJ9)EQ4w(|0Uc+8K&CXm>+i()RHwf`XqnSZ4St~gRq0p`nc4QY}LB-9D zjha#~VGhfc#MI8pBJn8S64Qg>*zPwgZ&fH0OPZ^yz#0JDCriKpYsWYVR91QfBfW+Z z?v$JQy-+IAC z-i@l53h6Izcq@)G92T`cD#K)HrNety+SC2~8n=5O^_;lv znA}6kHBmmVSL!P4Sh5MU-C&jvK!^cL%ahUIHmU>EjHX)$ z-m!+lNrb(A?uG*m(_8o+C8ZHJqpG*RvhW|Prqn$#>ljwv(6cs?Y7nxDsTXh2)Uk!3 z^3+vTJp+dr;D4QOv!sKseW**qTeJO_*dcRXzjL7T+gH-`fL|Jd6=)ncPctK2n$QM9 zkA@<1qv9&mv(0{lN8AR+fUGTErl8(S5@P7UM2(7%X;#@mu&|H-BYbuvFaHLlSh&3NOJ`-?OkCs7x=a#(uKD!jYBy|N3qjr*T= zM4X_1#MCBgq}GObfZ1**k|IRp-^=iBX1|$REC&FE&<@ZgP&tU3wtaCk3OM)GW@RLa zPL2v3POBNp{0*iVjI_Fc+TQ%lJM<=mw&x}%h2;}rsNTrsXxjd*KNrD3m}zq9j!NCs zFeiV2Un0KwKdC5S(ft9(PC{X{+Hz$i$){gf-zPO#vy7ND2i>&}I~0 zLC5w*gggP84KT!!_EYF^-!T+XxjYw#^4S;TS{KIf7!vYyVXsr^5?odo!q)7-)@2?S zFy+X%)6zudPoiBjlkjmtNq&`Ay487n@sF^Dg@c1bfQn~Ex5XkVM5c7GwvJ@2RSL5< zdV()wbAqiwrkWcq+y&-Jc3Am2IlbBV*QDco!S5!2Aa`M2^+(yL6q5h~849!vp45&u zBo!lK1);XKmZ*9vtfju;KUquz#@WoZZpJ?PL`|>Lf9k+2X!RRPj8Psakx@<+pS?^Y zQ#%O-w^t0R^NR~AZrEDY?b>l%cwjzt;?0RL>Ij?0@-pcdFrlb!PQd;N?tMK6*DQ2v zG!~2`Tc59(RcLz7a0e7mP!7x=xR&@g;;P#%q{1E0%%hV;n2N7#U!iJ;Va|WPfMS(A zW+9Tlhh_qzmVEAkJ=7S$2}h5kH((Cc;+^P~=eJivv7cw4q9Q0|Sqd&z9l&6ZAVoye z4P1`b*ENM>>7lQCLVcSvp^t|Cld;L}9GeAR!@{{L$SL5y1SPv-AWQ5xgyyOiK~qad zOtBdS>&&miD~8_T^BQ`6Se#PLB9)xxo|>+CKjO+ieCxZZno5Q$fZrj)iZV@U_w{mB z9VSMLd1y~a-FXdOUSpk&5^qsmBfa+bcCA)MAfEV=iifjf|8B$#udP-bb$o$N+cF)R zV=?M3ytkWKEcgj99uA2=+KdqL^zBF(DLPh4Q$S4`+C`nkpg{pXq6x1tj^= z*Q~Z{SSty~!+vWt@y5Tx}J9y0Fx$vH!~6WibgDIXEI`Zn#-z3%L~WlF;_6 z9#lEeI%vKx!~KtDUdKVll&_sSpJ&$`q zO+Mdm*yrI&I`WwdS2cpfAEe)RK^MRcV14VhLRcg;&Gq;oIrQhp7WjLL+XCn#P)lEa z>UsH)%CgZ^Rdwp-?(~v9xD5Nv?nNS=GqBlTt8WCbu>pR?*+jJG!aw+*oXgL! zHG4Lwa5xwuiIvq=Xayv3NjcPZI^a+M-I2*vnrZq5S6zC@Q;zoCDA69s)PuoM7eL8i zOn1EyP}Nk>?PVu!5aBtIv7!EwNXV>O_W1$$U;nv3(JWCq*hDzOUMM$9Qn>4q#v1QE zfvWAhKngxuDuqO1fe8S_xozix!`~lx7+E3w6jN)qCEl*D57;3^$;gf?Nui{sWH><@ z`(AwGWhcimQ*WC!Kd+e+B)%&-X_^r;WX7A_7mc76e-8ciB2&ikfHqr00U)y#e68|+ zJ-}!B&tDUEsEmpibRi{q$w`NKZm1V1Z;(EvT&`Jy62}3v>zsw)lyM)YV8om@_r@u; z@ZztDl^E672mXe^y~*Jjxd{G#(mw$`Y4@k@?L){UXAuwxywdL}wx?f3I#IhLnv|5f zgl~d_$(k?|UxGCMJ4XnGSA;bd5fKRhT^g@?SM}DF`Ey%YVtd9De=EVM-|QW|2?_v- z4HJRsi5f8sDrv+$2$MH7WL7PP_D9X}29+=%KqcV>d`+oUtc}WbZ)spn@h`wVCI(e$ z2^a;qy1Btb^!-1Y&N8Tuwrke71()Cici*@KC$MpMcXxM(;O-LK-GjSJaCd^cg#C9HqKvtTR zUV@V>OtK&-`|q()*bj+3wzswbXbOoW8w^BVD;|4+MGW&uq*X8tU4wijE-5wS$;g|9 z3OGjDs_Q8w6Y^8h)V>yZA9xP3l>f%K(_Nj!b4I#Mw2#<>sbw7!R3oUy41IaZH?0eQ zL9Z5I4i}j>no!m=K6`?Gt>B4m^W*m)Bb-r6gMfdc#TS0tzgwtZR0-*Jzl z-`6|!Zmow#v3mEJjv@a}9%1T2qS5L1D-klH$lKf$Iat!n5iraOeQLE5NI}CAK|#Zc zpb9bCcf`TbPC#m{q^ESXrwlgn@W4f&TP9U-?IW~=gk}SoCJnoqaH$Da3bsV@Vq+dj zrP&G}8|j-{Ivg@EkEB|paA{af-_zCz2ExK97?)=8b1taDiO5cAbH=)2ifxQ({0!zE z9Y`J)*W%zc^8e3(8(>zMmq|95g6NIYDg1dRD`_lrfS$D`R?LjA@XXg&*G&Zk0Du6P z5r7;8y7T}Y7+zypo@yLk456AYV>6r7b1`6+g=n=Ny2SuJW9$%=D-Qsf&O86Z5@j38 zoZJeCk%LSmZfLI5$CHETKNn#ypGv_N8#{O9zZK7>sdMWOJZRWj0AxqiAP36!BD5Rayfb85KkIYME}D>ZW8ppM3t~B+g(Y|HL+v{7S}k8Hn=~ zp2SA+l`7=d#AeZV8U?Mkd6Y<9hJo!r-%Bq!@rT~$Q#0oCV@=g_)+Jh0z4y46j}qk? zDxha6g%g^*eyO+_#^qKi8*D}XY?vuUQp>G~DW-P_(X3b6bdT(~A&Fao;U|5RvP&R0 z`5QAMVv38#-*P|Sgrkv%F5E`;%b-M;f|r4PLiMU%@;v3fL%! z4p5ystNvU!^5_K@CJry+$d-&>U5P|9=b>MeWTTZ%>5**PUl}78>~6+Bw4Ri#5XL-j zN4`IG%hH|~if+krB3wO5tOK}F zhgAexgLL*VG!I4zG%bEbhjoUMS{ASAQ%LW}YJ&ErD1BBr;lj+2T`|{p7)*L$M30*J zqB>%dlbe+976ZZD=L59%?z#Tx9zNF$wpE~JKuvD^Uxzy|>1s=~EhKfV(Y~a&;yiFv z8)!Gue{M!wy8-pj42ym#s-~$Nwbrl_C~ZZ}Y01B&23yE?U(xLnk#g~!QmwUs)OG2z zUObX-=1IxJTUHE?7^ltX!-|XPt4N$e%=6~KMOK#o>xQtYiZIZJ25}YoedzQ@& zhImNs{NJ6$Tb}lJT?ItaP+lfDuTJ6$OyIOMFq`r>*Xsm6Be!mvvIot=qIUvwOJ(Ka zDQ4iz<0EI+(@6@hVD8a6mMJNtAn$Hi4MER&CMy8+0ye>pUW40Mq9+v=)=Q*dp$M=2$goD zUru44C}YZ>3%_ik+?GjJZ#sZ z6Zql+oIY>EOEsa+ zZ(YS zBVmtCD|1sLJ+hKx{8wN2drs2_J#D-;f3pzcZJN=mG5TY<^)9+g`z)@7gXSJY_NrlS zO)jLfp@PYvdK>A3O|gkiwVzimmn7!z9%xPV`52IxjT?CQ_<&yk2>k$At^^vv+3Os- z{n+2Ptlvz_gH0fR(UHiIutQeB0ZzB6>Pq@Z<6@@T;sM#4`k#ko;)~xHZX>9EuuDl9 zQCE(Ex075&m~A#d6SI7BYp@_yYFB@(JQMAhZ%Z ziz_REqUk_HGdzFA6C{S)ySrbTjU}ua-dU?SU@A`D#ykrOraxK{)nb#S1uN%!UEie} zTFhKPc?&;SzVDY5G8Qiy?ySzn+@=^I+)&-(QqyLxb7lA+D>Mr=8JROC&NF!)l~5K^ zPiP^0Q6fL5R9-c=FqFQVlZeVK3;vNE{Kwg5eTID^XY&(Ser#myQAXRWkg>?9#_Q;N z^BDNa*-pD5C1rufT|CYAK6~fi6Cl4o1H{67$p`_>zZ}?>P#$T{?q8`;>s9~8?Da#$ z=Hv=vg^w2A8ByJC<Fc{rJ$xCh_6 zb;ah^QMS^7=fZg*;LZ5GiMrz?N;0o-<@j+{jT_p#x&Vv%+hMZ8?!2<}6b}tKA;q}p z{LqL=jO!a2VK$@7#XN9N1BJp99ir3^u8bm3UG(wSaclz-h^>?ZvlY#nKB*WtCGx9d zYs#%7YB7oujG05G{n|PsT$e7mI34);5v_|Tg)COw?EOhweF31UxaXlKBlnbO1uY%E z)caZ?BkhhJS2s?*P*~vuoYo+{fRF%Wb|JQ&k9--m zpZnK&=}WoBHxd0uAnWiC$U01{a^yIuUKLF=vE)?lvDm{sn3%`DkY(Yc9@YEMc@MXU zcfomL3I0t`b)Bq&h8`tb9vQQ2?h{7TrtsBpw1bY2YKd5%--<7cm{U8@Pwv~oeqOut zJ|EXZYwdEzCYpFbL8lt1I37T4Gjamjks+J@s(#}bWX@KG`u=SW{{{6;A^D5OSqBjq zufHVm@6fu+2$fg3f^2E=lwj=2QP@$6>tA*Hy@Cih%$@a&xkr9>bfYY?#L^?!t)iu)}u^T7r}0ZQ=E6!Ci+4M zvw9*!laZr!a>|LV+>JC@2M*jQTO4(xLn-3y_O@ebg2K_5p{}RRn}A{0(-dH$QFyo< z^_)$)gc<mWCgg$ep6O2!6e;yTPi$K zbV)H0AhoZ5lQ>o?=rkZ%{N{!z51tQAFDNp?V$`)l+RI^6(~_Qqngmk@ejx0XCF-^i z7q}`nCOU7OvNoAz3)ULYM|16SO~y4GEy~XpicO{|jNiQ49K7ePiU$|RvTG6K+Nj{G zU27ikoioXpXt06j>lDt1cFxpx1`SX1Ihn1t* z^EnG1vqs}5|chNuDKXMCZP7zP5Opf}<0!M-O??p`b>qQ6>W0 zmc6o1{zPrkVlK-sB@fIlU)IhAu~yI-6gLRwYn)`!e=F;EU})X(xfbNvT-0wKQKgY( zf^9Js!Yb{|_eR?VqY=LSBd<*-oPr@$41iO_X7_=55UHRlkatuQUh2~6*fsv#%}zW8 zT>$YwOSZ1*bLoktm|B=$9km=tut-uBT{*fb1aS*d5rxU^=i~EfRC(Voqr!u|6ei0e~IsHTM0pAF= z++)#Gk_#k5_oHjvkq40JrHFV*;xp+m9hs!yV@-X0{sNo|ASeO&^9)f0QUg~YZnb2B z@7EXV2Y!ha3my93C{xaP$XWBrK)4!!_dl-fhQ*FUrEwF)DuXq3rQ$#3Av!zDaG=vz(UnZ- zSvKGcZ-^-%oYVBfhY(KfdfmqW_LCsC;Pg&ynJXH`2*3_(S`X;ZdW@fW+CduEC+7Zs zettkG9iW`CIQLDXBLKP5sWDw2e7<`mQ62qEB>A~=A=L0gIm18p*u7vCJ6;Y z1xO%&>IP)U{QXfqM2Y+Z1%Yt|2-ZyM^H%4+`=`l_AbR3&qEwQF%t!;bZi0wyjX=^Ug`e$== ztmwNvzy-CxZ_JmguEvRntk^mCuMhdt4X~=e?)`Y5o}Sim=pHs*JN``U>DHkO5kUWyp!pdGkP^k`$8tL3%EtFj+_N+_A&hrtBTqY+j=KzW?ySY^qC#h795 zStteu#OwHY)x=`}n+Ls2UM@i|h ztnU2`*iZmkP{S)Z81>`&XJcjyio6psRE1m$LEuEYoc)P_oaS)(H zh>=#d$L{&9jbOvHF1$N-*UwH^(PM`E-jVX}iyyf~5o@pl9ALvA(VEehCC-N z2@U+wSqq%tTb!^M)xscJh(#0TiA{`J$c&}m@Kz&ay)|(`D#{W<#&qMDx)Ll6E4Jn) zN-!*ld<)~q<02!C)3m?w*OZqq+?Y2si3(lybNNM|YJEm*$PuptLSsjt=u8$;H%G+H z2M*)+6)HoHEc62L=~lHz{v2hs7{{ehXX5?t@Ac1gT9;u#ZKb>GHXY>1)OzLB>X*ue z9`9KRx-Sm$7dqZ^b&WRC7z}@FAW|B+0guR~^ja*;`z)>*v*P(45bk8imjV7rRuDE5 zLz9tTx^i#+!6iib#l<4SBAVQ1dy|k`e zSPR%y{o#VnfFr=UNaL>)i7&bs@iWC^mh+g|Wp*gwVuwszR3&gEEFgEKjxr#7MHDW3 zQr%D0kgK3_PDVg5|4#3AIb1ysy_mpGC1!zN5gAxwUaj9@01AhmgEUp3J5_ZaVNl3v zelo3AV&}`$M3{mO)Ws5B3+%*PI8+UW${3yK9_TmRd=H@*gFreB%}|CSbo}FpW8>z- zibn5rt66yKjJ}I>Q*ZCz|HvxbJT=^ZF}N8sk7}Mdaix7`*-u#IJiBwKZkggLv}hld z5S-+yj7nDBbrwv|*EQC5Xtxz!1buG#Uzv#{#Z+S^Ae{y(K!jkD41W&{fPY11%!rn0 z_$!HOHJ(H5WZ~(?#91*1$yZ}yNB+#9iIA+L26WSj7q0^BYQQ73wub+}8n_ZkQPq_t zazk&5C!wZR?hsxv^tu>U1fU2EI!P#;?d}Z%b2h;GegF&wh4xFp zd6*}F_slQ3L zn(r);f_A2x;b{9r6@*9Swv12<7WIDQVqo?)kY-2Mqx&9c5u38Le5$Ak?y74Jg-289;)jDG*^u|U~Jf-2p$R{o@UYGn?K$y%PkR$n0NF%)<@^f$ELuFr_@FT{e)?Ln#9WKE_ zRx19|faLVJK&|4CiC3cUf{W|Tmnq}fCktyvb~W_Qa=tUsHHmL0X3DK;o!InaLGpCD zmyFM7iXtB;!zNSbzNCU-1ifp_X`I{RgSmq&A50N_rHz-8PTN2P5+ETF0*BVgBlb{; z8bXrL`jy4Z-35WlX^XWHey_*-o58xe2%qjv!*JfVyCiHF@p|38P4V05RWS&Zo3Ecp zAmwoDfow752{M^2Q1D0Ekkn;c?gW!7yd}DKui4>1_rz-~`+~kHOf|4{4;}^b0G=OY z9NXggDkyjvu+!Hgvl@hmwTNV-m{_=aP|4}Y1LvgGdumw%r#fIn=utY_C)K3arzdwC zoAa9+bir?`JhdZ5TUxF0{s9nUH&{fx^K9WJ+*j7=%A#iwp^-D@O@QVG&^FqI0gH$% z);z5_1nHGz{O;}}klR;;615x^mkRsEESBxxm^*09ve^ELhqc&Z-U{$vgvT_M5o(t3vup)DTtL1zQ=#x-YB7>z?zyfqn1Hn<aJZ@4$ z<`$SXXiVG%?^}|#AC1D`jok95i{sM8+1?^Eyv!Q?n(lFaR$pHeY8;aPiv3kGkB&Ox z!*ZU?6tWTalbnRp|C*+bkIe%DdY?kM#!!vSce$HG_6{m2Gf#uR%#031vHuJv)Dy^e zSoi0qw5@Qr2)$hNn?&O{oFH`E>jq9nOBx1m0BAd-kfV8;j6rsKrY$|+%|8{3z{&ee zHSx#ze+@t9kFP-f{XYhrB}edXjbI$)C@9hgSVI6+#lUwZFaOZmu&DV0=Xjtlp%>@{ z`mYiQsK&xT1++xoU+#vX6>Nu&Vs zviNIuZ14`2$5=BeanZISdG=~ilZTn#a=;o7uK5Uk7gNhT?Kb`fzWiDPseR?qM#s@9 z5tV|S?7DS2kFXsRf@G#r5;R%!kXX7c;~Jhcim}CFp_~4L`FpYWWU);GCF0b_;NKrO zfcWvh>JE5-%{G|-K1Xtqy58zB@;kfMu;u`LD_)o*l!FW%Jq=e?j${vblmRFQ2F%@) zlHB5N5(l^zTrEb5Hqq0&W7;DUit25xtw4|;=wcJ4WhXaZ|(!=r9uQgG2)xAy7uW}1d+=n+_Lg``@dk7cVl|Qv6kBmh|+u@pUtnJv;zS`TR zG0-soWNNN+elg=;FR6COw#?WvXx;Sc{c73Rc(wLblz&XG>?Kb=E#IxUA5ANJKun!* zHtW}lgvZz%RVl^9)$HdudB01ovB>rFDw$5$hWct7YkfXgBB)acyimB@%z2s^uzW|g z@diszvG0j8J2%s85@KrokD7?x@FV9xgJ0fn7!3YQjE^G{Ek&XAWdwiLdt%)gj zNo)2~)VS*vd4GSd&F>8}_TCTni6E_S|PR^$v<#1AJUz;g0yNzI)))Q2}rvheR ziHJ~3Cvv1D`Mw*yt2kiYVhm$*An%gOKf6yi5J&xEN0t=fCoDenoQ1H`JQkwSVjxs< z%5upyrQA1&=o6+c*rLC9?H#9|m!F#70)ZG$xT zG$0&F^=^>QPm;1ePmxNq*LF98AFP$eW08hsPpb)t*CitmHO1>rhEZA;78NcRJeMc6 zrL(-c5PXAkO}~KF&IoEx4*#u z=LP6PwfMc)D~-+@3K70%x<}$0NCDE8BwoV>9|>hRBmmSQ6L%e>VNr-9 zUPtk)siB`hTp%9rF?`C3e??rubF;GNBPY8xN@e=$Zt2@h31y#4Rvjaa8 zyA(9Wb8pvjw>ez^NF3X@#%6R>edHH3l*;rI`Wkr%wwEQ}8599?>#)2@Z#2Ez+5?s!hM)UEC?a&HESm;bdY|_HznnaY{*NYt@HCFWt899EFV!miK z_^?BTiPybkoB_uPi>GvvKee(lCXJGwMnXEJdu83*s}#ngCo3P2+qS*WYjSgQ^WPuJ zrW|lONhyitd1+@J*Hs>2g)$FVZQ^XQ zOePNH^TDAYhW7A^E>lz;aS{17FSw@jH}4A6K#fJrM3dk`Z6~v22%Z0*^rl!%{Xf2&G*JE~W4^mf4Ar-n*?%;HNUvEBut6l}a1a+y( zK$x}qC;M2LF1`q?P>yXV_> zfn#Y$DW4M+2v|0zn4h%FeE$6K9a_g!zDIReFcmJZDe2*yWcfhH1@{;sOW;42;lR2I?({S#{hifv@ z_9}^^0$8v=Uh6(y0Z#n|a6AT71Bc!>F2y21965Eht{wM9`c^y}h%qv6UPpWSbW^AL z?`^pC{!`Ca4U(mnl@GFI$r0rUmgI6@keD+OIf5{W3iu{B=$R-9f-!v(kHQziD2Uc` z<@z~dkjzc@#s+wsUu#nQpc2-cLf%&ElS{ZlKY<>BLawsP0&<-Ixrowo#l%s!MS}@` zto=zmXR{UZ;z{88uXnfPk;m=;j9*r3cHhM01bloiYF;>w5s#gQlv;7X z)9z0&%rc8JoSdC~XZ`$!B8E^9lL;w8h#E0wCtjVS?0kgF13%;Eh!$!jEsLUzrwXjn z$Y8LI$*|23^!d(H;42{PauG4= zXwMWNW|_5Ajp#KgVfwXb19e8i;R62u{`*iw!uQ_|v0;AZf5Ac>dng`4D$-P zD7UFwfMqsrRllJ`S4+UyZmjEm0*ao1>^G1S@nplJo{0M7ms3RKnhEU%aRNvnX_}W- zNF>Wk%EK3+bS%)|&>qbaJ7}n1TsPY?RO{~%JOj3Y+QVZWsXlAw{;y@Bp+(eOd=ryYZr)+C87(2A^1T4*0} z`+Hn9dcbC^MfxSBe$Ap}TX013$$_Tjk1BcyJZ9dRc<;{j^Isqp6!_xC$1X$7FQ9VO z`Fly4kq;}TG4aHcK|Ket7O56NU#TXM)XY7D!$BZOtmA3ib1lW}A{U13@BtRGy=At- z?%gWAS*{W5N=d{tSb*MgW^{6?jAPbYCr*jK4lU_rUCmD^frEP4oR=zBzMRVv>NK1S z21_?C5d=J-dmaIMt>bO~&nNpCF|@PwW@PS~#8NBew>7?f`P@x{!Y56i2fTal{#|Vu zHl525X47+RgY`D$`V<*{ow3|YQ-qYSh38cl(v~42(yCX;m`naWu9mNU%c2(CTzdHT z={ww4%X;K9&$@>n)mnOHYqX+4nyJ4ezbF}%&!+LqKNVg~&OBQ?OghTNp<(hQ@vGD8R9p69qFf2VwI#86U&%V! zgkOPfz6~3Pkf81?PdONkR1?MhU?LjhS>P|;KVit6One+OSH$2DdMJ_Z5y6fV)o2%O zSGrCWv}NA|FJ#ES>Ul@W?|u;VyImt)-`k~{5A|srzkop2K&68(#xzQua(nm|kPcrK zk05-G<^Tpen__hU@f2npTJCE*2-BznMi7K6hVp52%7-;YM7UgR=Aj#yOIRQ#o5I62 z!rk3EeY(Fm@umJ#AjGCk^xa5O(75|ZqAbg{pe%vxCgm&uJ zCH_Q`9oEGfKkpPZhNuDFCkK5Ensd~pm^1YS3YVGg6%avQeXP32(sxEq5!-iNRe*t} z;a9mH&`AzB6g{1tgVX(i@}q@Q4zE;tQWX=9zhLeXk65Oloh9*#W4 zn)n_>8%I(+qo*lRQw2FqcqXJ^#AcNM4V*%;urgR8lDcb!sCOjEDhm!?o>Xr(nL=!M zhxxmQP~@-mtFF8v=y`}j5{O!WUV*Z~M z`mCz1=V{$$6KE>3M8iQrJ!sk_)DRRN(a+XPq@-g3D4&bw^G@QQv1a@(;5p; zWX5fOv>L2XMQ-K%msd`Ot7H2B^i|yf{D@oPKrv{zC@KDQga z5oW>lq@du=V#$S=O8azLtm%#gdwtU&<=sRy$1cYk3Hgcf3jd_v_sOz*#&0?dr$xbh z=L%0MG-21LAEoBpTWcMkC+r^bKJ)!eON@&^%Jx;Q$?(p_So-XVX0pPQAaAVgBmak` z?Y)HtjH>6;-MWlzvEeI0u_iMK&rg?miID#>VgCI~-yt25U}uBP1qZUE2s-OL2&2n+4Q%6D1*?UI4`s=1pt;{gCRnWtfc389$mnJ_Og_ zmGxWJa1;CgX%HxJg8KeLRXe7GM(NN&(bze<|N7Q}GEYkm<1sEGI3p4WBwK+)qH#LF z9}2v0$zLJO$Q|)2AWlhnGi3pJqjv{BOVO)d$d5@$H!KP^kXl$25);r`MA`s*QdK3C zIg()t)sKvy#2ui(a}mg4Limt=K)W$z?*LNkqJi`C>FObWccZ_xz*QncFq-E89kp5V zWdILiHXJ?S2D|Y0)s;OT5NBoX9Ar$dCFmA*Ec}ZI1qaIozKqx^KPOn~Oa4|pn2e1Y z1!y{o)a)RrV8{v#tJ6wET(+SV{mW zkOVxsfUQg1t9M7}e_x|IyVCHOkQ+dVuOCB4jdmIfl{F0Z3)ivL_cx(n z;4i|S$zvUyyOMB3fy?QHrah=IW`VTAbVI41I8=eAcf1B@ z((+}RxDPiaXzb#UL@iU@B1Jz#*ut3CAs4J`Lv|w|Es1)R1ZN3lcH9-&+i#Kehoyxb zO-#D=P5A#KYVz`C%9oWl#(FE-B2{qJpWOUHhvI{lhWhQKh{zEN%|nf>p%dr(S}xKpE*wv+*%UQBi@8gWf?gVdos{-}p0dUoPspYl-nFyy^oEyb3eB$wC8P zRa-Qs2K$!=yLXGe7sc&4W^}z~c8qpP7n@QUsb|V7z{W-PQOl|JvN$1iPjPCj3n`t| zt0jenJ5yuF!F|WNb^GpRwxzhGx8zqD_z#ekkRNnKST?IoR@#7c;XGr&I!6@Wr`VJZ zDLZH$LWu+{@k<>FD+N#!2xpv@w{wbvYCcjICY}uCssLjsR)aS-zsAl@lYbg2!oY{B z({}$wBvH3SatrnQ3fG^fIeCooZmO_H5j`kd`ajZ?>lNP%$EgHUc~vylMJ@sMtFwcF z9oa#*t^68wfB)gUP)^0_Q{>|EOIl2{Del8BI>hhmCr+shaV}0Db#ZHB|)8w-gLYZ=~SEKj|-Lb7|V%m8vZ=PZG0m zc!K2!pDtsQxi5kYN+48~@R8=NvuA^n@;OxU>ja||?=Hj^-!f9h*8>yp)K+6KLPfhm zYf%dSCAs*a6>9%7S`bu%qBayi3D^8u^f+IK2DFQOfn%Uq@ZRdtTRWqfCzRb$D?f8r~a(mnQCyhN?4Ji!+uF!JNM_Z*nM0h zce9*ZQF&e){&&-_5WaN>?+UjDOZR(0-wm${-;E?BL3214%z{yak4FQbv`e-9hY$X7 zd997u{VB+gF&TL|)eg80ANgymQ&T-gPy9k2HXjQYi&InnuP)q=pMC;qMj(raFkcNE zD{R}eYXYxox(WraY$+$zz=-yD9O`D`@&6&5v-Xg|9O&Y(y$>OJ@L2H*MvE9CY z9#8Xpv~Cfl#FldP^1>GtPW%GW0eG)26z~b&R9gJg(_Ep2A&`o+$axv&aDBKWStqQW z#XYgWlBurel|IE#mWqR^!1)AGP^f9tPy*@d>l>p&?yKdc#s=oPfi7?l zKReJkB+v_z^4aYJFzT#K7=Z`FiEn8s1ZP^m9^Q^$$B+3o)7fPS1Fw z0<^PStC0S_bY=VERtoxW;P0o?NbzZsN?d>Wrq)9os$-|ldhyv>gt~Z|wFhpSHGah2 zn^Ul}F-f6V(}j*$=AYAw8r{3rA{kSl$q&lF&9Jq#Je28Z%{01r02gqg7}57MXwS z2OK|fm7AYl&;Fg}EjKcoZAtByjXUu9G*%G%YxykGb$^51{e9~71Yl#yJ8Du2*_+*B zs)^-wmkobMHpaPaD{^IQjT~+A+GMZKdS?iZF%N`lVrkz=OTxq}7{blAcAY1TpR_NpNzkojxA7)P<|2AvhjBC>=DiNL{im?6=qG|w@4+2k*ehyenb-x$jR;X;*rSx`}&<5MN3F(Z4gr!Oji?OZF1IlJV8Q zLl-!F{qY6rEmM^N@}_`9P`dF_+@-ZZ4!Y*e{JhdlvLuLNH$$L~_6D3|6^gF;C7e*G z@L~_4Lzg*-7Zc_1J8T9*83K_!)j zFy>UWhO;BO3A_cA?nu`VdG3kKQi{Pq)uJnz_N|=dPiV~zGue$FQVj#HQTuYj&K26a zTzKN?D8Xj58}RdgR<+9}$~|G~WbbDd=VGW|ZD<~w(Xv%P7E8`uGB&fMv8>0b*MrHy zUA#qpWD;f={M= zbJAbiMA2r;F@{-qUOU+TfW#zl_L0LX6p&~W-Sl4spK*zKzV#O{+fOUi9^$)Ak?B2} z#IkMMZLLA~iZ-lh`uy0suSPmMWX3j!!-X$^$SkOL|BS15;Ld`n?VsQ2o@vXIixU3i zHVeU@e_0H1TJU^Q&JRB}dt_IvOfQ@>>*A!9$*7~&tPHGs2BtXOW~EZ8*da4&_G7~M zMx~Y~;8K-j+vrJVcV@|`QhBy7W|F)nmM45%zh7Ia_|$S+*6|Fd(uC3x&g!c=r|=3@ zu^v9h4)vTIt1;uhAK4c^rz{l1C}mdrMpLkrNS{pLZF^S8;_Y_&x{l?3q8TGAQKl%u zJ0;Rp3;YvaAZwcvX}Bz?RDtUY-7>AA;_2n_q_uHaS+VZb0Qe7lot@b;Wto|ogTEA! zlW6c;ne&`fcE5_73@wuB=}~mp9)^m}0){xONjMp^%v_^H2G|7}cl)=)Ba? zub}c!d25&^2z1H_f>T&H;n0RoG8mp$NTeY0FvnxP-UNS+P>9}@^(rb>8qyi`zRge; zxj3SrRVZ9))K3zW?dc4Xav$O#;8hN78vX-tb3u&u9V9HEBk_$yhqW~|srY0%^PPpG zXBef4OlWQZt5*Q5YqU-q*{sXVs|*p@w=Vo;4!B-`a~2OHIxR>=oNd(K^rZ$%PK+;Td9UjC$dq*OXo@VJzw{-_=h?=BnCdV`rs?=HqObPMXCm#J zsmmDW->jXWNtH;L#93fgJinWgE{=K1&^+vBQSsnA59*Es(z{qF|BN}{LS*G63*B>! zd_0yM{){j&!rq3w4CQk18dAK)pwjHhPBar; zS*cv*0eomlc+^pa&P3>qVQwBY8D;Fa+Uf-4p}H@YBx>EH{vym_+U!f}Okc1P7+Mdk zLBy&$eIflU?gfiE6Fv`I!|)983q#G+Xv)kxmW40Q2;Nf(-QLOS=~|@H%;&#g`KOys z`iEh%li43TKML12J}k#?C|iLx{{yZ0L|LK; z(+rlL^f!g8IPjNd;M9E?Sv1oX@j^A8H`Iq}rfarY+wNaaq72qik9QmlHVh^%Y~ zU-q>k2n?Fvh%y=UP)_q%Deez)t5844XEr0Qy+7* zzC6uF0SFy9wm?V(%Fy}<1ewpseTLLy&_fV1pD|lQLpR3CJ1?0xTsi4A)I8KR%-qel zS2~_^{`UM9w}msP>D3U=@d0g>%2`yIBy@Vo=S02%7Uq`sx4M?l&@+cO-2p`&%v$;O zrB5g_uGFC#etbqujL$0z{%((z>c%!|uldcC5e96GpFVvuRVLS@=ScsB)p~fwV9?0& zLRi{URW-zHqimzuS#LU_LP+`O*hQC^TPnAv+v3R7J8?2G#O zjgnJqqoKn_2F1MUNKvcRJ|JoFwTR#TomVAjYk6S4t~lYbjwonT;ATO*nL1?_z#;VB z#yZ&A+pAAki@Y1y2{+(BEhgR9_MMc}rl%22(wwS{|E z&fE&cv-R8zeEP4r2C=+5;N#urx*JICOC%<(PB=psXNAD)GZS83r&Ya@6s`jd-*WTG z2HIlib-Fpcj&DUjf*`QQ3%`Yx(z+39!}f)t10_|T+Vb=B%kJWHI1p0F zM-y>za1ae-$wsuHTVN3w#!1~NdC8lqp!;;%nK;KW=%~sSU@nc@6DF5zk|)l_DT_pJ zBpo6ZblJSU!5gM6SaQ`T<`5K`8u|yL=A^w4EOZ_>?3NiY+0TFdAk5ku(50lQDj!Q!|>G_ zv*p4g*Q8D{L~k8K9j|;4|CG24amUi$y7TSm2`B^tT#T-KVlapBaPWhw74l7kW(D}{ z8O;f4KC~)W<+az-x2tPlh4Mu zL4!*Rb{tpY@@&VN15mQY?xtYfNGArGE_e8$zc(yPsycsI^WfdB;Jc3nSe@RUcPysN zzIa2Vpun=}>*^9A!vU|$FMn4@ed8D5`onz7Yq)rQc?qP>gcx;UQjtx9)|rlWe*;wp zzYNJ>;-KGjJ!Qo5UlJFgi|`5c2Tu?sK%=4@o*ek_Tp3i=(5Y$CGx zU0?h^n$9^Y@Be?}*|zQOY};72Z7$nb#vPVz8_Tu4T5h?PwH6nC@6Yd?@B8fZSEst$ z-Rt$lbv-VJ^l>__xA>Kg?IZkf*Ucr@-nV7vdeX{!?4TsCRezh>d=tdZs~MFD38uF8 z?Z%Vqr3asn6|Vck6XE?@)5F4tweE+5l}i~V&XKm}<@`x=w|d=k`g*R7D|)Z=ImWHc z+>_mmvfwZO*0+WO{~2cC*l(2?boN|4PJt`#ONc>pMgJOB)PArjD%xSZrfXsoU3nMN zg6sVz$IFpBFm-h*rFTPpUF=nI>KM*cB(#)LM z)zk#>mN+ai818U0S|czj8~9?iosh?96D zz4(QMkcXAF*Wzde=qR1$2>0tDiZZYyhJbw^An~M(Yynl%wE>x3sHjL}Hxqk%l*$SM z5W(1rj6+#~ol!(sm?qDtY#?KCY;3GQ;89u}Y^!uF9XV(#-1_j|l>_(_<;H)N0LxQgUoai-ItFjF& zB=QdI75NmMy1Gh+(zt%K1A!hlTF$ja6fJc(ck{AIYT5^hLHt*d5 zFy!@-ko|OU#I2gyNr9cRmCDigFirT#JWGg$fYaQz7<$L^<8s^rEMEg08DPXNENta{ zNN*Lfa9TQto<_MV{~l#*S*u6Oq4s_>rLCL4?Vgl_99v9JYX5e{~IQB;(DG zQ9>S8udnNCjV>-~%;l8R{{u*rz+4V^nvW`FA6o9JPQQ6bPylL?1WY?GVKP9P06a?c z5z{|~z+bD@1<%tu^i56iFCXW>4ZVK!h#Is~KGfM2KUDu1P3zr0IcNcxNNBT2dW)&?)0dHG;0-GULbg$PT- zDIM3*KJ47|!T-Hm@6T5oOKpYSlIfCJJyk#N{sHdHN7MJ|kZ!MYozIl%^$$0$mrq}V zZ9MNZkb`Uu-xbaUC}FN|{nggci+-3W$b0MCy`?XIX_(%F=Mt(c7y2_K08yWc$hv2P z06AOtfQ-NL6sg3@#_K`Ww&x&k2vxW9^5LJbX6lt5wn++Jq52b~ta78JXLuPe5mgb{ z38w#)(y!iKGT%%%$0iC{2w;R}=jH$f1$^x!;iZ#!v2I>@vkgGyzW;bJ{QyAdHRrh_ zmb3Run5t-8&Zrf#;`I67ggkDn=AH{-D&1&Gi1<*0J*pvIM_}FQrtfw?DVGWvE*AT` zZIrqRYbxYNYlT$NT5}cGT;~^F5m@FISdh;o%YK6)K64075gUFntmOYrsjb}1#nDri z-cN^;?9O!0#S?vJnLL|AfB$C9O&3cM&#ubbmffJ`=0)c&{e@*VZ*+2y z(j%owX4G$-&cmS(>5y}^m5{3i5mzj`V!zFquOz|k7|{rbKURY(yG#a9|Iks8cj0Ij?gS(3Vdj|=PX@an)U5yR5XPULKmRyED zLzE(Gn(+cBs5yT)>m*KX4U$>vZE*pv+Q#tk@WuvFwkV8LMQAtNXt7z=a8+0_qz^=v z#3iMdL#`dW&%QiGA-0lL0xC-`r4%0lijJ->BCf5W1>6v%UlPXnN=IrU712!A*XH<7 zRPzqYa?JBnx$zv5{W!z563lhK0_Sqt#~b-)%rpqn?Q&Q#oZ3lPg{i#*|9ePg3=Q@4 z#I>ZwDsL^B9STADP*;&fvM>=1_AMCDaY5|NH2lGBp~e`VSehw>;&Kvz5DcdvHz#K= z5nIV?_=_Y0hJnB)kdXm^2ADwfBfw6u#9zlqwZz0A*OFaru-(jDaR!Y*1R6Fub7jQ~ zHG)iwfq02l2u`|-As)CO05gQ+YJ>V0l!Z4g7xs{M-4VlBi9EX?W>0#-K?Z*GGDls% zX(7Q~@xFzJ0JbpK{q$%0m(9(UA@OB13w=Xv*$uF*0Yy!mCUYvU-e?4Qqu(=16%PA5j`dN`C*WZz|E-{yE9B*!em> zWe(ikCOa?P*zqha4sB~8B4?bFw;GR2#tz+Ox?h$|x6nPG=&&kd?D}`(iY#wknD9q7 zgM2$_-;;gge&=kY{#d7I*>qb@UCEoe|DuZj?DPEl^!kdt-o|ugw>DsDLz$vx`!1x!0JzkO@JsDK zW-*E$iKGPGgcs>4mHgq?0>J%|JfWndH07z?70EI*s@==g&(hHXEjD#Y&k@O1fnfH{j@(xdn*0sJyst}-ZxhdFqbzt zS@vhBrJ(rwg)^QMqW5DUkzddDcc@kRSS8oCRq)susC|PMImP2?(Q)oJuc^D*4wU zFhqqcE`x0O1g%=_lw`*FL&`?Lyf@Ov#3@c5}!xAe8iRc*+ zVsfg%XNRQMB&>!1uM9|Gq7Gp3terYU5LObZ;+qKa(O)a?$dLR54TM| z%`P%~wNi+$QvX4S?R=N|NqfUv(uE}`tC5Z|cDUy3Z|1~lYJi@#q0BnSr0jX%6|$8O zahLxGJ<9?ZIDEYA0RLXwfLWEvZyExaqVMRPW8Q+UNxIkTs06CuEkZxQhIOu3q;bX_saDj4^*DE$`v+(-prq z{}X>zt&wr=%9nj^PoUoA9_n3*_411)gZw*8k<6hgrEP$!_Ae^2gQ&tsCZ^ec6SOH% zvTHVgt0>}39~L48(anpRJ^q=x(@=f&B(tDfv?0N007&lzk-3Cb;6vP$c)qT^}S-C@dqeeO_b zcZgipoYnHsJx?5BxlDd1_IP6LuV~O@b!s~NQ+~p%FNd_BdOLVDHWN}s@3XnvxFU!; zOHDpde}XPz^pSXlQdCRax>?kJ)3(j;HTr6@OI!-~)adaOLTxipsi$?<^-6TFrM7&# z6;rV+wNEj5RxOnEY57e3v%Y(ui8Bkh+PJIa?cI=(VJB*3ro&`!;67q~gVEq}2Fx#y zGu9wn_S+sigt;X?!myFJUv$BDYL8{wBPeL=m~jex+t~D%sGW9qKg?3e1q?bTqQ#Iz z04~~;#G8dR9N%8GvE2l00mmomCq{u|fME{%ND~Rc1b}^Rx>}FEU@Yl@kADBAYv_q( z1pHq=&&l?6{u32618JjVRPcSucNSpAr$?u6rP{GU&XGL zq#po40uc2=0s@fg`Fb@fKdQ>hX+IAE(b7OXk$}MZ+8S^q2?I(cK|v_gVg;n@S%C<< z&@SLFY^x7g<9m8KdCi1%$}1V*z-Dkap`6v!nqkIZ0f!3kb^A@wrFr;S&==JWyy?f- z0iKaY<;mfp6+1zSg~khlmR6NTM>rSumo8f~MxVh?a1le#&)ry)u+aWEsk5qs*lJ1T znQFV(5cpjIlrSdvEIiBm`}?i)qP{r=ltSn?VLP6AidbSt z1I8rc>P|E?_SzkqZE!^7kwmh#`d}cN05E`w3pk-r!el2)szQDa1V+N#BxtsE1i;>w zVs+TTkvSK~I4)w!;f7Xe2|4WuQ#-^SJ(?Zi*Ca(O>CErZ4uf7Sg%aZo@NQl-q&W2W zkf+tTMT!h83&@dufXMI+4o=!zHo@KA9+8RaL>SSOz&sW)D%IH~v~+bL%&V`X@cYjEK7kVwQ)}i4 zk;Ot)*QSF+>`+z7JlFhy4Xr$Y&vbT1MO;Yjty`R0gfe?`BdAypB*I+Ytz*z~x!T2CPzEv zpi@>dJZ+cuprE63@=jpCVl;YkYs#3N#5{TZ*;2}3VFzdHW-Eu4aeO+N))(7JKM|K= zNSiGAP|J5wQvQ*pZrFVYv0aEbcRV?(RooH>%Xy{?yaIr{D<~>TC)JE+`T43rP)4as zV$wF;bF%Nvn3#0%YZKYg-w>+<#Yh`WKY@~Askhzl4#_IVDviiq9g&!ic>lA);$1t|u%^IMpHaHnLX!N}yAf)}cDwS z4@kq_9g7E;tj1dZCz@HVg$)W()hqBF2~ zJ@-69S6KI=@vpDM6)d!gAf;u3X@gyy`;g>$>FMc#5M-bdoE-Z+EE=|f$P-`qJp-y? z=u-xLOH&g&2^yg72Z~FV?Y`&Rl@N2eik^q}Le3fKMN23wcJ6l_b}e!%QTOlE!c=PM0e$UrflBAMSmnahssgA$f|m zQA=o=T^N(56lYJIXnHnOfGYqved;*U-kZt-`pMXl&hwn=f%PIVAP=oye=^mpYN0F7 zALA7f6^%w@2rXiWkBWkwT8q=J3D+`fFES|ehW&t&Pn(?X9c}%hbIqWCSv@i$rDhN& zlnJ|rq`A_qsaU;p%?6Y`{?p*))btdyN~)PCZdH5pg@U!JInH+qkll6$7IjgpP{k=A zJ5M@XOIw5UdJ1~()iFANLL~z&Kq06DiCYVMX560b4j0!JS+}9;E>$_ zqxv0Vr-kirfAKXWNC$>{>-dZ{HApo@8VZZZw;0d(<`0Vc?LMK?>jriS5BAjo?jdfA z-_4k3K0B2sVkBTd{U9SI!?ENQz$9zcex4B+v0C~&qz&L}isC68Lxa@tVRsXwMrJsuc8cleIg5T$NXWr;HC_t#fO_v>>f**k* zd-+J4iU^cFYYZ;0l=a_?ZHz3VnfOTK{1oll!tD1^YhUR*VaY5X>Orsd%A$+t_+ z>?rR>jypj?I?fDPdOkVYT3YI8iM^lM04m<;aO&_xeKE0^a8dOR5Vzr2{s%+|p5sEo z5B+Uh))F`x%YoIPB8?6LA&NI)w_F64nYm=@9uQ%m*11Lua0xu9ETCjP{LKAIGi%1* z^|2C=FkCO(#Oj`TbC{>F`V;GPS9q{z^61l*us90}+^z!_&vkKJ)bodfTX;Ts0Dc>+ z_n|86-bQnk1-7gLTJMtLQs=q_=~CG+rhz8*up^Ilp&i`4;TxX-LkBJH`uDOEJ%uj( zOsk1Dar8C}X>Dg!wBChyWR*PKC6{0;#e4mW4%2v=Lq*zlp zwyMFly=h@W-H0&q2>n(a8x@m_lDjz?AOjz)COd)@Q_=d$=k>=gk2J#du?~4~$R_Ta ze7FmI3w^v@-9U}d);5~M95XRA=PTR=Q*Cobv?(1!EOKNrL3Me@e$%ZeU@ol0tiro$_DtnG1Gt~g_nITdJ*Ljc=-@Gai>O}!_nWUP4)9_n1++0>2*M#X=yk( zXz?}7o$fb2+BQJK2OI`!q`MSyco0VP-m#$QfkvLmP^ zDi{aOoSC^fRuBjRC!Pqzqr0YFd4s?%O<_;^lvhvyz$d1P)4VdQ# znjB=T#8R{=4XpLSMP}>_ggL+o9yM5*5z24RZYXKZi0SKOeW+uj0)51VewYVjHUVw# z|2yL{)p4S7qA>stNt8O&A_u9Xqa%$b_OAR6kox&`AFvTvSNuLcme3Vwi0rSDQeW5J zr!LD7zZ4<(?C;;x-=9bVtgw<;#H8#M)T<5PzJ!@iG;OZ^_h5{R5TFp;9UWQsq$GGG zm6c~eOigAW2~Py0H}YodVxK2 zqHcI4zqq^Nl{j<5Jm;H+In$a?Up=4*IF;RrhO)WTfZKdzFGV#9gWwq0_rRC|^{3-E z&@>QV*A`PZFLrSC=i^+FF^V7@S0MB33+rroXLCyg&w^RCev53STKhs6Js#d}e$}C* zqjk?DO6H{u=eraA^KS9NasVRSfhx$SqjS9E79M%xuX41Wf-O?+f=N-nAU{Q8Qwn#r zdtyQ`gJl-v3~P@Ouj5|LBMu%j3o-tPmSF<9_cktR88bpJZ=|l`b^tOFo{A~&_X>88 zk_5<*5a-=?!6QT5{D8ts>Cu1lM8~^|k+kq0)vFpyi&$GQF*WN6 zJ1`n9g?LnYCcv_#Op1@(bhn}1os~2k_l5Ax=oT6C0t4J=VXGc>`$oF zhpNO33iDc{Xi--)#}b~<7hWM#ZlOQ9Ix21jCcJb`EmVaD)GykXOs4G>hAZE=3s}V@ zyjnpDF283H&|FqNX<$2Dikg1<=@8FRkafIQ-4E>ESI>`kn?l#z$C^Ffq*|aW*jQN~ z9tfHr?f$0)cmN769UUEn*oAd(mlE}N<8QR}k1M1-Cripm3$4a0))F(E#6vVN%#Wtgn>pZ%vX76#-acuu z$ErY7HSL;#%g8zE-O&c5xcsVCCAT#`~=2AMG z>4>E4RZ)A$EW~f`YZvUAYAM6xcGsN= zwg#rn04o__ADGBEaW)!?p{sV&`Y^P2ba>zWo{flzfJY~@!xPRci7}h`)#t~>C*{p8 z@p!!xa*f}oJ6y%@v(dh<%xV4u#baBK*R3_Ri4H%UmRuOfXBbxw2-{aL* z-W@QC2Y~x6ZEf5HD88}bnqvMk+W#IEof@9XY8MMT&Nm~gbmoQcW;*wpL&*Lccmh^u zZEOZ4duUb~$(0Bf0ox1TS8s^`P+DSQA^_N%f;tAATze@lPEH^YNE`$EqtETIJ&&u3 zmgH$THsu6FiVxF@1KS>Z7B#8Yt#yTzrSq`tltZQeEQ-f(;IHT(kITwsjAA64P^h_V zY(lbTI=U#g)f$+sqb-eZ$gV$KTE z+d!ErrN4UyNFpqc-U%PY@obZ6)a7t?9`nX1oFUUz3BRA3ds>&jK*#<5C2706;GmOX zJ?ZXf4JlCti-+mBe%*_$gs-G(rJW-61Xw-QCHhSOdA74t=CACP%uL+WIXmcw<^)ST z1T7uzOthS~)aknnEM^cPIRkHrQkO_XU6MRh4uW)4*Fs*aSZq8;T8TuVuP%+Dy+qFG z35=UnG-f}%rB99ZU7OJisqI*~b-X<5JF>pB1p5L6npJ5V6@=bLojWh-z{DxyWcd>c z+Ro%GO|$_cnQBj0*Uc%22_Ko$oe^|m%xmGKtzAc?-_~xKQyta5>?;k`{^_=7LlILa zsbs&i_}6WVorYWXm+jghdI39v_Pk49sp(?x1l11uYEbvjD4D`o?@Cu>xubN)vV|nP zPbsJ?b%}dvC_8_N3{gxG13gaaUuhFN9_;)sJhZr1x7CZahiQ4{CMmDmp?CVf&?@}w zE3GXZ8&X(|w_%FgCE5C+AbCbBhnMwP#v!f#ud4^4>ld_1UCvTX5jLABcfs&Gr?(I( z>^;;ZsEbN!9zR(lECMe|qU1VuCdE_E*YE0&r5TB0w5)oUDK21iYPRE*80ixl3jVBi z&Wfguh;Pd!4O`}M5BfXn)%;21VTTa@LqjGheZqFC>8ZWV@P}kd{y(`LTJaGtTf6;0 z#Xj0#LAU)DZ@VsoyAyn%PNRw8dBUyf7Gj>pp;IDgPCzV~HK}Xa2OKZ@GGf>fTX>m{~&ILD~Deu2LHf;%ld! z#~>jXfG=nm%+AkSraecX?o2e7vqd;bu#?MeSk|`o3=FU(#lCX(P~cITC|hHm{~7?2 z@4tN`o3(2M8RmAP+ZR|2w{d}4Po%eF9z^%j*tyuhI|`wX--i86Aq_sHFK-(ps$1Du z@a?@j`IsKUa)rmfIjHV-d}9~%M7WwR)7R1oIeA~91JD92kUwJ<@<|7V5n1&*s%dfRxfZtrWFXTgX1}o8oJKD>ca?aTKdW^dJ zL`v+m8anW2>F}80)3Fv_c7VHk^T5DIdt=b$;bElksf_w75Z8PwblsP(0RSGdzkUrk zukTDd@IWk47~?}1MOG>%V^go(VOf3rQ`PaGHV5dcGnQo~?yiAh+OA~dYHyRnLSRzQ zyub*JjOoZr8JUvt>MmW`z%O9332a*GfOt)9LpptS9A#EtbGw*fhl`ZM)K6B*Qkm@*JU0&M5Pu@&;U{KU?A{UfFrTPFxeX;G8s`B-RttXI7AvTg|I}yb7MGX` zK_gK*J{x~u2)IKPejsvy%SW%0yc(n-l_NoB7}^hIz_b^5Bd^ufS$BB5zolUY{va3* z2aph__IfV4rWZoQRLK9C$;%x2U-~hlI>BkVY5l}0;1q+d&Nz_VcQM%8}&N@3e z`GyNfZ<#d83BrQWD?ZN7m@r=u1S-3#poX7Cgm6(IM(KJ18c~TL0m_d=hVrSFH;bRt zgA9--^Pm#oej_-zx?;7hiJBIgS(7YDzCvNtpR=Z{$(1PXDQb|UEFJk?P;yRf$r@;7 zlc|G&9+S9T?0guoJK`%Bb*dQ|HqZoKqX5!h6XPyc@3+#f=*ma%MCqcjMg`7W=*sF0`y&SvAj^a`0Q%)nRIH^^>| z!U{084h}9LNCmV+U~lf>@Ra?-Sh7smAsYN$4We07xVC62!4G)nqM)23YBLv$$?yF7 zak7s$Uz1$!R{EOmmm=ei9^poI(nmZo5%c{OgkJ<**vkcG1*N zmP^?6)AGxya_MnXkG99QNc0Ngvn1rqon1ji1;f(f|0;^UmC6^AJt&8pFj(xPk9o6~xl?c}3Jp&T$K}x` zwxV)y>w6pj^p^y3Ws-8?9Wj?pEV>&}`N`gS_S;606k5Ha7;<}r&N*5Fvq+IpkZq8X zN4iAC!@qBB(iuCV{Upm5H>u1nC);=&hO-Og{EquVEhs*P zoPbX=>)|9>7>s3|6Jt;4JJm8uYh-FVQQ<7Y%Pnwf;8?Hgc(C%NDPyYT@Wi-Q^ecJT zJP!#PhyE=Tkmn^^irKtuR_$cC1RXnDN0*C$DW8tnvusnhgE0*7TLcA%&+ShQ+ok{# z-5h`g1@OWz6sYyDZ*papD&yBc19z?M835Xt^Lw%+ArbY{7$WxJ#{(Ru}! z*}~DsZz&aaYK6Un+1u1uynY}jmu>LPUu!Pv8WX6#rS1CJ|82CZXRBwlzt?G8W*4KGw^wIuv$bE331{WtyG;{rNp z7VoDL`f+)ILD_K`UE2BBAaQ?vxKGVl_I!hv;br|Zu9x9fl3fDRvc#GWF= z0Hq+X{}{Od8Bu5

w}M-=^_us|_$WTpy`BndzTxm-SFz; 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 score_thr)[0] + for i in inds: + color_mask = np.random.randint(0, 256, (1, 3), dtype=np.uint8) + mask = maskUtils.decode(segms[i]).astype(np.bool) + img[mask] = img[mask] * 0.5 + color_mask * 0.5 + # draw bounding boxes + labels = [ + np.full(bbox.shape[0], i, dtype=np.int32) + for i, bbox in enumerate(bbox_result) + ] + labels = np.concatenate(labels) + mmcv.imshow_det_bboxes( + img, + bboxes, + labels, + class_names=class_names, + score_thr=score_thr, + show=show, + wait_time=wait_time, + out_file=out_file) + if not (show or out_file): + return img + + +def show_result_pyplot(img, + result, + class_names, + score_thr=0.3, + fig_size=(15, 10)): + """Visualize the detection results on the image. + + Args: + img (str or np.ndarray): Image filename or loaded image. + result (tuple[list] or list): The detection result, can be either + (bbox, segm) or just bbox. + class_names (list[str] or tuple[str]): A list of class names. + score_thr (float): The threshold to visualize the bboxes and masks. + fig_size (tuple): Figure size of the pyplot figure. + out_file (str, optional): If specified, the visualization result will + be written to the out file instead of shown in a window. + """ + img = show_result( + img, result, class_names, score_thr=score_thr, show=False) + plt.figure(figsize=fig_size) + plt.imshow(mmcv.bgr2rgb(img)) diff --git a/mmdet/apis/train.py b/mmdet/apis/train.py new file mode 100644 index 0000000..b4afa13 --- /dev/null +++ b/mmdet/apis/train.py @@ -0,0 +1,225 @@ +from __future__ import division +import re +from collections import OrderedDict + +import torch +from mmcv.parallel import MMDataParallel, MMDistributedDataParallel +from mmcv.runner import DistSamplerSeedHook, Runner, obj_from_dict + +from mmdet import datasets +from mmdet.core import (CocoDistEvalmAPHook, CocoDistEvalRecallHook, + DistEvalmAPHook, DistOptimizerHook, Fp16OptimizerHook) +from mmdet.datasets import DATASETS, build_dataloader +from mmdet.models import RPN +from .env import get_root_logger + + +def parse_losses(losses): + log_vars = OrderedDict() + for loss_name, loss_value in losses.items(): + if isinstance(loss_value, torch.Tensor): + log_vars[loss_name] = loss_value.mean() + elif isinstance(loss_value, list): + log_vars[loss_name] = sum(_loss.mean() for _loss in loss_value) + else: + raise TypeError( + '{} is not a tensor or list of tensors'.format(loss_name)) + + loss = sum(_value for _key, _value in log_vars.items() if 'loss' in _key) + + log_vars['loss'] = loss + + try: + for name in log_vars: + log_vars[name] = log_vars[name].item() + except Exception as e: + print('ddd') + + return loss, log_vars + + +def batch_processor(model, data, train_mode): + losses = model(**data) + loss, log_vars = parse_losses(losses) + + outputs = dict( + loss=loss, log_vars=log_vars, num_samples=len(data['img'].data)) + + return outputs + + +def train_detector(model, + dataset, + cfg, + distributed=False, + validate=False, + logger=None): + if logger is None: + logger = get_root_logger(cfg.log_level) + + # start training + if distributed: + _dist_train(model, dataset, cfg, validate=validate) + else: + _non_dist_train(model, dataset, cfg, validate=validate) + + +def build_optimizer(model, optimizer_cfg): + """Build optimizer from configs. + + Args: + model (:obj:`nn.Module`): The model with parameters to be optimized. + optimizer_cfg (dict): The config dict of the optimizer. + Positional fields are: + - type: class name of the optimizer. + - lr: base learning rate. + Optional fields are: + - any arguments of the corresponding optimizer type, e.g., + weight_decay, momentum, etc. + - paramwise_options: a dict with 3 accepted fileds + (bias_lr_mult, bias_decay_mult, norm_decay_mult). + `bias_lr_mult` and `bias_decay_mult` will be multiplied to + the lr and weight decay respectively for all bias parameters + (except for the normalization layers), and + `norm_decay_mult` will be multiplied to the weight decay + for all weight and bias parameters of normalization layers. + + Returns: + torch.optim.Optimizer: The initialized optimizer. + """ + if hasattr(model, 'module'): + model = model.module + + optimizer_cfg = optimizer_cfg.copy() + paramwise_options = optimizer_cfg.pop('paramwise_options', None) + # if no paramwise option is specified, just use the global setting + if paramwise_options is None: + return obj_from_dict(optimizer_cfg, torch.optim, + dict(params=model.parameters())) + else: + assert isinstance(paramwise_options, dict) + # get base lr and weight decay + base_lr = optimizer_cfg['lr'] + base_wd = optimizer_cfg.get('weight_decay', None) + # weight_decay must be explicitly specified if mult is specified + if ('bias_decay_mult' in paramwise_options + or 'norm_decay_mult' in paramwise_options): + assert base_wd is not None + # get param-wise options + bias_lr_mult = paramwise_options.get('bias_lr_mult', 1.) + bias_decay_mult = paramwise_options.get('bias_decay_mult', 1.) + norm_decay_mult = paramwise_options.get('norm_decay_mult', 1.) + # set param-wise lr and weight decay + params = [] + for name, param in model.named_parameters(): + param_group = {'params': [param]} + if not param.requires_grad: + # FP16 training needs to copy gradient/weight between master + # weight copy and model weight, it is convenient to keep all + # parameters here to align with model.parameters() + params.append(param_group) + continue + + # for norm layers, overwrite the weight decay of weight and bias + # TODO: obtain the norm layer prefixes dynamically + if re.search(r'(bn|gn)(\d+)?.(weight|bias)', name): + if base_wd is not None: + param_group['weight_decay'] = base_wd * norm_decay_mult + # for other layers, overwrite both lr and weight decay of bias + elif name.endswith('.bias'): + param_group['lr'] = base_lr * bias_lr_mult + if base_wd is not None: + param_group['weight_decay'] = base_wd * bias_decay_mult + # otherwise use the global settings + + params.append(param_group) + + optimizer_cls = getattr(torch.optim, optimizer_cfg.pop('type')) + return optimizer_cls(params, **optimizer_cfg) + + +def _dist_train(model, dataset, cfg, validate=False): + # prepare data loaders + dataset = dataset if isinstance(dataset, (list, tuple)) else [dataset] + data_loaders = [ + build_dataloader( + ds, cfg.data.imgs_per_gpu, cfg.data.workers_per_gpu, dist=True) + for ds in dataset + ] + # put model on gpus + model = MMDistributedDataParallel(model.cuda()) + + # build runner + optimizer = build_optimizer(model, cfg.optimizer) + runner = Runner(model, batch_processor, optimizer, cfg.work_dir, + cfg.log_level) + + # fp16 setting + fp16_cfg = cfg.get('fp16', None) + if fp16_cfg is not None: + optimizer_config = Fp16OptimizerHook(**cfg.optimizer_config, + **fp16_cfg) + else: + optimizer_config = DistOptimizerHook(**cfg.optimizer_config) + + # register hooks + runner.register_training_hooks(cfg.lr_config, optimizer_config, + cfg.checkpoint_config, cfg.log_config) + runner.register_hook(DistSamplerSeedHook()) + # register eval hooks + if validate: + val_dataset_cfg = cfg.data.val + eval_cfg = cfg.get('evaluation', {}) + if isinstance(model.module, RPN): + # TODO: implement recall hooks for other datasets + runner.register_hook( + CocoDistEvalRecallHook(val_dataset_cfg, **eval_cfg)) + else: + dataset_type = DATASETS.get(val_dataset_cfg.type) + if issubclass(dataset_type, datasets.CocoDataset): + runner.register_hook( + CocoDistEvalmAPHook(val_dataset_cfg, **eval_cfg)) + else: + runner.register_hook( + DistEvalmAPHook(val_dataset_cfg, **eval_cfg)) + + if cfg.resume_from: + runner.resume(cfg.resume_from) + elif cfg.load_from: + runner.load_checkpoint(cfg.load_from) + runner.run(data_loaders, cfg.workflow, cfg.total_epochs) + + +def _non_dist_train(model, dataset, cfg, validate=False): + # prepare data loaders + dataset = dataset if isinstance(dataset, (list, tuple)) else [dataset] + data_loaders = [ + build_dataloader( + ds, + cfg.data.imgs_per_gpu, + cfg.data.workers_per_gpu, + cfg.gpus, + dist=False) for ds in dataset + ] + # put model on gpus + model = MMDataParallel(model, device_ids=range(cfg.gpus)).cuda() + + # build runner + optimizer = build_optimizer(model, cfg.optimizer) + runner = Runner(model, batch_processor, optimizer, cfg.work_dir, + cfg.log_level) + # fp16 setting + fp16_cfg = cfg.get('fp16', None) + if fp16_cfg is not None: + optimizer_config = Fp16OptimizerHook( + **cfg.optimizer_config, **fp16_cfg, distributed=False) + else: + optimizer_config = cfg.optimizer_config + runner.register_training_hooks(cfg.lr_config, optimizer_config, + cfg.checkpoint_config, cfg.log_config) + + if cfg.resume_from: + runner.resume(cfg.resume_from) + elif cfg.load_from: + runner.load_checkpoint(cfg.load_from) + runner.run(data_loaders, cfg.workflow, cfg.total_epochs) diff --git a/mmdet/core/__init__.py b/mmdet/core/__init__.py new file mode 100644 index 0000000..f8eb6cb --- /dev/null +++ b/mmdet/core/__init__.py @@ -0,0 +1,7 @@ +from .anchor import * # noqa: F401, F403 +from .bbox import * # noqa: F401, F403 +from .evaluation import * # noqa: F401, F403 +from .fp16 import * # noqa: F401, F403 +from .mask import * # noqa: F401, F403 +from .post_processing import * # noqa: F401, F403 +from .utils import * # noqa: F401, F403 diff --git a/mmdet/core/anchor/__init__.py b/mmdet/core/anchor/__init__.py new file mode 100644 index 0000000..a5f070f --- /dev/null +++ b/mmdet/core/anchor/__init__.py @@ -0,0 +1,8 @@ +from .anchor_generator import AnchorGenerator +from .anchor_target import anchor_inside_flags, anchor_target +from .guided_anchor_target import ga_loc_target, ga_shape_target + +__all__ = [ + 'AnchorGenerator', 'anchor_target', 'anchor_inside_flags', 'ga_loc_target', + 'ga_shape_target' +] diff --git a/mmdet/core/anchor/anchor_generator.py b/mmdet/core/anchor/anchor_generator.py new file mode 100644 index 0000000..6130430 --- /dev/null +++ b/mmdet/core/anchor/anchor_generator.py @@ -0,0 +1,86 @@ +import torch + + +class AnchorGenerator(object): + + def __init__(self, base_size, scales, ratios, scale_major=True, ctr=None): + self.base_size = base_size + self.scales = torch.Tensor(scales) + self.ratios = torch.Tensor(ratios) + self.scale_major = scale_major + self.ctr = ctr + self.base_anchors = self.gen_base_anchors() + + @property + def num_base_anchors(self): + return self.base_anchors.size(0) + + def gen_base_anchors(self): + w = self.base_size + h = self.base_size + if self.ctr is None: + x_ctr = 0.5 * (w - 1) + y_ctr = 0.5 * (h - 1) + else: + x_ctr, y_ctr = self.ctr + + h_ratios = torch.sqrt(self.ratios) + w_ratios = 1 / h_ratios + if self.scale_major: + ws = (w * w_ratios[:, None] * self.scales[None, :]).view(-1) + hs = (h * h_ratios[:, None] * self.scales[None, :]).view(-1) + else: + ws = (w * self.scales[:, None] * w_ratios[None, :]).view(-1) + hs = (h * self.scales[:, None] * h_ratios[None, :]).view(-1) + + # yapf: disable + base_anchors = torch.stack( + [ + x_ctr - 0.5 * (ws - 1), y_ctr - 0.5 * (hs - 1), + x_ctr + 0.5 * (ws - 1), y_ctr + 0.5 * (hs - 1) + ], + dim=-1).round() + # yapf: enable + + return base_anchors + + def _meshgrid(self, x, y, row_major=True): + xx = x.repeat(len(y)) + yy = y.view(-1, 1).repeat(1, len(x)).view(-1) + if row_major: + return xx, yy + else: + return yy, xx + + def grid_anchors(self, featmap_size, stride=16, device='cuda'): + base_anchors = self.base_anchors.to(device) + + feat_h, feat_w = featmap_size + shift_x = torch.arange(0, feat_w, device=device) * stride + shift_y = torch.arange(0, feat_h, device=device) * stride + shift_xx, shift_yy = self._meshgrid(shift_x, shift_y) + 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 + + def valid_flags(self, featmap_size, valid_size, device='cuda'): + feat_h, feat_w = featmap_size + valid_h, valid_w = valid_size + assert valid_h <= feat_h and valid_w <= feat_w + valid_x = torch.zeros(feat_w, dtype=torch.uint8, device=device) + valid_y = torch.zeros(feat_h, dtype=torch.uint8, device=device) + valid_x[:valid_w] = 1 + valid_y[:valid_h] = 1 + valid_xx, valid_yy = self._meshgrid(valid_x, valid_y) + valid = valid_xx & valid_yy + valid = valid[:, None].expand( + valid.size(0), self.num_base_anchors).contiguous().view(-1) + return valid diff --git a/mmdet/core/anchor/anchor_target.py b/mmdet/core/anchor/anchor_target.py new file mode 100644 index 0000000..bba372f --- /dev/null +++ b/mmdet/core/anchor/anchor_target.py @@ -0,0 +1,186 @@ +import torch + +from ..bbox import PseudoSampler, assign_and_sample, bbox2delta, build_assigner +from ..utils import multi_apply + + +def anchor_target(anchor_list, + valid_flag_list, + gt_bboxes_list, + img_metas, + target_means, + target_stds, + cfg, + gt_bboxes_ignore_list=None, + gt_labels_list=None, + label_channels=1, + sampling=True, + unmap_outputs=True): + """Compute regression and classification targets for anchors. + + Args: + anchor_list (list[list]): Multi level anchors of each image. + valid_flag_list (list[list]): Multi level valid flags of each image. + gt_bboxes_list (list[Tensor]): Ground truth bboxes of each image. + img_metas (list[dict]): Meta info of each image. + target_means (Iterable): Mean value of regression targets. + target_stds (Iterable): Std value of regression targets. + cfg (dict): RPN train configs. + + Returns: + tuple + """ + num_imgs = len(img_metas) + assert len(anchor_list) == len(valid_flag_list) == num_imgs + + # anchor number of multi levels + num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]] + # concat all level anchors and flags to a single tensor + for i in range(num_imgs): + assert len(anchor_list[i]) == len(valid_flag_list[i]) + anchor_list[i] = torch.cat(anchor_list[i]) + valid_flag_list[i] = torch.cat(valid_flag_list[i]) + + # compute targets for each image + if gt_bboxes_ignore_list is None: + gt_bboxes_ignore_list = [None for _ in range(num_imgs)] + if gt_labels_list is None: + gt_labels_list = [None for _ in range(num_imgs)] + (all_labels, all_label_weights, all_bbox_targets, all_bbox_weights, + pos_inds_list, neg_inds_list) = multi_apply( + anchor_target_single, + anchor_list, + valid_flag_list, + gt_bboxes_list, + gt_bboxes_ignore_list, + gt_labels_list, + img_metas, + target_means=target_means, + target_stds=target_stds, + cfg=cfg, + label_channels=label_channels, + sampling=sampling, + unmap_outputs=unmap_outputs) + # no valid anchors + if any([labels is None for labels in all_labels]): + return None + # sampled anchors of all images + num_total_pos = sum([max(inds.numel(), 1) for inds in pos_inds_list]) + num_total_neg = sum([max(inds.numel(), 1) for inds in neg_inds_list]) + # split targets to a list w.r.t. multiple levels + labels_list = images_to_levels(all_labels, num_level_anchors) + label_weights_list = images_to_levels(all_label_weights, num_level_anchors) + bbox_targets_list = images_to_levels(all_bbox_targets, num_level_anchors) + bbox_weights_list = images_to_levels(all_bbox_weights, num_level_anchors) + return (labels_list, label_weights_list, bbox_targets_list, + bbox_weights_list, num_total_pos, num_total_neg) + + +def images_to_levels(target, num_level_anchors): + """Convert targets by image to targets by feature level. + + [target_img0, target_img1] -> [target_level0, target_level1, ...] + """ + target = torch.stack(target, 0) + level_targets = [] + start = 0 + for n in num_level_anchors: + end = start + n + level_targets.append(target[:, start:end].squeeze(0)) + start = end + return level_targets + + +def anchor_target_single(flat_anchors, + valid_flags, + gt_bboxes, + gt_bboxes_ignore, + gt_labels, + img_meta, + target_means, + target_stds, + cfg, + label_channels=1, + sampling=True, + unmap_outputs=True): + inside_flags = anchor_inside_flags(flat_anchors, valid_flags, + img_meta['img_shape'][:2], + cfg.allowed_border) + if not inside_flags.any(): + return (None, ) * 6 + # assign gt and sample anchors + anchors = flat_anchors[inside_flags, :] + + if sampling: + assign_result, sampling_result = assign_and_sample( + anchors, gt_bboxes, gt_bboxes_ignore, None, cfg) + else: + bbox_assigner = build_assigner(cfg.assigner) + assign_result = bbox_assigner.assign(anchors, gt_bboxes, + gt_bboxes_ignore, gt_labels) + bbox_sampler = PseudoSampler() + sampling_result = bbox_sampler.sample(assign_result, anchors, + gt_bboxes) + + num_valid_anchors = anchors.shape[0] + bbox_targets = torch.zeros_like(anchors) + bbox_weights = torch.zeros_like(anchors) + labels = anchors.new_zeros(num_valid_anchors, dtype=torch.long) + label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float) + + pos_inds = sampling_result.pos_inds + neg_inds = sampling_result.neg_inds + if len(pos_inds) > 0: + pos_bbox_targets = bbox2delta(sampling_result.pos_bboxes, + sampling_result.pos_gt_bboxes, + target_means, target_stds) + bbox_targets[pos_inds, :] = pos_bbox_targets + bbox_weights[pos_inds, :] = 1.0 + if gt_labels is None: + labels[pos_inds] = 1 + else: + labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds] + if cfg.pos_weight <= 0: + label_weights[pos_inds] = 1.0 + else: + label_weights[pos_inds] = cfg.pos_weight + if len(neg_inds) > 0: + label_weights[neg_inds] = 1.0 + + # map up to original set of anchors + if unmap_outputs: + num_total_anchors = flat_anchors.size(0) + labels = unmap(labels, num_total_anchors, inside_flags) + label_weights = unmap(label_weights, num_total_anchors, inside_flags) + bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags) + bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags) + + return (labels, label_weights, bbox_targets, bbox_weights, pos_inds, + neg_inds) + + +def anchor_inside_flags(flat_anchors, valid_flags, img_shape, + allowed_border=0): + img_h, img_w = img_shape[:2] + if allowed_border >= 0: + inside_flags = valid_flags & \ + (flat_anchors[:, 0] >= -allowed_border).type(torch.uint8) & \ + (flat_anchors[:, 1] >= -allowed_border).type(torch.uint8) & \ + (flat_anchors[:, 2] < img_w + allowed_border).type(torch.uint8) & \ + (flat_anchors[:, 3] < img_h + allowed_border).type(torch.uint8) + else: + inside_flags = valid_flags + return inside_flags + + +def unmap(data, count, inds, fill=0): + """ Unmap a subset of item (data) back to the original set of items (of + size count) """ + if data.dim() == 1: + ret = data.new_full((count, ), fill) + ret[inds] = data + else: + new_size = (count, ) + data.size()[1:] + ret = data.new_full(new_size, fill) + ret[inds, :] = data + return ret diff --git a/mmdet/core/anchor/guided_anchor_target.py b/mmdet/core/anchor/guided_anchor_target.py new file mode 100644 index 0000000..21abe5e --- /dev/null +++ b/mmdet/core/anchor/guided_anchor_target.py @@ -0,0 +1,287 @@ +import torch + +from ..bbox import PseudoSampler, build_assigner, build_sampler +from ..utils import multi_apply, unmap + + +def calc_region(bbox, ratio, featmap_size=None): + """Calculate a proportional bbox region. + + The bbox center are fixed and the new h' and w' is h * ratio and w * ratio. + + Args: + bbox (Tensor): Bboxes to calculate regions, shape (n, 4) + ratio (float): Ratio of the output region. + featmap_size (tuple): Feature map size used for clipping the boundary. + + Returns: + tuple: x1, y1, x2, y2 + """ + x1 = torch.round((1 - ratio) * bbox[0] + ratio * bbox[2]).long() + y1 = torch.round((1 - ratio) * bbox[1] + ratio * bbox[3]).long() + x2 = torch.round(ratio * bbox[0] + (1 - ratio) * bbox[2]).long() + y2 = torch.round(ratio * bbox[1] + (1 - ratio) * bbox[3]).long() + if featmap_size is not None: + x1 = x1.clamp(min=0, max=featmap_size[1] - 1) + y1 = y1.clamp(min=0, max=featmap_size[0] - 1) + x2 = x2.clamp(min=0, max=featmap_size[1] - 1) + y2 = y2.clamp(min=0, max=featmap_size[0] - 1) + return (x1, y1, x2, y2) + + +def ga_loc_target(gt_bboxes_list, + featmap_sizes, + anchor_scale, + anchor_strides, + center_ratio=0.2, + ignore_ratio=0.5): + """Compute location targets for guided anchoring. + + Each feature map is divided into positive, negative and ignore regions. + - positive regions: target 1, weight 1 + - ignore regions: target 0, weight 0 + - negative regions: target 0, weight 0.1 + + Args: + gt_bboxes_list (list[Tensor]): Gt bboxes of each image. + featmap_sizes (list[tuple]): Multi level sizes of each feature maps. + anchor_scale (int): Anchor scale. + anchor_strides ([list[int]]): Multi level anchor strides. + center_ratio (float): Ratio of center region. + ignore_ratio (float): Ratio of ignore region. + + Returns: + tuple + """ + img_per_gpu = len(gt_bboxes_list) + num_lvls = len(featmap_sizes) + r1 = (1 - center_ratio) / 2 + r2 = (1 - ignore_ratio) / 2 + all_loc_targets = [] + all_loc_weights = [] + all_ignore_map = [] + for lvl_id in range(num_lvls): + h, w = featmap_sizes[lvl_id] + loc_targets = torch.zeros( + img_per_gpu, + 1, + h, + w, + device=gt_bboxes_list[0].device, + dtype=torch.float32) + loc_weights = torch.full_like(loc_targets, -1) + ignore_map = torch.zeros_like(loc_targets) + all_loc_targets.append(loc_targets) + all_loc_weights.append(loc_weights) + all_ignore_map.append(ignore_map) + for img_id in range(img_per_gpu): + gt_bboxes = gt_bboxes_list[img_id] + scale = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1) * + (gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1)) + min_anchor_size = scale.new_full( + (1, ), float(anchor_scale * anchor_strides[0])) + # assign gt bboxes to different feature levels w.r.t. their scales + target_lvls = torch.floor( + torch.log2(scale) - torch.log2(min_anchor_size) + 0.5) + target_lvls = target_lvls.clamp(min=0, max=num_lvls - 1).long() + for gt_id in range(gt_bboxes.size(0)): + lvl = target_lvls[gt_id].item() + # rescaled to corresponding feature map + gt_ = gt_bboxes[gt_id, :4] / anchor_strides[lvl] + # calculate ignore regions + ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region( + gt_, r2, featmap_sizes[lvl]) + # calculate positive (center) regions + ctr_x1, ctr_y1, ctr_x2, ctr_y2 = calc_region( + gt_, r1, featmap_sizes[lvl]) + all_loc_targets[lvl][img_id, 0, ctr_y1:ctr_y2 + 1, ctr_x1:ctr_x2 + + 1] = 1 + all_loc_weights[lvl][img_id, 0, ignore_y1:ignore_y2 + + 1, ignore_x1:ignore_x2 + 1] = 0 + all_loc_weights[lvl][img_id, 0, ctr_y1:ctr_y2 + 1, ctr_x1:ctr_x2 + + 1] = 1 + # calculate ignore map on nearby low level feature + if lvl > 0: + d_lvl = lvl - 1 + # rescaled to corresponding feature map + gt_ = gt_bboxes[gt_id, :4] / anchor_strides[d_lvl] + ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region( + gt_, r2, featmap_sizes[d_lvl]) + all_ignore_map[d_lvl][img_id, 0, ignore_y1:ignore_y2 + + 1, ignore_x1:ignore_x2 + 1] = 1 + # calculate ignore map on nearby high level feature + if lvl < num_lvls - 1: + u_lvl = lvl + 1 + # rescaled to corresponding feature map + gt_ = gt_bboxes[gt_id, :4] / anchor_strides[u_lvl] + ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region( + gt_, r2, featmap_sizes[u_lvl]) + all_ignore_map[u_lvl][img_id, 0, ignore_y1:ignore_y2 + + 1, ignore_x1:ignore_x2 + 1] = 1 + for lvl_id in range(num_lvls): + # ignore negative regions w.r.t. ignore map + all_loc_weights[lvl_id][(all_loc_weights[lvl_id] < 0) + & (all_ignore_map[lvl_id] > 0)] = 0 + # set negative regions with weight 0.1 + all_loc_weights[lvl_id][all_loc_weights[lvl_id] < 0] = 0.1 + # loc average factor to balance loss + loc_avg_factor = sum( + [t.size(0) * t.size(-1) * t.size(-2) for t in all_loc_targets]) / 200 + return all_loc_targets, all_loc_weights, loc_avg_factor + + +def ga_shape_target(approx_list, + inside_flag_list, + square_list, + gt_bboxes_list, + img_metas, + approxs_per_octave, + cfg, + gt_bboxes_ignore_list=None, + sampling=True, + unmap_outputs=True): + """Compute guided anchoring targets. + + Args: + approx_list (list[list]): Multi level approxs of each image. + inside_flag_list (list[list]): Multi level inside flags of each image. + square_list (list[list]): Multi level squares of each image. + gt_bboxes_list (list[Tensor]): Ground truth bboxes of each image. + img_metas (list[dict]): Meta info of each image. + approxs_per_octave (int): number of approxs per octave + cfg (dict): RPN train configs. + gt_bboxes_ignore_list (list[Tensor]): ignore list of gt bboxes. + sampling (bool): sampling or not. + unmap_outputs (bool): unmap outputs or not. + + Returns: + tuple + """ + num_imgs = len(img_metas) + assert len(approx_list) == len(inside_flag_list) == len( + square_list) == num_imgs + # anchor number of multi levels + num_level_squares = [squares.size(0) for squares in square_list[0]] + # concat all level anchors and flags to a single tensor + inside_flag_flat_list = [] + approx_flat_list = [] + square_flat_list = [] + for i in range(num_imgs): + assert len(square_list[i]) == len(inside_flag_list[i]) + inside_flag_flat_list.append(torch.cat(inside_flag_list[i])) + approx_flat_list.append(torch.cat(approx_list[i])) + square_flat_list.append(torch.cat(square_list[i])) + + # compute targets for each image + if gt_bboxes_ignore_list is None: + gt_bboxes_ignore_list = [None for _ in range(num_imgs)] + (all_bbox_anchors, all_bbox_gts, all_bbox_weights, pos_inds_list, + neg_inds_list) = multi_apply( + ga_shape_target_single, + approx_flat_list, + inside_flag_flat_list, + square_flat_list, + gt_bboxes_list, + gt_bboxes_ignore_list, + img_metas, + approxs_per_octave=approxs_per_octave, + cfg=cfg, + sampling=sampling, + unmap_outputs=unmap_outputs) + # no valid anchors + if any([bbox_anchors is None for bbox_anchors in all_bbox_anchors]): + return None + # sampled anchors of all images + num_total_pos = sum([max(inds.numel(), 1) for inds in pos_inds_list]) + num_total_neg = sum([max(inds.numel(), 1) for inds in neg_inds_list]) + # split targets to a list w.r.t. multiple levels + bbox_anchors_list = images_to_levels(all_bbox_anchors, num_level_squares) + bbox_gts_list = images_to_levels(all_bbox_gts, num_level_squares) + bbox_weights_list = images_to_levels(all_bbox_weights, num_level_squares) + return (bbox_anchors_list, bbox_gts_list, bbox_weights_list, num_total_pos, + num_total_neg) + + +def images_to_levels(target, num_level_anchors): + """Convert targets by image to targets by feature level. + + [target_img0, target_img1] -> [target_level0, target_level1, ...] + """ + target = torch.stack(target, 0) + level_targets = [] + start = 0 + for n in num_level_anchors: + end = start + n + level_targets.append(target[:, start:end].squeeze(0)) + start = end + return level_targets + + +def ga_shape_target_single(flat_approxs, + inside_flags, + flat_squares, + gt_bboxes, + gt_bboxes_ignore, + img_meta, + approxs_per_octave, + cfg, + sampling=True, + unmap_outputs=True): + """Compute guided anchoring targets. + + This function returns sampled anchors and gt bboxes directly + rather than calculates regression targets. + + Args: + flat_approxs (Tensor): flat approxs of a single image, + shape (n, 4) + inside_flags (Tensor): inside flags of a single image, + shape (n, ). + flat_squares (Tensor): flat squares of a single image, + shape (approxs_per_octave * n, 4) + gt_bboxes (Tensor): Ground truth bboxes of a single image. + img_meta (dict): Meta info of a single image. + approxs_per_octave (int): number of approxs per octave + cfg (dict): RPN train configs. + sampling (bool): sampling or not. + unmap_outputs (bool): unmap outputs or not. + + Returns: + tuple + """ + if not inside_flags.any(): + return (None, ) * 6 + # assign gt and sample anchors + expand_inside_flags = inside_flags[:, None].expand( + -1, approxs_per_octave).reshape(-1) + approxs = flat_approxs[expand_inside_flags, :] + squares = flat_squares[inside_flags, :] + + bbox_assigner = build_assigner(cfg.ga_assigner) + assign_result = bbox_assigner.assign(approxs, squares, approxs_per_octave, + gt_bboxes, gt_bboxes_ignore) + if sampling: + bbox_sampler = build_sampler(cfg.ga_sampler) + else: + bbox_sampler = PseudoSampler() + sampling_result = bbox_sampler.sample(assign_result, squares, gt_bboxes) + + bbox_anchors = torch.zeros_like(squares) + bbox_gts = torch.zeros_like(squares) + bbox_weights = torch.zeros_like(squares) + + pos_inds = sampling_result.pos_inds + neg_inds = sampling_result.neg_inds + if len(pos_inds) > 0: + bbox_anchors[pos_inds, :] = sampling_result.pos_bboxes + bbox_gts[pos_inds, :] = sampling_result.pos_gt_bboxes + bbox_weights[pos_inds, :] = 1.0 + + # map up to original set of anchors + if unmap_outputs: + num_total_anchors = flat_squares.size(0) + bbox_anchors = unmap(bbox_anchors, num_total_anchors, inside_flags) + bbox_gts = unmap(bbox_gts, num_total_anchors, inside_flags) + bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags) + + return (bbox_anchors, bbox_gts, bbox_weights, pos_inds, neg_inds) diff --git a/mmdet/core/bbox/__init__.py b/mmdet/core/bbox/__init__.py new file mode 100644 index 0000000..a0de917 --- /dev/null +++ b/mmdet/core/bbox/__init__.py @@ -0,0 +1,22 @@ +from .assigners import AssignResult, BaseAssigner, MaxIoUAssigner +from .bbox_target import bbox_target +from .geometry import bbox_overlaps +from .samplers import (BaseSampler, CombinedSampler, + InstanceBalancedPosSampler, IoUBalancedNegSampler, + PseudoSampler, RandomSampler, SamplingResult) +from .transforms import (bbox2delta, bbox2result, bbox2roi, bbox_flip, + bbox_mapping, bbox_mapping_back, delta2bbox, + distance2bbox, roi2bbox) + +from .assign_sampling import ( # isort:skip, avoid recursive imports + assign_and_sample, build_assigner, build_sampler) + +__all__ = [ + 'bbox_overlaps', 'BaseAssigner', 'MaxIoUAssigner', 'AssignResult', + 'BaseSampler', 'PseudoSampler', 'RandomSampler', + 'InstanceBalancedPosSampler', 'IoUBalancedNegSampler', 'CombinedSampler', + 'SamplingResult', 'build_assigner', 'build_sampler', 'assign_and_sample', + 'bbox2delta', 'delta2bbox', 'bbox_flip', 'bbox_mapping', + 'bbox_mapping_back', 'bbox2roi', 'roi2bbox', 'bbox2result', + 'distance2bbox', 'bbox_target' +] diff --git a/mmdet/core/bbox/assign_sampling.py b/mmdet/core/bbox/assign_sampling.py new file mode 100644 index 0000000..4267174 --- /dev/null +++ b/mmdet/core/bbox/assign_sampling.py @@ -0,0 +1,33 @@ +import mmcv + +from . import assigners, samplers + + +def build_assigner(cfg, **kwargs): + if isinstance(cfg, assigners.BaseAssigner): + return cfg + elif isinstance(cfg, dict): + return mmcv.runner.obj_from_dict(cfg, assigners, default_args=kwargs) + else: + raise TypeError('Invalid type {} for building a sampler'.format( + type(cfg))) + + +def build_sampler(cfg, **kwargs): + if isinstance(cfg, samplers.BaseSampler): + return cfg + elif isinstance(cfg, dict): + return mmcv.runner.obj_from_dict(cfg, samplers, default_args=kwargs) + else: + raise TypeError('Invalid type {} for building a sampler'.format( + type(cfg))) + + +def assign_and_sample(bboxes, gt_bboxes, gt_bboxes_ignore, gt_labels, cfg): + bbox_assigner = build_assigner(cfg.assigner) + bbox_sampler = build_sampler(cfg.sampler) + assign_result = bbox_assigner.assign(bboxes, gt_bboxes, gt_bboxes_ignore, + gt_labels) + sampling_result = bbox_sampler.sample(assign_result, bboxes, gt_bboxes, + gt_labels) + return assign_result, sampling_result diff --git a/mmdet/core/bbox/assigners/__init__.py b/mmdet/core/bbox/assigners/__init__.py new file mode 100644 index 0000000..594e840 --- /dev/null +++ b/mmdet/core/bbox/assigners/__init__.py @@ -0,0 +1,8 @@ +from .approx_max_iou_assigner import ApproxMaxIoUAssigner +from .assign_result import AssignResult +from .base_assigner import BaseAssigner +from .max_iou_assigner import MaxIoUAssigner + +__all__ = [ + 'BaseAssigner', 'MaxIoUAssigner', 'ApproxMaxIoUAssigner', 'AssignResult' +] diff --git a/mmdet/core/bbox/assigners/approx_max_iou_assigner.py b/mmdet/core/bbox/assigners/approx_max_iou_assigner.py new file mode 100644 index 0000000..4ab5259 --- /dev/null +++ b/mmdet/core/bbox/assigners/approx_max_iou_assigner.py @@ -0,0 +1,114 @@ +import torch + +from ..geometry import bbox_overlaps +from .max_iou_assigner import MaxIoUAssigner + + +class ApproxMaxIoUAssigner(MaxIoUAssigner): + """Assign a corresponding gt bbox or background to each bbox. + + Each proposals will be assigned with `-1`, `0`, or a positive integer + indicating the ground truth index. + + - -1: don't care + - 0: negative sample, no assigned gt + - positive integer: positive sample, index (1-based) of assigned gt + + Args: + pos_iou_thr (float): IoU threshold for positive bboxes. + neg_iou_thr (float or tuple): IoU threshold for negative bboxes. + min_pos_iou (float): Minimum iou for a bbox to be considered as a + positive bbox. Positive samples can have smaller IoU than + pos_iou_thr due to the 4th step (assign max IoU sample to each gt). + gt_max_assign_all (bool): Whether to assign all bboxes with the same + highest overlap with some gt to that gt. + ignore_iof_thr (float): IoF threshold for ignoring bboxes (if + `gt_bboxes_ignore` is specified). Negative values mean not + ignoring any bboxes. + ignore_wrt_candidates (bool): Whether to compute the iof between + `bboxes` and `gt_bboxes_ignore`, or the contrary. + """ + + def __init__(self, + pos_iou_thr, + neg_iou_thr, + min_pos_iou=.0, + gt_max_assign_all=True, + ignore_iof_thr=-1, + ignore_wrt_candidates=True): + self.pos_iou_thr = pos_iou_thr + self.neg_iou_thr = neg_iou_thr + self.min_pos_iou = min_pos_iou + self.gt_max_assign_all = gt_max_assign_all + self.ignore_iof_thr = ignore_iof_thr + self.ignore_wrt_candidates = ignore_wrt_candidates + + def assign(self, + approxs, + squares, + approxs_per_octave, + gt_bboxes, + gt_bboxes_ignore=None, + gt_labels=None): + """Assign gt to approxs. + + This method assign a gt bbox to each group of approxs (bboxes), + each group of approxs is represent by a base approx (bbox) and + will be assigned with -1, 0, or a positive number. + -1 means don't care, 0 means negative sample, + positive number is the index (1-based) of assigned gt. + The assignment is done in following steps, the order matters. + + 1. assign every bbox to -1 + 2. use the max IoU of each group of approxs to assign + 2. assign proposals whose iou with all gts < neg_iou_thr to 0 + 3. for each bbox, if the iou with its nearest gt >= pos_iou_thr, + assign it to that bbox + 4. for each gt bbox, assign its nearest proposals (may be more than + one) to itself + + Args: + approxs (Tensor): Bounding boxes to be assigned, + shape(approxs_per_octave*n, 4). + squares (Tensor): Base Bounding boxes to be assigned, + shape(n, 4). + approxs_per_octave (int): number of approxs per octave + gt_bboxes (Tensor): Groundtruth boxes, shape (k, 4). + gt_bboxes_ignore (Tensor, optional): Ground truth bboxes that are + labelled as `ignored`, e.g., crowd boxes in COCO. + gt_labels (Tensor, optional): Label of gt_bboxes, shape (k, ). + + Returns: + :obj:`AssignResult`: The assign result. + """ + + if squares.shape[0] == 0 or gt_bboxes.shape[0] == 0: + raise ValueError('No gt or approxs') + num_squares = squares.size(0) + num_gts = gt_bboxes.size(0) + # re-organize anchors by approxs_per_octave x num_squares + approxs = torch.transpose( + approxs.view(num_squares, approxs_per_octave, 4), 0, + 1).contiguous().view(-1, 4) + all_overlaps = bbox_overlaps(approxs, gt_bboxes) + + overlaps, _ = all_overlaps.view(approxs_per_octave, num_squares, + num_gts).max(dim=0) + overlaps = torch.transpose(overlaps, 0, 1) + + bboxes = squares[:, :4] + + if (self.ignore_iof_thr > 0) and (gt_bboxes_ignore is not None) and ( + gt_bboxes_ignore.numel() > 0): + if self.ignore_wrt_candidates: + ignore_overlaps = bbox_overlaps( + bboxes, gt_bboxes_ignore, mode='iof') + ignore_max_overlaps, _ = ignore_overlaps.max(dim=1) + else: + ignore_overlaps = bbox_overlaps( + gt_bboxes_ignore, bboxes, mode='iof') + ignore_max_overlaps, _ = ignore_overlaps.max(dim=0) + overlaps[:, ignore_max_overlaps > self.ignore_iof_thr] = -1 + + assign_result = self.assign_wrt_overlaps(overlaps, gt_labels) + return assign_result diff --git a/mmdet/core/bbox/assigners/assign_result.py b/mmdet/core/bbox/assigners/assign_result.py new file mode 100644 index 0000000..33c761d --- /dev/null +++ b/mmdet/core/bbox/assigners/assign_result.py @@ -0,0 +1,19 @@ +import torch + + +class AssignResult(object): + + def __init__(self, num_gts, gt_inds, max_overlaps, labels=None): + self.num_gts = num_gts + self.gt_inds = gt_inds + self.max_overlaps = max_overlaps + self.labels = labels + + def add_gt_(self, gt_labels): + self_inds = torch.arange( + 1, len(gt_labels) + 1, dtype=torch.long, device=gt_labels.device) + self.gt_inds = torch.cat([self_inds, self.gt_inds]) + self.max_overlaps = torch.cat( + [self.max_overlaps.new_ones(self.num_gts), self.max_overlaps]) + if self.labels is not None: + self.labels = torch.cat([gt_labels, self.labels]) diff --git a/mmdet/core/bbox/assigners/base_assigner.py b/mmdet/core/bbox/assigners/base_assigner.py new file mode 100644 index 0000000..7bd02dc --- /dev/null +++ b/mmdet/core/bbox/assigners/base_assigner.py @@ -0,0 +1,8 @@ +from abc import ABCMeta, abstractmethod + + +class BaseAssigner(metaclass=ABCMeta): + + @abstractmethod + def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=None): + pass diff --git a/mmdet/core/bbox/assigners/max_iou_assigner.py b/mmdet/core/bbox/assigners/max_iou_assigner.py new file mode 100644 index 0000000..5c93b36 --- /dev/null +++ b/mmdet/core/bbox/assigners/max_iou_assigner.py @@ -0,0 +1,153 @@ +import torch + +from ..geometry import bbox_overlaps +from .assign_result import AssignResult +from .base_assigner import BaseAssigner + + +class MaxIoUAssigner(BaseAssigner): + """Assign a corresponding gt bbox or background to each bbox. + + Each proposals will be assigned with `-1`, `0`, or a positive integer + indicating the ground truth index. + + - -1: don't care + - 0: negative sample, no assigned gt + - positive integer: positive sample, index (1-based) of assigned gt + + Args: + pos_iou_thr (float): IoU threshold for positive bboxes. + neg_iou_thr (float or tuple): IoU threshold for negative bboxes. + min_pos_iou (float): Minimum iou for a bbox to be considered as a + positive bbox. Positive samples can have smaller IoU than + pos_iou_thr due to the 4th step (assign max IoU sample to each gt). + gt_max_assign_all (bool): Whether to assign all bboxes with the same + highest overlap with some gt to that gt. + ignore_iof_thr (float): IoF threshold for ignoring bboxes (if + `gt_bboxes_ignore` is specified). Negative values mean not + ignoring any bboxes. + ignore_wrt_candidates (bool): Whether to compute the iof between + `bboxes` and `gt_bboxes_ignore`, or the contrary. + """ + + def __init__(self, + pos_iou_thr, + neg_iou_thr, + min_pos_iou=.0, + gt_max_assign_all=True, + ignore_iof_thr=-1, + ignore_wrt_candidates=True): + self.pos_iou_thr = pos_iou_thr + self.neg_iou_thr = neg_iou_thr + self.min_pos_iou = min_pos_iou + self.gt_max_assign_all = gt_max_assign_all + self.ignore_iof_thr = ignore_iof_thr + self.ignore_wrt_candidates = ignore_wrt_candidates + + def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=None): + """Assign gt to bboxes. + + This method assign a gt bbox to every bbox (proposal/anchor), each bbox + will be assigned with -1, 0, or a positive number. -1 means don't care, + 0 means negative sample, positive number is the index (1-based) of + assigned gt. + The assignment is done in following steps, the order matters. + + 1. assign every bbox to -1 + 2. assign proposals whose iou with all gts < neg_iou_thr to 0 + 3. for each bbox, if the iou with its nearest gt >= pos_iou_thr, + assign it to that bbox + 4. for each gt bbox, assign its nearest proposals (may be more than + one) to itself + + Args: + bboxes (Tensor): Bounding boxes to be assigned, shape(n, 4). + gt_bboxes (Tensor): Groundtruth boxes, shape (k, 4). + gt_bboxes_ignore (Tensor, optional): Ground truth bboxes that are + labelled as `ignored`, e.g., crowd boxes in COCO. + gt_labels (Tensor, optional): Label of gt_bboxes, shape (k, ). + + Returns: + :obj:`AssignResult`: The assign result. + """ + if bboxes.shape[0] == 0 or gt_bboxes.shape[0] == 0: + raise ValueError('No gt or bboxes') + bboxes = bboxes[:, :4] + overlaps = bbox_overlaps(gt_bboxes, bboxes) + + if (self.ignore_iof_thr > 0) and (gt_bboxes_ignore is not None) and ( + gt_bboxes_ignore.numel() > 0): + if self.ignore_wrt_candidates: + ignore_overlaps = bbox_overlaps( + bboxes, gt_bboxes_ignore, mode='iof') + ignore_max_overlaps, _ = ignore_overlaps.max(dim=1) + else: + ignore_overlaps = bbox_overlaps( + gt_bboxes_ignore, bboxes, mode='iof') + ignore_max_overlaps, _ = ignore_overlaps.max(dim=0) + overlaps[:, ignore_max_overlaps > self.ignore_iof_thr] = -1 + + assign_result = self.assign_wrt_overlaps(overlaps, gt_labels) + return assign_result + + def assign_wrt_overlaps(self, overlaps, gt_labels=None): + """Assign w.r.t. the overlaps of bboxes with gts. + + Args: + overlaps (Tensor): Overlaps between k gt_bboxes and n bboxes, + shape(k, n). + gt_labels (Tensor, optional): Labels of k gt_bboxes, shape (k, ). + + Returns: + :obj:`AssignResult`: The assign result. + """ + if overlaps.numel() == 0: + raise ValueError('No gt or proposals') + + num_gts, num_bboxes = overlaps.size(0), overlaps.size(1) + + # 1. assign -1 by default + assigned_gt_inds = overlaps.new_full((num_bboxes, ), + -1, + dtype=torch.long) + + # 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 + 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 + + # 3. assign positive: above positive IoU threshold + pos_inds = max_overlaps >= self.pos_iou_thr + assigned_gt_inds[pos_inds] = argmax_overlaps[pos_inds] + 1 + + # 4. assign fg: for each gt, proposals with highest IoU + 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 + + if gt_labels is not None: + assigned_labels = assigned_gt_inds.new_zeros((num_bboxes, )) + pos_inds = torch.nonzero(assigned_gt_inds > 0).squeeze() + if pos_inds.numel() > 0: + assigned_labels[pos_inds] = gt_labels[ + assigned_gt_inds[pos_inds] - 1] + else: + assigned_labels = None + + return AssignResult( + num_gts, assigned_gt_inds, max_overlaps, labels=assigned_labels) diff --git a/mmdet/core/bbox/bbox_target.py b/mmdet/core/bbox/bbox_target.py new file mode 100644 index 0000000..2a918bf --- /dev/null +++ b/mmdet/core/bbox/bbox_target.py @@ -0,0 +1,73 @@ +import torch + +from ..utils import multi_apply +from .transforms import bbox2delta + + +def bbox_target(pos_bboxes_list, + neg_bboxes_list, + pos_gt_bboxes_list, + pos_gt_labels_list, + cfg, + reg_classes=1, + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0], + concat=True): + labels, label_weights, bbox_targets, bbox_weights = multi_apply( + bbox_target_single, + pos_bboxes_list, + neg_bboxes_list, + pos_gt_bboxes_list, + pos_gt_labels_list, + cfg=cfg, + reg_classes=reg_classes, + target_means=target_means, + target_stds=target_stds) + + if concat: + labels = torch.cat(labels, 0) + label_weights = torch.cat(label_weights, 0) + bbox_targets = torch.cat(bbox_targets, 0) + bbox_weights = torch.cat(bbox_weights, 0) + return labels, label_weights, bbox_targets, bbox_weights + + +def bbox_target_single(pos_bboxes, + neg_bboxes, + pos_gt_bboxes, + pos_gt_labels, + cfg, + reg_classes=1, + target_means=[.0, .0, .0, .0], + target_stds=[1.0, 1.0, 1.0, 1.0]): + num_pos = pos_bboxes.size(0) + num_neg = neg_bboxes.size(0) + num_samples = num_pos + num_neg + labels = pos_bboxes.new_zeros(num_samples, dtype=torch.long) + label_weights = pos_bboxes.new_zeros(num_samples) + bbox_targets = pos_bboxes.new_zeros(num_samples, 4) + bbox_weights = pos_bboxes.new_zeros(num_samples, 4) + if num_pos > 0: + labels[:num_pos] = pos_gt_labels + pos_weight = 1.0 if cfg.pos_weight <= 0 else cfg.pos_weight + label_weights[:num_pos] = pos_weight + pos_bbox_targets = bbox2delta(pos_bboxes, pos_gt_bboxes, target_means, + target_stds) + bbox_targets[:num_pos, :] = pos_bbox_targets + bbox_weights[:num_pos, :] = 1 + if num_neg > 0: + label_weights[-num_neg:] = 1.0 + + return labels, label_weights, bbox_targets, bbox_weights + + +def expand_target(bbox_targets, bbox_weights, labels, num_classes): + bbox_targets_expand = bbox_targets.new_zeros( + (bbox_targets.size(0), 4 * num_classes)) + bbox_weights_expand = bbox_weights.new_zeros( + (bbox_weights.size(0), 4 * num_classes)) + for i in torch.nonzero(labels > 0).squeeze(-1): + start, end = labels[i] * 4, (labels[i] + 1) * 4 + bbox_targets_expand[i, start:end] = bbox_targets[i, :] + bbox_weights_expand[i, start:end] = bbox_weights[i, :] + return bbox_targets_expand, bbox_weights_expand diff --git a/mmdet/core/bbox/geometry.py b/mmdet/core/bbox/geometry.py new file mode 100644 index 0000000..3bc8dae --- /dev/null +++ b/mmdet/core/bbox/geometry.py @@ -0,0 +1,63 @@ +import torch + + +def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False): + """Calculate overlap between two set of bboxes. + + If ``is_aligned`` is ``False``, then calculate the ious between each bbox + of bboxes1 and bboxes2, otherwise the ious between each aligned pair of + bboxes1 and bboxes2. + + Args: + bboxes1 (Tensor): shape (m, 4) + bboxes2 (Tensor): shape (n, 4), if is_aligned is ``True``, then m and n + must be equal. + mode (str): "iou" (intersection over union) or iof (intersection over + foreground). + + Returns: + ious(Tensor): shape (m, n) if is_aligned == False else shape (m, 1) + """ + + assert mode in ['iou', 'iof'] + + rows = bboxes1.size(0) + cols = bboxes2.size(0) + if is_aligned: + assert rows == cols + + if rows * cols == 0: + return bboxes1.new(rows, 1) if is_aligned else bboxes1.new(rows, cols) + + if is_aligned: + lt = torch.max(bboxes1[:, :2], bboxes2[:, :2]) # [rows, 2] + rb = torch.min(bboxes1[:, 2:], bboxes2[:, 2:]) # [rows, 2] + + wh = (rb - lt + 1).clamp(min=0) # [rows, 2] + overlap = wh[:, 0] * wh[:, 1] + area1 = (bboxes1[:, 2] - bboxes1[:, 0] + 1) * ( + bboxes1[:, 3] - bboxes1[:, 1] + 1) + + if mode == 'iou': + area2 = (bboxes2[:, 2] - bboxes2[:, 0] + 1) * ( + bboxes2[:, 3] - bboxes2[:, 1] + 1) + ious = overlap / (area1 + area2 - overlap) + else: + ious = overlap / area1 + else: + lt = torch.max(bboxes1[:, None, :2], bboxes2[:, :2]) # [rows, cols, 2] + rb = torch.min(bboxes1[:, None, 2:], bboxes2[:, 2:]) # [rows, cols, 2] + + wh = (rb - lt + 1).clamp(min=0) # [rows, cols, 2] + overlap = wh[:, :, 0] * wh[:, :, 1] + area1 = (bboxes1[:, 2] - bboxes1[:, 0] + 1) * ( + bboxes1[:, 3] - bboxes1[:, 1] + 1) + + if mode == 'iou': + area2 = (bboxes2[:, 2] - bboxes2[:, 0] + 1) * ( + bboxes2[:, 3] - bboxes2[:, 1] + 1) + ious = overlap / (area1[:, None] + area2 - overlap) + else: + ious = overlap / (area1[:, None]) + + return ious diff --git a/mmdet/core/bbox/samplers/__init__.py b/mmdet/core/bbox/samplers/__init__.py new file mode 100644 index 0000000..d709d8e --- /dev/null +++ b/mmdet/core/bbox/samplers/__init__.py @@ -0,0 +1,14 @@ +from .base_sampler import BaseSampler +from .combined_sampler import CombinedSampler +from .instance_balanced_pos_sampler import InstanceBalancedPosSampler +from .iou_balanced_neg_sampler import IoUBalancedNegSampler +from .ohem_sampler import OHEMSampler +from .pseudo_sampler import PseudoSampler +from .random_sampler import RandomSampler +from .sampling_result import SamplingResult + +__all__ = [ + 'BaseSampler', 'PseudoSampler', 'RandomSampler', + 'InstanceBalancedPosSampler', 'IoUBalancedNegSampler', 'CombinedSampler', + 'OHEMSampler', 'SamplingResult' +] diff --git a/mmdet/core/bbox/samplers/base_sampler.py b/mmdet/core/bbox/samplers/base_sampler.py new file mode 100644 index 0000000..12df013 --- /dev/null +++ b/mmdet/core/bbox/samplers/base_sampler.py @@ -0,0 +1,78 @@ +from abc import ABCMeta, abstractmethod + +import torch + +from .sampling_result import SamplingResult + + +class BaseSampler(metaclass=ABCMeta): + + def __init__(self, + num, + pos_fraction, + neg_pos_ub=-1, + add_gt_as_proposals=True, + **kwargs): + self.num = num + self.pos_fraction = pos_fraction + self.neg_pos_ub = neg_pos_ub + self.add_gt_as_proposals = add_gt_as_proposals + self.pos_sampler = self + self.neg_sampler = self + + @abstractmethod + def _sample_pos(self, assign_result, num_expected, **kwargs): + pass + + @abstractmethod + def _sample_neg(self, assign_result, num_expected, **kwargs): + pass + + def sample(self, + assign_result, + bboxes, + gt_bboxes, + gt_labels=None, + **kwargs): + """Sample positive and negative bboxes. + + This is a simple implementation of bbox sampling given candidates, + assigning results and ground truth bboxes. + + Args: + assign_result (:obj:`AssignResult`): Bbox assigning results. + bboxes (Tensor): Boxes to be sampled from. + gt_bboxes (Tensor): Ground truth bboxes. + gt_labels (Tensor, optional): Class labels of ground truth bboxes. + + Returns: + :obj:`SamplingResult`: Sampling result. + """ + bboxes = bboxes[:, :4] + + gt_flags = bboxes.new_zeros((bboxes.shape[0], ), dtype=torch.uint8) + if self.add_gt_as_proposals: + bboxes = torch.cat([gt_bboxes, bboxes], dim=0) + assign_result.add_gt_(gt_labels) + gt_ones = bboxes.new_ones(gt_bboxes.shape[0], dtype=torch.uint8) + gt_flags = torch.cat([gt_ones, gt_flags]) + + num_expected_pos = int(self.num * self.pos_fraction) + pos_inds = self.pos_sampler._sample_pos( + assign_result, num_expected_pos, bboxes=bboxes, **kwargs) + # We found that sampled indices have duplicated items occasionally. + # (may be a bug of PyTorch) + pos_inds = pos_inds.unique() + num_sampled_pos = pos_inds.numel() + num_expected_neg = self.num - num_sampled_pos + if self.neg_pos_ub >= 0: + _pos = max(1, num_sampled_pos) + neg_upper_bound = int(self.neg_pos_ub * _pos) + if num_expected_neg > neg_upper_bound: + num_expected_neg = neg_upper_bound + neg_inds = self.neg_sampler._sample_neg( + assign_result, num_expected_neg, bboxes=bboxes, **kwargs) + neg_inds = neg_inds.unique() + + return SamplingResult(pos_inds, neg_inds, bboxes, gt_bboxes, + assign_result, gt_flags) diff --git a/mmdet/core/bbox/samplers/combined_sampler.py b/mmdet/core/bbox/samplers/combined_sampler.py new file mode 100644 index 0000000..351a097 --- /dev/null +++ b/mmdet/core/bbox/samplers/combined_sampler.py @@ -0,0 +1,16 @@ +from ..assign_sampling import build_sampler +from .base_sampler import BaseSampler + + +class CombinedSampler(BaseSampler): + + def __init__(self, pos_sampler, neg_sampler, **kwargs): + super(CombinedSampler, self).__init__(**kwargs) + self.pos_sampler = build_sampler(pos_sampler, **kwargs) + self.neg_sampler = build_sampler(neg_sampler, **kwargs) + + def _sample_pos(self, **kwargs): + raise NotImplementedError + + def _sample_neg(self, **kwargs): + raise NotImplementedError diff --git a/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py b/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py new file mode 100644 index 0000000..bc829a2 --- /dev/null +++ b/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py @@ -0,0 +1,41 @@ +import numpy as np +import torch + +from .random_sampler import RandomSampler + + +class InstanceBalancedPosSampler(RandomSampler): + + def _sample_pos(self, assign_result, num_expected, **kwargs): + pos_inds = torch.nonzero(assign_result.gt_inds > 0) + if pos_inds.numel() != 0: + pos_inds = pos_inds.squeeze(1) + if pos_inds.numel() <= num_expected: + return pos_inds + else: + unique_gt_inds = assign_result.gt_inds[pos_inds].unique() + num_gts = len(unique_gt_inds) + num_per_gt = int(round(num_expected / float(num_gts)) + 1) + sampled_inds = [] + for i in unique_gt_inds: + inds = torch.nonzero(assign_result.gt_inds == i.item()) + if inds.numel() != 0: + inds = inds.squeeze(1) + else: + continue + if len(inds) > num_per_gt: + inds = self.random_choice(inds, num_per_gt) + sampled_inds.append(inds) + sampled_inds = torch.cat(sampled_inds) + if len(sampled_inds) < num_expected: + num_extra = num_expected - len(sampled_inds) + extra_inds = np.array( + list(set(pos_inds.cpu()) - set(sampled_inds.cpu()))) + if len(extra_inds) > num_extra: + extra_inds = self.random_choice(extra_inds, num_extra) + extra_inds = torch.from_numpy(extra_inds).to( + assign_result.gt_inds.device).long() + sampled_inds = torch.cat([sampled_inds, extra_inds]) + elif len(sampled_inds) > num_expected: + sampled_inds = self.random_choice(sampled_inds, num_expected) + return sampled_inds diff --git a/mmdet/core/bbox/samplers/iou_balanced_neg_sampler.py b/mmdet/core/bbox/samplers/iou_balanced_neg_sampler.py new file mode 100644 index 0000000..62431d6 --- /dev/null +++ b/mmdet/core/bbox/samplers/iou_balanced_neg_sampler.py @@ -0,0 +1,133 @@ +import numpy as np +import torch + +from .random_sampler import RandomSampler + + +class IoUBalancedNegSampler(RandomSampler): + """IoU Balanced Sampling + + arXiv: https://arxiv.org/pdf/1904.02701.pdf (CVPR 2019) + + Sampling proposals according to their IoU. `floor_fraction` of needed RoIs + are sampled from proposals whose IoU are lower than `floor_thr` randomly. + The others are sampled from proposals whose IoU are higher than + `floor_thr`. These proposals are sampled from some bins evenly, which are + split by `num_bins` via IoU evenly. + + Args: + num (int): number of proposals. + pos_fraction (float): fraction of positive proposals. + floor_thr (float): threshold (minimum) IoU for IoU balanced sampling, + set to -1 if all using IoU balanced sampling. + floor_fraction (float): sampling fraction of proposals under floor_thr. + num_bins (int): number of bins in IoU balanced sampling. + """ + + def __init__(self, + num, + pos_fraction, + floor_thr=-1, + floor_fraction=0, + num_bins=3, + **kwargs): + super(IoUBalancedNegSampler, self).__init__(num, pos_fraction, + **kwargs) + assert floor_thr >= 0 or floor_thr == -1 + assert 0 <= floor_fraction <= 1 + assert num_bins >= 1 + + self.floor_thr = floor_thr + self.floor_fraction = floor_fraction + self.num_bins = num_bins + + def sample_via_interval(self, max_overlaps, full_set, num_expected): + max_iou = max_overlaps.max() + iou_interval = (max_iou - self.floor_thr) / self.num_bins + per_num_expected = int(num_expected / self.num_bins) + + sampled_inds = [] + for i in range(self.num_bins): + start_iou = self.floor_thr + i * iou_interval + end_iou = self.floor_thr + (i + 1) * iou_interval + tmp_set = set( + np.where( + np.logical_and(max_overlaps >= start_iou, + max_overlaps < end_iou))[0]) + tmp_inds = list(tmp_set & full_set) + if len(tmp_inds) > per_num_expected: + tmp_sampled_set = self.random_choice(tmp_inds, + per_num_expected) + else: + tmp_sampled_set = np.array(tmp_inds, dtype=np.int) + sampled_inds.append(tmp_sampled_set) + + sampled_inds = np.concatenate(sampled_inds) + if len(sampled_inds) < num_expected: + num_extra = num_expected - len(sampled_inds) + extra_inds = np.array(list(full_set - set(sampled_inds))) + if len(extra_inds) > num_extra: + extra_inds = self.random_choice(extra_inds, num_extra) + sampled_inds = np.concatenate([sampled_inds, extra_inds]) + + return sampled_inds + + def _sample_neg(self, assign_result, num_expected, **kwargs): + neg_inds = torch.nonzero(assign_result.gt_inds == 0) + if neg_inds.numel() != 0: + neg_inds = neg_inds.squeeze(1) + if len(neg_inds) <= num_expected: + return neg_inds + else: + max_overlaps = assign_result.max_overlaps.cpu().numpy() + # balance sampling for negative samples + neg_set = set(neg_inds.cpu().numpy()) + + if self.floor_thr > 0: + floor_set = set( + np.where( + np.logical_and(max_overlaps >= 0, + max_overlaps < self.floor_thr))[0]) + iou_sampling_set = set( + np.where(max_overlaps >= self.floor_thr)[0]) + elif self.floor_thr == 0: + floor_set = set(np.where(max_overlaps == 0)[0]) + iou_sampling_set = set( + np.where(max_overlaps > self.floor_thr)[0]) + else: + floor_set = set() + iou_sampling_set = set( + np.where(max_overlaps > self.floor_thr)[0]) + + floor_neg_inds = list(floor_set & neg_set) + iou_sampling_neg_inds = list(iou_sampling_set & neg_set) + num_expected_iou_sampling = int(num_expected * + (1 - self.floor_fraction)) + if len(iou_sampling_neg_inds) > num_expected_iou_sampling: + if self.num_bins >= 2: + iou_sampled_inds = self.sample_via_interval( + max_overlaps, set(iou_sampling_neg_inds), + num_expected_iou_sampling) + else: + iou_sampled_inds = self.random_choice( + iou_sampling_neg_inds, num_expected_iou_sampling) + else: + iou_sampled_inds = np.array( + iou_sampling_neg_inds, dtype=np.int) + num_expected_floor = num_expected - len(iou_sampled_inds) + if len(floor_neg_inds) > num_expected_floor: + sampled_floor_inds = self.random_choice( + floor_neg_inds, num_expected_floor) + else: + sampled_floor_inds = np.array(floor_neg_inds, dtype=np.int) + sampled_inds = np.concatenate( + (sampled_floor_inds, iou_sampled_inds)) + if len(sampled_inds) < num_expected: + num_extra = num_expected - len(sampled_inds) + extra_inds = np.array(list(neg_set - set(sampled_inds))) + if len(extra_inds) > num_extra: + extra_inds = self.random_choice(extra_inds, num_extra) + sampled_inds = np.concatenate((sampled_inds, extra_inds)) + sampled_inds = torch.from_numpy(sampled_inds).long().to( + assign_result.gt_inds.device) + return sampled_inds diff --git a/mmdet/core/bbox/samplers/ohem_sampler.py b/mmdet/core/bbox/samplers/ohem_sampler.py new file mode 100644 index 0000000..2500f31 --- /dev/null +++ b/mmdet/core/bbox/samplers/ohem_sampler.py @@ -0,0 +1,73 @@ +import torch + +from ..transforms import bbox2roi +from .base_sampler import BaseSampler + + +class OHEMSampler(BaseSampler): + + def __init__(self, + num, + pos_fraction, + context, + neg_pos_ub=-1, + add_gt_as_proposals=True, + **kwargs): + super(OHEMSampler, self).__init__(num, pos_fraction, neg_pos_ub, + add_gt_as_proposals) + if not hasattr(context, 'num_stages'): + self.bbox_roi_extractor = context.bbox_roi_extractor + self.bbox_head = context.bbox_head + else: + self.bbox_roi_extractor = context.bbox_roi_extractor[ + context.current_stage] + self.bbox_head = context.bbox_head[context.current_stage] + + def hard_mining(self, inds, num_expected, bboxes, labels, feats): + with torch.no_grad(): + rois = bbox2roi([bboxes]) + bbox_feats = self.bbox_roi_extractor( + feats[:self.bbox_roi_extractor.num_inputs], rois) + cls_score, _ = self.bbox_head(bbox_feats) + loss = self.bbox_head.loss( + cls_score=cls_score, + bbox_pred=None, + labels=labels, + label_weights=cls_score.new_ones(cls_score.size(0)), + bbox_targets=None, + bbox_weights=None, + reduction_override='none')['loss_cls'] + _, topk_loss_inds = loss.topk(num_expected) + return inds[topk_loss_inds] + + def _sample_pos(self, + assign_result, + num_expected, + bboxes=None, + feats=None, + **kwargs): + # Sample some hard positive samples + pos_inds = torch.nonzero(assign_result.gt_inds > 0) + if pos_inds.numel() != 0: + pos_inds = pos_inds.squeeze(1) + if pos_inds.numel() <= num_expected: + return pos_inds + else: + return self.hard_mining(pos_inds, num_expected, bboxes[pos_inds], + assign_result.labels[pos_inds], feats) + + def _sample_neg(self, + assign_result, + num_expected, + bboxes=None, + feats=None, + **kwargs): + # Sample some hard negative samples + neg_inds = torch.nonzero(assign_result.gt_inds == 0) + if neg_inds.numel() != 0: + neg_inds = neg_inds.squeeze(1) + if len(neg_inds) <= num_expected: + return neg_inds + else: + return self.hard_mining(neg_inds, num_expected, bboxes[neg_inds], + assign_result.labels[neg_inds], feats) diff --git a/mmdet/core/bbox/samplers/pseudo_sampler.py b/mmdet/core/bbox/samplers/pseudo_sampler.py new file mode 100644 index 0000000..b4c2ea0 --- /dev/null +++ b/mmdet/core/bbox/samplers/pseudo_sampler.py @@ -0,0 +1,26 @@ +import torch + +from .base_sampler import BaseSampler +from .sampling_result import SamplingResult + + +class PseudoSampler(BaseSampler): + + def __init__(self, **kwargs): + pass + + def _sample_pos(self, **kwargs): + raise NotImplementedError + + def _sample_neg(self, **kwargs): + raise NotImplementedError + + def sample(self, assign_result, bboxes, gt_bboxes, **kwargs): + pos_inds = torch.nonzero( + assign_result.gt_inds > 0).squeeze(-1).unique() + neg_inds = torch.nonzero( + assign_result.gt_inds == 0).squeeze(-1).unique() + gt_flags = bboxes.new_zeros(bboxes.shape[0], dtype=torch.uint8) + sampling_result = SamplingResult(pos_inds, neg_inds, bboxes, gt_bboxes, + assign_result, gt_flags) + return sampling_result diff --git a/mmdet/core/bbox/samplers/random_sampler.py b/mmdet/core/bbox/samplers/random_sampler.py new file mode 100644 index 0000000..0d02b27 --- /dev/null +++ b/mmdet/core/bbox/samplers/random_sampler.py @@ -0,0 +1,53 @@ +import numpy as np +import torch + +from .base_sampler import BaseSampler + + +class RandomSampler(BaseSampler): + + def __init__(self, + num, + pos_fraction, + neg_pos_ub=-1, + add_gt_as_proposals=True, + **kwargs): + super(RandomSampler, self).__init__(num, pos_fraction, neg_pos_ub, + add_gt_as_proposals) + + @staticmethod + def random_choice(gallery, num): + """Random select some elements from the gallery. + + It seems that Pytorch's implementation is slower than numpy so we use + numpy to randperm the indices. + """ + assert len(gallery) >= num + if isinstance(gallery, list): + gallery = np.array(gallery) + cands = np.arange(len(gallery)) + np.random.shuffle(cands) + rand_inds = cands[:num] + if not isinstance(gallery, np.ndarray): + rand_inds = torch.from_numpy(rand_inds).long().to(gallery.device) + return gallery[rand_inds] + + def _sample_pos(self, assign_result, num_expected, **kwargs): + """Randomly sample some positive samples.""" + pos_inds = torch.nonzero(assign_result.gt_inds > 0) + if pos_inds.numel() != 0: + pos_inds = pos_inds.squeeze(1) + if pos_inds.numel() <= num_expected: + return pos_inds + else: + return self.random_choice(pos_inds, num_expected) + + def _sample_neg(self, assign_result, num_expected, **kwargs): + """Randomly sample some negative samples.""" + neg_inds = torch.nonzero(assign_result.gt_inds == 0) + if neg_inds.numel() != 0: + neg_inds = neg_inds.squeeze(1) + if len(neg_inds) <= num_expected: + return neg_inds + else: + return self.random_choice(neg_inds, num_expected) diff --git a/mmdet/core/bbox/samplers/sampling_result.py b/mmdet/core/bbox/samplers/sampling_result.py new file mode 100644 index 0000000..696e650 --- /dev/null +++ b/mmdet/core/bbox/samplers/sampling_result.py @@ -0,0 +1,24 @@ +import torch + + +class SamplingResult(object): + + def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result, + gt_flags): + self.pos_inds = pos_inds + self.neg_inds = neg_inds + self.pos_bboxes = bboxes[pos_inds] + self.neg_bboxes = bboxes[neg_inds] + self.pos_is_gt = gt_flags[pos_inds] + + self.num_gts = gt_bboxes.shape[0] + self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1 + self.pos_gt_bboxes = gt_bboxes[self.pos_assigned_gt_inds, :] + if assign_result.labels is not None: + self.pos_gt_labels = assign_result.labels[pos_inds] + else: + self.pos_gt_labels = None + + @property + def bboxes(self): + return torch.cat([self.pos_bboxes, self.neg_bboxes]) diff --git a/mmdet/core/bbox/transforms.py b/mmdet/core/bbox/transforms.py new file mode 100644 index 0000000..580b9bd --- /dev/null +++ b/mmdet/core/bbox/transforms.py @@ -0,0 +1,180 @@ +import mmcv +import numpy as np +import torch + + +def bbox2delta(proposals, gt, means=[0, 0, 0, 0], stds=[1, 1, 1, 1]): + assert proposals.size() == gt.size() + + proposals = proposals.float() + gt = gt.float() + px = (proposals[..., 0] + proposals[..., 2]) * 0.5 + py = (proposals[..., 1] + proposals[..., 3]) * 0.5 + pw = proposals[..., 2] - proposals[..., 0] + 1.0 + ph = proposals[..., 3] - proposals[..., 1] + 1.0 + + gx = (gt[..., 0] + gt[..., 2]) * 0.5 + gy = (gt[..., 1] + gt[..., 3]) * 0.5 + gw = gt[..., 2] - gt[..., 0] + 1.0 + gh = gt[..., 3] - gt[..., 1] + 1.0 + + dx = (gx - px) / pw + dy = (gy - py) / ph + dw = torch.log(gw / pw) + dh = torch.log(gh / ph) + deltas = torch.stack([dx, dy, dw, dh], dim=-1) + + means = deltas.new_tensor(means).unsqueeze(0) + stds = deltas.new_tensor(stds).unsqueeze(0) + deltas = deltas.sub_(means).div_(stds) + + return deltas + + +def delta2bbox(rois, + deltas, + means=[0, 0, 0, 0], + stds=[1, 1, 1, 1], + max_shape=None, + wh_ratio_clip=16 / 1000): + means = deltas.new_tensor(means).repeat(1, deltas.size(1) // 4) + stds = deltas.new_tensor(stds).repeat(1, deltas.size(1) // 4) + denorm_deltas = deltas * stds + means + dx = denorm_deltas[:, 0::4] + dy = denorm_deltas[:, 1::4] + dw = denorm_deltas[:, 2::4] + dh = denorm_deltas[:, 3::4] + max_ratio = np.abs(np.log(wh_ratio_clip)) + dw = dw.clamp(min=-max_ratio, max=max_ratio) + dh = dh.clamp(min=-max_ratio, max=max_ratio) + px = ((rois[:, 0] + rois[:, 2]) * 0.5).unsqueeze(1).expand_as(dx) + py = ((rois[:, 1] + rois[:, 3]) * 0.5).unsqueeze(1).expand_as(dy) + pw = (rois[:, 2] - rois[:, 0] + 1.0).unsqueeze(1).expand_as(dw) + ph = (rois[:, 3] - rois[:, 1] + 1.0).unsqueeze(1).expand_as(dh) + gw = pw * dw.exp() + gh = ph * dh.exp() + gx = torch.addcmul(px, 1, pw, dx) # gx = px + pw * dx + gy = torch.addcmul(py, 1, ph, dy) # gy = py + ph * dy + x1 = gx - gw * 0.5 + 0.5 + y1 = gy - gh * 0.5 + 0.5 + x2 = gx + gw * 0.5 - 0.5 + y2 = gy + gh * 0.5 - 0.5 + if max_shape is not None: + x1 = x1.clamp(min=0, max=max_shape[1] - 1) + y1 = y1.clamp(min=0, max=max_shape[0] - 1) + x2 = x2.clamp(min=0, max=max_shape[1] - 1) + y2 = y2.clamp(min=0, max=max_shape[0] - 1) + bboxes = torch.stack([x1, y1, x2, y2], dim=-1).view_as(deltas) + return bboxes + + +def bbox_flip(bboxes, img_shape): + """Flip bboxes horizontally. + + Args: + bboxes(Tensor or ndarray): Shape (..., 4*k) + img_shape(tuple): Image shape. + + Returns: + Same type as `bboxes`: Flipped bboxes. + """ + if isinstance(bboxes, torch.Tensor): + assert bboxes.shape[-1] % 4 == 0 + flipped = bboxes.clone() + flipped[:, 0::4] = img_shape[1] - bboxes[:, 2::4] - 1 + flipped[:, 2::4] = img_shape[1] - bboxes[:, 0::4] - 1 + return flipped + elif isinstance(bboxes, np.ndarray): + return mmcv.bbox_flip(bboxes, img_shape) + + +def bbox_mapping(bboxes, img_shape, scale_factor, flip): + """Map bboxes from the original image scale to testing scale""" + new_bboxes = bboxes * scale_factor + if flip: + new_bboxes = bbox_flip(new_bboxes, img_shape) + return new_bboxes + + +def bbox_mapping_back(bboxes, img_shape, scale_factor, flip): + """Map bboxes from testing scale to original image scale""" + new_bboxes = bbox_flip(bboxes, img_shape) if flip else bboxes + new_bboxes = new_bboxes / scale_factor + return new_bboxes + + +def bbox2roi(bbox_list): + """Convert a list of bboxes to roi format. + + Args: + bbox_list (list[Tensor]): a list of bboxes corresponding to a batch + of images. + + Returns: + Tensor: shape (n, 5), [batch_ind, x1, y1, x2, y2] + """ + rois_list = [] + for img_id, bboxes in enumerate(bbox_list): + if bboxes.size(0) > 0: + img_inds = bboxes.new_full((bboxes.size(0), 1), img_id) + rois = torch.cat([img_inds, bboxes[:, :4]], dim=-1) + else: + rois = bboxes.new_zeros((0, 5)) + rois_list.append(rois) + rois = torch.cat(rois_list, 0) + return rois + + +def roi2bbox(rois): + bbox_list = [] + img_ids = torch.unique(rois[:, 0].cpu(), sorted=True) + for img_id in img_ids: + inds = (rois[:, 0] == img_id.item()) + bbox = rois[inds, 1:] + bbox_list.append(bbox) + return bbox_list + + +def bbox2result(bboxes, labels, num_classes): + """Convert detection results to a list of numpy arrays. + + Args: + bboxes (Tensor): shape (n, 5) + labels (Tensor): shape (n, ) + num_classes (int): class number, including background class + + Returns: + list(ndarray): bbox results of each class + """ + if bboxes.shape[0] == 0: + return [ + np.zeros((0, 5), dtype=np.float32) for i in range(num_classes - 1) + ] + else: + bboxes = bboxes.cpu().numpy() + labels = labels.cpu().numpy() + return [bboxes[labels == i, :] for i in range(num_classes - 1)] + + +def distance2bbox(points, distance, max_shape=None): + """Decode distance prediction to bounding box. + + Args: + points (Tensor): Shape (n, 2), [x, y]. + distance (Tensor): Distance from the given point to 4 + boundaries (left, top, right, bottom). + max_shape (tuple): Shape of the image. + + Returns: + Tensor: Decoded bboxes. + """ + x1 = points[:, 0] - distance[:, 0] + y1 = points[:, 1] - distance[:, 1] + x2 = points[:, 0] + distance[:, 2] + y2 = points[:, 1] + distance[:, 3] + if max_shape is not None: + x1 = x1.clamp(min=0, max=max_shape[1] - 1) + y1 = y1.clamp(min=0, max=max_shape[0] - 1) + x2 = x2.clamp(min=0, max=max_shape[1] - 1) + y2 = y2.clamp(min=0, max=max_shape[0] - 1) + return torch.stack([x1, y1, x2, y2], -1) diff --git a/mmdet/core/evaluation/__init__.py b/mmdet/core/evaluation/__init__.py new file mode 100644 index 0000000..90703fe --- /dev/null +++ b/mmdet/core/evaluation/__init__.py @@ -0,0 +1,18 @@ +from .class_names import (coco_classes, dataset_aliases, get_classes, + imagenet_det_classes, imagenet_vid_classes, + voc_classes) +from .coco_utils import coco_eval, fast_eval_recall, results2json +from .eval_hooks import (CocoDistEvalmAPHook, CocoDistEvalRecallHook, + DistEvalHook, DistEvalmAPHook) +from .mean_ap import average_precision, eval_map, print_map_summary +from .recall import (eval_recalls, plot_iou_recall, plot_num_recall, + print_recall_summary) + +__all__ = [ + 'voc_classes', 'imagenet_det_classes', 'imagenet_vid_classes', + 'coco_classes', 'dataset_aliases', 'get_classes', 'coco_eval', + 'fast_eval_recall', 'results2json', 'DistEvalHook', 'DistEvalmAPHook', + 'CocoDistEvalRecallHook', 'CocoDistEvalmAPHook', 'average_precision', + 'eval_map', 'print_map_summary', 'eval_recalls', 'print_recall_summary', + 'plot_num_recall', 'plot_iou_recall' +] diff --git a/mmdet/core/evaluation/bbox_overlaps.py b/mmdet/core/evaluation/bbox_overlaps.py new file mode 100644 index 0000000..ad4c705 --- /dev/null +++ b/mmdet/core/evaluation/bbox_overlaps.py @@ -0,0 +1,49 @@ +import numpy as np + + +def bbox_overlaps(bboxes1, bboxes2, mode='iou'): + """Calculate the ious between each bbox of bboxes1 and bboxes2. + + Args: + bboxes1(ndarray): shape (n, 4) + bboxes2(ndarray): shape (k, 4) + mode(str): iou (intersection over union) or iof (intersection + over foreground) + + Returns: + ious(ndarray): shape (n, k) + """ + + assert mode in ['iou', 'iof'] + + bboxes1 = bboxes1.astype(np.float32) + bboxes2 = bboxes2.astype(np.float32) + rows = bboxes1.shape[0] + cols = bboxes2.shape[0] + ious = np.zeros((rows, cols), dtype=np.float32) + if rows * cols == 0: + return ious + exchange = False + if bboxes1.shape[0] > bboxes2.shape[0]: + bboxes1, bboxes2 = bboxes2, bboxes1 + ious = np.zeros((cols, rows), dtype=np.float32) + exchange = True + area1 = (bboxes1[:, 2] - bboxes1[:, 0] + 1) * ( + bboxes1[:, 3] - bboxes1[:, 1] + 1) + area2 = (bboxes2[:, 2] - bboxes2[:, 0] + 1) * ( + bboxes2[:, 3] - bboxes2[:, 1] + 1) + for i in range(bboxes1.shape[0]): + x_start = np.maximum(bboxes1[i, 0], bboxes2[:, 0]) + y_start = np.maximum(bboxes1[i, 1], bboxes2[:, 1]) + x_end = np.minimum(bboxes1[i, 2], bboxes2[:, 2]) + y_end = np.minimum(bboxes1[i, 3], bboxes2[:, 3]) + overlap = np.maximum(x_end - x_start + 1, 0) * np.maximum( + y_end - y_start + 1, 0) + if mode == 'iou': + union = area1[i] + area2 - overlap + else: + union = area1[i] if not exchange else area2 + ious[i, :] = overlap / union + if exchange: + ious = ious.T + return ious diff --git a/mmdet/core/evaluation/class_names.py b/mmdet/core/evaluation/class_names.py new file mode 100644 index 0000000..7842773 --- /dev/null +++ b/mmdet/core/evaluation/class_names.py @@ -0,0 +1,116 @@ +import mmcv + + +def wider_face_classes(): + return ['face'] + + +def voc_classes(): + return [ + 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', + 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person', + 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor' + ] + + +def imagenet_det_classes(): + return [ + 'accordion', 'airplane', 'ant', 'antelope', 'apple', 'armadillo', + 'artichoke', 'axe', 'baby_bed', 'backpack', 'bagel', 'balance_beam', + 'banana', 'band_aid', 'banjo', 'baseball', 'basketball', 'bathing_cap', + 'beaker', 'bear', 'bee', 'bell_pepper', 'bench', 'bicycle', 'binder', + 'bird', 'bookshelf', 'bow_tie', 'bow', 'bowl', 'brassiere', 'burrito', + 'bus', 'butterfly', 'camel', 'can_opener', 'car', 'cart', 'cattle', + 'cello', 'centipede', 'chain_saw', 'chair', 'chime', 'cocktail_shaker', + 'coffee_maker', 'computer_keyboard', 'computer_mouse', 'corkscrew', + 'cream', 'croquet_ball', 'crutch', 'cucumber', 'cup_or_mug', 'diaper', + 'digital_clock', 'dishwasher', 'dog', 'domestic_cat', 'dragonfly', + 'drum', 'dumbbell', 'electric_fan', 'elephant', 'face_powder', 'fig', + 'filing_cabinet', 'flower_pot', 'flute', 'fox', 'french_horn', 'frog', + 'frying_pan', 'giant_panda', 'goldfish', 'golf_ball', 'golfcart', + 'guacamole', 'guitar', 'hair_dryer', 'hair_spray', 'hamburger', + 'hammer', 'hamster', 'harmonica', 'harp', 'hat_with_a_wide_brim', + 'head_cabbage', 'helmet', 'hippopotamus', 'horizontal_bar', 'horse', + 'hotdog', 'iPod', 'isopod', 'jellyfish', 'koala_bear', 'ladle', + 'ladybug', 'lamp', 'laptop', 'lemon', 'lion', 'lipstick', 'lizard', + 'lobster', 'maillot', 'maraca', 'microphone', 'microwave', 'milk_can', + 'miniskirt', 'monkey', 'motorcycle', 'mushroom', 'nail', 'neck_brace', + 'oboe', 'orange', 'otter', 'pencil_box', 'pencil_sharpener', 'perfume', + 'person', 'piano', 'pineapple', 'ping-pong_ball', 'pitcher', 'pizza', + 'plastic_bag', 'plate_rack', 'pomegranate', 'popsicle', 'porcupine', + 'power_drill', 'pretzel', 'printer', 'puck', 'punching_bag', 'purse', + 'rabbit', 'racket', 'ray', 'red_panda', 'refrigerator', + 'remote_control', 'rubber_eraser', 'rugby_ball', 'ruler', + 'salt_or_pepper_shaker', 'saxophone', 'scorpion', 'screwdriver', + 'seal', 'sheep', 'ski', 'skunk', 'snail', 'snake', 'snowmobile', + 'snowplow', 'soap_dispenser', 'soccer_ball', 'sofa', 'spatula', + 'squirrel', 'starfish', 'stethoscope', 'stove', 'strainer', + 'strawberry', 'stretcher', 'sunglasses', 'swimming_trunks', 'swine', + 'syringe', 'table', 'tape_player', 'tennis_ball', 'tick', 'tie', + 'tiger', 'toaster', 'traffic_light', 'train', 'trombone', 'trumpet', + 'turtle', 'tv_or_monitor', 'unicycle', 'vacuum', 'violin', + 'volleyball', 'waffle_iron', 'washer', 'water_bottle', 'watercraft', + 'whale', 'wine_bottle', 'zebra' + ] + + +def imagenet_vid_classes(): + return [ + 'airplane', 'antelope', 'bear', 'bicycle', 'bird', 'bus', 'car', + 'cattle', 'dog', 'domestic_cat', 'elephant', 'fox', 'giant_panda', + 'hamster', 'horse', 'lion', 'lizard', 'monkey', 'motorcycle', 'rabbit', + 'red_panda', 'sheep', 'snake', 'squirrel', 'tiger', 'train', 'turtle', + 'watercraft', 'whale', 'zebra' + ] + + +def coco_classes(): + return [ + 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', + 'truck', 'boat', 'traffic_light', 'fire_hydrant', 'stop_sign', + 'parking_meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', + 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', + 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', + 'sports_ball', 'kite', 'baseball_bat', 'baseball_glove', 'skateboard', + 'surfboard', 'tennis_racket', 'bottle', 'wine_glass', 'cup', 'fork', + 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange', + 'broccoli', 'carrot', 'hot_dog', 'pizza', 'donut', 'cake', 'chair', + 'couch', 'potted_plant', 'bed', 'dining_table', 'toilet', 'tv', + 'laptop', 'mouse', 'remote', 'keyboard', 'cell_phone', 'microwave', + 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', + 'scissors', 'teddy_bear', 'hair_drier', 'toothbrush' + ] + + +def cityscapes_classes(): + return [ + 'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle', + 'bicycle' + ] + + +dataset_aliases = { + 'voc': ['voc', 'pascal_voc', 'voc07', 'voc12'], + 'imagenet_det': ['det', 'imagenet_det', 'ilsvrc_det'], + 'imagenet_vid': ['vid', 'imagenet_vid', 'ilsvrc_vid'], + 'coco': ['coco', 'mscoco', 'ms_coco'], + 'wider_face': ['WIDERFaceDataset', 'wider_face', 'WDIERFace'], + 'cityscapes': ['cityscapes'] +} + + +def get_classes(dataset): + """Get class names of a dataset.""" + alias2name = {} + for name, aliases in dataset_aliases.items(): + for alias in aliases: + alias2name[alias] = name + + if mmcv.is_str(dataset): + if dataset in alias2name: + labels = eval(alias2name[dataset] + '_classes()') + else: + raise ValueError('Unrecognized dataset: {}'.format(dataset)) + else: + raise TypeError('dataset must a str, but got {}'.format(type(dataset))) + return labels diff --git a/mmdet/core/evaluation/coco_utils.py b/mmdet/core/evaluation/coco_utils.py new file mode 100644 index 0000000..3022ad0 --- /dev/null +++ b/mmdet/core/evaluation/coco_utils.py @@ -0,0 +1,177 @@ +import mmcv +import numpy as np +from pycocotools.coco import COCO +from pycocotools.cocoeval import COCOeval + +from .recall import eval_recalls + + +def coco_eval(result_files, result_types, coco, max_dets=(100, 300, 1000)): + for res_type in result_types: + assert res_type in [ + 'proposal', 'proposal_fast', 'bbox', 'segm', 'keypoints' + ] + + if mmcv.is_str(coco): + coco = COCO(coco) + assert isinstance(coco, COCO) + + if result_types == ['proposal_fast']: + ar = fast_eval_recall(result_files, coco, np.array(max_dets)) + for i, num in enumerate(max_dets): + print('AR@{}\t= {:.4f}'.format(num, ar[i])) + return + + for res_type in result_types: + result_file = result_files[res_type] + assert result_file.endswith('.json') + + coco_dets = coco.loadRes(result_file) + img_ids = coco.getImgIds() + iou_type = 'bbox' if res_type == 'proposal' else res_type + cocoEval = COCOeval(coco, coco_dets, iou_type) + cocoEval.params.imgIds = img_ids + if res_type == 'proposal': + cocoEval.params.useCats = 0 + cocoEval.params.maxDets = list(max_dets) + cocoEval.evaluate() + cocoEval.accumulate() + cocoEval.summarize() + + +def fast_eval_recall(results, + coco, + max_dets, + iou_thrs=np.arange(0.5, 0.96, 0.05)): + if mmcv.is_str(results): + assert results.endswith('.pkl') + results = mmcv.load(results) + elif not isinstance(results, list): + raise TypeError( + 'results must be a list of numpy arrays or a filename, not {}'. + format(type(results))) + + gt_bboxes = [] + img_ids = coco.getImgIds() + for i in range(len(img_ids)): + ann_ids = coco.getAnnIds(imgIds=img_ids[i]) + ann_info = coco.loadAnns(ann_ids) + if len(ann_info) == 0: + gt_bboxes.append(np.zeros((0, 4))) + continue + bboxes = [] + for ann in ann_info: + if ann.get('ignore', False) or ann['iscrowd']: + continue + x1, y1, w, h = ann['bbox'] + bboxes.append([x1, y1, x1 + w - 1, y1 + h - 1]) + bboxes = np.array(bboxes, dtype=np.float32) + if bboxes.shape[0] == 0: + bboxes = np.zeros((0, 4)) + gt_bboxes.append(bboxes) + + recalls = eval_recalls( + gt_bboxes, results, max_dets, iou_thrs, print_summary=False) + ar = recalls.mean(axis=1) + return ar + + +def xyxy2xywh(bbox): + _bbox = bbox.tolist() + return [ + _bbox[0], + _bbox[1], + _bbox[2] - _bbox[0] + 1, + _bbox[3] - _bbox[1] + 1, + ] + + +def proposal2json(dataset, results): + json_results = [] + for idx in range(len(dataset)): + img_id = dataset.img_ids[idx] + bboxes = results[idx] + for i in range(bboxes.shape[0]): + data = dict() + data['image_id'] = img_id + data['bbox'] = xyxy2xywh(bboxes[i]) + data['score'] = float(bboxes[i][4]) + data['category_id'] = 1 + json_results.append(data) + return json_results + + +def det2json(dataset, results): + json_results = [] + for idx in range(len(dataset)): + img_id = dataset.img_ids[idx] + result = results[idx] + for label in range(len(result)): + bboxes = result[label] + for i in range(bboxes.shape[0]): + data = dict() + data['image_id'] = img_id + data['bbox'] = xyxy2xywh(bboxes[i]) + data['score'] = float(bboxes[i][4]) + data['category_id'] = dataset.cat_ids[label] + json_results.append(data) + return json_results + + +def segm2json(dataset, results): + bbox_json_results = [] + segm_json_results = [] + for idx in range(len(dataset)): + img_id = dataset.img_ids[idx] + det, seg = results[idx] + for label in range(len(det)): + # bbox results + bboxes = det[label] + for i in range(bboxes.shape[0]): + data = dict() + data['image_id'] = img_id + data['bbox'] = xyxy2xywh(bboxes[i]) + data['score'] = float(bboxes[i][4]) + data['category_id'] = dataset.cat_ids[label] + bbox_json_results.append(data) + + # segm results + # some detectors use different score for det and segm + if len(seg) == 2: + segms = seg[0][label] + mask_score = seg[1][label] + else: + segms = seg[label] + mask_score = [bbox[4] for bbox in bboxes] + for i in range(bboxes.shape[0]): + data = dict() + data['image_id'] = img_id + data['score'] = float(mask_score[i]) + data['category_id'] = dataset.cat_ids[label] + segms[i]['counts'] = segms[i]['counts'].decode() + data['segmentation'] = segms[i] + segm_json_results.append(data) + return bbox_json_results, segm_json_results + + +def results2json(dataset, results, out_file): + result_files = dict() + if isinstance(results[0], list): + json_results = det2json(dataset, results) + result_files['bbox'] = '{}.{}.json'.format(out_file, 'bbox') + result_files['proposal'] = '{}.{}.json'.format(out_file, 'bbox') + mmcv.dump(json_results, result_files['bbox']) + elif isinstance(results[0], tuple): + json_results = segm2json(dataset, results) + result_files['bbox'] = '{}.{}.json'.format(out_file, 'bbox') + result_files['proposal'] = '{}.{}.json'.format(out_file, 'bbox') + result_files['segm'] = '{}.{}.json'.format(out_file, 'segm') + mmcv.dump(json_results[0], result_files['bbox']) + mmcv.dump(json_results[1], result_files['segm']) + elif isinstance(results[0], np.ndarray): + json_results = proposal2json(dataset, results) + result_files['proposal'] = '{}.{}.json'.format(out_file, 'proposal') + mmcv.dump(json_results, result_files['proposal']) + else: + raise TypeError('invalid type of results') + return result_files diff --git a/mmdet/core/evaluation/eval_hooks.py b/mmdet/core/evaluation/eval_hooks.py new file mode 100644 index 0000000..c37f7bd --- /dev/null +++ b/mmdet/core/evaluation/eval_hooks.py @@ -0,0 +1,168 @@ +import os +import os.path as osp + +import mmcv +import numpy as np +import torch +import torch.distributed as dist +from mmcv.parallel import collate, scatter +from mmcv.runner import Hook +from pycocotools.cocoeval import COCOeval +from torch.utils.data import Dataset + +from mmdet import datasets +from .coco_utils import fast_eval_recall, results2json +from .mean_ap import eval_map + + +class DistEvalHook(Hook): + + def __init__(self, dataset, interval=1): + if isinstance(dataset, Dataset): + self.dataset = dataset + elif isinstance(dataset, dict): + self.dataset = datasets.build_dataset(dataset, {'test_mode': True}) + else: + raise TypeError( + 'dataset must be a Dataset object or a dict, not {}'.format( + type(dataset))) + self.interval = interval + + def after_train_epoch(self, runner): + if not self.every_n_epochs(runner, self.interval): + return + runner.model.eval() + results = [None for _ in range(len(self.dataset))] + if runner.rank == 0: + prog_bar = mmcv.ProgressBar(len(self.dataset)) + for idx in range(runner.rank, len(self.dataset), runner.world_size): + data = self.dataset[idx] + data_gpu = scatter( + collate([data], samples_per_gpu=1), + [torch.cuda.current_device()])[0] + + # compute output + with torch.no_grad(): + result = runner.model( + return_loss=False, rescale=True, **data_gpu) + results[idx] = result + + batch_size = runner.world_size + if runner.rank == 0: + for _ in range(batch_size): + prog_bar.update() + + if runner.rank == 0: + print('\n') + dist.barrier() + for i in range(1, runner.world_size): + tmp_file = osp.join(runner.work_dir, 'temp_{}.pkl'.format(i)) + tmp_results = mmcv.load(tmp_file) + for idx in range(i, len(results), runner.world_size): + results[idx] = tmp_results[idx] + os.remove(tmp_file) + self.evaluate(runner, results) + else: + tmp_file = osp.join(runner.work_dir, + 'temp_{}.pkl'.format(runner.rank)) + mmcv.dump(results, tmp_file) + dist.barrier() + dist.barrier() + + def evaluate(self): + raise NotImplementedError + + +class DistEvalmAPHook(DistEvalHook): + + def evaluate(self, runner, results): + gt_bboxes = [] + gt_labels = [] + gt_ignore = [] if self.dataset.with_crowd else None + for i in range(len(self.dataset)): + ann = self.dataset.get_ann_info(i) + bboxes = ann['bboxes'] + labels = ann['labels'] + if gt_ignore is not None: + ignore = np.concatenate([ + np.zeros(bboxes.shape[0], dtype=np.bool), + np.ones(ann['bboxes_ignore'].shape[0], dtype=np.bool) + ]) + gt_ignore.append(ignore) + bboxes = np.vstack([bboxes, ann['bboxes_ignore']]) + labels = np.concatenate([labels, ann['labels_ignore']]) + gt_bboxes.append(bboxes) + gt_labels.append(labels) + # If the dataset is VOC2007, then use 11 points mAP evaluation. + if hasattr(self.dataset, 'year') and self.dataset.year == 2007: + ds_name = 'voc07' + else: + ds_name = self.dataset.CLASSES + mean_ap, eval_results = eval_map( + results, + gt_bboxes, + gt_labels, + gt_ignore=gt_ignore, + scale_ranges=None, + iou_thr=0.5, + dataset=ds_name, + print_summary=True) + runner.log_buffer.output['mAP'] = mean_ap + runner.log_buffer.ready = True + + +class CocoDistEvalRecallHook(DistEvalHook): + + def __init__(self, + dataset, + interval=1, + proposal_nums=(100, 300, 1000), + iou_thrs=np.arange(0.5, 0.96, 0.05)): + super(CocoDistEvalRecallHook, self).__init__( + dataset, interval=interval) + self.proposal_nums = np.array(proposal_nums, dtype=np.int32) + self.iou_thrs = np.array(iou_thrs, dtype=np.float32) + + def evaluate(self, runner, results): + # the official coco evaluation is too slow, here we use our own + # implementation instead, which may get slightly different results + ar = fast_eval_recall(results, self.dataset.coco, self.proposal_nums, + self.iou_thrs) + for i, num in enumerate(self.proposal_nums): + runner.log_buffer.output['AR@{}'.format(num)] = ar[i] + runner.log_buffer.ready = True + + +class CocoDistEvalmAPHook(DistEvalHook): + + def evaluate(self, runner, results): + tmp_file = osp.join(runner.work_dir, 'temp_0') + result_files = results2json(self.dataset, results, tmp_file) + + res_types = ['bbox', 'segm' + ] if runner.model.module.with_mask else ['bbox'] + cocoGt = self.dataset.coco + imgIds = cocoGt.getImgIds() + for res_type in res_types: + try: + cocoDt = cocoGt.loadRes(result_files[res_type]) + except IndexError: + print('No prediction found.') + break + iou_type = res_type + cocoEval = COCOeval(cocoGt, cocoDt, iou_type) + cocoEval.params.imgIds = imgIds + cocoEval.evaluate() + cocoEval.accumulate() + cocoEval.summarize() + metrics = ['mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'] + for i in range(len(metrics)): + key = '{}_{}'.format(res_type, metrics[i]) + val = float('{:.3f}'.format(cocoEval.stats[i])) + runner.log_buffer.output[key] = val + runner.log_buffer.output['{}_mAP_copypaste'.format(res_type)] = ( + '{ap[0]:.3f} {ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} ' + '{ap[4]:.3f} {ap[5]:.3f}').format(ap=cocoEval.stats[:6]) + runner.log_buffer.ready = True + for res_type in res_types: + os.remove(result_files[res_type]) diff --git a/mmdet/core/evaluation/mean_ap.py b/mmdet/core/evaluation/mean_ap.py new file mode 100644 index 0000000..74a972b --- /dev/null +++ b/mmdet/core/evaluation/mean_ap.py @@ -0,0 +1,379 @@ +import mmcv +import numpy as np +from terminaltables import AsciiTable + +from .bbox_overlaps import bbox_overlaps +from .class_names import get_classes + + +def average_precision(recalls, precisions, mode='area'): + """Calculate average precision (for single or multiple scales). + + Args: + recalls (ndarray): shape (num_scales, num_dets) or (num_dets, ) + precisions (ndarray): shape (num_scales, num_dets) or (num_dets, ) + mode (str): 'area' or '11points', 'area' means calculating the area + under precision-recall curve, '11points' means calculating + the average precision of recalls at [0, 0.1, ..., 1] + + Returns: + float or ndarray: calculated average precision + """ + no_scale = False + if recalls.ndim == 1: + no_scale = True + recalls = recalls[np.newaxis, :] + precisions = precisions[np.newaxis, :] + assert recalls.shape == precisions.shape and recalls.ndim == 2 + num_scales = recalls.shape[0] + ap = np.zeros(num_scales, dtype=np.float32) + if mode == 'area': + zeros = np.zeros((num_scales, 1), dtype=recalls.dtype) + ones = np.ones((num_scales, 1), dtype=recalls.dtype) + mrec = np.hstack((zeros, recalls, ones)) + mpre = np.hstack((zeros, precisions, zeros)) + for i in range(mpre.shape[1] - 1, 0, -1): + mpre[:, i - 1] = np.maximum(mpre[:, i - 1], mpre[:, i]) + for i in range(num_scales): + ind = np.where(mrec[i, 1:] != mrec[i, :-1])[0] + ap[i] = np.sum( + (mrec[i, ind + 1] - mrec[i, ind]) * mpre[i, ind + 1]) + elif mode == '11points': + for i in range(num_scales): + for thr in np.arange(0, 1 + 1e-3, 0.1): + precs = precisions[i, recalls[i, :] >= thr] + prec = precs.max() if precs.size > 0 else 0 + ap[i] += prec + ap /= 11 + else: + raise ValueError( + 'Unrecognized mode, only "area" and "11points" are supported') + if no_scale: + ap = ap[0] + return ap + + +def tpfp_imagenet(det_bboxes, + gt_bboxes, + gt_ignore, + default_iou_thr, + area_ranges=None): + """Check if detected bboxes are true positive or false positive. + + Args: + det_bbox (ndarray): the detected bbox + gt_bboxes (ndarray): ground truth bboxes of this image + gt_ignore (ndarray): indicate if gts are ignored for evaluation or not + default_iou_thr (float): the iou thresholds for medium and large bboxes + area_ranges (list or None): gt bbox area ranges + + Returns: + tuple: two arrays (tp, fp) whose elements are 0 and 1 + """ + num_dets = det_bboxes.shape[0] + num_gts = gt_bboxes.shape[0] + if area_ranges is None: + area_ranges = [(None, None)] + num_scales = len(area_ranges) + # tp and fp are of shape (num_scales, num_gts), each row is tp or fp + # of a certain scale. + tp = np.zeros((num_scales, num_dets), dtype=np.float32) + fp = np.zeros((num_scales, num_dets), dtype=np.float32) + if gt_bboxes.shape[0] == 0: + if area_ranges == [(None, None)]: + fp[...] = 1 + else: + det_areas = (det_bboxes[:, 2] - det_bboxes[:, 0] + 1) * ( + det_bboxes[:, 3] - det_bboxes[:, 1] + 1) + for i, (min_area, max_area) in enumerate(area_ranges): + fp[i, (det_areas >= min_area) & (det_areas < max_area)] = 1 + return tp, fp + ious = bbox_overlaps(det_bboxes, gt_bboxes - 1) + gt_w = gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1 + gt_h = gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1 + iou_thrs = np.minimum((gt_w * gt_h) / ((gt_w + 10.0) * (gt_h + 10.0)), + default_iou_thr) + # sort all detections by scores in descending order + sort_inds = np.argsort(-det_bboxes[:, -1]) + for k, (min_area, max_area) in enumerate(area_ranges): + gt_covered = np.zeros(num_gts, dtype=bool) + # if no area range is specified, gt_area_ignore is all False + if min_area is None: + gt_area_ignore = np.zeros_like(gt_ignore, dtype=bool) + else: + gt_areas = gt_w * gt_h + gt_area_ignore = (gt_areas < min_area) | (gt_areas >= max_area) + for i in sort_inds: + max_iou = -1 + matched_gt = -1 + # find best overlapped available gt + for j in range(num_gts): + # different from PASCAL VOC: allow finding other gts if the + # best overlaped ones are already matched by other det bboxes + if gt_covered[j]: + continue + elif ious[i, j] >= iou_thrs[j] and ious[i, j] > max_iou: + max_iou = ious[i, j] + matched_gt = j + # there are 4 cases for a det bbox: + # 1. it matches a gt, tp = 1, fp = 0 + # 2. it matches an ignored gt, tp = 0, fp = 0 + # 3. it matches no gt and within area range, tp = 0, fp = 1 + # 4. it matches no gt but is beyond area range, tp = 0, fp = 0 + if matched_gt >= 0: + gt_covered[matched_gt] = 1 + if not (gt_ignore[matched_gt] or gt_area_ignore[matched_gt]): + tp[k, i] = 1 + elif min_area is None: + fp[k, i] = 1 + else: + bbox = det_bboxes[i, :4] + area = (bbox[2] - bbox[0] + 1) * (bbox[3] - bbox[1] + 1) + if area >= min_area and area < max_area: + fp[k, i] = 1 + return tp, fp + + +def tpfp_default(det_bboxes, gt_bboxes, gt_ignore, iou_thr, area_ranges=None): + """Check if detected bboxes are true positive or false positive. + + Args: + det_bbox (ndarray): the detected bbox + gt_bboxes (ndarray): ground truth bboxes of this image + gt_ignore (ndarray): indicate if gts are ignored for evaluation or not + iou_thr (float): the iou thresholds + + Returns: + tuple: (tp, fp), two arrays whose elements are 0 and 1 + """ + num_dets = det_bboxes.shape[0] + num_gts = gt_bboxes.shape[0] + if area_ranges is None: + area_ranges = [(None, None)] + num_scales = len(area_ranges) + # tp and fp are of shape (num_scales, num_gts), each row is tp or fp of + # a certain scale + tp = np.zeros((num_scales, num_dets), dtype=np.float32) + fp = np.zeros((num_scales, num_dets), dtype=np.float32) + # if there is no gt bboxes in this image, then all det bboxes + # within area range are false positives + if gt_bboxes.shape[0] == 0: + if area_ranges == [(None, None)]: + fp[...] = 1 + else: + det_areas = (det_bboxes[:, 2] - det_bboxes[:, 0] + 1) * ( + det_bboxes[:, 3] - det_bboxes[:, 1] + 1) + for i, (min_area, max_area) in enumerate(area_ranges): + fp[i, (det_areas >= min_area) & (det_areas < max_area)] = 1 + return tp, fp + ious = bbox_overlaps(det_bboxes, gt_bboxes) + ious_max = ious.max(axis=1) + ious_argmax = ious.argmax(axis=1) + sort_inds = np.argsort(-det_bboxes[:, -1]) + for k, (min_area, max_area) in enumerate(area_ranges): + gt_covered = np.zeros(num_gts, dtype=bool) + # if no area range is specified, gt_area_ignore is all False + if min_area is None: + gt_area_ignore = np.zeros_like(gt_ignore, dtype=bool) + else: + gt_areas = (gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1) * ( + gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1) + gt_area_ignore = (gt_areas < min_area) | (gt_areas >= max_area) + for i in sort_inds: + if ious_max[i] >= iou_thr: + matched_gt = ious_argmax[i] + if not (gt_ignore[matched_gt] or gt_area_ignore[matched_gt]): + if not gt_covered[matched_gt]: + gt_covered[matched_gt] = True + tp[k, i] = 1 + else: + fp[k, i] = 1 + # otherwise ignore this detected bbox, tp = 0, fp = 0 + elif min_area is None: + fp[k, i] = 1 + else: + bbox = det_bboxes[i, :4] + area = (bbox[2] - bbox[0] + 1) * (bbox[3] - bbox[1] + 1) + if area >= min_area and area < max_area: + fp[k, i] = 1 + return tp, fp + + +def get_cls_results(det_results, gt_bboxes, gt_labels, gt_ignore, class_id): + """Get det results and gt information of a certain class.""" + cls_dets = [det[class_id] + for det in det_results] # det bboxes of this class + cls_gts = [] # gt bboxes of this class + cls_gt_ignore = [] + for j in range(len(gt_bboxes)): + gt_bbox = gt_bboxes[j] + cls_inds = (gt_labels[j] == class_id + 1) + cls_gt = gt_bbox[cls_inds, :] if gt_bbox.shape[0] > 0 else gt_bbox + cls_gts.append(cls_gt) + if gt_ignore is None: + cls_gt_ignore.append(np.zeros(cls_gt.shape[0], dtype=np.int32)) + else: + cls_gt_ignore.append(gt_ignore[j][cls_inds]) + return cls_dets, cls_gts, cls_gt_ignore + + +def eval_map(det_results, + gt_bboxes, + gt_labels, + gt_ignore=None, + scale_ranges=None, + iou_thr=0.5, + dataset=None, + print_summary=True): + """Evaluate mAP of a dataset. + + Args: + det_results (list): a list of list, [[cls1_det, cls2_det, ...], ...] + gt_bboxes (list): ground truth bboxes of each image, a list of K*4 + array. + gt_labels (list): ground truth labels of each image, a list of K array + gt_ignore (list): gt ignore indicators of each image, a list of K array + scale_ranges (list, optional): [(min1, max1), (min2, max2), ...] + iou_thr (float): IoU threshold + dataset (None or str or list): dataset name or dataset classes, there + are minor differences in metrics for different datsets, e.g. + "voc07", "imagenet_det", etc. + print_summary (bool): whether to print the mAP summary + + Returns: + tuple: (mAP, [dict, dict, ...]) + """ + assert len(det_results) == len(gt_bboxes) == len(gt_labels) + if gt_ignore is not None: + assert len(gt_ignore) == len(gt_labels) + for i in range(len(gt_ignore)): + assert len(gt_labels[i]) == len(gt_ignore[i]) + area_ranges = ([(rg[0]**2, rg[1]**2) for rg in scale_ranges] + if scale_ranges is not None else None) + num_scales = len(scale_ranges) if scale_ranges is not None else 1 + eval_results = [] + num_classes = len(det_results[0]) # positive class num + gt_labels = [ + label if label.ndim == 1 else label[:, 0] for label in gt_labels + ] + for i in range(num_classes): + # get gt and det bboxes of this class + cls_dets, cls_gts, cls_gt_ignore = get_cls_results( + det_results, gt_bboxes, gt_labels, gt_ignore, i) + # calculate tp and fp for each image + tpfp_func = ( + tpfp_imagenet if dataset in ['det', 'vid'] else tpfp_default) + tpfp = [ + tpfp_func(cls_dets[j], cls_gts[j], cls_gt_ignore[j], iou_thr, + area_ranges) for j in range(len(cls_dets)) + ] + tp, fp = tuple(zip(*tpfp)) + # calculate gt number of each scale, gts ignored or beyond scale + # are not counted + num_gts = np.zeros(num_scales, dtype=int) + for j, bbox in enumerate(cls_gts): + if area_ranges is None: + num_gts[0] += np.sum(np.logical_not(cls_gt_ignore[j])) + else: + gt_areas = (bbox[:, 2] - bbox[:, 0] + 1) * ( + bbox[:, 3] - bbox[:, 1] + 1) + for k, (min_area, max_area) in enumerate(area_ranges): + num_gts[k] += np.sum( + np.logical_not(cls_gt_ignore[j]) + & (gt_areas >= min_area) & (gt_areas < max_area)) + # sort all det bboxes by score, also sort tp and fp + cls_dets = np.vstack(cls_dets) + num_dets = cls_dets.shape[0] + sort_inds = np.argsort(-cls_dets[:, -1]) + tp = np.hstack(tp)[:, sort_inds] + fp = np.hstack(fp)[:, sort_inds] + # calculate recall and precision with tp and fp + tp = np.cumsum(tp, axis=1) + fp = np.cumsum(fp, axis=1) + eps = np.finfo(np.float32).eps + recalls = tp / np.maximum(num_gts[:, np.newaxis], eps) + precisions = tp / np.maximum((tp + fp), eps) + # calculate AP + if scale_ranges is None: + recalls = recalls[0, :] + precisions = precisions[0, :] + num_gts = num_gts.item() + mode = 'area' if dataset != 'voc07' else '11points' + ap = average_precision(recalls, precisions, mode) + eval_results.append({ + 'num_gts': num_gts, + 'num_dets': num_dets, + 'recall': recalls, + 'precision': precisions, + 'ap': ap + }) + if scale_ranges is not None: + # shape (num_classes, num_scales) + all_ap = np.vstack([cls_result['ap'] for cls_result in eval_results]) + all_num_gts = np.vstack( + [cls_result['num_gts'] for cls_result in eval_results]) + mean_ap = [] + for i in range(num_scales): + if np.any(all_num_gts[:, i] > 0): + mean_ap.append(all_ap[all_num_gts[:, i] > 0, i].mean()) + else: + mean_ap.append(0.0) + else: + aps = [] + for cls_result in eval_results: + if cls_result['num_gts'] > 0: + aps.append(cls_result['ap']) + mean_ap = np.array(aps).mean().item() if aps else 0.0 + if print_summary: + print_map_summary(mean_ap, eval_results, dataset) + + return mean_ap, eval_results + + +def print_map_summary(mean_ap, results, dataset=None): + """Print mAP and results of each class. + + Args: + mean_ap(float): calculated from `eval_map` + results(list): calculated from `eval_map` + dataset(None or str or list): dataset name or dataset classes. + """ + num_scales = len(results[0]['ap']) if isinstance(results[0]['ap'], + np.ndarray) else 1 + num_classes = len(results) + + recalls = np.zeros((num_scales, num_classes), dtype=np.float32) + precisions = np.zeros((num_scales, num_classes), dtype=np.float32) + aps = np.zeros((num_scales, num_classes), dtype=np.float32) + num_gts = np.zeros((num_scales, num_classes), dtype=int) + for i, cls_result in enumerate(results): + if cls_result['recall'].size > 0: + recalls[:, i] = np.array(cls_result['recall'], ndmin=2)[:, -1] + precisions[:, i] = np.array( + cls_result['precision'], ndmin=2)[:, -1] + aps[:, i] = cls_result['ap'] + num_gts[:, i] = cls_result['num_gts'] + + if dataset is None: + label_names = [str(i) for i in range(1, num_classes + 1)] + elif mmcv.is_str(dataset): + label_names = get_classes(dataset) + else: + label_names = dataset + + if not isinstance(mean_ap, list): + mean_ap = [mean_ap] + header = ['class', 'gts', 'dets', 'recall', 'precision', 'ap'] + for i in range(num_scales): + table_data = [header] + for j in range(num_classes): + row_data = [ + label_names[j], num_gts[i, j], results[j]['num_dets'], + '{:.3f}'.format(recalls[i, j]), + '{:.3f}'.format(precisions[i, j]), '{:.3f}'.format(aps[i, j]) + ] + table_data.append(row_data) + table_data.append(['mAP', '', '', '', '', '{:.3f}'.format(mean_ap[i])]) + table = AsciiTable(table_data) + table.inner_footing_row_border = True + print(table.table) diff --git a/mmdet/core/evaluation/recall.py b/mmdet/core/evaluation/recall.py new file mode 100644 index 0000000..2a56f42 --- /dev/null +++ b/mmdet/core/evaluation/recall.py @@ -0,0 +1,185 @@ +import numpy as np +from terminaltables import AsciiTable + +from .bbox_overlaps import bbox_overlaps + + +def _recalls(all_ious, proposal_nums, thrs): + + img_num = all_ious.shape[0] + total_gt_num = sum([ious.shape[0] for ious in all_ious]) + + _ious = np.zeros((proposal_nums.size, total_gt_num), dtype=np.float32) + for k, proposal_num in enumerate(proposal_nums): + tmp_ious = np.zeros(0) + for i in range(img_num): + ious = all_ious[i][:, :proposal_num].copy() + gt_ious = np.zeros((ious.shape[0])) + if ious.size == 0: + tmp_ious = np.hstack((tmp_ious, gt_ious)) + continue + for j in range(ious.shape[0]): + gt_max_overlaps = ious.argmax(axis=1) + max_ious = ious[np.arange(0, ious.shape[0]), gt_max_overlaps] + gt_idx = max_ious.argmax() + gt_ious[j] = max_ious[gt_idx] + box_idx = gt_max_overlaps[gt_idx] + ious[gt_idx, :] = -1 + ious[:, box_idx] = -1 + tmp_ious = np.hstack((tmp_ious, gt_ious)) + _ious[k, :] = tmp_ious + + _ious = np.fliplr(np.sort(_ious, axis=1)) + recalls = np.zeros((proposal_nums.size, thrs.size)) + for i, thr in enumerate(thrs): + recalls[:, i] = (_ious >= thr).sum(axis=1) / float(total_gt_num) + + return recalls + + +def set_recall_param(proposal_nums, iou_thrs): + """Check proposal_nums and iou_thrs and set correct format. + """ + if isinstance(proposal_nums, list): + _proposal_nums = np.array(proposal_nums) + elif isinstance(proposal_nums, int): + _proposal_nums = np.array([proposal_nums]) + else: + _proposal_nums = proposal_nums + + if iou_thrs is None: + _iou_thrs = np.array([0.5]) + elif isinstance(iou_thrs, list): + _iou_thrs = np.array(iou_thrs) + elif isinstance(iou_thrs, float): + _iou_thrs = np.array([iou_thrs]) + else: + _iou_thrs = iou_thrs + + return _proposal_nums, _iou_thrs + + +def eval_recalls(gts, + proposals, + proposal_nums=None, + iou_thrs=None, + print_summary=True): + """Calculate recalls. + + Args: + gts(list or ndarray): a list of arrays of shape (n, 4) + proposals(list or ndarray): a list of arrays of shape (k, 4) or (k, 5) + proposal_nums(int or list of int or ndarray): top N proposals + thrs(float or list or ndarray): iou thresholds + + Returns: + ndarray: recalls of different ious and proposal nums + """ + + img_num = len(gts) + assert img_num == len(proposals) + + proposal_nums, iou_thrs = set_recall_param(proposal_nums, iou_thrs) + + all_ious = [] + for i in range(img_num): + if proposals[i].ndim == 2 and proposals[i].shape[1] == 5: + scores = proposals[i][:, 4] + sort_idx = np.argsort(scores)[::-1] + img_proposal = proposals[i][sort_idx, :] + else: + img_proposal = proposals[i] + prop_num = min(img_proposal.shape[0], proposal_nums[-1]) + if gts[i] is None or gts[i].shape[0] == 0: + ious = np.zeros((0, img_proposal.shape[0]), dtype=np.float32) + else: + ious = bbox_overlaps(gts[i], img_proposal[:prop_num, :4]) + all_ious.append(ious) + all_ious = np.array(all_ious) + recalls = _recalls(all_ious, proposal_nums, iou_thrs) + if print_summary: + print_recall_summary(recalls, proposal_nums, iou_thrs) + return recalls + + +def print_recall_summary(recalls, + proposal_nums, + iou_thrs, + row_idxs=None, + col_idxs=None): + """Print recalls in a table. + + Args: + recalls(ndarray): calculated from `bbox_recalls` + proposal_nums(ndarray or list): top N proposals + iou_thrs(ndarray or list): iou thresholds + row_idxs(ndarray): which rows(proposal nums) to print + col_idxs(ndarray): which cols(iou thresholds) to print + """ + proposal_nums = np.array(proposal_nums, dtype=np.int32) + iou_thrs = np.array(iou_thrs) + if row_idxs is None: + row_idxs = np.arange(proposal_nums.size) + if col_idxs is None: + col_idxs = np.arange(iou_thrs.size) + row_header = [''] + iou_thrs[col_idxs].tolist() + table_data = [row_header] + for i, num in enumerate(proposal_nums[row_idxs]): + row = [ + '{:.3f}'.format(val) + for val in recalls[row_idxs[i], col_idxs].tolist() + ] + row.insert(0, num) + table_data.append(row) + table = AsciiTable(table_data) + print(table.table) + + +def plot_num_recall(recalls, proposal_nums): + """Plot Proposal_num-Recalls curve. + + Args: + recalls(ndarray or list): shape (k,) + proposal_nums(ndarray or list): same shape as `recalls` + """ + if isinstance(proposal_nums, np.ndarray): + _proposal_nums = proposal_nums.tolist() + else: + _proposal_nums = proposal_nums + if isinstance(recalls, np.ndarray): + _recalls = recalls.tolist() + else: + _recalls = recalls + + import matplotlib.pyplot as plt + f = plt.figure() + plt.plot([0] + _proposal_nums, [0] + _recalls) + plt.xlabel('Proposal num') + plt.ylabel('Recall') + plt.axis([0, proposal_nums.max(), 0, 1]) + f.show() + + +def plot_iou_recall(recalls, iou_thrs): + """Plot IoU-Recalls curve. + + Args: + recalls(ndarray or list): shape (k,) + iou_thrs(ndarray or list): same shape as `recalls` + """ + if isinstance(iou_thrs, np.ndarray): + _iou_thrs = iou_thrs.tolist() + else: + _iou_thrs = iou_thrs + if isinstance(recalls, np.ndarray): + _recalls = recalls.tolist() + else: + _recalls = recalls + + import matplotlib.pyplot as plt + f = plt.figure() + plt.plot(_iou_thrs + [1.0], _recalls + [0.]) + plt.xlabel('IoU') + plt.ylabel('Recall') + plt.axis([iou_thrs.min(), 1, 0, 1]) + f.show() diff --git a/mmdet/core/fp16/__init__.py b/mmdet/core/fp16/__init__.py new file mode 100644 index 0000000..cc655b7 --- /dev/null +++ b/mmdet/core/fp16/__init__.py @@ -0,0 +1,4 @@ +from .decorators import auto_fp16, force_fp32 +from .hooks import Fp16OptimizerHook, wrap_fp16_model + +__all__ = ['auto_fp16', 'force_fp32', 'Fp16OptimizerHook', 'wrap_fp16_model'] diff --git a/mmdet/core/fp16/decorators.py b/mmdet/core/fp16/decorators.py new file mode 100644 index 0000000..10ffbf8 --- /dev/null +++ b/mmdet/core/fp16/decorators.py @@ -0,0 +1,160 @@ +import functools +from inspect import getfullargspec + +import torch + +from .utils import cast_tensor_type + + +def auto_fp16(apply_to=None, out_fp32=False): + """Decorator to enable fp16 training automatically. + + This decorator is useful when you write custom modules and want to support + mixed precision training. If inputs arguments are fp32 tensors, they will + be converted to fp16 automatically. Arguments other than fp32 tensors are + ignored. + + Args: + apply_to (Iterable, optional): The argument names to be converted. + `None` indicates all arguments. + out_fp32 (bool): Whether to convert the output back to fp32. + + :Example: + + class MyModule1(nn.Module) + + # Convert x and y to fp16 + @auto_fp16() + def forward(self, x, y): + pass + + class MyModule2(nn.Module): + + # convert pred to fp16 + @auto_fp16(apply_to=('pred', )) + def do_something(self, pred, others): + pass + """ + + def auto_fp16_wrapper(old_func): + + @functools.wraps(old_func) + def new_func(*args, **kwargs): + # check if the module has set the attribute `fp16_enabled`, if not, + # just fallback to the original method. + if not isinstance(args[0], torch.nn.Module): + raise TypeError('@auto_fp16 can only be used to decorate the ' + 'method of nn.Module') + if not (hasattr(args[0], 'fp16_enabled') and args[0].fp16_enabled): + return old_func(*args, **kwargs) + # get the arg spec of the decorated method + args_info = getfullargspec(old_func) + # get the argument names to be casted + args_to_cast = args_info.args if apply_to is None else apply_to + # convert the args that need to be processed + new_args = [] + # NOTE: default args are not taken into consideration + if args: + arg_names = args_info.args[:len(args)] + for i, arg_name in enumerate(arg_names): + if arg_name in args_to_cast: + new_args.append( + cast_tensor_type(args[i], torch.float, torch.half)) + else: + new_args.append(args[i]) + # convert the kwargs that need to be processed + new_kwargs = {} + if kwargs: + for arg_name, arg_value in kwargs.items(): + if arg_name in args_to_cast: + new_kwargs[arg_name] = cast_tensor_type( + arg_value, torch.float, torch.half) + else: + new_kwargs[arg_name] = arg_value + # apply converted arguments to the decorated method + output = old_func(*new_args, **new_kwargs) + # cast the results back to fp32 if necessary + if out_fp32: + output = cast_tensor_type(output, torch.half, torch.float) + return output + + return new_func + + return auto_fp16_wrapper + + +def force_fp32(apply_to=None, out_fp16=False): + """Decorator to convert input arguments to fp32 in force. + + This decorator is useful when you write custom modules and want to support + mixed precision training. If there are some inputs that must be processed + in fp32 mode, then this decorator can handle it. If inputs arguments are + fp16 tensors, they will be converted to fp32 automatically. Arguments other + than fp16 tensors are ignored. + + Args: + apply_to (Iterable, optional): The argument names to be converted. + `None` indicates all arguments. + out_fp16 (bool): Whether to convert the output back to fp16. + + :Example: + + class MyModule1(nn.Module) + + # Convert x and y to fp32 + @force_fp32() + def loss(self, x, y): + pass + + class MyModule2(nn.Module): + + # convert pred to fp32 + @force_fp32(apply_to=('pred', )) + def post_process(self, pred, others): + pass + """ + + def force_fp32_wrapper(old_func): + + @functools.wraps(old_func) + def new_func(*args, **kwargs): + # check if the module has set the attribute `fp16_enabled`, if not, + # just fallback to the original method. + if not isinstance(args[0], torch.nn.Module): + raise TypeError('@force_fp32 can only be used to decorate the ' + 'method of nn.Module') + if not (hasattr(args[0], 'fp16_enabled') and args[0].fp16_enabled): + return old_func(*args, **kwargs) + # get the arg spec of the decorated method + args_info = getfullargspec(old_func) + # get the argument names to be casted + args_to_cast = args_info.args if apply_to is None else apply_to + # convert the args that need to be processed + new_args = [] + if args: + arg_names = args_info.args[:len(args)] + for i, arg_name in enumerate(arg_names): + if arg_name in args_to_cast: + new_args.append( + cast_tensor_type(args[i], torch.half, torch.float)) + else: + new_args.append(args[i]) + # convert the kwargs that need to be processed + new_kwargs = dict() + if kwargs: + for arg_name, arg_value in kwargs.items(): + if arg_name in args_to_cast: + new_kwargs[arg_name] = cast_tensor_type( + arg_value, torch.half, torch.float) + else: + new_kwargs[arg_name] = arg_value + # apply converted arguments to the decorated method + output = old_func(*new_args, **new_kwargs) + # cast the results back to fp32 if necessary + if out_fp16: + output = cast_tensor_type(output, torch.float, torch.half) + return output + + return new_func + + return force_fp32_wrapper diff --git a/mmdet/core/fp16/hooks.py b/mmdet/core/fp16/hooks.py new file mode 100644 index 0000000..6b4dacb --- /dev/null +++ b/mmdet/core/fp16/hooks.py @@ -0,0 +1,127 @@ +import copy + +import torch +import torch.nn as nn +from mmcv.runner import OptimizerHook + +from ..utils.dist_utils import allreduce_grads +from .utils import cast_tensor_type + + +class Fp16OptimizerHook(OptimizerHook): + """FP16 optimizer hook. + + The steps of fp16 optimizer is as follows. + 1. Scale the loss value. + 2. BP in the fp16 model. + 2. Copy gradients from fp16 model to fp32 weights. + 3. Update fp32 weights. + 4. Copy updated parameters from fp32 weights to fp16 model. + + Refer to https://arxiv.org/abs/1710.03740 for more details. + + Args: + loss_scale (float): Scale factor multiplied with loss. + """ + + def __init__(self, + grad_clip=None, + coalesce=True, + bucket_size_mb=-1, + loss_scale=512., + distributed=True): + self.grad_clip = grad_clip + self.coalesce = coalesce + self.bucket_size_mb = bucket_size_mb + self.loss_scale = loss_scale + self.distributed = distributed + + def before_run(self, runner): + # keep a copy of fp32 weights + runner.optimizer.param_groups = copy.deepcopy( + runner.optimizer.param_groups) + # convert model to fp16 + wrap_fp16_model(runner.model) + + def copy_grads_to_fp32(self, fp16_net, fp32_weights): + """Copy gradients from fp16 model to fp32 weight copy.""" + for fp32_param, fp16_param in zip(fp32_weights, fp16_net.parameters()): + if fp16_param.grad is not None: + if fp32_param.grad is None: + fp32_param.grad = fp32_param.data.new(fp32_param.size()) + fp32_param.grad.copy_(fp16_param.grad) + + def copy_params_to_fp16(self, fp16_net, fp32_weights): + """Copy updated params from fp32 weight copy to fp16 model.""" + for fp16_param, fp32_param in zip(fp16_net.parameters(), fp32_weights): + fp16_param.data.copy_(fp32_param.data) + + def after_train_iter(self, runner): + # clear grads of last iteration + runner.model.zero_grad() + runner.optimizer.zero_grad() + # scale the loss value + scaled_loss = runner.outputs['loss'] * self.loss_scale + scaled_loss.backward() + # copy fp16 grads in the model to fp32 params in the optimizer + fp32_weights = [] + for param_group in runner.optimizer.param_groups: + fp32_weights += param_group['params'] + self.copy_grads_to_fp32(runner.model, fp32_weights) + # allreduce grads + if self.distributed: + allreduce_grads(fp32_weights, self.coalesce, self.bucket_size_mb) + # scale the gradients back + for param in fp32_weights: + if param.grad is not None: + param.grad.div_(self.loss_scale) + if self.grad_clip is not None: + self.clip_grads(fp32_weights) + # update fp32 params + runner.optimizer.step() + # copy fp32 params to the fp16 model + self.copy_params_to_fp16(runner.model, fp32_weights) + + +def wrap_fp16_model(model): + # convert model to fp16 + model.half() + # patch the normalization layers to make it work in fp32 mode + patch_norm_fp32(model) + # set `fp16_enabled` flag + for m in model.modules(): + if hasattr(m, 'fp16_enabled'): + m.fp16_enabled = True + + +def patch_norm_fp32(module): + if isinstance(module, (nn.modules.batchnorm._BatchNorm, nn.GroupNorm)): + module.float() + module.forward = patch_forward_method(module.forward, torch.half, + torch.float) + for child in module.children(): + patch_norm_fp32(child) + return module + + +def patch_forward_method(func, src_type, dst_type, convert_output=True): + """Patch the forward method of a module. + + Args: + func (callable): The original forward method. + src_type (torch.dtype): Type of input arguments to be converted from. + dst_type (torch.dtype): Type of input arguments to be converted to. + convert_output (bool): Whether to convert the output back to src_type. + + Returns: + callable: The patched forward method. + """ + + def new_forward(*args, **kwargs): + output = func(*cast_tensor_type(args, src_type, dst_type), + **cast_tensor_type(kwargs, src_type, dst_type)) + if convert_output: + output = cast_tensor_type(output, dst_type, src_type) + return output + + return new_forward diff --git a/mmdet/core/fp16/utils.py b/mmdet/core/fp16/utils.py new file mode 100644 index 0000000..ce691c7 --- /dev/null +++ b/mmdet/core/fp16/utils.py @@ -0,0 +1,23 @@ +from collections import abc + +import numpy as np +import torch + + +def cast_tensor_type(inputs, src_type, dst_type): + if isinstance(inputs, torch.Tensor): + return inputs.to(dst_type) + elif isinstance(inputs, str): + return inputs + elif isinstance(inputs, np.ndarray): + return inputs + elif isinstance(inputs, abc.Mapping): + return type(inputs)({ + k: cast_tensor_type(v, src_type, dst_type) + for k, v in inputs.items() + }) + elif isinstance(inputs, abc.Iterable): + return type(inputs)( + cast_tensor_type(item, src_type, dst_type) for item in inputs) + else: + return inputs diff --git a/mmdet/core/mask/__init__.py b/mmdet/core/mask/__init__.py new file mode 100644 index 0000000..845e718 --- /dev/null +++ b/mmdet/core/mask/__init__.py @@ -0,0 +1,4 @@ +from .mask_target import mask_target +from .utils import split_combined_polys + +__all__ = ['split_combined_polys', 'mask_target'] diff --git a/mmdet/core/mask/mask_target.py b/mmdet/core/mask/mask_target.py new file mode 100644 index 0000000..423f5ef --- /dev/null +++ b/mmdet/core/mask/mask_target.py @@ -0,0 +1,38 @@ +import mmcv +import numpy as np +import torch +from torch.nn.modules.utils import _pair + + +def mask_target(pos_proposals_list, pos_assigned_gt_inds_list, gt_masks_list, + cfg): + cfg_list = [cfg for _ in range(len(pos_proposals_list))] + mask_targets = map(mask_target_single, pos_proposals_list, + pos_assigned_gt_inds_list, gt_masks_list, cfg_list) + mask_targets = torch.cat(list(mask_targets)) + return mask_targets + + +def mask_target_single(pos_proposals, pos_assigned_gt_inds, gt_masks, cfg): + mask_size = _pair(cfg.mask_size) + num_pos = pos_proposals.size(0) + mask_targets = [] + if num_pos > 0: + proposals_np = pos_proposals.cpu().numpy() + pos_assigned_gt_inds = pos_assigned_gt_inds.cpu().numpy() + for i in range(num_pos): + gt_mask = gt_masks[pos_assigned_gt_inds[i]] + bbox = proposals_np[i, :].astype(np.int32) + x1, y1, x2, y2 = bbox + w = np.maximum(x2 - x1 + 1, 1) + h = np.maximum(y2 - y1 + 1, 1) + # mask is uint8 both before and after resizing + # mask_size (h, w) to (w, h) + target = mmcv.imresize(gt_mask[y1:y1 + h, x1:x1 + w], + mask_size[::-1]) + mask_targets.append(target) + mask_targets = torch.from_numpy(np.stack(mask_targets)).float().to( + pos_proposals.device) + else: + mask_targets = pos_proposals.new_zeros((0, ) + mask_size) + return mask_targets diff --git a/mmdet/core/mask/utils.py b/mmdet/core/mask/utils.py new file mode 100644 index 0000000..a68312b --- /dev/null +++ b/mmdet/core/mask/utils.py @@ -0,0 +1,30 @@ +import mmcv + + +def split_combined_polys(polys, poly_lens, polys_per_mask): + """Split the combined 1-D polys into masks. + + A mask is represented as a list of polys, and a poly is represented as + a 1-D array. In dataset, all masks are concatenated into a single 1-D + tensor. Here we need to split the tensor into original representations. + + Args: + polys (list): a list (length = image num) of 1-D tensors + poly_lens (list): a list (length = image num) of poly length + polys_per_mask (list): a list (length = image num) of poly number + of each mask + + Returns: + list: a list (length = image num) of list (length = mask num) of + list (length = poly num) of numpy array + """ + mask_polys_list = [] + for img_id in range(len(polys)): + polys_single = polys[img_id] + polys_lens_single = poly_lens[img_id].tolist() + polys_per_mask_single = polys_per_mask[img_id].tolist() + + split_polys = mmcv.slice_list(polys_single, polys_lens_single) + mask_polys = mmcv.slice_list(split_polys, polys_per_mask_single) + mask_polys_list.append(mask_polys) + return mask_polys_list diff --git a/mmdet/core/post_processing/__init__.py b/mmdet/core/post_processing/__init__.py new file mode 100644 index 0000000..11c3d30 --- /dev/null +++ b/mmdet/core/post_processing/__init__.py @@ -0,0 +1,8 @@ +from .bbox_nms import multiclass_nms +from .merge_augs import (merge_aug_bboxes, merge_aug_masks, + merge_aug_proposals, merge_aug_scores) + +__all__ = [ + 'multiclass_nms', 'merge_aug_proposals', 'merge_aug_bboxes', + 'merge_aug_scores', 'merge_aug_masks' +] diff --git a/mmdet/core/post_processing/bbox_nms.py b/mmdet/core/post_processing/bbox_nms.py new file mode 100644 index 0000000..f93da6b --- /dev/null +++ b/mmdet/core/post_processing/bbox_nms.py @@ -0,0 +1,106 @@ +import torch + +from mmdet.ops.nms import nms_wrapper +from mmdet.core.bbox.geometry import bbox_overlaps + + +def multiclass_nms(multi_bboxes, + multi_scores, + score_thr, + k, + agg_thr, + nms_cfg, + max_num=-1, + score_factors=None): + """NMS for multi-class bboxes. + + Args: + multi_bboxes (Tensor): shape (n, #class*4) or (n, 4) + multi_scores (Tensor): shape (n, #class) + score_thr (float): bbox threshold, bboxes with scores lower than it + will not be considered. + nms_thr (float): NMS IoU threshold + max_num (int): if there are more than max_num bboxes after NMS, + only top max_num will be kept. + score_factors (Tensor): The factors multiplied to scores before + applying NMS + + Returns: + tuple: (bboxes, labels), tensors of shape (k, 5) and (k, 1). Labels + are 0-based. + """ + num_classes = multi_scores.shape[1] + bboxes, labels = [], [] + nms_cfg_ = nms_cfg.copy() + nms_type = nms_cfg_.pop('type', 'nms') + nms_op = getattr(nms_wrapper, nms_type) + for i in range(1, num_classes): + cls_inds = multi_scores[:, i] > score_thr + if not cls_inds.any(): + continue + # get bboxes and scores of this class + if multi_bboxes.shape[1] == 4: + _bboxes = multi_bboxes[cls_inds, :] + else: + _bboxes = multi_bboxes[cls_inds, i * 4:(i + 1) * 4] + _scores = multi_scores[cls_inds, i] + if score_factors is not None: + _scores *= score_factors[cls_inds] + cls_dets = torch.cat([_bboxes, _scores[:, None]], dim=1) + cls_dets = agg_scores(cls_dets, k, agg_thr) + cls_dets, _ = nms_op(cls_dets, **nms_cfg_) + cls_labels = multi_bboxes.new_full((cls_dets.shape[0], ), + i - 1, + dtype=torch.long) + bboxes.append(cls_dets) + labels.append(cls_labels) + if bboxes: + bboxes = torch.cat(bboxes) + labels = torch.cat(labels) + if bboxes.shape[0] > max_num: + _, inds = bboxes[:, -1].sort(descending=True) + inds = inds[:max_num] + bboxes = bboxes[inds] + labels = labels[inds] + else: + bboxes = multi_bboxes.new_zeros((0, 5)) + labels = multi_bboxes.new_zeros((0, ), dtype=torch.long) + + return bboxes, labels + + +def agg_scores(cls_dets, k, agg_thr): + + cls_dets_agg = cls_dets.clone() + iou = calc_iou(cls_dets[:, :4], cls_dets[:, :4]) + + for i,det in enumerate(cls_dets): + + agg_ind = (iou[i] >= agg_thr) + iou_weight = iou[i, agg_ind] - 1 + iou_weight = k ** iou_weight + agg_score = (iou_weight * cls_dets[agg_ind, 4]).sum() + cls_dets_agg[i, 4] = agg_score + + return cls_dets_agg + + +def calc_iou(a, b): + area = (b[:, 2] - b[:, 0]) * (b[:, 3] - b[:, 1]) + + iw = torch.min(torch.unsqueeze(a[:, 2], dim=1), b[:, 2]) - torch.max(torch.unsqueeze(a[:, 0], 1), b[:, 0]) + ih = torch.min(torch.unsqueeze(a[:, 3], dim=1), b[:, 3]) - torch.max(torch.unsqueeze(a[:, 1], 1), b[:, 1]) + + iw = torch.clamp(iw, min=0) + ih = torch.clamp(ih, min=0) + + ua = torch.unsqueeze((a[:, 2] - a[:, 0]) * (a[:, 3] - a[:, 1]), dim=1) + area - iw * ih + + ua = torch.clamp(ua, min=1e-8) + + intersection = iw * ih + + IoU = intersection / ua + + return IoU + diff --git a/mmdet/core/post_processing/merge_augs.py b/mmdet/core/post_processing/merge_augs.py new file mode 100644 index 0000000..fcee4fb --- /dev/null +++ b/mmdet/core/post_processing/merge_augs.py @@ -0,0 +1,95 @@ +import numpy as np +import torch + +from mmdet.ops import nms +from ..bbox import bbox_mapping_back + + +def merge_aug_proposals(aug_proposals, img_metas, rpn_test_cfg): + """Merge augmented proposals (multiscale, flip, etc.) + + Args: + aug_proposals (list[Tensor]): proposals from different testing + schemes, shape (n, 5). Note that they are not rescaled to the + original image size. + img_metas (list[dict]): image info including "shape_scale" and "flip". + rpn_test_cfg (dict): rpn test config. + + Returns: + Tensor: shape (n, 4), proposals corresponding to original image scale. + """ + recovered_proposals = [] + for proposals, img_info in zip(aug_proposals, img_metas): + img_shape = img_info['img_shape'] + scale_factor = img_info['scale_factor'] + flip = img_info['flip'] + _proposals = proposals.clone() + _proposals[:, :4] = bbox_mapping_back(_proposals[:, :4], img_shape, + scale_factor, flip) + recovered_proposals.append(_proposals) + aug_proposals = torch.cat(recovered_proposals, dim=0) + merged_proposals, _ = nms(aug_proposals, rpn_test_cfg.nms_thr) + scores = merged_proposals[:, 4] + _, order = scores.sort(0, descending=True) + num = min(rpn_test_cfg.max_num, merged_proposals.shape[0]) + order = order[:num] + merged_proposals = merged_proposals[order, :] + return merged_proposals + + +def merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg): + """Merge augmented detection bboxes and scores. + + Args: + aug_bboxes (list[Tensor]): shape (n, 4*#class) + aug_scores (list[Tensor] or None): shape (n, #class) + img_shapes (list[Tensor]): shape (3, ). + rcnn_test_cfg (dict): rcnn test config. + + Returns: + tuple: (bboxes, scores) + """ + recovered_bboxes = [] + for bboxes, img_info in zip(aug_bboxes, img_metas): + img_shape = img_info[0]['img_shape'] + scale_factor = img_info[0]['scale_factor'] + flip = img_info[0]['flip'] + bboxes = bbox_mapping_back(bboxes, img_shape, scale_factor, flip) + recovered_bboxes.append(bboxes) + bboxes = torch.stack(recovered_bboxes).mean(dim=0) + if aug_scores is None: + return bboxes + else: + scores = torch.stack(aug_scores).mean(dim=0) + return bboxes, scores + + +def merge_aug_scores(aug_scores): + """Merge augmented bbox scores.""" + if isinstance(aug_scores[0], torch.Tensor): + return torch.mean(torch.stack(aug_scores), dim=0) + else: + return np.mean(aug_scores, axis=0) + + +def merge_aug_masks(aug_masks, img_metas, rcnn_test_cfg, weights=None): + """Merge augmented mask prediction. + + Args: + aug_masks (list[ndarray]): shape (n, #class, h, w) + img_shapes (list[ndarray]): shape (3, ). + rcnn_test_cfg (dict): rcnn test config. + + Returns: + tuple: (bboxes, scores) + """ + recovered_masks = [ + mask if not img_info[0]['flip'] else mask[..., ::-1] + for mask, img_info in zip(aug_masks, img_metas) + ] + if weights is None: + merged_masks = np.mean(recovered_masks, axis=0) + else: + merged_masks = np.average( + np.array(recovered_masks), axis=0, weights=np.array(weights)) + return merged_masks diff --git a/mmdet/core/utils/__init__.py b/mmdet/core/utils/__init__.py new file mode 100644 index 0000000..cc999ea --- /dev/null +++ b/mmdet/core/utils/__init__.py @@ -0,0 +1,7 @@ +from .dist_utils import DistOptimizerHook, allreduce_grads +from .misc import multi_apply, tensor2imgs, unmap + +__all__ = [ + 'allreduce_grads', 'DistOptimizerHook', 'tensor2imgs', 'unmap', + 'multi_apply' +] diff --git a/mmdet/core/utils/dist_utils.py b/mmdet/core/utils/dist_utils.py new file mode 100644 index 0000000..be830b6 --- /dev/null +++ b/mmdet/core/utils/dist_utils.py @@ -0,0 +1,58 @@ +from collections import OrderedDict + +import torch.distributed as dist +from mmcv.runner import OptimizerHook +from torch._utils import (_flatten_dense_tensors, _take_tensors, + _unflatten_dense_tensors) + + +def _allreduce_coalesced(tensors, world_size, bucket_size_mb=-1): + if bucket_size_mb > 0: + bucket_size_bytes = bucket_size_mb * 1024 * 1024 + buckets = _take_tensors(tensors, bucket_size_bytes) + else: + buckets = OrderedDict() + for tensor in tensors: + tp = tensor.type() + if tp not in buckets: + buckets[tp] = [] + buckets[tp].append(tensor) + buckets = buckets.values() + + for bucket in buckets: + flat_tensors = _flatten_dense_tensors(bucket) + dist.all_reduce(flat_tensors) + flat_tensors.div_(world_size) + for tensor, synced in zip( + bucket, _unflatten_dense_tensors(flat_tensors, bucket)): + tensor.copy_(synced) + + +def allreduce_grads(params, coalesce=True, bucket_size_mb=-1): + grads = [ + param.grad.data for param in params + if param.requires_grad and param.grad is not None + ] + world_size = dist.get_world_size() + if coalesce: + _allreduce_coalesced(grads, world_size, bucket_size_mb) + else: + for tensor in grads: + dist.all_reduce(tensor.div_(world_size)) + + +class DistOptimizerHook(OptimizerHook): + + def __init__(self, grad_clip=None, coalesce=True, bucket_size_mb=-1): + self.grad_clip = grad_clip + self.coalesce = coalesce + self.bucket_size_mb = bucket_size_mb + + def after_train_iter(self, runner): + runner.optimizer.zero_grad() + runner.outputs['loss'].backward() + allreduce_grads(runner.model.parameters(), self.coalesce, + self.bucket_size_mb) + if self.grad_clip is not None: + self.clip_grads(runner.model.parameters()) + runner.optimizer.step() diff --git a/mmdet/core/utils/misc.py b/mmdet/core/utils/misc.py new file mode 100644 index 0000000..262f168 --- /dev/null +++ b/mmdet/core/utils/misc.py @@ -0,0 +1,37 @@ +from functools import partial + +import mmcv +import numpy as np +from six.moves import map, zip + + +def tensor2imgs(tensor, mean=(0, 0, 0), std=(1, 1, 1), to_rgb=True): + num_imgs = tensor.size(0) + mean = np.array(mean, dtype=np.float32) + std = np.array(std, dtype=np.float32) + imgs = [] + for img_id in range(num_imgs): + img = tensor[img_id, ...].cpu().numpy().transpose(1, 2, 0) + img = mmcv.imdenormalize( + img, mean, std, to_bgr=to_rgb).astype(np.uint8) + imgs.append(np.ascontiguousarray(img)) + return imgs + + +def multi_apply(func, *args, **kwargs): + pfunc = partial(func, **kwargs) if kwargs else func + map_results = map(pfunc, *args) + return tuple(map(list, zip(*map_results))) + + +def unmap(data, count, inds, fill=0): + """ Unmap a subset of item (data) back to the original set of items (of + size count) """ + if data.dim() == 1: + ret = data.new_full((count, ), fill) + ret[inds] = data + else: + new_size = (count, ) + data.size()[1:] + ret = data.new_full(new_size, fill) + ret[inds, :] = data + return ret diff --git a/mmdet/datasets/__init__.py b/mmdet/datasets/__init__.py new file mode 100644 index 0000000..11b7569 --- /dev/null +++ b/mmdet/datasets/__init__.py @@ -0,0 +1,20 @@ +from .builder import build_dataset +from .cityscapes import CityscapesDataset +from .coco import CocoDataset +from .custom import CustomDataset +from .dataset_wrappers import ConcatDataset, RepeatDataset +from .extra_aug import ExtraAugmentation +from .loader import DistributedGroupSampler, GroupSampler, build_dataloader +from .registry import DATASETS +from .utils import random_scale, show_ann, to_tensor +from .voc import VOCDataset +from .wider_face import WIDERFaceDataset +from .xml_style import XMLDataset + +__all__ = [ + 'CustomDataset', 'XMLDataset', 'CocoDataset', 'VOCDataset', + 'CityscapesDataset', 'GroupSampler', 'DistributedGroupSampler', + 'build_dataloader', 'to_tensor', 'random_scale', 'show_ann', + 'ConcatDataset', 'RepeatDataset', 'ExtraAugmentation', 'WIDERFaceDataset', + 'DATASETS', 'build_dataset' +] diff --git a/mmdet/datasets/builder.py b/mmdet/datasets/builder.py new file mode 100644 index 0000000..1d101ff --- /dev/null +++ b/mmdet/datasets/builder.py @@ -0,0 +1,41 @@ +import copy + +from mmdet.utils import build_from_cfg +from .dataset_wrappers import ConcatDataset, RepeatDataset +from .registry import DATASETS + + +def _concat_dataset(cfg, default_args=None): + ann_files = cfg['ann_file'] + img_prefixes = cfg.get('img_prefix', None) + seg_prefixes = cfg.get('seg_prefixes', None) + proposal_files = cfg.get('proposal_file', None) + + datasets = [] + num_dset = len(ann_files) + for i in range(num_dset): + data_cfg = copy.deepcopy(cfg) + data_cfg['ann_file'] = ann_files[i] + if isinstance(img_prefixes, (list, tuple)): + data_cfg['img_prefix'] = img_prefixes[i] + if isinstance(seg_prefixes, (list, tuple)): + data_cfg['seg_prefix'] = seg_prefixes[i] + if isinstance(proposal_files, (list, tuple)): + data_cfg['proposal_file'] = proposal_files[i] + datasets.append(build_dataset(data_cfg, default_args)) + + return ConcatDataset(datasets) + + +def build_dataset(cfg, default_args=None): + if isinstance(cfg, (list, tuple)): + dataset = ConcatDataset([build_dataset(c, default_args) for c in cfg]) + elif cfg['type'] == 'RepeatDataset': + dataset = RepeatDataset( + build_dataset(cfg['dataset'], default_args), cfg['times']) + elif isinstance(cfg['ann_file'], (list, tuple)): + dataset = _concat_dataset(cfg, default_args) + else: + dataset = build_from_cfg(cfg, DATASETS, default_args) + + return dataset diff --git a/mmdet/datasets/cityscapes.py b/mmdet/datasets/cityscapes.py new file mode 100644 index 0000000..51ca049 --- /dev/null +++ b/mmdet/datasets/cityscapes.py @@ -0,0 +1,9 @@ +from .coco import CocoDataset +from .registry import DATASETS + + +@DATASETS.register_module +class CityscapesDataset(CocoDataset): + + CLASSES = ('person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle', + 'bicycle') diff --git a/mmdet/datasets/coco.py b/mmdet/datasets/coco.py new file mode 100644 index 0000000..46ef709 --- /dev/null +++ b/mmdet/datasets/coco.py @@ -0,0 +1,120 @@ +import numpy as np +from pycocotools.coco import COCO + +from .custom import CustomDataset +from .registry import DATASETS + + +@DATASETS.register_module +class CocoDataset(CustomDataset): + + CLASSES = ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', + 'train', 'truck', 'boat', 'traffic_light', 'fire_hydrant', + 'stop_sign', 'parking_meter', 'bench', 'bird', 'cat', 'dog', + 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', + 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', + 'skis', 'snowboard', 'sports_ball', 'kite', 'baseball_bat', + 'baseball_glove', 'skateboard', 'surfboard', 'tennis_racket', + 'bottle', 'wine_glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', + 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', + 'hot_dog', 'pizza', 'donut', 'cake', 'chair', 'couch', + 'potted_plant', 'bed', 'dining_table', 'toilet', 'tv', 'laptop', + 'mouse', 'remote', 'keyboard', 'cell_phone', 'microwave', + 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', + 'vase', 'scissors', 'teddy_bear', 'hair_drier', 'toothbrush') + + def load_annotations(self, ann_file): + self.coco = COCO(ann_file) + self.cat_ids = self.coco.getCatIds() + self.cat2label = { + cat_id: i + 1 + for i, cat_id in enumerate(self.cat_ids) + } + self.img_ids = self.coco.getImgIds() + img_infos = [] + for i in self.img_ids: + info = self.coco.loadImgs([i])[0] + info['filename'] = info['file_name'] + img_infos.append(info) + return img_infos + + def get_ann_info(self, idx): + img_id = self.img_infos[idx]['id'] + ann_ids = self.coco.getAnnIds(imgIds=[img_id]) + ann_info = self.coco.loadAnns(ann_ids) + return self._parse_ann_info(ann_info, self.with_mask) + + def _filter_imgs(self, min_size=32): + """Filter images too small or without ground truths.""" + valid_inds = [] + ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values()) + for i, img_info in enumerate(self.img_infos): + if self.img_ids[i] not in ids_with_ann: + continue + if min(img_info['width'], img_info['height']) >= min_size: + valid_inds.append(i) + return valid_inds + + def _parse_ann_info(self, ann_info, with_mask=True): + """Parse bbox and mask annotation. + + Args: + ann_info (list[dict]): Annotation info of an image. + with_mask (bool): Whether to parse mask annotations. + + Returns: + dict: A dict containing the following keys: bboxes, bboxes_ignore, + labels, masks, mask_polys, poly_lens. + """ + gt_bboxes = [] + gt_labels = [] + gt_bboxes_ignore = [] + # Two formats are provided. + # 1. mask: a binary map of the same size of the image. + # 2. polys: each mask consists of one or several polys, each poly is a + # list of float. + if with_mask: + gt_masks = [] + gt_mask_polys = [] + gt_poly_lens = [] + for i, ann in enumerate(ann_info): + if ann.get('ignore', False): + continue + x1, y1, w, h = ann['bbox'] + if ann['area'] <= 0 or w < 1 or h < 1: + continue + bbox = [x1, y1, x1 + w - 1, y1 + h - 1] + if ann['iscrowd']: + gt_bboxes_ignore.append(bbox) + else: + gt_bboxes.append(bbox) + gt_labels.append(self.cat2label[ann['category_id']]) + if with_mask: + gt_masks.append(self.coco.annToMask(ann)) + mask_polys = [ + p for p in ann['segmentation'] if len(p) >= 6 + ] # valid polygons have >= 3 points (6 coordinates) + poly_lens = [len(p) for p in mask_polys] + gt_mask_polys.append(mask_polys) + gt_poly_lens.extend(poly_lens) + if gt_bboxes: + gt_bboxes = np.array(gt_bboxes, dtype=np.float32) + gt_labels = np.array(gt_labels, dtype=np.int64) + else: + gt_bboxes = np.zeros((0, 4), dtype=np.float32) + gt_labels = np.array([], dtype=np.int64) + + if gt_bboxes_ignore: + gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32) + else: + gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32) + + ann = dict( + bboxes=gt_bboxes, labels=gt_labels, bboxes_ignore=gt_bboxes_ignore) + + if with_mask: + ann['masks'] = gt_masks + # poly format is not used in the current implementation + ann['mask_polys'] = gt_mask_polys + ann['poly_lens'] = gt_poly_lens + return ann diff --git a/mmdet/datasets/custom.py b/mmdet/datasets/custom.py new file mode 100644 index 0000000..6c762d7 --- /dev/null +++ b/mmdet/datasets/custom.py @@ -0,0 +1,349 @@ +import os.path as osp +import warnings + +import mmcv +import numpy as np +# from imagecorruptions import corrupt +from mmcv.parallel import DataContainer as DC +from torch.utils.data import Dataset + +from .extra_aug import ExtraAugmentation +from .registry import DATASETS +from .transforms import (BboxTransform, ImageTransform, MaskTransform, + Numpy2Tensor, SegMapTransform) +from .utils import random_scale, to_tensor + + +@DATASETS.register_module +class CustomDataset(Dataset): + """Custom dataset for detection. + + Annotation format: + [ + { + 'filename': 'a.jpg', + 'width': 1280, + 'height': 720, + 'ann': { + 'bboxes': (n, 4), + 'labels': (n, ), + 'bboxes_ignore': (k, 4), + 'labels_ignore': (k, 4) (optional field) + } + }, + ... + ] + + The `ann` field is optional for testing. + """ + + CLASSES = None + + def __init__(self, + ann_file, + img_prefix, + img_scale, + img_norm_cfg, + multiscale_mode='value', + size_divisor=None, + proposal_file=None, + num_max_proposals=1000, + flip_ratio=0, + with_mask=True, + with_crowd=True, + with_label=True, + with_semantic_seg=False, + seg_prefix=None, + seg_scale_factor=1, + extra_aug=None, + resize_keep_ratio=True, + corruption=None, + corruption_severity=1, + skip_img_without_anno=True, + test_mode=False): + # prefix of images path + self.img_prefix = img_prefix + + # load annotations (and proposals) + self.img_infos = self.load_annotations(ann_file) + if proposal_file is not None: + self.proposals = self.load_proposals(proposal_file) + else: + self.proposals = None + # filter images with no annotation during training + if not test_mode: + valid_inds = self._filter_imgs() + self.img_infos = [self.img_infos[i] for i in valid_inds] + if self.proposals is not None: + self.proposals = [self.proposals[i] for i in valid_inds] + + # (long_edge, short_edge) or [(long1, short1), (long2, short2), ...] + self.img_scales = img_scale if isinstance(img_scale, + list) else [img_scale] + assert mmcv.is_list_of(self.img_scales, tuple) + # normalization configs + self.img_norm_cfg = img_norm_cfg + + # multi-scale mode (only applicable for multi-scale training) + self.multiscale_mode = multiscale_mode + assert multiscale_mode in ['value', 'range'] + + # max proposals per image + self.num_max_proposals = num_max_proposals + # flip ratio + self.flip_ratio = flip_ratio + assert flip_ratio >= 0 and flip_ratio <= 1 + # padding border to ensure the image size can be divided by + # size_divisor (used for FPN) + self.size_divisor = size_divisor + + # with mask or not (reserved field, takes no effect) + self.with_mask = with_mask + # some datasets provide bbox annotations as ignore/crowd/difficult, + # if `with_crowd` is True, then these info is returned. + self.with_crowd = with_crowd + # with label is False for RPN + self.with_label = with_label + # with semantic segmentation (stuff) annotation or not + self.with_seg = with_semantic_seg + # prefix of semantic segmentation map path + self.seg_prefix = seg_prefix + # rescale factor for segmentation maps + self.seg_scale_factor = seg_scale_factor + # in test mode or not + self.test_mode = test_mode + + # set group flag for the sampler + if not self.test_mode: + self._set_group_flag() + # transforms + self.img_transform = ImageTransform( + size_divisor=self.size_divisor, **self.img_norm_cfg) + self.bbox_transform = BboxTransform() + self.mask_transform = MaskTransform() + self.seg_transform = SegMapTransform(self.size_divisor) + self.numpy2tensor = Numpy2Tensor() + + # if use extra augmentation + if extra_aug is not None: + self.extra_aug = ExtraAugmentation(**extra_aug) + else: + self.extra_aug = None + + # image rescale if keep ratio + self.resize_keep_ratio = resize_keep_ratio + self.skip_img_without_anno = skip_img_without_anno + + # corruptions + self.corruption = corruption + self.corruption_severity = corruption_severity + + def __len__(self): + return len(self.img_infos) + + def load_annotations(self, ann_file): + return mmcv.load(ann_file) + + def load_proposals(self, proposal_file): + return mmcv.load(proposal_file) + + def get_ann_info(self, idx): + return self.img_infos[idx]['ann'] + + def _filter_imgs(self, min_size=32): + """Filter images too small.""" + valid_inds = [] + for i, img_info in enumerate(self.img_infos): + if min(img_info['width'], img_info['height']) >= min_size: + valid_inds.append(i) + return valid_inds + + def _set_group_flag(self): + """Set flag according to image aspect ratio. + + Images with aspect ratio greater than 1 will be set as group 1, + otherwise group 0. + """ + self.flag = np.zeros(len(self), dtype=np.uint8) + for i in range(len(self)): + img_info = self.img_infos[i] + if img_info['width'] / img_info['height'] > 1: + self.flag[i] = 1 + + def _rand_another(self, idx): + pool = np.where(self.flag == self.flag[idx])[0] + return np.random.choice(pool) + + def __getitem__(self, idx): + if self.test_mode: + return self.prepare_test_img(idx) + while True: + data = self.prepare_train_img(idx) + if data is None: + idx = self._rand_another(idx) + continue + return data + + def prepare_train_img(self, idx): + img_info = self.img_infos[idx] + # load image + img = mmcv.imread(osp.join(self.img_prefix, img_info['filename'])) + # corruption + # if self.corruption is not None: + # img = corrupt( + # img, + # severity=self.corruption_severity, + # corruption_name=self.corruption) + # load proposals if necessary + if self.proposals is not None: + proposals = self.proposals[idx][:self.num_max_proposals] + # TODO: Handle empty proposals properly. Currently images with + # no proposals are just ignored, but they can be used for + # training in concept. + if len(proposals) == 0: + return None + if not (proposals.shape[1] == 4 or proposals.shape[1] == 5): + raise AssertionError( + 'proposals should have shapes (n, 4) or (n, 5), ' + 'but found {}'.format(proposals.shape)) + if proposals.shape[1] == 5: + scores = proposals[:, 4, None] + proposals = proposals[:, :4] + else: + scores = None + + ann = self.get_ann_info(idx) + gt_bboxes = ann['bboxes'] + gt_labels = ann['labels'] + if self.with_crowd: + gt_bboxes_ignore = ann['bboxes_ignore'] + + # skip the image if there is no valid gt bbox + if len(gt_bboxes) == 0 and self.skip_img_without_anno: + warnings.warn('Skip the image "%s" that has no valid gt bbox' % + osp.join(self.img_prefix, img_info['filename'])) + return None + + # extra augmentation + if self.extra_aug is not None: + img, gt_bboxes, gt_labels = self.extra_aug(img, gt_bboxes, + gt_labels) + + # apply transforms + flip = True if np.random.rand() < self.flip_ratio else False + # randomly sample a scale + img_scale = random_scale(self.img_scales, self.multiscale_mode) + img, img_shape, pad_shape, scale_factor = self.img_transform( + img, img_scale, flip, keep_ratio=self.resize_keep_ratio) + img = img.copy() + if self.with_seg: + gt_seg = mmcv.imread( + osp.join(self.seg_prefix, + img_info['filename'].replace('jpg', 'png')), + flag='unchanged') + gt_seg = self.seg_transform(gt_seg.squeeze(), img_scale, flip) + gt_seg = mmcv.imrescale( + gt_seg, self.seg_scale_factor, interpolation='nearest') + gt_seg = gt_seg[None, ...] + if self.proposals is not None: + proposals = self.bbox_transform(proposals, img_shape, scale_factor, + flip) + proposals = np.hstack([proposals, scores + ]) if scores is not None else proposals + gt_bboxes = self.bbox_transform(gt_bboxes, img_shape, scale_factor, + flip) + if self.with_crowd: + gt_bboxes_ignore = self.bbox_transform(gt_bboxes_ignore, img_shape, + scale_factor, flip) + if self.with_mask: + gt_masks = self.mask_transform(ann['masks'], pad_shape, + scale_factor, flip) + + ori_shape = (img_info['height'], img_info['width'], 3) + img_meta = dict( + ori_shape=ori_shape, + img_shape=img_shape, + pad_shape=pad_shape, + scale_factor=scale_factor, + flip=flip) + + data = dict( + img=DC(to_tensor(img), stack=True), + img_meta=DC(img_meta, cpu_only=True), + gt_bboxes=DC(to_tensor(gt_bboxes))) + if self.proposals is not None: + data['proposals'] = DC(to_tensor(proposals)) + if self.with_label: + data['gt_labels'] = DC(to_tensor(gt_labels)) + if self.with_crowd: + data['gt_bboxes_ignore'] = DC(to_tensor(gt_bboxes_ignore)) + if self.with_mask: + data['gt_masks'] = DC(gt_masks, cpu_only=True) + if self.with_seg: + data['gt_semantic_seg'] = DC(to_tensor(gt_seg), stack=True) + return data + + def prepare_test_img(self, idx): + """Prepare an image for testing (multi-scale and flipping)""" + img_info = self.img_infos[idx] + img = mmcv.imread(osp.join(self.img_prefix, img_info['filename'])) + # corruption + if self.corruption is not None: + img = corrupt( + img, + severity=self.corruption_severity, + corruption_name=self.corruption) + # load proposals if necessary + if self.proposals is not None: + proposal = self.proposals[idx][:self.num_max_proposals] + if not (proposal.shape[1] == 4 or proposal.shape[1] == 5): + raise AssertionError( + 'proposals should have shapes (n, 4) or (n, 5), ' + 'but found {}'.format(proposal.shape)) + else: + proposal = None + + def prepare_single(img, scale, flip, proposal=None): + _img, img_shape, pad_shape, scale_factor = self.img_transform( + img, scale, flip, keep_ratio=self.resize_keep_ratio) + _img = to_tensor(_img) + _img_meta = dict( + ori_shape=(img_info['height'], img_info['width'], 3), + img_shape=img_shape, + pad_shape=pad_shape, + scale_factor=scale_factor, + flip=flip) + if proposal is not None: + if proposal.shape[1] == 5: + score = proposal[:, 4, None] + proposal = proposal[:, :4] + else: + score = None + _proposal = self.bbox_transform(proposal, img_shape, + scale_factor, flip) + _proposal = np.hstack([_proposal, score + ]) if score is not None else _proposal + _proposal = to_tensor(_proposal) + else: + _proposal = None + return _img, _img_meta, _proposal + + imgs = [] + img_metas = [] + proposals = [] + for scale in self.img_scales: + _img, _img_meta, _proposal = prepare_single( + img, scale, False, proposal) + imgs.append(_img) + img_metas.append(DC(_img_meta, cpu_only=True)) + proposals.append(_proposal) + if self.flip_ratio > 0: + _img, _img_meta, _proposal = prepare_single( + img, scale, True, proposal) + imgs.append(_img) + img_metas.append(DC(_img_meta, cpu_only=True)) + proposals.append(_proposal) + data = dict(img=imgs, img_meta=img_metas) + if self.proposals is not None: + data['proposals'] = proposals + return data \ No newline at end of file diff --git a/mmdet/datasets/dataset_wrappers.py b/mmdet/datasets/dataset_wrappers.py new file mode 100644 index 0000000..e749cb0 --- /dev/null +++ b/mmdet/datasets/dataset_wrappers.py @@ -0,0 +1,55 @@ +import numpy as np +from torch.utils.data.dataset import ConcatDataset as _ConcatDataset + +from .registry import DATASETS + + +@DATASETS.register_module +class ConcatDataset(_ConcatDataset): + """A wrapper of concatenated dataset. + + Same as :obj:`torch.utils.data.dataset.ConcatDataset`, but + concat the group flag for image aspect ratio. + + Args: + datasets (list[:obj:`Dataset`]): A list of datasets. + """ + + def __init__(self, datasets): + super(ConcatDataset, self).__init__(datasets) + self.CLASSES = datasets[0].CLASSES + if hasattr(datasets[0], 'flag'): + flags = [] + for i in range(0, len(datasets)): + flags.append(datasets[i].flag) + self.flag = np.concatenate(flags) + + +@DATASETS.register_module +class RepeatDataset(object): + """A wrapper of repeated dataset. + + The length of repeated dataset will be `times` larger than the original + dataset. This is useful when the data loading time is long but the dataset + is small. Using RepeatDataset can reduce the data loading time between + epochs. + + Args: + dataset (:obj:`Dataset`): The dataset to be repeated. + times (int): Repeat times. + """ + + def __init__(self, dataset, times): + self.dataset = dataset + self.times = times + self.CLASSES = dataset.CLASSES + if hasattr(self.dataset, 'flag'): + self.flag = np.tile(self.dataset.flag, times) + + self._ori_len = len(self.dataset) + + def __getitem__(self, idx): + return self.dataset[idx % self._ori_len] + + def __len__(self): + return self.times * self._ori_len diff --git a/mmdet/datasets/extra_aug.py b/mmdet/datasets/extra_aug.py new file mode 100644 index 0000000..c1bda3e --- /dev/null +++ b/mmdet/datasets/extra_aug.py @@ -0,0 +1,163 @@ +import mmcv +import numpy as np +from numpy import random + +from mmdet.core.evaluation.bbox_overlaps import bbox_overlaps + + +class PhotoMetricDistortion(object): + + def __init__(self, + brightness_delta=32, + contrast_range=(0.5, 1.5), + saturation_range=(0.5, 1.5), + hue_delta=18): + self.brightness_delta = brightness_delta + self.contrast_lower, self.contrast_upper = contrast_range + self.saturation_lower, self.saturation_upper = saturation_range + self.hue_delta = hue_delta + + def __call__(self, img, boxes, labels): + # random brightness + if random.randint(2): + delta = random.uniform(-self.brightness_delta, + self.brightness_delta) + img += delta + + # mode == 0 --> do random contrast first + # mode == 1 --> do random contrast last + mode = random.randint(2) + if mode == 1: + if random.randint(2): + alpha = random.uniform(self.contrast_lower, + self.contrast_upper) + img *= alpha + + # convert color from BGR to HSV + img = mmcv.bgr2hsv(img) + + # random saturation + if random.randint(2): + img[..., 1] *= random.uniform(self.saturation_lower, + self.saturation_upper) + + # random hue + if random.randint(2): + img[..., 0] += random.uniform(-self.hue_delta, self.hue_delta) + img[..., 0][img[..., 0] > 360] -= 360 + img[..., 0][img[..., 0] < 0] += 360 + + # convert color from HSV to BGR + img = mmcv.hsv2bgr(img) + + # random contrast + if mode == 0: + if random.randint(2): + alpha = random.uniform(self.contrast_lower, + self.contrast_upper) + img *= alpha + + # randomly swap channels + if random.randint(2): + img = img[..., random.permutation(3)] + + return img, boxes, labels + + +class Expand(object): + + def __init__(self, mean=(0, 0, 0), to_rgb=True, ratio_range=(1, 4)): + if to_rgb: + self.mean = mean[::-1] + else: + self.mean = mean + self.min_ratio, self.max_ratio = ratio_range + + def __call__(self, img, boxes, labels): + if random.randint(2): + return img, boxes, labels + + h, w, c = img.shape + ratio = random.uniform(self.min_ratio, self.max_ratio) + expand_img = np.full((int(h * ratio), int(w * ratio), c), + self.mean).astype(img.dtype) + left = int(random.uniform(0, w * ratio - w)) + top = int(random.uniform(0, h * ratio - h)) + expand_img[top:top + h, left:left + w] = img + img = expand_img + boxes += np.tile((left, top), 2) + return img, boxes, labels + + +class RandomCrop(object): + + def __init__(self, min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), min_crop_size=0.3): + # 1: return ori img + self.sample_mode = (1, *min_ious, 0) + self.min_crop_size = min_crop_size + + def __call__(self, img, boxes, labels): + h, w, c = img.shape + while True: + mode = random.choice(self.sample_mode) + if mode == 1: + return img, boxes, labels + + min_iou = mode + for i in range(50): + new_w = random.uniform(self.min_crop_size * w, w) + new_h = random.uniform(self.min_crop_size * h, h) + + # h / w in [0.5, 2] + if new_h / new_w < 0.5 or new_h / new_w > 2: + continue + + left = random.uniform(w - new_w) + top = random.uniform(h - new_h) + + patch = np.array( + (int(left), int(top), int(left + new_w), int(top + new_h))) + overlaps = bbox_overlaps( + patch.reshape(-1, 4), boxes.reshape(-1, 4)).reshape(-1) + if overlaps.min() < min_iou: + continue + + # center of boxes should inside the crop img + center = (boxes[:, :2] + boxes[:, 2:]) / 2 + mask = (center[:, 0] > patch[0]) * ( + center[:, 1] > patch[1]) * (center[:, 0] < patch[2]) * ( + center[:, 1] < patch[3]) + if not mask.any(): + continue + boxes = boxes[mask] + labels = labels[mask] + + # adjust boxes + img = img[patch[1]:patch[3], patch[0]:patch[2]] + boxes[:, 2:] = boxes[:, 2:].clip(max=patch[2:]) + boxes[:, :2] = boxes[:, :2].clip(min=patch[:2]) + boxes -= np.tile(patch[:2], 2) + + return img, boxes, labels + + +class ExtraAugmentation(object): + + def __init__(self, + photo_metric_distortion=None, + expand=None, + random_crop=None): + self.transforms = [] + if photo_metric_distortion is not None: + self.transforms.append( + PhotoMetricDistortion(**photo_metric_distortion)) + if expand is not None: + self.transforms.append(Expand(**expand)) + if random_crop is not None: + self.transforms.append(RandomCrop(**random_crop)) + + def __call__(self, img, boxes, labels): + img = img.astype(np.float32) + for transform in self.transforms: + img, boxes, labels = transform(img, boxes, labels) + return img, boxes, labels diff --git a/mmdet/datasets/loader/__init__.py b/mmdet/datasets/loader/__init__.py new file mode 100644 index 0000000..4404615 --- /dev/null +++ b/mmdet/datasets/loader/__init__.py @@ -0,0 +1,4 @@ +from .build_loader import build_dataloader +from .sampler import DistributedGroupSampler, GroupSampler + +__all__ = ['GroupSampler', 'DistributedGroupSampler', 'build_dataloader'] diff --git a/mmdet/datasets/loader/build_loader.py b/mmdet/datasets/loader/build_loader.py new file mode 100644 index 0000000..d3746e1 --- /dev/null +++ b/mmdet/datasets/loader/build_loader.py @@ -0,0 +1,48 @@ +import platform +from functools import partial + +from mmcv.parallel import collate +from mmcv.runner import get_dist_info +from torch.utils.data import DataLoader + +from .sampler import DistributedGroupSampler, DistributedSampler, GroupSampler + +if platform.system() != 'Windows': + # https://github.com/pytorch/pytorch/issues/973 + import resource + rlimit = resource.getrlimit(resource.RLIMIT_NOFILE) + resource.setrlimit(resource.RLIMIT_NOFILE, (4096, rlimit[1])) + + +def build_dataloader(dataset, + imgs_per_gpu, + workers_per_gpu, + num_gpus=1, + dist=True, + **kwargs): + shuffle = kwargs.get('shuffle', True) + if dist: + rank, world_size = get_dist_info() + if shuffle: + sampler = DistributedGroupSampler(dataset, imgs_per_gpu, + world_size, rank) + else: + sampler = DistributedSampler( + dataset, world_size, rank, shuffle=False) + batch_size = imgs_per_gpu + num_workers = workers_per_gpu + else: + sampler = GroupSampler(dataset, imgs_per_gpu) if shuffle else None + batch_size = num_gpus * imgs_per_gpu + num_workers = num_gpus * workers_per_gpu + + data_loader = DataLoader( + dataset, + batch_size=batch_size, + sampler=sampler, + num_workers=num_workers, + collate_fn=partial(collate, samples_per_gpu=imgs_per_gpu), + pin_memory=False, + **kwargs) + + return data_loader diff --git a/mmdet/datasets/loader/sampler.py b/mmdet/datasets/loader/sampler.py new file mode 100644 index 0000000..6c52900 --- /dev/null +++ b/mmdet/datasets/loader/sampler.py @@ -0,0 +1,159 @@ +from __future__ import division +import math + +import numpy as np +import torch +from mmcv.runner.utils import get_dist_info +from torch.utils.data import DistributedSampler as _DistributedSampler +from torch.utils.data import Sampler + + +class DistributedSampler(_DistributedSampler): + + def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True): + super().__init__(dataset, num_replicas=num_replicas, rank=rank) + self.shuffle = shuffle + + def __iter__(self): + # deterministically shuffle based on epoch + if self.shuffle: + g = torch.Generator() + g.manual_seed(self.epoch) + indices = torch.randperm(len(self.dataset), generator=g).tolist() + else: + indices = torch.arange(len(self.dataset)).tolist() + + # add extra samples to make it evenly divisible + indices += indices[:(self.total_size - len(indices))] + assert len(indices) == self.total_size + + # subsample + indices = indices[self.rank:self.total_size:self.num_replicas] + assert len(indices) == self.num_samples + + return iter(indices) + + +class GroupSampler(Sampler): + + def __init__(self, dataset, samples_per_gpu=1): + assert hasattr(dataset, 'flag') + self.dataset = dataset + self.samples_per_gpu = samples_per_gpu + self.flag = dataset.flag.astype(np.int64) + self.group_sizes = np.bincount(self.flag) + self.num_samples = 0 + for i, size in enumerate(self.group_sizes): + self.num_samples += int(np.ceil( + size / self.samples_per_gpu)) * self.samples_per_gpu + + def __iter__(self): + indices = [] + for i, size in enumerate(self.group_sizes): + if size == 0: + continue + indice = np.where(self.flag == i)[0] + assert len(indice) == size + np.random.shuffle(indice) + num_extra = int(np.ceil(size / self.samples_per_gpu) + ) * self.samples_per_gpu - len(indice) + indice = np.concatenate([indice, indice[:num_extra]]) + indices.append(indice) + indices = np.concatenate(indices) + indices = [ + indices[i * self.samples_per_gpu:(i + 1) * self.samples_per_gpu] + for i in np.random.permutation( + range(len(indices) // self.samples_per_gpu)) + ] + indices = np.concatenate(indices) + indices = indices.astype(np.int64).tolist() + assert len(indices) == self.num_samples + return iter(indices) + + def __len__(self): + return self.num_samples + + +class DistributedGroupSampler(Sampler): + """Sampler that restricts data loading to a subset of the dataset. + It is especially useful in conjunction with + :class:`torch.nn.parallel.DistributedDataParallel`. In such case, each + process can pass a DistributedSampler instance as a DataLoader sampler, + and load a subset of the original dataset that is exclusive to it. + .. note:: + Dataset is assumed to be of constant size. + Arguments: + dataset: Dataset used for sampling. + num_replicas (optional): Number of processes participating in + distributed training. + rank (optional): Rank of the current process within num_replicas. + """ + + def __init__(self, + dataset, + samples_per_gpu=1, + num_replicas=None, + rank=None): + _rank, _num_replicas = get_dist_info() + if num_replicas is None: + num_replicas = _num_replicas + if rank is None: + rank = _rank + self.dataset = dataset + self.samples_per_gpu = samples_per_gpu + self.num_replicas = num_replicas + self.rank = rank + self.epoch = 0 + + assert hasattr(self.dataset, 'flag') + self.flag = self.dataset.flag + self.group_sizes = np.bincount(self.flag) + + self.num_samples = 0 + for i, j in enumerate(self.group_sizes): + self.num_samples += int( + math.ceil(self.group_sizes[i] * 1.0 / self.samples_per_gpu / + self.num_replicas)) * self.samples_per_gpu + self.total_size = self.num_samples * self.num_replicas + + def __iter__(self): + # deterministically shuffle based on epoch + g = torch.Generator() + g.manual_seed(self.epoch) + + indices = [] + for i, size in enumerate(self.group_sizes): + if size > 0: + indice = np.where(self.flag == i)[0] + assert len(indice) == size + indice = indice[list(torch.randperm(int(size), + generator=g))].tolist() + extra = int( + math.ceil( + size * 1.0 / self.samples_per_gpu / self.num_replicas) + ) * self.samples_per_gpu * self.num_replicas - len(indice) + indice += indice[:extra] + indices += indice + + assert len(indices) == self.total_size + + indices = [ + indices[j] for i in list( + torch.randperm( + len(indices) // self.samples_per_gpu, generator=g)) + for j in range(i * self.samples_per_gpu, (i + 1) * + self.samples_per_gpu) + ] + + # subsample + offset = self.num_samples * self.rank + indices = indices[offset:offset + self.num_samples] + assert len(indices) == self.num_samples + + return iter(indices) + + def __len__(self): + return self.num_samples + + def set_epoch(self, epoch): + self.epoch = epoch diff --git a/mmdet/datasets/registry.py b/mmdet/datasets/registry.py new file mode 100644 index 0000000..e726624 --- /dev/null +++ b/mmdet/datasets/registry.py @@ -0,0 +1,3 @@ +from mmdet.utils import Registry + +DATASETS = Registry('dataset') diff --git a/mmdet/datasets/transforms.py b/mmdet/datasets/transforms.py new file mode 100644 index 0000000..1e13d77 --- /dev/null +++ b/mmdet/datasets/transforms.py @@ -0,0 +1,166 @@ +import mmcv +import numpy as np +import torch + +__all__ = [ + 'ImageTransform', 'BboxTransform', 'MaskTransform', 'SegMapTransform', + 'Numpy2Tensor' +] + + +class ImageTransform(object): + """Preprocess an image. + + 1. rescale the image to expected size + 2. normalize the image + 3. flip the image (if needed) + 4. pad the image (if needed) + 5. transpose to (c, h, w) + """ + + def __init__(self, + mean=(0, 0, 0), + std=(1, 1, 1), + to_rgb=True, + size_divisor=None): + self.mean = np.array(mean, dtype=np.float32) + self.std = np.array(std, dtype=np.float32) + self.to_rgb = to_rgb + self.size_divisor = size_divisor + + def __call__(self, img, scale, flip=False, keep_ratio=True): + if keep_ratio: + img, scale_factor = mmcv.imrescale(img, scale, return_scale=True) + else: + img, w_scale, h_scale = mmcv.imresize( + img, scale, return_scale=True) + scale_factor = np.array([w_scale, h_scale, w_scale, h_scale], + dtype=np.float32) + img_shape = img.shape + img = mmcv.imnormalize(img, self.mean, self.std, self.to_rgb) + if flip: + img = mmcv.imflip(img) + if self.size_divisor is not None: + img = mmcv.impad_to_multiple(img, self.size_divisor) + pad_shape = img.shape + else: + pad_shape = img_shape + img = img.transpose(2, 0, 1) + return img, img_shape, pad_shape, scale_factor + + +def bbox_flip(bboxes, img_shape, direction='horizontal'): + """Flip bboxes horizontally or vertically. + + Args: + bboxes(ndarray): shape (..., 4*k) + img_shape(tuple): (height, width) + """ + assert bboxes.shape[-1] % 4 == 0 + flipped = bboxes.copy() + if direction == 'horizontal': + w = img_shape[1] + flipped[..., 0::4] = w - bboxes[..., 2::4] - 1 + flipped[..., 2::4] = w - bboxes[..., 0::4] - 1 + else: + h = img_shape[0] + flipped[..., 1::4] = h - bboxes[..., 3::4] - 1 + flipped[..., 3::4] = h - bboxes[..., 1::4] - 1 + return flipped + + +class BboxTransform(object): + """Preprocess gt bboxes. + + 1. rescale bboxes according to image size + 2. flip bboxes (if needed) + 3. pad the first dimension to `max_num_gts` + """ + + def __init__(self, max_num_gts=None): + self.max_num_gts = max_num_gts + + def __call__(self, bboxes, img_shape, scale_factor, flip=False): + gt_bboxes = bboxes * scale_factor + if flip: + gt_bboxes = bbox_flip(gt_bboxes, img_shape) + gt_bboxes[:, 0::2] = np.clip(gt_bboxes[:, 0::2], 0, img_shape[1] - 1) + gt_bboxes[:, 1::2] = np.clip(gt_bboxes[:, 1::2], 0, img_shape[0] - 1) + if self.max_num_gts is None: + return gt_bboxes + else: + num_gts = gt_bboxes.shape[0] + padded_bboxes = np.zeros((self.max_num_gts, 4), dtype=np.float32) + padded_bboxes[:num_gts, :] = gt_bboxes + return padded_bboxes + + +class MaskTransform(object): + """Preprocess masks. + + 1. resize masks to expected size and stack to a single array + 2. flip the masks (if needed) + 3. pad the masks (if needed) + """ + + def __call__(self, masks, pad_shape, scale_factor, flip=False): + # aspect ratio unchanged + if isinstance(scale_factor, float): + masks = [ + mmcv.imrescale(mask, scale_factor, interpolation='nearest') + for mask in masks + ] + # aspect ratio changed + else: + w_ratio, h_ratio = scale_factor[:2] + if masks: + h, w = masks[0].shape[:2] + new_h = int(np.round(h * h_ratio)) + new_w = int(np.round(w * w_ratio)) + new_size = (new_w, new_h) + masks = [ + mmcv.imresize(mask, new_size, interpolation='nearest') + for mask in masks + ] + if flip: + masks = [mask[:, ::-1] for mask in masks] + padded_masks = [ + mmcv.impad(mask, pad_shape[:2], pad_val=0) for mask in masks + ] + padded_masks = np.stack(padded_masks, axis=0) + return padded_masks + + +class SegMapTransform(object): + """Preprocess semantic segmentation maps. + + 1. rescale the segmentation map to expected size + 3. flip the image (if needed) + 4. pad the image (if needed) + """ + + def __init__(self, size_divisor=None): + self.size_divisor = size_divisor + + def __call__(self, img, scale, flip=False, keep_ratio=True): + if keep_ratio: + img = mmcv.imrescale(img, scale, interpolation='nearest') + else: + img = mmcv.imresize(img, scale, interpolation='nearest') + if flip: + img = mmcv.imflip(img) + if self.size_divisor is not None: + img = mmcv.impad_to_multiple(img, self.size_divisor) + return img + + +class Numpy2Tensor(object): + + def __init__(self): + pass + + def __call__(self, *args): + if len(args) == 1: + return torch.from_numpy(args[0]) + else: + return tuple([torch.from_numpy(np.array(array)) for array in args]) diff --git a/mmdet/datasets/utils.py b/mmdet/datasets/utils.py new file mode 100644 index 0000000..9f4f46c --- /dev/null +++ b/mmdet/datasets/utils.py @@ -0,0 +1,68 @@ +from collections import Sequence + +import matplotlib.pyplot as plt +import mmcv +import numpy as np +import torch + + +def to_tensor(data): + """Convert objects of various python types to :obj:`torch.Tensor`. + + Supported types are: :class:`numpy.ndarray`, :class:`torch.Tensor`, + :class:`Sequence`, :class:`int` and :class:`float`. + """ + if isinstance(data, torch.Tensor): + return data + elif isinstance(data, np.ndarray): + return torch.from_numpy(data) + elif isinstance(data, Sequence) and not mmcv.is_str(data): + return torch.tensor(data) + elif isinstance(data, int): + return torch.LongTensor([data]) + elif isinstance(data, float): + return torch.FloatTensor([data]) + else: + raise TypeError('type {} cannot be converted to tensor.'.format( + type(data))) + + +def random_scale(img_scales, mode='range'): + """Randomly select a scale from a list of scales or scale ranges. + + Args: + img_scales (list[tuple]): Image scale or scale range. + mode (str): "range" or "value". + + Returns: + tuple: Sampled image scale. + """ + num_scales = len(img_scales) + if num_scales == 1: # fixed scale is specified + img_scale = img_scales[0] + elif num_scales == 2: # randomly sample a scale + if mode == 'range': + img_scale_long = [max(s) for s in img_scales] + img_scale_short = [min(s) for s in img_scales] + long_edge = np.random.randint( + min(img_scale_long), + max(img_scale_long) + 1) + short_edge = np.random.randint( + min(img_scale_short), + max(img_scale_short) + 1) + img_scale = (long_edge, short_edge) + elif mode == 'value': + img_scale = img_scales[np.random.randint(num_scales)] + else: + if mode != 'value': + raise ValueError( + 'Only "value" mode supports more than 2 image scales') + img_scale = img_scales[np.random.randint(num_scales)] + return img_scale + + +def show_ann(coco, img, ann_info): + plt.imshow(mmcv.bgr2rgb(img)) + plt.axis('off') + coco.showAnns(ann_info) + plt.show() diff --git a/mmdet/datasets/voc.py b/mmdet/datasets/voc.py new file mode 100644 index 0000000..77bffe3 --- /dev/null +++ b/mmdet/datasets/voc.py @@ -0,0 +1,20 @@ +from .registry import DATASETS +from .xml_style import XMLDataset + + +@DATASETS.register_module +class VOCDataset(XMLDataset): + + CLASSES = ('aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', + 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', + 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train', + 'tvmonitor') + + def __init__(self, **kwargs): + super(VOCDataset, self).__init__(**kwargs) + if 'VOC2007' in self.img_prefix: + self.year = 2007 + elif 'VOC2012' in self.img_prefix: + self.year = 2012 + else: + raise ValueError('Cannot infer dataset year from img_prefix') diff --git a/mmdet/datasets/wider_face.py b/mmdet/datasets/wider_face.py new file mode 100644 index 0000000..b83e3d6 --- /dev/null +++ b/mmdet/datasets/wider_face.py @@ -0,0 +1,42 @@ +import os.path as osp +import xml.etree.ElementTree as ET + +import mmcv + +from .registry import DATASETS +from .xml_style import XMLDataset + + +@DATASETS.register_module +class WIDERFaceDataset(XMLDataset): + """ + Reader for the WIDER Face dataset in PASCAL VOC format. + Conversion scripts can be found in + https://github.com/sovrasov/wider-face-pascal-voc-annotations + """ + CLASSES = ('face', ) + + def __init__(self, **kwargs): + super(WIDERFaceDataset, self).__init__(**kwargs) + + def load_annotations(self, ann_file): + img_infos = [] + img_ids = mmcv.list_from_file(ann_file) + for img_id in img_ids: + filename = '{}.jpg'.format(img_id) + xml_path = osp.join(self.img_prefix, 'Annotations', + '{}.xml'.format(img_id)) + tree = ET.parse(xml_path) + root = tree.getroot() + size = root.find('size') + width = int(size.find('width').text) + height = int(size.find('height').text) + folder = root.find('folder').text + img_infos.append( + dict( + id=img_id, + filename=osp.join(folder, filename), + width=width, + height=height)) + + return img_infos diff --git a/mmdet/datasets/xml_style.py b/mmdet/datasets/xml_style.py new file mode 100644 index 0000000..39d5704 --- /dev/null +++ b/mmdet/datasets/xml_style.py @@ -0,0 +1,86 @@ +import os.path as osp +import xml.etree.ElementTree as ET + +import mmcv +import numpy as np + +from .custom import CustomDataset +from .registry import DATASETS + + +@DATASETS.register_module +class XMLDataset(CustomDataset): + + def __init__(self, min_size=None, **kwargs): + super(XMLDataset, self).__init__(**kwargs) + self.cat2label = {cat: i + 1 for i, cat in enumerate(self.CLASSES)} + self.min_size = min_size + + def load_annotations(self, ann_file): + img_infos = [] + img_ids = mmcv.list_from_file(ann_file) + for img_id in img_ids: + filename = 'JPEGImages/{}.jpg'.format(img_id) + xml_path = osp.join(self.img_prefix, 'Annotations', + '{}.xml'.format(img_id)) + tree = ET.parse(xml_path) + root = tree.getroot() + size = root.find('size') + width = int(size.find('width').text) + height = int(size.find('height').text) + img_infos.append( + dict(id=img_id, filename=filename, width=width, height=height)) + return img_infos + + def get_ann_info(self, idx): + img_id = self.img_infos[idx]['id'] + xml_path = osp.join(self.img_prefix, 'Annotations', + '{}.xml'.format(img_id)) + tree = ET.parse(xml_path) + root = tree.getroot() + bboxes = [] + labels = [] + bboxes_ignore = [] + labels_ignore = [] + for obj in root.findall('object'): + name = obj.find('name').text + label = self.cat2label[name] + difficult = int(obj.find('difficult').text) + bnd_box = obj.find('bndbox') + bbox = [ + int(bnd_box.find('xmin').text), + int(bnd_box.find('ymin').text), + int(bnd_box.find('xmax').text), + int(bnd_box.find('ymax').text) + ] + ignore = False + if self.min_size: + assert not self.test_mode + w = bbox[2] - bbox[0] + h = bbox[3] - bbox[1] + if w < self.min_size or h < self.min_size: + ignore = True + if difficult or ignore: + bboxes_ignore.append(bbox) + labels_ignore.append(label) + else: + bboxes.append(bbox) + labels.append(label) + if not bboxes: + bboxes = np.zeros((0, 4)) + labels = np.zeros((0, )) + else: + bboxes = np.array(bboxes, ndmin=2) - 1 + labels = np.array(labels) + if not bboxes_ignore: + bboxes_ignore = np.zeros((0, 4)) + labels_ignore = np.zeros((0, )) + else: + bboxes_ignore = np.array(bboxes_ignore, ndmin=2) - 1 + labels_ignore = np.array(labels_ignore) + ann = dict( + bboxes=bboxes.astype(np.float32), + labels=labels.astype(np.int64), + bboxes_ignore=bboxes_ignore.astype(np.float32), + labels_ignore=labels_ignore.astype(np.int64)) + return ann diff --git a/mmdet/models/__init__.py b/mmdet/models/__init__.py new file mode 100644 index 0000000..35f0a09 --- /dev/null +++ b/mmdet/models/__init__.py @@ -0,0 +1,19 @@ +from .anchor_heads import * # noqa: F401,F403 +from .backbones import * # noqa: F401,F403 +from .bbox_heads import * # noqa: F401,F403 +from .builder import (build_backbone, build_detector, build_head, build_loss, + build_neck, build_roi_extractor, build_shared_head) +from .detectors import * # noqa: F401,F403 +from .losses import * # noqa: F401,F403 +from .mask_heads import * # noqa: F401,F403 +from .necks import * # noqa: F401,F403 +from .registry import (BACKBONES, DETECTORS, HEADS, LOSSES, NECKS, + ROI_EXTRACTORS, SHARED_HEADS) +from .roi_extractors import * # noqa: F401,F403 +from .shared_heads import * # noqa: F401,F403 + +__all__ = [ + 'BACKBONES', 'NECKS', 'ROI_EXTRACTORS', 'SHARED_HEADS', 'HEADS', 'LOSSES', + 'DETECTORS', 'build_backbone', 'build_neck', 'build_roi_extractor', + 'build_shared_head', 'build_head', 'build_loss', 'build_detector' +] diff --git a/mmdet/models/anchor_heads/__init__.py b/mmdet/models/anchor_heads/__init__.py new file mode 100644 index 0000000..d670384 --- /dev/null +++ b/mmdet/models/anchor_heads/__init__.py @@ -0,0 +1,14 @@ +from .anchor_head import AnchorHead +from .fcos_head import FCOSHead +from .ga_retina_head import GARetinaHead +from .ga_rpn_head import GARPNHead +from .guided_anchor_head import FeatureAdaption, GuidedAnchorHead +from .retina_head import RetinaHead +from .rpn_head import RPNHead +from .ssd_head import SSDHead +from .ppdet_head import PPDetHead +__all__ = [ + 'AnchorHead', 'GuidedAnchorHead', 'FeatureAdaption', 'RPNHead', + 'GARPNHead', 'RetinaHead', 'GARetinaHead', 'SSDHead', 'FCOSHead', + 'PPDetHead' +] \ No newline at end of file diff --git a/mmdet/models/anchor_heads/anchor_head.py b/mmdet/models/anchor_heads/anchor_head.py new file mode 100644 index 0000000..b3fb5b4 --- /dev/null +++ b/mmdet/models/anchor_heads/anchor_head.py @@ -0,0 +1,270 @@ +from __future__ import division + +import numpy as np +import torch +import torch.nn as nn +from mmcv.cnn import normal_init + +from mmdet.core import (AnchorGenerator, anchor_target, delta2bbox, force_fp32, + multi_apply, multiclass_nms) +from ..builder import build_loss +from ..registry import HEADS + + +@HEADS.register_module +class AnchorHead(nn.Module): + """Anchor-based head (RPN, RetinaNet, SSD, etc.). + + Args: + in_channels (int): Number of channels in the input feature map. + feat_channels (int): Number of channels of the feature map. + anchor_scales (Iterable): Anchor scales. + anchor_ratios (Iterable): Anchor aspect ratios. + anchor_strides (Iterable): Anchor strides. + anchor_base_sizes (Iterable): Anchor base sizes. + target_means (Iterable): Mean values of regression targets. + target_stds (Iterable): Std values of regression targets. + loss_cls (dict): Config of classification loss. + loss_bbox (dict): Config of localization loss. + """ # noqa: W605 + + def __init__(self, + num_classes, + in_channels, + feat_channels=256, + anchor_scales=[8, 16, 32], + anchor_ratios=[0.5, 1.0, 2.0], + anchor_strides=[4, 8, 16, 32, 64], + anchor_base_sizes=None, + target_means=(.0, .0, .0, .0), + target_stds=(1.0, 1.0, 1.0, 1.0), + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0), + loss_bbox=dict( + type='SmoothL1Loss', beta=1.0 / 9.0, loss_weight=1.0)): + super(AnchorHead, self).__init__() + self.in_channels = in_channels + self.num_classes = num_classes + self.feat_channels = feat_channels + self.anchor_scales = anchor_scales + self.anchor_ratios = anchor_ratios + self.anchor_strides = anchor_strides + self.anchor_base_sizes = list( + anchor_strides) if anchor_base_sizes is None else anchor_base_sizes + self.target_means = target_means + self.target_stds = target_stds + + self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False) + self.sampling = loss_cls['type'] not in ['FocalLoss', 'GHMC'] + if self.use_sigmoid_cls: + self.cls_out_channels = num_classes - 1 + else: + self.cls_out_channels = num_classes + self.loss_cls = build_loss(loss_cls) + self.loss_bbox = build_loss(loss_bbox) + self.fp16_enabled = False + + self.anchor_generators = [] + for anchor_base in self.anchor_base_sizes: + self.anchor_generators.append( + AnchorGenerator(anchor_base, anchor_scales, anchor_ratios)) + + self.num_anchors = len(self.anchor_ratios) * len(self.anchor_scales) + self._init_layers() + + def _init_layers(self): + self.conv_cls = nn.Conv2d(self.feat_channels, + self.num_anchors * self.cls_out_channels, 1) + self.conv_reg = nn.Conv2d(self.feat_channels, self.num_anchors * 4, 1) + + def init_weights(self): + normal_init(self.conv_cls, std=0.01) + normal_init(self.conv_reg, std=0.01) + + def forward_single(self, x): + cls_score = self.conv_cls(x) + bbox_pred = self.conv_reg(x) + return cls_score, bbox_pred + + def forward(self, feats): + return multi_apply(self.forward_single, feats) + + def get_anchors(self, featmap_sizes, img_metas): + """Get anchors according to feature map sizes. + + Args: + featmap_sizes (list[tuple]): Multi-level feature map sizes. + img_metas (list[dict]): Image meta info. + + Returns: + tuple: anchors of each image, valid flags of each image + """ + num_imgs = len(img_metas) + num_levels = len(featmap_sizes) + + # since feature map sizes of all images are the same, we only compute + # anchors for one time + multi_level_anchors = [] + for i in range(num_levels): + anchors = self.anchor_generators[i].grid_anchors( + featmap_sizes[i], self.anchor_strides[i]) + multi_level_anchors.append(anchors) + anchor_list = [multi_level_anchors for _ in range(num_imgs)] + + # for each image, we compute valid flags of multi level anchors + valid_flag_list = [] + for img_id, img_meta in enumerate(img_metas): + multi_level_flags = [] + for i in range(num_levels): + anchor_stride = self.anchor_strides[i] + feat_h, feat_w = featmap_sizes[i] + h, w, _ = img_meta['pad_shape'] + valid_feat_h = min(int(np.ceil(h / anchor_stride)), feat_h) + valid_feat_w = min(int(np.ceil(w / anchor_stride)), feat_w) + flags = self.anchor_generators[i].valid_flags( + (feat_h, feat_w), (valid_feat_h, valid_feat_w)) + multi_level_flags.append(flags) + valid_flag_list.append(multi_level_flags) + + return anchor_list, valid_flag_list + + def loss_single(self, cls_score, bbox_pred, labels, label_weights, + bbox_targets, bbox_weights, num_total_samples, cfg): + # classification loss + labels = labels.reshape(-1) + label_weights = label_weights.reshape(-1) + cls_score = cls_score.permute(0, 2, 3, + 1).reshape(-1, self.cls_out_channels) + loss_cls = self.loss_cls( + cls_score, labels, label_weights, avg_factor=num_total_samples) + # regression loss + bbox_targets = bbox_targets.reshape(-1, 4) + bbox_weights = bbox_weights.reshape(-1, 4) + bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4) + loss_bbox = self.loss_bbox( + bbox_pred, + bbox_targets, + bbox_weights, + avg_factor=num_total_samples) + return loss_cls, loss_bbox + + @force_fp32(apply_to=('cls_scores', 'bbox_preds')) + def loss(self, + cls_scores, + bbox_preds, + gt_bboxes, + gt_labels, + img_metas, + cfg, + gt_bboxes_ignore=None): + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + assert len(featmap_sizes) == len(self.anchor_generators) + + anchor_list, valid_flag_list = self.get_anchors( + featmap_sizes, img_metas) + label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1 + cls_reg_targets = anchor_target( + anchor_list, + valid_flag_list, + gt_bboxes, + img_metas, + self.target_means, + self.target_stds, + cfg, + gt_bboxes_ignore_list=gt_bboxes_ignore, + gt_labels_list=gt_labels, + label_channels=label_channels, + sampling=self.sampling) + if cls_reg_targets is None: + return None + (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list, + num_total_pos, num_total_neg) = cls_reg_targets + num_total_samples = ( + num_total_pos + num_total_neg if self.sampling else num_total_pos) + losses_cls, losses_bbox = multi_apply( + self.loss_single, + cls_scores, + bbox_preds, + labels_list, + label_weights_list, + bbox_targets_list, + bbox_weights_list, + num_total_samples=num_total_samples, + cfg=cfg) + return dict(loss_cls=losses_cls, loss_bbox=losses_bbox) + + @force_fp32(apply_to=('cls_scores', 'bbox_preds')) + def get_bboxes(self, cls_scores, bbox_preds, img_metas, cfg, + rescale=False): + assert len(cls_scores) == len(bbox_preds) + num_levels = len(cls_scores) + + mlvl_anchors = [ + self.anchor_generators[i].grid_anchors(cls_scores[i].size()[-2:], + self.anchor_strides[i]) + for i in range(num_levels) + ] + result_list = [] + for img_id in range(len(img_metas)): + cls_score_list = [ + cls_scores[i][img_id].detach() for i in range(num_levels) + ] + bbox_pred_list = [ + bbox_preds[i][img_id].detach() for i in range(num_levels) + ] + img_shape = img_metas[img_id]['img_shape'] + scale_factor = img_metas[img_id]['scale_factor'] + proposals = self.get_bboxes_single(cls_score_list, bbox_pred_list, + mlvl_anchors, img_shape, + scale_factor, cfg, rescale) + result_list.append(proposals) + return result_list + + def get_bboxes_single(self, + cls_scores, + bbox_preds, + mlvl_anchors, + img_shape, + scale_factor, + cfg, + rescale=False): + assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors) + mlvl_bboxes = [] + mlvl_scores = [] + for cls_score, bbox_pred, anchors in zip(cls_scores, bbox_preds, + mlvl_anchors): + assert cls_score.size()[-2:] == bbox_pred.size()[-2:] + cls_score = cls_score.permute(1, 2, + 0).reshape(-1, self.cls_out_channels) + if self.use_sigmoid_cls: + scores = cls_score.sigmoid() + else: + scores = cls_score.softmax(-1) + bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4) + nms_pre = cfg.get('nms_pre', -1) + if nms_pre > 0 and scores.shape[0] > nms_pre: + if self.use_sigmoid_cls: + max_scores, _ = scores.max(dim=1) + else: + max_scores, _ = scores[:, 1:].max(dim=1) + _, topk_inds = max_scores.topk(nms_pre) + anchors = anchors[topk_inds, :] + bbox_pred = bbox_pred[topk_inds, :] + scores = scores[topk_inds, :] + bboxes = delta2bbox(anchors, bbox_pred, self.target_means, + self.target_stds, img_shape) + mlvl_bboxes.append(bboxes) + mlvl_scores.append(scores) + mlvl_bboxes = torch.cat(mlvl_bboxes) + if rescale: + mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor) + mlvl_scores = torch.cat(mlvl_scores) + if self.use_sigmoid_cls: + padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1) + mlvl_scores = torch.cat([padding, mlvl_scores], dim=1) + det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores, + cfg.score_thr, cfg.nms, + cfg.max_per_img) + return det_bboxes, det_labels diff --git a/mmdet/models/anchor_heads/fcos_head.py b/mmdet/models/anchor_heads/fcos_head.py new file mode 100644 index 0000000..c01e4ea --- /dev/null +++ b/mmdet/models/anchor_heads/fcos_head.py @@ -0,0 +1,392 @@ +import torch +import torch.nn as nn +from mmcv.cnn import normal_init + +from mmdet.core import distance2bbox, force_fp32, multi_apply, multiclass_nms +from ..builder import build_loss +from ..registry import HEADS +from ..utils import ConvModule, Scale, bias_init_with_prob + +INF = 1e8 + + +@HEADS.register_module +class FCOSHead(nn.Module): + + def __init__(self, + num_classes, + in_channels, + feat_channels=256, + stacked_convs=4, + strides=(4, 8, 16, 32, 64), + regress_ranges=((-1, 64), (64, 128), (128, 256), (256, 512), + (512, INF)), + loss_cls=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_bbox=dict(type='IoULoss', loss_weight=1.0), + loss_centerness=dict( + type='CrossEntropyLoss', + use_sigmoid=True, + loss_weight=1.0), + conv_cfg=None, + norm_cfg=dict(type='GN', num_groups=32, requires_grad=True)): + super(FCOSHead, self).__init__() + + self.num_classes = num_classes + self.cls_out_channels = num_classes - 1 + self.in_channels = in_channels + self.feat_channels = feat_channels + self.stacked_convs = stacked_convs + self.strides = strides + self.regress_ranges = regress_ranges + self.loss_cls = build_loss(loss_cls) + self.loss_bbox = build_loss(loss_bbox) + self.loss_centerness = build_loss(loss_centerness) + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self.fp16_enabled = False + + self._init_layers() + + def _init_layers(self): + self.cls_convs = nn.ModuleList() + self.reg_convs = nn.ModuleList() + for i in range(self.stacked_convs): + chn = self.in_channels if i == 0 else self.feat_channels + self.cls_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + bias=self.norm_cfg is None)) + self.reg_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + bias=self.norm_cfg is None)) + self.fcos_cls = nn.Conv2d( + self.feat_channels, self.cls_out_channels, 3, padding=1) + self.fcos_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) + self.fcos_centerness = nn.Conv2d(self.feat_channels, 1, 3, padding=1) + + self.scales = nn.ModuleList([Scale(1.0) for _ in self.strides]) + + def init_weights(self): + for m in self.cls_convs: + normal_init(m.conv, std=0.01) + for m in self.reg_convs: + normal_init(m.conv, std=0.01) + bias_cls = bias_init_with_prob(0.01) + normal_init(self.fcos_cls, std=0.01, bias=bias_cls) + normal_init(self.fcos_reg, std=0.01) + normal_init(self.fcos_centerness, std=0.01) + + def forward(self, feats): + return multi_apply(self.forward_single, feats, self.scales) + + def forward_single(self, x, scale): + cls_feat = x + reg_feat = x + + for cls_layer in self.cls_convs: + cls_feat = cls_layer(cls_feat) + cls_score = self.fcos_cls(cls_feat) + centerness = self.fcos_centerness(cls_feat) + + for reg_layer in self.reg_convs: + reg_feat = reg_layer(reg_feat) + # scale the bbox_pred of different level + # float to avoid overflow when enabling FP16 + bbox_pred = scale(self.fcos_reg(reg_feat)).float().exp() + return cls_score, bbox_pred, centerness + + @force_fp32(apply_to=('cls_scores', 'bbox_preds', 'centernesses')) + def loss(self, + cls_scores, + bbox_preds, + centernesses, + gt_bboxes, + gt_labels, + img_metas, + cfg, + gt_bboxes_ignore=None): + assert len(cls_scores) == len(bbox_preds) == len(centernesses) + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + all_level_points = self.get_points(featmap_sizes, bbox_preds[0].dtype, + bbox_preds[0].device) + labels, bbox_targets = self.fcos_target(all_level_points, gt_bboxes, + gt_labels) + + num_imgs = cls_scores[0].size(0) + # flatten cls_scores, bbox_preds and centerness + flatten_cls_scores = [ + cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels) + for cls_score in cls_scores + ] + flatten_bbox_preds = [ + bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4) + for bbox_pred in bbox_preds + ] + flatten_centerness = [ + centerness.permute(0, 2, 3, 1).reshape(-1) + for centerness in centernesses + ] + flatten_cls_scores = torch.cat(flatten_cls_scores) + flatten_bbox_preds = torch.cat(flatten_bbox_preds) + flatten_centerness = torch.cat(flatten_centerness) + flatten_labels = torch.cat(labels) + flatten_bbox_targets = torch.cat(bbox_targets) + # repeat points to align with bbox_preds + flatten_points = torch.cat( + [points.repeat(num_imgs, 1) for points in all_level_points]) + + pos_inds = flatten_labels.nonzero().reshape(-1) + num_pos = len(pos_inds) + loss_cls = self.loss_cls( + flatten_cls_scores, flatten_labels, + avg_factor=num_pos + num_imgs) # avoid num_pos is 0 + + pos_bbox_preds = flatten_bbox_preds[pos_inds] + pos_centerness = flatten_centerness[pos_inds] + + if num_pos > 0: + pos_bbox_targets = flatten_bbox_targets[pos_inds] + pos_centerness_targets = self.centerness_target(pos_bbox_targets) + pos_points = flatten_points[pos_inds] + pos_decoded_bbox_preds = distance2bbox(pos_points, pos_bbox_preds) + pos_decoded_target_preds = distance2bbox(pos_points, + pos_bbox_targets) + # centerness weighted iou loss + loss_bbox = self.loss_bbox( + pos_decoded_bbox_preds, + pos_decoded_target_preds, + weight=pos_centerness_targets, + avg_factor=pos_centerness_targets.sum()) + loss_centerness = self.loss_centerness(pos_centerness, + pos_centerness_targets) + else: + loss_bbox = pos_bbox_preds.sum() + loss_centerness = pos_centerness.sum() + + return dict( + loss_cls=loss_cls, + loss_bbox=loss_bbox, + loss_centerness=loss_centerness) + + @force_fp32(apply_to=('cls_scores', 'bbox_preds', 'centernesses')) + def get_bboxes(self, + cls_scores, + bbox_preds, + centernesses, + img_metas, + cfg, + rescale=None): + assert len(cls_scores) == len(bbox_preds) + num_levels = len(cls_scores) + + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + mlvl_points = self.get_points(featmap_sizes, bbox_preds[0].dtype, + bbox_preds[0].device) + result_list = [] + for img_id in range(len(img_metas)): + cls_score_list = [ + cls_scores[i][img_id].detach() for i in range(num_levels) + ] + bbox_pred_list = [ + bbox_preds[i][img_id].detach() for i in range(num_levels) + ] + centerness_pred_list = [ + centernesses[i][img_id].detach() for i in range(num_levels) + ] + img_shape = img_metas[img_id]['img_shape'] + scale_factor = img_metas[img_id]['scale_factor'] + det_bboxes = self.get_bboxes_single(cls_score_list, bbox_pred_list, + centerness_pred_list, + mlvl_points, img_shape, + scale_factor, cfg, rescale) + result_list.append(det_bboxes) + return result_list + + def get_bboxes_single(self, + cls_scores, + bbox_preds, + centernesses, + mlvl_points, + img_shape, + scale_factor, + cfg, + rescale=False): + assert len(cls_scores) == len(bbox_preds) == len(mlvl_points) + mlvl_bboxes = [] + mlvl_scores = [] + mlvl_centerness = [] + for cls_score, bbox_pred, centerness, points in zip( + cls_scores, bbox_preds, centernesses, mlvl_points): + assert cls_score.size()[-2:] == bbox_pred.size()[-2:] + scores = cls_score.permute(1, 2, 0).reshape( + -1, self.cls_out_channels).sigmoid() + centerness = centerness.permute(1, 2, 0).reshape(-1).sigmoid() + + bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4) + nms_pre = cfg.get('nms_pre', -1) + if nms_pre > 0 and scores.shape[0] > nms_pre: + max_scores, _ = (scores * centerness[:, None]).max(dim=1) + _, topk_inds = max_scores.topk(nms_pre) + points = points[topk_inds, :] + bbox_pred = bbox_pred[topk_inds, :] + scores = scores[topk_inds, :] + centerness = centerness[topk_inds] + bboxes = distance2bbox(points, bbox_pred, max_shape=img_shape) + mlvl_bboxes.append(bboxes) + mlvl_scores.append(scores) + mlvl_centerness.append(centerness) + mlvl_bboxes = torch.cat(mlvl_bboxes) + if rescale: + mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor) + mlvl_scores = torch.cat(mlvl_scores) + padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1) + mlvl_scores = torch.cat([padding, mlvl_scores], dim=1) + mlvl_centerness = torch.cat(mlvl_centerness) + det_bboxes, det_labels = multiclass_nms( + mlvl_bboxes, + mlvl_scores, + cfg.score_thr, + cfg.nms, + cfg.max_per_img, + score_factors=mlvl_centerness) + return det_bboxes, det_labels + + def get_points(self, featmap_sizes, dtype, device): + """Get points according to feature map sizes. + + Args: + featmap_sizes (list[tuple]): Multi-level feature map sizes. + dtype (torch.dtype): Type of points. + device (torch.device): Device of points. + + Returns: + tuple: points of each image. + """ + mlvl_points = [] + for i in range(len(featmap_sizes)): + mlvl_points.append( + self.get_points_single(featmap_sizes[i], self.strides[i], + dtype, device)) + return mlvl_points + + def get_points_single(self, featmap_size, stride, dtype, device): + h, w = featmap_size + x_range = torch.arange( + 0, w * stride, stride, dtype=dtype, device=device) + y_range = torch.arange( + 0, h * stride, stride, dtype=dtype, device=device) + y, x = torch.meshgrid(y_range, x_range) + points = torch.stack( + (x.reshape(-1), y.reshape(-1)), dim=-1) + stride // 2 + return points + + def fcos_target(self, points, gt_bboxes_list, gt_labels_list): + assert len(points) == len(self.regress_ranges) + num_levels = len(points) + # expand regress ranges to align with points + expanded_regress_ranges = [ + points[i].new_tensor(self.regress_ranges[i])[None].expand_as( + points[i]) for i in range(num_levels) + ] + # concat all levels points and regress ranges + concat_regress_ranges = torch.cat(expanded_regress_ranges, dim=0) + concat_points = torch.cat(points, dim=0) + # get labels and bbox_targets of each image + labels_list, bbox_targets_list = multi_apply( + self.fcos_target_single, + gt_bboxes_list, + gt_labels_list, + points=concat_points, + regress_ranges=concat_regress_ranges) + + # split to per img, per level + num_points = [center.size(0) for center in points] + labels_list = [labels.split(num_points, 0) for labels in labels_list] + bbox_targets_list = [ + bbox_targets.split(num_points, 0) + for bbox_targets in bbox_targets_list + ] + + # concat per level image + concat_lvl_labels = [] + concat_lvl_bbox_targets = [] + for i in range(num_levels): + concat_lvl_labels.append( + torch.cat([labels[i] for labels in labels_list])) + concat_lvl_bbox_targets.append( + torch.cat( + [bbox_targets[i] for bbox_targets in bbox_targets_list])) + return concat_lvl_labels, concat_lvl_bbox_targets + + def fcos_target_single(self, gt_bboxes, gt_labels, points, regress_ranges): + num_points = points.size(0) + num_gts = gt_labels.size(0) + if num_gts == 0: + return gt_labels.new_zeros(num_points), \ + gt_bboxes.new_zeros((num_points, 4)) + + areas = (gt_bboxes[:, 2] - gt_bboxes[:, 0] + 1) * ( + gt_bboxes[:, 3] - gt_bboxes[:, 1] + 1) + # TODO: figure out why these two are different + # areas = areas[None].expand(num_points, num_gts) + areas = areas[None].repeat(num_points, 1) + regress_ranges = regress_ranges[:, None, :].expand( + num_points, num_gts, 2) + gt_bboxes = gt_bboxes[None].expand(num_points, num_gts, 4) + xs, ys = points[:, 0], points[:, 1] + xs = xs[:, None].expand(num_points, num_gts) + ys = ys[:, None].expand(num_points, num_gts) + + left = xs - gt_bboxes[..., 0] + right = gt_bboxes[..., 2] - xs + top = ys - gt_bboxes[..., 1] + bottom = gt_bboxes[..., 3] - ys + bbox_targets = torch.stack((left, top, right, bottom), -1) + + # condition1: inside a gt bbox + inside_gt_bbox_mask = bbox_targets.min(-1)[0] > 0 + + # condition2: limit the regression range for each location + max_regress_distance = bbox_targets.max(-1)[0] + inside_regress_range = ( + max_regress_distance >= regress_ranges[..., 0]) & ( + max_regress_distance <= regress_ranges[..., 1]) + + # if there are still more than one objects for a location, + # we choose the one with minimal area + areas[inside_gt_bbox_mask == 0] = INF + areas[inside_regress_range == 0] = INF + min_area, min_area_inds = areas.min(dim=1) + + labels = gt_labels[min_area_inds] + labels[min_area == INF] = 0 + bbox_targets = bbox_targets[range(num_points), min_area_inds] + + return labels, bbox_targets + + def centerness_target(self, pos_bbox_targets): + # only calculate pos centerness targets, otherwise there may be nan + left_right = pos_bbox_targets[:, [0, 2]] + top_bottom = pos_bbox_targets[:, [1, 3]] + centerness_targets = ( + left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) * ( + top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0]) + return torch.sqrt(centerness_targets) diff --git a/mmdet/models/anchor_heads/ga_retina_head.py b/mmdet/models/anchor_heads/ga_retina_head.py new file mode 100644 index 0000000..73f89d7 --- /dev/null +++ b/mmdet/models/anchor_heads/ga_retina_head.py @@ -0,0 +1,107 @@ +import torch.nn as nn +from mmcv.cnn import normal_init + +from mmdet.ops import MaskedConv2d +from ..registry import HEADS +from ..utils import ConvModule, bias_init_with_prob +from .guided_anchor_head import FeatureAdaption, GuidedAnchorHead + + +@HEADS.register_module +class GARetinaHead(GuidedAnchorHead): + """Guided-Anchor-based RetinaNet head.""" + + def __init__(self, + num_classes, + in_channels, + stacked_convs=4, + conv_cfg=None, + norm_cfg=None, + **kwargs): + self.stacked_convs = stacked_convs + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + super(GARetinaHead, self).__init__(num_classes, in_channels, **kwargs) + + def _init_layers(self): + self.relu = nn.ReLU(inplace=True) + self.cls_convs = nn.ModuleList() + self.reg_convs = nn.ModuleList() + for i in range(self.stacked_convs): + chn = self.in_channels if i == 0 else self.feat_channels + self.cls_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg)) + self.reg_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg)) + + self.conv_loc = nn.Conv2d(self.feat_channels, 1, 1) + self.conv_shape = nn.Conv2d(self.feat_channels, self.num_anchors * 2, + 1) + self.feature_adaption_cls = FeatureAdaption( + self.feat_channels, + self.feat_channels, + kernel_size=3, + deformable_groups=self.deformable_groups) + self.feature_adaption_reg = FeatureAdaption( + self.feat_channels, + self.feat_channels, + kernel_size=3, + deformable_groups=self.deformable_groups) + self.retina_cls = MaskedConv2d( + self.feat_channels, + self.num_anchors * self.cls_out_channels, + 3, + padding=1) + self.retina_reg = MaskedConv2d( + self.feat_channels, self.num_anchors * 4, 3, padding=1) + + def init_weights(self): + for m in self.cls_convs: + normal_init(m.conv, std=0.01) + for m in self.reg_convs: + normal_init(m.conv, std=0.01) + + self.feature_adaption_cls.init_weights() + self.feature_adaption_reg.init_weights() + + bias_cls = bias_init_with_prob(0.01) + normal_init(self.conv_loc, std=0.01, bias=bias_cls) + normal_init(self.conv_shape, std=0.01) + normal_init(self.retina_cls, std=0.01, bias=bias_cls) + normal_init(self.retina_reg, std=0.01) + + def forward_single(self, x): + cls_feat = x + reg_feat = x + 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) + + loc_pred = self.conv_loc(cls_feat) + shape_pred = self.conv_shape(reg_feat) + + cls_feat = self.feature_adaption_cls(cls_feat, shape_pred) + reg_feat = self.feature_adaption_reg(reg_feat, shape_pred) + + if not self.training: + mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr + else: + mask = None + cls_score = self.retina_cls(cls_feat, mask) + bbox_pred = self.retina_reg(reg_feat, mask) + return cls_score, bbox_pred, shape_pred, loc_pred diff --git a/mmdet/models/anchor_heads/ga_rpn_head.py b/mmdet/models/anchor_heads/ga_rpn_head.py new file mode 100644 index 0000000..11512ff --- /dev/null +++ b/mmdet/models/anchor_heads/ga_rpn_head.py @@ -0,0 +1,127 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import normal_init + +from mmdet.core import delta2bbox +from mmdet.ops import nms +from ..registry import HEADS +from .guided_anchor_head import GuidedAnchorHead + + +@HEADS.register_module +class GARPNHead(GuidedAnchorHead): + """Guided-Anchor-based RPN head.""" + + def __init__(self, in_channels, **kwargs): + super(GARPNHead, self).__init__(2, in_channels, **kwargs) + + def _init_layers(self): + self.rpn_conv = nn.Conv2d( + self.in_channels, self.feat_channels, 3, padding=1) + super(GARPNHead, self)._init_layers() + + def init_weights(self): + normal_init(self.rpn_conv, std=0.01) + super(GARPNHead, self).init_weights() + + def forward_single(self, x): + x = self.rpn_conv(x) + x = F.relu(x, inplace=True) + (cls_score, bbox_pred, shape_pred, + loc_pred) = super(GARPNHead, self).forward_single(x) + return cls_score, bbox_pred, shape_pred, loc_pred + + def loss(self, + cls_scores, + bbox_preds, + shape_preds, + loc_preds, + gt_bboxes, + img_metas, + cfg, + gt_bboxes_ignore=None): + losses = super(GARPNHead, self).loss( + cls_scores, + bbox_preds, + shape_preds, + loc_preds, + gt_bboxes, + None, + img_metas, + cfg, + gt_bboxes_ignore=gt_bboxes_ignore) + return dict( + loss_rpn_cls=losses['loss_cls'], + loss_rpn_bbox=losses['loss_bbox'], + loss_anchor_shape=losses['loss_shape'], + loss_anchor_loc=losses['loss_loc']) + + def get_bboxes_single(self, + cls_scores, + bbox_preds, + mlvl_anchors, + mlvl_masks, + img_shape, + scale_factor, + cfg, + rescale=False): + mlvl_proposals = [] + for idx in range(len(cls_scores)): + rpn_cls_score = cls_scores[idx] + rpn_bbox_pred = bbox_preds[idx] + anchors = mlvl_anchors[idx] + mask = mlvl_masks[idx] + assert rpn_cls_score.size()[-2:] == rpn_bbox_pred.size()[-2:] + # if no location is kept, end. + if mask.sum() == 0: + continue + rpn_cls_score = rpn_cls_score.permute(1, 2, 0) + if self.use_sigmoid_cls: + rpn_cls_score = rpn_cls_score.reshape(-1) + scores = rpn_cls_score.sigmoid() + else: + rpn_cls_score = rpn_cls_score.reshape(-1, 2) + scores = rpn_cls_score.softmax(dim=1)[:, 1] + # filter scores, bbox_pred w.r.t. mask. + # anchors are filtered in get_anchors() beforehand. + scores = scores[mask] + rpn_bbox_pred = rpn_bbox_pred.permute(1, 2, 0).reshape(-1, + 4)[mask, :] + if scores.dim() == 0: + rpn_bbox_pred = rpn_bbox_pred.unsqueeze(0) + anchors = anchors.unsqueeze(0) + scores = scores.unsqueeze(0) + # filter anchors, bbox_pred, scores w.r.t. scores + if cfg.nms_pre > 0 and scores.shape[0] > cfg.nms_pre: + _, topk_inds = scores.topk(cfg.nms_pre) + rpn_bbox_pred = rpn_bbox_pred[topk_inds, :] + anchors = anchors[topk_inds, :] + scores = scores[topk_inds] + # get proposals w.r.t. anchors and rpn_bbox_pred + proposals = delta2bbox(anchors, rpn_bbox_pred, self.target_means, + self.target_stds, img_shape) + # filter out too small bboxes + if cfg.min_bbox_size > 0: + w = proposals[:, 2] - proposals[:, 0] + 1 + h = proposals[:, 3] - proposals[:, 1] + 1 + valid_inds = torch.nonzero((w >= cfg.min_bbox_size) & + (h >= cfg.min_bbox_size)).squeeze() + proposals = proposals[valid_inds, :] + scores = scores[valid_inds] + proposals = torch.cat([proposals, scores.unsqueeze(-1)], dim=-1) + # NMS in current level + proposals, _ = nms(proposals, cfg.nms_thr) + proposals = proposals[:cfg.nms_post, :] + mlvl_proposals.append(proposals) + proposals = torch.cat(mlvl_proposals, 0) + if cfg.nms_across_levels: + # NMS across multi levels + proposals, _ = nms(proposals, cfg.nms_thr) + proposals = proposals[:cfg.max_num, :] + else: + scores = proposals[:, 4] + num = min(cfg.max_num, proposals.shape[0]) + _, topk_inds = scores.topk(num) + proposals = proposals[topk_inds, :] + return proposals diff --git a/mmdet/models/anchor_heads/guided_anchor_head.py b/mmdet/models/anchor_heads/guided_anchor_head.py new file mode 100644 index 0000000..d2d71d0 --- /dev/null +++ b/mmdet/models/anchor_heads/guided_anchor_head.py @@ -0,0 +1,609 @@ +from __future__ import division + +import numpy as np +import torch +import torch.nn as nn +from mmcv.cnn import normal_init + +from mmdet.core import (AnchorGenerator, anchor_inside_flags, anchor_target, + delta2bbox, force_fp32, ga_loc_target, ga_shape_target, + multi_apply, multiclass_nms) +from mmdet.ops import DeformConv, MaskedConv2d +from ..builder import build_loss +from ..registry import HEADS +from ..utils import bias_init_with_prob +from .anchor_head import AnchorHead + + +class FeatureAdaption(nn.Module): + """Feature Adaption Module. + + Feature Adaption Module is implemented based on DCN v1. + It uses anchor shape prediction rather than feature map to + predict offsets of deformable conv layer. + + Args: + in_channels (int): Number of channels in the input feature map. + out_channels (int): Number of channels in the output feature map. + kernel_size (int): Deformable conv kernel size. + deformable_groups (int): Deformable conv group size. + """ + + def __init__(self, + in_channels, + out_channels, + kernel_size=3, + deformable_groups=4): + super(FeatureAdaption, self).__init__() + offset_channels = kernel_size * kernel_size * 2 + self.conv_offset = nn.Conv2d( + 2, deformable_groups * offset_channels, 1, bias=False) + self.conv_adaption = DeformConv( + in_channels, + out_channels, + kernel_size=kernel_size, + padding=(kernel_size - 1) // 2, + deformable_groups=deformable_groups) + self.relu = nn.ReLU(inplace=True) + + def init_weights(self): + normal_init(self.conv_offset, std=0.1) + normal_init(self.conv_adaption, std=0.01) + + def forward(self, x, shape): + offset = self.conv_offset(shape.detach()) + x = self.relu(self.conv_adaption(x, offset)) + return x + + +@HEADS.register_module +class GuidedAnchorHead(AnchorHead): + """Guided-Anchor-based head (GA-RPN, GA-RetinaNet, etc.). + + This GuidedAnchorHead will predict high-quality feature guided + anchors and locations where anchors will be kept in inference. + There are mainly 3 categories of bounding-boxes. + - Sampled (9) pairs for target assignment. (approxes) + - The square boxes where the predicted anchors are based on. + (squares) + - Guided anchors. + Please refer to https://arxiv.org/abs/1901.03278 for more details. + + Args: + num_classes (int): Number of classes. + in_channels (int): Number of channels in the input feature map. + feat_channels (int): Number of channels of the feature map. + octave_base_scale (int): Base octave scale of each level of + feature map. + scales_per_octave (int): Number of octave scales in each level of + feature map + octave_ratios (Iterable): octave aspect ratios. + anchor_strides (Iterable): Anchor strides. + anchor_base_sizes (Iterable): Anchor base sizes. + anchoring_means (Iterable): Mean values of anchoring targets. + anchoring_stds (Iterable): Std values of anchoring targets. + target_means (Iterable): Mean values of regression targets. + target_stds (Iterable): Std values of regression targets. + deformable_groups: (int): Group number of DCN in + FeatureAdaption module. + loc_filter_thr (float): Threshold to filter out unconcerned regions. + loss_loc (dict): Config of location loss. + loss_shape (dict): Config of anchor shape loss. + loss_cls (dict): Config of classification loss. + loss_bbox (dict): Config of bbox regression loss. + """ + + def __init__( + self, + num_classes, + in_channels, + feat_channels=256, + octave_base_scale=8, + scales_per_octave=3, + octave_ratios=[0.5, 1.0, 2.0], + anchor_strides=[4, 8, 16, 32, 64], + anchor_base_sizes=None, + anchoring_means=(.0, .0, .0, .0), + anchoring_stds=(1.0, 1.0, 1.0, 1.0), + target_means=(.0, .0, .0, .0), + target_stds=(1.0, 1.0, 1.0, 1.0), + deformable_groups=4, + loc_filter_thr=0.01, + loss_loc=dict( + type='FocalLoss', + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + loss_weight=1.0), + loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0), + loss_cls=dict( + type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0), + loss_bbox=dict(type='SmoothL1Loss', beta=1.0, loss_weight=1.0)): + super(AnchorHead, self).__init__() + self.in_channels = in_channels + self.num_classes = num_classes + self.feat_channels = feat_channels + self.octave_base_scale = octave_base_scale + self.scales_per_octave = scales_per_octave + self.octave_scales = octave_base_scale * np.array( + [2**(i / scales_per_octave) for i in range(scales_per_octave)]) + self.approxs_per_octave = len(self.octave_scales) * len(octave_ratios) + self.octave_ratios = octave_ratios + self.anchor_strides = anchor_strides + self.anchor_base_sizes = list( + anchor_strides) if anchor_base_sizes is None else anchor_base_sizes + self.anchoring_means = anchoring_means + self.anchoring_stds = anchoring_stds + self.target_means = target_means + self.target_stds = target_stds + self.deformable_groups = deformable_groups + self.loc_filter_thr = loc_filter_thr + self.approx_generators = [] + self.square_generators = [] + for anchor_base in self.anchor_base_sizes: + # Generators for approxs + self.approx_generators.append( + AnchorGenerator(anchor_base, self.octave_scales, + self.octave_ratios)) + # Generators for squares + self.square_generators.append( + AnchorGenerator(anchor_base, [self.octave_base_scale], [1.0])) + # one anchor per location + self.num_anchors = 1 + self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False) + self.cls_focal_loss = loss_cls['type'] in ['FocalLoss'] + self.loc_focal_loss = loss_loc['type'] in ['FocalLoss'] + if self.use_sigmoid_cls: + self.cls_out_channels = self.num_classes - 1 + else: + self.cls_out_channels = self.num_classes + + # build losses + self.loss_loc = build_loss(loss_loc) + self.loss_shape = build_loss(loss_shape) + self.loss_cls = build_loss(loss_cls) + self.loss_bbox = build_loss(loss_bbox) + + self.fp16_enabled = False + + self._init_layers() + + def _init_layers(self): + self.relu = nn.ReLU(inplace=True) + self.conv_loc = nn.Conv2d(self.feat_channels, 1, 1) + self.conv_shape = nn.Conv2d(self.feat_channels, self.num_anchors * 2, + 1) + self.feature_adaption = FeatureAdaption( + self.feat_channels, + self.feat_channels, + kernel_size=3, + deformable_groups=self.deformable_groups) + self.conv_cls = MaskedConv2d(self.feat_channels, + self.num_anchors * self.cls_out_channels, + 1) + self.conv_reg = MaskedConv2d(self.feat_channels, self.num_anchors * 4, + 1) + + def init_weights(self): + normal_init(self.conv_cls, std=0.01) + normal_init(self.conv_reg, std=0.01) + + bias_cls = bias_init_with_prob(0.01) + normal_init(self.conv_loc, std=0.01, bias=bias_cls) + normal_init(self.conv_shape, std=0.01) + + self.feature_adaption.init_weights() + + def forward_single(self, x): + loc_pred = self.conv_loc(x) + shape_pred = self.conv_shape(x) + x = self.feature_adaption(x, shape_pred) + # masked conv is only used during inference for speed-up + if not self.training: + mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr + else: + mask = None + cls_score = self.conv_cls(x, mask) + bbox_pred = self.conv_reg(x, mask) + return cls_score, bbox_pred, shape_pred, loc_pred + + def forward(self, feats): + return multi_apply(self.forward_single, feats) + + def get_sampled_approxs(self, featmap_sizes, img_metas, cfg): + """Get sampled approxs and inside flags according to feature map sizes. + + Args: + featmap_sizes (list[tuple]): Multi-level feature map sizes. + img_metas (list[dict]): Image meta info. + + Returns: + tuple: approxes of each image, inside flags of each image + """ + num_imgs = len(img_metas) + num_levels = len(featmap_sizes) + + # since feature map sizes of all images are the same, we only compute + # approxes for one time + multi_level_approxs = [] + for i in range(num_levels): + approxs = self.approx_generators[i].grid_anchors( + featmap_sizes[i], self.anchor_strides[i]) + multi_level_approxs.append(approxs) + approxs_list = [multi_level_approxs for _ in range(num_imgs)] + + # for each image, we compute inside flags of multi level approxes + inside_flag_list = [] + for img_id, img_meta in enumerate(img_metas): + multi_level_flags = [] + multi_level_approxs = approxs_list[img_id] + for i in range(num_levels): + approxs = multi_level_approxs[i] + anchor_stride = self.anchor_strides[i] + feat_h, feat_w = featmap_sizes[i] + h, w, _ = img_meta['pad_shape'] + valid_feat_h = min(int(np.ceil(h / anchor_stride)), feat_h) + valid_feat_w = min(int(np.ceil(w / anchor_stride)), feat_w) + flags = self.approx_generators[i].valid_flags( + (feat_h, feat_w), (valid_feat_h, valid_feat_w)) + inside_flags_list = [] + for i in range(self.approxs_per_octave): + split_valid_flags = flags[i::self.approxs_per_octave] + split_approxs = approxs[i::self.approxs_per_octave, :] + inside_flags = anchor_inside_flags( + split_approxs, split_valid_flags, + img_meta['img_shape'][:2], cfg.allowed_border) + inside_flags_list.append(inside_flags) + # inside_flag for a position is true if any anchor in this + # position is true + inside_flags = ( + torch.stack(inside_flags_list, 0).sum(dim=0) > 0) + multi_level_flags.append(inside_flags) + inside_flag_list.append(multi_level_flags) + return approxs_list, inside_flag_list + + def get_anchors(self, + featmap_sizes, + shape_preds, + loc_preds, + img_metas, + use_loc_filter=False): + """Get squares according to feature map sizes and guided + anchors. + + Args: + featmap_sizes (list[tuple]): Multi-level feature map sizes. + shape_preds (list[tensor]): Multi-level shape predictions. + loc_preds (list[tensor]): Multi-level location predictions. + img_metas (list[dict]): Image meta info. + use_loc_filter (bool): Use loc filter or not. + + Returns: + tuple: square approxs of each image, guided anchors of each image, + loc masks of each image + """ + num_imgs = len(img_metas) + num_levels = len(featmap_sizes) + + # since feature map sizes of all images are the same, we only compute + # squares for one time + multi_level_squares = [] + for i in range(num_levels): + squares = self.square_generators[i].grid_anchors( + featmap_sizes[i], self.anchor_strides[i]) + multi_level_squares.append(squares) + squares_list = [multi_level_squares for _ in range(num_imgs)] + + # for each image, we compute multi level guided anchors + guided_anchors_list = [] + loc_mask_list = [] + for img_id, img_meta in enumerate(img_metas): + multi_level_guided_anchors = [] + multi_level_loc_mask = [] + for i in range(num_levels): + squares = squares_list[img_id][i] + shape_pred = shape_preds[i][img_id] + loc_pred = loc_preds[i][img_id] + guided_anchors, loc_mask = self.get_guided_anchors_single( + squares, + shape_pred, + loc_pred, + use_loc_filter=use_loc_filter) + multi_level_guided_anchors.append(guided_anchors) + multi_level_loc_mask.append(loc_mask) + guided_anchors_list.append(multi_level_guided_anchors) + loc_mask_list.append(multi_level_loc_mask) + return squares_list, guided_anchors_list, loc_mask_list + + def get_guided_anchors_single(self, + squares, + shape_pred, + loc_pred, + use_loc_filter=False): + """Get guided anchors and loc masks for a single level. + + Args: + square (tensor): Squares of a single level. + shape_pred (tensor): Shape predections of a single level. + loc_pred (tensor): Loc predections of a single level. + use_loc_filter (list[tensor]): Use loc filter or not. + + Returns: + tuple: guided anchors, location masks + """ + # calculate location filtering mask + loc_pred = loc_pred.sigmoid().detach() + if use_loc_filter: + loc_mask = loc_pred >= self.loc_filter_thr + else: + loc_mask = loc_pred >= 0.0 + mask = loc_mask.permute(1, 2, 0).expand(-1, -1, self.num_anchors) + mask = mask.contiguous().view(-1) + # calculate guided anchors + squares = squares[mask] + anchor_deltas = shape_pred.permute(1, 2, 0).contiguous().view( + -1, 2).detach()[mask] + bbox_deltas = anchor_deltas.new_full(squares.size(), 0) + bbox_deltas[:, 2:] = anchor_deltas + guided_anchors = delta2bbox( + squares, + bbox_deltas, + self.anchoring_means, + self.anchoring_stds, + wh_ratio_clip=1e-6) + return guided_anchors, mask + + def loss_shape_single(self, shape_pred, bbox_anchors, bbox_gts, + anchor_weights, anchor_total_num): + shape_pred = shape_pred.permute(0, 2, 3, 1).contiguous().view(-1, 2) + bbox_anchors = bbox_anchors.contiguous().view(-1, 4) + bbox_gts = bbox_gts.contiguous().view(-1, 4) + anchor_weights = anchor_weights.contiguous().view(-1, 4) + bbox_deltas = bbox_anchors.new_full(bbox_anchors.size(), 0) + bbox_deltas[:, 2:] += shape_pred + # filter out negative samples to speed-up weighted_bounded_iou_loss + inds = torch.nonzero(anchor_weights[:, 0] > 0).squeeze(1) + bbox_deltas_ = bbox_deltas[inds] + bbox_anchors_ = bbox_anchors[inds] + bbox_gts_ = bbox_gts[inds] + anchor_weights_ = anchor_weights[inds] + pred_anchors_ = delta2bbox( + bbox_anchors_, + bbox_deltas_, + self.anchoring_means, + self.anchoring_stds, + wh_ratio_clip=1e-6) + loss_shape = self.loss_shape( + pred_anchors_, + bbox_gts_, + anchor_weights_, + avg_factor=anchor_total_num) + return loss_shape + + def loss_loc_single(self, loc_pred, loc_target, loc_weight, loc_avg_factor, + cfg): + loss_loc = self.loss_loc( + loc_pred.reshape(-1, 1), + loc_target.reshape(-1, 1).long(), + loc_weight.reshape(-1, 1), + avg_factor=loc_avg_factor) + return loss_loc + + @force_fp32( + apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds')) + def loss(self, + cls_scores, + bbox_preds, + shape_preds, + loc_preds, + gt_bboxes, + gt_labels, + img_metas, + cfg, + gt_bboxes_ignore=None): + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + assert len(featmap_sizes) == len(self.approx_generators) + + # get loc targets + loc_targets, loc_weights, loc_avg_factor = ga_loc_target( + gt_bboxes, + featmap_sizes, + self.octave_base_scale, + self.anchor_strides, + center_ratio=cfg.center_ratio, + ignore_ratio=cfg.ignore_ratio) + + # get sampled approxes + approxs_list, inside_flag_list = self.get_sampled_approxs( + featmap_sizes, img_metas, cfg) + # get squares and guided anchors + squares_list, guided_anchors_list, _ = self.get_anchors( + featmap_sizes, shape_preds, loc_preds, img_metas) + + # get shape targets + sampling = False if not hasattr(cfg, 'ga_sampler') else True + shape_targets = ga_shape_target( + approxs_list, + inside_flag_list, + squares_list, + gt_bboxes, + img_metas, + self.approxs_per_octave, + cfg, + sampling=sampling) + if shape_targets is None: + return None + (bbox_anchors_list, bbox_gts_list, anchor_weights_list, anchor_fg_num, + anchor_bg_num) = shape_targets + anchor_total_num = ( + anchor_fg_num if not sampling else anchor_fg_num + anchor_bg_num) + + # get anchor targets + sampling = False if self.cls_focal_loss else True + label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1 + cls_reg_targets = anchor_target( + guided_anchors_list, + inside_flag_list, + gt_bboxes, + img_metas, + self.target_means, + self.target_stds, + cfg, + gt_bboxes_ignore_list=gt_bboxes_ignore, + gt_labels_list=gt_labels, + label_channels=label_channels, + sampling=sampling) + if cls_reg_targets is None: + return None + (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list, + num_total_pos, num_total_neg) = cls_reg_targets + num_total_samples = ( + num_total_pos if self.cls_focal_loss else num_total_pos + + num_total_neg) + + # get classification and bbox regression losses + losses_cls, losses_bbox = multi_apply( + self.loss_single, + cls_scores, + bbox_preds, + labels_list, + label_weights_list, + bbox_targets_list, + bbox_weights_list, + num_total_samples=num_total_samples, + cfg=cfg) + + # get anchor location loss + losses_loc = [] + for i in range(len(loc_preds)): + loss_loc = self.loss_loc_single( + loc_preds[i], + loc_targets[i], + loc_weights[i], + loc_avg_factor=loc_avg_factor, + cfg=cfg) + losses_loc.append(loss_loc) + + # get anchor shape loss + losses_shape = [] + for i in range(len(shape_preds)): + loss_shape = self.loss_shape_single( + shape_preds[i], + bbox_anchors_list[i], + bbox_gts_list[i], + anchor_weights_list[i], + anchor_total_num=anchor_total_num) + losses_shape.append(loss_shape) + + return dict( + loss_cls=losses_cls, + loss_bbox=losses_bbox, + loss_shape=losses_shape, + loss_loc=losses_loc) + + @force_fp32( + apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds')) + def get_bboxes(self, + cls_scores, + bbox_preds, + shape_preds, + loc_preds, + img_metas, + cfg, + rescale=False): + assert len(cls_scores) == len(bbox_preds) == len(shape_preds) == len( + loc_preds) + num_levels = len(cls_scores) + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + # get guided anchors + _, guided_anchors, loc_masks = self.get_anchors( + featmap_sizes, + shape_preds, + loc_preds, + img_metas, + use_loc_filter=not self.training) + result_list = [] + for img_id in range(len(img_metas)): + cls_score_list = [ + cls_scores[i][img_id].detach() for i in range(num_levels) + ] + bbox_pred_list = [ + bbox_preds[i][img_id].detach() for i in range(num_levels) + ] + guided_anchor_list = [ + guided_anchors[img_id][i].detach() for i in range(num_levels) + ] + loc_mask_list = [ + loc_masks[img_id][i].detach() for i in range(num_levels) + ] + img_shape = img_metas[img_id]['img_shape'] + scale_factor = img_metas[img_id]['scale_factor'] + proposals = self.get_bboxes_single(cls_score_list, bbox_pred_list, + guided_anchor_list, + loc_mask_list, img_shape, + scale_factor, cfg, rescale) + result_list.append(proposals) + return result_list + + def get_bboxes_single(self, + cls_scores, + bbox_preds, + mlvl_anchors, + mlvl_masks, + img_shape, + scale_factor, + cfg, + rescale=False): + assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors) + mlvl_bboxes = [] + mlvl_scores = [] + for cls_score, bbox_pred, anchors, mask in zip(cls_scores, bbox_preds, + mlvl_anchors, + mlvl_masks): + assert cls_score.size()[-2:] == bbox_pred.size()[-2:] + # if no location is kept, end. + if mask.sum() == 0: + continue + # reshape scores and bbox_pred + cls_score = cls_score.permute(1, 2, + 0).reshape(-1, self.cls_out_channels) + if self.use_sigmoid_cls: + scores = cls_score.sigmoid() + else: + scores = cls_score.softmax(-1) + bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4) + # filter scores, bbox_pred w.r.t. mask. + # anchors are filtered in get_anchors() beforehand. + scores = scores[mask, :] + bbox_pred = bbox_pred[mask, :] + if scores.dim() == 0: + anchors = anchors.unsqueeze(0) + scores = scores.unsqueeze(0) + bbox_pred = bbox_pred.unsqueeze(0) + # filter anchors, bbox_pred, scores w.r.t. scores + nms_pre = cfg.get('nms_pre', -1) + if nms_pre > 0 and scores.shape[0] > nms_pre: + if self.use_sigmoid_cls: + max_scores, _ = scores.max(dim=1) + else: + max_scores, _ = scores[:, 1:].max(dim=1) + _, topk_inds = max_scores.topk(nms_pre) + anchors = anchors[topk_inds, :] + bbox_pred = bbox_pred[topk_inds, :] + scores = scores[topk_inds, :] + bboxes = delta2bbox(anchors, bbox_pred, self.target_means, + self.target_stds, img_shape) + mlvl_bboxes.append(bboxes) + mlvl_scores.append(scores) + mlvl_bboxes = torch.cat(mlvl_bboxes) + if rescale: + mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor) + mlvl_scores = torch.cat(mlvl_scores) + if self.use_sigmoid_cls: + padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1) + mlvl_scores = torch.cat([padding, mlvl_scores], dim=1) + # multi class NMS + det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores, + cfg.score_thr, cfg.nms, + cfg.max_per_img) + return det_bboxes, det_labels diff --git a/mmdet/models/anchor_heads/ppdet_head.py b/mmdet/models/anchor_heads/ppdet_head.py new file mode 100644 index 0000000..b418051 --- /dev/null +++ b/mmdet/models/anchor_heads/ppdet_head.py @@ -0,0 +1,497 @@ +import torch +import torch.nn as nn +from mmcv.cnn import normal_init +from mmdet.ops import DeformConv +from mmdet.core import multi_apply, multiclass_nms +from ..builder import build_loss +from ..registry import HEADS +from ..utils import bias_init_with_prob, ConvModule +INF = 1e8 + + +class FeatureAlign(nn.Module): + """Feature Alignment Module. + + Feature Alignment Module is implemented based on DCN v1. + It uses anchor shape prediction rather than feature map to + predict offsets of deformable conv layer. + + Args: + in_channels (int): Number of channels in the input feature map. + out_channels (int): Number of channels in the output feature map. + kernel_size (int): Deformable conv kernel size. + deformable_groups (int): Deformable conv group size. + """ + + def __init__(self, + in_channels, + out_channels, + kernel_size=3, + deformable_groups=4): + super(FeatureAlign, self).__init__() + offset_channels = kernel_size * kernel_size * 2 + self.conv_offset = nn.Conv2d(4, + deformable_groups * offset_channels, + 1, + bias=False) + self.conv_adaption = DeformConv(in_channels, + out_channels, + kernel_size=kernel_size, + padding=(kernel_size - 1) // 2, + deformable_groups=deformable_groups) + self.relu = nn.ReLU(inplace=True) + + def init_weights(self): + normal_init(self.conv_offset, std=0.1) + normal_init(self.conv_adaption, std=0.01) + + def forward(self, x, shape): + offset = self.conv_offset(shape) + x = self.relu(self.conv_adaption(x, offset)) + return x + +@HEADS.register_module +class PPDetHead(nn.Module): + + def __init__(self, + num_classes, + in_channels, + feat_channels=256, + stacked_convs=4, + strides=(4, 8, 16, 32, 64), + base_edge_list=(16, 32, 64, 126, 256), + scale_ranges=((8, 32), (16, 64), (32, 128), (64, 256), (128, 512)), + sigma = 0.4, + with_deform=False, + deformable_groups=4, + loss_cls=None, + loss_bbox=None, + conv_cfg=None, + norm_cfg=None): + super(PPDetHead, self).__init__() + self.num_classes = num_classes + self.cls_out_channels = num_classes - 1 + self.in_channels = in_channels + self.feat_channels = feat_channels + self.stacked_convs = stacked_convs + self.strides = strides + self.base_edge_list = base_edge_list + self.scale_ranges = scale_ranges + self.sigma = sigma + self.with_deform = with_deform + self.deformable_groups = deformable_groups + self.loss_cls = build_loss(loss_cls) + self.loss_bbox = build_loss(loss_bbox) + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self._init_layers() + + def _init_layers(self): + self.cls_convs = nn.ModuleList() + self.reg_convs = nn.ModuleList() + # box branch + for i in range(self.stacked_convs): + chn = self.in_channels if i == 0 else self.feat_channels + self.reg_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + bias=self.norm_cfg is None)) + self.ppdet_reg = nn.Conv2d(self.feat_channels, 4, 3, padding=1) + # cls branch + if not self.with_deform: + for i in range(self.stacked_convs): + chn = self.in_channels if i == 0 else self.feat_channels + self.cls_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + bias=self.norm_cfg is None)) + self.ppdet_cls = nn.Conv2d( + self.feat_channels, self.cls_out_channels, 3, padding=1) + else: + self.cls_convs.append( + ConvModule( + self.feat_channels, + (self.feat_channels * 4), + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + bias=self.norm_cfg is None)) + + self.cls_convs.append( + ConvModule( + (self.feat_channels * 4), + (self.feat_channels * 4), + 1, + stride=1, + padding=0, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + bias=self.norm_cfg is None)) + + self.feature_adaption = FeatureAlign( + self.feat_channels, + self.feat_channels, + kernel_size=3, + deformable_groups=self.deformable_groups) + + self.ppdet_cls = nn.Conv2d( + int(self.feat_channels * 4), self.cls_out_channels, 3, padding=1) + + def init_weights(self): + for m in self.cls_convs: + normal_init(m.conv, std=0.01) + for m in self.reg_convs: + normal_init(m.conv, std=0.01) + bias_cls = bias_init_with_prob(0.01) + normal_init(self.ppdet_cls, std=0.01, bias=bias_cls) + normal_init(self.ppdet_reg, std=0.01) + if self.with_deform: + self.feature_adaption.init_weights() + + def forward(self, feats): + return multi_apply(self.forward_single, feats) + + def forward_single(self, x): + cls_feat = x + reg_feat = x + for reg_layer in self.reg_convs: + reg_feat = reg_layer(reg_feat) + bbox_pred = self.ppdet_reg(reg_feat) + if self.with_deform: + cls_feat = self.feature_adaption(cls_feat, bbox_pred.exp()) + for cls_layer in self.cls_convs: + cls_feat = cls_layer(cls_feat) + cls_score = self.ppdet_cls(cls_feat) + return cls_score, bbox_pred + + def get_points(self, featmap_sizes, dtype, device, flatten=False): + points = [] + for featmap_size in featmap_sizes: + x_range = torch.arange(featmap_size[1], dtype=dtype, device=device) + 0.5 + y_range = torch.arange(featmap_size[0], dtype=dtype, device=device) + 0.5 + y, x = torch.meshgrid(y_range, x_range) + if flatten: + points.append((y.flatten(), x.flatten())) + else: + points.append((y, x)) + + return points + + def loss(self, + cls_scores, + bbox_preds, + gt_bbox_list, + gt_label_list, + img_metas, + cfg, + gt_bboxes_ignore=None): + assert len(cls_scores) == len(bbox_preds) + featmap_sizes = [featmap.size()[-2:] for featmap in + cls_scores] + points = self.get_points(featmap_sizes, bbox_preds[0].dtype, + bbox_preds[0].device) + + + all_gt_label_list = torch.cat([x for x in gt_label_list]) + temp = torch.tensor(0).cuda() + label_size_list = [] + for x in gt_label_list: + label_size_list.append(temp) + temp = torch.tensor(x.size()).cuda() + label_size_list[-1] + + label_list, bbox_target_list, gt_ids_list = multi_apply( + self.ppdet_target_single, + gt_bbox_list, + gt_label_list, + label_size_list, + featmap_size_list=featmap_sizes, + point_list=points) + + flatten_labels = [ + torch.cat([labels_level_img.flatten() + for labels_level_img in labels_level]) + for labels_level in zip(*label_list) + ] + flatten_bbox_targets = [ + torch.cat([bbox_targets_level_img.reshape(-1, 4) + for bbox_targets_level_img in bbox_targets_level]) + for bbox_targets_level in zip(*bbox_target_list) + ] + flatten_ids = [ + torch.cat([gt_ids_level_img.flatten() + for gt_ids_level_img in gt_ids_level]) + for gt_ids_level in zip(*gt_ids_list) + ] + + flatten_labels = torch.cat(flatten_labels) + flatten_bbox_targets = torch.cat(flatten_bbox_targets) + flatten_ids = torch.cat(flatten_ids) + num_imgs = cls_scores[0].size(0) + flatten_cls_scores = [ + cls_score.permute(0, 2, 3, 1).reshape(-1, self.cls_out_channels) + for cls_score in cls_scores + ] + flatten_bbox_preds = [ + bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4) + for bbox_pred in bbox_preds + ] + flatten_cls_scores = torch.cat(flatten_cls_scores) + flatten_bbox_preds = torch.cat(flatten_bbox_preds) + pos_inds = (flatten_labels > 0).nonzero().view(-1) + num_pos = len(pos_inds) + + + neg_inds = (flatten_labels <= 0).nonzero().view(-1) + agg_labels = flatten_labels[neg_inds] + agg_cls_scores = flatten_cls_scores[neg_inds] + num_agg_pos = 0 + + for i, class_id in enumerate(all_gt_label_list): + + aggregation_indices = (flatten_ids == i).nonzero() + + if flatten_labels[aggregation_indices].size()[0] != 0: + agg_labels = torch.cat((all_gt_label_list[i:i+1], agg_labels)) + agg_cls_scores = torch.cat((flatten_cls_scores[aggregation_indices].mean(dim=0), agg_cls_scores)) + num_agg_pos +=1 + + loss_cls = self.loss_cls(agg_cls_scores, agg_labels, avg_factor=num_agg_pos + num_imgs) + + if num_pos > 0: + pos_bbox_preds = flatten_bbox_preds[pos_inds] + pos_bbox_targets = flatten_bbox_targets[pos_inds] + pos_weights = pos_bbox_targets.new_zeros(pos_bbox_targets.size())+1.0 + loss_bbox = self.loss_bbox(pos_bbox_preds, + pos_bbox_targets, pos_weights, avg_factor = num_pos) + else: + loss_bbox = torch.tensor([0], dtype=flatten_bbox_preds.dtype, device=flatten_bbox_preds.device) + return dict( + loss_cls=loss_cls, + loss_bbox=loss_bbox) + + def ppdet_target_single(self, + gt_bboxes_raw, + gt_labels_raw, + label_size_list_raw, + featmap_size_list=None, + point_list=None): + + gt_areas = torch.sqrt((gt_bboxes_raw[:, 2] - gt_bboxes_raw[:, 0]) * ( + gt_bboxes_raw[:, 3] - gt_bboxes_raw[:, 1])) + label_list = [] + bbox_target_list = [] + ids_list = [] + for base_len, (lower_bound, upper_bound), stride, featmap_size, (y, x) \ + in zip(self.base_edge_list, self.scale_ranges, self.strides, featmap_size_list, point_list): + labels = gt_labels_raw.new_zeros(featmap_size) + bbox_targets = gt_bboxes_raw.new(featmap_size[0], featmap_size[1], 4) + 1 + gt_ids = gt_labels_raw.new_zeros(featmap_size) - 1 + hit_indices = ((gt_areas >= lower_bound) & (gt_areas <= upper_bound)).nonzero().flatten() + if len(hit_indices) == 0: + label_list.append(labels) + bbox_target_list.append(torch.log(bbox_targets)) + ids_list.append(gt_ids) + continue + + _, hit_index_order = torch.sort(-gt_areas[hit_indices]) + hit_indices = hit_indices[hit_index_order] + gt_bboxes = gt_bboxes_raw[hit_indices, :] / stride + gt_labels = gt_labels_raw[hit_indices] + half_w = 0.5 * (gt_bboxes[:, 2] - gt_bboxes[:, 0]) + half_h = 0.5 * (gt_bboxes[:, 3] - gt_bboxes[:, 1]) + pos_left = torch.ceil(gt_bboxes[:, 0] + (1 - self.sigma) * half_w - 0.5).long().\ + clamp(0, featmap_size[1] - 1) + pos_right = torch.floor(gt_bboxes[:, 0] + (1 + self.sigma) * half_w - 0.5).long().\ + clamp(0, featmap_size[1] - 1) + pos_top = torch.ceil(gt_bboxes[:, 1] + (1 - self.sigma) * half_h - 0.5).long().\ + clamp(0, featmap_size[0] - 1) + pos_down = torch.floor(gt_bboxes[:, 1] + (1 + self.sigma) * half_h - 0.5).long().\ + clamp(0, featmap_size[0] - 1) + for px1, py1, px2, py2, label, gt_id, (gt_x1, gt_y1, gt_x2, gt_y2) in \ + zip(pos_left, pos_top, pos_right, pos_down, gt_labels, hit_indices, + gt_bboxes_raw[hit_indices, :]): + labels[py1:py2 + 1, px1:px2 + 1] = label + gt_ids[py1:py2 + 1, px1:px2 + 1] = gt_id + label_size_list_raw + bbox_targets[py1:py2 + 1, px1:px2 + 1, 0] = (stride * x[py1:py2 + 1, px1:px2 + 1] - gt_x1) / base_len + bbox_targets[py1:py2 + 1, px1:px2 + 1, 1] = (stride * y[py1:py2 + 1, px1:px2 + 1] - gt_y1) / base_len + bbox_targets[py1:py2 + 1, px1:px2 + 1, 2] = (gt_x2 - stride * x[py1:py2 + 1, px1:px2 + 1]) / base_len + bbox_targets[py1:py2 + 1, px1:px2 + 1, 3] = (gt_y2 - stride * y[py1:py2 + 1, px1:px2 + 1]) / base_len + bbox_targets = bbox_targets.clamp(min=1./16, max=16.) + label_list.append(labels) + bbox_target_list.append(torch.log(bbox_targets)) + ids_list.append(gt_ids) + return label_list, bbox_target_list, ids_list + + def get_bboxes(self, + cls_scores, + bbox_preds, + img_metas, + cfg, + rescale=None): + assert len(cls_scores) == len(bbox_preds) + num_levels = len(cls_scores) + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + points = self.get_points(featmap_sizes, bbox_preds[0].dtype, + bbox_preds[0].device, flatten=True) + result_list = [] + for img_id in range(len(img_metas)): + cls_score_list = [ + cls_scores[i][img_id].detach() for i in range(num_levels) + ] + bbox_pred_list = [ + bbox_preds[i][img_id].detach() for i in range(num_levels) + ] + img_shape = img_metas[img_id]['img_shape'] + scale_factor = img_metas[img_id]['scale_factor'] + det_bboxes = self.get_bboxes_single(cls_score_list, bbox_pred_list, featmap_sizes, points, + img_shape, scale_factor, cfg, rescale) + result_list.append(det_bboxes) + return result_list + + def get_bboxes_aug(self, + cls_scores, + bbox_preds, + img_metas, + cfg, + rescale=None): + assert len(cls_scores) == len(bbox_preds) + num_levels = len(cls_scores) + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + points = self.get_points(featmap_sizes, bbox_preds[0].dtype, + bbox_preds[0].device, flatten=True) + result_list = [] + for img_id in range(len(img_metas)): + cls_score_list = [ + cls_scores[i][img_id].detach() for i in range(num_levels) + ] + bbox_pred_list = [ + bbox_preds[i][img_id].detach() for i in range(num_levels) + ] + img_shape = img_metas[img_id]['img_shape'] + scale_factor = img_metas[img_id]['scale_factor'] + det_bboxes = self.get_bboxes_single_aug(cls_score_list, bbox_pred_list, featmap_sizes, points, + img_shape, scale_factor, cfg, rescale) + result_list.append(det_bboxes) + + return result_list + + def get_bboxes_single_aug(self, + cls_scores, + bbox_preds, + featmap_sizes, + point_list, + img_shape, + scale_factor, + cfg, + rescale=False, debug=False): + assert len(cls_scores) == len(bbox_preds) == len(point_list) + det_bboxes = [] + det_scores = [] + for cls_score, bbox_pred, featmap_size, stride, base_len, (y, x) in zip( + cls_scores, bbox_preds, featmap_sizes, self.strides, self.base_edge_list, point_list): + + assert cls_score.size()[-2:] == bbox_pred.size()[-2:] + scores = cls_score.permute(1, 2, 0).reshape( + -1, self.cls_out_channels).sigmoid() + bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4).exp() + nms_pre = cfg.get('nms_pre', -1) + if nms_pre > 0 and scores.shape[0] > nms_pre: + max_scores, _ = scores.max(dim=1) + _, topk_inds = max_scores.topk(nms_pre) + bbox_pred = bbox_pred[topk_inds, :] + scores = scores[topk_inds, :] + y = y[topk_inds] + x = x[topk_inds] + x1 = (stride * x - base_len * bbox_pred[:, 0]).clamp(min=0, max=img_shape[1] - 1) + y1 = (stride * y - base_len * bbox_pred[:, 1]).clamp(min=0, max=img_shape[0] - 1) + x2 = (stride * x + base_len * bbox_pred[:, 2]).clamp(min=0, max=img_shape[1] - 1) + y2 = (stride * y + base_len * bbox_pred[:, 3]).clamp(min=0, max=img_shape[0] - 1) + bboxes = torch.stack([x1, y1, x2, y2], -1) + det_bboxes.append(bboxes) + det_scores.append(scores) + + det_bboxes = torch.cat(det_bboxes) + + if rescale: + det_bboxes /= det_bboxes.new_tensor(scale_factor) + + det_scores = torch.cat(det_scores) + padding = det_scores.new_zeros(det_scores.shape[0], 1) + det_scores = torch.cat([padding, det_scores], dim=1) + + return det_bboxes, det_scores + + + def get_bboxes_single(self, + cls_scores, + bbox_preds, + featmap_sizes, + point_list, + img_shape, + scale_factor, + cfg, + rescale=False, debug=False): + assert len(cls_scores) == len(bbox_preds) == len(point_list) + det_bboxes = [] + det_scores = [] + for cls_score, bbox_pred, featmap_size, stride, base_len, (y, x) in zip( + cls_scores, bbox_preds, featmap_sizes, self.strides, self.base_edge_list, point_list): + + assert cls_score.size()[-2:] == bbox_pred.size()[-2:] + scores = cls_score.permute(1, 2, 0).reshape( + -1, self.cls_out_channels).sigmoid() + bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4).exp() + nms_pre = cfg.get('nms_pre', -1) + if nms_pre > 0 and scores.shape[0] > nms_pre: + max_scores, _ = scores.max(dim=1) + _, topk_inds = max_scores.topk(nms_pre) + bbox_pred = bbox_pred[topk_inds, :] + scores = scores[topk_inds, :] + y = y[topk_inds] + x = x[topk_inds] + x1 = (stride * x - base_len * bbox_pred[:, 0]).clamp(min=0, max=img_shape[1] - 1) + y1 = (stride * y - base_len * bbox_pred[:, 1]).clamp(min=0, max=img_shape[0] - 1) + x2 = (stride * x + base_len * bbox_pred[:, 2]).clamp(min=0, max=img_shape[1] - 1) + y2 = (stride * y + base_len * bbox_pred[:, 3]).clamp(min=0, max=img_shape[0] - 1) + bboxes = torch.stack([x1, y1, x2, y2], -1) + det_bboxes.append(bboxes) + det_scores.append(scores) + det_bboxes = torch.cat(det_bboxes) + if rescale: + det_bboxes /= det_bboxes.new_tensor(scale_factor) + det_scores = torch.cat(det_scores) + padding = det_scores.new_zeros(det_scores.shape[0], 1) + det_scores = torch.cat([padding, det_scores], dim=1) + if debug: + det_bboxes, det_labels = multiclass_nms( + det_bboxes, + det_scores, + cfg['k'], + cfg['agg_thr'], + cfg['score_thr'], + cfg['nms'], + cfg['max_per_img']) + else: + det_bboxes, det_labels = multiclass_nms( + det_bboxes, + det_scores, + cfg.score_thr, + cfg.k, + cfg.agg_thr, + cfg.nms, + cfg.max_per_img) + return det_bboxes, det_labels diff --git a/mmdet/models/anchor_heads/retina_head.py b/mmdet/models/anchor_heads/retina_head.py new file mode 100644 index 0000000..045db70 --- /dev/null +++ b/mmdet/models/anchor_heads/retina_head.py @@ -0,0 +1,83 @@ +import numpy as np +import torch.nn as nn +from mmcv.cnn import normal_init + +from ..registry import HEADS +from ..utils import ConvModule, bias_init_with_prob +from .anchor_head import AnchorHead + + +@HEADS.register_module +class RetinaHead(AnchorHead): + + def __init__(self, + num_classes, + in_channels, + stacked_convs=4, + octave_base_scale=4, + scales_per_octave=3, + conv_cfg=None, + norm_cfg=None, + **kwargs): + self.stacked_convs = stacked_convs + self.octave_base_scale = octave_base_scale + self.scales_per_octave = scales_per_octave + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + octave_scales = np.array( + [2**(i / scales_per_octave) for i in range(scales_per_octave)]) + anchor_scales = octave_scales * octave_base_scale + super(RetinaHead, self).__init__( + num_classes, in_channels, anchor_scales=anchor_scales, **kwargs) + + def _init_layers(self): + self.relu = nn.ReLU(inplace=True) + self.cls_convs = nn.ModuleList() + self.reg_convs = nn.ModuleList() + for i in range(self.stacked_convs): + chn = self.in_channels if i == 0 else self.feat_channels + self.cls_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg)) + self.reg_convs.append( + ConvModule( + chn, + self.feat_channels, + 3, + stride=1, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg)) + self.retina_cls = nn.Conv2d( + self.feat_channels, + self.num_anchors * self.cls_out_channels, + 3, + padding=1) + self.retina_reg = nn.Conv2d( + self.feat_channels, self.num_anchors * 4, 3, padding=1) + + def init_weights(self): + for m in self.cls_convs: + normal_init(m.conv, std=0.01) + for m in self.reg_convs: + normal_init(m.conv, std=0.01) + bias_cls = bias_init_with_prob(0.01) + normal_init(self.retina_cls, std=0.01, bias=bias_cls) + normal_init(self.retina_reg, std=0.01) + + def forward_single(self, x): + cls_feat = x + reg_feat = x + 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 diff --git a/mmdet/models/anchor_heads/rpn_head.py b/mmdet/models/anchor_heads/rpn_head.py new file mode 100644 index 0000000..50f1cc5 --- /dev/null +++ b/mmdet/models/anchor_heads/rpn_head.py @@ -0,0 +1,104 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import normal_init + +from mmdet.core import delta2bbox +from mmdet.ops import nms +from ..registry import HEADS +from .anchor_head import AnchorHead + + +@HEADS.register_module +class RPNHead(AnchorHead): + + def __init__(self, in_channels, **kwargs): + super(RPNHead, self).__init__(2, in_channels, **kwargs) + + def _init_layers(self): + self.rpn_conv = nn.Conv2d( + self.in_channels, self.feat_channels, 3, padding=1) + self.rpn_cls = nn.Conv2d(self.feat_channels, + self.num_anchors * self.cls_out_channels, 1) + self.rpn_reg = nn.Conv2d(self.feat_channels, self.num_anchors * 4, 1) + + def init_weights(self): + normal_init(self.rpn_conv, std=0.01) + normal_init(self.rpn_cls, std=0.01) + normal_init(self.rpn_reg, std=0.01) + + def forward_single(self, x): + x = self.rpn_conv(x) + x = F.relu(x, inplace=True) + rpn_cls_score = self.rpn_cls(x) + rpn_bbox_pred = self.rpn_reg(x) + return rpn_cls_score, rpn_bbox_pred + + def loss(self, + cls_scores, + bbox_preds, + gt_bboxes, + img_metas, + cfg, + gt_bboxes_ignore=None): + losses = super(RPNHead, self).loss( + cls_scores, + bbox_preds, + gt_bboxes, + None, + img_metas, + cfg, + gt_bboxes_ignore=gt_bboxes_ignore) + return dict( + loss_rpn_cls=losses['loss_cls'], loss_rpn_bbox=losses['loss_bbox']) + + def get_bboxes_single(self, + cls_scores, + bbox_preds, + mlvl_anchors, + img_shape, + scale_factor, + cfg, + rescale=False): + mlvl_proposals = [] + for idx in range(len(cls_scores)): + rpn_cls_score = cls_scores[idx] + rpn_bbox_pred = bbox_preds[idx] + assert rpn_cls_score.size()[-2:] == rpn_bbox_pred.size()[-2:] + anchors = mlvl_anchors[idx] + rpn_cls_score = rpn_cls_score.permute(1, 2, 0) + if self.use_sigmoid_cls: + rpn_cls_score = rpn_cls_score.reshape(-1) + scores = rpn_cls_score.sigmoid() + else: + rpn_cls_score = rpn_cls_score.reshape(-1, 2) + scores = rpn_cls_score.softmax(dim=1)[:, 1] + rpn_bbox_pred = rpn_bbox_pred.permute(1, 2, 0).reshape(-1, 4) + if cfg.nms_pre > 0 and scores.shape[0] > cfg.nms_pre: + _, topk_inds = scores.topk(cfg.nms_pre) + rpn_bbox_pred = rpn_bbox_pred[topk_inds, :] + anchors = anchors[topk_inds, :] + scores = scores[topk_inds] + proposals = delta2bbox(anchors, rpn_bbox_pred, self.target_means, + self.target_stds, img_shape) + if cfg.min_bbox_size > 0: + w = proposals[:, 2] - proposals[:, 0] + 1 + h = proposals[:, 3] - proposals[:, 1] + 1 + valid_inds = torch.nonzero((w >= cfg.min_bbox_size) & + (h >= cfg.min_bbox_size)).squeeze() + proposals = proposals[valid_inds, :] + scores = scores[valid_inds] + proposals = torch.cat([proposals, scores.unsqueeze(-1)], dim=-1) + proposals, _ = nms(proposals, cfg.nms_thr) + proposals = proposals[:cfg.nms_post, :] + mlvl_proposals.append(proposals) + proposals = torch.cat(mlvl_proposals, 0) + if cfg.nms_across_levels: + proposals, _ = nms(proposals, cfg.nms_thr) + proposals = proposals[:cfg.max_num, :] + else: + scores = proposals[:, 4] + num = min(cfg.max_num, proposals.shape[0]) + _, topk_inds = scores.topk(num) + proposals = proposals[topk_inds, :] + return proposals diff --git a/mmdet/models/anchor_heads/ssd_head.py b/mmdet/models/anchor_heads/ssd_head.py new file mode 100644 index 0000000..600dd4a --- /dev/null +++ b/mmdet/models/anchor_heads/ssd_head.py @@ -0,0 +1,193 @@ +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import xavier_init + +from mmdet.core import AnchorGenerator, anchor_target, multi_apply +from ..losses import smooth_l1_loss +from ..registry import HEADS +from .anchor_head import AnchorHead + + +# TODO: add loss evaluator for SSD +@HEADS.register_module +class SSDHead(AnchorHead): + + def __init__(self, + input_size=300, + num_classes=81, + in_channels=(512, 1024, 512, 256, 256, 256), + anchor_strides=(8, 16, 32, 64, 100, 300), + basesize_ratio_range=(0.1, 0.9), + anchor_ratios=([2], [2, 3], [2, 3], [2, 3], [2], [2]), + target_means=(.0, .0, .0, .0), + target_stds=(1.0, 1.0, 1.0, 1.0)): + super(AnchorHead, self).__init__() + self.input_size = input_size + self.num_classes = num_classes + self.in_channels = in_channels + self.cls_out_channels = num_classes + num_anchors = [len(ratios) * 2 + 2 for ratios in anchor_ratios] + reg_convs = [] + cls_convs = [] + for i in range(len(in_channels)): + reg_convs.append( + nn.Conv2d( + in_channels[i], + num_anchors[i] * 4, + kernel_size=3, + padding=1)) + cls_convs.append( + nn.Conv2d( + in_channels[i], + num_anchors[i] * num_classes, + kernel_size=3, + padding=1)) + self.reg_convs = nn.ModuleList(reg_convs) + self.cls_convs = nn.ModuleList(cls_convs) + + min_ratio, max_ratio = basesize_ratio_range + min_ratio = int(min_ratio * 100) + max_ratio = int(max_ratio * 100) + step = int(np.floor(max_ratio - min_ratio) / (len(in_channels) - 2)) + min_sizes = [] + max_sizes = [] + for r in range(int(min_ratio), int(max_ratio) + 1, step): + min_sizes.append(int(input_size * r / 100)) + max_sizes.append(int(input_size * (r + step) / 100)) + if input_size == 300: + if basesize_ratio_range[0] == 0.15: # SSD300 COCO + min_sizes.insert(0, int(input_size * 7 / 100)) + max_sizes.insert(0, int(input_size * 15 / 100)) + elif basesize_ratio_range[0] == 0.2: # SSD300 VOC + min_sizes.insert(0, int(input_size * 10 / 100)) + max_sizes.insert(0, int(input_size * 20 / 100)) + elif input_size == 512: + if basesize_ratio_range[0] == 0.1: # SSD512 COCO + min_sizes.insert(0, int(input_size * 4 / 100)) + max_sizes.insert(0, int(input_size * 10 / 100)) + elif basesize_ratio_range[0] == 0.15: # SSD512 VOC + min_sizes.insert(0, int(input_size * 7 / 100)) + max_sizes.insert(0, int(input_size * 15 / 100)) + self.anchor_generators = [] + self.anchor_strides = anchor_strides + for k in range(len(anchor_strides)): + base_size = min_sizes[k] + stride = anchor_strides[k] + ctr = ((stride - 1) / 2., (stride - 1) / 2.) + scales = [1., np.sqrt(max_sizes[k] / min_sizes[k])] + ratios = [1.] + for r in anchor_ratios[k]: + ratios += [1 / r, r] # 4 or 6 ratio + anchor_generator = AnchorGenerator( + base_size, scales, ratios, scale_major=False, ctr=ctr) + indices = list(range(len(ratios))) + indices.insert(1, len(indices)) + anchor_generator.base_anchors = torch.index_select( + anchor_generator.base_anchors, 0, torch.LongTensor(indices)) + self.anchor_generators.append(anchor_generator) + + self.target_means = target_means + self.target_stds = target_stds + self.use_sigmoid_cls = False + self.cls_focal_loss = False + self.fp16_enabled = False + + def init_weights(self): + for m in self.modules(): + if isinstance(m, nn.Conv2d): + xavier_init(m, distribution='uniform', bias=0) + + def forward(self, feats): + cls_scores = [] + bbox_preds = [] + for feat, reg_conv, cls_conv in zip(feats, self.reg_convs, + self.cls_convs): + cls_scores.append(cls_conv(feat)) + bbox_preds.append(reg_conv(feat)) + return cls_scores, bbox_preds + + def loss_single(self, cls_score, bbox_pred, labels, label_weights, + bbox_targets, bbox_weights, num_total_samples, cfg): + loss_cls_all = F.cross_entropy( + cls_score, labels, reduction='none') * label_weights + pos_inds = (labels > 0).nonzero().view(-1) + neg_inds = (labels == 0).nonzero().view(-1) + + num_pos_samples = pos_inds.size(0) + num_neg_samples = cfg.neg_pos_ratio * num_pos_samples + if num_neg_samples > neg_inds.size(0): + num_neg_samples = neg_inds.size(0) + topk_loss_cls_neg, _ = loss_cls_all[neg_inds].topk(num_neg_samples) + loss_cls_pos = loss_cls_all[pos_inds].sum() + loss_cls_neg = topk_loss_cls_neg.sum() + loss_cls = (loss_cls_pos + loss_cls_neg) / num_total_samples + + loss_bbox = smooth_l1_loss( + bbox_pred, + bbox_targets, + bbox_weights, + beta=cfg.smoothl1_beta, + avg_factor=num_total_samples) + return loss_cls[None], loss_bbox + + def loss(self, + cls_scores, + bbox_preds, + gt_bboxes, + gt_labels, + img_metas, + cfg, + gt_bboxes_ignore=None): + featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores] + assert len(featmap_sizes) == len(self.anchor_generators) + + anchor_list, valid_flag_list = self.get_anchors( + featmap_sizes, img_metas) + cls_reg_targets = anchor_target( + anchor_list, + valid_flag_list, + gt_bboxes, + img_metas, + self.target_means, + self.target_stds, + cfg, + gt_bboxes_ignore_list=gt_bboxes_ignore, + gt_labels_list=gt_labels, + label_channels=1, + sampling=False, + unmap_outputs=False) + if cls_reg_targets is None: + return None + (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list, + num_total_pos, num_total_neg) = cls_reg_targets + + num_images = len(img_metas) + all_cls_scores = torch.cat([ + s.permute(0, 2, 3, 1).reshape( + num_images, -1, self.cls_out_channels) for s in cls_scores + ], 1) + all_labels = torch.cat(labels_list, -1).view(num_images, -1) + all_label_weights = torch.cat(label_weights_list, + -1).view(num_images, -1) + all_bbox_preds = torch.cat([ + b.permute(0, 2, 3, 1).reshape(num_images, -1, 4) + for b in bbox_preds + ], -2) + all_bbox_targets = torch.cat(bbox_targets_list, + -2).view(num_images, -1, 4) + all_bbox_weights = torch.cat(bbox_weights_list, + -2).view(num_images, -1, 4) + + losses_cls, losses_bbox = multi_apply( + self.loss_single, + all_cls_scores, + all_bbox_preds, + all_labels, + all_label_weights, + all_bbox_targets, + all_bbox_weights, + num_total_samples=num_total_pos, + cfg=cfg) + return dict(loss_cls=losses_cls, loss_bbox=losses_bbox) diff --git a/mmdet/models/backbones/__init__.py b/mmdet/models/backbones/__init__.py new file mode 100644 index 0000000..6fb56d6 --- /dev/null +++ b/mmdet/models/backbones/__init__.py @@ -0,0 +1,6 @@ +from .hrnet import HRNet +from .resnet import ResNet, make_res_layer +from .resnext import ResNeXt +from .ssd_vgg import SSDVGG + +__all__ = ['ResNet', 'make_res_layer', 'ResNeXt', 'SSDVGG', 'HRNet'] diff --git a/mmdet/models/backbones/hrnet.py b/mmdet/models/backbones/hrnet.py new file mode 100644 index 0000000..9c942d6 --- /dev/null +++ b/mmdet/models/backbones/hrnet.py @@ -0,0 +1,484 @@ +import logging + +import torch.nn as nn +from mmcv.cnn import constant_init, kaiming_init +from mmcv.runner import load_checkpoint +from torch.nn.modules.batchnorm import _BatchNorm + +from ..registry import BACKBONES +from ..utils import build_conv_layer, build_norm_layer +from .resnet import BasicBlock, Bottleneck + + +class HRModule(nn.Module): + """ High-Resolution Module for HRNet. In this module, every branch + has 4 BasicBlocks/Bottlenecks. Fusion/Exchange is in this module. + """ + + def __init__(self, + num_branches, + blocks, + num_blocks, + in_channels, + num_channels, + multiscale_output=True, + with_cp=False, + conv_cfg=None, + norm_cfg=dict(type='BN')): + super(HRModule, self).__init__() + self._check_branches(num_branches, num_blocks, in_channels, + num_channels) + + self.in_channels = in_channels + self.num_branches = num_branches + + self.multiscale_output = multiscale_output + self.norm_cfg = norm_cfg + self.conv_cfg = conv_cfg + self.with_cp = with_cp + self.branches = self._make_branches(num_branches, blocks, num_blocks, + num_channels) + self.fuse_layers = self._make_fuse_layers() + self.relu = nn.ReLU(inplace=False) + + def _check_branches(self, num_branches, num_blocks, in_channels, + num_channels): + if num_branches != len(num_blocks): + error_msg = 'NUM_BRANCHES({}) <> NUM_BLOCKS({})'.format( + num_branches, len(num_blocks)) + raise ValueError(error_msg) + + if num_branches != len(num_channels): + error_msg = 'NUM_BRANCHES({}) <> NUM_CHANNELS({})'.format( + num_branches, len(num_channels)) + raise ValueError(error_msg) + + if num_branches != len(in_channels): + error_msg = 'NUM_BRANCHES({}) <> NUM_INCHANNELS({})'.format( + num_branches, len(in_channels)) + raise ValueError(error_msg) + + def _make_one_branch(self, + branch_index, + block, + num_blocks, + num_channels, + stride=1): + downsample = None + if stride != 1 or \ + self.in_channels[branch_index] != \ + num_channels[branch_index] * block.expansion: + downsample = nn.Sequential( + build_conv_layer( + self.conv_cfg, + self.in_channels[branch_index], + num_channels[branch_index] * block.expansion, + kernel_size=1, + stride=stride, + bias=False), + build_norm_layer(self.norm_cfg, num_channels[branch_index] * + block.expansion)[1]) + + layers = [] + layers.append( + block( + self.in_channels[branch_index], + num_channels[branch_index], + stride, + downsample=downsample, + with_cp=self.with_cp, + norm_cfg=self.norm_cfg, + conv_cfg=self.conv_cfg)) + self.in_channels[branch_index] = \ + num_channels[branch_index] * block.expansion + for i in range(1, num_blocks[branch_index]): + layers.append( + block( + self.in_channels[branch_index], + num_channels[branch_index], + with_cp=self.with_cp, + norm_cfg=self.norm_cfg, + conv_cfg=self.conv_cfg)) + + return nn.Sequential(*layers) + + def _make_branches(self, num_branches, block, num_blocks, num_channels): + branches = [] + + for i in range(num_branches): + branches.append( + self._make_one_branch(i, block, num_blocks, num_channels)) + + return nn.ModuleList(branches) + + def _make_fuse_layers(self): + if self.num_branches == 1: + return None + + num_branches = self.num_branches + in_channels = self.in_channels + fuse_layers = [] + num_out_branches = num_branches if self.multiscale_output else 1 + for i in range(num_out_branches): + fuse_layer = [] + for j in range(num_branches): + if j > i: + fuse_layer.append( + nn.Sequential( + build_conv_layer( + self.conv_cfg, + in_channels[j], + in_channels[i], + kernel_size=1, + stride=1, + padding=0, + bias=False), + build_norm_layer(self.norm_cfg, in_channels[i])[1], + nn.Upsample( + scale_factor=2**(j - i), mode='nearest'))) + elif j == i: + fuse_layer.append(None) + else: + conv_downsamples = [] + for k in range(i - j): + if k == i - j - 1: + conv_downsamples.append( + nn.Sequential( + build_conv_layer( + self.conv_cfg, + in_channels[j], + in_channels[i], + kernel_size=3, + stride=2, + padding=1, + bias=False), + build_norm_layer(self.norm_cfg, + in_channels[i])[1])) + else: + conv_downsamples.append( + nn.Sequential( + build_conv_layer( + self.conv_cfg, + in_channels[j], + in_channels[j], + kernel_size=3, + stride=2, + padding=1, + bias=False), + build_norm_layer(self.norm_cfg, + in_channels[j])[1], + nn.ReLU(inplace=False))) + fuse_layer.append(nn.Sequential(*conv_downsamples)) + fuse_layers.append(nn.ModuleList(fuse_layer)) + + return nn.ModuleList(fuse_layers) + + def forward(self, x): + if self.num_branches == 1: + return [self.branches[0](x[0])] + + for i in range(self.num_branches): + x[i] = self.branches[i](x[i]) + + x_fuse = [] + for i in range(len(self.fuse_layers)): + y = 0 + for j in range(self.num_branches): + if i == j: + y += x[j] + else: + y += self.fuse_layers[i][j](x[j]) + x_fuse.append(self.relu(y)) + return x_fuse + + +@BACKBONES.register_module +class HRNet(nn.Module): + """HRNet backbone. + + High-Resolution Representations for Labeling Pixels and Regions + arXiv: https://arxiv.org/abs/1904.04514 + + Args: + extra (dict): detailed configuration for each stage of HRNet. + conv_cfg (dict): dictionary to construct and config conv layer. + norm_cfg (dict): dictionary to construct and config norm layer. + norm_eval (bool): Whether to set norm layers to eval mode, namely, + freeze running stats (mean and var). Note: Effect on Batch Norm + and its variants only. + with_cp (bool): Use checkpoint or not. Using checkpoint will save some + memory while slowing down the training speed. + zero_init_residual (bool): whether to use zero init for last norm layer + in resblocks to let them behave as identity. + """ + + blocks_dict = {'BASIC': BasicBlock, 'BOTTLENECK': Bottleneck} + + def __init__(self, + extra, + conv_cfg=None, + norm_cfg=dict(type='BN'), + norm_eval=True, + with_cp=False, + zero_init_residual=False): + super(HRNet, self).__init__() + self.extra = extra + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self.norm_eval = norm_eval + self.with_cp = with_cp + self.zero_init_residual = zero_init_residual + + # stem net + self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1) + self.norm2_name, norm2 = build_norm_layer(self.norm_cfg, 64, postfix=2) + + self.conv1 = build_conv_layer( + self.conv_cfg, + 3, + 64, + kernel_size=3, + stride=2, + padding=1, + bias=False) + + self.add_module(self.norm1_name, norm1) + self.conv2 = build_conv_layer( + self.conv_cfg, + 64, + 64, + kernel_size=3, + stride=2, + padding=1, + bias=False) + + self.add_module(self.norm2_name, norm2) + self.relu = nn.ReLU(inplace=True) + + # stage 1 + self.stage1_cfg = self.extra['stage1'] + num_channels = self.stage1_cfg['num_channels'][0] + block_type = self.stage1_cfg['block'] + num_blocks = self.stage1_cfg['num_blocks'][0] + + block = self.blocks_dict[block_type] + stage1_out_channels = num_channels * block.expansion + self.layer1 = self._make_layer(block, 64, num_channels, num_blocks) + + # stage 2 + self.stage2_cfg = self.extra['stage2'] + num_channels = self.stage2_cfg['num_channels'] + block_type = self.stage2_cfg['block'] + + block = self.blocks_dict[block_type] + num_channels = [channel * block.expansion for channel in num_channels] + self.transition1 = self._make_transition_layer([stage1_out_channels], + num_channels) + self.stage2, pre_stage_channels = self._make_stage( + self.stage2_cfg, num_channels) + + # stage 3 + self.stage3_cfg = self.extra['stage3'] + num_channels = self.stage3_cfg['num_channels'] + block_type = self.stage3_cfg['block'] + + block = self.blocks_dict[block_type] + num_channels = [channel * block.expansion for channel in num_channels] + self.transition2 = self._make_transition_layer(pre_stage_channels, + num_channels) + self.stage3, pre_stage_channels = self._make_stage( + self.stage3_cfg, num_channels) + + # stage 4 + self.stage4_cfg = self.extra['stage4'] + num_channels = self.stage4_cfg['num_channels'] + block_type = self.stage4_cfg['block'] + + block = self.blocks_dict[block_type] + num_channels = [channel * block.expansion for channel in num_channels] + self.transition3 = self._make_transition_layer(pre_stage_channels, + num_channels) + self.stage4, pre_stage_channels = self._make_stage( + self.stage4_cfg, num_channels) + + @property + def norm1(self): + return getattr(self, self.norm1_name) + + @property + def norm2(self): + return getattr(self, self.norm2_name) + + def _make_transition_layer(self, num_channels_pre_layer, + num_channels_cur_layer): + num_branches_cur = len(num_channels_cur_layer) + num_branches_pre = len(num_channels_pre_layer) + + transition_layers = [] + for i in range(num_branches_cur): + if i < num_branches_pre: + if num_channels_cur_layer[i] != num_channels_pre_layer[i]: + transition_layers.append( + nn.Sequential( + build_conv_layer( + self.conv_cfg, + num_channels_pre_layer[i], + num_channels_cur_layer[i], + kernel_size=3, + stride=1, + padding=1, + bias=False), + build_norm_layer(self.norm_cfg, + num_channels_cur_layer[i])[1], + nn.ReLU(inplace=True))) + else: + transition_layers.append(None) + else: + conv_downsamples = [] + for j in range(i + 1 - num_branches_pre): + in_channels = num_channels_pre_layer[-1] + out_channels = num_channels_cur_layer[i] \ + if j == i - num_branches_pre else in_channels + conv_downsamples.append( + nn.Sequential( + build_conv_layer( + self.conv_cfg, + in_channels, + out_channels, + kernel_size=3, + stride=2, + padding=1, + bias=False), + build_norm_layer(self.norm_cfg, out_channels)[1], + nn.ReLU(inplace=True))) + transition_layers.append(nn.Sequential(*conv_downsamples)) + + return nn.ModuleList(transition_layers) + + def _make_layer(self, block, inplanes, planes, blocks, stride=1): + downsample = None + if stride != 1 or inplanes != planes * block.expansion: + downsample = nn.Sequential( + build_conv_layer( + self.conv_cfg, + inplanes, + planes * block.expansion, + kernel_size=1, + stride=stride, + bias=False), + build_norm_layer(self.norm_cfg, planes * block.expansion)[1]) + + layers = [] + layers.append( + block( + inplanes, + planes, + stride, + downsample=downsample, + with_cp=self.with_cp, + norm_cfg=self.norm_cfg, + conv_cfg=self.conv_cfg)) + inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append( + block( + inplanes, + planes, + with_cp=self.with_cp, + norm_cfg=self.norm_cfg, + conv_cfg=self.conv_cfg)) + + return nn.Sequential(*layers) + + def _make_stage(self, layer_config, in_channels, multiscale_output=True): + num_modules = layer_config['num_modules'] + num_branches = layer_config['num_branches'] + num_blocks = layer_config['num_blocks'] + num_channels = layer_config['num_channels'] + block = self.blocks_dict[layer_config['block']] + + hr_modules = [] + for i in range(num_modules): + # multi_scale_output is only used for the last module + if not multiscale_output and i == num_modules - 1: + reset_multiscale_output = False + else: + reset_multiscale_output = True + + hr_modules.append( + HRModule( + num_branches, + block, + num_blocks, + in_channels, + num_channels, + reset_multiscale_output, + with_cp=self.with_cp, + norm_cfg=self.norm_cfg, + conv_cfg=self.conv_cfg)) + + return nn.Sequential(*hr_modules), in_channels + + def init_weights(self, pretrained=None): + if isinstance(pretrained, str): + logger = logging.getLogger() + load_checkpoint(self, pretrained, strict=False, logger=logger) + elif pretrained is None: + for m in self.modules(): + if isinstance(m, nn.Conv2d): + kaiming_init(m) + elif isinstance(m, (_BatchNorm, nn.GroupNorm)): + constant_init(m, 1) + + if self.zero_init_residual: + for m in self.modules(): + if isinstance(m, Bottleneck): + constant_init(m.norm3, 0) + elif isinstance(m, BasicBlock): + constant_init(m.norm2, 0) + else: + raise TypeError('pretrained must be a str or None') + + def forward(self, x): + + x = self.conv1(x) + x = self.norm1(x) + x = self.relu(x) + x = self.conv2(x) + x = self.norm2(x) + x = self.relu(x) + x = self.layer1(x) + + x_list = [] + for i in range(self.stage2_cfg['num_branches']): + if self.transition1[i] is not None: + x_list.append(self.transition1[i](x)) + else: + x_list.append(x) + y_list = self.stage2(x_list) + + x_list = [] + for i in range(self.stage3_cfg['num_branches']): + if self.transition2[i] is not None: + x_list.append(self.transition2[i](y_list[-1])) + else: + x_list.append(y_list[i]) + y_list = self.stage3(x_list) + + x_list = [] + for i in range(self.stage4_cfg['num_branches']): + if self.transition3[i] is not None: + x_list.append(self.transition3[i](y_list[-1])) + else: + x_list.append(y_list[i]) + y_list = self.stage4(x_list) + + return y_list + + def train(self, mode=True): + super(HRNet, self).train(mode) + if mode and self.norm_eval: + for m in self.modules(): + # trick: eval have effect on BatchNorm only + if isinstance(m, _BatchNorm): + m.eval() diff --git a/mmdet/models/backbones/resnet.py b/mmdet/models/backbones/resnet.py new file mode 100644 index 0000000..eaead29 --- /dev/null +++ b/mmdet/models/backbones/resnet.py @@ -0,0 +1,525 @@ +import logging + +import torch.nn as nn +import torch.utils.checkpoint as cp +from mmcv.cnn import constant_init, kaiming_init +from mmcv.runner import load_checkpoint +from torch.nn.modules.batchnorm import _BatchNorm + +from mmdet.models.plugins import GeneralizedAttention +from mmdet.ops import ContextBlock, DeformConv, ModulatedDeformConv +from ..registry import BACKBONES +from ..utils import build_conv_layer, build_norm_layer + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, + inplanes, + planes, + stride=1, + dilation=1, + downsample=None, + style='pytorch', + with_cp=False, + conv_cfg=None, + norm_cfg=dict(type='BN'), + dcn=None, + gcb=None, + gen_attention=None): + super(BasicBlock, self).__init__() + assert dcn is None, "Not implemented yet." + assert gen_attention is None, "Not implemented yet." + assert gcb is None, "Not implemented yet." + + self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1) + self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2) + + self.conv1 = build_conv_layer( + conv_cfg, + inplanes, + planes, + 3, + stride=stride, + padding=dilation, + dilation=dilation, + bias=False) + self.add_module(self.norm1_name, norm1) + self.conv2 = build_conv_layer( + conv_cfg, planes, planes, 3, padding=1, bias=False) + self.add_module(self.norm2_name, norm2) + + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + self.dilation = dilation + assert not with_cp + + @property + def norm1(self): + return getattr(self, self.norm1_name) + + @property + def norm2(self): + return getattr(self, self.norm2_name) + + def forward(self, x): + identity = x + + out = self.conv1(x) + out = self.norm1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.norm2(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, + inplanes, + planes, + stride=1, + dilation=1, + downsample=None, + style='pytorch', + with_cp=False, + conv_cfg=None, + norm_cfg=dict(type='BN'), + dcn=None, + gcb=None, + gen_attention=None): + """Bottleneck block for ResNet. + If style is "pytorch", the stride-two layer is the 3x3 conv layer, + if it is "caffe", the stride-two layer is the first 1x1 conv layer. + """ + super(Bottleneck, self).__init__() + assert style in ['pytorch', 'caffe'] + assert dcn is None or isinstance(dcn, dict) + assert gcb is None or isinstance(gcb, dict) + assert gen_attention is None or isinstance(gen_attention, dict) + + self.inplanes = inplanes + self.planes = planes + self.stride = stride + self.dilation = dilation + self.style = style + self.with_cp = with_cp + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self.dcn = dcn + self.with_dcn = dcn is not None + self.gcb = gcb + self.with_gcb = gcb is not None + self.gen_attention = gen_attention + self.with_gen_attention = gen_attention is not None + + if self.style == 'pytorch': + self.conv1_stride = 1 + self.conv2_stride = stride + else: + self.conv1_stride = stride + self.conv2_stride = 1 + + self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1) + self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2) + self.norm3_name, norm3 = build_norm_layer( + norm_cfg, planes * self.expansion, postfix=3) + + self.conv1 = build_conv_layer( + conv_cfg, + inplanes, + planes, + kernel_size=1, + stride=self.conv1_stride, + bias=False) + self.add_module(self.norm1_name, norm1) + fallback_on_stride = False + self.with_modulated_dcn = False + if self.with_dcn: + fallback_on_stride = dcn.get('fallback_on_stride', False) + self.with_modulated_dcn = dcn.get('modulated', False) + if not self.with_dcn or fallback_on_stride: + self.conv2 = build_conv_layer( + conv_cfg, + planes, + planes, + kernel_size=3, + stride=self.conv2_stride, + padding=dilation, + dilation=dilation, + bias=False) + else: + assert conv_cfg is None, 'conv_cfg must be None for DCN' + deformable_groups = dcn.get('deformable_groups', 1) + if not self.with_modulated_dcn: + conv_op = DeformConv + offset_channels = 18 + else: + conv_op = ModulatedDeformConv + offset_channels = 27 + self.conv2_offset = nn.Conv2d( + planes, + deformable_groups * offset_channels, + kernel_size=3, + stride=self.conv2_stride, + padding=dilation, + dilation=dilation) + self.conv2 = conv_op( + planes, + planes, + kernel_size=3, + stride=self.conv2_stride, + padding=dilation, + dilation=dilation, + deformable_groups=deformable_groups, + bias=False) + self.add_module(self.norm2_name, norm2) + self.conv3 = build_conv_layer( + conv_cfg, + planes, + planes * self.expansion, + kernel_size=1, + bias=False) + self.add_module(self.norm3_name, norm3) + + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + + if self.with_gcb: + gcb_inplanes = planes * self.expansion + self.context_block = ContextBlock(inplanes=gcb_inplanes, **gcb) + + # gen_attention + if self.with_gen_attention: + self.gen_attention_block = GeneralizedAttention( + planes, **gen_attention) + + @property + def norm1(self): + return getattr(self, self.norm1_name) + + @property + def norm2(self): + return getattr(self, self.norm2_name) + + @property + def norm3(self): + return getattr(self, self.norm3_name) + + def forward(self, x): + + def _inner_forward(x): + identity = x + + out = self.conv1(x) + out = self.norm1(out) + out = self.relu(out) + + if not self.with_dcn: + out = self.conv2(out) + elif self.with_modulated_dcn: + offset_mask = self.conv2_offset(out) + offset = offset_mask[:, :18, :, :] + mask = offset_mask[:, -9:, :, :].sigmoid() + out = self.conv2(out, offset, mask) + else: + offset = self.conv2_offset(out) + out = self.conv2(out, offset) + out = self.norm2(out) + out = self.relu(out) + + if self.with_gen_attention: + out = self.gen_attention_block(out) + + out = self.conv3(out) + out = self.norm3(out) + + if self.with_gcb: + out = self.context_block(out) + + if self.downsample is not None: + identity = self.downsample(x) + + out += identity + + return out + + if self.with_cp and x.requires_grad: + out = cp.checkpoint(_inner_forward, x) + else: + out = _inner_forward(x) + + out = self.relu(out) + + return out + + +def make_res_layer(block, + inplanes, + planes, + blocks, + stride=1, + dilation=1, + style='pytorch', + with_cp=False, + conv_cfg=None, + norm_cfg=dict(type='BN'), + dcn=None, + gcb=None, + gen_attention=None, + gen_attention_blocks=[]): + downsample = None + if stride != 1 or inplanes != planes * block.expansion: + downsample = nn.Sequential( + build_conv_layer( + conv_cfg, + inplanes, + planes * block.expansion, + kernel_size=1, + stride=stride, + bias=False), + build_norm_layer(norm_cfg, planes * block.expansion)[1], + ) + + layers = [] + layers.append( + block( + inplanes=inplanes, + planes=planes, + stride=stride, + dilation=dilation, + downsample=downsample, + style=style, + with_cp=with_cp, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + dcn=dcn, + gcb=gcb, + gen_attention=gen_attention if + (0 in gen_attention_blocks) else None)) + inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append( + block( + inplanes=inplanes, + planes=planes, + stride=1, + dilation=dilation, + style=style, + with_cp=with_cp, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + dcn=dcn, + gcb=gcb, + gen_attention=gen_attention if + (i in gen_attention_blocks) else None)) + + return nn.Sequential(*layers) + + +@BACKBONES.register_module +class ResNet(nn.Module): + """ResNet backbone. + + Args: + depth (int): Depth of resnet, from {18, 34, 50, 101, 152}. + num_stages (int): Resnet stages, normally 4. + strides (Sequence[int]): Strides of the first block of each stage. + dilations (Sequence[int]): Dilation of each stage. + out_indices (Sequence[int]): Output from which stages. + style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two + layer is the 3x3 conv layer, otherwise the stride-two layer is + the first 1x1 conv layer. + frozen_stages (int): Stages to be frozen (stop grad and set eval mode). + -1 means not freezing any parameters. + norm_cfg (dict): dictionary to construct and config norm layer. + norm_eval (bool): Whether to set norm layers to eval mode, namely, + freeze running stats (mean and var). Note: Effect on Batch Norm + and its variants only. + with_cp (bool): Use checkpoint or not. Using checkpoint will save some + memory while slowing down the training speed. + zero_init_residual (bool): whether to use zero init for last norm layer + in resblocks to let them behave as identity. + """ + + arch_settings = { + 18: (BasicBlock, (2, 2, 2, 2)), + 34: (BasicBlock, (3, 4, 6, 3)), + 50: (Bottleneck, (3, 4, 6, 3)), + 101: (Bottleneck, (3, 4, 23, 3)), + 152: (Bottleneck, (3, 8, 36, 3)) + } + + def __init__(self, + depth, + num_stages=4, + strides=(1, 2, 2, 2), + dilations=(1, 1, 1, 1), + out_indices=(0, 1, 2, 3), + style='pytorch', + frozen_stages=-1, + conv_cfg=None, + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + dcn=None, + stage_with_dcn=(False, False, False, False), + gcb=None, + stage_with_gcb=(False, False, False, False), + gen_attention=None, + stage_with_gen_attention=((), (), (), ()), + with_cp=False, + zero_init_residual=True): + super(ResNet, self).__init__() + if depth not in self.arch_settings: + raise KeyError('invalid depth {} for resnet'.format(depth)) + self.depth = depth + self.num_stages = num_stages + assert num_stages >= 1 and num_stages <= 4 + self.strides = strides + self.dilations = dilations + assert len(strides) == len(dilations) == num_stages + self.out_indices = out_indices + assert max(out_indices) < num_stages + self.style = style + self.frozen_stages = frozen_stages + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self.with_cp = with_cp + self.norm_eval = norm_eval + self.dcn = dcn + self.stage_with_dcn = stage_with_dcn + if dcn is not None: + assert len(stage_with_dcn) == num_stages + self.gen_attention = gen_attention + self.gcb = gcb + self.stage_with_gcb = stage_with_gcb + if gcb is not None: + assert len(stage_with_gcb) == num_stages + self.zero_init_residual = zero_init_residual + self.block, stage_blocks = self.arch_settings[depth] + self.stage_blocks = stage_blocks[:num_stages] + self.inplanes = 64 + + self._make_stem_layer() + + self.res_layers = [] + for i, num_blocks in enumerate(self.stage_blocks): + stride = strides[i] + dilation = dilations[i] + dcn = self.dcn if self.stage_with_dcn[i] else None + gcb = self.gcb if self.stage_with_gcb[i] else None + planes = 64 * 2**i + res_layer = make_res_layer( + self.block, + self.inplanes, + planes, + num_blocks, + stride=stride, + dilation=dilation, + style=self.style, + with_cp=with_cp, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + dcn=dcn, + gcb=gcb, + gen_attention=gen_attention, + gen_attention_blocks=stage_with_gen_attention[i]) + self.inplanes = planes * self.block.expansion + layer_name = 'layer{}'.format(i + 1) + self.add_module(layer_name, res_layer) + self.res_layers.append(layer_name) + + self._freeze_stages() + + self.feat_dim = self.block.expansion * 64 * 2**( + len(self.stage_blocks) - 1) + + @property + def norm1(self): + return getattr(self, self.norm1_name) + + def _make_stem_layer(self): + self.conv1 = build_conv_layer( + self.conv_cfg, + 3, + 64, + kernel_size=7, + stride=2, + padding=3, + bias=False) + self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1) + self.add_module(self.norm1_name, norm1) + self.relu = nn.ReLU(inplace=True) + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) + + def _freeze_stages(self): + if self.frozen_stages >= 0: + self.norm1.eval() + for m in [self.conv1, self.norm1]: + for param in m.parameters(): + param.requires_grad = False + + for i in range(1, self.frozen_stages + 1): + m = getattr(self, 'layer{}'.format(i)) + m.eval() + for param in m.parameters(): + param.requires_grad = False + + def init_weights(self, pretrained=None): + if isinstance(pretrained, str): + logger = logging.getLogger() + load_checkpoint(self, pretrained, strict=False, logger=logger) + elif pretrained is None: + for m in self.modules(): + if isinstance(m, nn.Conv2d): + kaiming_init(m) + elif isinstance(m, (_BatchNorm, nn.GroupNorm)): + constant_init(m, 1) + + if self.dcn is not None: + for m in self.modules(): + if isinstance(m, Bottleneck) and hasattr( + m, 'conv2_offset'): + constant_init(m.conv2_offset, 0) + + if self.zero_init_residual: + for m in self.modules(): + if isinstance(m, Bottleneck): + constant_init(m.norm3, 0) + elif isinstance(m, BasicBlock): + constant_init(m.norm2, 0) + else: + raise TypeError('pretrained must be a str or None') + + def forward(self, x): + x = self.conv1(x) + x = self.norm1(x) + x = self.relu(x) + x = self.maxpool(x) + outs = [] + for i, layer_name in enumerate(self.res_layers): + res_layer = getattr(self, layer_name) + x = res_layer(x) + if i in self.out_indices: + outs.append(x) + return tuple(outs) + + def train(self, mode=True): + super(ResNet, self).train(mode) + self._freeze_stages() + if mode and self.norm_eval: + for m in self.modules(): + # trick: eval have effect on BatchNorm only + if isinstance(m, _BatchNorm): + m.eval() diff --git a/mmdet/models/backbones/resnext.py b/mmdet/models/backbones/resnext.py new file mode 100644 index 0000000..c5feaa4 --- /dev/null +++ b/mmdet/models/backbones/resnext.py @@ -0,0 +1,223 @@ +import math + +import torch.nn as nn + +from mmdet.ops import DeformConv, ModulatedDeformConv +from ..registry import BACKBONES +from ..utils import build_conv_layer, build_norm_layer +from .resnet import Bottleneck as _Bottleneck +from .resnet import ResNet + + +class Bottleneck(_Bottleneck): + + def __init__(self, inplanes, planes, groups=1, base_width=4, **kwargs): + """Bottleneck block for ResNeXt. + If style is "pytorch", the stride-two layer is the 3x3 conv layer, + if it is "caffe", the stride-two layer is the first 1x1 conv layer. + """ + super(Bottleneck, self).__init__(inplanes, planes, **kwargs) + + if groups == 1: + width = self.planes + else: + width = math.floor(self.planes * (base_width / 64)) * groups + + self.norm1_name, norm1 = build_norm_layer( + self.norm_cfg, width, postfix=1) + self.norm2_name, norm2 = build_norm_layer( + self.norm_cfg, width, postfix=2) + self.norm3_name, norm3 = build_norm_layer( + self.norm_cfg, self.planes * self.expansion, postfix=3) + + self.conv1 = build_conv_layer( + self.conv_cfg, + self.inplanes, + width, + kernel_size=1, + stride=self.conv1_stride, + bias=False) + self.add_module(self.norm1_name, norm1) + fallback_on_stride = False + self.with_modulated_dcn = False + if self.with_dcn: + fallback_on_stride = self.dcn.get('fallback_on_stride', False) + self.with_modulated_dcn = self.dcn.get('modulated', False) + if not self.with_dcn or fallback_on_stride: + self.conv2 = build_conv_layer( + self.conv_cfg, + width, + width, + kernel_size=3, + stride=self.conv2_stride, + padding=self.dilation, + dilation=self.dilation, + groups=groups, + bias=False) + else: + assert self.conv_cfg is None, 'conv_cfg must be None for DCN' + groups = self.dcn.get('groups', 1) + deformable_groups = self.dcn.get('deformable_groups', 1) + if not self.with_modulated_dcn: + conv_op = DeformConv + offset_channels = 18 + else: + conv_op = ModulatedDeformConv + offset_channels = 27 + self.conv2_offset = nn.Conv2d( + width, + deformable_groups * offset_channels, + kernel_size=3, + stride=self.conv2_stride, + padding=self.dilation, + dilation=self.dilation) + self.conv2 = conv_op( + width, + width, + kernel_size=3, + stride=self.conv2_stride, + padding=self.dilation, + dilation=self.dilation, + groups=groups, + deformable_groups=deformable_groups, + bias=False) + self.add_module(self.norm2_name, norm2) + self.conv3 = build_conv_layer( + self.conv_cfg, + width, + self.planes * self.expansion, + kernel_size=1, + bias=False) + self.add_module(self.norm3_name, norm3) + + +def make_res_layer(block, + inplanes, + planes, + blocks, + stride=1, + dilation=1, + groups=1, + base_width=4, + style='pytorch', + with_cp=False, + conv_cfg=None, + norm_cfg=dict(type='BN'), + dcn=None, + gcb=None): + downsample = None + if stride != 1 or inplanes != planes * block.expansion: + downsample = nn.Sequential( + build_conv_layer( + conv_cfg, + inplanes, + planes * block.expansion, + kernel_size=1, + stride=stride, + bias=False), + build_norm_layer(norm_cfg, planes * block.expansion)[1], + ) + + layers = [] + layers.append( + block( + inplanes=inplanes, + planes=planes, + stride=stride, + dilation=dilation, + downsample=downsample, + groups=groups, + base_width=base_width, + style=style, + with_cp=with_cp, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + dcn=dcn, + gcb=gcb)) + inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append( + block( + inplanes=inplanes, + planes=planes, + stride=1, + dilation=dilation, + groups=groups, + base_width=base_width, + style=style, + with_cp=with_cp, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + dcn=dcn, + gcb=gcb)) + + return nn.Sequential(*layers) + + +@BACKBONES.register_module +class ResNeXt(ResNet): + """ResNeXt backbone. + + Args: + depth (int): Depth of resnet, from {18, 34, 50, 101, 152}. + num_stages (int): Resnet stages, normally 4. + groups (int): Group of resnext. + base_width (int): Base width of resnext. + strides (Sequence[int]): Strides of the first block of each stage. + dilations (Sequence[int]): Dilation of each stage. + out_indices (Sequence[int]): Output from which stages. + style (str): `pytorch` or `caffe`. If set to "pytorch", the stride-two + layer is the 3x3 conv layer, otherwise the stride-two layer is + the first 1x1 conv layer. + frozen_stages (int): Stages to be frozen (all param fixed). -1 means + not freezing any parameters. + norm_cfg (dict): dictionary to construct and config norm layer. + norm_eval (bool): Whether to set norm layers to eval mode, namely, + freeze running stats (mean and var). Note: Effect on Batch Norm + and its variants only. + with_cp (bool): Use checkpoint or not. Using checkpoint will save some + memory while slowing down the training speed. + zero_init_residual (bool): whether to use zero init for last norm layer + in resblocks to let them behave as identity. + """ + + arch_settings = { + 50: (Bottleneck, (3, 4, 6, 3)), + 101: (Bottleneck, (3, 4, 23, 3)), + 152: (Bottleneck, (3, 8, 36, 3)) + } + + def __init__(self, groups=1, base_width=4, **kwargs): + super(ResNeXt, self).__init__(**kwargs) + self.groups = groups + self.base_width = base_width + + self.inplanes = 64 + self.res_layers = [] + for i, num_blocks in enumerate(self.stage_blocks): + stride = self.strides[i] + dilation = self.dilations[i] + dcn = self.dcn if self.stage_with_dcn[i] else None + gcb = self.gcb if self.stage_with_gcb[i] else None + planes = 64 * 2**i + res_layer = make_res_layer( + self.block, + self.inplanes, + planes, + num_blocks, + stride=stride, + dilation=dilation, + groups=self.groups, + base_width=self.base_width, + style=self.style, + with_cp=self.with_cp, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + dcn=dcn, + gcb=gcb) + self.inplanes = planes * self.block.expansion + layer_name = 'layer{}'.format(i + 1) + self.add_module(layer_name, res_layer) + self.res_layers.append(layer_name) + + self._freeze_stages() diff --git a/mmdet/models/backbones/ssd_vgg.py b/mmdet/models/backbones/ssd_vgg.py new file mode 100644 index 0000000..ae65711 --- /dev/null +++ b/mmdet/models/backbones/ssd_vgg.py @@ -0,0 +1,133 @@ +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import VGG, constant_init, kaiming_init, normal_init, xavier_init +from mmcv.runner import load_checkpoint + +from ..registry import BACKBONES + + +@BACKBONES.register_module +class SSDVGG(VGG): + extra_setting = { + 300: (256, 'S', 512, 128, 'S', 256, 128, 256, 128, 256), + 512: (256, 'S', 512, 128, 'S', 256, 128, 'S', 256, 128, 'S', 256, 128), + } + + def __init__(self, + input_size, + depth, + with_last_pool=False, + ceil_mode=True, + out_indices=(3, 4), + out_feature_indices=(22, 34), + l2_norm_scale=20.): + super(SSDVGG, self).__init__( + depth, + with_last_pool=with_last_pool, + ceil_mode=ceil_mode, + out_indices=out_indices) + assert input_size in (300, 512) + self.input_size = input_size + + self.features.add_module( + str(len(self.features)), + nn.MaxPool2d(kernel_size=3, stride=1, padding=1)) + self.features.add_module( + str(len(self.features)), + nn.Conv2d(512, 1024, kernel_size=3, padding=6, dilation=6)) + self.features.add_module( + str(len(self.features)), nn.ReLU(inplace=True)) + self.features.add_module( + str(len(self.features)), nn.Conv2d(1024, 1024, kernel_size=1)) + self.features.add_module( + str(len(self.features)), nn.ReLU(inplace=True)) + self.out_feature_indices = out_feature_indices + + self.inplanes = 1024 + self.extra = self._make_extra_layers(self.extra_setting[input_size]) + self.l2_norm = L2Norm( + self.features[out_feature_indices[0] - 1].out_channels, + l2_norm_scale) + + def init_weights(self, pretrained=None): + if isinstance(pretrained, str): + logger = logging.getLogger() + load_checkpoint(self, pretrained, strict=False, logger=logger) + elif pretrained is None: + for m in self.features.modules(): + if isinstance(m, nn.Conv2d): + kaiming_init(m) + elif isinstance(m, nn.BatchNorm2d): + constant_init(m, 1) + elif isinstance(m, nn.Linear): + normal_init(m, std=0.01) + else: + raise TypeError('pretrained must be a str or None') + + for m in self.extra.modules(): + if isinstance(m, nn.Conv2d): + xavier_init(m, distribution='uniform') + + constant_init(self.l2_norm, self.l2_norm.scale) + + def forward(self, x): + outs = [] + for i, layer in enumerate(self.features): + x = layer(x) + if i in self.out_feature_indices: + outs.append(x) + for i, layer in enumerate(self.extra): + x = F.relu(layer(x), inplace=True) + if i % 2 == 1: + outs.append(x) + outs[0] = self.l2_norm(outs[0]) + if len(outs) == 1: + return outs[0] + else: + return tuple(outs) + + def _make_extra_layers(self, outplanes): + layers = [] + kernel_sizes = (1, 3) + num_layers = 0 + outplane = None + for i in range(len(outplanes)): + if self.inplanes == 'S': + self.inplanes = outplane + continue + k = kernel_sizes[num_layers % 2] + if outplanes[i] == 'S': + outplane = outplanes[i + 1] + conv = nn.Conv2d( + self.inplanes, outplane, k, stride=2, padding=1) + else: + outplane = outplanes[i] + conv = nn.Conv2d( + self.inplanes, outplane, k, stride=1, padding=0) + layers.append(conv) + self.inplanes = outplanes[i] + num_layers += 1 + if self.input_size == 512: + layers.append(nn.Conv2d(self.inplanes, 256, 4, padding=1)) + + return nn.Sequential(*layers) + + +class L2Norm(nn.Module): + + def __init__(self, n_dims, scale=20., eps=1e-10): + super(L2Norm, self).__init__() + self.n_dims = n_dims + self.weight = nn.Parameter(torch.Tensor(self.n_dims)) + self.eps = eps + self.scale = scale + + def forward(self, x): + # normalization layer convert to FP32 in FP16 training + x_float = x.float() + norm = x_float.pow(2).sum(1, keepdim=True).sqrt() + self.eps + return (self.weight[None, :, None, None].float().expand_as(x_float) * + x_float / norm).type_as(x) diff --git a/mmdet/models/bbox_heads/__init__.py b/mmdet/models/bbox_heads/__init__.py new file mode 100644 index 0000000..a668bdb --- /dev/null +++ b/mmdet/models/bbox_heads/__init__.py @@ -0,0 +1,7 @@ +from .bbox_head import BBoxHead +from .convfc_bbox_head import ConvFCBBoxHead, SharedFCBBoxHead +from .double_bbox_head import DoubleConvFCBBoxHead + +__all__ = [ + 'BBoxHead', 'ConvFCBBoxHead', 'SharedFCBBoxHead', 'DoubleConvFCBBoxHead' +] diff --git a/mmdet/models/bbox_heads/bbox_head.py b/mmdet/models/bbox_heads/bbox_head.py new file mode 100644 index 0000000..6188fb8 --- /dev/null +++ b/mmdet/models/bbox_heads/bbox_head.py @@ -0,0 +1,239 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.nn.modules.utils import _pair + +from mmdet.core import (auto_fp16, bbox_target, delta2bbox, force_fp32, + multiclass_nms) +from ..builder import build_loss +from ..losses import accuracy +from ..registry import HEADS + + +@HEADS.register_module +class BBoxHead(nn.Module): + """Simplest RoI head, with only two fc layers for classification and + regression respectively""" + + def __init__(self, + with_avg_pool=False, + with_cls=True, + with_reg=True, + roi_feat_size=7, + in_channels=256, + num_classes=81, + target_means=[0., 0., 0., 0.], + target_stds=[0.1, 0.1, 0.2, 0.2], + reg_class_agnostic=False, + loss_cls=dict( + type='CrossEntropyLoss', + use_sigmoid=False, + loss_weight=1.0), + loss_bbox=dict( + type='SmoothL1Loss', beta=1.0, loss_weight=1.0)): + super(BBoxHead, self).__init__() + assert with_cls or with_reg + self.with_avg_pool = with_avg_pool + self.with_cls = with_cls + self.with_reg = with_reg + self.roi_feat_size = _pair(roi_feat_size) + self.roi_feat_area = self.roi_feat_size[0] * self.roi_feat_size[1] + self.in_channels = in_channels + self.num_classes = num_classes + self.target_means = target_means + self.target_stds = target_stds + self.reg_class_agnostic = reg_class_agnostic + self.fp16_enabled = False + + self.loss_cls = build_loss(loss_cls) + self.loss_bbox = build_loss(loss_bbox) + + in_channels = self.in_channels + if self.with_avg_pool: + self.avg_pool = nn.AvgPool2d(self.roi_feat_size) + else: + in_channels *= self.roi_feat_area + if self.with_cls: + self.fc_cls = nn.Linear(in_channels, num_classes) + if self.with_reg: + out_dim_reg = 4 if reg_class_agnostic else 4 * num_classes + self.fc_reg = nn.Linear(in_channels, out_dim_reg) + self.debug_imgs = None + + def init_weights(self): + if self.with_cls: + nn.init.normal_(self.fc_cls.weight, 0, 0.01) + nn.init.constant_(self.fc_cls.bias, 0) + if self.with_reg: + nn.init.normal_(self.fc_reg.weight, 0, 0.001) + nn.init.constant_(self.fc_reg.bias, 0) + + @auto_fp16() + def forward(self, x): + if self.with_avg_pool: + x = self.avg_pool(x) + x = x.view(x.size(0), -1) + cls_score = self.fc_cls(x) if self.with_cls else None + bbox_pred = self.fc_reg(x) if self.with_reg else None + return cls_score, bbox_pred + + def get_target(self, sampling_results, gt_bboxes, gt_labels, + rcnn_train_cfg): + pos_proposals = [res.pos_bboxes for res in sampling_results] + neg_proposals = [res.neg_bboxes for res in sampling_results] + pos_gt_bboxes = [res.pos_gt_bboxes for res in sampling_results] + pos_gt_labels = [res.pos_gt_labels for res in sampling_results] + reg_classes = 1 if self.reg_class_agnostic else self.num_classes + cls_reg_targets = bbox_target( + pos_proposals, + neg_proposals, + pos_gt_bboxes, + pos_gt_labels, + rcnn_train_cfg, + reg_classes, + target_means=self.target_means, + target_stds=self.target_stds) + return cls_reg_targets + + @force_fp32(apply_to=('cls_score', 'bbox_pred')) + def loss(self, + cls_score, + bbox_pred, + labels, + label_weights, + bbox_targets, + bbox_weights, + reduction_override=None): + losses = dict() + if cls_score is not None: + avg_factor = max(torch.sum(label_weights > 0).float().item(), 1.) + losses['loss_cls'] = self.loss_cls( + cls_score, + labels, + label_weights, + avg_factor=avg_factor, + reduction_override=reduction_override) + losses['acc'] = accuracy(cls_score, labels) + if bbox_pred is not None: + pos_inds = labels > 0 + if self.reg_class_agnostic: + pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), 4)[pos_inds] + else: + pos_bbox_pred = bbox_pred.view(bbox_pred.size(0), -1, + 4)[pos_inds, labels[pos_inds]] + losses['loss_bbox'] = self.loss_bbox( + pos_bbox_pred, + bbox_targets[pos_inds], + bbox_weights[pos_inds], + avg_factor=bbox_targets.size(0), + reduction_override=reduction_override) + return losses + + @force_fp32(apply_to=('cls_score', 'bbox_pred')) + def get_det_bboxes(self, + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=False, + cfg=None): + if isinstance(cls_score, list): + cls_score = sum(cls_score) / float(len(cls_score)) + scores = F.softmax(cls_score, dim=1) if cls_score is not None else None + + if bbox_pred is not None: + bboxes = delta2bbox(rois[:, 1:], bbox_pred, self.target_means, + self.target_stds, img_shape) + else: + bboxes = rois[:, 1:].clone() + if img_shape is not None: + bboxes[:, [0, 2]].clamp_(min=0, max=img_shape[1] - 1) + bboxes[:, [1, 3]].clamp_(min=0, max=img_shape[0] - 1) + + if rescale: + if isinstance(scale_factor, float): + bboxes /= scale_factor + else: + bboxes /= torch.from_numpy(scale_factor).to(bboxes.device) + + if cfg is None: + return bboxes, scores + else: + det_bboxes, det_labels = multiclass_nms(bboxes, scores, + cfg.score_thr, cfg.nms, + cfg.max_per_img) + + return det_bboxes, det_labels + + @force_fp32(apply_to=('bbox_preds', )) + def refine_bboxes(self, rois, labels, bbox_preds, pos_is_gts, img_metas): + """Refine bboxes during training. + + Args: + rois (Tensor): Shape (n*bs, 5), where n is image number per GPU, + and bs is the sampled RoIs per image. + labels (Tensor): Shape (n*bs, ). + bbox_preds (Tensor): Shape (n*bs, 4) or (n*bs, 4*#class). + pos_is_gts (list[Tensor]): Flags indicating if each positive bbox + is a gt bbox. + img_metas (list[dict]): Meta info of each image. + + Returns: + list[Tensor]: Refined bboxes of each image in a mini-batch. + """ + img_ids = rois[:, 0].long().unique(sorted=True) + assert img_ids.numel() == len(img_metas) + + bboxes_list = [] + for i in range(len(img_metas)): + inds = torch.nonzero(rois[:, 0] == i).squeeze() + num_rois = inds.numel() + + bboxes_ = rois[inds, 1:] + label_ = labels[inds] + bbox_pred_ = bbox_preds[inds] + img_meta_ = img_metas[i] + pos_is_gts_ = pos_is_gts[i] + + bboxes = self.regress_by_class(bboxes_, label_, bbox_pred_, + img_meta_) + # filter gt bboxes + pos_keep = 1 - pos_is_gts_ + keep_inds = pos_is_gts_.new_ones(num_rois) + keep_inds[:len(pos_is_gts_)] = pos_keep + + bboxes_list.append(bboxes[keep_inds]) + + return bboxes_list + + @force_fp32(apply_to=('bbox_pred', )) + def regress_by_class(self, rois, label, bbox_pred, img_meta): + """Regress the bbox for the predicted class. Used in Cascade R-CNN. + + Args: + rois (Tensor): shape (n, 4) or (n, 5) + label (Tensor): shape (n, ) + bbox_pred (Tensor): shape (n, 4*(#class+1)) or (n, 4) + img_meta (dict): Image meta info. + + Returns: + Tensor: Regressed bboxes, the same shape as input rois. + """ + assert rois.size(1) == 4 or rois.size(1) == 5 + + if not self.reg_class_agnostic: + label = label * 4 + inds = torch.stack((label, label + 1, label + 2, label + 3), 1) + bbox_pred = torch.gather(bbox_pred, 1, inds) + assert bbox_pred.size(1) == 4 + + if rois.size(1) == 4: + new_rois = delta2bbox(rois, bbox_pred, self.target_means, + self.target_stds, img_meta['img_shape']) + else: + bboxes = delta2bbox(rois[:, 1:], bbox_pred, self.target_means, + self.target_stds, img_meta['img_shape']) + new_rois = torch.cat((rois[:, [0]], bboxes), dim=1) + + return new_rois diff --git a/mmdet/models/bbox_heads/convfc_bbox_head.py b/mmdet/models/bbox_heads/convfc_bbox_head.py new file mode 100644 index 0000000..f6659b3 --- /dev/null +++ b/mmdet/models/bbox_heads/convfc_bbox_head.py @@ -0,0 +1,185 @@ +import torch.nn as nn + +from ..registry import HEADS +from ..utils import ConvModule +from .bbox_head import BBoxHead + + +@HEADS.register_module +class ConvFCBBoxHead(BBoxHead): + """More general bbox head, with shared conv and fc layers and two optional + separated branches. + + /-> cls convs -> cls fcs -> cls + shared convs -> shared fcs + \-> reg convs -> reg fcs -> reg + """ # noqa: W605 + + def __init__(self, + num_shared_convs=0, + num_shared_fcs=0, + num_cls_convs=0, + num_cls_fcs=0, + num_reg_convs=0, + num_reg_fcs=0, + conv_out_channels=256, + fc_out_channels=1024, + conv_cfg=None, + norm_cfg=None, + *args, + **kwargs): + super(ConvFCBBoxHead, self).__init__(*args, **kwargs) + assert (num_shared_convs + num_shared_fcs + num_cls_convs + + num_cls_fcs + num_reg_convs + num_reg_fcs > 0) + if num_cls_convs > 0 or num_reg_convs > 0: + assert num_shared_fcs == 0 + if not self.with_cls: + assert num_cls_convs == 0 and num_cls_fcs == 0 + if not self.with_reg: + assert num_reg_convs == 0 and num_reg_fcs == 0 + self.num_shared_convs = num_shared_convs + self.num_shared_fcs = num_shared_fcs + self.num_cls_convs = num_cls_convs + self.num_cls_fcs = num_cls_fcs + self.num_reg_convs = num_reg_convs + self.num_reg_fcs = num_reg_fcs + self.conv_out_channels = conv_out_channels + self.fc_out_channels = fc_out_channels + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + + # add shared convs and fcs + self.shared_convs, self.shared_fcs, last_layer_dim = \ + self._add_conv_fc_branch( + self.num_shared_convs, self.num_shared_fcs, self.in_channels, + True) + self.shared_out_channels = last_layer_dim + + # add cls specific branch + self.cls_convs, self.cls_fcs, self.cls_last_dim = \ + self._add_conv_fc_branch( + self.num_cls_convs, self.num_cls_fcs, self.shared_out_channels) + + # add reg specific branch + self.reg_convs, self.reg_fcs, self.reg_last_dim = \ + self._add_conv_fc_branch( + self.num_reg_convs, self.num_reg_fcs, self.shared_out_channels) + + if self.num_shared_fcs == 0 and not self.with_avg_pool: + if self.num_cls_fcs == 0: + self.cls_last_dim *= self.roi_feat_area + if self.num_reg_fcs == 0: + self.reg_last_dim *= self.roi_feat_area + + self.relu = nn.ReLU(inplace=True) + # reconstruct fc_cls and fc_reg since input channels are changed + if self.with_cls: + self.fc_cls = nn.Linear(self.cls_last_dim, self.num_classes) + if self.with_reg: + out_dim_reg = (4 if self.reg_class_agnostic else 4 * + self.num_classes) + self.fc_reg = nn.Linear(self.reg_last_dim, out_dim_reg) + + def _add_conv_fc_branch(self, + num_branch_convs, + num_branch_fcs, + in_channels, + is_shared=False): + """Add shared or separable branch + + convs -> avg pool (optional) -> fcs + """ + last_layer_dim = in_channels + # add branch specific conv layers + branch_convs = nn.ModuleList() + if num_branch_convs > 0: + for i in range(num_branch_convs): + conv_in_channels = ( + last_layer_dim if i == 0 else self.conv_out_channels) + branch_convs.append( + ConvModule( + conv_in_channels, + self.conv_out_channels, + 3, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg)) + last_layer_dim = self.conv_out_channels + # add branch specific fc layers + branch_fcs = nn.ModuleList() + if num_branch_fcs > 0: + # for shared branch, only consider self.with_avg_pool + # for separated branches, also consider self.num_shared_fcs + if (is_shared + or self.num_shared_fcs == 0) and not self.with_avg_pool: + last_layer_dim *= self.roi_feat_area + for i in range(num_branch_fcs): + fc_in_channels = ( + last_layer_dim if i == 0 else self.fc_out_channels) + branch_fcs.append( + nn.Linear(fc_in_channels, self.fc_out_channels)) + last_layer_dim = self.fc_out_channels + return branch_convs, branch_fcs, last_layer_dim + + def init_weights(self): + super(ConvFCBBoxHead, self).init_weights() + for module_list in [self.shared_fcs, self.cls_fcs, self.reg_fcs]: + for m in module_list.modules(): + if isinstance(m, nn.Linear): + nn.init.xavier_uniform_(m.weight) + nn.init.constant_(m.bias, 0) + + def forward(self, x): + # shared part + if self.num_shared_convs > 0: + for conv in self.shared_convs: + x = conv(x) + + if self.num_shared_fcs > 0: + if self.with_avg_pool: + x = self.avg_pool(x) + x = x.view(x.size(0), -1) + for fc in self.shared_fcs: + x = self.relu(fc(x)) + # separate branches + x_cls = x + x_reg = x + + for conv in self.cls_convs: + x_cls = conv(x_cls) + if x_cls.dim() > 2: + if self.with_avg_pool: + x_cls = self.avg_pool(x_cls) + x_cls = x_cls.view(x_cls.size(0), -1) + for fc in self.cls_fcs: + x_cls = self.relu(fc(x_cls)) + + for conv in self.reg_convs: + x_reg = conv(x_reg) + if x_reg.dim() > 2: + if self.with_avg_pool: + x_reg = self.avg_pool(x_reg) + x_reg = x_reg.view(x_reg.size(0), -1) + for fc in self.reg_fcs: + x_reg = self.relu(fc(x_reg)) + + cls_score = self.fc_cls(x_cls) if self.with_cls else None + bbox_pred = self.fc_reg(x_reg) if self.with_reg else None + return cls_score, bbox_pred + + +@HEADS.register_module +class SharedFCBBoxHead(ConvFCBBoxHead): + + def __init__(self, num_fcs=2, fc_out_channels=1024, *args, **kwargs): + assert num_fcs >= 1 + super(SharedFCBBoxHead, self).__init__( + num_shared_convs=0, + num_shared_fcs=num_fcs, + num_cls_convs=0, + num_cls_fcs=0, + num_reg_convs=0, + num_reg_fcs=0, + fc_out_channels=fc_out_channels, + *args, + **kwargs) diff --git a/mmdet/models/bbox_heads/double_bbox_head.py b/mmdet/models/bbox_heads/double_bbox_head.py new file mode 100644 index 0000000..a2934a0 --- /dev/null +++ b/mmdet/models/bbox_heads/double_bbox_head.py @@ -0,0 +1,170 @@ +import torch.nn as nn +from mmcv.cnn.weight_init import normal_init, xavier_init + +from ..backbones.resnet import Bottleneck +from ..registry import HEADS +from ..utils import ConvModule +from .bbox_head import BBoxHead + + +class BasicResBlock(nn.Module): + """Basic residual block. + + This block is a little different from the block in the ResNet backbone. + The kernel size of conv1 is 1 in this block while 3 in ResNet BasicBlock. + + Args: + in_channels (int): Channels of the input feature map. + out_channels (int): Channels of the output feature map. + conv_cfg (dict): The config dict for convolution layers. + norm_cfg (dict): The config dict for normalization layers. + """ + + def __init__(self, + in_channels, + out_channels, + conv_cfg=None, + norm_cfg=dict(type='BN')): + super(BasicResBlock, self).__init__() + + # main path + self.conv1 = ConvModule( + in_channels, + in_channels, + kernel_size=3, + padding=1, + bias=False, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg) + self.conv2 = ConvModule( + in_channels, + out_channels, + kernel_size=1, + bias=False, + activation=None, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg) + + # identity path + self.conv_identity = ConvModule( + in_channels, + out_channels, + kernel_size=1, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + activation=None) + + self.relu = nn.ReLU(inplace=True) + + def forward(self, x): + identity = x + + x = self.conv1(x) + x = self.conv2(x) + + identity = self.conv_identity(identity) + out = x + identity + + out = self.relu(out) + return out + + +@HEADS.register_module +class DoubleConvFCBBoxHead(BBoxHead): + """Bbox head used in Double-Head R-CNN + + /-> cls + /-> shared convs -> + \-> reg + roi features + /-> cls + \-> shared fc -> + \-> reg + """ # noqa: W605 + + def __init__(self, + num_convs=0, + num_fcs=0, + conv_out_channels=1024, + fc_out_channels=1024, + conv_cfg=None, + norm_cfg=dict(type='BN'), + **kwargs): + kwargs.setdefault('with_avg_pool', True) + super(DoubleConvFCBBoxHead, self).__init__(**kwargs) + assert self.with_avg_pool + assert num_convs > 0 + assert num_fcs > 0 + self.num_convs = num_convs + self.num_fcs = num_fcs + self.conv_out_channels = conv_out_channels + self.fc_out_channels = fc_out_channels + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + + # increase the channel of input features + self.res_block = BasicResBlock(self.in_channels, + self.conv_out_channels) + + # add conv heads + self.conv_branch = self._add_conv_branch() + # add fc heads + self.fc_branch = self._add_fc_branch() + + out_dim_reg = 4 if self.reg_class_agnostic else 4 * self.num_classes + self.fc_reg = nn.Linear(self.conv_out_channels, out_dim_reg) + + self.fc_cls = nn.Linear(self.fc_out_channels, self.num_classes) + self.relu = nn.ReLU(inplace=True) + + def _add_conv_branch(self): + """Add the fc branch which consists of a sequential of conv layers""" + branch_convs = nn.ModuleList() + for i in range(self.num_convs): + branch_convs.append( + Bottleneck( + inplanes=self.conv_out_channels, + planes=self.conv_out_channels // 4, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg)) + return branch_convs + + def _add_fc_branch(self): + """Add the fc branch which consists of a sequential of fc layers""" + branch_fcs = nn.ModuleList() + for i in range(self.num_fcs): + fc_in_channels = ( + self.in_channels * + self.roi_feat_area if i == 0 else self.fc_out_channels) + branch_fcs.append(nn.Linear(fc_in_channels, self.fc_out_channels)) + return branch_fcs + + def init_weights(self): + normal_init(self.fc_cls, std=0.01) + normal_init(self.fc_reg, std=0.001) + + for m in self.fc_branch.modules(): + if isinstance(m, nn.Linear): + xavier_init(m, distribution='uniform') + + def forward(self, x_cls, x_reg): + # conv head + x_conv = self.res_block(x_reg) + + for conv in self.conv_branch: + x_conv = conv(x_conv) + + if self.with_avg_pool: + x_conv = self.avg_pool(x_conv) + + x_conv = x_conv.view(x_conv.size(0), -1) + bbox_pred = self.fc_reg(x_conv) + + # fc head + x_fc = x_cls.view(x_cls.size(0), -1) + for fc in self.fc_branch: + x_fc = self.relu(fc(x_fc)) + + cls_score = self.fc_cls(x_fc) + + return cls_score, bbox_pred diff --git a/mmdet/models/builder.py b/mmdet/models/builder.py new file mode 100644 index 0000000..dc82ab7 --- /dev/null +++ b/mmdet/models/builder.py @@ -0,0 +1,43 @@ +from torch import nn + +from mmdet.utils import build_from_cfg +from .registry import (BACKBONES, DETECTORS, HEADS, LOSSES, NECKS, + ROI_EXTRACTORS, SHARED_HEADS) + + +def build(cfg, registry, default_args=None): + if isinstance(cfg, list): + modules = [ + build_from_cfg(cfg_, registry, default_args) for cfg_ in cfg + ] + return nn.Sequential(*modules) + else: + return build_from_cfg(cfg, registry, default_args) + + +def build_backbone(cfg): + return build(cfg, BACKBONES) + + +def build_neck(cfg): + return build(cfg, NECKS) + + +def build_roi_extractor(cfg): + return build(cfg, ROI_EXTRACTORS) + + +def build_shared_head(cfg): + return build(cfg, SHARED_HEADS) + + +def build_head(cfg): + return build(cfg, HEADS) + + +def build_loss(cfg): + return build(cfg, LOSSES) + + +def build_detector(cfg, train_cfg=None, test_cfg=None): + return build(cfg, DETECTORS, dict(train_cfg=train_cfg, test_cfg=test_cfg)) diff --git a/mmdet/models/detectors/__init__.py b/mmdet/models/detectors/__init__.py new file mode 100644 index 0000000..6612e07 --- /dev/null +++ b/mmdet/models/detectors/__init__.py @@ -0,0 +1,21 @@ +from .base import BaseDetector +from .cascade_rcnn import CascadeRCNN +from .double_head_rcnn import DoubleHeadRCNN +from .fast_rcnn import FastRCNN +from .faster_rcnn import FasterRCNN +from .fcos import FCOS +from .grid_rcnn import GridRCNN +from .htc import HybridTaskCascade +from .mask_rcnn import MaskRCNN +from .mask_scoring_rcnn import MaskScoringRCNN +from .retinanet import RetinaNet +from .rpn import RPN +from .single_stage import SingleStageDetector +from .two_stage import TwoStageDetector +from .ppdet import PPDet + +__all__ = [ + 'BaseDetector', 'SingleStageDetector', 'TwoStageDetector', 'RPN', + 'FastRCNN', 'FasterRCNN', 'MaskRCNN', 'CascadeRCNN', 'HybridTaskCascade', + 'DoubleHeadRCNN', 'RetinaNet', 'FCOS', 'GridRCNN', 'MaskScoringRCNN', 'PPDet' +] diff --git a/mmdet/models/detectors/base.py b/mmdet/models/detectors/base.py new file mode 100644 index 0000000..038dd10 --- /dev/null +++ b/mmdet/models/detectors/base.py @@ -0,0 +1,142 @@ +import logging +from abc import ABCMeta, abstractmethod + +import mmcv +import numpy as np +import pycocotools.mask as maskUtils +import torch.nn as nn + +from mmdet.core import auto_fp16, get_classes, tensor2imgs + + +class BaseDetector(nn.Module): + """Base class for detectors""" + + __metaclass__ = ABCMeta + + def __init__(self): + super(BaseDetector, self).__init__() + self.fp16_enabled = False + + @property + def with_neck(self): + return hasattr(self, 'neck') and self.neck is not None + + @property + def with_shared_head(self): + return hasattr(self, 'shared_head') and self.shared_head is not None + + @property + def with_bbox(self): + return hasattr(self, 'bbox_head') and self.bbox_head is not None + + @property + def with_mask(self): + return hasattr(self, 'mask_head') and self.mask_head is not None + + @abstractmethod + def extract_feat(self, imgs): + pass + + def extract_feats(self, imgs): + assert isinstance(imgs, list) + for img in imgs: + yield self.extract_feat(img) + + @abstractmethod + def forward_train(self, imgs, img_metas, **kwargs): + pass + + @abstractmethod + def simple_test(self, img, img_meta, **kwargs): + pass + + @abstractmethod + def aug_test(self, imgs, img_metas, **kwargs): + pass + + def init_weights(self, pretrained=None): + if pretrained is not None: + logger = logging.getLogger() + logger.info('load model from: {}'.format(pretrained)) + + def forward_test(self, imgs, img_metas, **kwargs): + for var, name in [(imgs, 'imgs'), (img_metas, 'img_metas')]: + if not isinstance(var, list): + raise TypeError('{} must be a list, but got {}'.format( + name, type(var))) + + num_augs = len(imgs) + if num_augs != len(img_metas): + raise ValueError( + 'num of augmentations ({}) != num of image meta ({})'.format( + len(imgs), len(img_metas))) + # TODO: remove the restriction of imgs_per_gpu == 1 when prepared + imgs_per_gpu = imgs[0].size(0) + assert imgs_per_gpu == 1 + + if num_augs == 1: + return self.simple_test(imgs[0], img_metas[0], **kwargs) + else: + return self.aug_test(imgs, img_metas, **kwargs) + + @auto_fp16(apply_to=('img', )) + def forward(self, img, img_meta, return_loss=True, **kwargs): + if return_loss: + return self.forward_train(img, img_meta, **kwargs) + else: + return self.forward_test(img, img_meta, **kwargs) + + def show_result(self, + data, + result, + img_norm_cfg, + dataset=None, + score_thr=0.3): + if isinstance(result, tuple): + bbox_result, segm_result = result + else: + bbox_result, segm_result = result, None + + img_tensor = data['img'][0] + img_metas = data['img_meta'][0].data[0] + imgs = tensor2imgs(img_tensor, **img_norm_cfg) + assert len(imgs) == len(img_metas) + + if dataset is None: + class_names = self.CLASSES + elif isinstance(dataset, str): + class_names = get_classes(dataset) + elif isinstance(dataset, (list, tuple)): + class_names = dataset + else: + raise TypeError( + 'dataset must be a valid dataset name or a sequence' + ' of class names, not {}'.format(type(dataset))) + + for img, img_meta in zip(imgs, img_metas): + h, w, _ = img_meta['img_shape'] + img_show = img[:h, :w, :] + + bboxes = np.vstack(bbox_result) + # draw segmentation masks + if segm_result is not None: + segms = mmcv.concat_list(segm_result) + inds = np.where(bboxes[:, -1] > score_thr)[0] + for i in inds: + color_mask = np.random.randint( + 0, 256, (1, 3), dtype=np.uint8) + mask = maskUtils.decode(segms[i]).astype(np.bool) + img_show[mask] = img_show[mask] * 0.5 + color_mask * 0.5 + # draw bounding boxes + labels = [ + np.full(bbox.shape[0], i, dtype=np.int32) + for i, bbox in enumerate(bbox_result) + ] + labels = np.concatenate(labels) + mmcv.imshow_det_bboxes( + img_show, + bboxes, + labels, + class_names=class_names, + score_thr=score_thr) diff --git a/mmdet/models/detectors/cascade_rcnn.py b/mmdet/models/detectors/cascade_rcnn.py new file mode 100644 index 0000000..bd878eb --- /dev/null +++ b/mmdet/models/detectors/cascade_rcnn.py @@ -0,0 +1,415 @@ +from __future__ import division + +import torch +import torch.nn as nn + +from mmdet.core import (bbox2result, bbox2roi, build_assigner, build_sampler, + merge_aug_masks) +from .. import builder +from ..registry import DETECTORS +from .base import BaseDetector +from .test_mixins import RPNTestMixin + + +@DETECTORS.register_module +class CascadeRCNN(BaseDetector, RPNTestMixin): + + def __init__(self, + num_stages, + backbone, + neck=None, + shared_head=None, + rpn_head=None, + bbox_roi_extractor=None, + bbox_head=None, + mask_roi_extractor=None, + mask_head=None, + train_cfg=None, + test_cfg=None, + pretrained=None): + assert bbox_roi_extractor is not None + assert bbox_head is not None + super(CascadeRCNN, self).__init__() + + self.num_stages = num_stages + self.backbone = builder.build_backbone(backbone) + + if neck is not None: + self.neck = builder.build_neck(neck) + + if rpn_head is not None: + self.rpn_head = builder.build_head(rpn_head) + + if shared_head is not None: + self.shared_head = builder.build_shared_head(shared_head) + + if bbox_head is not None: + self.bbox_roi_extractor = nn.ModuleList() + self.bbox_head = nn.ModuleList() + if not isinstance(bbox_roi_extractor, list): + bbox_roi_extractor = [ + bbox_roi_extractor for _ in range(num_stages) + ] + if not isinstance(bbox_head, list): + bbox_head = [bbox_head for _ in range(num_stages)] + assert len(bbox_roi_extractor) == len(bbox_head) == self.num_stages + for roi_extractor, head in zip(bbox_roi_extractor, bbox_head): + self.bbox_roi_extractor.append( + builder.build_roi_extractor(roi_extractor)) + self.bbox_head.append(builder.build_head(head)) + + if mask_head is not None: + self.mask_head = nn.ModuleList() + if not isinstance(mask_head, list): + mask_head = [mask_head for _ in range(num_stages)] + assert len(mask_head) == self.num_stages + for head in mask_head: + self.mask_head.append(builder.build_head(head)) + if mask_roi_extractor is not None: + self.share_roi_extractor = False + self.mask_roi_extractor = nn.ModuleList() + if not isinstance(mask_roi_extractor, list): + mask_roi_extractor = [ + mask_roi_extractor for _ in range(num_stages) + ] + assert len(mask_roi_extractor) == self.num_stages + for roi_extractor in mask_roi_extractor: + self.mask_roi_extractor.append( + builder.build_roi_extractor(roi_extractor)) + else: + self.share_roi_extractor = True + self.mask_roi_extractor = self.bbox_roi_extractor + + self.train_cfg = train_cfg + self.test_cfg = test_cfg + + self.init_weights(pretrained=pretrained) + + @property + def with_rpn(self): + return hasattr(self, 'rpn_head') and self.rpn_head is not None + + def init_weights(self, pretrained=None): + super(CascadeRCNN, self).init_weights(pretrained) + self.backbone.init_weights(pretrained=pretrained) + if self.with_neck: + if isinstance(self.neck, nn.Sequential): + for m in self.neck: + m.init_weights() + else: + self.neck.init_weights() + if self.with_rpn: + self.rpn_head.init_weights() + if self.with_shared_head: + self.shared_head.init_weights(pretrained=pretrained) + for i in range(self.num_stages): + if self.with_bbox: + self.bbox_roi_extractor[i].init_weights() + self.bbox_head[i].init_weights() + if self.with_mask: + if not self.share_roi_extractor: + self.mask_roi_extractor[i].init_weights() + self.mask_head[i].init_weights() + + def extract_feat(self, img): + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def forward_dummy(self, img): + outs = () + # backbone + x = self.extract_feat(img) + # rpn + if self.with_rpn: + rpn_outs = self.rpn_head(x) + outs = outs + (rpn_outs, ) + proposals = torch.randn(1000, 4).cuda() + # bbox heads + rois = bbox2roi([proposals]) + if self.with_bbox: + for i in range(self.num_stages): + bbox_feats = self.bbox_roi_extractor[i]( + x[:self.bbox_roi_extractor[i].num_inputs], rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + cls_score, bbox_pred = self.bbox_head[i](bbox_feats) + outs = outs + (cls_score, bbox_pred) + # mask heads + if self.with_mask: + mask_rois = rois[:100] + for i in range(self.num_stages): + mask_feats = self.mask_roi_extractor[i]( + x[:self.mask_roi_extractor[i].num_inputs], mask_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + mask_pred = self.mask_head[i](mask_feats) + outs = outs + (mask_pred, ) + return outs + + def forward_train(self, + img, + img_meta, + gt_bboxes, + gt_labels, + gt_bboxes_ignore=None, + gt_masks=None, + proposals=None): + x = self.extract_feat(img) + + losses = dict() + + if self.with_rpn: + rpn_outs = self.rpn_head(x) + rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, + self.train_cfg.rpn) + rpn_losses = self.rpn_head.loss( + *rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + losses.update(rpn_losses) + + proposal_cfg = self.train_cfg.get('rpn_proposal', + self.test_cfg.rpn) + proposal_inputs = rpn_outs + (img_meta, proposal_cfg) + proposal_list = self.rpn_head.get_bboxes(*proposal_inputs) + else: + proposal_list = proposals + + for i in range(self.num_stages): + self.current_stage = i + rcnn_train_cfg = self.train_cfg.rcnn[i] + lw = self.train_cfg.stage_loss_weights[i] + + # assign gts and sample proposals + sampling_results = [] + if self.with_bbox or self.with_mask: + bbox_assigner = build_assigner(rcnn_train_cfg.assigner) + bbox_sampler = build_sampler( + rcnn_train_cfg.sampler, context=self) + num_imgs = img.size(0) + if gt_bboxes_ignore is None: + gt_bboxes_ignore = [None for _ in range(num_imgs)] + + for j in range(num_imgs): + assign_result = bbox_assigner.assign( + proposal_list[j], gt_bboxes[j], gt_bboxes_ignore[j], + gt_labels[j]) + sampling_result = bbox_sampler.sample( + assign_result, + proposal_list[j], + gt_bboxes[j], + gt_labels[j], + feats=[lvl_feat[j][None] for lvl_feat in x]) + sampling_results.append(sampling_result) + + # bbox head forward and loss + bbox_roi_extractor = self.bbox_roi_extractor[i] + bbox_head = self.bbox_head[i] + + rois = bbox2roi([res.bboxes for res in sampling_results]) + bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs], + rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + cls_score, bbox_pred = bbox_head(bbox_feats) + + bbox_targets = bbox_head.get_target(sampling_results, gt_bboxes, + gt_labels, rcnn_train_cfg) + loss_bbox = bbox_head.loss(cls_score, bbox_pred, *bbox_targets) + for name, value in loss_bbox.items(): + losses['s{}.{}'.format(i, name)] = ( + value * lw if 'loss' in name else value) + + # mask head forward and loss + if self.with_mask: + if not self.share_roi_extractor: + mask_roi_extractor = self.mask_roi_extractor[i] + pos_rois = bbox2roi( + [res.pos_bboxes for res in sampling_results]) + mask_feats = mask_roi_extractor( + x[:mask_roi_extractor.num_inputs], pos_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + else: + # reuse positive bbox feats + pos_inds = [] + device = bbox_feats.device + for res in sampling_results: + pos_inds.append( + torch.ones( + res.pos_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds.append( + torch.zeros( + res.neg_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds = torch.cat(pos_inds) + mask_feats = bbox_feats[pos_inds] + mask_head = self.mask_head[i] + mask_pred = mask_head(mask_feats) + mask_targets = mask_head.get_target(sampling_results, gt_masks, + rcnn_train_cfg) + pos_labels = torch.cat( + [res.pos_gt_labels for res in sampling_results]) + loss_mask = mask_head.loss(mask_pred, mask_targets, pos_labels) + for name, value in loss_mask.items(): + losses['s{}.{}'.format(i, name)] = ( + value * lw if 'loss' in name else value) + + # refine bboxes + if i < self.num_stages - 1: + pos_is_gts = [res.pos_is_gt for res in sampling_results] + roi_labels = bbox_targets[0] # bbox_targets is a tuple + with torch.no_grad(): + proposal_list = bbox_head.refine_bboxes( + rois, roi_labels, bbox_pred, pos_is_gts, img_meta) + + return losses + + def simple_test(self, img, img_meta, proposals=None, rescale=False): + x = self.extract_feat(img) + proposal_list = self.simple_test_rpn( + x, img_meta, self.test_cfg.rpn) if proposals is None else proposals + + img_shape = img_meta[0]['img_shape'] + ori_shape = img_meta[0]['ori_shape'] + scale_factor = img_meta[0]['scale_factor'] + + # "ms" in variable names means multi-stage + ms_bbox_result = {} + ms_segm_result = {} + ms_scores = [] + rcnn_test_cfg = self.test_cfg.rcnn + + rois = bbox2roi(proposal_list) + for i in range(self.num_stages): + bbox_roi_extractor = self.bbox_roi_extractor[i] + bbox_head = self.bbox_head[i] + + bbox_feats = bbox_roi_extractor( + x[:len(bbox_roi_extractor.featmap_strides)], rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + + cls_score, bbox_pred = bbox_head(bbox_feats) + ms_scores.append(cls_score) + + if self.test_cfg.keep_all_stages: + det_bboxes, det_labels = bbox_head.get_det_bboxes( + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=rescale, + cfg=rcnn_test_cfg) + bbox_result = bbox2result(det_bboxes, det_labels, + bbox_head.num_classes) + ms_bbox_result['stage{}'.format(i)] = bbox_result + + if self.with_mask: + mask_roi_extractor = self.mask_roi_extractor[i] + mask_head = self.mask_head[i] + if det_bboxes.shape[0] == 0: + mask_classes = mask_head.num_classes - 1 + segm_result = [[] for _ in range(mask_classes)] + else: + _bboxes = ( + det_bboxes[:, :4] * + scale_factor if rescale else det_bboxes) + mask_rois = bbox2roi([_bboxes]) + mask_feats = mask_roi_extractor( + x[:len(mask_roi_extractor.featmap_strides)], + mask_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats, i) + mask_pred = mask_head(mask_feats) + segm_result = mask_head.get_seg_masks( + mask_pred, _bboxes, det_labels, rcnn_test_cfg, + ori_shape, scale_factor, rescale) + ms_segm_result['stage{}'.format(i)] = segm_result + + if i < self.num_stages - 1: + bbox_label = cls_score.argmax(dim=1) + rois = bbox_head.regress_by_class(rois, bbox_label, bbox_pred, + img_meta[0]) + + cls_score = sum(ms_scores) / self.num_stages + det_bboxes, det_labels = self.bbox_head[-1].get_det_bboxes( + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=rescale, + cfg=rcnn_test_cfg) + bbox_result = bbox2result(det_bboxes, det_labels, + self.bbox_head[-1].num_classes) + ms_bbox_result['ensemble'] = bbox_result + + if self.with_mask: + if det_bboxes.shape[0] == 0: + mask_classes = self.mask_head[-1].num_classes - 1 + segm_result = [[] for _ in range(mask_classes)] + else: + if isinstance(scale_factor, float): # aspect ratio fixed + _bboxes = ( + det_bboxes[:, :4] * + scale_factor if rescale else det_bboxes) + else: + _bboxes = ( + det_bboxes[:, :4] * + torch.from_numpy(scale_factor).to(det_bboxes.device) + if rescale else det_bboxes) + + mask_rois = bbox2roi([_bboxes]) + aug_masks = [] + for i in range(self.num_stages): + mask_roi_extractor = self.mask_roi_extractor[i] + mask_feats = mask_roi_extractor( + x[:len(mask_roi_extractor.featmap_strides)], mask_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + mask_pred = self.mask_head[i](mask_feats) + aug_masks.append(mask_pred.sigmoid().cpu().numpy()) + merged_masks = merge_aug_masks(aug_masks, + [img_meta] * self.num_stages, + self.test_cfg.rcnn) + segm_result = self.mask_head[-1].get_seg_masks( + merged_masks, _bboxes, det_labels, rcnn_test_cfg, + ori_shape, scale_factor, rescale) + ms_segm_result['ensemble'] = segm_result + + if not self.test_cfg.keep_all_stages: + if self.with_mask: + results = (ms_bbox_result['ensemble'], + ms_segm_result['ensemble']) + else: + results = ms_bbox_result['ensemble'] + else: + if self.with_mask: + results = { + stage: (ms_bbox_result[stage], ms_segm_result[stage]) + for stage in ms_bbox_result + } + else: + results = ms_bbox_result + + return results + + def aug_test(self, img, img_meta, proposals=None, rescale=False): + raise NotImplementedError + + def show_result(self, data, result, img_norm_cfg, **kwargs): + if self.with_mask: + ms_bbox_result, ms_segm_result = result + if isinstance(ms_bbox_result, dict): + result = (ms_bbox_result['ensemble'], + ms_segm_result['ensemble']) + else: + if isinstance(result, dict): + result = result['ensemble'] + super(CascadeRCNN, self).show_result(data, result, img_norm_cfg, + **kwargs) diff --git a/mmdet/models/detectors/double_head_rcnn.py b/mmdet/models/detectors/double_head_rcnn.py new file mode 100644 index 0000000..7a78335 --- /dev/null +++ b/mmdet/models/detectors/double_head_rcnn.py @@ -0,0 +1,178 @@ +import torch + +from mmdet.core import bbox2roi, build_assigner, build_sampler +from ..registry import DETECTORS +from .two_stage import TwoStageDetector + + +@DETECTORS.register_module +class DoubleHeadRCNN(TwoStageDetector): + + def __init__(self, reg_roi_scale_factor, **kwargs): + super().__init__(**kwargs) + self.reg_roi_scale_factor = reg_roi_scale_factor + + def forward_dummy(self, img): + outs = () + # backbone + x = self.extract_feat(img) + # rpn + if self.with_rpn: + rpn_outs = self.rpn_head(x) + outs = outs + (rpn_outs, ) + proposals = torch.randn(1000, 4).cuda() + # bbox head + rois = bbox2roi([proposals]) + bbox_cls_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + bbox_reg_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], + rois, + roi_scale_factor=self.reg_roi_scale_factor) + if self.with_shared_head: + bbox_cls_feats = self.shared_head(bbox_cls_feats) + bbox_reg_feats = self.shared_head(bbox_reg_feats) + cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats) + outs += (cls_score, bbox_pred) + return outs + + def forward_train(self, + img, + img_meta, + gt_bboxes, + gt_labels, + gt_bboxes_ignore=None, + gt_masks=None, + proposals=None): + x = self.extract_feat(img) + + losses = dict() + + # RPN forward and loss + if self.with_rpn: + rpn_outs = self.rpn_head(x) + rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, + self.train_cfg.rpn) + rpn_losses = self.rpn_head.loss( + *rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + losses.update(rpn_losses) + + proposal_cfg = self.train_cfg.get('rpn_proposal', + self.test_cfg.rpn) + proposal_inputs = rpn_outs + (img_meta, proposal_cfg) + proposal_list = self.rpn_head.get_bboxes(*proposal_inputs) + else: + proposal_list = proposals + + # assign gts and sample proposals + if self.with_bbox or self.with_mask: + bbox_assigner = build_assigner(self.train_cfg.rcnn.assigner) + bbox_sampler = build_sampler( + self.train_cfg.rcnn.sampler, context=self) + num_imgs = img.size(0) + if gt_bboxes_ignore is None: + gt_bboxes_ignore = [None for _ in range(num_imgs)] + sampling_results = [] + for i in range(num_imgs): + assign_result = bbox_assigner.assign(proposal_list[i], + gt_bboxes[i], + gt_bboxes_ignore[i], + gt_labels[i]) + sampling_result = bbox_sampler.sample( + assign_result, + proposal_list[i], + gt_bboxes[i], + gt_labels[i], + feats=[lvl_feat[i][None] for lvl_feat in x]) + sampling_results.append(sampling_result) + + # bbox head forward and loss + if self.with_bbox: + rois = bbox2roi([res.bboxes for res in sampling_results]) + # TODO: a more flexible way to decide which feature maps to use + bbox_cls_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + bbox_reg_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], + rois, + roi_scale_factor=self.reg_roi_scale_factor) + if self.with_shared_head: + bbox_cls_feats = self.shared_head(bbox_cls_feats) + bbox_reg_feats = self.shared_head(bbox_reg_feats) + cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, + bbox_reg_feats) + + bbox_targets = self.bbox_head.get_target(sampling_results, + gt_bboxes, gt_labels, + self.train_cfg.rcnn) + loss_bbox = self.bbox_head.loss(cls_score, bbox_pred, + *bbox_targets) + losses.update(loss_bbox) + + # mask head forward and loss + if self.with_mask: + if not self.share_roi_extractor: + pos_rois = bbox2roi( + [res.pos_bboxes for res in sampling_results]) + mask_feats = self.mask_roi_extractor( + x[:self.mask_roi_extractor.num_inputs], pos_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + else: + pos_inds = [] + device = bbox_cls_feats.device + for res in sampling_results: + pos_inds.append( + torch.ones( + res.pos_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds.append( + torch.zeros( + res.neg_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds = torch.cat(pos_inds) + mask_feats = bbox_cls_feats[pos_inds] + mask_pred = self.mask_head(mask_feats) + + mask_targets = self.mask_head.get_target(sampling_results, + gt_masks, + self.train_cfg.rcnn) + pos_labels = torch.cat( + [res.pos_gt_labels for res in sampling_results]) + loss_mask = self.mask_head.loss(mask_pred, mask_targets, + pos_labels) + losses.update(loss_mask) + + return losses + + def simple_test_bboxes(self, + x, + img_meta, + proposals, + rcnn_test_cfg, + rescale=False): + """Test only det bboxes without augmentation.""" + rois = bbox2roi(proposals) + bbox_cls_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + bbox_reg_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], + rois, + roi_scale_factor=self.reg_roi_scale_factor) + if self.with_shared_head: + bbox_cls_feats = self.shared_head(bbox_cls_feats) + bbox_reg_feats = self.shared_head(bbox_reg_feats) + cls_score, bbox_pred = self.bbox_head(bbox_cls_feats, bbox_reg_feats) + img_shape = img_meta[0]['img_shape'] + scale_factor = img_meta[0]['scale_factor'] + det_bboxes, det_labels = self.bbox_head.get_det_bboxes( + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=rescale, + cfg=rcnn_test_cfg) + return det_bboxes, det_labels diff --git a/mmdet/models/detectors/fast_rcnn.py b/mmdet/models/detectors/fast_rcnn.py new file mode 100644 index 0000000..9e3b2aa --- /dev/null +++ b/mmdet/models/detectors/fast_rcnn.py @@ -0,0 +1,50 @@ +from ..registry import DETECTORS +from .two_stage import TwoStageDetector + + +@DETECTORS.register_module +class FastRCNN(TwoStageDetector): + + def __init__(self, + backbone, + bbox_roi_extractor, + bbox_head, + train_cfg, + test_cfg, + neck=None, + shared_head=None, + mask_roi_extractor=None, + mask_head=None, + pretrained=None): + super(FastRCNN, self).__init__( + backbone=backbone, + neck=neck, + shared_head=shared_head, + bbox_roi_extractor=bbox_roi_extractor, + bbox_head=bbox_head, + train_cfg=train_cfg, + test_cfg=test_cfg, + mask_roi_extractor=mask_roi_extractor, + mask_head=mask_head, + pretrained=pretrained) + + def forward_test(self, imgs, img_metas, proposals, **kwargs): + for var, name in [(imgs, 'imgs'), (img_metas, 'img_metas')]: + if not isinstance(var, list): + raise TypeError('{} must be a list, but got {}'.format( + name, type(var))) + + num_augs = len(imgs) + if num_augs != len(img_metas): + raise ValueError( + 'num of augmentations ({}) != num of image meta ({})'.format( + len(imgs), len(img_metas))) + # TODO: remove the restriction of imgs_per_gpu == 1 when prepared + imgs_per_gpu = imgs[0].size(0) + assert imgs_per_gpu == 1 + + if num_augs == 1: + return self.simple_test(imgs[0], img_metas[0], proposals[0], + **kwargs) + else: + return self.aug_test(imgs, img_metas, proposals, **kwargs) diff --git a/mmdet/models/detectors/faster_rcnn.py b/mmdet/models/detectors/faster_rcnn.py new file mode 100644 index 0000000..969cd7c --- /dev/null +++ b/mmdet/models/detectors/faster_rcnn.py @@ -0,0 +1,27 @@ +from ..registry import DETECTORS +from .two_stage import TwoStageDetector + + +@DETECTORS.register_module +class FasterRCNN(TwoStageDetector): + + def __init__(self, + backbone, + rpn_head, + bbox_roi_extractor, + bbox_head, + train_cfg, + test_cfg, + neck=None, + shared_head=None, + pretrained=None): + super(FasterRCNN, self).__init__( + backbone=backbone, + neck=neck, + shared_head=shared_head, + rpn_head=rpn_head, + bbox_roi_extractor=bbox_roi_extractor, + bbox_head=bbox_head, + train_cfg=train_cfg, + test_cfg=test_cfg, + pretrained=pretrained) diff --git a/mmdet/models/detectors/fcos.py b/mmdet/models/detectors/fcos.py new file mode 100644 index 0000000..89cc592 --- /dev/null +++ b/mmdet/models/detectors/fcos.py @@ -0,0 +1,16 @@ +from ..registry import DETECTORS +from .single_stage import SingleStageDetector + + +@DETECTORS.register_module +class FCOS(SingleStageDetector): + + def __init__(self, + backbone, + neck, + bbox_head, + train_cfg=None, + test_cfg=None, + pretrained=None): + super(FCOS, self).__init__(backbone, neck, bbox_head, train_cfg, + test_cfg, pretrained) diff --git a/mmdet/models/detectors/grid_rcnn.py b/mmdet/models/detectors/grid_rcnn.py new file mode 100644 index 0000000..853242c --- /dev/null +++ b/mmdet/models/detectors/grid_rcnn.py @@ -0,0 +1,229 @@ +import torch + +from mmdet.core import bbox2result, bbox2roi, build_assigner, build_sampler +from .. import builder +from ..registry import DETECTORS +from .two_stage import TwoStageDetector + + +@DETECTORS.register_module +class GridRCNN(TwoStageDetector): + """Grid R-CNN. + + This detector is the implementation of: + - Grid R-CNN (https://arxiv.org/abs/1811.12030) + - Grid R-CNN Plus: Faster and Better (https://arxiv.org/abs/1906.05688) + """ + + def __init__(self, + backbone, + rpn_head, + bbox_roi_extractor, + bbox_head, + grid_roi_extractor, + grid_head, + train_cfg, + test_cfg, + neck=None, + shared_head=None, + pretrained=None): + assert grid_head is not None + super(GridRCNN, self).__init__( + backbone=backbone, + neck=neck, + shared_head=shared_head, + rpn_head=rpn_head, + bbox_roi_extractor=bbox_roi_extractor, + bbox_head=bbox_head, + train_cfg=train_cfg, + test_cfg=test_cfg, + pretrained=pretrained) + + if grid_roi_extractor is not None: + self.grid_roi_extractor = builder.build_roi_extractor( + grid_roi_extractor) + self.share_roi_extractor = False + else: + self.share_roi_extractor = True + self.grid_roi_extractor = self.bbox_roi_extractor + self.grid_head = builder.build_head(grid_head) + + self.init_extra_weights() + + def init_extra_weights(self): + self.grid_head.init_weights() + if not self.share_roi_extractor: + self.grid_roi_extractor.init_weights() + + def _random_jitter(self, sampling_results, img_metas, amplitude=0.15): + """Ramdom jitter positive proposals for training.""" + for sampling_result, img_meta in zip(sampling_results, img_metas): + bboxes = sampling_result.pos_bboxes + random_offsets = bboxes.new_empty(bboxes.shape[0], 4).uniform_( + -amplitude, amplitude) + # before jittering + cxcy = (bboxes[:, 2:4] + bboxes[:, :2]) / 2 + wh = (bboxes[:, 2:4] - bboxes[:, :2]).abs() + # after jittering + new_cxcy = cxcy + wh * random_offsets[:, :2] + new_wh = wh * (1 + random_offsets[:, 2:]) + # xywh to xyxy + new_x1y1 = (new_cxcy - new_wh / 2) + new_x2y2 = (new_cxcy + new_wh / 2) + new_bboxes = torch.cat([new_x1y1, new_x2y2], dim=1) + # clip bboxes + max_shape = img_meta['img_shape'] + if max_shape is not None: + new_bboxes[:, 0::2].clamp_(min=0, max=max_shape[1] - 1) + new_bboxes[:, 1::2].clamp_(min=0, max=max_shape[0] - 1) + + sampling_result.pos_bboxes = new_bboxes + return sampling_results + + def forward_dummy(self, img): + outs = () + # backbone + x = self.extract_feat(img) + # rpn + if self.with_rpn: + rpn_outs = self.rpn_head(x) + outs = outs + (rpn_outs, ) + proposals = torch.randn(1000, 4).cuda() + # bbox head + rois = bbox2roi([proposals]) + bbox_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + cls_score, bbox_pred = self.bbox_head(bbox_feats) + # grid head + grid_rois = rois[:100] + grid_feats = self.grid_roi_extractor( + x[:self.grid_roi_extractor.num_inputs], grid_rois) + if self.with_shared_head: + grid_feats = self.shared_head(grid_feats) + grid_pred = self.grid_head(grid_feats) + return rpn_outs, cls_score, bbox_pred, grid_pred + + def forward_train(self, + img, + img_meta, + gt_bboxes, + gt_labels, + gt_bboxes_ignore=None, + gt_masks=None, + proposals=None): + x = self.extract_feat(img) + + losses = dict() + + # RPN forward and loss + if self.with_rpn: + rpn_outs = self.rpn_head(x) + rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, + self.train_cfg.rpn) + rpn_losses = self.rpn_head.loss( + *rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + losses.update(rpn_losses) + + proposal_cfg = self.train_cfg.get('rpn_proposal', + self.test_cfg.rpn) + proposal_inputs = rpn_outs + (img_meta, proposal_cfg) + proposal_list = self.rpn_head.get_bboxes(*proposal_inputs) + else: + proposal_list = proposals + + if self.with_bbox: + # assign gts and sample proposals + bbox_assigner = build_assigner(self.train_cfg.rcnn.assigner) + bbox_sampler = build_sampler( + self.train_cfg.rcnn.sampler, context=self) + num_imgs = img.size(0) + if gt_bboxes_ignore is None: + gt_bboxes_ignore = [None for _ in range(num_imgs)] + sampling_results = [] + for i in range(num_imgs): + assign_result = bbox_assigner.assign(proposal_list[i], + gt_bboxes[i], + gt_bboxes_ignore[i], + gt_labels[i]) + sampling_result = bbox_sampler.sample( + assign_result, + proposal_list[i], + gt_bboxes[i], + gt_labels[i], + feats=[lvl_feat[i][None] for lvl_feat in x]) + sampling_results.append(sampling_result) + + # bbox head forward and loss + rois = bbox2roi([res.bboxes for res in sampling_results]) + # TODO: a more flexible way to decide which feature maps to use + bbox_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + cls_score, bbox_pred = self.bbox_head(bbox_feats) + + bbox_targets = self.bbox_head.get_target(sampling_results, + gt_bboxes, gt_labels, + self.train_cfg.rcnn) + loss_bbox = self.bbox_head.loss(cls_score, bbox_pred, + *bbox_targets) + losses.update(loss_bbox) + + # Grid head forward and loss + sampling_results = self._random_jitter(sampling_results, img_meta) + pos_rois = bbox2roi([res.pos_bboxes for res in sampling_results]) + grid_feats = self.grid_roi_extractor( + x[:self.grid_roi_extractor.num_inputs], pos_rois) + if self.with_shared_head: + grid_feats = self.shared_head(grid_feats) + # Accelerate training + max_sample_num_grid = self.train_cfg.rcnn.get('max_num_grid', 192) + sample_idx = torch.randperm( + grid_feats.shape[0])[:min(grid_feats. + shape[0], max_sample_num_grid)] + grid_feats = grid_feats[sample_idx] + + grid_pred = self.grid_head(grid_feats) + + grid_targets = self.grid_head.get_target(sampling_results, + self.train_cfg.rcnn) + grid_targets = grid_targets[sample_idx] + + loss_grid = self.grid_head.loss(grid_pred, grid_targets) + losses.update(loss_grid) + + return losses + + def simple_test(self, img, img_meta, proposals=None, rescale=False): + """Test without augmentation.""" + assert self.with_bbox, "Bbox head must be implemented." + + x = self.extract_feat(img) + + proposal_list = self.simple_test_rpn( + x, img_meta, self.test_cfg.rpn) if proposals is None else proposals + + det_bboxes, det_labels = self.simple_test_bboxes( + x, img_meta, proposal_list, self.test_cfg.rcnn, rescale=False) + + # pack rois into bboxes + grid_rois = bbox2roi([det_bboxes[:, :4]]) + grid_feats = self.grid_roi_extractor( + x[:len(self.grid_roi_extractor.featmap_strides)], grid_rois) + if grid_rois.shape[0] != 0: + self.grid_head.test_mode = True + grid_pred = self.grid_head(grid_feats) + det_bboxes = self.grid_head.get_bboxes(det_bboxes, + grid_pred['fused'], + img_meta) + if rescale: + det_bboxes[:, :4] /= img_meta[0]['scale_factor'] + else: + det_bboxes = torch.Tensor([]) + + bbox_results = bbox2result(det_bboxes, det_labels, + self.bbox_head.num_classes) + + return bbox_results diff --git a/mmdet/models/detectors/htc.py b/mmdet/models/detectors/htc.py new file mode 100644 index 0000000..d0a7024 --- /dev/null +++ b/mmdet/models/detectors/htc.py @@ -0,0 +1,435 @@ +import torch +import torch.nn.functional as F + +from mmdet.core import (bbox2result, bbox2roi, build_assigner, build_sampler, + merge_aug_masks) +from .. import builder +from ..registry import DETECTORS +from .cascade_rcnn import CascadeRCNN + + +@DETECTORS.register_module +class HybridTaskCascade(CascadeRCNN): + + def __init__(self, + num_stages, + backbone, + semantic_roi_extractor=None, + semantic_head=None, + semantic_fusion=('bbox', 'mask'), + interleaved=True, + mask_info_flow=True, + **kwargs): + super(HybridTaskCascade, self).__init__(num_stages, backbone, **kwargs) + assert self.with_bbox and self.with_mask + assert not self.with_shared_head # shared head not supported + if semantic_head is not None: + self.semantic_roi_extractor = builder.build_roi_extractor( + semantic_roi_extractor) + self.semantic_head = builder.build_head(semantic_head) + + self.semantic_fusion = semantic_fusion + self.interleaved = interleaved + self.mask_info_flow = mask_info_flow + + @property + def with_semantic(self): + if hasattr(self, 'semantic_head') and self.semantic_head is not None: + return True + else: + return False + + def _bbox_forward_train(self, + stage, + x, + sampling_results, + gt_bboxes, + gt_labels, + rcnn_train_cfg, + semantic_feat=None): + rois = bbox2roi([res.bboxes for res in sampling_results]) + bbox_roi_extractor = self.bbox_roi_extractor[stage] + bbox_head = self.bbox_head[stage] + bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs], + rois) + # semantic feature fusion + # element-wise sum for original features and pooled semantic features + if self.with_semantic and 'bbox' in self.semantic_fusion: + bbox_semantic_feat = self.semantic_roi_extractor([semantic_feat], + rois) + if bbox_semantic_feat.shape[-2:] != bbox_feats.shape[-2:]: + bbox_semantic_feat = F.adaptive_avg_pool2d( + bbox_semantic_feat, bbox_feats.shape[-2:]) + bbox_feats += bbox_semantic_feat + + cls_score, bbox_pred = bbox_head(bbox_feats) + + bbox_targets = bbox_head.get_target(sampling_results, gt_bboxes, + gt_labels, rcnn_train_cfg) + loss_bbox = bbox_head.loss(cls_score, bbox_pred, *bbox_targets) + return loss_bbox, rois, bbox_targets, bbox_pred + + def _mask_forward_train(self, + stage, + x, + sampling_results, + gt_masks, + rcnn_train_cfg, + semantic_feat=None): + mask_roi_extractor = self.mask_roi_extractor[stage] + mask_head = self.mask_head[stage] + pos_rois = bbox2roi([res.pos_bboxes for res in sampling_results]) + mask_feats = mask_roi_extractor(x[:mask_roi_extractor.num_inputs], + pos_rois) + + # semantic feature fusion + # element-wise sum for original features and pooled semantic features + if self.with_semantic and 'mask' in self.semantic_fusion: + mask_semantic_feat = self.semantic_roi_extractor([semantic_feat], + pos_rois) + if mask_semantic_feat.shape[-2:] != mask_feats.shape[-2:]: + mask_semantic_feat = F.adaptive_avg_pool2d( + mask_semantic_feat, mask_feats.shape[-2:]) + mask_feats += mask_semantic_feat + + # mask information flow + # forward all previous mask heads to obtain last_feat, and fuse it + # with the normal mask feature + if self.mask_info_flow: + last_feat = None + for i in range(stage): + last_feat = self.mask_head[i]( + mask_feats, last_feat, return_logits=False) + mask_pred = mask_head(mask_feats, last_feat, return_feat=False) + else: + mask_pred = mask_head(mask_feats) + + mask_targets = mask_head.get_target(sampling_results, gt_masks, + rcnn_train_cfg) + pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results]) + loss_mask = mask_head.loss(mask_pred, mask_targets, pos_labels) + return loss_mask + + def _bbox_forward_test(self, stage, x, rois, semantic_feat=None): + bbox_roi_extractor = self.bbox_roi_extractor[stage] + bbox_head = self.bbox_head[stage] + bbox_feats = bbox_roi_extractor( + x[:len(bbox_roi_extractor.featmap_strides)], rois) + if self.with_semantic and 'bbox' in self.semantic_fusion: + bbox_semantic_feat = self.semantic_roi_extractor([semantic_feat], + rois) + if bbox_semantic_feat.shape[-2:] != bbox_feats.shape[-2:]: + bbox_semantic_feat = F.adaptive_avg_pool2d( + bbox_semantic_feat, bbox_feats.shape[-2:]) + bbox_feats += bbox_semantic_feat + cls_score, bbox_pred = bbox_head(bbox_feats) + return cls_score, bbox_pred + + def _mask_forward_test(self, stage, x, bboxes, semantic_feat=None): + mask_roi_extractor = self.mask_roi_extractor[stage] + mask_head = self.mask_head[stage] + mask_rois = bbox2roi([bboxes]) + mask_feats = mask_roi_extractor( + x[:len(mask_roi_extractor.featmap_strides)], mask_rois) + if self.with_semantic and 'mask' in self.semantic_fusion: + mask_semantic_feat = self.semantic_roi_extractor([semantic_feat], + mask_rois) + if mask_semantic_feat.shape[-2:] != mask_feats.shape[-2:]: + mask_semantic_feat = F.adaptive_avg_pool2d( + mask_semantic_feat, mask_feats.shape[-2:]) + mask_feats += mask_semantic_feat + if self.mask_info_flow: + last_feat = None + last_pred = None + for i in range(stage): + mask_pred, last_feat = self.mask_head[i](mask_feats, last_feat) + if last_pred is not None: + mask_pred = mask_pred + last_pred + last_pred = mask_pred + mask_pred = mask_head(mask_feats, last_feat, return_feat=False) + if last_pred is not None: + mask_pred = mask_pred + last_pred + else: + mask_pred = mask_head(mask_feats) + return mask_pred + + def forward_dummy(self, img): + outs = () + # backbone + x = self.extract_feat(img) + # rpn + if self.with_rpn: + rpn_outs = self.rpn_head(x) + outs = outs + (rpn_outs, ) + proposals = torch.randn(1000, 4).cuda() + # semantic head + if self.with_semantic: + _, semantic_feat = self.semantic_head(x) + else: + semantic_feat = None + # bbox heads + rois = bbox2roi([proposals]) + for i in range(self.num_stages): + cls_score, bbox_pred = self._bbox_forward_test( + i, x, rois, semantic_feat=semantic_feat) + outs = outs + (cls_score, bbox_pred) + # mask heads + if self.with_mask: + mask_rois = rois[:100] + mask_roi_extractor = self.mask_roi_extractor[-1] + mask_feats = mask_roi_extractor( + x[:len(mask_roi_extractor.featmap_strides)], mask_rois) + if self.with_semantic and 'mask' in self.semantic_fusion: + mask_semantic_feat = self.semantic_roi_extractor( + [semantic_feat], mask_rois) + mask_feats += mask_semantic_feat + last_feat = None + for i in range(self.num_stages): + mask_head = self.mask_head[i] + if self.mask_info_flow: + mask_pred, last_feat = mask_head(mask_feats, last_feat) + else: + mask_pred = mask_head(mask_feats) + outs = outs + (mask_pred, ) + return outs + + def forward_train(self, + img, + img_meta, + gt_bboxes, + gt_labels, + gt_bboxes_ignore=None, + gt_masks=None, + gt_semantic_seg=None, + proposals=None): + x = self.extract_feat(img) + + losses = dict() + + # RPN part, the same as normal two-stage detectors + if self.with_rpn: + rpn_outs = self.rpn_head(x) + rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, + self.train_cfg.rpn) + rpn_losses = self.rpn_head.loss( + *rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + losses.update(rpn_losses) + + proposal_cfg = self.train_cfg.get('rpn_proposal', + self.test_cfg.rpn) + proposal_inputs = rpn_outs + (img_meta, proposal_cfg) + proposal_list = self.rpn_head.get_bboxes(*proposal_inputs) + else: + proposal_list = proposals + + # semantic segmentation part + # 2 outputs: segmentation prediction and embedded features + if self.with_semantic: + semantic_pred, semantic_feat = self.semantic_head(x) + loss_seg = self.semantic_head.loss(semantic_pred, gt_semantic_seg) + losses['loss_semantic_seg'] = loss_seg + else: + semantic_feat = None + + for i in range(self.num_stages): + self.current_stage = i + rcnn_train_cfg = self.train_cfg.rcnn[i] + lw = self.train_cfg.stage_loss_weights[i] + + # assign gts and sample proposals + sampling_results = [] + bbox_assigner = build_assigner(rcnn_train_cfg.assigner) + bbox_sampler = build_sampler(rcnn_train_cfg.sampler, context=self) + num_imgs = img.size(0) + if gt_bboxes_ignore is None: + gt_bboxes_ignore = [None for _ in range(num_imgs)] + + for j in range(num_imgs): + assign_result = bbox_assigner.assign(proposal_list[j], + gt_bboxes[j], + gt_bboxes_ignore[j], + gt_labels[j]) + sampling_result = bbox_sampler.sample( + assign_result, + proposal_list[j], + gt_bboxes[j], + gt_labels[j], + feats=[lvl_feat[j][None] for lvl_feat in x]) + sampling_results.append(sampling_result) + + # bbox head forward and loss + loss_bbox, rois, bbox_targets, bbox_pred = \ + self._bbox_forward_train( + i, x, sampling_results, gt_bboxes, gt_labels, + rcnn_train_cfg, semantic_feat) + roi_labels = bbox_targets[0] + + for name, value in loss_bbox.items(): + losses['s{}.{}'.format(i, name)] = ( + value * lw if 'loss' in name else value) + + # mask head forward and loss + if self.with_mask: + # interleaved execution: use regressed bboxes by the box branch + # to train the mask branch + if self.interleaved: + pos_is_gts = [res.pos_is_gt for res in sampling_results] + with torch.no_grad(): + proposal_list = self.bbox_head[i].refine_bboxes( + rois, roi_labels, bbox_pred, pos_is_gts, img_meta) + # re-assign and sample 512 RoIs from 512 RoIs + sampling_results = [] + for j in range(num_imgs): + assign_result = bbox_assigner.assign( + proposal_list[j], gt_bboxes[j], + gt_bboxes_ignore[j], gt_labels[j]) + sampling_result = bbox_sampler.sample( + assign_result, + proposal_list[j], + gt_bboxes[j], + gt_labels[j], + feats=[lvl_feat[j][None] for lvl_feat in x]) + sampling_results.append(sampling_result) + loss_mask = self._mask_forward_train(i, x, sampling_results, + gt_masks, rcnn_train_cfg, + semantic_feat) + for name, value in loss_mask.items(): + losses['s{}.{}'.format(i, name)] = ( + value * lw if 'loss' in name else value) + + # refine bboxes (same as Cascade R-CNN) + if i < self.num_stages - 1 and not self.interleaved: + pos_is_gts = [res.pos_is_gt for res in sampling_results] + with torch.no_grad(): + proposal_list = self.bbox_head[i].refine_bboxes( + rois, roi_labels, bbox_pred, pos_is_gts, img_meta) + + return losses + + def simple_test(self, img, img_meta, proposals=None, rescale=False): + x = self.extract_feat(img) + proposal_list = self.simple_test_rpn( + x, img_meta, self.test_cfg.rpn) if proposals is None else proposals + + if self.with_semantic: + _, semantic_feat = self.semantic_head(x) + else: + semantic_feat = None + + img_shape = img_meta[0]['img_shape'] + ori_shape = img_meta[0]['ori_shape'] + scale_factor = img_meta[0]['scale_factor'] + + # "ms" in variable names means multi-stage + ms_bbox_result = {} + ms_segm_result = {} + ms_scores = [] + rcnn_test_cfg = self.test_cfg.rcnn + + rois = bbox2roi(proposal_list) + for i in range(self.num_stages): + bbox_head = self.bbox_head[i] + cls_score, bbox_pred = self._bbox_forward_test( + i, x, rois, semantic_feat=semantic_feat) + ms_scores.append(cls_score) + + if self.test_cfg.keep_all_stages: + det_bboxes, det_labels = bbox_head.get_det_bboxes( + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=rescale, + nms_cfg=rcnn_test_cfg) + bbox_result = bbox2result(det_bboxes, det_labels, + bbox_head.num_classes) + ms_bbox_result['stage{}'.format(i)] = bbox_result + + if self.with_mask: + mask_head = self.mask_head[i] + if det_bboxes.shape[0] == 0: + mask_classes = mask_head.num_classes - 1 + segm_result = [[] for _ in range(mask_classes)] + else: + _bboxes = ( + det_bboxes[:, :4] * + scale_factor if rescale else det_bboxes) + mask_pred = self._mask_forward_test( + i, x, _bboxes, semantic_feat=semantic_feat) + segm_result = mask_head.get_seg_masks( + mask_pred, _bboxes, det_labels, rcnn_test_cfg, + ori_shape, scale_factor, rescale) + ms_segm_result['stage{}'.format(i)] = segm_result + + if i < self.num_stages - 1: + bbox_label = cls_score.argmax(dim=1) + rois = bbox_head.regress_by_class(rois, bbox_label, bbox_pred, + img_meta[0]) + + cls_score = sum(ms_scores) / float(len(ms_scores)) + det_bboxes, det_labels = self.bbox_head[-1].get_det_bboxes( + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=rescale, + cfg=rcnn_test_cfg) + bbox_result = bbox2result(det_bboxes, det_labels, + self.bbox_head[-1].num_classes) + ms_bbox_result['ensemble'] = bbox_result + + if self.with_mask: + if det_bboxes.shape[0] == 0: + mask_classes = self.mask_head[-1].num_classes - 1 + segm_result = [[] for _ in range(mask_classes)] + else: + _bboxes = ( + det_bboxes[:, :4] * + scale_factor if rescale else det_bboxes) + + mask_rois = bbox2roi([_bboxes]) + aug_masks = [] + mask_roi_extractor = self.mask_roi_extractor[-1] + mask_feats = mask_roi_extractor( + x[:len(mask_roi_extractor.featmap_strides)], mask_rois) + if self.with_semantic and 'mask' in self.semantic_fusion: + mask_semantic_feat = self.semantic_roi_extractor( + [semantic_feat], mask_rois) + mask_feats += mask_semantic_feat + last_feat = None + for i in range(self.num_stages): + mask_head = self.mask_head[i] + if self.mask_info_flow: + mask_pred, last_feat = mask_head(mask_feats, last_feat) + else: + mask_pred = mask_head(mask_feats) + aug_masks.append(mask_pred.sigmoid().cpu().numpy()) + merged_masks = merge_aug_masks(aug_masks, + [img_meta] * self.num_stages, + self.test_cfg.rcnn) + segm_result = self.mask_head[-1].get_seg_masks( + merged_masks, _bboxes, det_labels, rcnn_test_cfg, + ori_shape, scale_factor, rescale) + ms_segm_result['ensemble'] = segm_result + + if not self.test_cfg.keep_all_stages: + if self.with_mask: + results = (ms_bbox_result['ensemble'], + ms_segm_result['ensemble']) + else: + results = ms_bbox_result['ensemble'] + else: + if self.with_mask: + results = { + stage: (ms_bbox_result[stage], ms_segm_result[stage]) + for stage in ms_bbox_result + } + else: + results = ms_bbox_result + + return results + + def aug_test(self, img, img_meta, proposals=None, rescale=False): + raise NotImplementedError diff --git a/mmdet/models/detectors/mask_rcnn.py b/mmdet/models/detectors/mask_rcnn.py new file mode 100644 index 0000000..becfdad --- /dev/null +++ b/mmdet/models/detectors/mask_rcnn.py @@ -0,0 +1,31 @@ +from ..registry import DETECTORS +from .two_stage import TwoStageDetector + + +@DETECTORS.register_module +class MaskRCNN(TwoStageDetector): + + def __init__(self, + backbone, + rpn_head, + bbox_roi_extractor, + bbox_head, + mask_roi_extractor, + mask_head, + train_cfg, + test_cfg, + neck=None, + shared_head=None, + pretrained=None): + super(MaskRCNN, self).__init__( + backbone=backbone, + neck=neck, + shared_head=shared_head, + rpn_head=rpn_head, + bbox_roi_extractor=bbox_roi_extractor, + bbox_head=bbox_head, + mask_roi_extractor=mask_roi_extractor, + mask_head=mask_head, + train_cfg=train_cfg, + test_cfg=test_cfg, + pretrained=pretrained) diff --git a/mmdet/models/detectors/mask_scoring_rcnn.py b/mmdet/models/detectors/mask_scoring_rcnn.py new file mode 100644 index 0000000..9c16ab1 --- /dev/null +++ b/mmdet/models/detectors/mask_scoring_rcnn.py @@ -0,0 +1,200 @@ +import torch + +from mmdet.core import bbox2roi, build_assigner, build_sampler +from .. import builder +from ..registry import DETECTORS +from .two_stage import TwoStageDetector + + +@DETECTORS.register_module +class MaskScoringRCNN(TwoStageDetector): + """Mask Scoring RCNN. + + https://arxiv.org/abs/1903.00241 + """ + + def __init__(self, + backbone, + rpn_head, + bbox_roi_extractor, + bbox_head, + mask_roi_extractor, + mask_head, + train_cfg, + test_cfg, + neck=None, + shared_head=None, + mask_iou_head=None, + pretrained=None): + super(MaskScoringRCNN, self).__init__( + backbone=backbone, + neck=neck, + shared_head=shared_head, + rpn_head=rpn_head, + bbox_roi_extractor=bbox_roi_extractor, + bbox_head=bbox_head, + mask_roi_extractor=mask_roi_extractor, + mask_head=mask_head, + train_cfg=train_cfg, + test_cfg=test_cfg, + pretrained=pretrained) + + self.mask_iou_head = builder.build_head(mask_iou_head) + self.mask_iou_head.init_weights() + + def forward_dummy(self, img): + raise NotImplementedError + + # TODO: refactor forward_train in two stage to reduce code redundancy + def forward_train(self, + img, + img_meta, + gt_bboxes, + gt_labels, + gt_bboxes_ignore=None, + gt_masks=None, + proposals=None): + x = self.extract_feat(img) + + losses = dict() + + # RPN forward and loss + if self.with_rpn: + rpn_outs = self.rpn_head(x) + rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, + self.train_cfg.rpn) + rpn_losses = self.rpn_head.loss( + *rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + losses.update(rpn_losses) + + proposal_cfg = self.train_cfg.get('rpn_proposal', + self.test_cfg.rpn) + proposal_inputs = rpn_outs + (img_meta, proposal_cfg) + proposal_list = self.rpn_head.get_bboxes(*proposal_inputs) + else: + proposal_list = proposals + + # assign gts and sample proposals + if self.with_bbox or self.with_mask: + bbox_assigner = build_assigner(self.train_cfg.rcnn.assigner) + bbox_sampler = build_sampler( + self.train_cfg.rcnn.sampler, context=self) + num_imgs = img.size(0) + if gt_bboxes_ignore is None: + gt_bboxes_ignore = [None for _ in range(num_imgs)] + sampling_results = [] + for i in range(num_imgs): + assign_result = bbox_assigner.assign(proposal_list[i], + gt_bboxes[i], + gt_bboxes_ignore[i], + gt_labels[i]) + sampling_result = bbox_sampler.sample( + assign_result, + proposal_list[i], + gt_bboxes[i], + gt_labels[i], + feats=[lvl_feat[i][None] for lvl_feat in x]) + sampling_results.append(sampling_result) + + # bbox head forward and loss + if self.with_bbox: + rois = bbox2roi([res.bboxes for res in sampling_results]) + # TODO: a more flexible way to decide which feature maps to use + bbox_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + cls_score, bbox_pred = self.bbox_head(bbox_feats) + + bbox_targets = self.bbox_head.get_target(sampling_results, + gt_bboxes, gt_labels, + self.train_cfg.rcnn) + loss_bbox = self.bbox_head.loss(cls_score, bbox_pred, + *bbox_targets) + losses.update(loss_bbox) + + # mask head forward and loss + if self.with_mask: + if not self.share_roi_extractor: + pos_rois = bbox2roi( + [res.pos_bboxes for res in sampling_results]) + mask_feats = self.mask_roi_extractor( + x[:self.mask_roi_extractor.num_inputs], pos_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + else: + pos_inds = [] + device = bbox_feats.device + for res in sampling_results: + pos_inds.append( + torch.ones( + res.pos_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds.append( + torch.zeros( + res.neg_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds = torch.cat(pos_inds) + mask_feats = bbox_feats[pos_inds] + mask_pred = self.mask_head(mask_feats) + + mask_targets = self.mask_head.get_target(sampling_results, + gt_masks, + self.train_cfg.rcnn) + pos_labels = torch.cat( + [res.pos_gt_labels for res in sampling_results]) + loss_mask = self.mask_head.loss(mask_pred, mask_targets, + pos_labels) + losses.update(loss_mask) + + # mask iou head forward and loss + pos_mask_pred = mask_pred[range(mask_pred.size(0)), pos_labels] + mask_iou_pred = self.mask_iou_head(mask_feats, pos_mask_pred) + pos_mask_iou_pred = mask_iou_pred[range(mask_iou_pred.size(0) + ), pos_labels] + mask_iou_targets = self.mask_iou_head.get_target( + sampling_results, gt_masks, pos_mask_pred, mask_targets, + self.train_cfg.rcnn) + loss_mask_iou = self.mask_iou_head.loss(pos_mask_iou_pred, + mask_iou_targets) + losses.update(loss_mask_iou) + return losses + + def simple_test_mask(self, + x, + img_meta, + det_bboxes, + det_labels, + rescale=False): + # image shape of the first image in the batch (only one) + ori_shape = img_meta[0]['ori_shape'] + scale_factor = img_meta[0]['scale_factor'] + + if det_bboxes.shape[0] == 0: + segm_result = [[] for _ in range(self.mask_head.num_classes - 1)] + mask_scores = [[] for _ in range(self.mask_head.num_classes - 1)] + else: + # if det_bboxes is rescaled to the original image size, we need to + # rescale it back to the testing scale to obtain RoIs. + _bboxes = ( + det_bboxes[:, :4] * scale_factor if rescale else det_bboxes) + mask_rois = bbox2roi([_bboxes]) + mask_feats = self.mask_roi_extractor( + x[:len(self.mask_roi_extractor.featmap_strides)], mask_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + mask_pred = self.mask_head(mask_feats) + segm_result = self.mask_head.get_seg_masks(mask_pred, _bboxes, + det_labels, + self.test_cfg.rcnn, + ori_shape, scale_factor, + rescale) + # get mask scores with mask iou head + mask_iou_pred = self.mask_iou_head( + mask_feats, + mask_pred[range(det_labels.size(0)), det_labels + 1]) + mask_scores = self.mask_iou_head.get_mask_scores( + mask_iou_pred, det_bboxes, det_labels) + return segm_result, mask_scores diff --git a/mmdet/models/detectors/ppdet.py b/mmdet/models/detectors/ppdet.py new file mode 100644 index 0000000..a7c564f --- /dev/null +++ b/mmdet/models/detectors/ppdet.py @@ -0,0 +1,16 @@ +from .single_stage import SingleStageDetector +from ..registry import DETECTORS + + +@DETECTORS.register_module +class PPDet(SingleStageDetector): + + def __init__(self, + backbone, + neck, + bbox_head, + train_cfg=None, + test_cfg=None, + pretrained=None): + super(PPDet, self).__init__(backbone, neck, bbox_head, train_cfg, + test_cfg, pretrained) \ No newline at end of file diff --git a/mmdet/models/detectors/retinanet.py b/mmdet/models/detectors/retinanet.py new file mode 100644 index 0000000..7c93d74 --- /dev/null +++ b/mmdet/models/detectors/retinanet.py @@ -0,0 +1,16 @@ +from ..registry import DETECTORS +from .single_stage import SingleStageDetector + + +@DETECTORS.register_module +class RetinaNet(SingleStageDetector): + + def __init__(self, + backbone, + neck, + bbox_head, + train_cfg=None, + test_cfg=None, + pretrained=None): + super(RetinaNet, self).__init__(backbone, neck, bbox_head, train_cfg, + test_cfg, pretrained) diff --git a/mmdet/models/detectors/rpn.py b/mmdet/models/detectors/rpn.py new file mode 100644 index 0000000..c9de290 --- /dev/null +++ b/mmdet/models/detectors/rpn.py @@ -0,0 +1,97 @@ +import mmcv + +from mmdet.core import bbox_mapping, tensor2imgs +from .. import builder +from ..registry import DETECTORS +from .base import BaseDetector +from .test_mixins import RPNTestMixin + + +@DETECTORS.register_module +class RPN(BaseDetector, RPNTestMixin): + + def __init__(self, + backbone, + neck, + rpn_head, + train_cfg, + test_cfg, + pretrained=None): + super(RPN, self).__init__() + self.backbone = builder.build_backbone(backbone) + self.neck = builder.build_neck(neck) if neck is not None else None + self.rpn_head = builder.build_head(rpn_head) + self.train_cfg = train_cfg + self.test_cfg = test_cfg + self.init_weights(pretrained=pretrained) + + def init_weights(self, pretrained=None): + super(RPN, self).init_weights(pretrained) + self.backbone.init_weights(pretrained=pretrained) + if self.with_neck: + self.neck.init_weights() + self.rpn_head.init_weights() + + def extract_feat(self, img): + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def forward_dummy(self, img): + x = self.extract_feat(img) + rpn_outs = self.rpn_head(x) + return rpn_outs + + def forward_train(self, + img, + img_meta, + gt_bboxes=None, + gt_bboxes_ignore=None): + if self.train_cfg.rpn.get('debug', False): + self.rpn_head.debug_imgs = tensor2imgs(img) + + x = self.extract_feat(img) + rpn_outs = self.rpn_head(x) + + rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, self.train_cfg.rpn) + losses = self.rpn_head.loss( + *rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + return losses + + def simple_test(self, img, img_meta, rescale=False): + x = self.extract_feat(img) + proposal_list = self.simple_test_rpn(x, img_meta, self.test_cfg.rpn) + if rescale: + for proposals, meta in zip(proposal_list, img_meta): + proposals[:, :4] /= meta['scale_factor'] + # TODO: remove this restriction + return proposal_list[0].cpu().numpy() + + def aug_test(self, imgs, img_metas, rescale=False): + proposal_list = self.aug_test_rpn( + self.extract_feats(imgs), img_metas, self.test_cfg.rpn) + if not rescale: + for proposals, img_meta in zip(proposal_list, img_metas[0]): + img_shape = img_meta['img_shape'] + scale_factor = img_meta['scale_factor'] + flip = img_meta['flip'] + proposals[:, :4] = bbox_mapping(proposals[:, :4], img_shape, + scale_factor, flip) + # TODO: remove this restriction + return proposal_list[0].cpu().numpy() + + def show_result(self, data, result, img_norm_cfg, dataset=None, top_k=20): + """Show RPN proposals on the image. + + Although we assume batch size is 1, this method supports arbitrary + batch size. + """ + img_tensor = data['img'][0] + img_metas = data['img_meta'][0].data[0] + imgs = tensor2imgs(img_tensor, **img_norm_cfg) + assert len(imgs) == len(img_metas) + for img, img_meta in zip(imgs, img_metas): + h, w, _ = img_meta['img_shape'] + img_show = img[:h, :w, :] + mmcv.imshow_bboxes(img_show, result, top_k=top_k) diff --git a/mmdet/models/detectors/single_stage.py b/mmdet/models/detectors/single_stage.py new file mode 100644 index 0000000..652d55a --- /dev/null +++ b/mmdet/models/detectors/single_stage.py @@ -0,0 +1,108 @@ +import torch.nn as nn +import torch + +from mmdet.core import bbox2result +from .. import builder +from ..registry import DETECTORS +from .base import BaseDetector +from mmdet.core import (bbox2roi, bbox_mapping, merge_aug_bboxes, + merge_aug_masks, merge_aug_proposals, multiclass_nms) + +@DETECTORS.register_module +class SingleStageDetector(BaseDetector): + + def __init__(self, + backbone, + neck=None, + bbox_head=None, + train_cfg=None, + test_cfg=None, + pretrained=None): + super(SingleStageDetector, self).__init__() + self.backbone = builder.build_backbone(backbone) + if neck is not None: + self.neck = builder.build_neck(neck) + self.bbox_head = builder.build_head(bbox_head) + self.train_cfg = train_cfg + self.test_cfg = test_cfg + self.init_weights(pretrained=pretrained) + + def init_weights(self, pretrained=None): + super(SingleStageDetector, self).init_weights(pretrained) + self.backbone.init_weights(pretrained=pretrained) + if self.with_neck: + if isinstance(self.neck, nn.Sequential): + for m in self.neck: + m.init_weights() + else: + self.neck.init_weights() + self.bbox_head.init_weights() + + def extract_feat(self, img): + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def forward_dummy(self, img): + x = self.extract_feat(img) + outs = self.bbox_head(x) + return outs + + def forward_train(self, + img, + img_metas, + gt_bboxes, + gt_labels, + gt_bboxes_ignore=None): + x = self.extract_feat(img) + outs = self.bbox_head(x) + loss_inputs = outs + (gt_bboxes, gt_labels, img_metas, self.train_cfg) + losses = self.bbox_head.loss( + *loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + return losses + + def simple_test(self, img, img_meta, rescale=False): + x = self.extract_feat(img) + outs = self.bbox_head(x) + bbox_inputs = outs + (img_meta, self.test_cfg, rescale) + bbox_list = self.bbox_head.get_bboxes(*bbox_inputs) + bbox_results = [ + bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes) + for det_bboxes, det_labels in bbox_list + ] + return bbox_results[0] + + def aug_test(self, imgs, img_metas, rescale=False): + + aug_proposals = [] + for i, (img, img_meta) in enumerate(zip(imgs, img_metas)): + x = self.extract_feat(img) + outs = self.bbox_head(x) + bbox_inputs = outs + (img_meta, self.test_cfg, rescale) + bbox_list = self.bbox_head.get_bboxes_aug(*bbox_inputs) + aug_proposals.append(bbox_list) + + # here now first merge detections, then run NMS + det_bboxes, det_scores = [], [] + for prop in aug_proposals: + det_bboxes.append(prop[0][0]) + det_scores.append(prop[0][1]) + + det_bboxes = torch.cat(det_bboxes) + det_scores = torch.cat(det_scores) + bbox_list = [] + bbox_list.append(multiclass_nms( + det_bboxes, + det_scores, + self.test_cfg.score_thr, + self.test_cfg.k, + self.test_cfg.agg_thr, + self.test_cfg.nms, + self.test_cfg.max_per_img)) + + bbox_results = [ + bbox2result(det_bboxes, det_labels, self.bbox_head.num_classes) + for det_bboxes, det_labels in bbox_list + ] + return bbox_results[0] diff --git a/mmdet/models/detectors/test_mixins.py b/mmdet/models/detectors/test_mixins.py new file mode 100644 index 0000000..1abd609 --- /dev/null +++ b/mmdet/models/detectors/test_mixins.py @@ -0,0 +1,164 @@ +from mmdet.core import (bbox2roi, bbox_mapping, merge_aug_bboxes, + merge_aug_masks, merge_aug_proposals, multiclass_nms) + + +class RPNTestMixin(object): + + def simple_test_rpn(self, x, img_meta, rpn_test_cfg): + rpn_outs = self.rpn_head(x) + proposal_inputs = rpn_outs + (img_meta, rpn_test_cfg) + proposal_list = self.rpn_head.get_bboxes(*proposal_inputs) + return proposal_list + + def aug_test_rpn(self, feats, img_metas, rpn_test_cfg): + imgs_per_gpu = len(img_metas[0]) + aug_proposals = [[] for _ in range(imgs_per_gpu)] + for x, img_meta in zip(feats, img_metas): + proposal_list = self.simple_test_rpn(x, img_meta, rpn_test_cfg) + for i, proposals in enumerate(proposal_list): + aug_proposals[i].append(proposals) + # reorganize the order of 'img_metas' to match the dimensions + # of 'aug_proposals' + aug_img_metas = [] + for i in range(imgs_per_gpu): + aug_img_meta = [] + for j in range(len(img_metas)): + aug_img_meta.append(img_metas[j][i]) + aug_img_metas.append(aug_img_meta) + # after merging, proposals will be rescaled to the original image size + merged_proposals = [ + merge_aug_proposals(proposals, aug_img_meta, rpn_test_cfg) + for proposals, aug_img_meta in zip(aug_proposals, aug_img_metas) + ] + return merged_proposals + + +class BBoxTestMixin(object): + + def simple_test_bboxes(self, + x, + img_meta, + proposals, + rcnn_test_cfg, + rescale=False): + """Test only det bboxes without augmentation.""" + rois = bbox2roi(proposals) + roi_feats = self.bbox_roi_extractor( + x[:len(self.bbox_roi_extractor.featmap_strides)], rois) + if self.with_shared_head: + roi_feats = self.shared_head(roi_feats) + cls_score, bbox_pred = self.bbox_head(roi_feats) + img_shape = img_meta[0]['img_shape'] + scale_factor = img_meta[0]['scale_factor'] + det_bboxes, det_labels = self.bbox_head.get_det_bboxes( + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=rescale, + cfg=rcnn_test_cfg) + return det_bboxes, det_labels + + def aug_test_bboxes(self, feats, img_metas, proposal_list, rcnn_test_cfg): + aug_bboxes = [] + aug_scores = [] + for x, img_meta in zip(feats, img_metas): + # only one image in the batch + img_shape = img_meta[0]['img_shape'] + scale_factor = img_meta[0]['scale_factor'] + flip = img_meta[0]['flip'] + # TODO more flexible + proposals = bbox_mapping(proposal_list[0][:, :4], img_shape, + scale_factor, flip) + rois = bbox2roi([proposals]) + # recompute feature maps to save GPU memory + roi_feats = self.bbox_roi_extractor( + x[:len(self.bbox_roi_extractor.featmap_strides)], rois) + if self.with_shared_head: + roi_feats = self.shared_head(roi_feats) + cls_score, bbox_pred = self.bbox_head(roi_feats) + bboxes, scores = self.bbox_head.get_det_bboxes( + rois, + cls_score, + bbox_pred, + img_shape, + scale_factor, + rescale=False, + cfg=None) + aug_bboxes.append(bboxes) + aug_scores.append(scores) + # after merging, bboxes will be rescaled to the original image size + merged_bboxes, merged_scores = merge_aug_bboxes( + aug_bboxes, aug_scores, img_metas, rcnn_test_cfg) + det_bboxes, det_labels = multiclass_nms(merged_bboxes, merged_scores, + rcnn_test_cfg.score_thr, + rcnn_test_cfg.nms, + rcnn_test_cfg.max_per_img) + return det_bboxes, det_labels + + +class MaskTestMixin(object): + + def simple_test_mask(self, + x, + img_meta, + det_bboxes, + det_labels, + rescale=False): + # image shape of the first image in the batch (only one) + ori_shape = img_meta[0]['ori_shape'] + scale_factor = img_meta[0]['scale_factor'] + if det_bboxes.shape[0] == 0: + segm_result = [[] for _ in range(self.mask_head.num_classes - 1)] + else: + # if det_bboxes is rescaled to the original image size, we need to + # rescale it back to the testing scale to obtain RoIs. + _bboxes = ( + det_bboxes[:, :4] * scale_factor if rescale else det_bboxes) + mask_rois = bbox2roi([_bboxes]) + mask_feats = self.mask_roi_extractor( + x[:len(self.mask_roi_extractor.featmap_strides)], mask_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + mask_pred = self.mask_head(mask_feats) + segm_result = self.mask_head.get_seg_masks(mask_pred, _bboxes, + det_labels, + self.test_cfg.rcnn, + ori_shape, scale_factor, + rescale) + return segm_result + + def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels): + if det_bboxes.shape[0] == 0: + segm_result = [[] for _ in range(self.mask_head.num_classes - 1)] + else: + aug_masks = [] + for x, img_meta in zip(feats, img_metas): + img_shape = img_meta[0]['img_shape'] + scale_factor = img_meta[0]['scale_factor'] + flip = img_meta[0]['flip'] + _bboxes = bbox_mapping(det_bboxes[:, :4], img_shape, + scale_factor, flip) + mask_rois = bbox2roi([_bboxes]) + mask_feats = self.mask_roi_extractor( + x[:len(self.mask_roi_extractor.featmap_strides)], + mask_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + mask_pred = self.mask_head(mask_feats) + # convert to numpy array to save memory + aug_masks.append(mask_pred.sigmoid().cpu().numpy()) + merged_masks = merge_aug_masks(aug_masks, img_metas, + self.test_cfg.rcnn) + + ori_shape = img_metas[0][0]['ori_shape'] + segm_result = self.mask_head.get_seg_masks( + merged_masks, + det_bboxes, + det_labels, + self.test_cfg.rcnn, + ori_shape, + scale_factor=1.0, + rescale=False) + return segm_result diff --git a/mmdet/models/detectors/two_stage.py b/mmdet/models/detectors/two_stage.py new file mode 100644 index 0000000..6ec1541 --- /dev/null +++ b/mmdet/models/detectors/two_stage.py @@ -0,0 +1,272 @@ +import torch +import torch.nn as nn + +from mmdet.core import bbox2result, bbox2roi, build_assigner, build_sampler +from .. import builder +from ..registry import DETECTORS +from .base import BaseDetector +from .test_mixins import BBoxTestMixin, MaskTestMixin, RPNTestMixin + + +@DETECTORS.register_module +class TwoStageDetector(BaseDetector, RPNTestMixin, BBoxTestMixin, + MaskTestMixin): + + def __init__(self, + backbone, + neck=None, + shared_head=None, + rpn_head=None, + bbox_roi_extractor=None, + bbox_head=None, + mask_roi_extractor=None, + mask_head=None, + train_cfg=None, + test_cfg=None, + pretrained=None): + super(TwoStageDetector, self).__init__() + self.backbone = builder.build_backbone(backbone) + + if neck is not None: + self.neck = builder.build_neck(neck) + + if shared_head is not None: + self.shared_head = builder.build_shared_head(shared_head) + + if rpn_head is not None: + self.rpn_head = builder.build_head(rpn_head) + + if bbox_head is not None: + self.bbox_roi_extractor = builder.build_roi_extractor( + bbox_roi_extractor) + self.bbox_head = builder.build_head(bbox_head) + + if mask_head is not None: + if mask_roi_extractor is not None: + self.mask_roi_extractor = builder.build_roi_extractor( + mask_roi_extractor) + self.share_roi_extractor = False + else: + self.share_roi_extractor = True + self.mask_roi_extractor = self.bbox_roi_extractor + self.mask_head = builder.build_head(mask_head) + + self.train_cfg = train_cfg + self.test_cfg = test_cfg + + self.init_weights(pretrained=pretrained) + + @property + def with_rpn(self): + return hasattr(self, 'rpn_head') and self.rpn_head is not None + + def init_weights(self, pretrained=None): + super(TwoStageDetector, self).init_weights(pretrained) + self.backbone.init_weights(pretrained=pretrained) + if self.with_neck: + if isinstance(self.neck, nn.Sequential): + for m in self.neck: + m.init_weights() + else: + self.neck.init_weights() + if self.with_shared_head: + self.shared_head.init_weights(pretrained=pretrained) + if self.with_rpn: + self.rpn_head.init_weights() + if self.with_bbox: + self.bbox_roi_extractor.init_weights() + self.bbox_head.init_weights() + if self.with_mask: + self.mask_head.init_weights() + if not self.share_roi_extractor: + self.mask_roi_extractor.init_weights() + + def extract_feat(self, img): + x = self.backbone(img) + if self.with_neck: + x = self.neck(x) + return x + + def forward_dummy(self, img): + outs = () + # backbone + x = self.extract_feat(img) + # rpn + if self.with_rpn: + rpn_outs = self.rpn_head(x) + outs = outs + (rpn_outs, ) + proposals = torch.randn(1000, 4).cuda() + # bbox head + rois = bbox2roi([proposals]) + if self.with_bbox: + bbox_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + cls_score, bbox_pred = self.bbox_head(bbox_feats) + outs = outs + (cls_score, bbox_pred) + # mask head + if self.with_mask: + mask_rois = rois[:100] + mask_feats = self.mask_roi_extractor( + x[:self.mask_roi_extractor.num_inputs], mask_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + mask_pred = self.mask_head(mask_feats) + outs = outs + (mask_pred, ) + return outs + + def forward_train(self, + img, + img_meta, + gt_bboxes, + gt_labels, + gt_bboxes_ignore=None, + gt_masks=None, + proposals=None): + x = self.extract_feat(img) + + losses = dict() + + # RPN forward and loss + if self.with_rpn: + rpn_outs = self.rpn_head(x) + rpn_loss_inputs = rpn_outs + (gt_bboxes, img_meta, + self.train_cfg.rpn) + rpn_losses = self.rpn_head.loss( + *rpn_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore) + losses.update(rpn_losses) + + proposal_cfg = self.train_cfg.get('rpn_proposal', + self.test_cfg.rpn) + proposal_inputs = rpn_outs + (img_meta, proposal_cfg) + proposal_list = self.rpn_head.get_bboxes(*proposal_inputs) + else: + proposal_list = proposals + + # assign gts and sample proposals + if self.with_bbox or self.with_mask: + bbox_assigner = build_assigner(self.train_cfg.rcnn.assigner) + bbox_sampler = build_sampler( + self.train_cfg.rcnn.sampler, context=self) + num_imgs = img.size(0) + if gt_bboxes_ignore is None: + gt_bboxes_ignore = [None for _ in range(num_imgs)] + sampling_results = [] + for i in range(num_imgs): + assign_result = bbox_assigner.assign(proposal_list[i], + gt_bboxes[i], + gt_bboxes_ignore[i], + gt_labels[i]) + sampling_result = bbox_sampler.sample( + assign_result, + proposal_list[i], + gt_bboxes[i], + gt_labels[i], + feats=[lvl_feat[i][None] for lvl_feat in x]) + sampling_results.append(sampling_result) + + # bbox head forward and loss + if self.with_bbox: + rois = bbox2roi([res.bboxes for res in sampling_results]) + # TODO: a more flexible way to decide which feature maps to use + bbox_feats = self.bbox_roi_extractor( + x[:self.bbox_roi_extractor.num_inputs], rois) + if self.with_shared_head: + bbox_feats = self.shared_head(bbox_feats) + cls_score, bbox_pred = self.bbox_head(bbox_feats) + + bbox_targets = self.bbox_head.get_target(sampling_results, + gt_bboxes, gt_labels, + self.train_cfg.rcnn) + loss_bbox = self.bbox_head.loss(cls_score, bbox_pred, + *bbox_targets) + losses.update(loss_bbox) + + # mask head forward and loss + if self.with_mask: + if not self.share_roi_extractor: + pos_rois = bbox2roi( + [res.pos_bboxes for res in sampling_results]) + mask_feats = self.mask_roi_extractor( + x[:self.mask_roi_extractor.num_inputs], pos_rois) + if self.with_shared_head: + mask_feats = self.shared_head(mask_feats) + else: + pos_inds = [] + device = bbox_feats.device + for res in sampling_results: + pos_inds.append( + torch.ones( + res.pos_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds.append( + torch.zeros( + res.neg_bboxes.shape[0], + device=device, + dtype=torch.uint8)) + pos_inds = torch.cat(pos_inds) + mask_feats = bbox_feats[pos_inds] + mask_pred = self.mask_head(mask_feats) + + mask_targets = self.mask_head.get_target(sampling_results, + gt_masks, + self.train_cfg.rcnn) + pos_labels = torch.cat( + [res.pos_gt_labels for res in sampling_results]) + loss_mask = self.mask_head.loss(mask_pred, mask_targets, + pos_labels) + losses.update(loss_mask) + + return losses + + def simple_test(self, img, img_meta, proposals=None, rescale=False): + """Test without augmentation.""" + assert self.with_bbox, "Bbox head must be implemented." + + x = self.extract_feat(img) + + proposal_list = self.simple_test_rpn( + x, img_meta, self.test_cfg.rpn) if proposals is None else proposals + + det_bboxes, det_labels = self.simple_test_bboxes( + x, img_meta, proposal_list, self.test_cfg.rcnn, rescale=rescale) + bbox_results = bbox2result(det_bboxes, det_labels, + self.bbox_head.num_classes) + + if not self.with_mask: + return bbox_results + else: + segm_results = self.simple_test_mask( + x, img_meta, det_bboxes, det_labels, rescale=rescale) + return bbox_results, segm_results + + def aug_test(self, imgs, img_metas, rescale=False): + """Test with augmentations. + + If rescale is False, then returned bboxes and masks will fit the scale + of imgs[0]. + """ + # recompute feats to save memory + proposal_list = self.aug_test_rpn( + self.extract_feats(imgs), img_metas, self.test_cfg.rpn) + det_bboxes, det_labels = self.aug_test_bboxes( + self.extract_feats(imgs), img_metas, proposal_list, + self.test_cfg.rcnn) + + if rescale: + _det_bboxes = det_bboxes + else: + _det_bboxes = det_bboxes.clone() + _det_bboxes[:, :4] *= img_metas[0][0]['scale_factor'] + bbox_results = bbox2result(_det_bboxes, det_labels, + self.bbox_head.num_classes) + + # det_bboxes always keep the original scale + if self.with_mask: + segm_results = self.aug_test_mask( + self.extract_feats(imgs), img_metas, det_bboxes, det_labels) + return bbox_results, segm_results + else: + return bbox_results diff --git a/mmdet/models/losses/__init__.py b/mmdet/models/losses/__init__.py new file mode 100644 index 0000000..992741a --- /dev/null +++ b/mmdet/models/losses/__init__.py @@ -0,0 +1,19 @@ +from .accuracy import Accuracy, accuracy +from .balanced_l1_loss import BalancedL1Loss, balanced_l1_loss +from .cross_entropy_loss import (CrossEntropyLoss, binary_cross_entropy, + cross_entropy, mask_cross_entropy) +from .focal_loss import FocalLoss, sigmoid_focal_loss +from .ghm_loss import GHMC, GHMR +from .iou_loss import BoundedIoULoss, IoULoss, bounded_iou_loss, iou_loss +from .mse_loss import MSELoss, mse_loss +from .smooth_l1_loss import SmoothL1Loss, smooth_l1_loss +from .utils import reduce_loss, weight_reduce_loss, weighted_loss + +__all__ = [ + 'accuracy', 'Accuracy', 'cross_entropy', 'binary_cross_entropy', + 'mask_cross_entropy', 'CrossEntropyLoss', 'sigmoid_focal_loss', + 'FocalLoss', 'smooth_l1_loss', 'SmoothL1Loss', 'balanced_l1_loss', + 'BalancedL1Loss', 'mse_loss', 'MSELoss', 'iou_loss', 'bounded_iou_loss', + 'IoULoss', 'BoundedIoULoss', 'GHMC', 'GHMR', 'reduce_loss', + 'weight_reduce_loss', 'weighted_loss' +] diff --git a/mmdet/models/losses/accuracy.py b/mmdet/models/losses/accuracy.py new file mode 100644 index 0000000..20d0ad8 --- /dev/null +++ b/mmdet/models/losses/accuracy.py @@ -0,0 +1,31 @@ +import torch.nn as nn + + +def accuracy(pred, target, topk=1): + assert isinstance(topk, (int, tuple)) + if isinstance(topk, int): + topk = (topk, ) + return_single = True + else: + return_single = False + + maxk = max(topk) + _, pred_label = pred.topk(maxk, dim=1) + pred_label = pred_label.t() + correct = pred_label.eq(target.view(1, -1).expand_as(pred_label)) + + res = [] + for k in topk: + correct_k = correct[:k].view(-1).float().sum(0, keepdim=True) + res.append(correct_k.mul_(100.0 / pred.size(0))) + return res[0] if return_single else res + + +class Accuracy(nn.Module): + + def __init__(self, topk=(1, )): + super().__init__() + self.topk = topk + + def forward(self, pred, target): + return accuracy(pred, target, self.topk) diff --git a/mmdet/models/losses/balanced_l1_loss.py b/mmdet/models/losses/balanced_l1_loss.py new file mode 100644 index 0000000..fab60db --- /dev/null +++ b/mmdet/models/losses/balanced_l1_loss.py @@ -0,0 +1,69 @@ +import numpy as np +import torch +import torch.nn as nn + +from ..registry import LOSSES +from .utils import weighted_loss + + +@weighted_loss +def balanced_l1_loss(pred, + target, + beta=1.0, + alpha=0.5, + gamma=1.5, + reduction='mean'): + assert beta > 0 + assert pred.size() == target.size() and target.numel() > 0 + + diff = torch.abs(pred - target) + b = np.e**(gamma / alpha) - 1 + loss = torch.where( + diff < beta, alpha / b * + (b * diff + 1) * torch.log(b * diff / beta + 1) - alpha * diff, + gamma * diff + gamma / b - alpha * beta) + + return loss + + +@LOSSES.register_module +class BalancedL1Loss(nn.Module): + """Balanced L1 Loss + + arXiv: https://arxiv.org/pdf/1904.02701.pdf (CVPR 2019) + """ + + def __init__(self, + alpha=0.5, + gamma=1.5, + beta=1.0, + reduction='mean', + loss_weight=1.0): + super(BalancedL1Loss, self).__init__() + self.alpha = alpha + self.gamma = gamma + self.beta = beta + self.reduction = reduction + self.loss_weight = loss_weight + + def forward(self, + pred, + target, + weight=None, + avg_factor=None, + reduction_override=None, + **kwargs): + assert reduction_override in (None, 'none', 'mean', 'sum') + reduction = ( + reduction_override if reduction_override else self.reduction) + loss_bbox = self.loss_weight * balanced_l1_loss( + pred, + target, + weight, + alpha=self.alpha, + gamma=self.gamma, + beta=self.beta, + reduction=reduction, + avg_factor=avg_factor, + **kwargs) + return loss_bbox diff --git a/mmdet/models/losses/cross_entropy_loss.py b/mmdet/models/losses/cross_entropy_loss.py new file mode 100644 index 0000000..dd9d477 --- /dev/null +++ b/mmdet/models/losses/cross_entropy_loss.py @@ -0,0 +1,103 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from ..registry import LOSSES +from .utils import weight_reduce_loss + + +def cross_entropy(pred, label, weight=None, reduction='mean', avg_factor=None): + # element-wise losses + loss = F.cross_entropy(pred, label, reduction='none') + + # apply weights and do the reduction + if weight is not None: + weight = weight.float() + loss = weight_reduce_loss( + loss, weight=weight, reduction=reduction, avg_factor=avg_factor) + + return loss + + +def _expand_binary_labels(labels, label_weights, label_channels): + bin_labels = labels.new_full((labels.size(0), label_channels), 0) + inds = torch.nonzero(labels >= 1).squeeze() + if inds.numel() > 0: + bin_labels[inds, labels[inds] - 1] = 1 + if label_weights is None: + bin_label_weights = None + else: + bin_label_weights = label_weights.view(-1, 1).expand( + label_weights.size(0), label_channels) + return bin_labels, bin_label_weights + + +def binary_cross_entropy(pred, + label, + weight=None, + reduction='mean', + avg_factor=None): + if pred.dim() != label.dim(): + label, weight = _expand_binary_labels(label, weight, pred.size(-1)) + + # weighted element-wise losses + if weight is not None: + weight = weight.float() + loss = F.binary_cross_entropy_with_logits( + pred, label.float(), weight, reduction='none') + # do the reduction for the weighted loss + loss = weight_reduce_loss(loss, reduction=reduction, avg_factor=avg_factor) + + return loss + + +def mask_cross_entropy(pred, target, label, reduction='mean', avg_factor=None): + # TODO: handle these two reserved arguments + assert reduction == 'mean' and avg_factor is None + num_rois = pred.size()[0] + inds = torch.arange(0, num_rois, dtype=torch.long, device=pred.device) + pred_slice = pred[inds, label].squeeze(1) + return F.binary_cross_entropy_with_logits( + pred_slice, target, reduction='mean')[None] + + +@LOSSES.register_module +class CrossEntropyLoss(nn.Module): + + def __init__(self, + use_sigmoid=False, + use_mask=False, + reduction='mean', + loss_weight=1.0): + super(CrossEntropyLoss, self).__init__() + assert (use_sigmoid is False) or (use_mask is False) + self.use_sigmoid = use_sigmoid + self.use_mask = use_mask + self.reduction = reduction + self.loss_weight = loss_weight + + if self.use_sigmoid: + self.cls_criterion = binary_cross_entropy + elif self.use_mask: + self.cls_criterion = mask_cross_entropy + else: + self.cls_criterion = cross_entropy + + def forward(self, + cls_score, + label, + weight=None, + avg_factor=None, + reduction_override=None, + **kwargs): + assert reduction_override in (None, 'none', 'mean', 'sum') + reduction = ( + reduction_override if reduction_override else self.reduction) + loss_cls = self.loss_weight * self.cls_criterion( + cls_score, + label, + weight, + reduction=reduction, + avg_factor=avg_factor, + **kwargs) + return loss_cls diff --git a/mmdet/models/losses/focal_loss.py b/mmdet/models/losses/focal_loss.py new file mode 100644 index 0000000..6b28e12 --- /dev/null +++ b/mmdet/models/losses/focal_loss.py @@ -0,0 +1,82 @@ +import torch.nn as nn +import torch.nn.functional as F + +from mmdet.ops import sigmoid_focal_loss as _sigmoid_focal_loss +from ..registry import LOSSES +from .utils import weight_reduce_loss + + +# This method is only for debugging +def py_sigmoid_focal_loss(pred, + target, + weight=None, + gamma=2.0, + alpha=0.25, + reduction='mean', + avg_factor=None): + pred_sigmoid = pred.sigmoid() + target = target.type_as(pred) + pt = (1 - pred_sigmoid) * target + pred_sigmoid * (1 - target) + focal_weight = (alpha * target + (1 - alpha) * + (1 - target)) * pt.pow(gamma) + loss = F.binary_cross_entropy_with_logits( + pred, target, reduction='none') * focal_weight + loss = weight_reduce_loss(loss, weight, reduction, avg_factor) + return loss + + +def sigmoid_focal_loss(pred, + target, + weight=None, + gamma=2.0, + alpha=0.25, + reduction='mean', + avg_factor=None): + # Function.apply does not accept keyword arguments, so the decorator + # "weighted_loss" is not applicable + loss = _sigmoid_focal_loss(pred, target, gamma, alpha) + # TODO: find a proper way to handle the shape of weight + if weight is not None: + weight = weight.view(-1, 1) + loss = weight_reduce_loss(loss, weight, reduction, avg_factor) + return loss + + +@LOSSES.register_module +class FocalLoss(nn.Module): + + def __init__(self, + use_sigmoid=True, + gamma=2.0, + alpha=0.25, + reduction='mean', + loss_weight=1.0): + super(FocalLoss, self).__init__() + assert use_sigmoid is True, 'Only sigmoid focal loss supported now.' + self.use_sigmoid = use_sigmoid + self.gamma = gamma + self.alpha = alpha + self.reduction = reduction + self.loss_weight = loss_weight + + def forward(self, + pred, + target, + weight=None, + avg_factor=None, + reduction_override=None): + assert reduction_override in (None, 'none', 'mean', 'sum') + reduction = ( + reduction_override if reduction_override else self.reduction) + if self.use_sigmoid: + loss_cls = self.loss_weight * sigmoid_focal_loss( + pred, + target, + weight, + gamma=self.gamma, + alpha=self.alpha, + reduction=reduction, + avg_factor=avg_factor) + else: + raise NotImplementedError + return loss_cls diff --git a/mmdet/models/losses/ghm_loss.py b/mmdet/models/losses/ghm_loss.py new file mode 100644 index 0000000..95656a2 --- /dev/null +++ b/mmdet/models/losses/ghm_loss.py @@ -0,0 +1,167 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from ..registry import LOSSES + + +def _expand_binary_labels(labels, label_weights, label_channels): + bin_labels = labels.new_full((labels.size(0), label_channels), 0) + inds = torch.nonzero(labels >= 1).squeeze() + if inds.numel() > 0: + bin_labels[inds, labels[inds] - 1] = 1 + bin_label_weights = label_weights.view(-1, 1).expand( + label_weights.size(0), label_channels) + return bin_labels, bin_label_weights + + +# TODO: code refactoring to make it consistent with other losses +@LOSSES.register_module +class GHMC(nn.Module): + """GHM Classification Loss. + + Details of the theorem can be viewed in the paper + "Gradient Harmonized Single-stage Detector". + https://arxiv.org/abs/1811.05181 + + Args: + bins (int): Number of the unit regions for distribution calculation. + momentum (float): The parameter for moving average. + use_sigmoid (bool): Can only be true for BCE based loss now. + loss_weight (float): The weight of the total GHM-C loss. + """ + + def __init__(self, bins=10, momentum=0, use_sigmoid=True, loss_weight=1.0): + super(GHMC, self).__init__() + self.bins = bins + self.momentum = momentum + self.edges = torch.arange(bins + 1).float().cuda() / bins + self.edges[-1] += 1e-6 + if momentum > 0: + self.acc_sum = torch.zeros(bins).cuda() + self.use_sigmoid = use_sigmoid + if not self.use_sigmoid: + raise NotImplementedError + self.loss_weight = loss_weight + + def forward(self, pred, target, label_weight, *args, **kwargs): + """Calculate the GHM-C loss. + + Args: + pred (float tensor of size [batch_num, class_num]): + The direct prediction of classification fc layer. + target (float tensor of size [batch_num, class_num]): + Binary class target for each sample. + label_weight (float tensor of size [batch_num, class_num]): + the value is 1 if the sample is valid and 0 if ignored. + Returns: + The gradient harmonized loss. + """ + # the target should be binary class label + if pred.dim() != target.dim(): + target, label_weight = _expand_binary_labels( + target, label_weight, pred.size(-1)) + target, label_weight = target.float(), label_weight.float() + edges = self.edges + mmt = self.momentum + weights = torch.zeros_like(pred) + + # gradient length + g = torch.abs(pred.sigmoid().detach() - target) + + valid = label_weight > 0 + tot = max(valid.float().sum().item(), 1.0) + n = 0 # n valid bins + for i in range(self.bins): + inds = (g >= edges[i]) & (g < edges[i + 1]) & valid + num_in_bin = inds.sum().item() + if num_in_bin > 0: + if mmt > 0: + self.acc_sum[i] = mmt * self.acc_sum[i] \ + + (1 - mmt) * num_in_bin + weights[inds] = tot / self.acc_sum[i] + else: + weights[inds] = tot / num_in_bin + n += 1 + if n > 0: + weights = weights / n + + loss = F.binary_cross_entropy_with_logits( + pred, target, weights, reduction='sum') / tot + return loss * self.loss_weight + + +# TODO: code refactoring to make it consistent with other losses +@LOSSES.register_module +class GHMR(nn.Module): + """GHM Regression Loss. + + Details of the theorem can be viewed in the paper + "Gradient Harmonized Single-stage Detector" + https://arxiv.org/abs/1811.05181 + + Args: + mu (float): The parameter for the Authentic Smooth L1 loss. + bins (int): Number of the unit regions for distribution calculation. + momentum (float): The parameter for moving average. + loss_weight (float): The weight of the total GHM-R loss. + """ + + def __init__(self, mu=0.02, bins=10, momentum=0, loss_weight=1.0): + super(GHMR, self).__init__() + self.mu = mu + self.bins = bins + self.edges = torch.arange(bins + 1).float().cuda() / bins + self.edges[-1] = 1e3 + self.momentum = momentum + if momentum > 0: + self.acc_sum = torch.zeros(bins).cuda() + self.loss_weight = loss_weight + + # TODO: support reduction parameter + def forward(self, pred, target, label_weight, avg_factor=None): + """Calculate the GHM-R loss. + + Args: + pred (float tensor of size [batch_num, 4 (* class_num)]): + The prediction of box regression layer. Channel number can be 4 + or 4 * class_num depending on whether it is class-agnostic. + target (float tensor of size [batch_num, 4 (* class_num)]): + The target regression values with the same size of pred. + label_weight (float tensor of size [batch_num, 4 (* class_num)]): + The weight of each sample, 0 if ignored. + Returns: + The gradient harmonized loss. + """ + mu = self.mu + edges = self.edges + mmt = self.momentum + + # ASL1 loss + diff = pred - target + loss = torch.sqrt(diff * diff + mu * mu) - mu + + # gradient length + g = torch.abs(diff / torch.sqrt(mu * mu + diff * diff)).detach() + weights = torch.zeros_like(g) + + valid = label_weight > 0 + tot = max(label_weight.float().sum().item(), 1.0) + n = 0 # n: valid bins + for i in range(self.bins): + inds = (g >= edges[i]) & (g < edges[i + 1]) & valid + num_in_bin = inds.sum().item() + if num_in_bin > 0: + n += 1 + if mmt > 0: + self.acc_sum[i] = mmt * self.acc_sum[i] \ + + (1 - mmt) * num_in_bin + weights[inds] = tot / self.acc_sum[i] + else: + weights[inds] = tot / num_in_bin + if n > 0: + weights /= n + + loss = loss * weights + loss = loss.sum() / tot + return loss * self.loss_weight diff --git a/mmdet/models/losses/iou_loss.py b/mmdet/models/losses/iou_loss.py new file mode 100644 index 0000000..cf24994 --- /dev/null +++ b/mmdet/models/losses/iou_loss.py @@ -0,0 +1,135 @@ +import torch +import torch.nn as nn + +from mmdet.core import bbox_overlaps +from ..registry import LOSSES +from .utils import weighted_loss + + +@weighted_loss +def iou_loss(pred, target, eps=1e-6): + """IoU loss. + + Computing the IoU loss between a set of predicted bboxes and target bboxes. + The loss is calculated as negative log of IoU. + + Args: + pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2), + shape (n, 4). + target (Tensor): Corresponding gt bboxes, shape (n, 4). + eps (float): Eps to avoid log(0). + + Return: + Tensor: Loss tensor. + """ + ious = bbox_overlaps(pred, target, is_aligned=True).clamp(min=eps) + loss = -ious.log() + return loss + + +@weighted_loss +def bounded_iou_loss(pred, target, beta=0.2, eps=1e-3): + """Improving Object Localization with Fitness NMS and Bounded IoU Loss, + https://arxiv.org/abs/1711.00164. + + Args: + pred (tensor): Predicted bboxes. + target (tensor): Target bboxes. + beta (float): beta parameter in smoothl1. + eps (float): eps to avoid NaN. + """ + pred_ctrx = (pred[:, 0] + pred[:, 2]) * 0.5 + pred_ctry = (pred[:, 1] + pred[:, 3]) * 0.5 + pred_w = pred[:, 2] - pred[:, 0] + 1 + pred_h = pred[:, 3] - pred[:, 1] + 1 + with torch.no_grad(): + target_ctrx = (target[:, 0] + target[:, 2]) * 0.5 + target_ctry = (target[:, 1] + target[:, 3]) * 0.5 + target_w = target[:, 2] - target[:, 0] + 1 + target_h = target[:, 3] - target[:, 1] + 1 + + dx = target_ctrx - pred_ctrx + dy = target_ctry - pred_ctry + + loss_dx = 1 - torch.max( + (target_w - 2 * dx.abs()) / + (target_w + 2 * dx.abs() + eps), torch.zeros_like(dx)) + loss_dy = 1 - torch.max( + (target_h - 2 * dy.abs()) / + (target_h + 2 * dy.abs() + eps), torch.zeros_like(dy)) + loss_dw = 1 - torch.min(target_w / (pred_w + eps), pred_w / + (target_w + eps)) + loss_dh = 1 - torch.min(target_h / (pred_h + eps), pred_h / + (target_h + eps)) + loss_comb = torch.stack([loss_dx, loss_dy, loss_dw, loss_dh], + dim=-1).view(loss_dx.size(0), -1) + + loss = torch.where(loss_comb < beta, 0.5 * loss_comb * loss_comb / beta, + loss_comb - 0.5 * beta) + return loss + + +@LOSSES.register_module +class IoULoss(nn.Module): + + def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0): + super(IoULoss, self).__init__() + self.eps = eps + self.reduction = reduction + self.loss_weight = loss_weight + + def forward(self, + pred, + target, + weight=None, + avg_factor=None, + reduction_override=None, + **kwargs): + if weight is not None and not torch.any(weight > 0): + return (pred * weight).sum() # 0 + assert reduction_override in (None, 'none', 'mean', 'sum') + reduction = ( + reduction_override if reduction_override else self.reduction) + loss = self.loss_weight * iou_loss( + pred, + target, + weight, + eps=self.eps, + reduction=reduction, + avg_factor=avg_factor, + **kwargs) + return loss + + +@LOSSES.register_module +class BoundedIoULoss(nn.Module): + + def __init__(self, beta=0.2, eps=1e-3, reduction='mean', loss_weight=1.0): + super(BoundedIoULoss, self).__init__() + self.beta = beta + self.eps = eps + self.reduction = reduction + self.loss_weight = loss_weight + + def forward(self, + pred, + target, + weight=None, + avg_factor=None, + reduction_override=None, + **kwargs): + if weight is not None and not torch.any(weight > 0): + return (pred * weight).sum() # 0 + assert reduction_override in (None, 'none', 'mean', 'sum') + reduction = ( + reduction_override if reduction_override else self.reduction) + loss = self.loss_weight * bounded_iou_loss( + pred, + target, + weight, + beta=self.beta, + eps=self.eps, + reduction=reduction, + avg_factor=avg_factor, + **kwargs) + return loss diff --git a/mmdet/models/losses/mse_loss.py b/mmdet/models/losses/mse_loss.py new file mode 100644 index 0000000..a868b2b --- /dev/null +++ b/mmdet/models/losses/mse_loss.py @@ -0,0 +1,25 @@ +import torch.nn as nn +import torch.nn.functional as F + +from ..registry import LOSSES +from .utils import weighted_loss + +mse_loss = weighted_loss(F.mse_loss) + + +@LOSSES.register_module +class MSELoss(nn.Module): + + def __init__(self, reduction='mean', loss_weight=1.0): + super().__init__() + self.reduction = reduction + self.loss_weight = loss_weight + + def forward(self, pred, target, weight=None, avg_factor=None): + loss = self.loss_weight * mse_loss( + pred, + target, + weight, + reduction=self.reduction, + avg_factor=avg_factor) + return loss diff --git a/mmdet/models/losses/smooth_l1_loss.py b/mmdet/models/losses/smooth_l1_loss.py new file mode 100644 index 0000000..bc34073 --- /dev/null +++ b/mmdet/models/losses/smooth_l1_loss.py @@ -0,0 +1,45 @@ +import torch +import torch.nn as nn + +from ..registry import LOSSES +from .utils import weighted_loss + + +@weighted_loss +def smooth_l1_loss(pred, target, beta=1.0): + assert beta > 0 + assert pred.size() == target.size() and target.numel() > 0 + diff = torch.abs(pred - target) + loss = torch.where(diff < beta, 0.5 * diff * diff / beta, + diff - 0.5 * beta) + return loss + + +@LOSSES.register_module +class SmoothL1Loss(nn.Module): + + def __init__(self, beta=1.0, reduction='mean', loss_weight=1.0): + super(SmoothL1Loss, self).__init__() + self.beta = beta + self.reduction = reduction + self.loss_weight = loss_weight + + def forward(self, + pred, + target, + weight=None, + avg_factor=None, + reduction_override=None, + **kwargs): + assert reduction_override in (None, 'none', 'mean', 'sum') + reduction = ( + reduction_override if reduction_override else self.reduction) + loss_bbox = self.loss_weight * smooth_l1_loss( + pred, + target, + weight, + beta=self.beta, + reduction=reduction, + avg_factor=avg_factor, + **kwargs) + return loss_bbox diff --git a/mmdet/models/losses/utils.py b/mmdet/models/losses/utils.py new file mode 100644 index 0000000..5c16e06 --- /dev/null +++ b/mmdet/models/losses/utils.py @@ -0,0 +1,97 @@ +import functools + +import torch.nn.functional as F + + +def reduce_loss(loss, reduction): + """Reduce loss as specified. + + Args: + loss (Tensor): Elementwise loss tensor. + reduction (str): Options are "none", "mean" and "sum". + + Return: + Tensor: Reduced loss tensor. + """ + reduction_enum = F._Reduction.get_enum(reduction) + # none: 0, elementwise_mean:1, sum: 2 + if reduction_enum == 0: + return loss + elif reduction_enum == 1: + return loss.mean() + elif reduction_enum == 2: + return loss.sum() + + +def weight_reduce_loss(loss, weight=None, reduction='mean', avg_factor=None): + """Apply element-wise weight and reduce loss. + + Args: + loss (Tensor): Element-wise loss. + weight (Tensor): Element-wise weights. + reduction (str): Same as built-in losses of PyTorch. + avg_factor (float): Avarage factor when computing the mean of losses. + + Returns: + Tensor: Processed loss values. + """ + # if weight is specified, apply element-wise weight + if weight is not None: + loss = loss * weight + + # if avg_factor is not specified, just reduce the loss + if avg_factor is None: + loss = reduce_loss(loss, reduction) + else: + # if reduction is mean, then average the loss by avg_factor + if reduction == 'mean': + loss = loss.sum() / avg_factor + # if reduction is 'none', then do nothing, otherwise raise an error + elif reduction != 'none': + raise ValueError('avg_factor can not be used with reduction="sum"') + return loss + + +def weighted_loss(loss_func): + """Create a weighted version of a given loss function. + + To use this decorator, the loss function must have the signature like + `loss_func(pred, target, **kwargs)`. The function only needs to compute + element-wise loss without any reduction. This decorator will add weight + and reduction arguments to the function. The decorated function will have + the signature like `loss_func(pred, target, weight=None, reduction='mean', + avg_factor=None, **kwargs)`. + + :Example: + + >>> @weighted_loss + >>> def l1_loss(pred, target): + >>> return (pred - target).abs() + + >>> pred = torch.Tensor([0, 2, 3]) + >>> target = torch.Tensor([1, 1, 1]) + >>> weight = torch.Tensor([1, 0, 1]) + + >>> l1_loss(pred, target) + tensor(1.3333) + >>> l1_loss(pred, target, weight) + tensor(1.) + >>> l1_loss(pred, target, reduction='none') + tensor([1., 1., 2.]) + >>> l1_loss(pred, target, weight, avg_factor=2) + tensor(1.5000) + """ + + @functools.wraps(loss_func) + def wrapper(pred, + target, + weight=None, + reduction='mean', + avg_factor=None, + **kwargs): + # get element-wise loss + loss = loss_func(pred, target, **kwargs) + loss = weight_reduce_loss(loss, weight, reduction, avg_factor) + return loss + + return wrapper diff --git a/mmdet/models/mask_heads/__init__.py b/mmdet/models/mask_heads/__init__.py new file mode 100644 index 0000000..ed71edc --- /dev/null +++ b/mmdet/models/mask_heads/__init__.py @@ -0,0 +1,10 @@ +from .fcn_mask_head import FCNMaskHead +from .fused_semantic_head import FusedSemanticHead +from .grid_head import GridHead +from .htc_mask_head import HTCMaskHead +from .maskiou_head import MaskIoUHead + +__all__ = [ + 'FCNMaskHead', 'HTCMaskHead', 'FusedSemanticHead', 'GridHead', + 'MaskIoUHead' +] diff --git a/mmdet/models/mask_heads/fcn_mask_head.py b/mmdet/models/mask_heads/fcn_mask_head.py new file mode 100644 index 0000000..f25aa17 --- /dev/null +++ b/mmdet/models/mask_heads/fcn_mask_head.py @@ -0,0 +1,181 @@ +import mmcv +import numpy as np +import pycocotools.mask as mask_util +import torch +import torch.nn as nn +from torch.nn.modules.utils import _pair + +from mmdet.core import auto_fp16, force_fp32, mask_target +from ..builder import build_loss +from ..registry import HEADS +from ..utils import ConvModule + + +@HEADS.register_module +class FCNMaskHead(nn.Module): + + def __init__(self, + num_convs=4, + roi_feat_size=14, + in_channels=256, + conv_kernel_size=3, + conv_out_channels=256, + upsample_method='deconv', + upsample_ratio=2, + num_classes=81, + class_agnostic=False, + conv_cfg=None, + norm_cfg=None, + loss_mask=dict( + type='CrossEntropyLoss', use_mask=True, loss_weight=1.0)): + super(FCNMaskHead, self).__init__() + if upsample_method not in [None, 'deconv', 'nearest', 'bilinear']: + raise ValueError( + 'Invalid upsample method {}, accepted methods ' + 'are "deconv", "nearest", "bilinear"'.format(upsample_method)) + self.num_convs = num_convs + # WARN: roi_feat_size is reserved and not used + self.roi_feat_size = _pair(roi_feat_size) + self.in_channels = in_channels + self.conv_kernel_size = conv_kernel_size + self.conv_out_channels = conv_out_channels + self.upsample_method = upsample_method + self.upsample_ratio = upsample_ratio + self.num_classes = num_classes + self.class_agnostic = class_agnostic + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self.fp16_enabled = False + self.loss_mask = build_loss(loss_mask) + + self.convs = nn.ModuleList() + for i in range(self.num_convs): + in_channels = ( + self.in_channels if i == 0 else self.conv_out_channels) + padding = (self.conv_kernel_size - 1) // 2 + self.convs.append( + ConvModule( + in_channels, + self.conv_out_channels, + self.conv_kernel_size, + padding=padding, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg)) + upsample_in_channels = ( + self.conv_out_channels if self.num_convs > 0 else in_channels) + if self.upsample_method is None: + self.upsample = None + elif self.upsample_method == 'deconv': + self.upsample = nn.ConvTranspose2d( + upsample_in_channels, + self.conv_out_channels, + self.upsample_ratio, + stride=self.upsample_ratio) + else: + self.upsample = nn.Upsample( + scale_factor=self.upsample_ratio, mode=self.upsample_method) + + out_channels = 1 if self.class_agnostic else self.num_classes + logits_in_channel = ( + self.conv_out_channels + if self.upsample_method == 'deconv' else upsample_in_channels) + self.conv_logits = nn.Conv2d(logits_in_channel, out_channels, 1) + self.relu = nn.ReLU(inplace=True) + self.debug_imgs = None + + def init_weights(self): + for m in [self.upsample, self.conv_logits]: + if m is None: + continue + nn.init.kaiming_normal_( + m.weight, mode='fan_out', nonlinearity='relu') + nn.init.constant_(m.bias, 0) + + @auto_fp16() + def forward(self, x): + for conv in self.convs: + x = conv(x) + if self.upsample is not None: + x = self.upsample(x) + if self.upsample_method == 'deconv': + x = self.relu(x) + mask_pred = self.conv_logits(x) + return mask_pred + + def get_target(self, sampling_results, gt_masks, rcnn_train_cfg): + pos_proposals = [res.pos_bboxes for res in sampling_results] + pos_assigned_gt_inds = [ + res.pos_assigned_gt_inds for res in sampling_results + ] + mask_targets = mask_target(pos_proposals, pos_assigned_gt_inds, + gt_masks, rcnn_train_cfg) + return mask_targets + + @force_fp32(apply_to=('mask_pred', )) + def loss(self, mask_pred, mask_targets, labels): + loss = dict() + if self.class_agnostic: + loss_mask = self.loss_mask(mask_pred, mask_targets, + torch.zeros_like(labels)) + else: + loss_mask = self.loss_mask(mask_pred, mask_targets, labels) + loss['loss_mask'] = loss_mask + return loss + + def get_seg_masks(self, mask_pred, det_bboxes, det_labels, rcnn_test_cfg, + ori_shape, scale_factor, rescale): + """Get segmentation masks from mask_pred and bboxes. + + Args: + mask_pred (Tensor or ndarray): shape (n, #class+1, h, w). + For single-scale testing, mask_pred is the direct output of + model, whose type is Tensor, while for multi-scale testing, + it will be converted to numpy array outside of this method. + det_bboxes (Tensor): shape (n, 4/5) + det_labels (Tensor): shape (n, ) + img_shape (Tensor): shape (3, ) + rcnn_test_cfg (dict): rcnn testing config + ori_shape: original image size + + Returns: + list[list]: encoded masks + """ + if isinstance(mask_pred, torch.Tensor): + mask_pred = mask_pred.sigmoid().cpu().numpy() + assert isinstance(mask_pred, np.ndarray) + # when enabling mixed precision training, mask_pred may be float16 + # numpy array + mask_pred = mask_pred.astype(np.float32) + + cls_segms = [[] for _ in range(self.num_classes - 1)] + bboxes = det_bboxes.cpu().numpy()[:, :4] + labels = det_labels.cpu().numpy() + 1 + + if rescale: + img_h, img_w = ori_shape[:2] + else: + img_h = np.round(ori_shape[0] * scale_factor).astype(np.int32) + img_w = np.round(ori_shape[1] * scale_factor).astype(np.int32) + scale_factor = 1.0 + + for i in range(bboxes.shape[0]): + bbox = (bboxes[i, :] / scale_factor).astype(np.int32) + label = labels[i] + w = max(bbox[2] - bbox[0] + 1, 1) + h = max(bbox[3] - bbox[1] + 1, 1) + + if not self.class_agnostic: + mask_pred_ = mask_pred[i, label, :, :] + else: + mask_pred_ = mask_pred[i, 0, :, :] + im_mask = np.zeros((img_h, img_w), dtype=np.uint8) + + bbox_mask = mmcv.imresize(mask_pred_, (w, h)) + bbox_mask = (bbox_mask > rcnn_test_cfg.mask_thr_binary).astype( + np.uint8) + im_mask[bbox[1]:bbox[1] + h, bbox[0]:bbox[0] + w] = bbox_mask + rle = mask_util.encode( + np.array(im_mask[:, :, np.newaxis], order='F'))[0] + cls_segms[label - 1].append(rle) + + return cls_segms diff --git a/mmdet/models/mask_heads/fused_semantic_head.py b/mmdet/models/mask_heads/fused_semantic_head.py new file mode 100644 index 0000000..ee6910f --- /dev/null +++ b/mmdet/models/mask_heads/fused_semantic_head.py @@ -0,0 +1,106 @@ +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import kaiming_init + +from mmdet.core import auto_fp16, force_fp32 +from ..registry import HEADS +from ..utils import ConvModule + + +@HEADS.register_module +class FusedSemanticHead(nn.Module): + """Multi-level fused semantic segmentation head. + + in_1 -> 1x1 conv --- + | + in_2 -> 1x1 conv -- | + || + in_3 -> 1x1 conv - || + ||| /-> 1x1 conv (mask prediction) + in_4 -> 1x1 conv -----> 3x3 convs (*4) + | \-> 1x1 conv (feature) + in_5 -> 1x1 conv --- + """ # noqa: W605 + + def __init__(self, + num_ins, + fusion_level, + num_convs=4, + in_channels=256, + conv_out_channels=256, + num_classes=183, + ignore_label=255, + loss_weight=0.2, + conv_cfg=None, + norm_cfg=None): + super(FusedSemanticHead, self).__init__() + self.num_ins = num_ins + self.fusion_level = fusion_level + self.num_convs = num_convs + self.in_channels = in_channels + self.conv_out_channels = conv_out_channels + self.num_classes = num_classes + self.ignore_label = ignore_label + self.loss_weight = loss_weight + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self.fp16_enabled = False + + self.lateral_convs = nn.ModuleList() + for i in range(self.num_ins): + self.lateral_convs.append( + ConvModule( + self.in_channels, + self.in_channels, + 1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + inplace=False)) + + self.convs = nn.ModuleList() + for i in range(self.num_convs): + in_channels = self.in_channels if i == 0 else conv_out_channels + self.convs.append( + ConvModule( + in_channels, + conv_out_channels, + 3, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg)) + self.conv_embedding = ConvModule( + conv_out_channels, + conv_out_channels, + 1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg) + self.conv_logits = nn.Conv2d(conv_out_channels, self.num_classes, 1) + + self.criterion = nn.CrossEntropyLoss(ignore_index=ignore_label) + + def init_weights(self): + kaiming_init(self.conv_logits) + + @auto_fp16() + def forward(self, feats): + x = self.lateral_convs[self.fusion_level](feats[self.fusion_level]) + fused_size = tuple(x.shape[-2:]) + for i, feat in enumerate(feats): + if i != self.fusion_level: + feat = F.interpolate( + feat, size=fused_size, mode='bilinear', align_corners=True) + x += self.lateral_convs[i](feat) + + for i in range(self.num_convs): + x = self.convs[i](x) + + mask_pred = self.conv_logits(x) + x = self.conv_embedding(x) + return mask_pred, x + + @force_fp32(apply_to=('mask_pred', )) + def loss(self, mask_pred, labels): + labels = labels.squeeze(1).long() + loss_semantic_seg = self.criterion(mask_pred, labels) + loss_semantic_seg *= self.loss_weight + return loss_semantic_seg diff --git a/mmdet/models/mask_heads/grid_head.py b/mmdet/models/mask_heads/grid_head.py new file mode 100644 index 0000000..7206530 --- /dev/null +++ b/mmdet/models/mask_heads/grid_head.py @@ -0,0 +1,361 @@ +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import kaiming_init, normal_init + +from ..builder import build_loss +from ..registry import HEADS +from ..utils import ConvModule + + +@HEADS.register_module +class GridHead(nn.Module): + + def __init__(self, + grid_points=9, + num_convs=8, + roi_feat_size=14, + in_channels=256, + conv_kernel_size=3, + point_feat_channels=64, + deconv_kernel_size=4, + class_agnostic=False, + loss_grid=dict( + type='CrossEntropyLoss', use_sigmoid=True, + loss_weight=15), + conv_cfg=None, + norm_cfg=dict(type='GN', num_groups=36)): + super(GridHead, self).__init__() + self.grid_points = grid_points + self.num_convs = num_convs + self.roi_feat_size = roi_feat_size + self.in_channels = in_channels + self.conv_kernel_size = conv_kernel_size + self.point_feat_channels = point_feat_channels + self.conv_out_channels = self.point_feat_channels * self.grid_points + self.class_agnostic = class_agnostic + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + if isinstance(norm_cfg, dict) and norm_cfg['type'] == 'GN': + assert self.conv_out_channels % norm_cfg['num_groups'] == 0 + + assert self.grid_points >= 4 + self.grid_size = int(np.sqrt(self.grid_points)) + if self.grid_size * self.grid_size != self.grid_points: + raise ValueError('grid_points must be a square number') + + # the predicted heatmap is half of whole_map_size + if not isinstance(self.roi_feat_size, int): + raise ValueError('Only square RoIs are supporeted in Grid R-CNN') + self.whole_map_size = self.roi_feat_size * 4 + + # compute point-wise sub-regions + self.sub_regions = self.calc_sub_regions() + + self.convs = [] + for i in range(self.num_convs): + in_channels = ( + self.in_channels if i == 0 else self.conv_out_channels) + stride = 2 if i == 0 else 1 + padding = (self.conv_kernel_size - 1) // 2 + self.convs.append( + ConvModule( + in_channels, + self.conv_out_channels, + self.conv_kernel_size, + stride=stride, + padding=padding, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg, + bias=True)) + self.convs = nn.Sequential(*self.convs) + + self.deconv1 = nn.ConvTranspose2d( + self.conv_out_channels, + self.conv_out_channels, + kernel_size=deconv_kernel_size, + stride=2, + padding=(deconv_kernel_size - 2) // 2, + groups=grid_points) + self.norm1 = nn.GroupNorm(grid_points, self.conv_out_channels) + self.deconv2 = nn.ConvTranspose2d( + self.conv_out_channels, + grid_points, + kernel_size=deconv_kernel_size, + stride=2, + padding=(deconv_kernel_size - 2) // 2, + groups=grid_points) + + # find the 4-neighbor of each grid point + self.neighbor_points = [] + grid_size = self.grid_size + for i in range(grid_size): # i-th column + for j in range(grid_size): # j-th row + neighbors = [] + if i > 0: # left: (i - 1, j) + neighbors.append((i - 1) * grid_size + j) + if j > 0: # up: (i, j - 1) + neighbors.append(i * grid_size + j - 1) + if j < grid_size - 1: # down: (i, j + 1) + neighbors.append(i * grid_size + j + 1) + if i < grid_size - 1: # right: (i + 1, j) + neighbors.append((i + 1) * grid_size + j) + self.neighbor_points.append(tuple(neighbors)) + # total edges in the grid + self.num_edges = sum([len(p) for p in self.neighbor_points]) + + self.forder_trans = nn.ModuleList() # first-order feature transition + self.sorder_trans = nn.ModuleList() # second-order feature transition + for neighbors in self.neighbor_points: + fo_trans = nn.ModuleList() + so_trans = nn.ModuleList() + for _ in range(len(neighbors)): + # each transition module consists of a 5x5 depth-wise conv and + # 1x1 conv. + fo_trans.append( + nn.Sequential( + nn.Conv2d( + self.point_feat_channels, + self.point_feat_channels, + 5, + stride=1, + padding=2, + groups=self.point_feat_channels), + nn.Conv2d(self.point_feat_channels, + self.point_feat_channels, 1))) + so_trans.append( + nn.Sequential( + nn.Conv2d( + self.point_feat_channels, + self.point_feat_channels, + 5, + 1, + 2, + groups=self.point_feat_channels), + nn.Conv2d(self.point_feat_channels, + self.point_feat_channels, 1))) + self.forder_trans.append(fo_trans) + self.sorder_trans.append(so_trans) + + self.loss_grid = build_loss(loss_grid) + + def init_weights(self): + for m in self.modules(): + if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear): + # TODO: compare mode = "fan_in" or "fan_out" + kaiming_init(m) + for m in self.modules(): + if isinstance(m, nn.ConvTranspose2d): + normal_init(m, std=0.001) + nn.init.constant_(self.deconv2.bias, -np.log(0.99 / 0.01)) + + def forward(self, x): + assert x.shape[-1] == x.shape[-2] == self.roi_feat_size + # RoI feature transformation, downsample 2x + x = self.convs(x) + + c = self.point_feat_channels + # first-order fusion + x_fo = [None for _ in range(self.grid_points)] + for i, points in enumerate(self.neighbor_points): + x_fo[i] = x[:, i * c:(i + 1) * c] + for j, point_idx in enumerate(points): + x_fo[i] = x_fo[i] + self.forder_trans[i][j]( + x[:, point_idx * c:(point_idx + 1) * c]) + + # second-order fusion + x_so = [None for _ in range(self.grid_points)] + for i, points in enumerate(self.neighbor_points): + x_so[i] = x[:, i * c:(i + 1) * c] + for j, point_idx in enumerate(points): + x_so[i] = x_so[i] + self.sorder_trans[i][j](x_fo[point_idx]) + + # predicted heatmap with fused features + x2 = torch.cat(x_so, dim=1) + x2 = self.deconv1(x2) + x2 = F.relu(self.norm1(x2), inplace=True) + heatmap = self.deconv2(x2) + + # predicted heatmap with original features (applicable during training) + if self.training: + x1 = x + x1 = self.deconv1(x1) + x1 = F.relu(self.norm1(x1), inplace=True) + heatmap_unfused = self.deconv2(x1) + else: + heatmap_unfused = heatmap + + return dict(fused=heatmap, unfused=heatmap_unfused) + + def calc_sub_regions(self): + """Compute point specific representation regions. + + See Grid R-CNN Plus (https://arxiv.org/abs/1906.05688) for details. + """ + # to make it consistent with the original implementation, half_size + # is computed as 2 * quarter_size, which is smaller + half_size = self.whole_map_size // 4 * 2 + sub_regions = [] + for i in range(self.grid_points): + x_idx = i // self.grid_size + y_idx = i % self.grid_size + if x_idx == 0: + sub_x1 = 0 + elif x_idx == self.grid_size - 1: + sub_x1 = half_size + else: + ratio = x_idx / (self.grid_size - 1) - 0.25 + sub_x1 = max(int(ratio * self.whole_map_size), 0) + + if y_idx == 0: + sub_y1 = 0 + elif y_idx == self.grid_size - 1: + sub_y1 = half_size + else: + ratio = y_idx / (self.grid_size - 1) - 0.25 + sub_y1 = max(int(ratio * self.whole_map_size), 0) + sub_regions.append( + (sub_x1, sub_y1, sub_x1 + half_size, sub_y1 + half_size)) + return sub_regions + + def get_target(self, sampling_results, rcnn_train_cfg): + # mix all samples (across images) together. + pos_bboxes = torch.cat([res.pos_bboxes for res in sampling_results], + dim=0).cpu() + pos_gt_bboxes = torch.cat( + [res.pos_gt_bboxes for res in sampling_results], dim=0).cpu() + assert pos_bboxes.shape == pos_gt_bboxes.shape + + # expand pos_bboxes to 2x of original size + x1 = pos_bboxes[:, 0] - (pos_bboxes[:, 2] - pos_bboxes[:, 0]) / 2 + y1 = pos_bboxes[:, 1] - (pos_bboxes[:, 3] - pos_bboxes[:, 1]) / 2 + x2 = pos_bboxes[:, 2] + (pos_bboxes[:, 2] - pos_bboxes[:, 0]) / 2 + y2 = pos_bboxes[:, 3] + (pos_bboxes[:, 3] - pos_bboxes[:, 1]) / 2 + pos_bboxes = torch.stack([x1, y1, x2, y2], dim=-1) + pos_bbox_ws = (pos_bboxes[:, 2] - pos_bboxes[:, 0]).unsqueeze(-1) + pos_bbox_hs = (pos_bboxes[:, 3] - pos_bboxes[:, 1]).unsqueeze(-1) + + num_rois = pos_bboxes.shape[0] + map_size = self.whole_map_size + # this is not the final target shape + targets = torch.zeros((num_rois, self.grid_points, map_size, map_size), + dtype=torch.float) + + # pre-compute interpolation factors for all grid points. + # the first item is the factor of x-dim, and the second is y-dim. + # for a 9-point grid, factors are like (1, 0), (0.5, 0.5), (0, 1) + factors = [] + for j in range(self.grid_points): + x_idx = j // self.grid_size + y_idx = j % self.grid_size + factors.append((1 - x_idx / (self.grid_size - 1), + 1 - y_idx / (self.grid_size - 1))) + + radius = rcnn_train_cfg.pos_radius + radius2 = radius**2 + for i in range(num_rois): + # ignore small bboxes + if (pos_bbox_ws[i] <= self.grid_size + or pos_bbox_hs[i] <= self.grid_size): + continue + # for each grid point, mark a small circle as positive + for j in range(self.grid_points): + factor_x, factor_y = factors[j] + gridpoint_x = factor_x * pos_gt_bboxes[i, 0] + ( + 1 - factor_x) * pos_gt_bboxes[i, 2] + gridpoint_y = factor_y * pos_gt_bboxes[i, 1] + ( + 1 - factor_y) * pos_gt_bboxes[i, 3] + + cx = int((gridpoint_x - pos_bboxes[i, 0]) / pos_bbox_ws[i] * + map_size) + cy = int((gridpoint_y - pos_bboxes[i, 1]) / pos_bbox_hs[i] * + map_size) + + for x in range(cx - radius, cx + radius + 1): + for y in range(cy - radius, cy + radius + 1): + if x >= 0 and x < map_size and y >= 0 and y < map_size: + if (x - cx)**2 + (y - cy)**2 <= radius2: + targets[i, j, y, x] = 1 + # reduce the target heatmap size by a half + # proposed in Grid R-CNN Plus (https://arxiv.org/abs/1906.05688). + sub_targets = [] + for i in range(self.grid_points): + sub_x1, sub_y1, sub_x2, sub_y2 = self.sub_regions[i] + sub_targets.append(targets[:, [i], sub_y1:sub_y2, sub_x1:sub_x2]) + sub_targets = torch.cat(sub_targets, dim=1) + sub_targets = sub_targets.cuda() + return sub_targets + + def loss(self, grid_pred, grid_targets): + loss_fused = self.loss_grid(grid_pred['fused'], grid_targets) + loss_unfused = self.loss_grid(grid_pred['unfused'], grid_targets) + loss_grid = loss_fused + loss_unfused + return dict(loss_grid=loss_grid) + + def get_bboxes(self, det_bboxes, grid_pred, img_meta): + # TODO: refactoring + assert det_bboxes.shape[0] == grid_pred.shape[0] + det_bboxes = det_bboxes.cpu() + cls_scores = det_bboxes[:, [4]] + det_bboxes = det_bboxes[:, :4] + grid_pred = grid_pred.sigmoid().cpu() + + R, c, h, w = grid_pred.shape + half_size = self.whole_map_size // 4 * 2 + assert h == w == half_size + assert c == self.grid_points + + # find the point with max scores in the half-sized heatmap + grid_pred = grid_pred.view(R * c, h * w) + pred_scores, pred_position = grid_pred.max(dim=1) + xs = pred_position % w + ys = pred_position // w + + # get the position in the whole heatmap instead of half-sized heatmap + for i in range(self.grid_points): + xs[i::self.grid_points] += self.sub_regions[i][0] + ys[i::self.grid_points] += self.sub_regions[i][1] + + # reshape to (num_rois, grid_points) + pred_scores, xs, ys = tuple( + map(lambda x: x.view(R, c), [pred_scores, xs, ys])) + + # get expanded pos_bboxes + widths = (det_bboxes[:, 2] - det_bboxes[:, 0]).unsqueeze(-1) + heights = (det_bboxes[:, 3] - det_bboxes[:, 1]).unsqueeze(-1) + x1 = (det_bboxes[:, 0, None] - widths / 2) + y1 = (det_bboxes[:, 1, None] - heights / 2) + # map the grid point to the absolute coordinates + abs_xs = (xs.float() + 0.5) / w * widths + x1 + abs_ys = (ys.float() + 0.5) / h * heights + y1 + + # get the grid points indices that fall on the bbox boundaries + x1_inds = [i for i in range(self.grid_size)] + y1_inds = [i * self.grid_size for i in range(self.grid_size)] + x2_inds = [ + self.grid_points - self.grid_size + i + for i in range(self.grid_size) + ] + y2_inds = [(i + 1) * self.grid_size - 1 for i in range(self.grid_size)] + + # voting of all grid points on some boundary + bboxes_x1 = (abs_xs[:, x1_inds] * pred_scores[:, x1_inds]).sum( + dim=1, keepdim=True) / ( + pred_scores[:, x1_inds].sum(dim=1, keepdim=True)) + bboxes_y1 = (abs_ys[:, y1_inds] * pred_scores[:, y1_inds]).sum( + dim=1, keepdim=True) / ( + pred_scores[:, y1_inds].sum(dim=1, keepdim=True)) + bboxes_x2 = (abs_xs[:, x2_inds] * pred_scores[:, x2_inds]).sum( + dim=1, keepdim=True) / ( + pred_scores[:, x2_inds].sum(dim=1, keepdim=True)) + bboxes_y2 = (abs_ys[:, y2_inds] * pred_scores[:, y2_inds]).sum( + dim=1, keepdim=True) / ( + pred_scores[:, y2_inds].sum(dim=1, keepdim=True)) + + bbox_res = torch.cat( + [bboxes_x1, bboxes_y1, bboxes_x2, bboxes_y2, cls_scores], dim=1) + bbox_res[:, [0, 2]].clamp_(min=0, max=img_meta[0]['img_shape'][1] - 1) + bbox_res[:, [1, 3]].clamp_(min=0, max=img_meta[0]['img_shape'][0] - 1) + + return bbox_res diff --git a/mmdet/models/mask_heads/htc_mask_head.py b/mmdet/models/mask_heads/htc_mask_head.py new file mode 100644 index 0000000..7c81255 --- /dev/null +++ b/mmdet/models/mask_heads/htc_mask_head.py @@ -0,0 +1,38 @@ +from ..registry import HEADS +from ..utils import ConvModule +from .fcn_mask_head import FCNMaskHead + + +@HEADS.register_module +class HTCMaskHead(FCNMaskHead): + + def __init__(self, *args, **kwargs): + super(HTCMaskHead, self).__init__(*args, **kwargs) + self.conv_res = ConvModule( + self.conv_out_channels, + self.conv_out_channels, + 1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg) + + def init_weights(self): + super(HTCMaskHead, self).init_weights() + self.conv_res.init_weights() + + def forward(self, x, res_feat=None, return_logits=True, return_feat=True): + if res_feat is not None: + res_feat = self.conv_res(res_feat) + x = x + res_feat + for conv in self.convs: + x = conv(x) + res_feat = x + outs = [] + if return_logits: + x = self.upsample(x) + if self.upsample_method == 'deconv': + x = self.relu(x) + mask_pred = self.conv_logits(x) + outs.append(mask_pred) + if return_feat: + outs.append(res_feat) + return outs if len(outs) > 1 else outs[0] diff --git a/mmdet/models/mask_heads/maskiou_head.py b/mmdet/models/mask_heads/maskiou_head.py new file mode 100644 index 0000000..3c92368 --- /dev/null +++ b/mmdet/models/mask_heads/maskiou_head.py @@ -0,0 +1,190 @@ +import numpy as np +import torch +import torch.nn as nn +from mmcv.cnn import kaiming_init, normal_init +from torch.nn.modules.utils import _pair + +from mmdet.core import force_fp32 +from ..builder import build_loss +from ..registry import HEADS + + +@HEADS.register_module +class MaskIoUHead(nn.Module): + """Mask IoU Head. + + This head predicts the IoU of predicted masks and corresponding gt masks. + """ + + def __init__(self, + num_convs=4, + num_fcs=2, + roi_feat_size=14, + in_channels=256, + conv_out_channels=256, + fc_out_channels=1024, + num_classes=81, + loss_iou=dict(type='MSELoss', loss_weight=0.5)): + super(MaskIoUHead, self).__init__() + self.in_channels = in_channels + self.conv_out_channels = conv_out_channels + self.fc_out_channels = fc_out_channels + self.num_classes = num_classes + self.fp16_enabled = False + + self.convs = nn.ModuleList() + for i in range(num_convs): + if i == 0: + # concatenation of mask feature and mask prediction + in_channels = self.in_channels + 1 + else: + in_channels = self.conv_out_channels + stride = 2 if i == num_convs - 1 else 1 + self.convs.append( + nn.Conv2d( + in_channels, + self.conv_out_channels, + 3, + stride=stride, + padding=1)) + + roi_feat_size = _pair(roi_feat_size) + pooled_area = (roi_feat_size[0] // 2) * (roi_feat_size[1] // 2) + self.fcs = nn.ModuleList() + for i in range(num_fcs): + in_channels = ( + self.conv_out_channels * + pooled_area if i == 0 else self.fc_out_channels) + self.fcs.append(nn.Linear(in_channels, self.fc_out_channels)) + + self.fc_mask_iou = nn.Linear(self.fc_out_channels, self.num_classes) + self.relu = nn.ReLU() + self.max_pool = nn.MaxPool2d(2, 2) + self.loss_iou = build_loss(loss_iou) + + def init_weights(self): + for conv in self.convs: + kaiming_init(conv) + for fc in self.fcs: + kaiming_init( + fc, + a=1, + mode='fan_in', + nonlinearity='leaky_relu', + distribution='uniform') + normal_init(self.fc_mask_iou, std=0.01) + + def forward(self, mask_feat, mask_pred): + mask_pred = mask_pred.sigmoid() + mask_pred_pooled = self.max_pool(mask_pred.unsqueeze(1)) + + x = torch.cat((mask_feat, mask_pred_pooled), 1) + + for conv in self.convs: + x = self.relu(conv(x)) + x = x.view(x.size(0), -1) + for fc in self.fcs: + x = self.relu(fc(x)) + mask_iou = self.fc_mask_iou(x) + return mask_iou + + @force_fp32(apply_to=('mask_iou_pred', )) + def loss(self, mask_iou_pred, mask_iou_targets): + pos_inds = mask_iou_targets > 0 + if pos_inds.sum() > 0: + loss_mask_iou = self.loss_iou(mask_iou_pred[pos_inds], + mask_iou_targets[pos_inds]) + else: + loss_mask_iou = mask_iou_pred * 0 + return dict(loss_mask_iou=loss_mask_iou) + + @force_fp32(apply_to=('mask_pred', )) + def get_target(self, sampling_results, gt_masks, mask_pred, mask_targets, + rcnn_train_cfg): + """Compute target of mask IoU. + + Mask IoU target is the IoU of the predicted mask (inside a bbox) and + the gt mask of corresponding gt mask (the whole instance). + The intersection area is computed inside the bbox, and the gt mask area + is computed with two steps, firstly we compute the gt area inside the + bbox, then divide it by the area ratio of gt area inside the bbox and + the gt area of the whole instance. + + Args: + sampling_results (list[:obj:`SamplingResult`]): sampling results. + gt_masks (list[ndarray]): Gt masks (the whole instance) of each + image, binary maps with the same shape of the input image. + mask_pred (Tensor): Predicted masks of each positive proposal, + shape (num_pos, h, w). + mask_targets (Tensor): Gt mask of each positive proposal, + binary map of the shape (num_pos, h, w). + rcnn_train_cfg (dict): Training config for R-CNN part. + + Returns: + Tensor: mask iou target (length == num positive). + """ + pos_proposals = [res.pos_bboxes for res in sampling_results] + pos_assigned_gt_inds = [ + res.pos_assigned_gt_inds for res in sampling_results + ] + + # compute the area ratio of gt areas inside the proposals and + # the whole instance + area_ratios = map(self._get_area_ratio, pos_proposals, + pos_assigned_gt_inds, gt_masks) + area_ratios = torch.cat(list(area_ratios)) + assert mask_targets.size(0) == area_ratios.size(0) + + mask_pred = (mask_pred > rcnn_train_cfg.mask_thr_binary).float() + mask_pred_areas = mask_pred.sum((-1, -2)) + + # mask_pred and mask_targets are binary maps + overlap_areas = (mask_pred * mask_targets).sum((-1, -2)) + + # compute the mask area of the whole instance + gt_full_areas = mask_targets.sum((-1, -2)) / (area_ratios + 1e-7) + + mask_iou_targets = overlap_areas / ( + mask_pred_areas + gt_full_areas - overlap_areas) + return mask_iou_targets + + def _get_area_ratio(self, pos_proposals, pos_assigned_gt_inds, gt_masks): + """Compute area ratio of the gt mask inside the proposal and the gt + mask of the corresponding instance""" + num_pos = pos_proposals.size(0) + if num_pos > 0: + area_ratios = [] + proposals_np = pos_proposals.cpu().numpy() + pos_assigned_gt_inds = pos_assigned_gt_inds.cpu().numpy() + # compute mask areas of gt instances (batch processing for speedup) + gt_instance_mask_area = gt_masks.sum((-1, -2)) + for i in range(num_pos): + gt_mask = gt_masks[pos_assigned_gt_inds[i]] + + # crop the gt mask inside the proposal + x1, y1, x2, y2 = proposals_np[i, :].astype(np.int32) + gt_mask_in_proposal = gt_mask[y1:y2 + 1, x1:x2 + 1] + + ratio = gt_mask_in_proposal.sum() / ( + gt_instance_mask_area[pos_assigned_gt_inds[i]] + 1e-7) + area_ratios.append(ratio) + area_ratios = torch.from_numpy(np.stack(area_ratios)).float().to( + pos_proposals.device) + else: + area_ratios = pos_proposals.new_zeros((0, )) + return area_ratios + + @force_fp32(apply_to=('mask_iou_pred', )) + def get_mask_scores(self, mask_iou_pred, det_bboxes, det_labels): + """Get the mask scores. + + mask_score = bbox_score * mask_iou + """ + inds = range(det_labels.size(0)) + mask_scores = mask_iou_pred[inds, det_labels + + 1] * det_bboxes[inds, -1] + mask_scores = mask_scores.cpu().numpy() + det_labels = det_labels.cpu().numpy() + return [ + mask_scores[det_labels == i] for i in range(self.num_classes - 1) + ] diff --git a/mmdet/models/necks/__init__.py b/mmdet/models/necks/__init__.py new file mode 100644 index 0000000..6b26e5f --- /dev/null +++ b/mmdet/models/necks/__init__.py @@ -0,0 +1,5 @@ +from .bfp import BFP +from .fpn import FPN +from .hrfpn import HRFPN + +__all__ = ['FPN', 'BFP', 'HRFPN'] diff --git a/mmdet/models/necks/bfp.py b/mmdet/models/necks/bfp.py new file mode 100644 index 0000000..03aee10 --- /dev/null +++ b/mmdet/models/necks/bfp.py @@ -0,0 +1,102 @@ +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import xavier_init + +from ..plugins import NonLocal2D +from ..registry import NECKS +from ..utils import ConvModule + + +@NECKS.register_module +class BFP(nn.Module): + """BFP (Balanced Feature Pyrmamids) + + BFP takes multi-level features as inputs and gather them into a single one, + then refine the gathered feature and scatter the refined results to + multi-level features. This module is used in Libra R-CNN (CVPR 2019), see + https://arxiv.org/pdf/1904.02701.pdf for details. + + Args: + in_channels (int): Number of input channels (feature maps of all levels + should have the same channels). + num_levels (int): Number of input feature levels. + conv_cfg (dict): The config dict for convolution layers. + norm_cfg (dict): The config dict for normalization layers. + refine_level (int): Index of integration and refine level of BSF in + multi-level features from bottom to top. + refine_type (str): Type of the refine op, currently support + [None, 'conv', 'non_local']. + """ + + def __init__(self, + in_channels, + num_levels, + refine_level=2, + refine_type=None, + conv_cfg=None, + norm_cfg=None): + super(BFP, self).__init__() + assert refine_type in [None, 'conv', 'non_local'] + + self.in_channels = in_channels + self.num_levels = num_levels + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + + self.refine_level = refine_level + self.refine_type = refine_type + assert 0 <= self.refine_level < self.num_levels + + if self.refine_type == 'conv': + self.refine = ConvModule( + self.in_channels, + self.in_channels, + 3, + padding=1, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg) + elif self.refine_type == 'non_local': + self.refine = NonLocal2D( + self.in_channels, + reduction=1, + use_scale=False, + conv_cfg=self.conv_cfg, + norm_cfg=self.norm_cfg) + + def init_weights(self): + for m in self.modules(): + if isinstance(m, nn.Conv2d): + xavier_init(m, distribution='uniform') + + def forward(self, inputs): + assert len(inputs) == self.num_levels + + # step 1: gather multi-level features by resize and average + feats = [] + gather_size = inputs[self.refine_level].size()[2:] + for i in range(self.num_levels): + if i < self.refine_level: + gathered = F.adaptive_max_pool2d( + inputs[i], output_size=gather_size) + else: + gathered = F.interpolate( + inputs[i], size=gather_size, mode='nearest') + feats.append(gathered) + + bsf = sum(feats) / len(feats) + + # step 2: refine gathered features + if self.refine_type is not None: + bsf = self.refine(bsf) + + # step 3: scatter refined features to multi-levels by a residual path + outs = [] + for i in range(self.num_levels): + out_size = inputs[i].size()[2:] + if i < self.refine_level: + residual = F.interpolate(bsf, size=out_size, mode='nearest') + else: + residual = F.adaptive_max_pool2d(bsf, output_size=out_size) + outs.append(residual + inputs[i]) + + return tuple(outs) diff --git a/mmdet/models/necks/fpn.py b/mmdet/models/necks/fpn.py new file mode 100644 index 0000000..d42fb1d --- /dev/null +++ b/mmdet/models/necks/fpn.py @@ -0,0 +1,139 @@ +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import xavier_init + +from mmdet.core import auto_fp16 +from ..registry import NECKS +from ..utils import ConvModule + + +@NECKS.register_module +class FPN(nn.Module): + + def __init__(self, + in_channels, + out_channels, + num_outs, + start_level=0, + end_level=-1, + add_extra_convs=False, + extra_convs_on_inputs=True, + relu_before_extra_convs=False, + conv_cfg=None, + norm_cfg=None, + activation=None): + super(FPN, self).__init__() + assert isinstance(in_channels, list) + self.in_channels = in_channels + self.out_channels = out_channels + self.num_ins = len(in_channels) + self.num_outs = num_outs + self.activation = activation + self.relu_before_extra_convs = relu_before_extra_convs + self.fp16_enabled = False + + if end_level == -1: + self.backbone_end_level = self.num_ins + assert num_outs >= self.num_ins - start_level + else: + # if end_level < inputs, no extra level is allowed + self.backbone_end_level = end_level + assert end_level <= len(in_channels) + assert num_outs == end_level - start_level + self.start_level = start_level + self.end_level = end_level + self.add_extra_convs = add_extra_convs + self.extra_convs_on_inputs = extra_convs_on_inputs + + self.lateral_convs = nn.ModuleList() + self.fpn_convs = nn.ModuleList() + + for i in range(self.start_level, self.backbone_end_level): + l_conv = ConvModule( + in_channels[i], + out_channels, + 1, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + activation=self.activation, + inplace=False) + fpn_conv = ConvModule( + out_channels, + out_channels, + 3, + padding=1, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + activation=self.activation, + inplace=False) + + self.lateral_convs.append(l_conv) + self.fpn_convs.append(fpn_conv) + + # add extra conv layers (e.g., RetinaNet) + extra_levels = num_outs - self.backbone_end_level + self.start_level + if add_extra_convs and extra_levels >= 1: + for i in range(extra_levels): + if i == 0 and self.extra_convs_on_inputs: + in_channels = self.in_channels[self.backbone_end_level - 1] + else: + in_channels = out_channels + extra_fpn_conv = ConvModule( + in_channels, + out_channels, + 3, + stride=2, + padding=1, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + activation=self.activation, + inplace=False) + self.fpn_convs.append(extra_fpn_conv) + + # default init_weights for conv(msra) and norm in ConvModule + def init_weights(self): + for m in self.modules(): + if isinstance(m, nn.Conv2d): + xavier_init(m, distribution='uniform') + + @auto_fp16() + def forward(self, inputs): + assert len(inputs) == len(self.in_channels) + + # build laterals + laterals = [ + lateral_conv(inputs[i + self.start_level]) + for i, lateral_conv in enumerate(self.lateral_convs) + ] + + # build top-down path + used_backbone_levels = len(laterals) + for i in range(used_backbone_levels - 1, 0, -1): + laterals[i - 1] += F.interpolate( + laterals[i], scale_factor=2, mode='nearest') + + # build outputs + # part 1: from original levels + outs = [ + self.fpn_convs[i](laterals[i]) for i in range(used_backbone_levels) + ] + # part 2: add extra levels + if self.num_outs > len(outs): + # use max pool to get more levels on top of outputs + # (e.g., Faster R-CNN, Mask R-CNN) + if not self.add_extra_convs: + for i in range(self.num_outs - used_backbone_levels): + outs.append(F.max_pool2d(outs[-1], 1, stride=2)) + # add conv layers on top of original feature maps (RetinaNet) + else: + if self.extra_convs_on_inputs: + orig = inputs[self.backbone_end_level - 1] + outs.append(self.fpn_convs[used_backbone_levels](orig)) + else: + outs.append(self.fpn_convs[used_backbone_levels](outs[-1])) + for i in range(used_backbone_levels + 1, self.num_outs): + if self.relu_before_extra_convs: + outs.append(self.fpn_convs[i](F.relu(outs[-1]))) + else: + outs.append(self.fpn_convs[i](outs[-1])) + return tuple(outs) diff --git a/mmdet/models/necks/hrfpn.py b/mmdet/models/necks/hrfpn.py new file mode 100644 index 0000000..33155f0 --- /dev/null +++ b/mmdet/models/necks/hrfpn.py @@ -0,0 +1,100 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn.weight_init import caffe2_xavier_init +from torch.utils.checkpoint import checkpoint + +from ..registry import NECKS +from ..utils import ConvModule + + +@NECKS.register_module +class HRFPN(nn.Module): + """HRFPN (High Resolution Feature Pyrmamids) + + arXiv: https://arxiv.org/abs/1904.04514 + + Args: + in_channels (list): number of channels for each branch. + out_channels (int): output channels of feature pyramids. + num_outs (int): number of output stages. + pooling_type (str): pooling for generating feature pyramids + from {MAX, AVG}. + conv_cfg (dict): dictionary to construct and config conv layer. + norm_cfg (dict): dictionary to construct and config norm layer. + with_cp (bool): Use checkpoint or not. Using checkpoint will save some + memory while slowing down the training speed. + stride (int): stride of 3x3 convolutional layers + """ + + def __init__(self, + in_channels, + out_channels, + num_outs=5, + pooling_type='AVG', + conv_cfg=None, + norm_cfg=None, + with_cp=False, + stride=1): + super(HRFPN, self).__init__() + assert isinstance(in_channels, list) + self.in_channels = in_channels + self.out_channels = out_channels + self.num_ins = len(in_channels) + self.num_outs = num_outs + self.with_cp = with_cp + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + + self.reduction_conv = ConvModule( + sum(in_channels), + out_channels, + kernel_size=1, + conv_cfg=self.conv_cfg, + activation=None) + + self.fpn_convs = nn.ModuleList() + for i in range(self.num_outs): + self.fpn_convs.append( + ConvModule( + out_channels, + out_channels, + kernel_size=3, + padding=1, + stride=stride, + conv_cfg=self.conv_cfg, + activation=None)) + + if pooling_type == 'MAX': + self.pooling = F.max_pool2d + else: + self.pooling = F.avg_pool2d + + def init_weights(self): + for m in self.modules(): + if isinstance(m, nn.Conv2d): + caffe2_xavier_init(m) + + def forward(self, inputs): + assert len(inputs) == self.num_ins + outs = [inputs[0]] + for i in range(1, self.num_ins): + outs.append( + F.interpolate(inputs[i], scale_factor=2**i, mode='bilinear')) + out = torch.cat(outs, dim=1) + if out.requires_grad and self.with_cp: + out = checkpoint(self.reduction_conv, out) + else: + out = self.reduction_conv(out) + outs = [out] + for i in range(1, self.num_outs): + outs.append(self.pooling(out, kernel_size=2**i, stride=2**i)) + outputs = [] + + for i in range(self.num_outs): + if outs[i].requires_grad and self.with_cp: + tmp_out = checkpoint(self.fpn_convs[i], outs[i]) + else: + tmp_out = self.fpn_convs[i](outs[i]) + outputs.append(tmp_out) + return tuple(outputs) diff --git a/mmdet/models/plugins/__init__.py b/mmdet/models/plugins/__init__.py new file mode 100644 index 0000000..0ff85f2 --- /dev/null +++ b/mmdet/models/plugins/__init__.py @@ -0,0 +1,4 @@ +from .generalized_attention import GeneralizedAttention +from .non_local import NonLocal2D + +__all__ = ['NonLocal2D', 'GeneralizedAttention'] diff --git a/mmdet/models/plugins/generalized_attention.py b/mmdet/models/plugins/generalized_attention.py new file mode 100644 index 0000000..9517776 --- /dev/null +++ b/mmdet/models/plugins/generalized_attention.py @@ -0,0 +1,384 @@ +import math + +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import kaiming_init + + +class GeneralizedAttention(nn.Module): + """GeneralizedAttention module. + + See 'An Empirical Study of Spatial Attention Mechanisms in Deep Networks' + (https://arxiv.org/abs/1711.07971) for details. + + Args: + in_dim (int): Channels of the input feature map. + spatial_range (int): The spatial range. + -1 indicates no spatial range constraint. + num_heads (int): The head number of empirical_attention module. + position_embedding_dim (int): The position embedding dimension. + position_magnitude (int): A multiplier acting on coord difference. + kv_stride (int): The feature stride acting on key/value feature map. + q_stride (int): The feature stride acting on query feature map. + attention_type (str): A binary indicator string for indicating which + items in generalized empirical_attention module are used. + '1000' indicates 'query and key content' (appr - appr) item, + '0100' indicates 'query content and relative position' + (appr - position) item, + '0010' indicates 'key content only' (bias - appr) item, + '0001' indicates 'relative position only' (bias - position) item. + """ + + def __init__(self, + in_dim, + spatial_range=-1, + num_heads=9, + position_embedding_dim=-1, + position_magnitude=1, + kv_stride=2, + q_stride=1, + attention_type='1111'): + + super(GeneralizedAttention, self).__init__() + + # hard range means local range for non-local operation + self.position_embedding_dim = ( + position_embedding_dim if position_embedding_dim > 0 else in_dim) + + self.position_magnitude = position_magnitude + self.num_heads = num_heads + self.channel_in = in_dim + self.spatial_range = spatial_range + self.kv_stride = kv_stride + self.q_stride = q_stride + self.attention_type = [bool(int(_)) for _ in attention_type] + self.qk_embed_dim = in_dim // num_heads + out_c = self.qk_embed_dim * num_heads + + if self.attention_type[0] or self.attention_type[1]: + self.query_conv = nn.Conv2d( + in_channels=in_dim, + out_channels=out_c, + kernel_size=1, + bias=False) + self.query_conv.kaiming_init = True + + if self.attention_type[0] or self.attention_type[2]: + self.key_conv = nn.Conv2d( + in_channels=in_dim, + out_channels=out_c, + kernel_size=1, + bias=False) + self.key_conv.kaiming_init = True + + self.v_dim = in_dim // num_heads + self.value_conv = nn.Conv2d( + in_channels=in_dim, + out_channels=self.v_dim * num_heads, + kernel_size=1, + bias=False) + self.value_conv.kaiming_init = True + + if self.attention_type[1] or self.attention_type[3]: + self.appr_geom_fc_x = nn.Linear( + self.position_embedding_dim // 2, out_c, bias=False) + self.appr_geom_fc_x.kaiming_init = True + + self.appr_geom_fc_y = nn.Linear( + self.position_embedding_dim // 2, out_c, bias=False) + self.appr_geom_fc_y.kaiming_init = True + + if self.attention_type[2]: + stdv = 1.0 / math.sqrt(self.qk_embed_dim * 2) + appr_bias_value = -2 * stdv * torch.rand(out_c) + stdv + self.appr_bias = nn.Parameter(appr_bias_value) + + if self.attention_type[3]: + stdv = 1.0 / math.sqrt(self.qk_embed_dim * 2) + geom_bias_value = -2 * stdv * torch.rand(out_c) + stdv + self.geom_bias = nn.Parameter(geom_bias_value) + + self.proj_conv = nn.Conv2d( + in_channels=self.v_dim * num_heads, + out_channels=in_dim, + kernel_size=1, + bias=True) + self.proj_conv.kaiming_init = True + self.gamma = nn.Parameter(torch.zeros(1)) + + if self.spatial_range >= 0: + # only works when non local is after 3*3 conv + if in_dim == 256: + max_len = 84 + elif in_dim == 512: + max_len = 42 + + max_len_kv = int((max_len - 1.0) / self.kv_stride + 1) + local_constraint_map = np.ones( + (max_len, max_len, max_len_kv, max_len_kv), dtype=np.int) + for iy in range(max_len): + for ix in range(max_len): + local_constraint_map[iy, ix, + max((iy - self.spatial_range) // + self.kv_stride, 0):min( + (iy + self.spatial_range + + 1) // self.kv_stride + + 1, max_len), + max((ix - self.spatial_range) // + self.kv_stride, 0):min( + (ix + self.spatial_range + + 1) // self.kv_stride + + 1, max_len)] = 0 + + self.local_constraint_map = nn.Parameter( + torch.from_numpy(local_constraint_map).byte(), + requires_grad=False) + + if self.q_stride > 1: + self.q_downsample = nn.AvgPool2d( + kernel_size=1, stride=self.q_stride) + else: + self.q_downsample = None + + if self.kv_stride > 1: + self.kv_downsample = nn.AvgPool2d( + kernel_size=1, stride=self.kv_stride) + else: + self.kv_downsample = None + + self.init_weights() + + def get_position_embedding(self, + h, + w, + h_kv, + w_kv, + q_stride, + kv_stride, + device, + feat_dim, + wave_length=1000): + h_idxs = torch.linspace(0, h - 1, h).cuda(device) + h_idxs = h_idxs.view((h, 1)) * q_stride + + w_idxs = torch.linspace(0, w - 1, w).cuda(device) + w_idxs = w_idxs.view((w, 1)) * q_stride + + h_kv_idxs = torch.linspace(0, h_kv - 1, h_kv).cuda(device) + h_kv_idxs = h_kv_idxs.view((h_kv, 1)) * kv_stride + + w_kv_idxs = torch.linspace(0, w_kv - 1, w_kv).cuda(device) + w_kv_idxs = w_kv_idxs.view((w_kv, 1)) * kv_stride + + # (h, h_kv, 1) + h_diff = h_idxs.unsqueeze(1) - h_kv_idxs.unsqueeze(0) + h_diff *= self.position_magnitude + + # (w, w_kv, 1) + w_diff = w_idxs.unsqueeze(1) - w_kv_idxs.unsqueeze(0) + w_diff *= self.position_magnitude + + feat_range = torch.arange(0, feat_dim / 4).cuda(device) + + dim_mat = torch.Tensor([wave_length]).cuda(device) + dim_mat = dim_mat**((4. / feat_dim) * feat_range) + dim_mat = dim_mat.view((1, 1, -1)) + + embedding_x = torch.cat( + ((w_diff / dim_mat).sin(), (w_diff / dim_mat).cos()), dim=2) + + embedding_y = torch.cat( + ((h_diff / dim_mat).sin(), (h_diff / dim_mat).cos()), dim=2) + + return embedding_x, embedding_y + + def forward(self, x_input): + num_heads = self.num_heads + + # use empirical_attention + if self.q_downsample is not None: + x_q = self.q_downsample(x_input) + else: + x_q = x_input + n, _, h, w = x_q.shape + + if self.kv_downsample is not None: + x_kv = self.kv_downsample(x_input) + else: + x_kv = x_input + _, _, h_kv, w_kv = x_kv.shape + + if self.attention_type[0] or self.attention_type[1]: + proj_query = self.query_conv(x_q).view( + (n, num_heads, self.qk_embed_dim, h * w)) + proj_query = proj_query.permute(0, 1, 3, 2) + + if self.attention_type[0] or self.attention_type[2]: + proj_key = self.key_conv(x_kv).view( + (n, num_heads, self.qk_embed_dim, h_kv * w_kv)) + + if self.attention_type[1] or self.attention_type[3]: + position_embed_x, position_embed_y = self.get_position_embedding( + h, w, h_kv, w_kv, self.q_stride, self.kv_stride, + x_input.device, self.position_embedding_dim) + # (n, num_heads, w, w_kv, dim) + position_feat_x = self.appr_geom_fc_x(position_embed_x).\ + view(1, w, w_kv, num_heads, self.qk_embed_dim).\ + permute(0, 3, 1, 2, 4).\ + repeat(n, 1, 1, 1, 1) + + # (n, num_heads, h, h_kv, dim) + position_feat_y = self.appr_geom_fc_y(position_embed_y).\ + view(1, h, h_kv, num_heads, self.qk_embed_dim).\ + permute(0, 3, 1, 2, 4).\ + repeat(n, 1, 1, 1, 1) + + position_feat_x /= math.sqrt(2) + position_feat_y /= math.sqrt(2) + + # accelerate for saliency only + if (np.sum(self.attention_type) == 1) and self.attention_type[2]: + appr_bias = self.appr_bias.\ + view(1, num_heads, 1, self.qk_embed_dim).\ + repeat(n, 1, 1, 1) + + energy = torch.matmul(appr_bias, proj_key).\ + view(n, num_heads, 1, h_kv * w_kv) + + h = 1 + w = 1 + else: + # (n, num_heads, h*w, h_kv*w_kv), query before key, 540mb for + if not self.attention_type[0]: + energy = torch.zeros( + n, + num_heads, + h, + w, + h_kv, + w_kv, + dtype=x_input.dtype, + device=x_input.device) + + # attention_type[0]: appr - appr + # attention_type[1]: appr - position + # attention_type[2]: bias - appr + # attention_type[3]: bias - position + if self.attention_type[0] or self.attention_type[2]: + if self.attention_type[0] and self.attention_type[2]: + appr_bias = self.appr_bias.\ + view(1, num_heads, 1, self.qk_embed_dim) + energy = torch.matmul(proj_query + appr_bias, proj_key).\ + view(n, num_heads, h, w, h_kv, w_kv) + + elif self.attention_type[0]: + energy = torch.matmul(proj_query, proj_key).\ + view(n, num_heads, h, w, h_kv, w_kv) + + elif self.attention_type[2]: + appr_bias = self.appr_bias.\ + view(1, num_heads, 1, self.qk_embed_dim).\ + repeat(n, 1, 1, 1) + + energy += torch.matmul(appr_bias, proj_key).\ + view(n, num_heads, 1, 1, h_kv, w_kv) + + if self.attention_type[1] or self.attention_type[3]: + if self.attention_type[1] and self.attention_type[3]: + geom_bias = self.geom_bias.\ + view(1, num_heads, 1, self.qk_embed_dim) + + proj_query_reshape = (proj_query + geom_bias).\ + view(n, num_heads, h, w, self.qk_embed_dim) + + energy_x = torch.matmul( + proj_query_reshape.permute(0, 1, 3, 2, 4), + position_feat_x.permute(0, 1, 2, 4, 3)) + energy_x = energy_x.\ + permute(0, 1, 3, 2, 4).unsqueeze(4) + + energy_y = torch.matmul( + proj_query_reshape, + position_feat_y.permute(0, 1, 2, 4, 3)) + energy_y = energy_y.unsqueeze(5) + + energy += energy_x + energy_y + + elif self.attention_type[1]: + proj_query_reshape = proj_query.\ + view(n, num_heads, h, w, self.qk_embed_dim) + proj_query_reshape = proj_query_reshape.\ + permute(0, 1, 3, 2, 4) + position_feat_x_reshape = position_feat_x.\ + permute(0, 1, 2, 4, 3) + position_feat_y_reshape = position_feat_y.\ + permute(0, 1, 2, 4, 3) + + energy_x = torch.matmul(proj_query_reshape, + position_feat_x_reshape) + energy_x = energy_x.permute(0, 1, 3, 2, 4).unsqueeze(4) + + energy_y = torch.matmul(proj_query_reshape, + position_feat_y_reshape) + energy_y = energy_y.unsqueeze(5) + + energy += energy_x + energy_y + + elif self.attention_type[3]: + geom_bias = self.geom_bias.\ + view(1, num_heads, self.qk_embed_dim, 1).\ + repeat(n, 1, 1, 1) + + position_feat_x_reshape = position_feat_x.\ + view(n, num_heads, w*w_kv, self.qk_embed_dim) + + position_feat_y_reshape = position_feat_y.\ + view(n, num_heads, h * h_kv, self.qk_embed_dim) + + energy_x = torch.matmul(position_feat_x_reshape, geom_bias) + energy_x = energy_x.view(n, num_heads, 1, w, 1, w_kv) + + energy_y = torch.matmul(position_feat_y_reshape, geom_bias) + energy_y = energy_y.view(n, num_heads, h, 1, h_kv, 1) + + energy += energy_x + energy_y + + energy = energy.view(n, num_heads, h * w, h_kv * w_kv) + + if self.spatial_range >= 0: + cur_local_constraint_map = \ + self.local_constraint_map[:h, :w, :h_kv, :w_kv].\ + contiguous().\ + view(1, 1, h*w, h_kv*w_kv) + + energy = energy.masked_fill_(cur_local_constraint_map, + float('-inf')) + + attention = F.softmax(energy, 3) + + proj_value = self.value_conv(x_kv) + proj_value_reshape = proj_value.\ + view((n, num_heads, self.v_dim, h_kv * w_kv)).\ + permute(0, 1, 3, 2) + + out = torch.matmul(attention, proj_value_reshape).\ + permute(0, 1, 3, 2).\ + contiguous().\ + view(n, self.v_dim * self.num_heads, h, w) + + out = self.proj_conv(out) + out = self.gamma * out + x_input + return out + + def init_weights(self): + for m in self.modules(): + if hasattr(m, 'kaiming_init') and m.kaiming_init: + kaiming_init( + m, + mode='fan_in', + nonlinearity='leaky_relu', + bias=0, + distribution='uniform', + a=1) diff --git a/mmdet/models/plugins/non_local.py b/mmdet/models/plugins/non_local.py new file mode 100644 index 0000000..cbec7a4 --- /dev/null +++ b/mmdet/models/plugins/non_local.py @@ -0,0 +1,114 @@ +import torch +import torch.nn as nn +from mmcv.cnn import constant_init, normal_init + +from ..utils import ConvModule + + +class NonLocal2D(nn.Module): + """Non-local module. + + See https://arxiv.org/abs/1711.07971 for details. + + Args: + in_channels (int): Channels of the input feature map. + reduction (int): Channel reduction ratio. + use_scale (bool): Whether to scale pairwise_weight by 1/inter_channels. + conv_cfg (dict): The config dict for convolution layers. + (only applicable to conv_out) + norm_cfg (dict): The config dict for normalization layers. + (only applicable to conv_out) + mode (str): Options are `embedded_gaussian` and `dot_product`. + """ + + def __init__(self, + in_channels, + reduction=2, + use_scale=True, + conv_cfg=None, + norm_cfg=None, + mode='embedded_gaussian'): + super(NonLocal2D, self).__init__() + self.in_channels = in_channels + self.reduction = reduction + self.use_scale = use_scale + self.inter_channels = in_channels // reduction + self.mode = mode + assert mode in ['embedded_gaussian', 'dot_product'] + + # g, theta, phi are actually `nn.Conv2d`. Here we use ConvModule for + # potential usage. + self.g = ConvModule( + self.in_channels, + self.inter_channels, + kernel_size=1, + activation=None) + self.theta = ConvModule( + self.in_channels, + self.inter_channels, + kernel_size=1, + activation=None) + self.phi = ConvModule( + self.in_channels, + self.inter_channels, + kernel_size=1, + activation=None) + self.conv_out = ConvModule( + self.inter_channels, + self.in_channels, + kernel_size=1, + conv_cfg=conv_cfg, + norm_cfg=norm_cfg, + activation=None) + + self.init_weights() + + def init_weights(self, std=0.01, zeros_init=True): + for m in [self.g, self.theta, self.phi]: + normal_init(m.conv, std=std) + if zeros_init: + constant_init(self.conv_out.conv, 0) + else: + normal_init(self.conv_out.conv, std=std) + + def embedded_gaussian(self, theta_x, phi_x): + # pairwise_weight: [N, HxW, HxW] + pairwise_weight = torch.matmul(theta_x, phi_x) + if self.use_scale: + # theta_x.shape[-1] is `self.inter_channels` + pairwise_weight /= theta_x.shape[-1]**-0.5 + pairwise_weight = pairwise_weight.softmax(dim=-1) + return pairwise_weight + + def dot_product(self, theta_x, phi_x): + # pairwise_weight: [N, HxW, HxW] + pairwise_weight = torch.matmul(theta_x, phi_x) + pairwise_weight /= pairwise_weight.shape[-1] + return pairwise_weight + + def forward(self, x): + n, _, h, w = x.shape + + # g_x: [N, HxW, C] + g_x = self.g(x).view(n, self.inter_channels, -1) + g_x = g_x.permute(0, 2, 1) + + # theta_x: [N, HxW, C] + theta_x = self.theta(x).view(n, self.inter_channels, -1) + theta_x = theta_x.permute(0, 2, 1) + + # phi_x: [N, C, HxW] + phi_x = self.phi(x).view(n, self.inter_channels, -1) + + pairwise_func = getattr(self, self.mode) + # pairwise_weight: [N, HxW, HxW] + pairwise_weight = pairwise_func(theta_x, phi_x) + + # y: [N, HxW, C] + y = torch.matmul(pairwise_weight, g_x) + # y: [N, C, H, W] + y = y.permute(0, 2, 1).reshape(n, self.inter_channels, h, w) + + output = x + self.conv_out(y) + + return output diff --git a/mmdet/models/registry.py b/mmdet/models/registry.py new file mode 100644 index 0000000..78ef248 --- /dev/null +++ b/mmdet/models/registry.py @@ -0,0 +1,9 @@ +from mmdet.utils import Registry + +BACKBONES = Registry('backbone') +NECKS = Registry('neck') +ROI_EXTRACTORS = Registry('roi_extractor') +SHARED_HEADS = Registry('shared_head') +HEADS = Registry('head') +LOSSES = Registry('loss') +DETECTORS = Registry('detector') diff --git a/mmdet/models/roi_extractors/__init__.py b/mmdet/models/roi_extractors/__init__.py new file mode 100644 index 0000000..9161708 --- /dev/null +++ b/mmdet/models/roi_extractors/__init__.py @@ -0,0 +1,3 @@ +from .single_level import SingleRoIExtractor + +__all__ = ['SingleRoIExtractor'] diff --git a/mmdet/models/roi_extractors/single_level.py b/mmdet/models/roi_extractors/single_level.py new file mode 100644 index 0000000..6620d1d --- /dev/null +++ b/mmdet/models/roi_extractors/single_level.py @@ -0,0 +1,107 @@ +from __future__ import division + +import torch +import torch.nn as nn + +from mmdet import ops +from mmdet.core import force_fp32 +from ..registry import ROI_EXTRACTORS + + +@ROI_EXTRACTORS.register_module +class SingleRoIExtractor(nn.Module): + """Extract RoI features from a single level feature map. + + If there are mulitple input feature levels, each RoI is mapped to a level + according to its scale. + + Args: + roi_layer (dict): Specify RoI layer type and arguments. + out_channels (int): Output channels of RoI layers. + featmap_strides (int): Strides of input feature maps. + finest_scale (int): Scale threshold of mapping to level 0. + """ + + def __init__(self, + roi_layer, + out_channels, + featmap_strides, + finest_scale=56): + super(SingleRoIExtractor, self).__init__() + self.roi_layers = self.build_roi_layers(roi_layer, featmap_strides) + self.out_channels = out_channels + self.featmap_strides = featmap_strides + self.finest_scale = finest_scale + self.fp16_enabled = False + + @property + def num_inputs(self): + """int: Input feature map levels.""" + return len(self.featmap_strides) + + def init_weights(self): + pass + + def build_roi_layers(self, layer_cfg, featmap_strides): + cfg = layer_cfg.copy() + layer_type = cfg.pop('type') + assert hasattr(ops, layer_type) + layer_cls = getattr(ops, layer_type) + roi_layers = nn.ModuleList( + [layer_cls(spatial_scale=1 / s, **cfg) for s in featmap_strides]) + return roi_layers + + def map_roi_levels(self, rois, num_levels): + """Map rois to corresponding feature levels by scales. + + - scale < finest_scale * 2: level 0 + - finest_scale * 2 <= scale < finest_scale * 4: level 1 + - finest_scale * 4 <= scale < finest_scale * 8: level 2 + - scale >= finest_scale * 8: level 3 + + Args: + rois (Tensor): Input RoIs, shape (k, 5). + num_levels (int): Total level number. + + Returns: + Tensor: Level index (0-based) of each RoI, shape (k, ) + """ + scale = torch.sqrt( + (rois[:, 3] - rois[:, 1] + 1) * (rois[:, 4] - rois[:, 2] + 1)) + target_lvls = torch.floor(torch.log2(scale / self.finest_scale + 1e-6)) + target_lvls = target_lvls.clamp(min=0, max=num_levels - 1).long() + return target_lvls + + def roi_rescale(self, rois, scale_factor): + cx = (rois[:, 1] + rois[:, 3]) * 0.5 + cy = (rois[:, 2] + rois[:, 4]) * 0.5 + w = rois[:, 3] - rois[:, 1] + 1 + h = rois[:, 4] - rois[:, 2] + 1 + new_w = w * scale_factor + new_h = h * scale_factor + x1 = cx - new_w * 0.5 + 0.5 + x2 = cx + new_w * 0.5 - 0.5 + y1 = cy - new_h * 0.5 + 0.5 + y2 = cy + new_h * 0.5 - 0.5 + new_rois = torch.stack((rois[:, 0], x1, y1, x2, y2), dim=-1) + return new_rois + + @force_fp32(apply_to=('feats', ), out_fp16=True) + def forward(self, feats, rois, roi_scale_factor=None): + if len(feats) == 1: + return self.roi_layers[0](feats[0], rois) + + out_size = self.roi_layers[0].out_size + num_levels = len(feats) + target_lvls = self.map_roi_levels(rois, num_levels) + roi_feats = feats[0].new_zeros( + rois.size(0), self.out_channels, *out_size) + if roi_scale_factor is not None: + rois = self.roi_rescale(rois, roi_scale_factor) + for i in range(num_levels): + inds = target_lvls == i + if inds.any(): + rois_ = rois[inds, :] + roi_feats_t = self.roi_layers[i](feats[i], rois_) + roi_feats[inds] = roi_feats_t + return roi_feats diff --git a/mmdet/models/shared_heads/__init__.py b/mmdet/models/shared_heads/__init__.py new file mode 100644 index 0000000..bbe7014 --- /dev/null +++ b/mmdet/models/shared_heads/__init__.py @@ -0,0 +1,3 @@ +from .res_layer import ResLayer + +__all__ = ['ResLayer'] diff --git a/mmdet/models/shared_heads/res_layer.py b/mmdet/models/shared_heads/res_layer.py new file mode 100644 index 0000000..cbc77ac --- /dev/null +++ b/mmdet/models/shared_heads/res_layer.py @@ -0,0 +1,72 @@ +import logging + +import torch.nn as nn +from mmcv.cnn import constant_init, kaiming_init +from mmcv.runner import load_checkpoint + +from mmdet.core import auto_fp16 +from ..backbones import ResNet, make_res_layer +from ..registry import SHARED_HEADS + + +@SHARED_HEADS.register_module +class ResLayer(nn.Module): + + def __init__(self, + depth, + stage=3, + stride=2, + dilation=1, + style='pytorch', + norm_cfg=dict(type='BN', requires_grad=True), + norm_eval=True, + with_cp=False, + dcn=None): + super(ResLayer, self).__init__() + self.norm_eval = norm_eval + self.norm_cfg = norm_cfg + self.stage = stage + self.fp16_enabled = False + block, stage_blocks = ResNet.arch_settings[depth] + stage_block = stage_blocks[stage] + planes = 64 * 2**stage + inplanes = 64 * 2**(stage - 1) * block.expansion + + res_layer = make_res_layer( + block, + inplanes, + planes, + stage_block, + stride=stride, + dilation=dilation, + style=style, + with_cp=with_cp, + norm_cfg=self.norm_cfg, + dcn=dcn) + self.add_module('layer{}'.format(stage + 1), res_layer) + + def init_weights(self, pretrained=None): + if isinstance(pretrained, str): + logger = logging.getLogger() + load_checkpoint(self, pretrained, strict=False, logger=logger) + elif pretrained is None: + for m in self.modules(): + if isinstance(m, nn.Conv2d): + kaiming_init(m) + elif isinstance(m, nn.BatchNorm2d): + constant_init(m, 1) + else: + raise TypeError('pretrained must be a str or None') + + @auto_fp16() + def forward(self, x): + res_layer = getattr(self, 'layer{}'.format(self.stage + 1)) + out = res_layer(x) + return out + + def train(self, mode=True): + super(ResLayer, self).train(mode) + if self.norm_eval: + for m in self.modules(): + if isinstance(m, nn.BatchNorm2d): + m.eval() diff --git a/mmdet/models/utils/__init__.py b/mmdet/models/utils/__init__.py new file mode 100644 index 0000000..3db4092 --- /dev/null +++ b/mmdet/models/utils/__init__.py @@ -0,0 +1,12 @@ +from .conv_module import ConvModule, build_conv_layer +from .conv_ws import ConvWS2d, conv_ws_2d +from .norm import build_norm_layer +from .scale import Scale +from .weight_init import (bias_init_with_prob, kaiming_init, normal_init, + uniform_init, xavier_init) + +__all__ = [ + 'conv_ws_2d', 'ConvWS2d', 'build_conv_layer', 'ConvModule', + 'build_norm_layer', 'xavier_init', 'normal_init', 'uniform_init', + 'kaiming_init', 'bias_init_with_prob', 'Scale' +] diff --git a/mmdet/models/utils/conv_module.py b/mmdet/models/utils/conv_module.py new file mode 100644 index 0000000..f2bddc4 --- /dev/null +++ b/mmdet/models/utils/conv_module.py @@ -0,0 +1,164 @@ +import warnings + +import torch.nn as nn +from mmcv.cnn import constant_init, kaiming_init + +from .conv_ws import ConvWS2d +from .norm import build_norm_layer + +conv_cfg = { + 'Conv': nn.Conv2d, + 'ConvWS': ConvWS2d, + # TODO: octave conv +} + + +def build_conv_layer(cfg, *args, **kwargs): + """ Build convolution layer + + Args: + cfg (None or dict): cfg should contain: + type (str): identify conv layer type. + layer args: args needed to instantiate a conv layer. + + Returns: + layer (nn.Module): created conv layer + """ + if cfg is None: + cfg_ = dict(type='Conv') + else: + assert isinstance(cfg, dict) and 'type' in cfg + cfg_ = cfg.copy() + + layer_type = cfg_.pop('type') + if layer_type not in conv_cfg: + raise KeyError('Unrecognized norm type {}'.format(layer_type)) + else: + conv_layer = conv_cfg[layer_type] + + layer = conv_layer(*args, **kwargs, **cfg_) + + return layer + + +class ConvModule(nn.Module): + """A conv block that contains conv/norm/activation layers. + + Args: + in_channels (int): Same as nn.Conv2d. + out_channels (int): Same as nn.Conv2d. + kernel_size (int or tuple[int]): Same as nn.Conv2d. + stride (int or tuple[int]): Same as nn.Conv2d. + padding (int or tuple[int]): Same as nn.Conv2d. + dilation (int or tuple[int]): Same as nn.Conv2d. + groups (int): Same as nn.Conv2d. + bias (bool or str): If specified as `auto`, it will be decided by the + norm_cfg. Bias will be set as True if norm_cfg is None, otherwise + False. + conv_cfg (dict): Config dict for convolution layer. + norm_cfg (dict): Config dict for normalization layer. + activation (str or None): Activation type, "ReLU" by default. + inplace (bool): Whether to use inplace mode for activation. + order (tuple[str]): The order of conv/norm/activation layers. It is a + sequence of "conv", "norm" and "act". Examples are + ("conv", "norm", "act") and ("act", "conv", "norm"). + """ + + def __init__(self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + bias='auto', + conv_cfg=None, + norm_cfg=None, + activation='relu', + inplace=True, + order=('conv', 'norm', 'act')): + super(ConvModule, self).__init__() + assert conv_cfg is None or isinstance(conv_cfg, dict) + assert norm_cfg is None or isinstance(norm_cfg, dict) + self.conv_cfg = conv_cfg + self.norm_cfg = norm_cfg + self.activation = activation + self.inplace = inplace + self.order = order + assert isinstance(self.order, tuple) and len(self.order) == 3 + assert set(order) == set(['conv', 'norm', 'act']) + + self.with_norm = norm_cfg is not None + self.with_activatation = activation is not None + # if the conv layer is before a norm layer, bias is unnecessary. + if bias == 'auto': + bias = False if self.with_norm else True + self.with_bias = bias + + if self.with_norm and self.with_bias: + warnings.warn('ConvModule has norm and bias at the same time') + + # build convolution layer + self.conv = build_conv_layer( + conv_cfg, + in_channels, + out_channels, + kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + groups=groups, + bias=bias) + # export the attributes of self.conv to a higher level for convenience + self.in_channels = self.conv.in_channels + self.out_channels = self.conv.out_channels + self.kernel_size = self.conv.kernel_size + self.stride = self.conv.stride + self.padding = self.conv.padding + self.dilation = self.conv.dilation + self.transposed = self.conv.transposed + self.output_padding = self.conv.output_padding + self.groups = self.conv.groups + + # build normalization layers + if self.with_norm: + # norm layer is after conv layer + if order.index('norm') > order.index('conv'): + norm_channels = out_channels + else: + norm_channels = in_channels + self.norm_name, norm = build_norm_layer(norm_cfg, norm_channels) + self.add_module(self.norm_name, norm) + + # build activation layer + if self.with_activatation: + # TODO: introduce `act_cfg` and supports more activation layers + if self.activation not in ['relu']: + raise ValueError('{} is currently not supported.'.format( + self.activation)) + if self.activation == 'relu': + self.activate = nn.ReLU(inplace=inplace) + + # Use msra init by default + self.init_weights() + + @property + def norm(self): + return getattr(self, self.norm_name) + + def init_weights(self): + nonlinearity = 'relu' if self.activation is None else self.activation + kaiming_init(self.conv, nonlinearity=nonlinearity) + if self.with_norm: + constant_init(self.norm, 1, bias=0) + + def forward(self, x, activate=True, norm=True): + for layer in self.order: + if layer == 'conv': + x = self.conv(x) + elif layer == 'norm' and norm and self.with_norm: + x = self.norm(x) + elif layer == 'act' and activate and self.with_activatation: + x = self.activate(x) + return x diff --git a/mmdet/models/utils/conv_ws.py b/mmdet/models/utils/conv_ws.py new file mode 100644 index 0000000..5ccd735 --- /dev/null +++ b/mmdet/models/utils/conv_ws.py @@ -0,0 +1,46 @@ +import torch.nn as nn +import torch.nn.functional as F + + +def conv_ws_2d(input, + weight, + bias=None, + stride=1, + padding=0, + dilation=1, + groups=1, + eps=1e-5): + c_in = weight.size(0) + weight_flat = weight.view(c_in, -1) + mean = weight_flat.mean(dim=1, keepdim=True).view(c_in, 1, 1, 1) + std = weight_flat.std(dim=1, keepdim=True).view(c_in, 1, 1, 1) + weight = (weight - mean) / (std + eps) + return F.conv2d(input, weight, bias, stride, padding, dilation, groups) + + +class ConvWS2d(nn.Conv2d): + + def __init__(self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + bias=True, + eps=1e-5): + super(ConvWS2d, self).__init__( + in_channels, + out_channels, + kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + groups=groups, + bias=bias) + self.eps = eps + + def forward(self, x): + return conv_ws_2d(x, self.weight, self.bias, self.stride, self.padding, + self.dilation, self.groups, self.eps) diff --git a/mmdet/models/utils/norm.py b/mmdet/models/utils/norm.py new file mode 100644 index 0000000..d5687cb --- /dev/null +++ b/mmdet/models/utils/norm.py @@ -0,0 +1,55 @@ +import torch.nn as nn + +norm_cfg = { + # format: layer_type: (abbreviation, module) + 'BN': ('bn', nn.BatchNorm2d), + 'SyncBN': ('bn', nn.SyncBatchNorm), + 'GN': ('gn', nn.GroupNorm), + # and potentially 'SN' +} + + +def build_norm_layer(cfg, num_features, postfix=''): + """ Build normalization layer + + Args: + cfg (dict): cfg should contain: + type (str): identify norm layer type. + layer args: args needed to instantiate a norm layer. + requires_grad (bool): [optional] whether stop gradient updates + num_features (int): number of channels from input. + postfix (int, str): appended into norm abbreviation to + create named layer. + + Returns: + name (str): abbreviation + postfix + layer (nn.Module): created norm layer + """ + assert isinstance(cfg, dict) and 'type' in cfg + cfg_ = cfg.copy() + + layer_type = cfg_.pop('type') + if layer_type not in norm_cfg: + raise KeyError('Unrecognized norm type {}'.format(layer_type)) + else: + abbr, norm_layer = norm_cfg[layer_type] + if norm_layer is None: + raise NotImplementedError + + assert isinstance(postfix, (int, str)) + name = abbr + str(postfix) + + requires_grad = cfg_.pop('requires_grad', True) + cfg_.setdefault('eps', 1e-5) + if layer_type != 'GN': + layer = norm_layer(num_features, **cfg_) + if layer_type == 'SyncBN': + layer._specify_ddp_gpu_num(1) + else: + assert 'num_groups' in cfg_ + layer = norm_layer(num_channels=num_features, **cfg_) + + for param in layer.parameters(): + param.requires_grad = requires_grad + + return name, layer diff --git a/mmdet/models/utils/scale.py b/mmdet/models/utils/scale.py new file mode 100644 index 0000000..68c37cd --- /dev/null +++ b/mmdet/models/utils/scale.py @@ -0,0 +1,12 @@ +import torch +import torch.nn as nn + + +class Scale(nn.Module): + + def __init__(self, scale=1.0): + super(Scale, self).__init__() + self.scale = nn.Parameter(torch.tensor(scale, dtype=torch.float)) + + def forward(self, x): + return x * self.scale diff --git a/mmdet/models/utils/weight_init.py b/mmdet/models/utils/weight_init.py new file mode 100644 index 0000000..17d4988 --- /dev/null +++ b/mmdet/models/utils/weight_init.py @@ -0,0 +1,46 @@ +import numpy as np +import torch.nn as nn + + +def xavier_init(module, gain=1, bias=0, distribution='normal'): + assert distribution in ['uniform', 'normal'] + if distribution == 'uniform': + nn.init.xavier_uniform_(module.weight, gain=gain) + else: + nn.init.xavier_normal_(module.weight, gain=gain) + if hasattr(module, 'bias'): + nn.init.constant_(module.bias, bias) + + +def normal_init(module, mean=0, std=1, bias=0): + nn.init.normal_(module.weight, mean, std) + if hasattr(module, 'bias'): + nn.init.constant_(module.bias, bias) + + +def uniform_init(module, a=0, b=1, bias=0): + nn.init.uniform_(module.weight, a, b) + if hasattr(module, 'bias'): + nn.init.constant_(module.bias, bias) + + +def kaiming_init(module, + mode='fan_out', + nonlinearity='relu', + bias=0, + distribution='normal'): + assert distribution in ['uniform', 'normal'] + if distribution == 'uniform': + nn.init.kaiming_uniform_( + module.weight, mode=mode, nonlinearity=nonlinearity) + else: + nn.init.kaiming_normal_( + module.weight, mode=mode, nonlinearity=nonlinearity) + if hasattr(module, 'bias'): + nn.init.constant_(module.bias, bias) + + +def bias_init_with_prob(prior_prob): + """ initialize conv/fc bias value according to giving probablity""" + bias_init = float(-np.log((1 - prior_prob) / prior_prob)) + return bias_init diff --git a/mmdet/ops/__init__.py b/mmdet/ops/__init__.py new file mode 100644 index 0000000..4317899 --- /dev/null +++ b/mmdet/ops/__init__.py @@ -0,0 +1,19 @@ +from .context_block import ContextBlock +from .dcn import (DeformConv, DeformConvPack, DeformRoIPooling, + DeformRoIPoolingPack, ModulatedDeformConv, + ModulatedDeformConvPack, ModulatedDeformRoIPoolingPack, + deform_conv, deform_roi_pooling, modulated_deform_conv) +from .masked_conv import MaskedConv2d +from .nms import nms, soft_nms +from .roi_align import RoIAlign, roi_align +from .roi_pool import RoIPool, roi_pool +from .sigmoid_focal_loss import SigmoidFocalLoss, sigmoid_focal_loss + +__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' +] diff --git a/mmdet/ops/context_block.py b/mmdet/ops/context_block.py new file mode 100644 index 0000000..be9092c --- /dev/null +++ b/mmdet/ops/context_block.py @@ -0,0 +1,104 @@ +import torch +from mmcv.cnn import constant_init, kaiming_init +from torch import nn + + +def last_zero_init(m): + if isinstance(m, nn.Sequential): + constant_init(m[-1], val=0) + else: + constant_init(m, val=0) + + +class ContextBlock(nn.Module): + + def __init__(self, + inplanes, + ratio, + pooling_type='att', + fusion_types=('channel_add', )): + super(ContextBlock, self).__init__() + assert pooling_type in ['avg', 'att'] + assert isinstance(fusion_types, (list, tuple)) + valid_fusion_types = ['channel_add', 'channel_mul'] + assert all([f in valid_fusion_types for f in fusion_types]) + assert len(fusion_types) > 0, 'at least one fusion should be used' + self.inplanes = inplanes + self.ratio = ratio + self.planes = int(inplanes * ratio) + self.pooling_type = pooling_type + self.fusion_types = fusion_types + if pooling_type == 'att': + self.conv_mask = nn.Conv2d(inplanes, 1, kernel_size=1) + self.softmax = nn.Softmax(dim=2) + else: + self.avg_pool = nn.AdaptiveAvgPool2d(1) + if 'channel_add' in fusion_types: + self.channel_add_conv = nn.Sequential( + nn.Conv2d(self.inplanes, self.planes, kernel_size=1), + nn.LayerNorm([self.planes, 1, 1]), + nn.ReLU(inplace=True), # yapf: disable + nn.Conv2d(self.planes, self.inplanes, kernel_size=1)) + else: + self.channel_add_conv = None + if 'channel_mul' in fusion_types: + self.channel_mul_conv = nn.Sequential( + nn.Conv2d(self.inplanes, self.planes, kernel_size=1), + nn.LayerNorm([self.planes, 1, 1]), + nn.ReLU(inplace=True), # yapf: disable + nn.Conv2d(self.planes, self.inplanes, kernel_size=1)) + else: + self.channel_mul_conv = None + self.reset_parameters() + + def reset_parameters(self): + if self.pooling_type == 'att': + kaiming_init(self.conv_mask, mode='fan_in') + self.conv_mask.inited = True + + if self.channel_add_conv is not None: + last_zero_init(self.channel_add_conv) + if self.channel_mul_conv is not None: + last_zero_init(self.channel_mul_conv) + + def spatial_pool(self, x): + batch, channel, height, width = x.size() + if self.pooling_type == 'att': + input_x = x + # [N, C, H * W] + input_x = input_x.view(batch, channel, height * width) + # [N, 1, C, H * W] + input_x = input_x.unsqueeze(1) + # [N, 1, H, W] + context_mask = self.conv_mask(x) + # [N, 1, H * W] + context_mask = context_mask.view(batch, 1, height * width) + # [N, 1, H * W] + context_mask = self.softmax(context_mask) + # [N, 1, H * W, 1] + context_mask = context_mask.unsqueeze(-1) + # [N, 1, C, 1] + context = torch.matmul(input_x, context_mask) + # [N, C, 1, 1] + context = context.view(batch, channel, 1, 1) + else: + # [N, C, 1, 1] + context = self.avg_pool(x) + + return context + + def forward(self, x): + # [N, C, 1, 1] + context = self.spatial_pool(x) + + out = x + if self.channel_mul_conv is not None: + # [N, C, 1, 1] + channel_mul_term = torch.sigmoid(self.channel_mul_conv(context)) + out = out * channel_mul_term + if self.channel_add_conv is not None: + # [N, C, 1, 1] + channel_add_term = self.channel_add_conv(context) + out = out + channel_add_term + + return out diff --git a/mmdet/ops/dcn/__init__.py b/mmdet/ops/dcn/__init__.py new file mode 100644 index 0000000..79594c9 --- /dev/null +++ b/mmdet/ops/dcn/__init__.py @@ -0,0 +1,12 @@ +from .deform_conv import (DeformConv, DeformConvPack, ModulatedDeformConv, + ModulatedDeformConvPack, deform_conv, + modulated_deform_conv) +from .deform_pool import (DeformRoIPooling, DeformRoIPoolingPack, + ModulatedDeformRoIPoolingPack, deform_roi_pooling) + +__all__ = [ + 'DeformConv', 'DeformConvPack', 'ModulatedDeformConv', + 'ModulatedDeformConvPack', 'DeformRoIPooling', 'DeformRoIPoolingPack', + 'ModulatedDeformRoIPoolingPack', 'deform_conv', 'modulated_deform_conv', + 'deform_roi_pooling' +] diff --git a/mmdet/ops/dcn/deform_conv.py b/mmdet/ops/dcn/deform_conv.py new file mode 100644 index 0000000..7f6841a --- /dev/null +++ b/mmdet/ops/dcn/deform_conv.py @@ -0,0 +1,337 @@ +import math + +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.modules.utils import _pair + +from . import deform_conv_cuda + + +class DeformConvFunction(Function): + + @staticmethod + def forward(ctx, + input, + offset, + weight, + stride=1, + padding=0, + dilation=1, + groups=1, + deformable_groups=1, + im2col_step=64): + if input is not None and input.dim() != 4: + raise ValueError( + "Expected 4D tensor as input, got {}D tensor instead.".format( + input.dim())) + ctx.stride = _pair(stride) + ctx.padding = _pair(padding) + ctx.dilation = _pair(dilation) + ctx.groups = groups + ctx.deformable_groups = deformable_groups + ctx.im2col_step = im2col_step + + ctx.save_for_backward(input, offset, weight) + + output = input.new_empty( + DeformConvFunction._output_size(input, weight, ctx.padding, + ctx.dilation, ctx.stride)) + + ctx.bufs_ = [input.new_empty(0), input.new_empty(0)] # columns, ones + + if not input.is_cuda: + raise NotImplementedError + else: + cur_im2col_step = min(ctx.im2col_step, input.shape[0]) + assert (input.shape[0] % + cur_im2col_step) == 0, 'im2col step must divide batchsize' + deform_conv_cuda.deform_conv_forward_cuda( + input, weight, offset, output, ctx.bufs_[0], ctx.bufs_[1], + weight.size(3), weight.size(2), ctx.stride[1], ctx.stride[0], + ctx.padding[1], ctx.padding[0], ctx.dilation[1], + ctx.dilation[0], ctx.groups, ctx.deformable_groups, + cur_im2col_step) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + input, offset, weight = ctx.saved_tensors + + grad_input = grad_offset = grad_weight = None + + if not grad_output.is_cuda: + raise NotImplementedError + else: + cur_im2col_step = min(ctx.im2col_step, input.shape[0]) + assert (input.shape[0] % + cur_im2col_step) == 0, 'im2col step must divide batchsize' + + if ctx.needs_input_grad[0] or ctx.needs_input_grad[1]: + grad_input = torch.zeros_like(input) + grad_offset = torch.zeros_like(offset) + deform_conv_cuda.deform_conv_backward_input_cuda( + input, offset, grad_output, grad_input, + grad_offset, weight, ctx.bufs_[0], weight.size(3), + weight.size(2), ctx.stride[1], ctx.stride[0], + ctx.padding[1], ctx.padding[0], ctx.dilation[1], + ctx.dilation[0], ctx.groups, ctx.deformable_groups, + cur_im2col_step) + + if ctx.needs_input_grad[2]: + grad_weight = torch.zeros_like(weight) + deform_conv_cuda.deform_conv_backward_parameters_cuda( + input, offset, grad_output, + grad_weight, ctx.bufs_[0], ctx.bufs_[1], weight.size(3), + weight.size(2), ctx.stride[1], ctx.stride[0], + ctx.padding[1], ctx.padding[0], ctx.dilation[1], + ctx.dilation[0], ctx.groups, ctx.deformable_groups, 1, + cur_im2col_step) + + return (grad_input, grad_offset, grad_weight, None, None, None, None, + None) + + @staticmethod + def _output_size(input, weight, padding, dilation, stride): + channels = weight.size(0) + output_size = (input.size(0), channels) + for d in range(input.dim() - 2): + in_size = input.size(d + 2) + pad = padding[d] + kernel = dilation[d] * (weight.size(d + 2) - 1) + 1 + stride_ = stride[d] + output_size += ((in_size + (2 * pad) - kernel) // stride_ + 1, ) + if not all(map(lambda s: s > 0, output_size)): + raise ValueError( + "convolution input is too small (output would be {})".format( + 'x'.join(map(str, output_size)))) + return output_size + + +class ModulatedDeformConvFunction(Function): + + @staticmethod + def forward(ctx, + input, + offset, + mask, + weight, + bias=None, + stride=1, + padding=0, + dilation=1, + groups=1, + deformable_groups=1): + ctx.stride = stride + ctx.padding = padding + ctx.dilation = dilation + ctx.groups = groups + ctx.deformable_groups = deformable_groups + ctx.with_bias = bias is not None + if not ctx.with_bias: + bias = input.new_empty(1) # fake tensor + if not input.is_cuda: + raise NotImplementedError + if weight.requires_grad or mask.requires_grad or offset.requires_grad \ + or input.requires_grad: + ctx.save_for_backward(input, offset, mask, weight, bias) + output = input.new_empty( + ModulatedDeformConvFunction._infer_shape(ctx, input, weight)) + ctx._bufs = [input.new_empty(0), input.new_empty(0)] + deform_conv_cuda.modulated_deform_conv_cuda_forward( + input, weight, bias, ctx._bufs[0], offset, mask, output, + ctx._bufs[1], weight.shape[2], weight.shape[3], ctx.stride, + ctx.stride, ctx.padding, ctx.padding, ctx.dilation, ctx.dilation, + ctx.groups, ctx.deformable_groups, ctx.with_bias) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + if not grad_output.is_cuda: + raise NotImplementedError + input, offset, mask, weight, bias = ctx.saved_tensors + grad_input = torch.zeros_like(input) + grad_offset = torch.zeros_like(offset) + grad_mask = torch.zeros_like(mask) + grad_weight = torch.zeros_like(weight) + grad_bias = torch.zeros_like(bias) + deform_conv_cuda.modulated_deform_conv_cuda_backward( + input, weight, bias, ctx._bufs[0], offset, mask, ctx._bufs[1], + grad_input, grad_weight, grad_bias, grad_offset, grad_mask, + grad_output, weight.shape[2], weight.shape[3], ctx.stride, + ctx.stride, ctx.padding, ctx.padding, ctx.dilation, ctx.dilation, + ctx.groups, ctx.deformable_groups, ctx.with_bias) + if not ctx.with_bias: + grad_bias = None + + return (grad_input, grad_offset, grad_mask, grad_weight, grad_bias, + None, None, None, None, None) + + @staticmethod + def _infer_shape(ctx, input, weight): + n = input.size(0) + channels_out = weight.size(0) + height, width = input.shape[2:4] + kernel_h, kernel_w = weight.shape[2:4] + height_out = (height + 2 * ctx.padding - + (ctx.dilation * (kernel_h - 1) + 1)) // ctx.stride + 1 + width_out = (width + 2 * ctx.padding - + (ctx.dilation * (kernel_w - 1) + 1)) // ctx.stride + 1 + return n, channels_out, height_out, width_out + + +deform_conv = DeformConvFunction.apply +modulated_deform_conv = ModulatedDeformConvFunction.apply + + +class DeformConv(nn.Module): + + def __init__(self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + deformable_groups=1, + bias=False): + super(DeformConv, self).__init__() + + assert not bias + assert in_channels % groups == 0, \ + 'in_channels {} cannot be divisible by groups {}'.format( + in_channels, groups) + assert out_channels % groups == 0, \ + 'out_channels {} cannot be divisible by groups {}'.format( + out_channels, groups) + + self.in_channels = in_channels + self.out_channels = out_channels + self.kernel_size = _pair(kernel_size) + self.stride = _pair(stride) + self.padding = _pair(padding) + self.dilation = _pair(dilation) + self.groups = groups + self.deformable_groups = deformable_groups + + self.weight = nn.Parameter( + torch.Tensor(out_channels, in_channels // self.groups, + *self.kernel_size)) + + self.reset_parameters() + + def reset_parameters(self): + n = self.in_channels + for k in self.kernel_size: + n *= k + stdv = 1. / math.sqrt(n) + self.weight.data.uniform_(-stdv, stdv) + + def forward(self, x, offset): + return deform_conv(x, offset, self.weight, self.stride, self.padding, + self.dilation, self.groups, self.deformable_groups) + + +class DeformConvPack(DeformConv): + + def __init__(self, *args, **kwargs): + super(DeformConvPack, self).__init__(*args, **kwargs) + + self.conv_offset = nn.Conv2d( + self.in_channels, + self.deformable_groups * 2 * self.kernel_size[0] * + self.kernel_size[1], + kernel_size=self.kernel_size, + stride=_pair(self.stride), + padding=_pair(self.padding), + bias=True) + self.init_offset() + + def init_offset(self): + self.conv_offset.weight.data.zero_() + self.conv_offset.bias.data.zero_() + + def forward(self, x): + offset = self.conv_offset(x) + return deform_conv(x, offset, self.weight, self.stride, self.padding, + self.dilation, self.groups, self.deformable_groups) + + +class ModulatedDeformConv(nn.Module): + + def __init__(self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + deformable_groups=1, + bias=True): + super(ModulatedDeformConv, self).__init__() + self.in_channels = in_channels + self.out_channels = out_channels + self.kernel_size = _pair(kernel_size) + self.stride = stride + self.padding = padding + self.dilation = dilation + self.groups = groups + self.deformable_groups = deformable_groups + self.with_bias = bias + + self.weight = nn.Parameter( + torch.Tensor(out_channels, in_channels // groups, + *self.kernel_size)) + if bias: + self.bias = nn.Parameter(torch.Tensor(out_channels)) + else: + self.register_parameter('bias', None) + self.reset_parameters() + + def reset_parameters(self): + n = self.in_channels + for k in self.kernel_size: + n *= k + stdv = 1. / math.sqrt(n) + self.weight.data.uniform_(-stdv, stdv) + if self.bias is not None: + self.bias.data.zero_() + + def forward(self, x, offset, mask): + return modulated_deform_conv(x, offset, mask, self.weight, self.bias, + self.stride, self.padding, self.dilation, + self.groups, self.deformable_groups) + + +class ModulatedDeformConvPack(ModulatedDeformConv): + + def __init__(self, *args, **kwargs): + super(ModulatedDeformConvPack, self).__init__(*args, **kwargs) + + self.conv_offset_mask = nn.Conv2d( + self.in_channels, + self.deformable_groups * 3 * self.kernel_size[0] * + self.kernel_size[1], + kernel_size=self.kernel_size, + stride=_pair(self.stride), + padding=_pair(self.padding), + bias=True) + self.init_offset() + + def init_offset(self): + self.conv_offset_mask.weight.data.zero_() + self.conv_offset_mask.bias.data.zero_() + + def forward(self, x): + out = self.conv_offset_mask(x) + o1, o2, mask = torch.chunk(out, 3, dim=1) + offset = torch.cat((o1, o2), dim=1) + mask = torch.sigmoid(mask) + return modulated_deform_conv(x, offset, mask, self.weight, self.bias, + self.stride, self.padding, self.dilation, + self.groups, self.deformable_groups) diff --git a/mmdet/ops/dcn/deform_pool.py b/mmdet/ops/dcn/deform_pool.py new file mode 100644 index 0000000..2d09dec --- /dev/null +++ b/mmdet/ops/dcn/deform_pool.py @@ -0,0 +1,245 @@ +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable + +from . import deform_pool_cuda + + +class DeformRoIPoolingFunction(Function): + + @staticmethod + def forward(ctx, + data, + rois, + offset, + spatial_scale, + out_size, + out_channels, + no_trans, + group_size=1, + part_size=None, + sample_per_part=4, + trans_std=.0): + ctx.spatial_scale = spatial_scale + ctx.out_size = out_size + ctx.out_channels = out_channels + ctx.no_trans = no_trans + ctx.group_size = group_size + ctx.part_size = out_size if part_size is None else part_size + ctx.sample_per_part = sample_per_part + ctx.trans_std = trans_std + + assert 0.0 <= ctx.trans_std <= 1.0 + if not data.is_cuda: + raise NotImplementedError + + n = rois.shape[0] + output = data.new_empty(n, out_channels, out_size, out_size) + output_count = data.new_empty(n, out_channels, out_size, out_size) + deform_pool_cuda.deform_psroi_pooling_cuda_forward( + data, rois, offset, output, output_count, ctx.no_trans, + ctx.spatial_scale, ctx.out_channels, ctx.group_size, ctx.out_size, + ctx.part_size, ctx.sample_per_part, ctx.trans_std) + + if data.requires_grad or rois.requires_grad or offset.requires_grad: + ctx.save_for_backward(data, rois, offset) + ctx.output_count = output_count + + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + if not grad_output.is_cuda: + raise NotImplementedError + + data, rois, offset = ctx.saved_tensors + output_count = ctx.output_count + grad_input = torch.zeros_like(data) + grad_rois = None + grad_offset = torch.zeros_like(offset) + + deform_pool_cuda.deform_psroi_pooling_cuda_backward( + grad_output, data, rois, offset, output_count, grad_input, + grad_offset, ctx.no_trans, ctx.spatial_scale, ctx.out_channels, + ctx.group_size, ctx.out_size, ctx.part_size, ctx.sample_per_part, + ctx.trans_std) + return (grad_input, grad_rois, grad_offset, None, None, None, None, + None, None, None, None) + + +deform_roi_pooling = DeformRoIPoolingFunction.apply + + +class DeformRoIPooling(nn.Module): + + def __init__(self, + spatial_scale, + out_size, + out_channels, + no_trans, + group_size=1, + part_size=None, + sample_per_part=4, + trans_std=.0): + super(DeformRoIPooling, self).__init__() + self.spatial_scale = spatial_scale + self.out_size = out_size + self.out_channels = out_channels + self.no_trans = no_trans + self.group_size = group_size + self.part_size = out_size if part_size is None else part_size + self.sample_per_part = sample_per_part + self.trans_std = trans_std + + def forward(self, data, rois, offset): + if self.no_trans: + offset = data.new_empty(0) + return deform_roi_pooling(data, rois, offset, self.spatial_scale, + self.out_size, self.out_channels, + self.no_trans, self.group_size, + self.part_size, self.sample_per_part, + self.trans_std) + + +class DeformRoIPoolingPack(DeformRoIPooling): + + def __init__(self, + spatial_scale, + out_size, + out_channels, + no_trans, + group_size=1, + part_size=None, + sample_per_part=4, + trans_std=.0, + num_offset_fcs=3, + deform_fc_channels=1024): + super(DeformRoIPoolingPack, + self).__init__(spatial_scale, out_size, out_channels, no_trans, + group_size, part_size, sample_per_part, trans_std) + + self.num_offset_fcs = num_offset_fcs + self.deform_fc_channels = deform_fc_channels + + if not no_trans: + seq = [] + ic = self.out_size * self.out_size * self.out_channels + for i in range(self.num_offset_fcs): + if i < self.num_offset_fcs - 1: + oc = self.deform_fc_channels + else: + oc = self.out_size * self.out_size * 2 + seq.append(nn.Linear(ic, oc)) + ic = oc + if i < self.num_offset_fcs - 1: + seq.append(nn.ReLU(inplace=True)) + self.offset_fc = nn.Sequential(*seq) + self.offset_fc[-1].weight.data.zero_() + self.offset_fc[-1].bias.data.zero_() + + def forward(self, data, rois): + assert data.size(1) == self.out_channels + if self.no_trans: + offset = data.new_empty(0) + return deform_roi_pooling(data, rois, offset, self.spatial_scale, + self.out_size, self.out_channels, + self.no_trans, self.group_size, + self.part_size, self.sample_per_part, + self.trans_std) + else: + n = rois.shape[0] + offset = data.new_empty(0) + x = deform_roi_pooling(data, rois, offset, self.spatial_scale, + self.out_size, self.out_channels, True, + self.group_size, self.part_size, + self.sample_per_part, self.trans_std) + offset = self.offset_fc(x.view(n, -1)) + offset = offset.view(n, 2, self.out_size, self.out_size) + return deform_roi_pooling(data, rois, offset, self.spatial_scale, + self.out_size, self.out_channels, + self.no_trans, self.group_size, + self.part_size, self.sample_per_part, + self.trans_std) + + +class ModulatedDeformRoIPoolingPack(DeformRoIPooling): + + def __init__(self, + spatial_scale, + out_size, + out_channels, + no_trans, + group_size=1, + part_size=None, + sample_per_part=4, + trans_std=.0, + num_offset_fcs=3, + num_mask_fcs=2, + deform_fc_channels=1024): + super(ModulatedDeformRoIPoolingPack, + self).__init__(spatial_scale, out_size, out_channels, no_trans, + group_size, part_size, sample_per_part, trans_std) + + self.num_offset_fcs = num_offset_fcs + self.num_mask_fcs = num_mask_fcs + self.deform_fc_channels = deform_fc_channels + + if not no_trans: + offset_fc_seq = [] + ic = self.out_size * self.out_size * self.out_channels + for i in range(self.num_offset_fcs): + if i < self.num_offset_fcs - 1: + oc = self.deform_fc_channels + else: + oc = self.out_size * self.out_size * 2 + offset_fc_seq.append(nn.Linear(ic, oc)) + ic = oc + if i < self.num_offset_fcs - 1: + offset_fc_seq.append(nn.ReLU(inplace=True)) + self.offset_fc = nn.Sequential(*offset_fc_seq) + self.offset_fc[-1].weight.data.zero_() + self.offset_fc[-1].bias.data.zero_() + + mask_fc_seq = [] + ic = self.out_size * self.out_size * self.out_channels + for i in range(self.num_mask_fcs): + if i < self.num_mask_fcs - 1: + oc = self.deform_fc_channels + else: + oc = self.out_size * self.out_size + mask_fc_seq.append(nn.Linear(ic, oc)) + ic = oc + if i < self.num_mask_fcs - 1: + mask_fc_seq.append(nn.ReLU(inplace=True)) + else: + mask_fc_seq.append(nn.Sigmoid()) + self.mask_fc = nn.Sequential(*mask_fc_seq) + self.mask_fc[-2].weight.data.zero_() + self.mask_fc[-2].bias.data.zero_() + + def forward(self, data, rois): + assert data.size(1) == self.out_channels + if self.no_trans: + offset = data.new_empty(0) + return deform_roi_pooling(data, rois, offset, self.spatial_scale, + self.out_size, self.out_channels, + self.no_trans, self.group_size, + self.part_size, self.sample_per_part, + self.trans_std) + else: + n = rois.shape[0] + offset = data.new_empty(0) + x = deform_roi_pooling(data, rois, offset, self.spatial_scale, + self.out_size, self.out_channels, True, + self.group_size, self.part_size, + self.sample_per_part, self.trans_std) + offset = self.offset_fc(x.view(n, -1)) + offset = offset.view(n, 2, self.out_size, self.out_size) + mask = self.mask_fc(x.view(n, -1)) + mask = mask.view(n, 1, self.out_size, self.out_size) + return deform_roi_pooling( + data, rois, offset, self.spatial_scale, self.out_size, + self.out_channels, self.no_trans, self.group_size, + self.part_size, self.sample_per_part, self.trans_std) * mask diff --git a/mmdet/ops/dcn/src/deform_conv_cuda.cpp b/mmdet/ops/dcn/src/deform_conv_cuda.cpp new file mode 100644 index 0000000..dd76bab --- /dev/null +++ b/mmdet/ops/dcn/src/deform_conv_cuda.cpp @@ -0,0 +1,695 @@ +// modify from +// https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/deform_conv_cuda.c + +#include + +#include +#include + +void deformable_im2col(const at::Tensor data_im, const at::Tensor data_offset, + const int channels, const int height, const int width, + const int ksize_h, const int ksize_w, const int pad_h, + const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int parallel_imgs, const int deformable_group, + at::Tensor data_col); + +void deformable_col2im(const at::Tensor data_col, const at::Tensor data_offset, + const int channels, const int height, const int width, + const int ksize_h, const int ksize_w, const int pad_h, + const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int parallel_imgs, const int deformable_group, + at::Tensor grad_im); + +void deformable_col2im_coord( + const at::Tensor data_col, const at::Tensor data_im, + const at::Tensor data_offset, const int channels, const int height, + const int width, const int ksize_h, const int ksize_w, const int pad_h, + const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, const int parallel_imgs, + const int deformable_group, at::Tensor grad_offset); + +void modulated_deformable_im2col_cuda( + const at::Tensor data_im, const at::Tensor data_offset, + const at::Tensor data_mask, const int batch_size, const int channels, + const int height_im, const int width_im, const int height_col, + const int width_col, const int kernel_h, const int kenerl_w, + const int pad_h, const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, const int deformable_group, + at::Tensor data_col); + +void modulated_deformable_col2im_cuda( + const at::Tensor data_col, const at::Tensor data_offset, + const at::Tensor data_mask, const int batch_size, const int channels, + const int height_im, const int width_im, const int height_col, + const int width_col, const int kernel_h, const int kenerl_w, + const int pad_h, const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, const int deformable_group, + at::Tensor grad_im); + +void modulated_deformable_col2im_coord_cuda( + const at::Tensor data_col, const at::Tensor data_im, + const at::Tensor data_offset, const at::Tensor data_mask, + const int batch_size, const int channels, const int height_im, + const int width_im, const int height_col, const int width_col, + const int kernel_h, const int kenerl_w, const int pad_h, const int pad_w, + const int stride_h, const int stride_w, const int dilation_h, + const int dilation_w, const int deformable_group, at::Tensor grad_offset, + at::Tensor grad_mask); + +void shape_check(at::Tensor input, at::Tensor offset, at::Tensor *gradOutput, + at::Tensor weight, int kH, int kW, int dH, int dW, int padH, + int padW, int dilationH, int dilationW, int group, + int deformable_group) { + AT_CHECK(weight.ndimension() == 4, + "4D weight tensor (nOutputPlane,nInputPlane,kH,kW) expected, " + "but got: %s", + weight.ndimension()); + + AT_CHECK(weight.is_contiguous(), "weight tensor has to be contiguous"); + + AT_CHECK(kW > 0 && kH > 0, + "kernel size should be greater than zero, but got kH: %d kW: %d", kH, + kW); + + AT_CHECK((weight.size(2) == kH && weight.size(3) == kW), + "kernel size should be consistent with weight, ", + "but got kH: %d kW: %d weight.size(2): %d, weight.size(3): %d", kH, + kW, weight.size(2), weight.size(3)); + + AT_CHECK(dW > 0 && dH > 0, + "stride should be greater than zero, but got dH: %d dW: %d", dH, dW); + + AT_CHECK( + dilationW > 0 && dilationH > 0, + "dilation should be greater than 0, but got dilationH: %d dilationW: %d", + dilationH, dilationW); + + int ndim = input.ndimension(); + int dimf = 0; + int dimh = 1; + int dimw = 2; + + if (ndim == 4) { + dimf++; + dimh++; + dimw++; + } + + AT_CHECK(ndim == 3 || ndim == 4, "3D or 4D input tensor expected but got: %s", + ndim); + + long nInputPlane = weight.size(1) * group; + long inputHeight = input.size(dimh); + long inputWidth = input.size(dimw); + long nOutputPlane = weight.size(0); + long outputHeight = + (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1; + long outputWidth = + (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1; + + AT_CHECK(nInputPlane % deformable_group == 0, + "input channels must divide deformable group size"); + + if (outputWidth < 1 || outputHeight < 1) + AT_ERROR( + "Given input size: (%ld x %ld x %ld). " + "Calculated output size: (%ld x %ld x %ld). Output size is too small", + nInputPlane, inputHeight, inputWidth, nOutputPlane, outputHeight, + outputWidth); + + AT_CHECK(input.size(1) == nInputPlane, + "invalid number of input planes, expected: %d, but got: %d", + nInputPlane, input.size(1)); + +// AT_CHECK((inputHeight >= kH && inputWidth >= kW), +// "input image is smaller than kernel"); + + AT_CHECK((offset.size(2) == outputHeight && offset.size(3) == outputWidth), + "invalid spatial size of offset, expected height: %d width: %d, but " + "got height: %d width: %d", + outputHeight, outputWidth, offset.size(2), offset.size(3)); + + AT_CHECK((offset.size(1) == deformable_group * 2 * kH * kW), + "invalid number of channels of offset"); + + if (gradOutput != NULL) { + AT_CHECK(gradOutput->size(dimf) == nOutputPlane, + "invalid number of gradOutput planes, expected: %d, but got: %d", + nOutputPlane, gradOutput->size(dimf)); + + AT_CHECK((gradOutput->size(dimh) == outputHeight && + gradOutput->size(dimw) == outputWidth), + "invalid size of gradOutput, expected height: %d width: %d , but " + "got height: %d width: %d", + outputHeight, outputWidth, gradOutput->size(dimh), + gradOutput->size(dimw)); + } +} + +int deform_conv_forward_cuda(at::Tensor input, at::Tensor weight, + at::Tensor offset, at::Tensor output, + at::Tensor columns, at::Tensor ones, int kW, + int kH, int dW, int dH, int padW, int padH, + int dilationW, int dilationH, int group, + int deformable_group, int im2col_step) { + // todo: resize columns to include im2col: done + // todo: add im2col_step as input + // todo: add new output buffer and transpose it to output (or directly + // transpose output) todo: possibly change data indexing because of + // parallel_imgs + + shape_check(input, offset, NULL, weight, kH, kW, dH, dW, padH, padW, + dilationH, dilationW, group, deformable_group); + + input = input.contiguous(); + offset = offset.contiguous(); + weight = weight.contiguous(); + + int batch = 1; + if (input.ndimension() == 3) { + // Force batch + batch = 0; + input.unsqueeze_(0); + offset.unsqueeze_(0); + } + + // todo: assert batchsize dividable by im2col_step + + long batchSize = input.size(0); + long nInputPlane = input.size(1); + long inputHeight = input.size(2); + long inputWidth = input.size(3); + + long nOutputPlane = weight.size(0); + + long outputWidth = + (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1; + long outputHeight = + (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1; + + AT_CHECK((offset.size(0) == batchSize), "invalid batch size of offset"); + + output = output.view({batchSize / im2col_step, im2col_step, nOutputPlane, + outputHeight, outputWidth}); + columns = at::zeros( + {nInputPlane * kW * kH, im2col_step * outputHeight * outputWidth}, + input.options()); + + if (ones.ndimension() != 2 || + ones.size(0) * ones.size(1) < outputHeight * outputWidth) { + ones = at::ones({outputHeight, outputWidth}, input.options()); + } + + input = input.view({batchSize / im2col_step, im2col_step, nInputPlane, + inputHeight, inputWidth}); + offset = + offset.view({batchSize / im2col_step, im2col_step, + deformable_group * 2 * kH * kW, outputHeight, outputWidth}); + + at::Tensor output_buffer = + at::zeros({batchSize / im2col_step, nOutputPlane, + im2col_step * outputHeight, outputWidth}, + output.options()); + + output_buffer = output_buffer.view( + {output_buffer.size(0), group, output_buffer.size(1) / group, + output_buffer.size(2), output_buffer.size(3)}); + + for (int elt = 0; elt < batchSize / im2col_step; elt++) { + deformable_im2col(input[elt], offset[elt], nInputPlane, inputHeight, + inputWidth, kH, kW, padH, padW, dH, dW, dilationH, + dilationW, im2col_step, deformable_group, columns); + + columns = columns.view({group, columns.size(0) / group, columns.size(1)}); + weight = weight.view({group, weight.size(0) / group, weight.size(1), + weight.size(2), weight.size(3)}); + + for (int g = 0; g < group; g++) { + output_buffer[elt][g] = output_buffer[elt][g] + .flatten(1) + .addmm_(weight[g].flatten(1), columns[g]) + .view_as(output_buffer[elt][g]); + } + } + + output_buffer = output_buffer.view( + {output_buffer.size(0), output_buffer.size(1) * output_buffer.size(2), + output_buffer.size(3), output_buffer.size(4)}); + + output_buffer = output_buffer.view({batchSize / im2col_step, nOutputPlane, + im2col_step, outputHeight, outputWidth}); + output_buffer.transpose_(1, 2); + output.copy_(output_buffer); + output = output.view({batchSize, nOutputPlane, outputHeight, outputWidth}); + + input = input.view({batchSize, nInputPlane, inputHeight, inputWidth}); + offset = offset.view( + {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth}); + + if (batch == 0) { + output = output.view({nOutputPlane, outputHeight, outputWidth}); + input = input.view({nInputPlane, inputHeight, inputWidth}); + offset = offset.view({offset.size(1), offset.size(2), offset.size(3)}); + } + + return 1; +} + +int deform_conv_backward_input_cuda(at::Tensor input, at::Tensor offset, + at::Tensor gradOutput, at::Tensor gradInput, + at::Tensor gradOffset, at::Tensor weight, + at::Tensor columns, int kW, int kH, int dW, + int dH, int padW, int padH, int dilationW, + int dilationH, int group, + int deformable_group, int im2col_step) { + shape_check(input, offset, &gradOutput, weight, kH, kW, dH, dW, padH, padW, + dilationH, dilationW, group, deformable_group); + + input = input.contiguous(); + offset = offset.contiguous(); + gradOutput = gradOutput.contiguous(); + weight = weight.contiguous(); + + int batch = 1; + + if (input.ndimension() == 3) { + // Force batch + batch = 0; + input = input.view({1, input.size(0), input.size(1), input.size(2)}); + offset = offset.view({1, offset.size(0), offset.size(1), offset.size(2)}); + gradOutput = gradOutput.view( + {1, gradOutput.size(0), gradOutput.size(1), gradOutput.size(2)}); + } + + long batchSize = input.size(0); + long nInputPlane = input.size(1); + long inputHeight = input.size(2); + long inputWidth = input.size(3); + + long nOutputPlane = weight.size(0); + + long outputWidth = + (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1; + long outputHeight = + (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1; + + AT_CHECK((offset.size(0) == batchSize), 3, "invalid batch size of offset"); + gradInput = gradInput.view({batchSize, nInputPlane, inputHeight, inputWidth}); + columns = at::zeros( + {nInputPlane * kW * kH, im2col_step * outputHeight * outputWidth}, + input.options()); + + // change order of grad output + gradOutput = gradOutput.view({batchSize / im2col_step, im2col_step, + nOutputPlane, outputHeight, outputWidth}); + gradOutput.transpose_(1, 2); + + gradInput = gradInput.view({batchSize / im2col_step, im2col_step, nInputPlane, + inputHeight, inputWidth}); + input = input.view({batchSize / im2col_step, im2col_step, nInputPlane, + inputHeight, inputWidth}); + gradOffset = gradOffset.view({batchSize / im2col_step, im2col_step, + deformable_group * 2 * kH * kW, outputHeight, + outputWidth}); + offset = + offset.view({batchSize / im2col_step, im2col_step, + deformable_group * 2 * kH * kW, outputHeight, outputWidth}); + + for (int elt = 0; elt < batchSize / im2col_step; elt++) { + // divide into groups + columns = columns.view({group, columns.size(0) / group, columns.size(1)}); + weight = weight.view({group, weight.size(0) / group, weight.size(1), + weight.size(2), weight.size(3)}); + gradOutput = gradOutput.view( + {gradOutput.size(0), group, gradOutput.size(1) / group, + gradOutput.size(2), gradOutput.size(3), gradOutput.size(4)}); + + for (int g = 0; g < group; g++) { + columns[g] = columns[g].addmm_(weight[g].flatten(1).transpose(0, 1), + gradOutput[elt][g].flatten(1), 0.0f, 1.0f); + } + + columns = + columns.view({columns.size(0) * columns.size(1), columns.size(2)}); + gradOutput = gradOutput.view( + {gradOutput.size(0), gradOutput.size(1) * gradOutput.size(2), + gradOutput.size(3), gradOutput.size(4), gradOutput.size(5)}); + + deformable_col2im_coord(columns, input[elt], offset[elt], nInputPlane, + inputHeight, inputWidth, kH, kW, padH, padW, dH, dW, + dilationH, dilationW, im2col_step, deformable_group, + gradOffset[elt]); + + deformable_col2im(columns, offset[elt], nInputPlane, inputHeight, + inputWidth, kH, kW, padH, padW, dH, dW, dilationH, + dilationW, im2col_step, deformable_group, gradInput[elt]); + } + + gradOutput.transpose_(1, 2); + gradOutput = + gradOutput.view({batchSize, nOutputPlane, outputHeight, outputWidth}); + + gradInput = gradInput.view({batchSize, nInputPlane, inputHeight, inputWidth}); + input = input.view({batchSize, nInputPlane, inputHeight, inputWidth}); + gradOffset = gradOffset.view( + {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth}); + offset = offset.view( + {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth}); + + if (batch == 0) { + gradOutput = gradOutput.view({nOutputPlane, outputHeight, outputWidth}); + input = input.view({nInputPlane, inputHeight, inputWidth}); + gradInput = gradInput.view({nInputPlane, inputHeight, inputWidth}); + offset = offset.view({offset.size(1), offset.size(2), offset.size(3)}); + gradOffset = + gradOffset.view({offset.size(1), offset.size(2), offset.size(3)}); + } + + return 1; +} + +int deform_conv_backward_parameters_cuda( + at::Tensor input, at::Tensor offset, at::Tensor gradOutput, + at::Tensor gradWeight, // at::Tensor gradBias, + at::Tensor columns, at::Tensor ones, int kW, int kH, int dW, int dH, + int padW, int padH, int dilationW, int dilationH, int group, + int deformable_group, float scale, int im2col_step) { + // todo: transpose and reshape outGrad + // todo: reshape columns + // todo: add im2col_step as input + + shape_check(input, offset, &gradOutput, gradWeight, kH, kW, dH, dW, padH, + padW, dilationH, dilationW, group, deformable_group); + + input = input.contiguous(); + offset = offset.contiguous(); + gradOutput = gradOutput.contiguous(); + + int batch = 1; + + if (input.ndimension() == 3) { + // Force batch + batch = 0; + input = input.view( + at::IntList({1, input.size(0), input.size(1), input.size(2)})); + gradOutput = gradOutput.view( + {1, gradOutput.size(0), gradOutput.size(1), gradOutput.size(2)}); + } + + long batchSize = input.size(0); + long nInputPlane = input.size(1); + long inputHeight = input.size(2); + long inputWidth = input.size(3); + + long nOutputPlane = gradWeight.size(0); + + long outputWidth = + (inputWidth + 2 * padW - (dilationW * (kW - 1) + 1)) / dW + 1; + long outputHeight = + (inputHeight + 2 * padH - (dilationH * (kH - 1) + 1)) / dH + 1; + + AT_CHECK((offset.size(0) == batchSize), "invalid batch size of offset"); + + columns = at::zeros( + {nInputPlane * kW * kH, im2col_step * outputHeight * outputWidth}, + input.options()); + + gradOutput = gradOutput.view({batchSize / im2col_step, im2col_step, + nOutputPlane, outputHeight, outputWidth}); + gradOutput.transpose_(1, 2); + + at::Tensor gradOutputBuffer = at::zeros_like(gradOutput); + gradOutputBuffer = + gradOutputBuffer.view({batchSize / im2col_step, nOutputPlane, im2col_step, + outputHeight, outputWidth}); + gradOutputBuffer.copy_(gradOutput); + gradOutputBuffer = + gradOutputBuffer.view({batchSize / im2col_step, nOutputPlane, + im2col_step * outputHeight, outputWidth}); + + gradOutput.transpose_(1, 2); + gradOutput = + gradOutput.view({batchSize, nOutputPlane, outputHeight, outputWidth}); + + input = input.view({batchSize / im2col_step, im2col_step, nInputPlane, + inputHeight, inputWidth}); + offset = + offset.view({batchSize / im2col_step, im2col_step, + deformable_group * 2 * kH * kW, outputHeight, outputWidth}); + + for (int elt = 0; elt < batchSize / im2col_step; elt++) { + deformable_im2col(input[elt], offset[elt], nInputPlane, inputHeight, + inputWidth, kH, kW, padH, padW, dH, dW, dilationH, + dilationW, im2col_step, deformable_group, columns); + + // divide into group + gradOutputBuffer = gradOutputBuffer.view( + {gradOutputBuffer.size(0), group, gradOutputBuffer.size(1) / group, + gradOutputBuffer.size(2), gradOutputBuffer.size(3)}); + columns = columns.view({group, columns.size(0) / group, columns.size(1)}); + gradWeight = + gradWeight.view({group, gradWeight.size(0) / group, gradWeight.size(1), + gradWeight.size(2), gradWeight.size(3)}); + + for (int g = 0; g < group; g++) { + gradWeight[g] = gradWeight[g] + .flatten(1) + .addmm_(gradOutputBuffer[elt][g].flatten(1), + columns[g].transpose(1, 0), 1.0, scale) + .view_as(gradWeight[g]); + } + gradOutputBuffer = gradOutputBuffer.view( + {gradOutputBuffer.size(0), + gradOutputBuffer.size(1) * gradOutputBuffer.size(2), + gradOutputBuffer.size(3), gradOutputBuffer.size(4)}); + columns = + columns.view({columns.size(0) * columns.size(1), columns.size(2)}); + gradWeight = gradWeight.view({gradWeight.size(0) * gradWeight.size(1), + gradWeight.size(2), gradWeight.size(3), + gradWeight.size(4)}); + } + + input = input.view({batchSize, nInputPlane, inputHeight, inputWidth}); + offset = offset.view( + {batchSize, deformable_group * 2 * kH * kW, outputHeight, outputWidth}); + + if (batch == 0) { + gradOutput = gradOutput.view({nOutputPlane, outputHeight, outputWidth}); + input = input.view({nInputPlane, inputHeight, inputWidth}); + } + + return 1; +} + +void modulated_deform_conv_cuda_forward( + at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones, + at::Tensor offset, at::Tensor mask, at::Tensor output, at::Tensor columns, + int kernel_h, int kernel_w, const int stride_h, const int stride_w, + const int pad_h, const int pad_w, const int dilation_h, + const int dilation_w, const int group, const int deformable_group, + const bool with_bias) { + AT_CHECK(input.is_contiguous(), "input tensor has to be contiguous"); + AT_CHECK(weight.is_contiguous(), "weight tensor has to be contiguous"); + + const int batch = input.size(0); + const int channels = input.size(1); + const int height = input.size(2); + const int width = input.size(3); + + const int channels_out = weight.size(0); + const int channels_kernel = weight.size(1); + const int kernel_h_ = weight.size(2); + const int kernel_w_ = weight.size(3); + + if (kernel_h_ != kernel_h || kernel_w_ != kernel_w) + AT_ERROR("Input shape and kernel shape wont match: (%d x %d vs %d x %d).", + kernel_h_, kernel_w, kernel_h_, kernel_w_); + if (channels != channels_kernel * group) + AT_ERROR("Input shape and kernel channels wont match: (%d vs %d).", + channels, channels_kernel * group); + + const int height_out = + (height + 2 * pad_h - (dilation_h * (kernel_h - 1) + 1)) / stride_h + 1; + const int width_out = + (width + 2 * pad_w - (dilation_w * (kernel_w - 1) + 1)) / stride_w + 1; + + if (ones.ndimension() != 2 || + ones.size(0) * ones.size(1) < height_out * width_out) { + // Resize plane and fill with ones... + ones = at::ones({height_out, width_out}, input.options()); + } + + // resize output + output = output.view({batch, channels_out, height_out, width_out}).zero_(); + // resize temporary columns + columns = + at::zeros({channels * kernel_h * kernel_w, 1 * height_out * width_out}, + input.options()); + + output = output.view({output.size(0), group, output.size(1) / group, + output.size(2), output.size(3)}); + + for (int b = 0; b < batch; b++) { + modulated_deformable_im2col_cuda( + input[b], offset[b], mask[b], 1, channels, height, width, height_out, + width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w, + dilation_h, dilation_w, deformable_group, columns); + + // divide into group + weight = weight.view({group, weight.size(0) / group, weight.size(1), + weight.size(2), weight.size(3)}); + columns = columns.view({group, columns.size(0) / group, columns.size(1)}); + + for (int g = 0; g < group; g++) { + output[b][g] = output[b][g] + .flatten(1) + .addmm_(weight[g].flatten(1), columns[g]) + .view_as(output[b][g]); + } + + weight = weight.view({weight.size(0) * weight.size(1), weight.size(2), + weight.size(3), weight.size(4)}); + columns = + columns.view({columns.size(0) * columns.size(1), columns.size(2)}); + } + + output = output.view({output.size(0), output.size(1) * output.size(2), + output.size(3), output.size(4)}); + + if (with_bias) { + output += bias.view({1, bias.size(0), 1, 1}); + } +} + +void modulated_deform_conv_cuda_backward( + at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones, + at::Tensor offset, at::Tensor mask, at::Tensor columns, + at::Tensor grad_input, at::Tensor grad_weight, at::Tensor grad_bias, + at::Tensor grad_offset, at::Tensor grad_mask, at::Tensor grad_output, + int kernel_h, int kernel_w, int stride_h, int stride_w, int pad_h, + int pad_w, int dilation_h, int dilation_w, int group, int deformable_group, + const bool with_bias) { + AT_CHECK(input.is_contiguous(), "input tensor has to be contiguous"); + AT_CHECK(weight.is_contiguous(), "weight tensor has to be contiguous"); + + const int batch = input.size(0); + const int channels = input.size(1); + const int height = input.size(2); + const int width = input.size(3); + + const int channels_kernel = weight.size(1); + const int kernel_h_ = weight.size(2); + const int kernel_w_ = weight.size(3); + if (kernel_h_ != kernel_h || kernel_w_ != kernel_w) + AT_ERROR("Input shape and kernel shape wont match: (%d x %d vs %d x %d).", + kernel_h_, kernel_w, kernel_h_, kernel_w_); + if (channels != channels_kernel * group) + AT_ERROR("Input shape and kernel channels wont match: (%d vs %d).", + channels, channels_kernel * group); + + const int height_out = + (height + 2 * pad_h - (dilation_h * (kernel_h - 1) + 1)) / stride_h + 1; + const int width_out = + (width + 2 * pad_w - (dilation_w * (kernel_w - 1) + 1)) / stride_w + 1; + + if (ones.ndimension() != 2 || + ones.size(0) * ones.size(1) < height_out * width_out) { + // Resize plane and fill with ones... + ones = at::ones({height_out, width_out}, input.options()); + } + + grad_input = grad_input.view({batch, channels, height, width}); + columns = at::zeros({channels * kernel_h * kernel_w, height_out * width_out}, + input.options()); + + grad_output = + grad_output.view({grad_output.size(0), group, grad_output.size(1) / group, + grad_output.size(2), grad_output.size(3)}); + + for (int b = 0; b < batch; b++) { + // divide int group + columns = columns.view({group, columns.size(0) / group, columns.size(1)}); + weight = weight.view({group, weight.size(0) / group, weight.size(1), + weight.size(2), weight.size(3)}); + + for (int g = 0; g < group; g++) { + columns[g].addmm_(weight[g].flatten(1).transpose(0, 1), + grad_output[b][g].flatten(1), 0.0f, 1.0f); + } + + columns = + columns.view({columns.size(0) * columns.size(1), columns.size(2)}); + weight = weight.view({weight.size(0) * weight.size(1), weight.size(2), + weight.size(3), weight.size(4)}); + + // gradient w.r.t. input coordinate data + modulated_deformable_col2im_coord_cuda( + columns, input[b], offset[b], mask[b], 1, channels, height, width, + height_out, width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h, + stride_w, dilation_h, dilation_w, deformable_group, grad_offset[b], + grad_mask[b]); + // gradient w.r.t. input data + modulated_deformable_col2im_cuda( + columns, offset[b], mask[b], 1, channels, height, width, height_out, + width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w, + dilation_h, dilation_w, deformable_group, grad_input[b]); + + // gradient w.r.t. weight, dWeight should accumulate across the batch and + // group + modulated_deformable_im2col_cuda( + input[b], offset[b], mask[b], 1, channels, height, width, height_out, + width_out, kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w, + dilation_h, dilation_w, deformable_group, columns); + + columns = columns.view({group, columns.size(0) / group, columns.size(1)}); + grad_weight = grad_weight.view({group, grad_weight.size(0) / group, + grad_weight.size(1), grad_weight.size(2), + grad_weight.size(3)}); + if (with_bias) + grad_bias = grad_bias.view({group, grad_bias.size(0) / group}); + + for (int g = 0; g < group; g++) { + grad_weight[g] = + grad_weight[g] + .flatten(1) + .addmm_(grad_output[b][g].flatten(1), columns[g].transpose(0, 1)) + .view_as(grad_weight[g]); + if (with_bias) { + grad_bias[g] = + grad_bias[g] + .view({-1, 1}) + .addmm_(grad_output[b][g].flatten(1), ones.view({-1, 1})) + .view(-1); + } + } + + columns = + columns.view({columns.size(0) * columns.size(1), columns.size(2)}); + grad_weight = grad_weight.view({grad_weight.size(0) * grad_weight.size(1), + grad_weight.size(2), grad_weight.size(3), + grad_weight.size(4)}); + if (with_bias) + grad_bias = grad_bias.view({grad_bias.size(0) * grad_bias.size(1)}); + } + grad_output = grad_output.view({grad_output.size(0) * grad_output.size(1), + grad_output.size(2), grad_output.size(3), + grad_output.size(4)}); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("deform_conv_forward_cuda", &deform_conv_forward_cuda, + "deform forward (CUDA)"); + m.def("deform_conv_backward_input_cuda", &deform_conv_backward_input_cuda, + "deform_conv_backward_input (CUDA)"); + m.def("deform_conv_backward_parameters_cuda", + &deform_conv_backward_parameters_cuda, + "deform_conv_backward_parameters (CUDA)"); + m.def("modulated_deform_conv_cuda_forward", + &modulated_deform_conv_cuda_forward, + "modulated deform conv forward (CUDA)"); + m.def("modulated_deform_conv_cuda_backward", + &modulated_deform_conv_cuda_backward, + "modulated deform conv backward (CUDA)"); +} diff --git a/mmdet/ops/dcn/src/deform_conv_cuda_kernel.cu b/mmdet/ops/dcn/src/deform_conv_cuda_kernel.cu new file mode 100644 index 0000000..a2b9428 --- /dev/null +++ b/mmdet/ops/dcn/src/deform_conv_cuda_kernel.cu @@ -0,0 +1,866 @@ +/*! + ******************* BEGIN Caffe Copyright Notice and Disclaimer **************** + * + * COPYRIGHT + * + * All contributions by the University of California: + * Copyright (c) 2014-2017 The Regents of the University of California (Regents) + * All rights reserved. + * + * All other contributions: + * Copyright (c) 2014-2017, the respective contributors + * All rights reserved. + * + * Caffe uses a shared copyright model: each contributor holds copyright over + * their contributions to Caffe. The project versioning records all such + * contribution and copyright details. If a contributor wants to further mark + * their specific copyright on a particular contribution, they should indicate + * their copyright solely in the commit message of the change when it is + * committed. + * + * LICENSE + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * CONTRIBUTION AGREEMENT + * + * By contributing to the BVLC/caffe repository through pull-request, comment, + * or otherwise, the contributor releases their content to the + * license and copyright terms herein. + * + ***************** END Caffe Copyright Notice and Disclaimer ******************** + * + * Copyright (c) 2018 Microsoft + * Licensed under The MIT License [see LICENSE for details] + * \file modulated_deformable_im2col.cuh + * \brief Function definitions of converting an image to + * column matrix based on kernel, padding, dilation, and offset. + * These functions are mainly used in deformable convolution operators. + * \ref: https://arxiv.org/abs/1703.06211 + * \author Yuwen Xiong, Haozhi Qi, Jifeng Dai, Xizhou Zhu, Han Hu, Dazhi Cheng + */ + +// modified from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/deform_conv_cuda_kernel.cu + +#include +#include +#include +#include +#include + +using namespace at; + +#define CUDA_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < (n); \ + i += blockDim.x * gridDim.x) + +const int CUDA_NUM_THREADS = 1024; +const int kMaxGridNum = 65535; + +inline int GET_BLOCKS(const int N) +{ + return std::min(kMaxGridNum, (N + CUDA_NUM_THREADS - 1) / CUDA_NUM_THREADS); +} + +template +__device__ scalar_t deformable_im2col_bilinear(const scalar_t *bottom_data, const int data_width, + const int height, const int width, scalar_t h, scalar_t w) +{ + + int h_low = floor(h); + int w_low = floor(w); + int h_high = h_low + 1; + int w_high = w_low + 1; + + scalar_t lh = h - h_low; + scalar_t lw = w - w_low; + scalar_t hh = 1 - lh, hw = 1 - lw; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + v1 = bottom_data[h_low * data_width + w_low]; + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + v2 = bottom_data[h_low * data_width + w_high]; + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + v3 = bottom_data[h_high * data_width + w_low]; + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + v4 = bottom_data[h_high * data_width + w_high]; + + scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + + scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + return val; +} + +template +__device__ scalar_t get_gradient_weight(scalar_t argmax_h, scalar_t argmax_w, + const int h, const int w, const int height, const int width) +{ + + if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width) + { + //empty + return 0; + } + + int argmax_h_low = floor(argmax_h); + int argmax_w_low = floor(argmax_w); + int argmax_h_high = argmax_h_low + 1; + int argmax_w_high = argmax_w_low + 1; + + scalar_t weight = 0; + if (h == argmax_h_low && w == argmax_w_low) + weight = (h + 1 - argmax_h) * (w + 1 - argmax_w); + if (h == argmax_h_low && w == argmax_w_high) + weight = (h + 1 - argmax_h) * (argmax_w + 1 - w); + if (h == argmax_h_high && w == argmax_w_low) + weight = (argmax_h + 1 - h) * (w + 1 - argmax_w); + if (h == argmax_h_high && w == argmax_w_high) + weight = (argmax_h + 1 - h) * (argmax_w + 1 - w); + return weight; +} + +template +__device__ scalar_t get_coordinate_weight(scalar_t argmax_h, scalar_t argmax_w, + const int height, const int width, const scalar_t *im_data, + const int data_width, const int bp_dir) +{ + + if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width) + { + //empty + return 0; + } + + int argmax_h_low = floor(argmax_h); + int argmax_w_low = floor(argmax_w); + int argmax_h_high = argmax_h_low + 1; + int argmax_w_high = argmax_w_low + 1; + + scalar_t weight = 0; + + if (bp_dir == 0) + { + if (argmax_h_low >= 0 && argmax_w_low >= 0) + weight += -1 * (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_low * data_width + argmax_w_low]; + if (argmax_h_low >= 0 && argmax_w_high <= width - 1) + weight += -1 * (argmax_w - argmax_w_low) * im_data[argmax_h_low * data_width + argmax_w_high]; + if (argmax_h_high <= height - 1 && argmax_w_low >= 0) + weight += (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_high * data_width + argmax_w_low]; + if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1) + weight += (argmax_w - argmax_w_low) * im_data[argmax_h_high * data_width + argmax_w_high]; + } + else if (bp_dir == 1) + { + if (argmax_h_low >= 0 && argmax_w_low >= 0) + weight += -1 * (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_low]; + if (argmax_h_low >= 0 && argmax_w_high <= width - 1) + weight += (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_high]; + if (argmax_h_high <= height - 1 && argmax_w_low >= 0) + weight += -1 * (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_low]; + if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1) + weight += (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_high]; + } + + return weight; +} + +template +__global__ void deformable_im2col_gpu_kernel(const int n, const scalar_t *data_im, const scalar_t *data_offset, + const int height, const int width, const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, const int channel_per_deformable_group, + const int batch_size, const int num_channels, const int deformable_group, + const int height_col, const int width_col, + scalar_t *data_col) +{ + CUDA_KERNEL_LOOP(index, n) + { + // index index of output matrix + const int w_col = index % width_col; + const int h_col = (index / width_col) % height_col; + const int b_col = (index / width_col / height_col) % batch_size; + const int c_im = (index / width_col / height_col) / batch_size; + const int c_col = c_im * kernel_h * kernel_w; + + // compute deformable group index + const int deformable_group_index = c_im / channel_per_deformable_group; + + const int h_in = h_col * stride_h - pad_h; + const int w_in = w_col * stride_w - pad_w; + scalar_t *data_col_ptr = data_col + ((c_col * batch_size + b_col) * height_col + h_col) * width_col + w_col; + //const scalar_t* data_im_ptr = data_im + ((b_col * num_channels + c_im) * height + h_in) * width + w_in; + const scalar_t *data_im_ptr = data_im + (b_col * num_channels + c_im) * height * width; + const scalar_t *data_offset_ptr = data_offset + (b_col * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col; + + for (int i = 0; i < kernel_h; ++i) + { + for (int j = 0; j < kernel_w; ++j) + { + const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_col) * width_col + w_col; + const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_col) * width_col + w_col; + const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr]; + const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr]; + scalar_t val = static_cast(0); + const scalar_t h_im = h_in + i * dilation_h + offset_h; + const scalar_t w_im = w_in + j * dilation_w + offset_w; + if (h_im > -1 && w_im > -1 && h_im < height && w_im < width) + { + //const scalar_t map_h = i * dilation_h + offset_h; + //const scalar_t map_w = j * dilation_w + offset_w; + //const int cur_height = height - h_in; + //const int cur_width = width - w_in; + //val = deformable_im2col_bilinear(data_im_ptr, width, cur_height, cur_width, map_h, map_w); + val = deformable_im2col_bilinear(data_im_ptr, width, height, width, h_im, w_im); + } + *data_col_ptr = val; + data_col_ptr += batch_size * height_col * width_col; + } + } + } +} + +void deformable_im2col( + const at::Tensor data_im, const at::Tensor data_offset, const int channels, + const int height, const int width, const int ksize_h, const int ksize_w, + const int pad_h, const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, const int parallel_imgs, + const int deformable_group, at::Tensor data_col) +{ + // num_axes should be smaller than block size + // todo: check parallel_imgs is correctly passed in + int height_col = (height + 2 * pad_h - (dilation_h * (ksize_h - 1) + 1)) / stride_h + 1; + int width_col = (width + 2 * pad_w - (dilation_w * (ksize_w - 1) + 1)) / stride_w + 1; + int num_kernels = channels * height_col * width_col * parallel_imgs; + int channel_per_deformable_group = channels / deformable_group; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + data_im.scalar_type(), "deformable_im2col_gpu", ([&] { + const scalar_t *data_im_ = data_im.data(); + const scalar_t *data_offset_ = data_offset.data(); + scalar_t *data_col_ = data_col.data(); + + deformable_im2col_gpu_kernel<<>>( + num_kernels, data_im_, data_offset_, height, width, ksize_h, ksize_w, + pad_h, pad_w, stride_h, stride_w, dilation_h, dilation_w, + channel_per_deformable_group, parallel_imgs, channels, deformable_group, + height_col, width_col, data_col_); + })); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in deformable_im2col: %s\n", cudaGetErrorString(err)); + } +} + +template +__global__ void deformable_col2im_gpu_kernel( + const int n, const scalar_t *data_col, const scalar_t *data_offset, + const int channels, const int height, const int width, + const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int channel_per_deformable_group, + const int batch_size, const int deformable_group, + const int height_col, const int width_col, + scalar_t *grad_im) +{ + CUDA_KERNEL_LOOP(index, n) + { + const int j = (index / width_col / height_col / batch_size) % kernel_w; + const int i = (index / width_col / height_col / batch_size / kernel_w) % kernel_h; + const int c = index / width_col / height_col / batch_size / kernel_w / kernel_h; + // compute the start and end of the output + + const int deformable_group_index = c / channel_per_deformable_group; + + int w_out = index % width_col; + int h_out = (index / width_col) % height_col; + int b = (index / width_col / height_col) % batch_size; + int w_in = w_out * stride_w - pad_w; + int h_in = h_out * stride_h - pad_h; + + const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) * + 2 * kernel_h * kernel_w * height_col * width_col; + const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out; + const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out; + const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr]; + const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr]; + const scalar_t cur_inv_h_data = h_in + i * dilation_h + offset_h; + const scalar_t cur_inv_w_data = w_in + j * dilation_w + offset_w; + + const scalar_t cur_top_grad = data_col[index]; + const int cur_h = (int)cur_inv_h_data; + const int cur_w = (int)cur_inv_w_data; + for (int dy = -2; dy <= 2; dy++) + { + for (int dx = -2; dx <= 2; dx++) + { + if (cur_h + dy >= 0 && cur_h + dy < height && + cur_w + dx >= 0 && cur_w + dx < width && + abs(cur_inv_h_data - (cur_h + dy)) < 1 && + abs(cur_inv_w_data - (cur_w + dx)) < 1) + { + int cur_bottom_grad_pos = ((b * channels + c) * height + cur_h + dy) * width + cur_w + dx; + scalar_t weight = get_gradient_weight(cur_inv_h_data, cur_inv_w_data, cur_h + dy, cur_w + dx, height, width); + atomicAdd(grad_im + cur_bottom_grad_pos, weight * cur_top_grad); + } + } + } + } +} + +void deformable_col2im( + const at::Tensor data_col, const at::Tensor data_offset, const int channels, + const int height, const int width, const int ksize_h, + const int ksize_w, const int pad_h, const int pad_w, + const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int parallel_imgs, const int deformable_group, + at::Tensor grad_im) +{ + + // todo: make sure parallel_imgs is passed in correctly + int height_col = (height + 2 * pad_h - (dilation_h * (ksize_h - 1) + 1)) / stride_h + 1; + int width_col = (width + 2 * pad_w - (dilation_w * (ksize_w - 1) + 1)) / stride_w + 1; + int num_kernels = channels * ksize_h * ksize_w * height_col * width_col * parallel_imgs; + int channel_per_deformable_group = channels / deformable_group; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + data_col.scalar_type(), "deformable_col2im_gpu", ([&] { + const scalar_t *data_col_ = data_col.data(); + const scalar_t *data_offset_ = data_offset.data(); + scalar_t *grad_im_ = grad_im.data(); + + deformable_col2im_gpu_kernel<<>>( + num_kernels, data_col_, data_offset_, channels, height, width, ksize_h, + ksize_w, pad_h, pad_w, stride_h, stride_w, + dilation_h, dilation_w, channel_per_deformable_group, + parallel_imgs, deformable_group, height_col, width_col, grad_im_); + })); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in deformable_col2im: %s\n", cudaGetErrorString(err)); + } +} + +template +__global__ void deformable_col2im_coord_gpu_kernel(const int n, const scalar_t *data_col, + const scalar_t *data_im, const scalar_t *data_offset, + const int channels, const int height, const int width, + const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int channel_per_deformable_group, + const int batch_size, const int offset_channels, const int deformable_group, + const int height_col, const int width_col, scalar_t *grad_offset) +{ + CUDA_KERNEL_LOOP(index, n) + { + scalar_t val = 0; + int w = index % width_col; + int h = (index / width_col) % height_col; + int c = (index / width_col / height_col) % offset_channels; + int b = (index / width_col / height_col) / offset_channels; + // compute the start and end of the output + + const int deformable_group_index = c / (2 * kernel_h * kernel_w); + const int col_step = kernel_h * kernel_w; + int cnt = 0; + const scalar_t *data_col_ptr = data_col + deformable_group_index * channel_per_deformable_group * + batch_size * width_col * height_col; + const scalar_t *data_im_ptr = data_im + (b * deformable_group + deformable_group_index) * + channel_per_deformable_group / kernel_h / kernel_w * height * width; + const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) * 2 * + kernel_h * kernel_w * height_col * width_col; + + const int offset_c = c - deformable_group_index * 2 * kernel_h * kernel_w; + + for (int col_c = (offset_c / 2); col_c < channel_per_deformable_group; col_c += col_step) + { + const int col_pos = (((col_c * batch_size + b) * height_col) + h) * width_col + w; + const int bp_dir = offset_c % 2; + + int j = (col_pos / width_col / height_col / batch_size) % kernel_w; + int i = (col_pos / width_col / height_col / batch_size / kernel_w) % kernel_h; + int w_out = col_pos % width_col; + int h_out = (col_pos / width_col) % height_col; + int w_in = w_out * stride_w - pad_w; + int h_in = h_out * stride_h - pad_h; + const int data_offset_h_ptr = (((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out); + const int data_offset_w_ptr = (((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out); + const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr]; + const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr]; + scalar_t inv_h = h_in + i * dilation_h + offset_h; + scalar_t inv_w = w_in + j * dilation_w + offset_w; + if (inv_h <= -1 || inv_w <= -1 || inv_h >= height || inv_w >= width) + { + inv_h = inv_w = -2; + } + const scalar_t weight = get_coordinate_weight( + inv_h, inv_w, + height, width, data_im_ptr + cnt * height * width, width, bp_dir); + val += weight * data_col_ptr[col_pos]; + cnt += 1; + } + + grad_offset[index] = val; + } +} + +void deformable_col2im_coord( + const at::Tensor data_col, const at::Tensor data_im, const at::Tensor data_offset, + const int channels, const int height, const int width, const int ksize_h, + const int ksize_w, const int pad_h, const int pad_w, const int stride_h, + const int stride_w, const int dilation_h, const int dilation_w, + const int parallel_imgs, const int deformable_group, at::Tensor grad_offset) +{ + + int height_col = (height + 2 * pad_h - (dilation_h * (ksize_h - 1) + 1)) / stride_h + 1; + int width_col = (width + 2 * pad_w - (dilation_w * (ksize_w - 1) + 1)) / stride_w + 1; + int num_kernels = height_col * width_col * 2 * ksize_h * ksize_w * deformable_group * parallel_imgs; + int channel_per_deformable_group = channels * ksize_h * ksize_w / deformable_group; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + data_col.scalar_type(), "deformable_col2im_coord_gpu", ([&] { + const scalar_t *data_col_ = data_col.data(); + const scalar_t *data_im_ = data_im.data(); + const scalar_t *data_offset_ = data_offset.data(); + scalar_t *grad_offset_ = grad_offset.data(); + + deformable_col2im_coord_gpu_kernel<<>>( + num_kernels, data_col_, data_im_, data_offset_, channels, height, width, + ksize_h, ksize_w, pad_h, pad_w, stride_h, stride_w, + dilation_h, dilation_w, channel_per_deformable_group, + parallel_imgs, 2 * ksize_h * ksize_w * deformable_group, deformable_group, + height_col, width_col, grad_offset_); + })); +} + +template +__device__ scalar_t dmcn_im2col_bilinear(const scalar_t *bottom_data, const int data_width, + const int height, const int width, scalar_t h, scalar_t w) +{ + int h_low = floor(h); + int w_low = floor(w); + int h_high = h_low + 1; + int w_high = w_low + 1; + + scalar_t lh = h - h_low; + scalar_t lw = w - w_low; + scalar_t hh = 1 - lh, hw = 1 - lw; + + scalar_t v1 = 0; + if (h_low >= 0 && w_low >= 0) + v1 = bottom_data[h_low * data_width + w_low]; + scalar_t v2 = 0; + if (h_low >= 0 && w_high <= width - 1) + v2 = bottom_data[h_low * data_width + w_high]; + scalar_t v3 = 0; + if (h_high <= height - 1 && w_low >= 0) + v3 = bottom_data[h_high * data_width + w_low]; + scalar_t v4 = 0; + if (h_high <= height - 1 && w_high <= width - 1) + v4 = bottom_data[h_high * data_width + w_high]; + + scalar_t w1 = hh * hw, w2 = hh * lw, w3 = lh * hw, w4 = lh * lw; + + scalar_t val = (w1 * v1 + w2 * v2 + w3 * v3 + w4 * v4); + return val; +} + +template +__device__ scalar_t dmcn_get_gradient_weight(scalar_t argmax_h, scalar_t argmax_w, + const int h, const int w, const int height, const int width) +{ + if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width) + { + //empty + return 0; + } + + int argmax_h_low = floor(argmax_h); + int argmax_w_low = floor(argmax_w); + int argmax_h_high = argmax_h_low + 1; + int argmax_w_high = argmax_w_low + 1; + + scalar_t weight = 0; + if (h == argmax_h_low && w == argmax_w_low) + weight = (h + 1 - argmax_h) * (w + 1 - argmax_w); + if (h == argmax_h_low && w == argmax_w_high) + weight = (h + 1 - argmax_h) * (argmax_w + 1 - w); + if (h == argmax_h_high && w == argmax_w_low) + weight = (argmax_h + 1 - h) * (w + 1 - argmax_w); + if (h == argmax_h_high && w == argmax_w_high) + weight = (argmax_h + 1 - h) * (argmax_w + 1 - w); + return weight; +} + +template +__device__ scalar_t dmcn_get_coordinate_weight(scalar_t argmax_h, scalar_t argmax_w, + const int height, const int width, const scalar_t *im_data, + const int data_width, const int bp_dir) +{ + if (argmax_h <= -1 || argmax_h >= height || argmax_w <= -1 || argmax_w >= width) + { + //empty + return 0; + } + + int argmax_h_low = floor(argmax_h); + int argmax_w_low = floor(argmax_w); + int argmax_h_high = argmax_h_low + 1; + int argmax_w_high = argmax_w_low + 1; + + scalar_t weight = 0; + + if (bp_dir == 0) + { + if (argmax_h_low >= 0 && argmax_w_low >= 0) + weight += -1 * (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_low * data_width + argmax_w_low]; + if (argmax_h_low >= 0 && argmax_w_high <= width - 1) + weight += -1 * (argmax_w - argmax_w_low) * im_data[argmax_h_low * data_width + argmax_w_high]; + if (argmax_h_high <= height - 1 && argmax_w_low >= 0) + weight += (argmax_w_low + 1 - argmax_w) * im_data[argmax_h_high * data_width + argmax_w_low]; + if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1) + weight += (argmax_w - argmax_w_low) * im_data[argmax_h_high * data_width + argmax_w_high]; + } + else if (bp_dir == 1) + { + if (argmax_h_low >= 0 && argmax_w_low >= 0) + weight += -1 * (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_low]; + if (argmax_h_low >= 0 && argmax_w_high <= width - 1) + weight += (argmax_h_low + 1 - argmax_h) * im_data[argmax_h_low * data_width + argmax_w_high]; + if (argmax_h_high <= height - 1 && argmax_w_low >= 0) + weight += -1 * (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_low]; + if (argmax_h_high <= height - 1 && argmax_w_high <= width - 1) + weight += (argmax_h - argmax_h_low) * im_data[argmax_h_high * data_width + argmax_w_high]; + } + + return weight; +} + +template +__global__ void modulated_deformable_im2col_gpu_kernel(const int n, + const scalar_t *data_im, const scalar_t *data_offset, const scalar_t *data_mask, + const int height, const int width, const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int channel_per_deformable_group, + const int batch_size, const int num_channels, const int deformable_group, + const int height_col, const int width_col, + scalar_t *data_col) +{ + CUDA_KERNEL_LOOP(index, n) + { + // index index of output matrix + const int w_col = index % width_col; + const int h_col = (index / width_col) % height_col; + const int b_col = (index / width_col / height_col) % batch_size; + const int c_im = (index / width_col / height_col) / batch_size; + const int c_col = c_im * kernel_h * kernel_w; + + // compute deformable group index + const int deformable_group_index = c_im / channel_per_deformable_group; + + const int h_in = h_col * stride_h - pad_h; + const int w_in = w_col * stride_w - pad_w; + + scalar_t *data_col_ptr = data_col + ((c_col * batch_size + b_col) * height_col + h_col) * width_col + w_col; + //const float* data_im_ptr = data_im + ((b_col * num_channels + c_im) * height + h_in) * width + w_in; + const scalar_t *data_im_ptr = data_im + (b_col * num_channels + c_im) * height * width; + const scalar_t *data_offset_ptr = data_offset + (b_col * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col; + + const scalar_t *data_mask_ptr = data_mask + (b_col * deformable_group + deformable_group_index) * kernel_h * kernel_w * height_col * width_col; + + for (int i = 0; i < kernel_h; ++i) + { + for (int j = 0; j < kernel_w; ++j) + { + const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_col) * width_col + w_col; + const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_col) * width_col + w_col; + const int data_mask_hw_ptr = ((i * kernel_w + j) * height_col + h_col) * width_col + w_col; + const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr]; + const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr]; + const scalar_t mask = data_mask_ptr[data_mask_hw_ptr]; + scalar_t val = static_cast(0); + const scalar_t h_im = h_in + i * dilation_h + offset_h; + const scalar_t w_im = w_in + j * dilation_w + offset_w; + //if (h_im >= 0 && w_im >= 0 && h_im < height && w_im < width) { + if (h_im > -1 && w_im > -1 && h_im < height && w_im < width) + { + //const float map_h = i * dilation_h + offset_h; + //const float map_w = j * dilation_w + offset_w; + //const int cur_height = height - h_in; + //const int cur_width = width - w_in; + //val = dmcn_im2col_bilinear(data_im_ptr, width, cur_height, cur_width, map_h, map_w); + val = dmcn_im2col_bilinear(data_im_ptr, width, height, width, h_im, w_im); + } + *data_col_ptr = val * mask; + data_col_ptr += batch_size * height_col * width_col; + //data_col_ptr += height_col * width_col; + } + } + } +} + +template +__global__ void modulated_deformable_col2im_gpu_kernel(const int n, + const scalar_t *data_col, const scalar_t *data_offset, const scalar_t *data_mask, + const int channels, const int height, const int width, + const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int channel_per_deformable_group, + const int batch_size, const int deformable_group, + const int height_col, const int width_col, + scalar_t *grad_im) +{ + CUDA_KERNEL_LOOP(index, n) + { + const int j = (index / width_col / height_col / batch_size) % kernel_w; + const int i = (index / width_col / height_col / batch_size / kernel_w) % kernel_h; + const int c = index / width_col / height_col / batch_size / kernel_w / kernel_h; + // compute the start and end of the output + + const int deformable_group_index = c / channel_per_deformable_group; + + int w_out = index % width_col; + int h_out = (index / width_col) % height_col; + int b = (index / width_col / height_col) % batch_size; + int w_in = w_out * stride_w - pad_w; + int h_in = h_out * stride_h - pad_h; + + const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col; + const scalar_t *data_mask_ptr = data_mask + (b * deformable_group + deformable_group_index) * kernel_h * kernel_w * height_col * width_col; + const int data_offset_h_ptr = ((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out; + const int data_offset_w_ptr = ((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out; + const int data_mask_hw_ptr = ((i * kernel_w + j) * height_col + h_out) * width_col + w_out; + const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr]; + const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr]; + const scalar_t mask = data_mask_ptr[data_mask_hw_ptr]; + const scalar_t cur_inv_h_data = h_in + i * dilation_h + offset_h; + const scalar_t cur_inv_w_data = w_in + j * dilation_w + offset_w; + + const scalar_t cur_top_grad = data_col[index] * mask; + const int cur_h = (int)cur_inv_h_data; + const int cur_w = (int)cur_inv_w_data; + for (int dy = -2; dy <= 2; dy++) + { + for (int dx = -2; dx <= 2; dx++) + { + if (cur_h + dy >= 0 && cur_h + dy < height && + cur_w + dx >= 0 && cur_w + dx < width && + abs(cur_inv_h_data - (cur_h + dy)) < 1 && + abs(cur_inv_w_data - (cur_w + dx)) < 1) + { + int cur_bottom_grad_pos = ((b * channels + c) * height + cur_h + dy) * width + cur_w + dx; + scalar_t weight = dmcn_get_gradient_weight(cur_inv_h_data, cur_inv_w_data, cur_h + dy, cur_w + dx, height, width); + atomicAdd(grad_im + cur_bottom_grad_pos, weight * cur_top_grad); + } + } + } + } +} + +template +__global__ void modulated_deformable_col2im_coord_gpu_kernel(const int n, + const scalar_t *data_col, const scalar_t *data_im, + const scalar_t *data_offset, const scalar_t *data_mask, + const int channels, const int height, const int width, + const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int channel_per_deformable_group, + const int batch_size, const int offset_channels, const int deformable_group, + const int height_col, const int width_col, + scalar_t *grad_offset, scalar_t *grad_mask) +{ + CUDA_KERNEL_LOOP(index, n) + { + scalar_t val = 0, mval = 0; + int w = index % width_col; + int h = (index / width_col) % height_col; + int c = (index / width_col / height_col) % offset_channels; + int b = (index / width_col / height_col) / offset_channels; + // compute the start and end of the output + + const int deformable_group_index = c / (2 * kernel_h * kernel_w); + const int col_step = kernel_h * kernel_w; + int cnt = 0; + const scalar_t *data_col_ptr = data_col + deformable_group_index * channel_per_deformable_group * batch_size * width_col * height_col; + const scalar_t *data_im_ptr = data_im + (b * deformable_group + deformable_group_index) * channel_per_deformable_group / kernel_h / kernel_w * height * width; + const scalar_t *data_offset_ptr = data_offset + (b * deformable_group + deformable_group_index) * 2 * kernel_h * kernel_w * height_col * width_col; + const scalar_t *data_mask_ptr = data_mask + (b * deformable_group + deformable_group_index) * kernel_h * kernel_w * height_col * width_col; + + const int offset_c = c - deformable_group_index * 2 * kernel_h * kernel_w; + + for (int col_c = (offset_c / 2); col_c < channel_per_deformable_group; col_c += col_step) + { + const int col_pos = (((col_c * batch_size + b) * height_col) + h) * width_col + w; + const int bp_dir = offset_c % 2; + + int j = (col_pos / width_col / height_col / batch_size) % kernel_w; + int i = (col_pos / width_col / height_col / batch_size / kernel_w) % kernel_h; + int w_out = col_pos % width_col; + int h_out = (col_pos / width_col) % height_col; + int w_in = w_out * stride_w - pad_w; + int h_in = h_out * stride_h - pad_h; + const int data_offset_h_ptr = (((2 * (i * kernel_w + j)) * height_col + h_out) * width_col + w_out); + const int data_offset_w_ptr = (((2 * (i * kernel_w + j) + 1) * height_col + h_out) * width_col + w_out); + const int data_mask_hw_ptr = (((i * kernel_w + j) * height_col + h_out) * width_col + w_out); + const scalar_t offset_h = data_offset_ptr[data_offset_h_ptr]; + const scalar_t offset_w = data_offset_ptr[data_offset_w_ptr]; + const scalar_t mask = data_mask_ptr[data_mask_hw_ptr]; + scalar_t inv_h = h_in + i * dilation_h + offset_h; + scalar_t inv_w = w_in + j * dilation_w + offset_w; + if (inv_h <= -1 || inv_w <= -1 || inv_h >= height || inv_w >= width) + { + inv_h = inv_w = -2; + } + else + { + mval += data_col_ptr[col_pos] * dmcn_im2col_bilinear(data_im_ptr + cnt * height * width, width, height, width, inv_h, inv_w); + } + const scalar_t weight = dmcn_get_coordinate_weight( + inv_h, inv_w, + height, width, data_im_ptr + cnt * height * width, width, bp_dir); + val += weight * data_col_ptr[col_pos] * mask; + cnt += 1; + } + // KERNEL_ASSIGN(grad_offset[index], offset_req, val); + grad_offset[index] = val; + if (offset_c % 2 == 0) + // KERNEL_ASSIGN(grad_mask[(((b * deformable_group + deformable_group_index) * kernel_h * kernel_w + offset_c / 2) * height_col + h) * width_col + w], mask_req, mval); + grad_mask[(((b * deformable_group + deformable_group_index) * kernel_h * kernel_w + offset_c / 2) * height_col + h) * width_col + w] = mval; + } +} + +void modulated_deformable_im2col_cuda( + const at::Tensor data_im, const at::Tensor data_offset, const at::Tensor data_mask, + const int batch_size, const int channels, const int height_im, const int width_im, + const int height_col, const int width_col, const int kernel_h, const int kenerl_w, + const int pad_h, const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int deformable_group, at::Tensor data_col) +{ + // num_axes should be smaller than block size + const int channel_per_deformable_group = channels / deformable_group; + const int num_kernels = channels * batch_size * height_col * width_col; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + data_im.scalar_type(), "modulated_deformable_im2col_gpu", ([&] { + const scalar_t *data_im_ = data_im.data(); + const scalar_t *data_offset_ = data_offset.data(); + const scalar_t *data_mask_ = data_mask.data(); + scalar_t *data_col_ = data_col.data(); + + modulated_deformable_im2col_gpu_kernel<<>>( + num_kernels, data_im_, data_offset_, data_mask_, height_im, width_im, kernel_h, kenerl_w, + pad_h, pad_w, stride_h, stride_w, dilation_h, dilation_w, channel_per_deformable_group, + batch_size, channels, deformable_group, height_col, width_col, data_col_); + })); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in modulated_deformable_im2col_cuda: %s\n", cudaGetErrorString(err)); + } +} + +void modulated_deformable_col2im_cuda( + const at::Tensor data_col, const at::Tensor data_offset, const at::Tensor data_mask, + const int batch_size, const int channels, const int height_im, const int width_im, + const int height_col, const int width_col, const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int deformable_group, at::Tensor grad_im) +{ + + const int channel_per_deformable_group = channels / deformable_group; + const int num_kernels = channels * kernel_h * kernel_w * batch_size * height_col * width_col; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + data_col.scalar_type(), "modulated_deformable_col2im_gpu", ([&] { + const scalar_t *data_col_ = data_col.data(); + const scalar_t *data_offset_ = data_offset.data(); + const scalar_t *data_mask_ = data_mask.data(); + scalar_t *grad_im_ = grad_im.data(); + + modulated_deformable_col2im_gpu_kernel<<>>( + num_kernels, data_col_, data_offset_, data_mask_, channels, height_im, width_im, + kernel_h, kernel_w, pad_h, pad_h, stride_h, stride_w, + dilation_h, dilation_w, channel_per_deformable_group, + batch_size, deformable_group, height_col, width_col, grad_im_); + })); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in modulated_deformable_col2im_cuda: %s\n", cudaGetErrorString(err)); + } +} + +void modulated_deformable_col2im_coord_cuda( + const at::Tensor data_col, const at::Tensor data_im, const at::Tensor data_offset, const at::Tensor data_mask, + const int batch_size, const int channels, const int height_im, const int width_im, + const int height_col, const int width_col, const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, const int stride_h, const int stride_w, + const int dilation_h, const int dilation_w, + const int deformable_group, + at::Tensor grad_offset, at::Tensor grad_mask) +{ + const int num_kernels = batch_size * height_col * width_col * 2 * kernel_h * kernel_w * deformable_group; + const int channel_per_deformable_group = channels * kernel_h * kernel_w / deformable_group; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + data_col.scalar_type(), "modulated_deformable_col2im_coord_gpu", ([&] { + const scalar_t *data_col_ = data_col.data(); + const scalar_t *data_im_ = data_im.data(); + const scalar_t *data_offset_ = data_offset.data(); + const scalar_t *data_mask_ = data_mask.data(); + scalar_t *grad_offset_ = grad_offset.data(); + scalar_t *grad_mask_ = grad_mask.data(); + + modulated_deformable_col2im_coord_gpu_kernel<<>>( + num_kernels, data_col_, data_im_, data_offset_, data_mask_, channels, height_im, width_im, + kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w, + dilation_h, dilation_w, channel_per_deformable_group, + batch_size, 2 * kernel_h * kernel_w * deformable_group, deformable_group, height_col, width_col, + grad_offset_, grad_mask_); + })); + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in modulated_deformable_col2im_coord_cuda: %s\n", cudaGetErrorString(err)); + } +} diff --git a/mmdet/ops/dcn/src/deform_pool_cuda.cpp b/mmdet/ops/dcn/src/deform_pool_cuda.cpp new file mode 100644 index 0000000..803d5f1 --- /dev/null +++ b/mmdet/ops/dcn/src/deform_pool_cuda.cpp @@ -0,0 +1,87 @@ +// modify from +// https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/modulated_dcn_cuda.c + +// based on +// author: Charles Shang +// https://github.com/torch/cunn/blob/master/lib/THCUNN/generic/SpatialConvolutionMM.cu + +#include + +#include +#include + +void DeformablePSROIPoolForward( + const at::Tensor data, const at::Tensor bbox, const at::Tensor trans, + at::Tensor out, at::Tensor top_count, const int batch, const int channels, + const int height, const int width, const int num_bbox, + const int channels_trans, const int no_trans, const float spatial_scale, + const int output_dim, const int group_size, const int pooled_size, + const int part_size, const int sample_per_part, const float trans_std); + +void DeformablePSROIPoolBackwardAcc( + const at::Tensor out_grad, const at::Tensor data, const at::Tensor bbox, + const at::Tensor trans, const at::Tensor top_count, at::Tensor in_grad, + at::Tensor trans_grad, const int batch, const int channels, + const int height, const int width, const int num_bbox, + const int channels_trans, const int no_trans, const float spatial_scale, + const int output_dim, const int group_size, const int pooled_size, + const int part_size, const int sample_per_part, const float trans_std); + +void deform_psroi_pooling_cuda_forward( + at::Tensor input, at::Tensor bbox, at::Tensor trans, at::Tensor out, + at::Tensor top_count, const int no_trans, const float spatial_scale, + const int output_dim, const int group_size, const int pooled_size, + const int part_size, const int sample_per_part, const float trans_std) { + AT_CHECK(input.is_contiguous(), "input tensor has to be contiguous"); + + const int batch = input.size(0); + const int channels = input.size(1); + const int height = input.size(2); + const int width = input.size(3); + const int channels_trans = no_trans ? 2 : trans.size(1); + + const int num_bbox = bbox.size(0); + if (num_bbox != out.size(0)) + AT_ERROR("Output shape and bbox number wont match: (%d vs %d).", + out.size(0), num_bbox); + + DeformablePSROIPoolForward( + input, bbox, trans, out, top_count, batch, channels, height, width, + num_bbox, channels_trans, no_trans, spatial_scale, output_dim, group_size, + pooled_size, part_size, sample_per_part, trans_std); +} + +void deform_psroi_pooling_cuda_backward( + at::Tensor out_grad, at::Tensor input, at::Tensor bbox, at::Tensor trans, + at::Tensor top_count, at::Tensor input_grad, at::Tensor trans_grad, + const int no_trans, const float spatial_scale, const int output_dim, + const int group_size, const int pooled_size, const int part_size, + const int sample_per_part, const float trans_std) { + AT_CHECK(out_grad.is_contiguous(), "out_grad tensor has to be contiguous"); + AT_CHECK(input.is_contiguous(), "input tensor has to be contiguous"); + + const int batch = input.size(0); + const int channels = input.size(1); + const int height = input.size(2); + const int width = input.size(3); + const int channels_trans = no_trans ? 2 : trans.size(1); + + const int num_bbox = bbox.size(0); + if (num_bbox != out_grad.size(0)) + AT_ERROR("Output shape and bbox number wont match: (%d vs %d).", + out_grad.size(0), num_bbox); + + DeformablePSROIPoolBackwardAcc( + out_grad, input, bbox, trans, top_count, input_grad, trans_grad, batch, + channels, height, width, num_bbox, channels_trans, no_trans, + spatial_scale, output_dim, group_size, pooled_size, part_size, + sample_per_part, trans_std); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("deform_psroi_pooling_cuda_forward", &deform_psroi_pooling_cuda_forward, + "deform psroi pooling forward(CUDA)"); + m.def("deform_psroi_pooling_cuda_backward", + &deform_psroi_pooling_cuda_backward, + "deform psroi pooling backward(CUDA)"); +} \ No newline at end of file diff --git a/mmdet/ops/dcn/src/deform_pool_cuda_kernel.cu b/mmdet/ops/dcn/src/deform_pool_cuda_kernel.cu new file mode 100644 index 0000000..1922d72 --- /dev/null +++ b/mmdet/ops/dcn/src/deform_pool_cuda_kernel.cu @@ -0,0 +1,364 @@ +/*! + * Copyright (c) 2017 Microsoft + * Licensed under The MIT License [see LICENSE for details] + * \file deformable_psroi_pooling.cu + * \brief + * \author Yi Li, Guodong Zhang, Jifeng Dai +*/ +/***************** Adapted by Charles Shang *********************/ +// modify from https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/cuda/deform_psroi_pooling_cuda.cu + +#include +#include +#include +#include +#include + +using namespace at; + +#define CUDA_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; \ + i < (n); \ + i += blockDim.x * gridDim.x) + +const int CUDA_NUM_THREADS = 1024; +inline int GET_BLOCKS(const int N) +{ + return (N + CUDA_NUM_THREADS - 1) / CUDA_NUM_THREADS; +} + +template +__device__ scalar_t bilinear_interp( + const scalar_t *data, + const scalar_t x, + const scalar_t y, + const int width, + const int height) +{ + int x1 = floor(x); + int x2 = ceil(x); + int y1 = floor(y); + int y2 = ceil(y); + scalar_t dist_x = (scalar_t)(x - x1); + scalar_t dist_y = (scalar_t)(y - y1); + scalar_t value11 = data[y1 * width + x1]; + scalar_t value12 = data[y2 * width + x1]; + scalar_t value21 = data[y1 * width + x2]; + scalar_t value22 = data[y2 * width + x2]; + scalar_t value = (1 - dist_x) * (1 - dist_y) * value11 + (1 - dist_x) * dist_y * value12 + dist_x * (1 - dist_y) * value21 + dist_x * dist_y * value22; + return value; +} + +template +__global__ void DeformablePSROIPoolForwardKernel( + const int count, + const scalar_t *bottom_data, + const scalar_t spatial_scale, + const int channels, + const int height, const int width, + const int pooled_height, const int pooled_width, + const scalar_t *bottom_rois, const scalar_t *bottom_trans, + const int no_trans, + const scalar_t trans_std, + const int sample_per_part, + const int output_dim, + const int group_size, + const int part_size, + const int num_classes, + const int channels_each_class, + scalar_t *top_data, + scalar_t *top_count) +{ + CUDA_KERNEL_LOOP(index, count) + { + // The output is in order (n, ctop, ph, pw) + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int ctop = (index / pooled_width / pooled_height) % output_dim; + int n = index / pooled_width / pooled_height / output_dim; + + // [start, end) interval for spatial sampling + const scalar_t *offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + scalar_t roi_start_w = (scalar_t)(round(offset_bottom_rois[1])) * spatial_scale - 0.5; + scalar_t roi_start_h = (scalar_t)(round(offset_bottom_rois[2])) * spatial_scale - 0.5; + scalar_t roi_end_w = (scalar_t)(round(offset_bottom_rois[3]) + 1.) * spatial_scale - 0.5; + scalar_t roi_end_h = (scalar_t)(round(offset_bottom_rois[4]) + 1.) * spatial_scale - 0.5; + + // Force too small ROIs to be 1x1 + scalar_t roi_width = max(roi_end_w - roi_start_w, 0.1); //avoid 0 + scalar_t roi_height = max(roi_end_h - roi_start_h, 0.1); + + // Compute w and h at bottom + scalar_t bin_size_h = roi_height / (scalar_t)(pooled_height); + scalar_t bin_size_w = roi_width / (scalar_t)(pooled_width); + + scalar_t sub_bin_size_h = bin_size_h / (scalar_t)(sample_per_part); + scalar_t sub_bin_size_w = bin_size_w / (scalar_t)(sample_per_part); + + int part_h = floor((scalar_t)(ph) / pooled_height * part_size); + int part_w = floor((scalar_t)(pw) / pooled_width * part_size); + int class_id = ctop / channels_each_class; + scalar_t trans_x = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std; + scalar_t trans_y = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2 + 1) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std; + + scalar_t wstart = (scalar_t)(pw)*bin_size_w + roi_start_w; + wstart += trans_x * roi_width; + scalar_t hstart = (scalar_t)(ph)*bin_size_h + roi_start_h; + hstart += trans_y * roi_height; + + scalar_t sum = 0; + int count = 0; + int gw = floor((scalar_t)(pw)*group_size / pooled_width); + int gh = floor((scalar_t)(ph)*group_size / pooled_height); + gw = min(max(gw, 0), group_size - 1); + gh = min(max(gh, 0), group_size - 1); + + const scalar_t *offset_bottom_data = bottom_data + (roi_batch_ind * channels) * height * width; + for (int ih = 0; ih < sample_per_part; ih++) + { + for (int iw = 0; iw < sample_per_part; iw++) + { + scalar_t w = wstart + iw * sub_bin_size_w; + scalar_t h = hstart + ih * sub_bin_size_h; + // bilinear interpolation + if (w < -0.5 || w > width - 0.5 || h < -0.5 || h > height - 0.5) + { + continue; + } + w = min(max(w, 0.), width - 1.); + h = min(max(h, 0.), height - 1.); + int c = (ctop * group_size + gh) * group_size + gw; + scalar_t val = bilinear_interp(offset_bottom_data + c * height * width, w, h, width, height); + sum += val; + count++; + } + } + top_data[index] = count == 0 ? (scalar_t)(0) : sum / count; + top_count[index] = count; + } +} + +template +__global__ void DeformablePSROIPoolBackwardAccKernel( + const int count, + const scalar_t *top_diff, + const scalar_t *top_count, + const int num_rois, + const scalar_t spatial_scale, + const int channels, + const int height, const int width, + const int pooled_height, const int pooled_width, + const int output_dim, + scalar_t *bottom_data_diff, scalar_t *bottom_trans_diff, + const scalar_t *bottom_data, + const scalar_t *bottom_rois, + const scalar_t *bottom_trans, + const int no_trans, + const scalar_t trans_std, + const int sample_per_part, + const int group_size, + const int part_size, + const int num_classes, + const int channels_each_class) +{ + CUDA_KERNEL_LOOP(index, count) + { + // The output is in order (n, ctop, ph, pw) + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int ctop = (index / pooled_width / pooled_height) % output_dim; + int n = index / pooled_width / pooled_height / output_dim; + + // [start, end) interval for spatial sampling + const scalar_t *offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + scalar_t roi_start_w = (scalar_t)(round(offset_bottom_rois[1])) * spatial_scale - 0.5; + scalar_t roi_start_h = (scalar_t)(round(offset_bottom_rois[2])) * spatial_scale - 0.5; + scalar_t roi_end_w = (scalar_t)(round(offset_bottom_rois[3]) + 1.) * spatial_scale - 0.5; + scalar_t roi_end_h = (scalar_t)(round(offset_bottom_rois[4]) + 1.) * spatial_scale - 0.5; + + // Force too small ROIs to be 1x1 + scalar_t roi_width = max(roi_end_w - roi_start_w, 0.1); //avoid 0 + scalar_t roi_height = max(roi_end_h - roi_start_h, 0.1); + + // Compute w and h at bottom + scalar_t bin_size_h = roi_height / (scalar_t)(pooled_height); + scalar_t bin_size_w = roi_width / (scalar_t)(pooled_width); + + scalar_t sub_bin_size_h = bin_size_h / (scalar_t)(sample_per_part); + scalar_t sub_bin_size_w = bin_size_w / (scalar_t)(sample_per_part); + + int part_h = floor((scalar_t)(ph) / pooled_height * part_size); + int part_w = floor((scalar_t)(pw) / pooled_width * part_size); + int class_id = ctop / channels_each_class; + scalar_t trans_x = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std; + scalar_t trans_y = no_trans ? (scalar_t)(0) : bottom_trans[(((n * num_classes + class_id) * 2 + 1) * part_size + part_h) * part_size + part_w] * (scalar_t)trans_std; + + scalar_t wstart = (scalar_t)(pw)*bin_size_w + roi_start_w; + wstart += trans_x * roi_width; + scalar_t hstart = (scalar_t)(ph)*bin_size_h + roi_start_h; + hstart += trans_y * roi_height; + + if (top_count[index] <= 0) + { + continue; + } + scalar_t diff_val = top_diff[index] / top_count[index]; + const scalar_t *offset_bottom_data = bottom_data + roi_batch_ind * channels * height * width; + scalar_t *offset_bottom_data_diff = bottom_data_diff + roi_batch_ind * channels * height * width; + int gw = floor((scalar_t)(pw)*group_size / pooled_width); + int gh = floor((scalar_t)(ph)*group_size / pooled_height); + gw = min(max(gw, 0), group_size - 1); + gh = min(max(gh, 0), group_size - 1); + + for (int ih = 0; ih < sample_per_part; ih++) + { + for (int iw = 0; iw < sample_per_part; iw++) + { + scalar_t w = wstart + iw * sub_bin_size_w; + scalar_t h = hstart + ih * sub_bin_size_h; + // bilinear interpolation + if (w < -0.5 || w > width - 0.5 || h < -0.5 || h > height - 0.5) + { + continue; + } + w = min(max(w, 0.), width - 1.); + h = min(max(h, 0.), height - 1.); + int c = (ctop * group_size + gh) * group_size + gw; + // backward on feature + int x0 = floor(w); + int x1 = ceil(w); + int y0 = floor(h); + int y1 = ceil(h); + scalar_t dist_x = w - x0, dist_y = h - y0; + scalar_t q00 = (1 - dist_x) * (1 - dist_y); + scalar_t q01 = (1 - dist_x) * dist_y; + scalar_t q10 = dist_x * (1 - dist_y); + scalar_t q11 = dist_x * dist_y; + int bottom_index_base = c * height * width; + atomicAdd(offset_bottom_data_diff + bottom_index_base + y0 * width + x0, q00 * diff_val); + atomicAdd(offset_bottom_data_diff + bottom_index_base + y1 * width + x0, q01 * diff_val); + atomicAdd(offset_bottom_data_diff + bottom_index_base + y0 * width + x1, q10 * diff_val); + atomicAdd(offset_bottom_data_diff + bottom_index_base + y1 * width + x1, q11 * diff_val); + + if (no_trans) + { + continue; + } + scalar_t U00 = offset_bottom_data[bottom_index_base + y0 * width + x0]; + scalar_t U01 = offset_bottom_data[bottom_index_base + y1 * width + x0]; + scalar_t U10 = offset_bottom_data[bottom_index_base + y0 * width + x1]; + scalar_t U11 = offset_bottom_data[bottom_index_base + y1 * width + x1]; + scalar_t diff_x = (U11 * dist_y + U10 * (1 - dist_y) - U01 * dist_y - U00 * (1 - dist_y)) * trans_std * diff_val; + diff_x *= roi_width; + scalar_t diff_y = (U11 * dist_x + U01 * (1 - dist_x) - U10 * dist_x - U00 * (1 - dist_x)) * trans_std * diff_val; + diff_y *= roi_height; + + atomicAdd(bottom_trans_diff + (((n * num_classes + class_id) * 2) * part_size + part_h) * part_size + part_w, diff_x); + atomicAdd(bottom_trans_diff + (((n * num_classes + class_id) * 2 + 1) * part_size + part_h) * part_size + part_w, diff_y); + } + } + } +} + +void DeformablePSROIPoolForward(const at::Tensor data, + const at::Tensor bbox, + const at::Tensor trans, + at::Tensor out, + at::Tensor top_count, + const int batch, + const int channels, + const int height, + const int width, + const int num_bbox, + const int channels_trans, + const int no_trans, + const float spatial_scale, + const int output_dim, + const int group_size, + const int pooled_size, + const int part_size, + const int sample_per_part, + const float trans_std) +{ + const int pooled_height = pooled_size; + const int pooled_width = pooled_size; + const int count = num_bbox * output_dim * pooled_height * pooled_width; + const int num_classes = no_trans ? 1 : channels_trans / 2; + const int channels_each_class = no_trans ? output_dim : output_dim / num_classes; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + data.scalar_type(), "deformable_psroi_pool_forward", ([&] { + const scalar_t *bottom_data = data.data(); + const scalar_t *bottom_rois = bbox.data(); + const scalar_t *bottom_trans = no_trans ? NULL : trans.data(); + scalar_t *top_data = out.data(); + scalar_t *top_count_data = top_count.data(); + + DeformablePSROIPoolForwardKernel<<>>( + count, bottom_data, (scalar_t)spatial_scale, channels, height, width, pooled_height, pooled_width, + bottom_rois, bottom_trans, no_trans, (scalar_t)trans_std, sample_per_part, output_dim, + group_size, part_size, num_classes, channels_each_class, top_data, top_count_data); + })); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in DeformablePSROIPoolForward: %s\n", cudaGetErrorString(err)); + } +} + +void DeformablePSROIPoolBackwardAcc(const at::Tensor out_grad, + const at::Tensor data, + const at::Tensor bbox, + const at::Tensor trans, + const at::Tensor top_count, + at::Tensor in_grad, + at::Tensor trans_grad, + const int batch, + const int channels, + const int height, + const int width, + const int num_bbox, + const int channels_trans, + const int no_trans, + const float spatial_scale, + const int output_dim, + const int group_size, + const int pooled_size, + const int part_size, + const int sample_per_part, + const float trans_std) +{ + // LOG(INFO) << "DeformablePSROIPoolBackward"; + const int num_rois = num_bbox; + const int pooled_height = pooled_size; + const int pooled_width = pooled_size; + const int count = num_bbox * output_dim * pooled_height * pooled_width; + const int num_classes = no_trans ? 1 : channels_trans / 2; + const int channels_each_class = no_trans ? output_dim : output_dim / num_classes; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + out_grad.scalar_type(), "deformable_psroi_pool_backward_acc", ([&] { + const scalar_t *top_diff = out_grad.data(); + const scalar_t *bottom_data = data.data(); + const scalar_t *bottom_rois = bbox.data(); + const scalar_t *bottom_trans = no_trans ? NULL : trans.data(); + scalar_t *bottom_data_diff = in_grad.data(); + scalar_t *bottom_trans_diff = no_trans ? NULL : trans_grad.data(); + const scalar_t *top_count_data = top_count.data(); + + DeformablePSROIPoolBackwardAccKernel<<>>( + count, top_diff, top_count_data, num_rois, (scalar_t)spatial_scale, channels, height, width, + pooled_height, pooled_width, output_dim, bottom_data_diff, bottom_trans_diff, + bottom_data, bottom_rois, bottom_trans, no_trans, (scalar_t)trans_std, sample_per_part, + group_size, part_size, num_classes, channels_each_class); + })); + + cudaError_t err = cudaGetLastError(); + if (err != cudaSuccess) + { + printf("error in DeformablePSROIPoolForward: %s\n", cudaGetErrorString(err)); + } +} \ No newline at end of file diff --git a/mmdet/ops/masked_conv/__init__.py b/mmdet/ops/masked_conv/__init__.py new file mode 100644 index 0000000..f537ace --- /dev/null +++ b/mmdet/ops/masked_conv/__init__.py @@ -0,0 +1,3 @@ +from .masked_conv import MaskedConv2d, masked_conv2d + +__all__ = ['masked_conv2d', 'MaskedConv2d'] diff --git a/mmdet/ops/masked_conv/masked_conv.py b/mmdet/ops/masked_conv/masked_conv.py new file mode 100644 index 0000000..7d84f50 --- /dev/null +++ b/mmdet/ops/masked_conv/masked_conv.py @@ -0,0 +1,89 @@ +import math + +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.modules.utils import _pair + +from . import masked_conv2d_cuda + + +class MaskedConv2dFunction(Function): + + @staticmethod + def forward(ctx, features, mask, weight, bias, padding=0, stride=1): + assert mask.dim() == 3 and mask.size(0) == 1 + assert features.dim() == 4 and features.size(0) == 1 + assert features.size()[2:] == mask.size()[1:] + pad_h, pad_w = _pair(padding) + stride_h, stride_w = _pair(stride) + if stride_h != 1 or stride_w != 1: + raise ValueError( + 'Stride could not only be 1 in masked_conv2d currently.') + if not features.is_cuda: + raise NotImplementedError + + out_channel, in_channel, kernel_h, kernel_w = weight.size() + + batch_size = features.size(0) + out_h = int( + math.floor((features.size(2) + 2 * pad_h - + (kernel_h - 1) - 1) / stride_h + 1)) + out_w = int( + math.floor((features.size(3) + 2 * pad_w - + (kernel_h - 1) - 1) / stride_w + 1)) + mask_inds = torch.nonzero(mask[0] > 0) + output = features.new_zeros(batch_size, out_channel, out_h, out_w) + if mask_inds.numel() > 0: + mask_h_idx = mask_inds[:, 0].contiguous() + mask_w_idx = mask_inds[:, 1].contiguous() + data_col = features.new_zeros(in_channel * kernel_h * kernel_w, + mask_inds.size(0)) + masked_conv2d_cuda.masked_im2col_forward(features, mask_h_idx, + mask_w_idx, kernel_h, + kernel_w, pad_h, pad_w, + data_col) + + masked_output = torch.addmm(1, bias[:, None], 1, + weight.view(out_channel, -1), data_col) + masked_conv2d_cuda.masked_col2im_forward(masked_output, mask_h_idx, + mask_w_idx, out_h, out_w, + out_channel, output) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + return (None, ) * 5 + + +masked_conv2d = MaskedConv2dFunction.apply + + +class MaskedConv2d(nn.Conv2d): + """A MaskedConv2d which inherits the official Conv2d. + + The masked forward doesn't implement the backward function and only + supports the stride parameter to be 1 currently. + """ + + def __init__(self, + in_channels, + out_channels, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups=1, + bias=True): + super(MaskedConv2d, + self).__init__(in_channels, out_channels, kernel_size, stride, + padding, dilation, groups, bias) + + def forward(self, input, mask=None): + if mask is None: # fallback to the normal Conv2d + return super(MaskedConv2d, self).forward(input) + else: + return masked_conv2d(input, mask, self.weight, self.bias, + self.padding) diff --git a/mmdet/ops/masked_conv/src/masked_conv2d_cuda.cpp b/mmdet/ops/masked_conv/src/masked_conv2d_cuda.cpp new file mode 100644 index 0000000..f9d5373 --- /dev/null +++ b/mmdet/ops/masked_conv/src/masked_conv2d_cuda.cpp @@ -0,0 +1,74 @@ +#include + +#include +#include + +int MaskedIm2colForwardLaucher(const at::Tensor im, const int height, + const int width, const int channels, + const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const at::Tensor mask_h_idx, + const at::Tensor mask_w_idx, const int mask_cnt, + at::Tensor col); + +int MaskedCol2imForwardLaucher(const at::Tensor col, const int height, + const int width, const int channels, + const at::Tensor mask_h_idx, + const at::Tensor mask_w_idx, const int mask_cnt, + at::Tensor im); + +#define CHECK_CUDA(x) AT_CHECK(x.type().is_cuda(), #x, " must be a CUDAtensor ") +#define CHECK_CONTIGUOUS(x) \ + AT_CHECK(x.is_contiguous(), #x, " must be contiguous ") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +int masked_im2col_forward_cuda(const at::Tensor im, const at::Tensor mask_h_idx, + const at::Tensor mask_w_idx, const int kernel_h, + const int kernel_w, const int pad_h, + const int pad_w, at::Tensor col) { + CHECK_INPUT(im); + CHECK_INPUT(mask_h_idx); + CHECK_INPUT(mask_w_idx); + CHECK_INPUT(col); + // im: (n, ic, h, w), kernel size (kh, kw) + // kernel: (oc, ic * kh * kw), col: (kh * kw * ic, ow * oh) + + int channels = im.size(1); + int height = im.size(2); + int width = im.size(3); + int mask_cnt = mask_h_idx.size(0); + + MaskedIm2colForwardLaucher(im, height, width, channels, kernel_h, kernel_w, + pad_h, pad_w, mask_h_idx, mask_w_idx, mask_cnt, + col); + + return 1; +} + +int masked_col2im_forward_cuda(const at::Tensor col, + const at::Tensor mask_h_idx, + const at::Tensor mask_w_idx, int height, + int width, int channels, at::Tensor im) { + CHECK_INPUT(col); + CHECK_INPUT(mask_h_idx); + CHECK_INPUT(mask_w_idx); + CHECK_INPUT(im); + // im: (n, ic, h, w), kernel size (kh, kw) + // kernel: (oc, ic * kh * kh), col: (kh * kw * ic, ow * oh) + + int mask_cnt = mask_h_idx.size(0); + + MaskedCol2imForwardLaucher(col, height, width, channels, mask_h_idx, + mask_w_idx, mask_cnt, im); + + return 1; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("masked_im2col_forward", &masked_im2col_forward_cuda, + "masked_im2col forward (CUDA)"); + m.def("masked_col2im_forward", &masked_col2im_forward_cuda, + "masked_col2im forward (CUDA)"); +} \ No newline at end of file diff --git a/mmdet/ops/masked_conv/src/masked_conv2d_kernel.cu b/mmdet/ops/masked_conv/src/masked_conv2d_kernel.cu new file mode 100644 index 0000000..2312d12 --- /dev/null +++ b/mmdet/ops/masked_conv/src/masked_conv2d_kernel.cu @@ -0,0 +1,112 @@ +#include +#include + +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + +#define THREADS_PER_BLOCK 1024 + +inline int GET_BLOCKS(const int N) { + int optimal_block_num = (N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK; + int max_block_num = 65000; + return min(optimal_block_num, max_block_num); +} + +template +__global__ void MaskedIm2colForward(const int n, const scalar_t *data_im, + const int height, const int width, + const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const int64_t *mask_h_idx, + const int64_t *mask_w_idx, + const int mask_cnt, scalar_t *data_col) { + // mask_cnt * channels + CUDA_1D_KERNEL_LOOP(index, n) { + const int m_index = index % mask_cnt; + const int h_col = mask_h_idx[m_index]; + const int w_col = mask_w_idx[m_index]; + const int c_im = index / mask_cnt; + const int c_col = c_im * kernel_h * kernel_w; + const int h_offset = h_col - pad_h; + const int w_offset = w_col - pad_w; + scalar_t *data_col_ptr = data_col + c_col * mask_cnt + m_index; + for (int i = 0; i < kernel_h; ++i) { + int h_im = h_offset + i; + for (int j = 0; j < kernel_w; ++j) { + int w_im = w_offset + j; + if (h_im >= 0 && w_im >= 0 && h_im < height && w_im < width) { + *data_col_ptr = + (scalar_t)data_im[(c_im * height + h_im) * width + w_im]; + } else { + *data_col_ptr = 0.0; + } + data_col_ptr += mask_cnt; + } + } + } +} + +int MaskedIm2colForwardLaucher(const at::Tensor bottom_data, const int height, + const int width, const int channels, + const int kernel_h, const int kernel_w, + const int pad_h, const int pad_w, + const at::Tensor mask_h_idx, + const at::Tensor mask_w_idx, const int mask_cnt, + at::Tensor top_data) { + const int output_size = mask_cnt * channels; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + bottom_data.scalar_type(), "MaskedIm2colLaucherForward", ([&] { + const scalar_t *bottom_data_ = bottom_data.data(); + const int64_t *mask_h_idx_ = mask_h_idx.data(); + const int64_t *mask_w_idx_ = mask_w_idx.data(); + scalar_t *top_data_ = top_data.data(); + MaskedIm2colForward + <<>>( + output_size, bottom_data_, height, width, kernel_h, kernel_w, + pad_h, pad_w, mask_h_idx_, mask_w_idx_, mask_cnt, top_data_); + })); + THCudaCheck(cudaGetLastError()); + return 1; +} + +template +__global__ void MaskedCol2imForward(const int n, const scalar_t *data_col, + const int height, const int width, + const int channels, + const int64_t *mask_h_idx, + const int64_t *mask_w_idx, + const int mask_cnt, scalar_t *data_im) { + CUDA_1D_KERNEL_LOOP(index, n) { + const int m_index = index % mask_cnt; + const int h_im = mask_h_idx[m_index]; + const int w_im = mask_w_idx[m_index]; + const int c_im = index / mask_cnt; + // compute the start and end of the output + data_im[(c_im * height + h_im) * width + w_im] = data_col[index]; + } +} + +int MaskedCol2imForwardLaucher(const at::Tensor bottom_data, const int height, + const int width, const int channels, + const at::Tensor mask_h_idx, + const at::Tensor mask_w_idx, const int mask_cnt, + at::Tensor top_data) { + const int output_size = mask_cnt * channels; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + bottom_data.scalar_type(), "MaskedCol2imLaucherForward", ([&] { + const scalar_t *bottom_data_ = bottom_data.data(); + const int64_t *mask_h_idx_ = mask_h_idx.data(); + const int64_t *mask_w_idx_ = mask_w_idx.data(); + scalar_t *top_data_ = top_data.data(); + + MaskedCol2imForward + <<>>( + output_size, bottom_data_, height, width, channels, mask_h_idx_, + mask_w_idx_, mask_cnt, top_data_); + })); + THCudaCheck(cudaGetLastError()); + return 1; +} diff --git a/mmdet/ops/nms/__init__.py b/mmdet/ops/nms/__init__.py new file mode 100644 index 0000000..c440704 --- /dev/null +++ b/mmdet/ops/nms/__init__.py @@ -0,0 +1,3 @@ +from .nms_wrapper import nms, soft_nms + +__all__ = ['nms', 'soft_nms'] diff --git a/mmdet/ops/nms/nms_wrapper.py b/mmdet/ops/nms/nms_wrapper.py new file mode 100644 index 0000000..03215f1 --- /dev/null +++ b/mmdet/ops/nms/nms_wrapper.py @@ -0,0 +1,78 @@ +import numpy as np +import torch + +from . import nms_cpu, nms_cuda +from .soft_nms_cpu import soft_nms_cpu + + +def nms(dets, iou_thr, device_id=None): + """Dispatch to either CPU or GPU NMS implementations. + + The input can be either a torch tensor or numpy array. GPU NMS will be used + if the input is a gpu tensor or device_id is specified, otherwise CPU NMS + will be used. The returned type will always be the same as inputs. + + Arguments: + dets (torch.Tensor or np.ndarray): bboxes with scores. + iou_thr (float): IoU threshold for NMS. + device_id (int, optional): when `dets` is a numpy array, if `device_id` + is None, then cpu nms is used, otherwise gpu_nms will be used. + + Returns: + tuple: kept bboxes and indice, which is always the same data type as + the input. + """ + # convert dets (tensor or numpy array) to tensor + if isinstance(dets, torch.Tensor): + is_numpy = False + dets_th = dets + elif isinstance(dets, np.ndarray): + is_numpy = True + device = 'cpu' if device_id is None else 'cuda:{}'.format(device_id) + dets_th = torch.from_numpy(dets).to(device) + else: + raise TypeError( + 'dets must be either a Tensor or numpy array, but got {}'.format( + type(dets))) + + # execute cpu or cuda nms + if dets_th.shape[0] == 0: + inds = dets_th.new_zeros(0, dtype=torch.long) + else: + if dets_th.is_cuda: + inds = nms_cuda.nms(dets_th, iou_thr) + else: + inds = nms_cpu.nms(dets_th, iou_thr) + + if is_numpy: + inds = inds.cpu().numpy() + return dets[inds, :], inds + + +def soft_nms(dets, iou_thr, method='linear', sigma=0.5, min_score=1e-3): + if isinstance(dets, torch.Tensor): + is_tensor = True + dets_np = dets.detach().cpu().numpy() + elif isinstance(dets, np.ndarray): + is_tensor = False + dets_np = dets + else: + raise TypeError( + 'dets must be either a Tensor or numpy array, but got {}'.format( + type(dets))) + + method_codes = {'linear': 1, 'gaussian': 2} + if method not in method_codes: + raise ValueError('Invalid method for SoftNMS: {}'.format(method)) + new_dets, inds = soft_nms_cpu( + dets_np, + iou_thr, + method=method_codes[method], + sigma=sigma, + min_score=min_score) + + if is_tensor: + return dets.new_tensor(new_dets), dets.new_tensor( + inds, dtype=torch.long) + else: + return new_dets.astype(np.float32), inds.astype(np.int64) diff --git a/mmdet/ops/nms/src/nms_cpu.cpp b/mmdet/ops/nms/src/nms_cpu.cpp new file mode 100644 index 0000000..f7cffb4 --- /dev/null +++ b/mmdet/ops/nms/src/nms_cpu.cpp @@ -0,0 +1,71 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include + +template +at::Tensor nms_cpu_kernel(const at::Tensor& dets, const float threshold) { + AT_ASSERTM(!dets.type().is_cuda(), "dets must be a CPU tensor"); + + if (dets.numel() == 0) { + return at::empty({0}, dets.options().dtype(at::kLong).device(at::kCPU)); + } + + auto x1_t = dets.select(1, 0).contiguous(); + auto y1_t = dets.select(1, 1).contiguous(); + auto x2_t = dets.select(1, 2).contiguous(); + auto y2_t = dets.select(1, 3).contiguous(); + auto scores = dets.select(1, 4).contiguous(); + + at::Tensor areas_t = (x2_t - x1_t + 1) * (y2_t - y1_t + 1); + + auto order_t = std::get<1>(scores.sort(0, /* descending=*/true)); + + auto ndets = dets.size(0); + at::Tensor suppressed_t = + at::zeros({ndets}, dets.options().dtype(at::kByte).device(at::kCPU)); + + auto suppressed = suppressed_t.data(); + auto order = order_t.data(); + auto x1 = x1_t.data(); + auto y1 = y1_t.data(); + auto x2 = x2_t.data(); + auto y2 = y2_t.data(); + auto areas = areas_t.data(); + + for (int64_t _i = 0; _i < ndets; _i++) { + auto i = order[_i]; + if (suppressed[i] == 1) continue; + auto ix1 = x1[i]; + auto iy1 = y1[i]; + auto ix2 = x2[i]; + auto iy2 = y2[i]; + auto iarea = areas[i]; + + for (int64_t _j = _i + 1; _j < ndets; _j++) { + auto j = order[_j]; + if (suppressed[j] == 1) continue; + auto xx1 = std::max(ix1, x1[j]); + auto yy1 = std::max(iy1, y1[j]); + auto xx2 = std::min(ix2, x2[j]); + auto yy2 = std::min(iy2, y2[j]); + + auto w = std::max(static_cast(0), xx2 - xx1 + 1); + auto h = std::max(static_cast(0), yy2 - yy1 + 1); + auto inter = w * h; + auto ovr = inter / (iarea + areas[j] - inter); + if (ovr >= threshold) suppressed[j] = 1; + } + } + return at::nonzero(suppressed_t == 0).squeeze(1); +} + +at::Tensor nms(const at::Tensor& dets, const float threshold) { + at::Tensor result; + AT_DISPATCH_FLOATING_TYPES(dets.scalar_type(), "nms", [&] { + result = nms_cpu_kernel(dets, threshold); + }); + return result; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("nms", &nms, "non-maximum suppression"); +} \ No newline at end of file diff --git a/mmdet/ops/nms/src/nms_cuda.cpp b/mmdet/ops/nms/src/nms_cuda.cpp new file mode 100644 index 0000000..0ea6f9b --- /dev/null +++ b/mmdet/ops/nms/src/nms_cuda.cpp @@ -0,0 +1,17 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include + +#define CHECK_CUDA(x) AT_CHECK(x.type().is_cuda(), #x, " must be a CUDAtensor ") + +at::Tensor nms_cuda(const at::Tensor boxes, float nms_overlap_thresh); + +at::Tensor nms(const at::Tensor& dets, const float threshold) { + CHECK_CUDA(dets); + if (dets.numel() == 0) + return at::empty({0}, dets.options().dtype(at::kLong).device(at::kCPU)); + return nms_cuda(dets, threshold); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("nms", &nms, "non-maximum suppression"); +} \ No newline at end of file diff --git a/mmdet/ops/nms/src/nms_kernel.cu b/mmdet/ops/nms/src/nms_kernel.cu new file mode 100644 index 0000000..9254f2a --- /dev/null +++ b/mmdet/ops/nms/src/nms_kernel.cu @@ -0,0 +1,131 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include +#include + +#include +#include + +#include +#include + +int const threadsPerBlock = sizeof(unsigned long long) * 8; + +__device__ inline float devIoU(float const * const a, float const * const b) { + float left = max(a[0], b[0]), right = min(a[2], b[2]); + float top = max(a[1], b[1]), bottom = min(a[3], b[3]); + float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f); + float interS = width * height; + float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1); + float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1); + return interS / (Sa + Sb - interS); +} + +__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh, + const float *dev_boxes, unsigned long long *dev_mask) { + const int row_start = blockIdx.y; + const int col_start = blockIdx.x; + + // if (row_start > col_start) return; + + const int row_size = + min(n_boxes - row_start * threadsPerBlock, threadsPerBlock); + const int col_size = + min(n_boxes - col_start * threadsPerBlock, threadsPerBlock); + + __shared__ float block_boxes[threadsPerBlock * 5]; + if (threadIdx.x < col_size) { + block_boxes[threadIdx.x * 5 + 0] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0]; + block_boxes[threadIdx.x * 5 + 1] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1]; + block_boxes[threadIdx.x * 5 + 2] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2]; + block_boxes[threadIdx.x * 5 + 3] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3]; + block_boxes[threadIdx.x * 5 + 4] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4]; + } + __syncthreads(); + + if (threadIdx.x < row_size) { + const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; + const float *cur_box = dev_boxes + cur_box_idx * 5; + int i = 0; + unsigned long long t = 0; + int start = 0; + if (row_start == col_start) { + start = threadIdx.x + 1; + } + for (i = start; i < col_size; i++) { + if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) { + t |= 1ULL << i; + } + } + const int col_blocks = THCCeilDiv(n_boxes, threadsPerBlock); + dev_mask[cur_box_idx * col_blocks + col_start] = t; + } +} + +// boxes is a N x 5 tensor +at::Tensor nms_cuda(const at::Tensor boxes, float nms_overlap_thresh) { + using scalar_t = float; + AT_ASSERTM(boxes.type().is_cuda(), "boxes must be a CUDA tensor"); + auto scores = boxes.select(1, 4); + auto order_t = std::get<1>(scores.sort(0, /* descending=*/true)); + auto boxes_sorted = boxes.index_select(0, order_t); + + int boxes_num = boxes.size(0); + + const int col_blocks = THCCeilDiv(boxes_num, threadsPerBlock); + + scalar_t* boxes_dev = boxes_sorted.data(); + + THCState *state = at::globalContext().lazyInitCUDA(); // TODO replace with getTHCState + + unsigned long long* mask_dev = NULL; + //THCudaCheck(THCudaMalloc(state, (void**) &mask_dev, + // boxes_num * col_blocks * sizeof(unsigned long long))); + + mask_dev = (unsigned long long*) THCudaMalloc(state, boxes_num * col_blocks * sizeof(unsigned long long)); + + dim3 blocks(THCCeilDiv(boxes_num, threadsPerBlock), + THCCeilDiv(boxes_num, threadsPerBlock)); + dim3 threads(threadsPerBlock); + nms_kernel<<>>(boxes_num, + nms_overlap_thresh, + boxes_dev, + mask_dev); + + std::vector mask_host(boxes_num * col_blocks); + THCudaCheck(cudaMemcpy(&mask_host[0], + mask_dev, + sizeof(unsigned long long) * boxes_num * col_blocks, + cudaMemcpyDeviceToHost)); + + std::vector remv(col_blocks); + memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks); + + at::Tensor keep = at::empty({boxes_num}, boxes.options().dtype(at::kLong).device(at::kCPU)); + int64_t* keep_out = keep.data(); + + int num_to_keep = 0; + for (int i = 0; i < boxes_num; i++) { + int nblock = i / threadsPerBlock; + int inblock = i % threadsPerBlock; + + if (!(remv[nblock] & (1ULL << inblock))) { + keep_out[num_to_keep++] = i; + unsigned long long *p = &mask_host[0] + i * col_blocks; + for (int j = nblock; j < col_blocks; j++) { + remv[j] |= p[j]; + } + } + } + + THCudaFree(state, mask_dev); + // TODO improve this part + return std::get<0>(order_t.index({ + keep.narrow(/*dim=*/0, /*start=*/0, /*length=*/num_to_keep).to( + order_t.device(), keep.scalar_type()) + }).sort(0, false)); +} \ No newline at end of file diff --git a/mmdet/ops/nms/src/soft_nms_cpu.pyx b/mmdet/ops/nms/src/soft_nms_cpu.pyx new file mode 100644 index 0000000..97f53f1 --- /dev/null +++ b/mmdet/ops/nms/src/soft_nms_cpu.pyx @@ -0,0 +1,127 @@ +# ---------------------------------------------------------- +# Soft-NMS: Improving Object Detection With One Line of Code +# Copyright (c) University of Maryland, College Park +# Licensed under The MIT License [see LICENSE for details] +# Written by Navaneeth Bodla and Bharat Singh +# Modified by Kai Chen +# ---------------------------------------------------------- + +# cython: language_level=3, boundscheck=False + +import numpy as np +cimport numpy as np + + +cdef inline np.float32_t max(np.float32_t a, np.float32_t b): + return a if a >= b else b + +cdef inline np.float32_t min(np.float32_t a, np.float32_t b): + return a if a <= b else b + + +def soft_nms_cpu( + np.ndarray[float, ndim=2] boxes_in, + float iou_thr, + unsigned int method=1, + float sigma=0.5, + float min_score=0.001, +): + boxes = boxes_in.copy() + cdef int N = boxes.shape[0] + cdef float iw, ih, box_area + cdef float ua + cdef int pos = 0 + cdef float maxscore = 0 + cdef int maxpos = 0 + cdef float x1, x2, y1, y2, tx1, tx2, ty1, ty2, ts, area, weight, ov + inds = np.arange(N) + + for i in range(N): + maxscore = boxes[i, 4] + maxpos = i + + tx1 = boxes[i, 0] + ty1 = boxes[i, 1] + tx2 = boxes[i, 2] + ty2 = boxes[i, 3] + ts = boxes[i, 4] + ti = inds[i] + + pos = i + 1 + # get max box + while pos < N: + if maxscore < boxes[pos, 4]: + maxscore = boxes[pos, 4] + maxpos = pos + pos = pos + 1 + + # add max box as a detection + boxes[i, 0] = boxes[maxpos, 0] + boxes[i, 1] = boxes[maxpos, 1] + boxes[i, 2] = boxes[maxpos, 2] + boxes[i, 3] = boxes[maxpos, 3] + boxes[i, 4] = boxes[maxpos, 4] + inds[i] = inds[maxpos] + + # swap ith box with position of max box + boxes[maxpos, 0] = tx1 + boxes[maxpos, 1] = ty1 + boxes[maxpos, 2] = tx2 + boxes[maxpos, 3] = ty2 + boxes[maxpos, 4] = ts + inds[maxpos] = ti + + tx1 = boxes[i, 0] + ty1 = boxes[i, 1] + tx2 = boxes[i, 2] + ty2 = boxes[i, 3] + ts = boxes[i, 4] + + pos = i + 1 + # NMS iterations, note that N changes if detection boxes fall below + # threshold + while pos < N: + x1 = boxes[pos, 0] + y1 = boxes[pos, 1] + x2 = boxes[pos, 2] + y2 = boxes[pos, 3] + s = boxes[pos, 4] + + area = (x2 - x1 + 1) * (y2 - y1 + 1) + iw = (min(tx2, x2) - max(tx1, x1) + 1) + if iw > 0: + ih = (min(ty2, y2) - max(ty1, y1) + 1) + if ih > 0: + ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih) + ov = iw * ih / ua # iou between max box and detection box + + if method == 1: # linear + if ov > iou_thr: + weight = 1 - ov + else: + weight = 1 + elif method == 2: # gaussian + weight = np.exp(-(ov * ov) / sigma) + else: # original NMS + if ov > iou_thr: + weight = 0 + else: + weight = 1 + + boxes[pos, 4] = weight * boxes[pos, 4] + + # if box score falls below threshold, discard the box by + # swapping with last box update N + if boxes[pos, 4] < min_score: + boxes[pos, 0] = boxes[N-1, 0] + boxes[pos, 1] = boxes[N-1, 1] + boxes[pos, 2] = boxes[N-1, 2] + boxes[pos, 3] = boxes[N-1, 3] + boxes[pos, 4] = boxes[N-1, 4] + inds[pos] = inds[N - 1] + N = N - 1 + pos = pos - 1 + + pos = pos + 1 + + return boxes[:N], inds[:N] diff --git a/mmdet/ops/roi_align/__init__.py b/mmdet/ops/roi_align/__init__.py new file mode 100644 index 0000000..6da9829 --- /dev/null +++ b/mmdet/ops/roi_align/__init__.py @@ -0,0 +1,3 @@ +from .roi_align import RoIAlign, roi_align + +__all__ = ['roi_align', 'RoIAlign'] diff --git a/mmdet/ops/roi_align/gradcheck.py b/mmdet/ops/roi_align/gradcheck.py new file mode 100644 index 0000000..136456b --- /dev/null +++ b/mmdet/ops/roi_align/gradcheck.py @@ -0,0 +1,30 @@ +import os.path as osp +import sys + +import numpy as np +import torch +from torch.autograd import gradcheck + +sys.path.append(osp.abspath(osp.join(__file__, '../../'))) +from roi_align import RoIAlign # noqa: E402, isort:skip + +feat_size = 15 +spatial_scale = 1.0 / 8 +img_size = feat_size / spatial_scale +num_imgs = 2 +num_rois = 20 + +batch_ind = np.random.randint(num_imgs, size=(num_rois, 1)) +rois = np.random.rand(num_rois, 4) * img_size * 0.5 +rois[:, 2:] += img_size * 0.5 +rois = np.hstack((batch_ind, rois)) + +feat = torch.randn( + num_imgs, 16, feat_size, feat_size, requires_grad=True, device='cuda:0') +rois = torch.from_numpy(rois).float().cuda() +inputs = (feat, rois) +print('Gradcheck for roi align...') +test = gradcheck(RoIAlign(3, spatial_scale), inputs, atol=1e-3, eps=1e-3) +print(test) +test = gradcheck(RoIAlign(3, spatial_scale, 2), inputs, atol=1e-3, eps=1e-3) +print(test) diff --git a/mmdet/ops/roi_align/roi_align.py b/mmdet/ops/roi_align/roi_align.py new file mode 100644 index 0000000..a4cf244 --- /dev/null +++ b/mmdet/ops/roi_align/roi_align.py @@ -0,0 +1,87 @@ +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.modules.utils import _pair + +from . import roi_align_cuda + + +class RoIAlignFunction(Function): + + @staticmethod + def forward(ctx, features, rois, out_size, spatial_scale, sample_num=0): + out_h, out_w = _pair(out_size) + assert isinstance(out_h, int) and isinstance(out_w, int) + ctx.spatial_scale = spatial_scale + ctx.sample_num = sample_num + ctx.save_for_backward(rois) + ctx.feature_size = features.size() + + batch_size, num_channels, data_height, data_width = features.size() + num_rois = rois.size(0) + + output = features.new_zeros(num_rois, num_channels, out_h, out_w) + if features.is_cuda: + roi_align_cuda.forward(features, rois, out_h, out_w, spatial_scale, + sample_num, output) + else: + raise NotImplementedError + + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + feature_size = ctx.feature_size + spatial_scale = ctx.spatial_scale + sample_num = ctx.sample_num + rois = ctx.saved_tensors[0] + assert (feature_size is not None and grad_output.is_cuda) + + batch_size, num_channels, data_height, data_width = feature_size + out_w = grad_output.size(3) + out_h = grad_output.size(2) + + grad_input = grad_rois = None + if ctx.needs_input_grad[0]: + grad_input = rois.new_zeros(batch_size, num_channels, data_height, + data_width) + roi_align_cuda.backward(grad_output.contiguous(), rois, out_h, + out_w, spatial_scale, sample_num, + grad_input) + + return grad_input, grad_rois, None, None, None + + +roi_align = RoIAlignFunction.apply + + +class RoIAlign(nn.Module): + + def __init__(self, + out_size, + spatial_scale, + sample_num=0, + use_torchvision=False): + super(RoIAlign, self).__init__() + + self.out_size = _pair(out_size) + self.spatial_scale = float(spatial_scale) + self.sample_num = int(sample_num) + self.use_torchvision = use_torchvision + + def forward(self, features, rois): + if self.use_torchvision: + from torchvision.ops import roi_align as tv_roi_align + return tv_roi_align(features, rois, self.out_size, + self.spatial_scale, self.sample_num) + else: + return roi_align(features, rois, self.out_size, self.spatial_scale, + self.sample_num) + + def __repr__(self): + format_str = self.__class__.__name__ + format_str += '(out_size={}, spatial_scale={}, sample_num={}'.format( + self.out_size, self.spatial_scale, self.sample_num) + format_str += ', use_torchvision={})'.format(self.use_torchvision) + return format_str diff --git a/mmdet/ops/roi_align/src/roi_align_cuda.cpp b/mmdet/ops/roi_align/src/roi_align_cuda.cpp new file mode 100644 index 0000000..06a73aa --- /dev/null +++ b/mmdet/ops/roi_align/src/roi_align_cuda.cpp @@ -0,0 +1,85 @@ +#include + +#include +#include + +int ROIAlignForwardLaucher(const at::Tensor features, const at::Tensor rois, + const float spatial_scale, const int sample_num, + const int channels, const int height, + const int width, const int num_rois, + const int pooled_height, const int pooled_width, + at::Tensor output); + +int ROIAlignBackwardLaucher(const at::Tensor top_grad, const at::Tensor rois, + const float spatial_scale, const int sample_num, + const int channels, const int height, + const int width, const int num_rois, + const int pooled_height, const int pooled_width, + at::Tensor bottom_grad); + +#define CHECK_CUDA(x) AT_CHECK(x.type().is_cuda(), #x, " must be a CUDAtensor ") +#define CHECK_CONTIGUOUS(x) \ + AT_CHECK(x.is_contiguous(), #x, " must be contiguous ") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +int roi_align_forward_cuda(at::Tensor features, at::Tensor rois, + int pooled_height, int pooled_width, + float spatial_scale, int sample_num, + at::Tensor output) { + CHECK_INPUT(features); + CHECK_INPUT(rois); + CHECK_INPUT(output); + + // Number of ROIs + int num_rois = rois.size(0); + int size_rois = rois.size(1); + + if (size_rois != 5) { + printf("wrong roi size\n"); + return 0; + } + + int num_channels = features.size(1); + int data_height = features.size(2); + int data_width = features.size(3); + + ROIAlignForwardLaucher(features, rois, spatial_scale, sample_num, + num_channels, data_height, data_width, num_rois, + pooled_height, pooled_width, output); + + return 1; +} + +int roi_align_backward_cuda(at::Tensor top_grad, at::Tensor rois, + int pooled_height, int pooled_width, + float spatial_scale, int sample_num, + at::Tensor bottom_grad) { + CHECK_INPUT(top_grad); + CHECK_INPUT(rois); + CHECK_INPUT(bottom_grad); + + // Number of ROIs + int num_rois = rois.size(0); + int size_rois = rois.size(1); + if (size_rois != 5) { + printf("wrong roi size\n"); + return 0; + } + + int num_channels = bottom_grad.size(1); + int data_height = bottom_grad.size(2); + int data_width = bottom_grad.size(3); + + ROIAlignBackwardLaucher(top_grad, rois, spatial_scale, sample_num, + num_channels, data_height, data_width, num_rois, + pooled_height, pooled_width, bottom_grad); + + return 1; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &roi_align_forward_cuda, "Roi_Align forward (CUDA)"); + m.def("backward", &roi_align_backward_cuda, "Roi_Align backward (CUDA)"); +} diff --git a/mmdet/ops/roi_align/src/roi_align_kernel.cu b/mmdet/ops/roi_align/src/roi_align_kernel.cu new file mode 100644 index 0000000..6d3b279 --- /dev/null +++ b/mmdet/ops/roi_align/src/roi_align_kernel.cu @@ -0,0 +1,294 @@ +#include +#include + +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + +#define THREADS_PER_BLOCK 1024 + +inline int GET_BLOCKS(const int N) { + int optimal_block_num = (N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK; + int max_block_num = 65000; + return min(optimal_block_num, max_block_num); +} + +template +__device__ scalar_t bilinear_interpolate(const scalar_t *bottom_data, + const int height, const int width, + scalar_t y, scalar_t x) { + // deal with cases that inverse elements are out of feature map boundary + if (y < -1.0 || y > height || x < -1.0 || x > width) { + return 0; + } + + if (y <= 0) y = 0; + if (x <= 0) x = 0; + + int y_low = (int)y; + int x_low = (int)x; + int y_high; + int x_high; + + if (y_low >= height - 1) { + y_high = y_low = height - 1; + y = (scalar_t)y_low; + } else { + y_high = y_low + 1; + } + + if (x_low >= width - 1) { + x_high = x_low = width - 1; + x = (scalar_t)x_low; + } else { + x_high = x_low + 1; + } + + scalar_t ly = y - y_low; + scalar_t lx = x - x_low; + scalar_t hy = 1. - ly; + scalar_t hx = 1. - lx; + // do bilinear interpolation + scalar_t lt = bottom_data[y_low * width + x_low]; + scalar_t rt = bottom_data[y_low * width + x_high]; + scalar_t lb = bottom_data[y_high * width + x_low]; + scalar_t rb = bottom_data[y_high * width + x_high]; + scalar_t w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx; + + scalar_t val = (w1 * lt + w2 * rt + w3 * lb + w4 * rb); + + return val; +} + +template +__global__ void ROIAlignForward(const int nthreads, const scalar_t *bottom_data, + const scalar_t *bottom_rois, + const scalar_t spatial_scale, + const int sample_num, const int channels, + const int height, const int width, + const int pooled_height, const int pooled_width, + scalar_t *top_data) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the aligned output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + const scalar_t *offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + scalar_t roi_start_w = offset_bottom_rois[1] * spatial_scale; + scalar_t roi_start_h = offset_bottom_rois[2] * spatial_scale; + scalar_t roi_end_w = (offset_bottom_rois[3] + 1) * spatial_scale; + scalar_t roi_end_h = (offset_bottom_rois[4] + 1) * spatial_scale; + + // Force malformed ROIs to be 1x1 + scalar_t roi_width = fmaxf((scalar_t)roi_end_w - roi_start_w, 0.); + scalar_t roi_height = fmaxf((scalar_t)roi_end_h - roi_start_h, 0.); + + scalar_t bin_size_h = roi_height / pooled_height; + scalar_t bin_size_w = roi_width / pooled_width; + + const scalar_t *offset_bottom_data = + bottom_data + (roi_batch_ind * channels + c) * height * width; + + int sample_num_h = (sample_num > 0) + ? sample_num + : ceil(roi_height / pooled_height); // e.g., = 2 + int sample_num_w = + (sample_num > 0) ? sample_num : ceil(roi_width / pooled_width); + + scalar_t h = (scalar_t)(ph + 0.5) * bin_size_h + roi_start_h; + scalar_t w = (scalar_t)(pw + 0.5) * bin_size_w + roi_start_w; + + int hstart = fminf(floor(h), height - 2); + int wstart = fminf(floor(w), width - 2); + + scalar_t output_val = 0; + for (int iy = 0; iy < sample_num_h; iy++) { + const scalar_t y = roi_start_h + ph * bin_size_h + + (scalar_t)(iy + scalar_t(.5f)) * bin_size_h / + (scalar_t)(sample_num_h); + for (int ix = 0; ix < sample_num_w; ix++) { + const scalar_t x = roi_start_w + pw * bin_size_w + + (scalar_t)(ix + scalar_t(.5f)) * bin_size_w / + (scalar_t)(sample_num_w); + scalar_t val = bilinear_interpolate(offset_bottom_data, + height, width, y, x); + output_val += val; + } + } + output_val /= (sample_num_h * sample_num_w); + top_data[index] = output_val; + } +} + +int ROIAlignForwardLaucher(const at::Tensor features, const at::Tensor rois, + const float spatial_scale, const int sample_num, + const int channels, const int height, + const int width, const int num_rois, + const int pooled_height, const int pooled_width, + at::Tensor output) { + const int output_size = num_rois * pooled_height * pooled_width * channels; + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + features.scalar_type(), "ROIAlignLaucherForward", ([&] { + const scalar_t *bottom_data = features.data(); + const scalar_t *rois_data = rois.data(); + scalar_t *top_data = output.data(); + + ROIAlignForward + <<>>( + output_size, bottom_data, rois_data, scalar_t(spatial_scale), + sample_num, channels, height, width, pooled_height, + pooled_width, top_data); + })); + THCudaCheck(cudaGetLastError()); + return 1; +} + +template +__device__ void bilinear_interpolate_gradient(const int height, const int width, + scalar_t y, scalar_t x, + scalar_t &w1, scalar_t &w2, + scalar_t &w3, scalar_t &w4, + int &x_low, int &x_high, + int &y_low, int &y_high) { + // deal with cases that inverse elements are out of feature map boundary + if (y < -1.0 || y > height || x < -1.0 || x > width) { + w1 = w2 = w3 = w4 = 0.; + x_low = x_high = y_low = y_high = -1; + return; + } + + if (y <= 0) y = 0; + if (x <= 0) x = 0; + + y_low = (int)y; + x_low = (int)x; + + if (y_low >= height - 1) { + y_high = y_low = height - 1; + y = (scalar_t)y_low; + } else { + y_high = y_low + 1; + } + + if (x_low >= width - 1) { + x_high = x_low = width - 1; + x = (scalar_t)x_low; + } else { + x_high = x_low + 1; + } + + scalar_t ly = y - y_low; + scalar_t lx = x - x_low; + scalar_t hy = 1. - ly; + scalar_t hx = 1. - lx; + + w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx; + + return; +} + +template +__global__ void ROIAlignBackward( + const int nthreads, const scalar_t *top_diff, const scalar_t *bottom_rois, + const scalar_t spatial_scale, const int sample_num, const int channels, + const int height, const int width, const int pooled_height, + const int pooled_width, scalar_t *bottom_diff) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the aligned output + int pw = index % pooled_width; + int ph = (index / pooled_width) % pooled_height; + int c = (index / pooled_width / pooled_height) % channels; + int n = index / pooled_width / pooled_height / channels; + + const scalar_t *offset_bottom_rois = bottom_rois + n * 5; + int roi_batch_ind = offset_bottom_rois[0]; + scalar_t roi_start_w = offset_bottom_rois[1] * spatial_scale; + scalar_t roi_start_h = offset_bottom_rois[2] * spatial_scale; + scalar_t roi_end_w = (offset_bottom_rois[3] + 1) * spatial_scale; + scalar_t roi_end_h = (offset_bottom_rois[4] + 1) * spatial_scale; + + // Force malformed ROIs to be 1x1 + scalar_t roi_width = fmaxf((scalar_t)roi_end_w - roi_start_w, 0.); + scalar_t roi_height = fmaxf((scalar_t)roi_end_h - roi_start_h, 0.); + + scalar_t bin_size_h = roi_height / pooled_height; + scalar_t bin_size_w = roi_width / pooled_width; + + scalar_t *offset_bottom_diff = + bottom_diff + (roi_batch_ind * channels + c) * height * width; + int offset_top = (n * channels + c) * pooled_height * pooled_width + + ph * pooled_width + pw; + scalar_t offset_top_diff = top_diff[offset_top]; + + int sample_num_h = (sample_num > 0) + ? sample_num + : ceil(roi_height / pooled_height); // e.g., = 2 + int sample_num_w = + (sample_num > 0) ? sample_num : ceil(roi_width / pooled_width); + + const scalar_t count = (scalar_t)(sample_num_h * sample_num_w); + + scalar_t h = (scalar_t)(ph + 0.5) * bin_size_h + roi_start_h; + scalar_t w = (scalar_t)(pw + 0.5) * bin_size_w + roi_start_w; + + int hstart = fminf(floor(h), height - 2); + int wstart = fminf(floor(w), width - 2); + + for (int iy = 0; iy < sample_num_h; iy++) { + const scalar_t y = + roi_start_h + ph * bin_size_h + + (scalar_t)(iy + .5f) * bin_size_h / (scalar_t)(sample_num_h); + for (int ix = 0; ix < sample_num_w; ix++) { + const scalar_t x = + roi_start_w + pw * bin_size_w + + (scalar_t)(ix + .5f) * bin_size_w / (scalar_t)(sample_num_w); + scalar_t w1, w2, w3, w4; + int x_low, x_high, y_low, y_high; + + bilinear_interpolate_gradient( + height, width, y, x, w1, w2, w3, w4, x_low, x_high, y_low, y_high); + scalar_t g1 = offset_top_diff * w1 / count; + scalar_t g2 = offset_top_diff * w2 / count; + scalar_t g3 = offset_top_diff * w3 / count; + scalar_t g4 = offset_top_diff * w4 / count; + if (x_low >= 0 && x_high >= 0 && y_low >= 0 && y_high >= 0) { + atomicAdd(offset_bottom_diff + y_low * width + x_low, g1); + atomicAdd(offset_bottom_diff + y_low * width + x_high, g2); + atomicAdd(offset_bottom_diff + y_high * width + x_low, g3); + atomicAdd(offset_bottom_diff + y_high * width + x_high, g4); + } + } + } + } +} + +int ROIAlignBackwardLaucher(const at::Tensor top_grad, const at::Tensor rois, + const float spatial_scale, const int sample_num, + const int channels, const int height, + const int width, const int num_rois, + const int pooled_height, const int pooled_width, + at::Tensor bottom_grad) { + const int output_size = num_rois * pooled_height * pooled_width * channels; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + top_grad.scalar_type(), "ROIAlignLaucherBackward", ([&] { + const scalar_t *top_diff = top_grad.data(); + const scalar_t *rois_data = rois.data(); + scalar_t *bottom_diff = bottom_grad.data(); + if (sizeof(scalar_t) == sizeof(double)) { + fprintf(stderr, "double is not supported\n"); + exit(-1); + } + + ROIAlignBackward + <<>>( + output_size, top_diff, rois_data, spatial_scale, sample_num, + channels, height, width, pooled_height, pooled_width, + bottom_diff); + })); + THCudaCheck(cudaGetLastError()); + return 1; +} diff --git a/mmdet/ops/roi_pool/__init__.py b/mmdet/ops/roi_pool/__init__.py new file mode 100644 index 0000000..9f0474e --- /dev/null +++ b/mmdet/ops/roi_pool/__init__.py @@ -0,0 +1,3 @@ +from .roi_pool import RoIPool, roi_pool + +__all__ = ['roi_pool', 'RoIPool'] diff --git a/mmdet/ops/roi_pool/gradcheck.py b/mmdet/ops/roi_pool/gradcheck.py new file mode 100644 index 0000000..d11af79 --- /dev/null +++ b/mmdet/ops/roi_pool/gradcheck.py @@ -0,0 +1,16 @@ +import os.path as osp +import sys + +import torch +from torch.autograd import gradcheck + +sys.path.append(osp.abspath(osp.join(__file__, '../../'))) +from roi_pool import RoIPool # noqa: E402, isort:skip + +feat = torch.randn(4, 16, 15, 15, requires_grad=True).cuda() +rois = torch.Tensor([[0, 0, 0, 50, 50], [0, 10, 30, 43, 55], + [1, 67, 40, 110, 120]]).cuda() +inputs = (feat, rois) +print('Gradcheck for roi pooling...') +test = gradcheck(RoIPool(4, 1.0 / 8), inputs, eps=1e-5, atol=1e-3) +print(test) diff --git a/mmdet/ops/roi_pool/roi_pool.py b/mmdet/ops/roi_pool/roi_pool.py new file mode 100644 index 0000000..26d900f --- /dev/null +++ b/mmdet/ops/roi_pool/roi_pool.py @@ -0,0 +1,75 @@ +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.nn.modules.utils import _pair + +from . import roi_pool_cuda + + +class RoIPoolFunction(Function): + + @staticmethod + def forward(ctx, features, rois, out_size, spatial_scale): + assert features.is_cuda + out_h, out_w = _pair(out_size) + assert isinstance(out_h, int) and isinstance(out_w, int) + ctx.save_for_backward(rois) + num_channels = features.size(1) + num_rois = rois.size(0) + out_size = (num_rois, num_channels, out_h, out_w) + output = features.new_zeros(out_size) + argmax = features.new_zeros(out_size, dtype=torch.int) + roi_pool_cuda.forward(features, rois, out_h, out_w, spatial_scale, + output, argmax) + ctx.spatial_scale = spatial_scale + ctx.feature_size = features.size() + ctx.argmax = argmax + + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + assert grad_output.is_cuda + spatial_scale = ctx.spatial_scale + feature_size = ctx.feature_size + argmax = ctx.argmax + rois = ctx.saved_tensors[0] + assert feature_size is not None + + grad_input = grad_rois = None + if ctx.needs_input_grad[0]: + grad_input = grad_output.new_zeros(feature_size) + roi_pool_cuda.backward(grad_output.contiguous(), rois, argmax, + spatial_scale, grad_input) + + return grad_input, grad_rois, None, None + + +roi_pool = RoIPoolFunction.apply + + +class RoIPool(nn.Module): + + def __init__(self, out_size, spatial_scale, use_torchvision=False): + super(RoIPool, self).__init__() + + self.out_size = _pair(out_size) + self.spatial_scale = float(spatial_scale) + self.use_torchvision = use_torchvision + + def forward(self, features, rois): + if self.use_torchvision: + from torchvision.ops import roi_pool as tv_roi_pool + return tv_roi_pool(features, rois, self.out_size, + self.spatial_scale) + else: + return roi_pool(features, rois, self.out_size, self.spatial_scale) + + def __repr__(self): + format_str = self.__class__.__name__ + format_str += '(out_size={}, spatial_scale={}'.format( + self.out_size, self.spatial_scale) + format_str += ', use_torchvision={})'.format(self.use_torchvision) + return format_str diff --git a/mmdet/ops/roi_pool/src/roi_pool_cuda.cpp b/mmdet/ops/roi_pool/src/roi_pool_cuda.cpp new file mode 100644 index 0000000..84c4e4b --- /dev/null +++ b/mmdet/ops/roi_pool/src/roi_pool_cuda.cpp @@ -0,0 +1,86 @@ +#include + +#include +#include + +int ROIPoolForwardLaucher(const at::Tensor features, const at::Tensor rois, + const float spatial_scale, const int channels, + const int height, const int width, const int num_rois, + const int pooled_h, const int pooled_w, + at::Tensor output, at::Tensor argmax); + +int ROIPoolBackwardLaucher(const at::Tensor top_grad, const at::Tensor rois, + const at::Tensor argmax, const float spatial_scale, + const int batch_size, const int channels, + const int height, const int width, + const int num_rois, const int pooled_h, + const int pooled_w, at::Tensor bottom_grad); + +#define CHECK_CUDA(x) AT_CHECK(x.type().is_cuda(), #x, " must be a CUDAtensor ") +#define CHECK_CONTIGUOUS(x) \ + AT_CHECK(x.is_contiguous(), #x, " must be contiguous ") +#define CHECK_INPUT(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) + +int roi_pooling_forward_cuda(at::Tensor features, at::Tensor rois, + int pooled_height, int pooled_width, + float spatial_scale, at::Tensor output, + at::Tensor argmax) { + CHECK_INPUT(features); + CHECK_INPUT(rois); + CHECK_INPUT(output); + CHECK_INPUT(argmax); + + // Number of ROIs + int num_rois = rois.size(0); + int size_rois = rois.size(1); + + if (size_rois != 5) { + printf("wrong roi size\n"); + return 0; + } + + int channels = features.size(1); + int height = features.size(2); + int width = features.size(3); + + ROIPoolForwardLaucher(features, rois, spatial_scale, channels, height, width, + num_rois, pooled_height, pooled_width, output, argmax); + + return 1; +} + +int roi_pooling_backward_cuda(at::Tensor top_grad, at::Tensor rois, + at::Tensor argmax, float spatial_scale, + at::Tensor bottom_grad) { + CHECK_INPUT(top_grad); + CHECK_INPUT(rois); + CHECK_INPUT(argmax); + CHECK_INPUT(bottom_grad); + + int pooled_height = top_grad.size(2); + int pooled_width = top_grad.size(3); + int num_rois = rois.size(0); + int size_rois = rois.size(1); + + if (size_rois != 5) { + printf("wrong roi size\n"); + return 0; + } + int batch_size = bottom_grad.size(0); + int channels = bottom_grad.size(1); + int height = bottom_grad.size(2); + int width = bottom_grad.size(3); + + ROIPoolBackwardLaucher(top_grad, rois, argmax, spatial_scale, batch_size, + channels, height, width, num_rois, pooled_height, + pooled_width, bottom_grad); + + return 1; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &roi_pooling_forward_cuda, "Roi_Pooling forward (CUDA)"); + m.def("backward", &roi_pooling_backward_cuda, "Roi_Pooling backward (CUDA)"); +} diff --git a/mmdet/ops/roi_pool/src/roi_pool_kernel.cu b/mmdet/ops/roi_pool/src/roi_pool_kernel.cu new file mode 100644 index 0000000..25ba985 --- /dev/null +++ b/mmdet/ops/roi_pool/src/roi_pool_kernel.cu @@ -0,0 +1,156 @@ +#include +#include + +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + +#define THREADS_PER_BLOCK 1024 + +inline int GET_BLOCKS(const int N) { + int optimal_block_num = (N + THREADS_PER_BLOCK - 1) / THREADS_PER_BLOCK; + int max_block_num = 65000; + return min(optimal_block_num, max_block_num); +} + +template +__global__ void ROIPoolForward(const int nthreads, const scalar_t *bottom_data, + const scalar_t *rois, + const scalar_t spatial_scale, const int channels, + const int height, const int width, + const int pooled_h, const int pooled_w, + scalar_t *top_data, int *argmax_data) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + // (n, c, ph, pw) is an element in the pooled output + int pw = index % pooled_w; + int ph = (index / pooled_w) % pooled_h; + int c = (index / pooled_w / pooled_h) % channels; + int n = index / pooled_w / pooled_h / channels; + + const scalar_t *offset_rois = rois + n * 5; + int roi_batch_ind = offset_rois[0]; + // calculate the roi region on feature maps + scalar_t roi_x1 = offset_rois[1] * spatial_scale; + scalar_t roi_y1 = offset_rois[2] * spatial_scale; + scalar_t roi_x2 = (offset_rois[3] + 1) * spatial_scale; + scalar_t roi_y2 = (offset_rois[4] + 1) * spatial_scale; + + // force malformed rois to be 1x1 + scalar_t roi_w = roi_x2 - roi_x1; + scalar_t roi_h = roi_y2 - roi_y1; + if (roi_w <= 0 || roi_h <= 0) continue; + + scalar_t bin_size_w = roi_w / static_cast(pooled_w); + scalar_t bin_size_h = roi_h / static_cast(pooled_h); + + // the corresponding bin region + int bin_x1 = floor(static_cast(pw) * bin_size_w + roi_x1); + int bin_y1 = floor(static_cast(ph) * bin_size_h + roi_y1); + int bin_x2 = ceil(static_cast(pw + 1) * bin_size_w + roi_x1); + int bin_y2 = ceil(static_cast(ph + 1) * bin_size_h + roi_y1); + + // add roi offsets and clip to input boundaries + bin_x1 = min(max(bin_x1, 0), width); + bin_y1 = min(max(bin_y1, 0), height); + bin_x2 = min(max(bin_x2, 0), width); + bin_y2 = min(max(bin_y2, 0), height); + bool is_empty = (bin_y2 <= bin_y1) || (bin_x2 <= bin_x1); + + // If nothing is pooled, argmax = -1 causes nothing to be backprop'd + int max_idx = -1; + bottom_data += (roi_batch_ind * channels + c) * height * width; + + // Define an empty pooling region to be zero + scalar_t max_val = is_empty ? static_cast(0) + : bottom_data[bin_y1 * width + bin_x1] - 1; + + for (int h = bin_y1; h < bin_y2; ++h) { + for (int w = bin_x1; w < bin_x2; ++w) { + int offset = h * width + w; + if (bottom_data[offset] > max_val) { + max_val = bottom_data[offset]; + max_idx = offset; + } + } + } + top_data[index] = max_val; + if (argmax_data != NULL) argmax_data[index] = max_idx; + } +} + +int ROIPoolForwardLaucher(const at::Tensor features, const at::Tensor rois, + const float spatial_scale, const int channels, + const int height, const int width, const int num_rois, + const int pooled_h, const int pooled_w, + at::Tensor output, at::Tensor argmax) { + const int output_size = num_rois * channels * pooled_h * pooled_w; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + features.scalar_type(), "ROIPoolLaucherForward", ([&] { + const scalar_t *bottom_data = features.data(); + const scalar_t *rois_data = rois.data(); + scalar_t *top_data = output.data(); + int *argmax_data = argmax.data(); + + ROIPoolForward + <<>>( + output_size, bottom_data, rois_data, scalar_t(spatial_scale), + channels, height, width, pooled_h, pooled_w, top_data, + argmax_data); + })); + THCudaCheck(cudaGetLastError()); + return 1; +} + +template +__global__ void ROIPoolBackward(const int nthreads, const scalar_t *top_diff, + const scalar_t *rois, const int *argmax_data, + const scalar_t spatial_scale, + const int channels, const int height, + const int width, const int pooled_h, + const int pooled_w, scalar_t *bottom_diff) { + CUDA_1D_KERNEL_LOOP(index, nthreads) { + int pw = index % pooled_w; + int ph = (index / pooled_w) % pooled_h; + int c = (index / pooled_w / pooled_h) % channels; + int n = index / pooled_w / pooled_h / channels; + + int roi_batch_ind = rois[n * 5]; + int bottom_index = argmax_data[(n * channels + c) * pooled_h * pooled_w + + ph * pooled_w + pw]; + + atomicAdd(bottom_diff + (roi_batch_ind * channels + c) * height * width + + bottom_index, + top_diff[index]); + } +} + +int ROIPoolBackwardLaucher(const at::Tensor top_grad, const at::Tensor rois, + const at::Tensor argmax, const float spatial_scale, + const int batch_size, const int channels, + const int height, const int width, + const int num_rois, const int pooled_h, + const int pooled_w, at::Tensor bottom_grad) { + const int output_size = num_rois * pooled_h * pooled_w * channels; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + top_grad.scalar_type(), "ROIPoolLaucherBackward", ([&] { + const scalar_t *top_diff = top_grad.data(); + const scalar_t *rois_data = rois.data(); + const int *argmax_data = argmax.data(); + scalar_t *bottom_diff = bottom_grad.data(); + + if (sizeof(scalar_t) == sizeof(double)) { + fprintf(stderr, "double is not supported\n"); + exit(-1); + } + + ROIPoolBackward + <<>>( + output_size, top_diff, rois_data, argmax_data, + scalar_t(spatial_scale), channels, height, width, pooled_h, + pooled_w, bottom_diff); + })); + THCudaCheck(cudaGetLastError()); + return 1; +} diff --git a/mmdet/ops/sigmoid_focal_loss/__init__.py b/mmdet/ops/sigmoid_focal_loss/__init__.py new file mode 100644 index 0000000..a936cb3 --- /dev/null +++ b/mmdet/ops/sigmoid_focal_loss/__init__.py @@ -0,0 +1,3 @@ +from .sigmoid_focal_loss import SigmoidFocalLoss, sigmoid_focal_loss + +__all__ = ['SigmoidFocalLoss', 'sigmoid_focal_loss'] diff --git a/mmdet/ops/sigmoid_focal_loss/sigmoid_focal_loss.py b/mmdet/ops/sigmoid_focal_loss/sigmoid_focal_loss.py new file mode 100644 index 0000000..8298f43 --- /dev/null +++ b/mmdet/ops/sigmoid_focal_loss/sigmoid_focal_loss.py @@ -0,0 +1,54 @@ +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable + +from . import sigmoid_focal_loss_cuda + + +class SigmoidFocalLossFunction(Function): + + @staticmethod + def forward(ctx, input, target, gamma=2.0, alpha=0.25): + ctx.save_for_backward(input, target) + num_classes = input.shape[1] + ctx.num_classes = num_classes + ctx.gamma = gamma + ctx.alpha = alpha + + loss = sigmoid_focal_loss_cuda.forward(input, target, num_classes, + gamma, alpha) + return loss + + @staticmethod + @once_differentiable + def backward(ctx, d_loss): + input, target = ctx.saved_tensors + num_classes = ctx.num_classes + gamma = ctx.gamma + alpha = ctx.alpha + d_loss = d_loss.contiguous() + d_input = sigmoid_focal_loss_cuda.backward(input, target, d_loss, + num_classes, gamma, alpha) + return d_input, None, None, None, None + + +sigmoid_focal_loss = SigmoidFocalLossFunction.apply + + +# TODO: remove this module +class SigmoidFocalLoss(nn.Module): + + def __init__(self, gamma, alpha): + super(SigmoidFocalLoss, self).__init__() + self.gamma = gamma + self.alpha = alpha + + def forward(self, logits, targets): + assert logits.is_cuda + loss = sigmoid_focal_loss(logits, targets, self.gamma, self.alpha) + return loss.sum() + + def __repr__(self): + tmpstr = self.__class__.__name__ + '(gamma={}, alpha={})'.format( + self.gamma, self.alpha) + return tmpstr diff --git a/mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss.cpp b/mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss.cpp new file mode 100644 index 0000000..b5fef27 --- /dev/null +++ b/mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss.cpp @@ -0,0 +1,45 @@ +// modify from +// https://github.com/facebookresearch/maskrcnn-benchmark/blob/master/maskrcnn_benchmark/csrc/SigmoidFocalLoss.h +#include + +at::Tensor SigmoidFocalLoss_forward_cuda(const at::Tensor &logits, + const at::Tensor &targets, + const int num_classes, + const float gamma, const float alpha); + +at::Tensor SigmoidFocalLoss_backward_cuda(const at::Tensor &logits, + const at::Tensor &targets, + const at::Tensor &d_losses, + const int num_classes, + const float gamma, const float alpha); + +// Interface for Python +at::Tensor SigmoidFocalLoss_forward(const at::Tensor &logits, + const at::Tensor &targets, + const int num_classes, const float gamma, + const float alpha) { + if (logits.type().is_cuda()) { + return SigmoidFocalLoss_forward_cuda(logits, targets, num_classes, gamma, + alpha); + } + AT_ERROR("SigmoidFocalLoss is not implemented on the CPU"); +} + +at::Tensor SigmoidFocalLoss_backward(const at::Tensor &logits, + const at::Tensor &targets, + const at::Tensor &d_losses, + const int num_classes, const float gamma, + const float alpha) { + if (logits.type().is_cuda()) { + return SigmoidFocalLoss_backward_cuda(logits, targets, d_losses, + num_classes, gamma, alpha); + } + AT_ERROR("SigmoidFocalLoss is not implemented on the CPU"); +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("forward", &SigmoidFocalLoss_forward, + "SigmoidFocalLoss forward (CUDA)"); + m.def("backward", &SigmoidFocalLoss_backward, + "SigmoidFocalLoss backward (CUDA)"); +} diff --git a/mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss_cuda.cu b/mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss_cuda.cu new file mode 100644 index 0000000..6a9104c --- /dev/null +++ b/mmdet/ops/sigmoid_focal_loss/src/sigmoid_focal_loss_cuda.cu @@ -0,0 +1,171 @@ +// modified from +// https://github.com/facebookresearch/maskrcnn-benchmark/blob/master/maskrcnn_benchmark/csrc/cuda/SigmoidFocalLoss_cuda.cu + +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +// This file is modified from +// https://github.com/pytorch/pytorch/blob/master/modules/detectron/sigmoid_focal_loss_op.cu +// Cheng-Yang Fu +// cyfu@cs.unc.edu +#include +#include + +#include +#include +#include + +#include + +// TODO make it in a common file +#define CUDA_1D_KERNEL_LOOP(i, n) \ + for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < n; \ + i += blockDim.x * gridDim.x) + +template +__global__ void SigmoidFocalLossForward(const int nthreads, + const scalar_t *logits, + const int64_t *targets, + const int num_classes, + const float gamma, const float alpha, + const int num, scalar_t *losses) { + CUDA_1D_KERNEL_LOOP(i, nthreads) { + int n = i / num_classes; + int d = i % num_classes; // current class[0~79]; + int t = targets[n]; // target class [1~80]; + + // Decide it is positive or negative case. + scalar_t c1 = (t == (d + 1)); + scalar_t c2 = (t >= 0 & t != (d + 1)); + + scalar_t zn = (1.0 - alpha); + scalar_t zp = (alpha); + + // p = 1. / 1. + expf(-x); p = sigmoid(x) + scalar_t p = 1. / (1. + expf(-logits[i])); + + // (1-p)**gamma * log(p) where + scalar_t term1 = powf((1. - p), gamma) * logf(max(p, FLT_MIN)); + + // p**gamma * log(1-p) + scalar_t term2 = + powf(p, gamma) * + (-1. * logits[i] * (logits[i] >= 0) - + logf(1. + expf(logits[i] - 2. * logits[i] * (logits[i] >= 0)))); + + losses[i] = 0.0; + losses[i] += -c1 * term1 * zp; + losses[i] += -c2 * term2 * zn; + + } // CUDA_1D_KERNEL_LOOP +} // SigmoidFocalLossForward + +template +__global__ void SigmoidFocalLossBackward( + const int nthreads, const scalar_t *logits, const int64_t *targets, + const scalar_t *d_losses, const int num_classes, const float gamma, + const float alpha, const int num, scalar_t *d_logits) { + CUDA_1D_KERNEL_LOOP(i, nthreads) { + int n = i / num_classes; + int d = i % num_classes; // current class[0~79]; + int t = targets[n]; // target class [1~80], 0 is background; + + // Decide it is positive or negative case. + scalar_t c1 = (t == (d + 1)); + scalar_t c2 = (t >= 0 & t != (d + 1)); + + scalar_t zn = (1.0 - alpha); + scalar_t zp = (alpha); + // p = 1. / 1. + expf(-x); p = sigmoid(x) + scalar_t p = 1. / (1. + expf(-logits[i])); + + // (1-p)**g * (1 - p - g*p*log(p) + scalar_t term1 = + powf((1. - p), gamma) * (1. - p - (p * gamma * logf(max(p, FLT_MIN)))); + + // (p**g) * (g*(1-p)*log(1-p) - p) + scalar_t term2 = + powf(p, gamma) * + ((-1. * logits[i] * (logits[i] >= 0) - + logf(1. + expf(logits[i] - 2. * logits[i] * (logits[i] >= 0)))) * + (1. - p) * gamma - + p); + d_logits[i] = 0.0; + d_logits[i] += -c1 * term1 * zp; + d_logits[i] += -c2 * term2 * zn; + d_logits[i] = d_logits[i] * d_losses[i]; + + } // CUDA_1D_KERNEL_LOOP +} // SigmoidFocalLossBackward + +at::Tensor SigmoidFocalLoss_forward_cuda(const at::Tensor &logits, + const at::Tensor &targets, + const int num_classes, + const float gamma, const float alpha) { + AT_ASSERTM(logits.type().is_cuda(), "logits must be a CUDA tensor"); + AT_ASSERTM(targets.type().is_cuda(), "targets must be a CUDA tensor"); + AT_ASSERTM(logits.dim() == 2, "logits should be NxClass"); + + const int num_samples = logits.size(0); + + auto losses = at::empty({num_samples, logits.size(1)}, logits.options()); + auto losses_size = num_samples * logits.size(1); + + dim3 grid( + std::min(THCCeilDiv((int64_t)losses_size, (int64_t)512), (int64_t)4096)); + dim3 block(512); + + if (losses.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return losses; + } + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + logits.scalar_type(), "SigmoidFocalLoss_forward", [&] { + SigmoidFocalLossForward<<>>( + losses_size, logits.contiguous().data(), + targets.contiguous().data(), num_classes, gamma, alpha, + num_samples, losses.data()); + }); + THCudaCheck(cudaGetLastError()); + return losses; +} + +at::Tensor SigmoidFocalLoss_backward_cuda(const at::Tensor &logits, + const at::Tensor &targets, + const at::Tensor &d_losses, + const int num_classes, + const float gamma, + const float alpha) { + AT_ASSERTM(logits.type().is_cuda(), "logits must be a CUDA tensor"); + AT_ASSERTM(targets.type().is_cuda(), "targets must be a CUDA tensor"); + AT_ASSERTM(d_losses.type().is_cuda(), "d_losses must be a CUDA tensor"); + + AT_ASSERTM(logits.dim() == 2, "logits should be NxClass"); + + const int num_samples = logits.size(0); + AT_ASSERTM(logits.size(1) == num_classes, + "logits.size(1) should be num_classes"); + + auto d_logits = at::zeros({num_samples, num_classes}, logits.options()); + auto d_logits_size = num_samples * logits.size(1); + + dim3 grid(std::min(THCCeilDiv((int64_t)d_logits_size, (int64_t)512), + (int64_t)4096)); + dim3 block(512); + + if (d_logits.numel() == 0) { + THCudaCheck(cudaGetLastError()); + return d_logits; + } + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + logits.scalar_type(), "SigmoidFocalLoss_backward", [&] { + SigmoidFocalLossBackward<<>>( + d_logits_size, logits.contiguous().data(), + targets.contiguous().data(), + d_losses.contiguous().data(), num_classes, gamma, alpha, + num_samples, d_logits.data()); + }); + + THCudaCheck(cudaGetLastError()); + return d_logits; +} diff --git a/mmdet/utils/__init__.py b/mmdet/utils/__init__.py new file mode 100644 index 0000000..f65e3b2 --- /dev/null +++ b/mmdet/utils/__init__.py @@ -0,0 +1,4 @@ +from .flops_counter import get_model_complexity_info +from .registry import Registry, build_from_cfg + +__all__ = ['Registry', 'build_from_cfg', 'get_model_complexity_info'] diff --git a/mmdet/utils/flops_counter.py b/mmdet/utils/flops_counter.py new file mode 100644 index 0000000..3005a14 --- /dev/null +++ b/mmdet/utils/flops_counter.py @@ -0,0 +1,421 @@ +# Modified from flops-counter.pytorch by Vladislav Sovrasov +# original repo: https://github.com/sovrasov/flops-counter.pytorch + +# MIT License + +# Copyright (c) 2018 Vladislav Sovrasov + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +import sys + +import numpy as np +import torch +import torch.nn as nn +from torch.nn.modules.batchnorm import _BatchNorm +from torch.nn.modules.conv import _ConvNd, _ConvTransposeMixin +from torch.nn.modules.pooling import (_AdaptiveAvgPoolNd, _AdaptiveMaxPoolNd, + _AvgPoolNd, _MaxPoolNd) + +CONV_TYPES = (_ConvNd, ) +DECONV_TYPES = (_ConvTransposeMixin, ) +LINEAR_TYPES = (nn.Linear, ) +POOLING_TYPES = (_AvgPoolNd, _MaxPoolNd, _AdaptiveAvgPoolNd, + _AdaptiveMaxPoolNd) +RELU_TYPES = (nn.ReLU, nn.PReLU, nn.ELU, nn.LeakyReLU, nn.ReLU6) +BN_TYPES = (_BatchNorm, ) +UPSAMPLE_TYPES = (nn.Upsample, ) + +SUPPORTED_TYPES = ( + CONV_TYPES + DECONV_TYPES + LINEAR_TYPES + POOLING_TYPES + RELU_TYPES + + BN_TYPES + UPSAMPLE_TYPES) + + +def get_model_complexity_info(model, + input_res, + print_per_layer_stat=True, + as_strings=True, + input_constructor=None, + ost=sys.stdout): + assert type(input_res) is tuple + assert len(input_res) >= 2 + flops_model = add_flops_counting_methods(model) + flops_model.eval().start_flops_count() + if input_constructor: + input = input_constructor(input_res) + _ = flops_model(**input) + else: + batch = torch.ones(()).new_empty( + (1, *input_res), + dtype=next(flops_model.parameters()).dtype, + device=next(flops_model.parameters()).device) + flops_model(batch) + + if print_per_layer_stat: + print_model_with_flops(flops_model, ost=ost) + flops_count = flops_model.compute_average_flops_cost() + params_count = get_model_parameters_number(flops_model) + flops_model.stop_flops_count() + + if as_strings: + return flops_to_string(flops_count), params_to_string(params_count) + + return flops_count, params_count + + +def flops_to_string(flops, units='GMac', precision=2): + if units is None: + if flops // 10**9 > 0: + return str(round(flops / 10.**9, precision)) + ' GMac' + elif flops // 10**6 > 0: + return str(round(flops / 10.**6, precision)) + ' MMac' + elif flops // 10**3 > 0: + return str(round(flops / 10.**3, precision)) + ' KMac' + else: + return str(flops) + ' Mac' + else: + if units == 'GMac': + return str(round(flops / 10.**9, precision)) + ' ' + units + elif units == 'MMac': + return str(round(flops / 10.**6, precision)) + ' ' + units + elif units == 'KMac': + return str(round(flops / 10.**3, precision)) + ' ' + units + else: + return str(flops) + ' Mac' + + +def params_to_string(params_num): + if params_num // 10**6 > 0: + return str(round(params_num / 10**6, 2)) + ' M' + elif params_num // 10**3: + return str(round(params_num / 10**3, 2)) + ' k' + else: + return str(params_num) + + +def print_model_with_flops(model, units='GMac', precision=3, ost=sys.stdout): + total_flops = model.compute_average_flops_cost() + + def accumulate_flops(self): + if is_supported_instance(self): + return self.__flops__ / model.__batch_counter__ + else: + sum = 0 + for m in self.children(): + sum += m.accumulate_flops() + return sum + + def flops_repr(self): + accumulated_flops_cost = self.accumulate_flops() + return ', '.join([ + flops_to_string( + accumulated_flops_cost, units=units, precision=precision), + '{:.3%} MACs'.format(accumulated_flops_cost / total_flops), + self.original_extra_repr() + ]) + + def add_extra_repr(m): + m.accumulate_flops = accumulate_flops.__get__(m) + flops_extra_repr = flops_repr.__get__(m) + if m.extra_repr != flops_extra_repr: + m.original_extra_repr = m.extra_repr + m.extra_repr = flops_extra_repr + assert m.extra_repr != m.original_extra_repr + + def del_extra_repr(m): + if hasattr(m, 'original_extra_repr'): + m.extra_repr = m.original_extra_repr + del m.original_extra_repr + if hasattr(m, 'accumulate_flops'): + del m.accumulate_flops + + model.apply(add_extra_repr) + print(model, file=ost) + model.apply(del_extra_repr) + + +def get_model_parameters_number(model): + params_num = sum(p.numel() for p in model.parameters() if p.requires_grad) + return params_num + + +def add_flops_counting_methods(net_main_module): + # adding additional methods to the existing module object, + # this is done this way so that each function has access to self object + net_main_module.start_flops_count = start_flops_count.__get__( + net_main_module) + net_main_module.stop_flops_count = stop_flops_count.__get__( + net_main_module) + net_main_module.reset_flops_count = reset_flops_count.__get__( + net_main_module) + net_main_module.compute_average_flops_cost = \ + compute_average_flops_cost.__get__(net_main_module) + + net_main_module.reset_flops_count() + + # Adding variables necessary for masked flops computation + net_main_module.apply(add_flops_mask_variable_or_reset) + + return net_main_module + + +def compute_average_flops_cost(self): + """ + A method that will be available after add_flops_counting_methods() is + called on a desired net object. + Returns current mean flops consumption per image. + """ + + batches_count = self.__batch_counter__ + flops_sum = 0 + for module in self.modules(): + if is_supported_instance(module): + flops_sum += module.__flops__ + + return flops_sum / batches_count + + +def start_flops_count(self): + """ + A method that will be available after add_flops_counting_methods() is + called on a desired net object. + Activates the computation of mean flops consumption per image. + Call it before you run the network. + """ + add_batch_counter_hook_function(self) + self.apply(add_flops_counter_hook_function) + + +def stop_flops_count(self): + """ + A method that will be available after add_flops_counting_methods() is + called on a desired net object. + Stops computing the mean flops consumption per image. + Call whenever you want to pause the computation. + """ + remove_batch_counter_hook_function(self) + self.apply(remove_flops_counter_hook_function) + + +def reset_flops_count(self): + """ + A method that will be available after add_flops_counting_methods() is + called on a desired net object. + Resets statistics computed so far. + """ + add_batch_counter_variables_or_reset(self) + self.apply(add_flops_counter_variable_or_reset) + + +def add_flops_mask(module, mask): + + def add_flops_mask_func(module): + if isinstance(module, torch.nn.Conv2d): + module.__mask__ = mask + + module.apply(add_flops_mask_func) + + +def remove_flops_mask(module): + module.apply(add_flops_mask_variable_or_reset) + + +def is_supported_instance(module): + if isinstance(module, SUPPORTED_TYPES): + return True + else: + return False + + +def empty_flops_counter_hook(module, input, output): + module.__flops__ += 0 + + +def upsample_flops_counter_hook(module, input, output): + output_size = output[0] + batch_size = output_size.shape[0] + output_elements_count = batch_size + for val in output_size.shape[1:]: + output_elements_count *= val + module.__flops__ += int(output_elements_count) + + +def relu_flops_counter_hook(module, input, output): + active_elements_count = output.numel() + module.__flops__ += int(active_elements_count) + + +def linear_flops_counter_hook(module, input, output): + input = input[0] + batch_size = input.shape[0] + module.__flops__ += int(batch_size * input.shape[1] * output.shape[1]) + + +def pool_flops_counter_hook(module, input, output): + input = input[0] + module.__flops__ += int(np.prod(input.shape)) + + +def bn_flops_counter_hook(module, input, output): + module.affine + input = input[0] + + batch_flops = np.prod(input.shape) + if module.affine: + batch_flops *= 2 + module.__flops__ += int(batch_flops) + + +def deconv_flops_counter_hook(conv_module, input, output): + # Can have multiple inputs, getting the first one + input = input[0] + + batch_size = input.shape[0] + input_height, input_width = input.shape[2:] + + kernel_height, kernel_width = conv_module.kernel_size + in_channels = conv_module.in_channels + out_channels = conv_module.out_channels + groups = conv_module.groups + + filters_per_channel = out_channels // groups + conv_per_position_flops = ( + kernel_height * kernel_width * in_channels * filters_per_channel) + + active_elements_count = batch_size * input_height * input_width + overall_conv_flops = conv_per_position_flops * active_elements_count + bias_flops = 0 + if conv_module.bias is not None: + output_height, output_width = output.shape[2:] + bias_flops = out_channels * batch_size * output_height * output_height + overall_flops = overall_conv_flops + bias_flops + + conv_module.__flops__ += int(overall_flops) + + +def conv_flops_counter_hook(conv_module, input, output): + # Can have multiple inputs, getting the first one + input = input[0] + + batch_size = input.shape[0] + output_dims = list(output.shape[2:]) + + kernel_dims = list(conv_module.kernel_size) + in_channels = conv_module.in_channels + out_channels = conv_module.out_channels + groups = conv_module.groups + + filters_per_channel = out_channels // groups + conv_per_position_flops = np.prod( + kernel_dims) * in_channels * filters_per_channel + + active_elements_count = batch_size * np.prod(output_dims) + + if conv_module.__mask__ is not None: + # (b, 1, h, w) + output_height, output_width = output.shape[2:] + flops_mask = conv_module.__mask__.expand(batch_size, 1, output_height, + output_width) + active_elements_count = flops_mask.sum() + + overall_conv_flops = conv_per_position_flops * active_elements_count + + bias_flops = 0 + + if conv_module.bias is not None: + + bias_flops = out_channels * active_elements_count + + overall_flops = overall_conv_flops + bias_flops + + conv_module.__flops__ += int(overall_flops) + + +def batch_counter_hook(module, input, output): + batch_size = 1 + if len(input) > 0: + # Can have multiple inputs, getting the first one + input = input[0] + batch_size = len(input) + else: + print('Warning! No positional inputs found for a module, ' + 'assuming batch size is 1.') + module.__batch_counter__ += batch_size + + +def add_batch_counter_variables_or_reset(module): + + module.__batch_counter__ = 0 + + +def add_batch_counter_hook_function(module): + if hasattr(module, '__batch_counter_handle__'): + return + + handle = module.register_forward_hook(batch_counter_hook) + module.__batch_counter_handle__ = handle + + +def remove_batch_counter_hook_function(module): + if hasattr(module, '__batch_counter_handle__'): + module.__batch_counter_handle__.remove() + del module.__batch_counter_handle__ + + +def add_flops_counter_variable_or_reset(module): + if is_supported_instance(module): + module.__flops__ = 0 + + +def add_flops_counter_hook_function(module): + if is_supported_instance(module): + if hasattr(module, '__flops_handle__'): + return + + if isinstance(module, CONV_TYPES): + handle = module.register_forward_hook(conv_flops_counter_hook) + elif isinstance(module, RELU_TYPES): + handle = module.register_forward_hook(relu_flops_counter_hook) + elif isinstance(module, LINEAR_TYPES): + handle = module.register_forward_hook(linear_flops_counter_hook) + elif isinstance(module, POOLING_TYPES): + handle = module.register_forward_hook(pool_flops_counter_hook) + elif isinstance(module, BN_TYPES): + handle = module.register_forward_hook(bn_flops_counter_hook) + elif isinstance(module, UPSAMPLE_TYPES): + handle = module.register_forward_hook(upsample_flops_counter_hook) + elif isinstance(module, DECONV_TYPES): + handle = module.register_forward_hook(deconv_flops_counter_hook) + else: + handle = module.register_forward_hook(empty_flops_counter_hook) + module.__flops_handle__ = handle + + +def remove_flops_counter_hook_function(module): + if is_supported_instance(module): + if hasattr(module, '__flops_handle__'): + module.__flops_handle__.remove() + del module.__flops_handle__ + + +# --- Masked flops counting +# Also being run in the initialization +def add_flops_mask_variable_or_reset(module): + if is_supported_instance(module): + module.__mask__ = None diff --git a/mmdet/utils/registry.py b/mmdet/utils/registry.py new file mode 100644 index 0000000..e39552a --- /dev/null +++ b/mmdet/utils/registry.py @@ -0,0 +1,74 @@ +import inspect + +import mmcv + + +class Registry(object): + + def __init__(self, name): + self._name = name + self._module_dict = dict() + + def __repr__(self): + format_str = self.__class__.__name__ + '(name={}, items={})'.format( + self._name, list(self._module_dict.keys())) + return format_str + + @property + def name(self): + return self._name + + @property + def module_dict(self): + return self._module_dict + + def get(self, key): + return self._module_dict.get(key, None) + + def _register_module(self, module_class): + """Register a module. + + Args: + module (:obj:`nn.Module`): Module to be registered. + """ + if not inspect.isclass(module_class): + raise TypeError('module must be a class, but got {}'.format( + type(module_class))) + module_name = module_class.__name__ + if module_name in self._module_dict: + raise KeyError('{} is already registered in {}'.format( + module_name, self.name)) + self._module_dict[module_name] = module_class + + def register_module(self, cls): + self._register_module(cls) + return cls + + +def build_from_cfg(cfg, registry, default_args=None): + """Build a module from config dict. + + Args: + cfg (dict): Config dict. It should at least contain the key "type". + registry (:obj:`Registry`): The registry to search the type from. + default_args (dict, optional): Default initialization arguments. + + Returns: + obj: The constructed object. + """ + assert isinstance(cfg, dict) and 'type' in cfg + assert isinstance(default_args, dict) or default_args is None + args = cfg.copy() + obj_type = args.pop('type') + if mmcv.is_str(obj_type): + obj_type = registry.get(obj_type) + if obj_type is None: + raise KeyError('{} is not in the {} registry'.format( + obj_type, registry.name)) + elif not inspect.isclass(obj_type): + raise TypeError('type must be a str or valid type, but got {}'.format( + type(obj_type))) + if default_args is not None: + for name, value in default_args.items(): + args.setdefault(name, value) + return obj_type(**args) diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..cf3a6e1 --- /dev/null +++ b/setup.py @@ -0,0 +1,201 @@ +import os +import platform +import subprocess +import time +from setuptools import Extension, dist, find_packages, setup + +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + +dist.Distribution().fetch_build_eggs(['Cython', 'numpy>=1.11.1']) +import numpy as np # noqa: E402 +from Cython.Build import cythonize # noqa: E402 + + +def readme(): + with open('README.md', encoding='utf-8') as f: + content = f.read() + return content + + +MAJOR = 1 +MINOR = 0 +PATCH = '' +SUFFIX = 'rc0' +SHORT_VERSION = '{}.{}.{}{}'.format(MAJOR, MINOR, PATCH, SUFFIX) + +version_file = 'mmdet/version.py' + + +def get_git_hash(): + + def _minimal_ext_cmd(cmd): + # construct minimal environment + env = {} + for k in ['SYSTEMROOT', 'PATH', 'HOME']: + v = os.environ.get(k) + if v is not None: + env[k] = v + # LANGUAGE is used on win32 + env['LANGUAGE'] = 'C' + env['LANG'] = 'C' + env['LC_ALL'] = 'C' + out = subprocess.Popen( + cmd, stdout=subprocess.PIPE, env=env).communicate()[0] + return out + + try: + out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD']) + sha = out.strip().decode('ascii') + except OSError: + sha = 'unknown' + + return sha + + +def get_hash(): + if os.path.exists('.git'): + sha = get_git_hash()[:7] + elif os.path.exists(version_file): + try: + from mmdet.version import __version__ + sha = __version__.split('+')[-1] + except ImportError: + raise ImportError('Unable to get git version') + else: + sha = 'unknown' + + return sha + + +def write_version_py(): + content = """# GENERATED VERSION FILE +# TIME: {} + +__version__ = '{}' +short_version = '{}' +""" + sha = get_hash() + VERSION = SHORT_VERSION + '+' + sha + + with open(version_file, 'w') as f: + f.write(content.format(time.asctime(), VERSION, SHORT_VERSION)) + + +def get_version(): + with open(version_file, 'r') as f: + exec(compile(f.read(), version_file, 'exec')) + return locals()['__version__'] + + +def make_cuda_ext(name, module, sources): + + return CUDAExtension( + name='{}.{}'.format(module, name), + sources=[os.path.join(*module.split('.'), p) for p in sources], + extra_compile_args={ + 'cxx': [], + 'nvcc': [ + '-D__CUDA_NO_HALF_OPERATORS__', + '-D__CUDA_NO_HALF_CONVERSIONS__', + '-D__CUDA_NO_HALF2_OPERATORS__', + ] + }) + + +def make_cython_ext(name, module, sources): + extra_compile_args = None + if platform.system() != 'Windows': + extra_compile_args = { + 'cxx': ['-Wno-unused-function', '-Wno-write-strings'] + } + + extension = Extension( + '{}.{}'.format(module, name), + [os.path.join(*module.split('.'), p) for p in sources], + include_dirs=[np.get_include()], + language='c++', + extra_compile_args=extra_compile_args) + extension, = cythonize(extension) + return extension + + +if __name__ == '__main__': + write_version_py() + setup( + name='mmdet', + version=get_version(), + description='Open MMLab Detection Toolbox and Benchmark', + long_description=readme(), + keywords='computer vision, object detection', + url='https://github.com/open-mmlab/mmdetection', + packages=find_packages(exclude=('configs', 'tools', 'demo')), + package_data={'mmdet.ops': ['*/*.so']}, + classifiers=[ + 'Development Status :: 4 - Beta', + 'License :: OSI Approved :: Apache Software License', + 'Operating System :: OS Independent', + 'Programming Language :: Python :: 2', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.4', + 'Programming Language :: Python :: 3.5', + 'Programming Language :: Python :: 3.6', + ], + license='Apache License 2.0', + setup_requires=['pytest-runner', 'cython', 'numpy'], + tests_require=['pytest'], + install_requires=[ + 'mmcv>=0.2.10', 'numpy', 'matplotlib', 'six', 'terminaltables', + 'pycocotools', 'torch>=1.1', 'imagecorruptions' + ], + ext_modules=[ + make_cython_ext( + name='soft_nms_cpu', + module='mmdet.ops.nms', + sources=['src/soft_nms_cpu.pyx']), + make_cuda_ext( + name='nms_cpu', + module='mmdet.ops.nms', + sources=['src/nms_cpu.cpp']), + make_cuda_ext( + name='nms_cuda', + module='mmdet.ops.nms', + sources=['src/nms_cuda.cpp', 'src/nms_kernel.cu']), + make_cuda_ext( + name='roi_align_cuda', + module='mmdet.ops.roi_align', + sources=['src/roi_align_cuda.cpp', 'src/roi_align_kernel.cu']), + make_cuda_ext( + name='roi_pool_cuda', + module='mmdet.ops.roi_pool', + sources=['src/roi_pool_cuda.cpp', 'src/roi_pool_kernel.cu']), + make_cuda_ext( + name='deform_conv_cuda', + module='mmdet.ops.dcn', + sources=[ + 'src/deform_conv_cuda.cpp', + 'src/deform_conv_cuda_kernel.cu' + ]), + make_cuda_ext( + name='deform_pool_cuda', + module='mmdet.ops.dcn', + sources=[ + 'src/deform_pool_cuda.cpp', + 'src/deform_pool_cuda_kernel.cu' + ]), + make_cuda_ext( + name='sigmoid_focal_loss_cuda', + module='mmdet.ops.sigmoid_focal_loss', + sources=[ + 'src/sigmoid_focal_loss.cpp', + 'src/sigmoid_focal_loss_cuda.cu' + ]), + make_cuda_ext( + name='masked_conv2d_cuda', + module='mmdet.ops.masked_conv', + sources=[ + 'src/masked_conv2d_cuda.cpp', 'src/masked_conv2d_kernel.cu' + ]), + ], + cmdclass={'build_ext': BuildExtension}, + zip_safe=False) diff --git a/tools/analyze_logs.py b/tools/analyze_logs.py new file mode 100644 index 0000000..2810c98 --- /dev/null +++ b/tools/analyze_logs.py @@ -0,0 +1,178 @@ +import argparse +import json +from collections import defaultdict + +import matplotlib.pyplot as plt +import numpy as np +import seaborn as sns + + +def cal_train_time(log_dicts, args): + for i, log_dict in enumerate(log_dicts): + print('{}Analyze train time of {}{}'.format('-' * 5, args.json_logs[i], + '-' * 5)) + all_times = [] + for epoch in log_dict.keys(): + if args.include_outliers: + all_times.append(log_dict[epoch]['time']) + else: + all_times.append(log_dict[epoch]['time'][1:]) + all_times = np.array(all_times) + epoch_ave_time = all_times.mean(-1) + slowest_epoch = epoch_ave_time.argmax() + fastest_epoch = epoch_ave_time.argmin() + std_over_epoch = epoch_ave_time.std() + print('slowest epoch {}, average time is {:.4f}'.format( + slowest_epoch + 1, epoch_ave_time[slowest_epoch])) + print('fastest epoch {}, average time is {:.4f}'.format( + fastest_epoch + 1, epoch_ave_time[fastest_epoch])) + print('time std over epochs is {:.4f}'.format(std_over_epoch)) + print('average iter time: {:.4f} s/iter'.format(np.mean(all_times))) + print() + + +def plot_curve(log_dicts, args): + if args.backend is not None: + plt.switch_backend(args.backend) + sns.set_style(args.style) + # if legend is None, use {filename}_{key} as legend + legend = args.legend + if legend is None: + legend = [] + for json_log in args.json_logs: + for metric in args.keys: + legend.append('{}_{}'.format(json_log, metric)) + assert len(legend) == (len(args.json_logs) * len(args.keys)) + metrics = args.keys + + num_metrics = len(metrics) + for i, log_dict in enumerate(log_dicts): + epochs = list(log_dict.keys()) + for j, metric in enumerate(metrics): + print('plot curve of {}, metric is {}'.format( + args.json_logs[i], metric)) + if metric not in log_dict[epochs[0]]: + raise KeyError('{} does not contain metric {}'.format( + args.json_logs[i], metric)) + + if 'mAP' in metric: + xs = np.arange(1, max(epochs) + 1) + ys = [] + for epoch in epochs: + ys += log_dict[epoch][metric] + ax = plt.gca() + ax.set_xticks(xs) + plt.xlabel('epoch') + plt.plot(xs, ys, label=legend[i * num_metrics + j], marker='o') + else: + xs = [] + ys = [] + num_iters_per_epoch = log_dict[epochs[0]]['iter'][-1] + for epoch in epochs: + iters = log_dict[epoch]['iter'] + if log_dict[epoch]['mode'][-1] == 'val': + iters = iters[:-1] + xs.append( + np.array(iters) + (epoch - 1) * num_iters_per_epoch) + ys.append(np.array(log_dict[epoch][metric][:len(iters)])) + xs = np.concatenate(xs) + ys = np.concatenate(ys) + plt.xlabel('iter') + plt.plot( + xs, ys, label=legend[i * num_metrics + j], linewidth=0.5) + plt.legend() + if args.title is not None: + plt.title(args.title) + if args.out is None: + plt.show() + else: + print('save curve to: {}'.format(args.out)) + plt.savefig(args.out) + plt.cla() + + +def add_plot_parser(subparsers): + parser_plt = subparsers.add_parser( + 'plot_curve', help='parser for plotting curves') + parser_plt.add_argument( + 'json_logs', + type=str, + nargs='+', + help='path of train log in json format') + parser_plt.add_argument( + '--keys', + type=str, + nargs='+', + default=['bbox_mAP'], + help='the metric that you want to plot') + parser_plt.add_argument('--title', type=str, help='title of figure') + parser_plt.add_argument( + '--legend', + type=str, + nargs='+', + default=None, + help='legend of each plot') + parser_plt.add_argument( + '--backend', type=str, default=None, help='backend of plt') + parser_plt.add_argument( + '--style', type=str, default='dark', help='style of plt') + parser_plt.add_argument('--out', type=str, default=None) + + +def add_time_parser(subparsers): + parser_time = subparsers.add_parser( + 'cal_train_time', + help='parser for computing the average time per training iteration') + parser_time.add_argument( + 'json_logs', + type=str, + nargs='+', + help='path of train log in json format') + parser_time.add_argument( + '--include-outliers', + action='store_true', + help='include the first value of every epoch when computing ' + 'the average time') + + +def parse_args(): + parser = argparse.ArgumentParser(description='Analyze Json Log') + # currently only support plot curve and calculate average train time + subparsers = parser.add_subparsers(dest='task', help='task parser') + add_plot_parser(subparsers) + add_time_parser(subparsers) + args = parser.parse_args() + return args + + +def load_json_logs(json_logs): + # load and convert json_logs to log_dict, key is epoch, value is a sub dict + # keys of sub dict is different metrics, e.g. memory, bbox_mAP + # value of sub dict is a list of corresponding values of all iterations + log_dicts = [dict() for _ in json_logs] + for json_log, log_dict in zip(json_logs, log_dicts): + with open(json_log, 'r') as log_file: + for l in log_file: + log = json.loads(l.strip()) + epoch = log.pop('epoch') + if epoch not in log_dict: + log_dict[epoch] = defaultdict(list) + for k, v in log.items(): + log_dict[epoch][k].append(v) + return log_dicts + + +def main(): + args = parse_args() + + json_logs = args.json_logs + for json_log in json_logs: + assert json_log.endswith('.json') + + log_dicts = load_json_logs(json_logs) + + eval(args.task)(log_dicts, args) + + +if __name__ == '__main__': + main() diff --git a/tools/coco_eval.py b/tools/coco_eval.py new file mode 100644 index 0000000..65e114c --- /dev/null +++ b/tools/coco_eval.py @@ -0,0 +1,28 @@ +from argparse import ArgumentParser + +from mmdet.core import coco_eval + + +def main(): + parser = ArgumentParser(description='COCO Evaluation') + parser.add_argument('result', help='result file path') + parser.add_argument('--ann', help='annotation file path') + parser.add_argument( + '--types', + type=str, + nargs='+', + choices=['proposal_fast', 'proposal', 'bbox', 'segm', 'keypoint'], + default=['bbox'], + help='result types') + parser.add_argument( + '--max-dets', + type=int, + nargs='+', + default=[100, 300, 1000], + help='proposal numbers, only used for recall evaluation') + args = parser.parse_args() + coco_eval(args.result, args.types, args.ann, args.max_dets) + + +if __name__ == '__main__': + main() diff --git a/tools/convert_datasets/pascal_voc.py b/tools/convert_datasets/pascal_voc.py new file mode 100644 index 0000000..029eeb0 --- /dev/null +++ b/tools/convert_datasets/pascal_voc.py @@ -0,0 +1,141 @@ +import argparse +import os.path as osp +import xml.etree.ElementTree as ET + +import mmcv +import numpy as np + +from mmdet.core import voc_classes + +label_ids = {name: i + 1 for i, name in enumerate(voc_classes())} + + +def parse_xml(args): + xml_path, img_path = args + tree = ET.parse(xml_path) + root = tree.getroot() + size = root.find('size') + w = int(size.find('width').text) + h = int(size.find('height').text) + bboxes = [] + labels = [] + bboxes_ignore = [] + labels_ignore = [] + for obj in root.findall('object'): + name = obj.find('name').text + label = label_ids[name] + difficult = int(obj.find('difficult').text) + bnd_box = obj.find('bndbox') + bbox = [ + int(bnd_box.find('xmin').text), + int(bnd_box.find('ymin').text), + int(bnd_box.find('xmax').text), + int(bnd_box.find('ymax').text) + ] + if difficult: + bboxes_ignore.append(bbox) + labels_ignore.append(label) + else: + bboxes.append(bbox) + labels.append(label) + if not bboxes: + bboxes = np.zeros((0, 4)) + labels = np.zeros((0, )) + else: + bboxes = np.array(bboxes, ndmin=2) - 1 + labels = np.array(labels) + if not bboxes_ignore: + bboxes_ignore = np.zeros((0, 4)) + labels_ignore = np.zeros((0, )) + else: + bboxes_ignore = np.array(bboxes_ignore, ndmin=2) - 1 + labels_ignore = np.array(labels_ignore) + annotation = { + 'filename': img_path, + 'width': w, + 'height': h, + 'ann': { + 'bboxes': bboxes.astype(np.float32), + 'labels': labels.astype(np.int64), + 'bboxes_ignore': bboxes_ignore.astype(np.float32), + 'labels_ignore': labels_ignore.astype(np.int64) + } + } + return annotation + + +def cvt_annotations(devkit_path, years, split, out_file): + if not isinstance(years, list): + years = [years] + annotations = [] + for year in years: + filelist = osp.join(devkit_path, + 'VOC{}/ImageSets/Main/{}.txt'.format(year, split)) + if not osp.isfile(filelist): + print('filelist does not exist: {}, skip voc{} {}'.format( + filelist, year, split)) + return + img_names = mmcv.list_from_file(filelist) + xml_paths = [ + osp.join(devkit_path, + 'VOC{}/Annotations/{}.xml'.format(year, img_name)) + for img_name in img_names + ] + img_paths = [ + 'VOC{}/JPEGImages/{}.jpg'.format(year, img_name) + for img_name in img_names + ] + part_annotations = mmcv.track_progress(parse_xml, + list(zip(xml_paths, img_paths))) + annotations.extend(part_annotations) + mmcv.dump(annotations, out_file) + return annotations + + +def parse_args(): + parser = argparse.ArgumentParser( + description='Convert PASCAL VOC annotations to mmdetection format') + parser.add_argument('devkit_path', help='pascal voc devkit path') + parser.add_argument('-o', '--out-dir', help='output path') + args = parser.parse_args() + return args + + +def main(): + args = parse_args() + devkit_path = args.devkit_path + out_dir = args.out_dir if args.out_dir else devkit_path + mmcv.mkdir_or_exist(out_dir) + + years = [] + if osp.isdir(osp.join(devkit_path, 'VOC2007')): + years.append('2007') + if osp.isdir(osp.join(devkit_path, 'VOC2012')): + years.append('2012') + if '2007' in years and '2012' in years: + years.append(['2007', '2012']) + if not years: + raise IOError('The devkit path {} contains neither "VOC2007" nor ' + '"VOC2012" subfolder'.format(devkit_path)) + for year in years: + if year == '2007': + prefix = 'voc07' + elif year == '2012': + prefix = 'voc12' + elif year == ['2007', '2012']: + prefix = 'voc0712' + for split in ['train', 'val', 'trainval']: + dataset_name = prefix + '_' + split + print('processing {} ...'.format(dataset_name)) + cvt_annotations(devkit_path, year, split, + osp.join(out_dir, dataset_name + '.pkl')) + if not isinstance(year, list): + dataset_name = prefix + '_test' + print('processing {} ...'.format(dataset_name)) + cvt_annotations(devkit_path, year, 'test', + osp.join(out_dir, dataset_name + '.pkl')) + print('Done!') + + +if __name__ == '__main__': + main() diff --git a/tools/detectron2pytorch.py b/tools/detectron2pytorch.py new file mode 100644 index 0000000..0a90ad1 --- /dev/null +++ b/tools/detectron2pytorch.py @@ -0,0 +1,88 @@ +import argparse +from collections import OrderedDict + +import mmcv +import torch + +arch_settings = {50: (3, 4, 6, 3), 101: (3, 4, 23, 3)} + + +def convert_bn(blobs, state_dict, caffe_name, torch_name, converted_names): + # detectron replace bn with affine channel layer + state_dict[torch_name + '.bias'] = torch.from_numpy(blobs[caffe_name + + '_b']) + state_dict[torch_name + '.weight'] = torch.from_numpy(blobs[caffe_name + + '_s']) + bn_size = state_dict[torch_name + '.weight'].size() + state_dict[torch_name + '.running_mean'] = torch.zeros(bn_size) + state_dict[torch_name + '.running_var'] = torch.ones(bn_size) + converted_names.add(caffe_name + '_b') + converted_names.add(caffe_name + '_s') + + +def convert_conv_fc(blobs, state_dict, caffe_name, torch_name, + converted_names): + state_dict[torch_name + '.weight'] = torch.from_numpy(blobs[caffe_name + + '_w']) + converted_names.add(caffe_name + '_w') + if caffe_name + '_b' in blobs: + state_dict[torch_name + '.bias'] = torch.from_numpy(blobs[caffe_name + + '_b']) + converted_names.add(caffe_name + '_b') + + +def convert(src, dst, depth): + """Convert keys in detectron pretrained ResNet models to pytorch style.""" + # load arch_settings + if depth not in arch_settings: + raise ValueError('Only support ResNet-50 and ResNet-101 currently') + block_nums = arch_settings[depth] + # load caffe model + caffe_model = mmcv.load(src, encoding='latin1') + blobs = caffe_model['blobs'] if 'blobs' in caffe_model else caffe_model + # convert to pytorch style + state_dict = OrderedDict() + converted_names = set() + convert_conv_fc(blobs, state_dict, 'conv1', 'conv1', converted_names) + convert_bn(blobs, state_dict, 'res_conv1_bn', 'bn1', converted_names) + for i in range(1, len(block_nums) + 1): + for j in range(block_nums[i - 1]): + if j == 0: + convert_conv_fc(blobs, state_dict, + 'res{}_{}_branch1'.format(i + 1, j), + 'layer{}.{}.downsample.0'.format(i, j), + converted_names) + convert_bn(blobs, state_dict, + 'res{}_{}_branch1_bn'.format(i + 1, j), + 'layer{}.{}.downsample.1'.format(i, j), + converted_names) + for k, letter in enumerate(['a', 'b', 'c']): + convert_conv_fc(blobs, state_dict, + 'res{}_{}_branch2{}'.format(i + 1, j, letter), + 'layer{}.{}.conv{}'.format(i, j, k + 1), + converted_names) + convert_bn(blobs, state_dict, + 'res{}_{}_branch2{}_bn'.format(i + 1, j, letter), + 'layer{}.{}.bn{}'.format(i, j, + k + 1), converted_names) + # check if all layers are converted + for key in blobs: + if key not in converted_names: + print('Not Convert: {}'.format(key)) + # save checkpoint + checkpoint = dict() + checkpoint['state_dict'] = state_dict + torch.save(checkpoint, dst) + + +def main(): + parser = argparse.ArgumentParser(description='Convert model keys') + parser.add_argument('src', help='src detectron model path') + parser.add_argument('dst', help='save path') + parser.add_argument('depth', type=int, help='ResNet model depth') + args = parser.parse_args() + convert(args.src, args.dst, args.depth) + + +if __name__ == '__main__': + main() diff --git a/tools/dist_test.sh b/tools/dist_test.sh new file mode 100755 index 0000000..5f6abf1 --- /dev/null +++ b/tools/dist_test.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +PYTHON=${PYTHON:-"python"} + +CONFIG=$1 +CHECKPOINT=$2 +GPUS=$3 + +$PYTHON -m torch.distributed.launch --nproc_per_node=$GPUS \ + $(dirname "$0")/test.py $CONFIG $CHECKPOINT --launcher pytorch ${@:4} diff --git a/tools/dist_train.sh b/tools/dist_train.sh new file mode 100755 index 0000000..a6ed485 --- /dev/null +++ b/tools/dist_train.sh @@ -0,0 +1,9 @@ +#!/usr/bin/env bash + +PYTHON=${PYTHON:-"python"} + +CONFIG=$1 +GPUS=$2 + +$PYTHON -m torch.distributed.launch --nproc_per_node=$GPUS \ + $(dirname "$0")/train.py $CONFIG --launcher pytorch ${@:3} diff --git a/tools/get_flops.py b/tools/get_flops.py new file mode 100644 index 0000000..e64bac6 --- /dev/null +++ b/tools/get_flops.py @@ -0,0 +1,52 @@ +import argparse + +from mmcv import Config + +from mmdet.models import build_detector +from mmdet.utils import get_model_complexity_info + + +def parse_args(): + parser = argparse.ArgumentParser(description='Train a detector') + parser.add_argument('config', help='train config file path') + parser.add_argument( + '--shape', + type=int, + nargs='+', + default=[1280, 800], + help='input image size') + args = parser.parse_args() + return args + + +def main(): + + args = parse_args() + + if len(args.shape) == 1: + input_shape = (3, args.shape[0], args.shape[0]) + elif len(args.shape) == 2: + input_shape = (3, ) + tuple(args.shape) + else: + raise ValueError('invalid input shape') + + cfg = Config.fromfile(args.config) + model = build_detector( + cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg).cuda() + model.eval() + + if hasattr(model, 'forward_dummy'): + model.forward = model.forward_dummy + else: + raise NotImplementedError( + 'FLOPs counter is currently not currently supported with {}'. + format(model.__class__.__name__)) + + flops, params = get_model_complexity_info(model, input_shape) + split_line = '=' * 30 + print('{0}\nInput shape: {1}\nFlops: {2}\nParams: {3}\n{0}'.format( + split_line, input_shape, flops, params)) + + +if __name__ == '__main__': + main() diff --git a/tools/publish_model.py b/tools/publish_model.py new file mode 100644 index 0000000..a049f17 --- /dev/null +++ b/tools/publish_model.py @@ -0,0 +1,35 @@ +import argparse +import subprocess + +import torch + + +def parse_args(): + parser = argparse.ArgumentParser( + description='Process a checkpoint to be published') + parser.add_argument('in_file', help='input checkpoint filename') + parser.add_argument('out_file', help='output checkpoint filename') + args = parser.parse_args() + return args + + +def process_checkpoint(in_file, out_file): + checkpoint = torch.load(in_file, map_location='cpu') + # remove optimizer for smaller file size + if 'optimizer' in checkpoint: + del checkpoint['optimizer'] + # if it is necessary to remove some sensitive data in checkpoint['meta'], + # add the code here. + torch.save(checkpoint, out_file) + sha = subprocess.check_output(['sha256sum', out_file]).decode() + final_file = out_file.rstrip('.pth') + '-{}.pth'.format(sha[:8]) + subprocess.Popen(['mv', out_file, final_file]) + + +def main(): + args = parse_args() + process_checkpoint(args.in_file, args.out_file) + + +if __name__ == '__main__': + main() diff --git a/tools/robustness_eval.py b/tools/robustness_eval.py new file mode 100644 index 0000000..a07aa01 --- /dev/null +++ b/tools/robustness_eval.py @@ -0,0 +1,256 @@ +import os.path as osp +from argparse import ArgumentParser + +import mmcv +import numpy as np + + +def print_coco_results(results): + + def _print(result, ap=1, iouThr=None, areaRng='all', maxDets=100): + iStr = ' {:<18} {} @[ IoU={:<9} | \ + area={:>6s} | maxDets={:>3d} ] = {:0.3f}' + + titleStr = 'Average Precision' if ap == 1 else 'Average Recall' + typeStr = '(AP)' if ap == 1 else '(AR)' + iouStr = '{:0.2f}:{:0.2f}'.format(.5, .95) \ + if iouThr is None else '{:0.2f}'.format(iouThr) + print(iStr.format(titleStr, typeStr, iouStr, areaRng, maxDets, result)) + + stats = np.zeros((12, )) + stats[0] = _print(results[0], 1) + stats[1] = _print(results[1], 1, iouThr=.5) + stats[2] = _print(results[2], 1, iouThr=.75) + stats[3] = _print(results[3], 1, areaRng='small') + stats[4] = _print(results[4], 1, areaRng='medium') + stats[5] = _print(results[5], 1, areaRng='large') + stats[6] = _print(results[6], 0, maxDets=1) + stats[7] = _print(results[7], 0, maxDets=10) + stats[8] = _print(results[8], 0) + stats[9] = _print(results[9], 0, areaRng='small') + stats[10] = _print(results[10], 0, areaRng='medium') + stats[11] = _print(results[11], 0, areaRng='large') + + +def get_coco_style_results(filename, + task='bbox', + metric=None, + prints='mPC', + aggregate='benchmark'): + + assert aggregate in ['benchmark', 'all'] + + if prints == 'all': + prints = ['P', 'mPC', 'rPC'] + elif isinstance(prints, str): + prints = [prints] + for p in prints: + assert p in ['P', 'mPC', 'rPC'] + + if metric is None: + metrics = [ + 'AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'AR1', 'AR10', 'AR100', + 'ARs', 'ARm', 'ARl' + ] + elif isinstance(metric, list): + metrics = metric + else: + metrics = [metric] + + for metric_name in metrics: + assert metric_name in [ + 'AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'AR1', 'AR10', 'AR100', + 'ARs', 'ARm', 'ARl' + ] + + eval_output = mmcv.load(filename) + + num_distortions = len(list(eval_output.keys())) + results = np.zeros((num_distortions, 6, len(metrics)), dtype='float32') + + for corr_i, distortion in enumerate(eval_output): + for severity in eval_output[distortion]: + for metric_j, metric_name in enumerate(metrics): + mAP = eval_output[distortion][severity][task][metric_name] + results[corr_i, severity, metric_j] = mAP + + P = results[0, 0, :] + if aggregate == 'benchmark': + mPC = np.mean(results[:15, 1:, :], axis=(0, 1)) + else: + mPC = np.mean(results[:, 1:, :], axis=(0, 1)) + rPC = mPC / P + + print('\nmodel: {}'.format(osp.basename(filename))) + if metric is None: + if 'P' in prints: + print('Performance on Clean Data [P] ({})'.format(task)) + print_coco_results(P) + if 'mPC' in prints: + print('Mean Performance under Corruption [mPC] ({})'.format(task)) + print_coco_results(mPC) + if 'rPC' in prints: + print('Realtive Performance under Corruption [rPC] ({})'.format( + task)) + print_coco_results(rPC) + else: + if 'P' in prints: + print('Performance on Clean Data [P] ({})'.format(task)) + for metric_i, metric_name in enumerate(metrics): + print('{:5} = {:0.3f}'.format(metric_name, P[metric_i])) + if 'mPC' in prints: + print('Mean Performance under Corruption [mPC] ({})'.format(task)) + for metric_i, metric_name in enumerate(metrics): + print('{:5} = {:0.3f}'.format(metric_name, mPC[metric_i])) + if 'rPC' in prints: + print('Relative Performance under Corruption [rPC] ({})'.format( + task)) + for metric_i, metric_name in enumerate(metrics): + print('{:5} => {:0.1f} %'.format(metric_name, + rPC[metric_i] * 100)) + + return results + + +def get_voc_style_results(filename, prints='mPC', aggregate='benchmark'): + + assert aggregate in ['benchmark', 'all'] + + if prints == 'all': + prints = ['P', 'mPC', 'rPC'] + elif isinstance(prints, str): + prints = [prints] + for p in prints: + assert p in ['P', 'mPC', 'rPC'] + + eval_output = mmcv.load(filename) + + num_distortions = len(list(eval_output.keys())) + results = np.zeros((num_distortions, 6, 20), dtype='float32') + + for i, distortion in enumerate(eval_output): + for severity in eval_output[distortion]: + mAP = [ + eval_output[distortion][severity][j]['ap'] + for j in range(len(eval_output[distortion][severity])) + ] + results[i, severity, :] = mAP + + P = results[0, 0, :] + if aggregate == 'benchmark': + mPC = np.mean(results[:15, 1:, :], axis=(0, 1)) + else: + mPC = np.mean(results[:, 1:, :], axis=(0, 1)) + rPC = mPC / P + + print('\nmodel: {}'.format(osp.basename(filename))) + if 'P' in prints: + print('{:48} = {:0.3f}'.format('Performance on Clean Data [P] in AP50', + np.mean(P))) + if 'mPC' in prints: + print('{:48} = {:0.3f}'.format( + 'Mean Performance under Corruption [mPC] in AP50', np.mean(mPC))) + if 'rPC' in prints: + print('{:48} = {:0.1f}'.format( + 'Realtive Performance under Corruption [rPC] in %', + np.mean(rPC) * 100)) + + return np.mean(results, axis=2, keepdims=True) + + +def get_results(filename, + dataset='coco', + task='bbox', + metric=None, + prints='mPC', + aggregate='benchmark'): + assert dataset in ['coco', 'voc', 'cityscapes'] + + if dataset in ['coco', 'cityscapes']: + results = get_coco_style_results( + filename, + task=task, + metric=metric, + prints=prints, + aggregate=aggregate) + elif dataset == 'voc': + if task != 'bbox': + print('Only bbox analysis is supported for Pascal VOC') + print('Will report bbox results\n') + if metric not in [None, ['AP'], ['AP50']]: + print('Only the AP50 metric is supported for Pascal VOC') + print('Will report AP50 metric\n') + results = get_voc_style_results( + filename, prints=prints, aggregate=aggregate) + + return results + + +def get_distortions_from_file(filename): + + eval_output = mmcv.load(filename) + + return get_distortions_from_results(eval_output) + + +def get_distortions_from_results(eval_output): + distortions = [] + for i, distortion in enumerate(eval_output): + distortions.append(distortion.replace("_", " ")) + return distortions + + +def main(): + parser = ArgumentParser(description='Corruption Result Analysis') + parser.add_argument('filename', help='result file path') + parser.add_argument( + '--dataset', + type=str, + choices=['coco', 'voc', 'cityscapes'], + default='coco', + help='dataset type') + parser.add_argument( + '--task', + type=str, + nargs='+', + choices=['bbox', 'segm'], + default=['bbox'], + help='task to report') + parser.add_argument( + '--metric', + nargs='+', + choices=[ + None, 'AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'AR1', 'AR10', + 'AR100', 'ARs', 'ARm', 'ARl' + ], + default=None, + help='metric to report') + parser.add_argument( + '--prints', + type=str, + nargs='+', + choices=['P', 'mPC', 'rPC'], + default='mPC', + help='corruption benchmark metric to print') + parser.add_argument( + '--aggregate', + type=str, + choices=['all', 'benchmark'], + default='benchmark', + help='aggregate all results or only those \ + for benchmark corruptions') + + args = parser.parse_args() + + for task in args.task: + get_results( + args.filename, + dataset=args.dataset, + task=task, + metric=args.metric, + prints=args.prints, + aggregate=args.aggregate) + + +if __name__ == '__main__': + main() diff --git a/tools/slurm_test.sh b/tools/slurm_test.sh new file mode 100755 index 0000000..8950bc8 --- /dev/null +++ b/tools/slurm_test.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash + +set -x + +PARTITION=$1 +JOB_NAME=$2 +CONFIG=$3 +CHECKPOINT=$4 +GPUS=${GPUS:-8} +GPUS_PER_NODE=${GPUS_PER_NODE:-8} +CPUS_PER_TASK=${CPUS_PER_TASK:-5} +PY_ARGS=${@:5} +SRUN_ARGS=${SRUN_ARGS:-""} + +srun -p ${PARTITION} \ + --job-name=${JOB_NAME} \ + --gres=gpu:${GPUS_PER_NODE} \ + --ntasks=${GPUS} \ + --ntasks-per-node=${GPUS_PER_NODE} \ + --cpus-per-task=${CPUS_PER_TASK} \ + --kill-on-bad-exit=1 \ + ${SRUN_ARGS} \ + python -u tools/test.py ${CONFIG} ${CHECKPOINT} --launcher="slurm" ${PY_ARGS} diff --git a/tools/slurm_train.sh b/tools/slurm_train.sh new file mode 100755 index 0000000..45474c4 --- /dev/null +++ b/tools/slurm_train.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash + +set -x + +PARTITION=$1 +JOB_NAME=$2 +CONFIG=$3 +WORK_DIR=$4 +GPUS=${5:-8} +GPUS_PER_NODE=${GPUS_PER_NODE:-8} +CPUS_PER_TASK=${CPUS_PER_TASK:-5} +SRUN_ARGS=${SRUN_ARGS:-""} +PY_ARGS=${PY_ARGS:-"--validate"} + +srun -p ${PARTITION} \ + --job-name=${JOB_NAME} \ + --gres=gpu:${GPUS_PER_NODE} \ + --ntasks=${GPUS} \ + --ntasks-per-node=${GPUS_PER_NODE} \ + --cpus-per-task=${CPUS_PER_TASK} \ + --kill-on-bad-exit=1 \ + ${SRUN_ARGS} \ + python -u tools/train.py ${CONFIG} --work_dir=${WORK_DIR} --launcher="slurm" ${PY_ARGS} diff --git a/tools/test.py b/tools/test.py new file mode 100644 index 0000000..575cd50 --- /dev/null +++ b/tools/test.py @@ -0,0 +1,226 @@ +import argparse +import os +import os.path as osp +import shutil +import tempfile + +import mmcv +import torch +import torch.distributed as dist +from mmcv.parallel import MMDataParallel, MMDistributedDataParallel +from mmcv.runner import get_dist_info, load_checkpoint + +from mmdet.apis import init_dist +from mmdet.core import coco_eval, results2json, wrap_fp16_model +from mmdet.datasets import build_dataloader, build_dataset +from mmdet.models import build_detector + + +def single_gpu_test(model, data_loader, show=False): + model.eval() + results = [] + dataset = data_loader.dataset + prog_bar = mmcv.ProgressBar(len(dataset)) + for i, data in enumerate(data_loader): + with torch.no_grad(): + result = model(return_loss=False, rescale=not show, **data) + results.append(result) + + if show: + model.module.show_result(data, result, dataset.img_norm_cfg) + + batch_size = data['img'][0].size(0) + for _ in range(batch_size): + prog_bar.update() + return results + + +def multi_gpu_test(model, data_loader, tmpdir=None): + model.eval() + results = [] + dataset = data_loader.dataset + rank, world_size = get_dist_info() + if rank == 0: + prog_bar = mmcv.ProgressBar(len(dataset)) + for i, data in enumerate(data_loader): + with torch.no_grad(): + result = model(return_loss=False, rescale=True, **data) + results.append(result) + + if rank == 0: + batch_size = data['img'][0].size(0) + for _ in range(batch_size * world_size): + prog_bar.update() + + # collect results from all ranks + results = collect_results(results, len(dataset), tmpdir) + + return results + + +def collect_results(result_part, size, tmpdir=None): + rank, world_size = get_dist_info() + # create a tmp dir if it is not specified + if tmpdir is None: + MAX_LEN = 512 + # 32 is whitespace + dir_tensor = torch.full((MAX_LEN, ), + 32, + dtype=torch.uint8, + device='cuda') + if rank == 0: + tmpdir = tempfile.mkdtemp() + tmpdir = torch.tensor( + bytearray(tmpdir.encode()), dtype=torch.uint8, device='cuda') + dir_tensor[:len(tmpdir)] = tmpdir + dist.broadcast(dir_tensor, 0) + tmpdir = dir_tensor.cpu().numpy().tobytes().decode().rstrip() + else: + mmcv.mkdir_or_exist(tmpdir) + # dump the part result to the dir + mmcv.dump(result_part, osp.join(tmpdir, 'part_{}.pkl'.format(rank))) + dist.barrier() + # collect all parts + if rank != 0: + return None + else: + # load results of all parts from tmp dir + part_list = [] + for i in range(world_size): + part_file = osp.join(tmpdir, 'part_{}.pkl'.format(i)) + part_list.append(mmcv.load(part_file)) + # sort the results + ordered_results = [] + for res in zip(*part_list): + ordered_results.extend(list(res)) + # the dataloader may pad some samples + ordered_results = ordered_results[:size] + # remove tmp dir + shutil.rmtree(tmpdir) + return ordered_results + + +def parse_args(): + parser = argparse.ArgumentParser(description='MMDet test detector') + parser.add_argument('config', help='test config file path') + parser.add_argument('checkpoint', help='checkpoint file') + parser.add_argument('--out', default='./result.pkl',help='output result file') + parser.add_argument( + '--json_out', + default='./result.pkl.bbox', + help='output result file name without extension', + type=str) + parser.add_argument( + '--eval', + type=str, + nargs='+', + choices=['proposal', 'proposal_fast', 'bbox', 'segm', 'keypoints'], + default=['bbox'], + help='eval types') + parser.add_argument('--show', action='store_true', help='show results') + parser.add_argument('--tmpdir', help='tmp dir for writing some results') + parser.add_argument( + '--launcher', + choices=['none', 'pytorch', 'slurm', 'mpi'], + default='none', + help='job launcher') + parser.add_argument('--local_rank', type=int, default=0) + args = parser.parse_args() + if 'LOCAL_RANK' not in os.environ: + os.environ['LOCAL_RANK'] = str(args.local_rank) + return args + + +def main(): + args = parse_args() + + assert args.out or args.show or args.json_out, \ + ('Please specify at least one operation (save or show the results) ' + 'with the argument "--out" or "--show" or "--json_out"') + + if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): + raise ValueError('The output file must be a pkl file.') + + if args.json_out is not None and args.json_out.endswith('.json'): + args.json_out = args.json_out[:-5] + + cfg = mmcv.Config.fromfile(args.config) + # set cudnn_benchmark + if cfg.get('cudnn_benchmark', False): + torch.backends.cudnn.benchmark = True + cfg.model.pretrained = None + cfg.data.test.test_mode = True + + # init distributed env first, since logger depends on the dist info. + if args.launcher == 'none': + distributed = False + else: + distributed = True + init_dist(args.launcher, **cfg.dist_params) + + # build the dataloader + # TODO: support multiple images per gpu (only minor changes are needed) + dataset = build_dataset(cfg.data.test) + data_loader = build_dataloader( + dataset, + imgs_per_gpu=1, + workers_per_gpu=cfg.data.workers_per_gpu, + dist=distributed, + shuffle=False) + + # build the model and load checkpoint + model = build_detector(cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) + fp16_cfg = cfg.get('fp16', None) + if fp16_cfg is not None: + wrap_fp16_model(model) + checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu') + # old versions did not save class info in checkpoints, this walkaround is + # for backward compatibility + if 'CLASSES' in checkpoint['meta']: + model.CLASSES = checkpoint['meta']['CLASSES'] + else: + model.CLASSES = dataset.CLASSES + + if not distributed: + model = MMDataParallel(model, device_ids=[0]) + outputs = single_gpu_test(model, data_loader, args.show) + else: + model = MMDistributedDataParallel(model.cuda()) + outputs = multi_gpu_test(model, data_loader, args.tmpdir) + + rank, _ = get_dist_info() + if args.out and rank == 0: + print('\nwriting results to {}'.format(args.out)) + mmcv.dump(outputs, args.out) + eval_types = args.eval + if eval_types: + print('Starting evaluate {}'.format(' and '.join(eval_types))) + if eval_types == ['proposal_fast']: + result_file = args.out + coco_eval(result_file, eval_types, dataset.coco) + else: + if not isinstance(outputs[0], dict): + result_files = results2json(dataset, outputs, args.out) + coco_eval(result_files, eval_types, dataset.coco) + else: + for name in outputs[0]: + print('\nEvaluating {}'.format(name)) + outputs_ = [out[name] for out in outputs] + result_file = args.out + '.{}'.format(name) + result_files = results2json(dataset, outputs_, + result_file) + coco_eval(result_files, eval_types, dataset.coco) + + # Save predictions in the COCO json format + if args.json_out and rank == 0: + if not isinstance(outputs[0], dict): + results2json(dataset, outputs, args.json_out) + else: + for name in outputs[0]: + outputs_ = [out[name] for out in outputs] + result_file = args.json_out + '.{}'.format(name) + results2json(dataset, outputs_, result_file) + + +if __name__ == '__main__': + main() diff --git a/tools/test_robustness.py b/tools/test_robustness.py new file mode 100644 index 0000000..584654b --- /dev/null +++ b/tools/test_robustness.py @@ -0,0 +1,469 @@ +import argparse +import os +import os.path as osp +import shutil +import tempfile + +import mmcv +import numpy as np +import torch +import torch.distributed as dist +from mmcv.parallel import MMDataParallel, MMDistributedDataParallel +from mmcv.runner import get_dist_info, load_checkpoint +from pycocotools.coco import COCO +from pycocotools.cocoeval import COCOeval +from robustness_eval import get_results + +from mmdet import datasets +from mmdet.apis import init_dist, set_random_seed +from mmdet.core import (eval_map, fast_eval_recall, results2json, + wrap_fp16_model) +from mmdet.datasets import build_dataloader, build_dataset +from mmdet.models import build_detector + + +def coco_eval_with_return(result_files, + result_types, + coco, + max_dets=(100, 300, 1000)): + for res_type in result_types: + assert res_type in [ + 'proposal', 'proposal_fast', 'bbox', 'segm', 'keypoints' + ] + + if mmcv.is_str(coco): + coco = COCO(coco) + assert isinstance(coco, COCO) + + if result_types == ['proposal_fast']: + ar = fast_eval_recall(result_files, coco, np.array(max_dets)) + for i, num in enumerate(max_dets): + print('AR@{}\t= {:.4f}'.format(num, ar[i])) + return + + eval_results = {} + for res_type in result_types: + result_file = result_files[res_type] + assert result_file.endswith('.json') + + coco_dets = coco.loadRes(result_file) + img_ids = coco.getImgIds() + iou_type = 'bbox' if res_type == 'proposal' else res_type + cocoEval = COCOeval(coco, coco_dets, iou_type) + cocoEval.params.imgIds = img_ids + if res_type == 'proposal': + cocoEval.params.useCats = 0 + cocoEval.params.maxDets = list(max_dets) + cocoEval.evaluate() + cocoEval.accumulate() + cocoEval.summarize() + if res_type == 'segm' or res_type == 'bbox': + metric_names = [ + 'AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'AR1', 'AR10', + 'AR100', 'ARs', 'ARm', 'ARl' + ] + eval_results[res_type] = { + metric_names[i]: cocoEval.stats[i] + for i in range(len(metric_names)) + } + else: + eval_results[res_type] = cocoEval.stats + + return eval_results + + +def voc_eval_with_return(result_file, + dataset, + iou_thr=0.5, + print_summary=True, + only_ap=True): + det_results = mmcv.load(result_file) + gt_bboxes = [] + gt_labels = [] + gt_ignore = [] + for i in range(len(dataset)): + ann = dataset.get_ann_info(i) + bboxes = ann['bboxes'] + labels = ann['labels'] + if 'bboxes_ignore' in ann: + ignore = np.concatenate([ + np.zeros(bboxes.shape[0], dtype=np.bool), + np.ones(ann['bboxes_ignore'].shape[0], dtype=np.bool) + ]) + gt_ignore.append(ignore) + bboxes = np.vstack([bboxes, ann['bboxes_ignore']]) + labels = np.concatenate([labels, ann['labels_ignore']]) + gt_bboxes.append(bboxes) + gt_labels.append(labels) + if not gt_ignore: + gt_ignore = gt_ignore + if hasattr(dataset, 'year') and dataset.year == 2007: + dataset_name = 'voc07' + else: + dataset_name = dataset.CLASSES + mean_ap, eval_results = eval_map( + det_results, + gt_bboxes, + gt_labels, + gt_ignore=gt_ignore, + scale_ranges=None, + iou_thr=iou_thr, + dataset=dataset_name, + print_summary=print_summary) + + if only_ap: + eval_results = [{ + 'ap': eval_results[i]['ap'] + } for i in range(len(eval_results))] + + return mean_ap, eval_results + + +def single_gpu_test(model, data_loader, show=False): + model.eval() + results = [] + dataset = data_loader.dataset + prog_bar = mmcv.ProgressBar(len(dataset)) + for i, data in enumerate(data_loader): + with torch.no_grad(): + result = model(return_loss=False, rescale=not show, **data) + results.append(result) + + if show: + model.module.show_result(data, result, dataset.img_norm_cfg) + + batch_size = data['img'][0].size(0) + for _ in range(batch_size): + prog_bar.update() + return results + + +def multi_gpu_test(model, data_loader, tmpdir=None): + model.eval() + results = [] + dataset = data_loader.dataset + rank, world_size = get_dist_info() + if rank == 0: + prog_bar = mmcv.ProgressBar(len(dataset)) + for i, data in enumerate(data_loader): + with torch.no_grad(): + result = model(return_loss=False, rescale=True, **data) + results.append(result) + + if rank == 0: + batch_size = data['img'][0].size(0) + for _ in range(batch_size * world_size): + prog_bar.update() + + # collect results from all ranks + results = collect_results(results, len(dataset), tmpdir) + + return results + + +def collect_results(result_part, size, tmpdir=None): + rank, world_size = get_dist_info() + # create a tmp dir if it is not specified + if tmpdir is None: + MAX_LEN = 512 + # 32 is whitespace + dir_tensor = torch.full((MAX_LEN, ), + 32, + dtype=torch.uint8, + device='cuda') + if rank == 0: + tmpdir = tempfile.mkdtemp() + tmpdir = torch.tensor( + bytearray(tmpdir.encode()), dtype=torch.uint8, device='cuda') + dir_tensor[:len(tmpdir)] = tmpdir + dist.broadcast(dir_tensor, 0) + tmpdir = dir_tensor.cpu().numpy().tobytes().decode().rstrip() + else: + mmcv.mkdir_or_exist(tmpdir) + # dump the part result to the dir + mmcv.dump(result_part, osp.join(tmpdir, 'part_{}.pkl'.format(rank))) + dist.barrier() + # collect all parts + if rank != 0: + return None + else: + # load results of all parts from tmp dir + part_list = [] + for i in range(world_size): + part_file = osp.join(tmpdir, 'part_{}.pkl'.format(i)) + part_list.append(mmcv.load(part_file)) + # sort the results + ordered_results = [] + for res in zip(*part_list): + ordered_results.extend(list(res)) + # the dataloader may pad some samples + ordered_results = ordered_results[:size] + # remove tmp dir + shutil.rmtree(tmpdir) + return ordered_results + + +def parse_args(): + parser = argparse.ArgumentParser(description='MMDet test detector') + parser.add_argument('config', help='test config file path') + parser.add_argument('checkpoint', help='checkpoint file') + parser.add_argument('--out', help='output result file') + parser.add_argument( + '--corruptions', + type=str, + nargs='+', + default='benchmark', + choices=[ + 'all', 'benchmark', 'noise', 'blur', 'weather', 'digital', + 'holdout', 'None', 'gaussian_noise', 'shot_noise', 'impulse_noise', + 'defocus_blur', 'glass_blur', 'motion_blur', 'zoom_blur', 'snow', + 'frost', 'fog', 'brightness', 'contrast', 'elastic_transform', + 'pixelate', 'jpeg_compression', 'speckle_noise', 'gaussian_blur', + 'spatter', 'saturate' + ], + help='corruptions') + parser.add_argument( + '--severities', + type=int, + nargs='+', + default=[0, 1, 2, 3, 4, 5], + help='corruption severity levels') + parser.add_argument( + '--eval', + type=str, + nargs='+', + choices=['proposal', 'proposal_fast', 'bbox', 'segm', 'keypoints'], + help='eval types') + parser.add_argument( + '--iou-thr', + type=float, + default=0.5, + help='IoU threshold for pascal voc evaluation') + parser.add_argument( + '--summaries', + type=bool, + default=False, + help='Print summaries for every corruption and severity') + parser.add_argument( + '--workers', type=int, default=32, help='workers per gpu') + parser.add_argument('--show', action='store_true', help='show results') + parser.add_argument('--tmpdir', help='tmp dir for writing some results') + parser.add_argument('--seed', type=int, default=None, help='random seed') + parser.add_argument( + '--launcher', + choices=['none', 'pytorch', 'slurm', 'mpi'], + default='none', + help='job launcher') + parser.add_argument('--local_rank', type=int, default=0) + parser.add_argument( + '--final-prints', + type=str, + nargs='+', + choices=['P', 'mPC', 'rPC'], + default='mPC', + help='corruption benchmark metric to print at the end') + parser.add_argument( + '--final-prints-aggregate', + type=str, + choices=['all', 'benchmark'], + default='benchmark', + help='aggregate all results or only those for benchmark corruptions') + args = parser.parse_args() + if 'LOCAL_RANK' not in os.environ: + os.environ['LOCAL_RANK'] = str(args.local_rank) + return args + + +def main(): + args = parse_args() + + assert args.out or args.show, \ + ('Please specify at least one operation (save or show the results) ' + 'with the argument "--out" or "--show"') + + if args.out is not None and not args.out.endswith(('.pkl', '.pickle')): + raise ValueError('The output file must be a pkl file.') + + cfg = mmcv.Config.fromfile(args.config) + # set cudnn_benchmark + if cfg.get('cudnn_benchmark', False): + torch.backends.cudnn.benchmark = True + cfg.model.pretrained = None + cfg.data.test.test_mode = True + if args.workers == 0: + args.workers = cfg.data.workers_per_gpu + + # init distributed env first, since logger depends on the dist info. + if args.launcher == 'none': + distributed = False + else: + distributed = True + init_dist(args.launcher, **cfg.dist_params) + + # set random seeds + if args.seed is not None: + set_random_seed(args.seed) + + if 'all' in args.corruptions: + corruptions = [ + 'gaussian_noise', 'shot_noise', 'impulse_noise', 'defocus_blur', + 'glass_blur', 'motion_blur', 'zoom_blur', 'snow', 'frost', 'fog', + 'brightness', 'contrast', 'elastic_transform', 'pixelate', + 'jpeg_compression', 'speckle_noise', 'gaussian_blur', 'spatter', + 'saturate' + ] + elif 'benchmark' in args.corruptions: + corruptions = [ + 'gaussian_noise', 'shot_noise', 'impulse_noise', 'defocus_blur', + 'glass_blur', 'motion_blur', 'zoom_blur', 'snow', 'frost', 'fog', + 'brightness', 'contrast', 'elastic_transform', 'pixelate', + 'jpeg_compression' + ] + elif 'noise' in args.corruptions: + corruptions = ['gaussian_noise', 'shot_noise', 'impulse_noise'] + elif 'blur' in args.corruptions: + corruptions = [ + 'defocus_blur', 'glass_blur', 'motion_blur', 'zoom_blur' + ] + elif 'weather' in args.corruptions: + corruptions = ['snow', 'frost', 'fog', 'brightness'] + elif 'digital' in args.corruptions: + corruptions = [ + 'contrast', 'elastic_transform', 'pixelate', 'jpeg_compression' + ] + elif 'holdout' in args.corruptions: + corruptions = ['speckle_noise', 'gaussian_blur', 'spatter', 'saturate'] + elif 'None' in args.corruptions: + corruptions = ['None'] + args.severities = [0] + else: + corruptions = args.corruptions + + aggregated_results = {} + for corr_i, corruption in enumerate(corruptions): + aggregated_results[corruption] = {} + for sev_i, corruption_severity in enumerate(args.severities): + # evaluate severity 0 (= no corruption) only once + if corr_i > 0 and corruption_severity == 0: + aggregated_results[corruption][0] = \ + aggregated_results[corruptions[0]][0] + continue + + # assign corruption and severity + if corruption_severity == 0: + # evaluate without corruptions for severity = 0 + cfg.data.test['corruption'] = None + cfg.data.test['corruption_severity'] = 0 + else: + cfg.data.test['corruption'] = corruption + cfg.data.test['corruption_severity'] = corruption_severity + + # print info + print('\nTesting {} at severity {}'.format(corruption, + corruption_severity)) + + # build the dataloader + # TODO: support multiple images per gpu + # (only minor changes are needed) + dataset = build_dataset(cfg.data.test) + data_loader = build_dataloader( + dataset, + imgs_per_gpu=1, + workers_per_gpu=args.workers, + dist=distributed, + shuffle=False) + + # build the model and load checkpoint + model = build_detector( + cfg.model, train_cfg=None, test_cfg=cfg.test_cfg) + fp16_cfg = cfg.get('fp16', None) + if fp16_cfg is not None: + wrap_fp16_model(model) + checkpoint = load_checkpoint( + model, args.checkpoint, map_location='cpu') + # old versions did not save class info in checkpoints, + # this walkaround is for backward compatibility + if 'CLASSES' in checkpoint['meta']: + model.CLASSES = checkpoint['meta']['CLASSES'] + else: + model.CLASSES = dataset.CLASSES + + if not distributed: + model = MMDataParallel(model, device_ids=[0]) + outputs = single_gpu_test(model, data_loader, args.show) + else: + model = MMDistributedDataParallel(model.cuda()) + outputs = multi_gpu_test(model, data_loader, args.tmpdir) + + rank, _ = get_dist_info() + if args.out and rank == 0: + eval_results_filename = ( + osp.splitext(args.out)[0] + '_results' + + osp.splitext(args.out)[1]) + mmcv.dump(outputs, args.out) + eval_types = args.eval + if cfg.dataset_type == 'VOCDataset': + if eval_types: + for eval_type in eval_types: + if eval_type == 'bbox': + test_dataset = mmcv.runner.obj_from_dict( + cfg.data.test, datasets) + mean_ap, eval_results = \ + voc_eval_with_return( + args.out, test_dataset, + args.iou_thr, args.summaries) + aggregated_results[corruption][ + corruption_severity] = eval_results + else: + print('\nOnly "bbox" evaluation \ + is supported for pascal voc') + else: + if eval_types: + print('Starting evaluate {}'.format( + ' and '.join(eval_types))) + if eval_types == ['proposal_fast']: + result_file = args.out + else: + if not isinstance(outputs[0], dict): + result_files = results2json( + dataset, outputs, args.out) + else: + for name in outputs[0]: + print('\nEvaluating {}'.format(name)) + outputs_ = [out[name] for out in outputs] + result_file = args.out + + '.{}'.format(name) + result_files = results2json( + dataset, outputs_, result_file) + eval_results = coco_eval_with_return( + result_files, eval_types, dataset.coco) + aggregated_results[corruption][ + corruption_severity] = eval_results + else: + print('\nNo task was selected for evaluation;' + '\nUse --eval to select a task') + + # save results after each evaluation + mmcv.dump(aggregated_results, eval_results_filename) + + # print filan results + print('\nAggregated results:') + prints = args.final_prints + aggregate = args.final_prints_aggregate + + if cfg.dataset_type == 'VOCDataset': + get_results( + eval_results_filename, + dataset='voc', + prints=prints, + aggregate=aggregate) + else: + get_results( + eval_results_filename, + dataset='coco', + prints=prints, + aggregate=aggregate) + + +if __name__ == '__main__': + main() diff --git a/tools/train.py b/tools/train.py new file mode 100644 index 0000000..0854163 --- /dev/null +++ b/tools/train.py @@ -0,0 +1,108 @@ +from __future__ import division +import argparse +import os + +import torch +from mmcv import Config + +from mmdet import __version__ +from mmdet.apis import (get_root_logger, init_dist, set_random_seed, + train_detector) +from mmdet.datasets import build_dataset +from mmdet.models import build_detector + + +def parse_args(): + parser = argparse.ArgumentParser(description='Train a detector') + parser.add_argument('config', help='train config file path') + parser.add_argument('--work_dir', help='the dir to save logs and models') + parser.add_argument( + '--resume_from', help='the checkpoint file to resume from') + parser.add_argument( + '--validate', + action='store_true', + help='whether to evaluate the checkpoint during training') + parser.add_argument( + '--gpus', + type=int, + default=1, + help='number of gpus to use ' + '(only applicable to non-distributed training)') + parser.add_argument('--seed', type=int, default=None, help='random seed') + parser.add_argument( + '--launcher', + choices=['none', 'pytorch', 'slurm', 'mpi'], + default='none', + help='job launcher') + parser.add_argument('--local_rank', type=int, default=0) + parser.add_argument( + '--autoscale-lr', + action='store_true', + help='automatically scale lr with the number of gpus') + args = parser.parse_args() + if 'LOCAL_RANK' not in os.environ: + os.environ['LOCAL_RANK'] = str(args.local_rank) + + return args + + +def main(): + args = parse_args() + + cfg = Config.fromfile(args.config) + # set cudnn_benchmark + if cfg.get('cudnn_benchmark', False): + torch.backends.cudnn.benchmark = True + # update configs according to CLI args + if args.work_dir is not None: + cfg.work_dir = args.work_dir + if args.resume_from is not None: + cfg.resume_from = args.resume_from + cfg.gpus = args.gpus + + if args.autoscale_lr: + # apply the linear scaling rule (https://arxiv.org/abs/1706.02677) + cfg.optimizer['lr'] = cfg.optimizer['lr'] * cfg.gpus / 8 + + # init distributed env first, since logger depends on the dist info. + if args.launcher == 'none': + distributed = False + else: + distributed = True + init_dist(args.launcher, **cfg.dist_params) + + # init logger before other steps + logger = get_root_logger(cfg.log_level) + logger.info('Distributed training: {}'.format(distributed)) + + # set random seeds + if args.seed is not None: + logger.info('Set random seed to {}'.format(args.seed)) + set_random_seed(args.seed) + + model = build_detector( + cfg.model, train_cfg=cfg.train_cfg, test_cfg=cfg.test_cfg) + + datasets = [build_dataset(cfg.data.train)] + if len(cfg.workflow) == 2: + datasets.append(build_dataset(cfg.data.val)) + if cfg.checkpoint_config is not None: + # save mmdet version, config file content and class names in + # checkpoints as meta data + cfg.checkpoint_config.meta = dict( + mmdet_version=__version__, + config=cfg.text, + CLASSES=datasets[0].CLASSES) + # add an attribute for visualization convenience + model.CLASSES = datasets[0].CLASSES + train_detector( + model, + datasets, + cfg, + distributed=distributed, + validate=args.validate, + logger=logger) + + +if __name__ == '__main__': + main() diff --git a/tools/upgrade_model_version.py b/tools/upgrade_model_version.py new file mode 100644 index 0000000..00bcdf4 --- /dev/null +++ b/tools/upgrade_model_version.py @@ -0,0 +1,42 @@ +import argparse +import re +from collections import OrderedDict + +import torch + + +def convert(in_file, out_file): + """Convert keys in checkpoints. + + There can be some breaking changes during the development of mmdetection, + and this tool is used for upgrading checkpoints trained with old versions + to the latest one. + """ + checkpoint = torch.load(in_file) + in_state_dict = checkpoint.pop('state_dict') + out_state_dict = OrderedDict() + for key, val in in_state_dict.items(): + # Use ConvModule instead of nn.Conv2d in RetinaNet + # cls_convs.0.weight -> cls_convs.0.conv.weight + m = re.search(r'(cls_convs|reg_convs).\d.(weight|bias)', key) + if m is not None: + param = m.groups()[1] + new_key = key.replace(param, 'conv.{}'.format(param)) + out_state_dict[new_key] = val + continue + + out_state_dict[key] = val + checkpoint['state_dict'] = out_state_dict + torch.save(checkpoint, out_file) + + +def main(): + parser = argparse.ArgumentParser(description='Upgrade model version') + parser.add_argument('in_file', help='input checkpoint file') + parser.add_argument('out_file', help='output checkpoint file') + args = parser.parse_args() + convert(args.in_file, args.out_file) + + +if __name__ == '__main__': + main() diff --git a/tools/voc_eval.py b/tools/voc_eval.py new file mode 100644 index 0000000..478ec3c --- /dev/null +++ b/tools/voc_eval.py @@ -0,0 +1,62 @@ +from argparse import ArgumentParser + +import mmcv +import numpy as np + +from mmdet import datasets +from mmdet.core import eval_map + + +def voc_eval(result_file, dataset, iou_thr=0.5): + det_results = mmcv.load(result_file) + gt_bboxes = [] + gt_labels = [] + gt_ignore = [] + for i in range(len(dataset)): + ann = dataset.get_ann_info(i) + bboxes = ann['bboxes'] + labels = ann['labels'] + if 'bboxes_ignore' in ann: + ignore = np.concatenate([ + np.zeros(bboxes.shape[0], dtype=np.bool), + np.ones(ann['bboxes_ignore'].shape[0], dtype=np.bool) + ]) + gt_ignore.append(ignore) + bboxes = np.vstack([bboxes, ann['bboxes_ignore']]) + labels = np.concatenate([labels, ann['labels_ignore']]) + gt_bboxes.append(bboxes) + gt_labels.append(labels) + if not gt_ignore: + gt_ignore = gt_ignore + if hasattr(dataset, 'year') and dataset.year == 2007: + dataset_name = 'voc07' + else: + dataset_name = dataset.CLASSES + eval_map( + det_results, + gt_bboxes, + gt_labels, + gt_ignore=gt_ignore, + scale_ranges=None, + iou_thr=iou_thr, + dataset=dataset_name, + print_summary=True) + + +def main(): + parser = ArgumentParser(description='VOC Evaluation') + parser.add_argument('result', help='result file path') + parser.add_argument('config', help='config file path') + parser.add_argument( + '--iou-thr', + type=float, + default=0.5, + help='IoU threshold for evaluation') + args = parser.parse_args() + cfg = mmcv.Config.fromfile(args.config) + test_dataset = mmcv.runner.obj_from_dict(cfg.data.test, datasets) + voc_eval(args.result, test_dataset, args.iou_thr) + + +if __name__ == '__main__': + main()