Full Code of Duankaiwen/LSNet for AI

gitextract_ye5co4e2/

├── README.md
├── checkpoints/
│   └── 000.txt
├── code/
│   ├── LICENSE
│   ├── ThirdPartyNotices.txt
│   ├── cocoapi/
│   │   ├── .github/
│   │   │   └── workflows/
│   │   │       ├── build.yml
│   │   │       └── deploy.yml
│   │   ├── .gitignore
│   │   ├── .isort.cfg
│   │   ├── .pre-commit-config.yaml
│   │   ├── MANIFEST.in
│   │   ├── README.md
│   │   ├── license.txt
│   │   ├── lvis/
│   │   │   ├── lvis/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── colormap.py
│   │   │   │   ├── eval.py
│   │   │   │   ├── lvis.py
│   │   │   │   ├── results.py
│   │   │   │   └── vis.py
│   │   │   ├── requirements.txt
│   │   │   └── setup.py
│   │   └── pycocotools/
│   │       ├── MANIFEST.in
│   │       ├── Makefile
│   │       ├── common/
│   │       │   ├── gason.cpp
│   │       │   ├── gason.h
│   │       │   ├── maskApi.c
│   │       │   └── maskApi.h
│   │       ├── pycocoDemo.ipynb
│   │       ├── pycocoEvalDemo.ipynb
│   │       ├── pycocotools/
│   │       │   ├── __init__.py
│   │       │   ├── _mask.pyx
│   │       │   ├── coco.py
│   │       │   ├── cocoeval.py
│   │       │   └── mask.py
│   │       └── setup.py
│   ├── configs/
│   │   ├── _base_/
│   │   │   ├── datasets/
│   │   │   │   ├── cityscapes_detection.py
│   │   │   │   ├── cityscapes_instance.py
│   │   │   │   ├── coco_detection.py
│   │   │   │   ├── coco_instance.py
│   │   │   │   ├── coco_instance_semantic.py
│   │   │   │   ├── coco_lsvr.py
│   │   │   │   ├── coco_pose.py
│   │   │   │   ├── deepfashion.py
│   │   │   │   ├── lvis_instance.py
│   │   │   │   ├── voc0712.py
│   │   │   │   └── wider_face.py
│   │   │   ├── default_runtime.py
│   │   │   ├── models/
│   │   │   │   ├── cascade_mask_rcnn_r50_fpn.py
│   │   │   │   ├── cascade_rcnn_r50_fpn.py
│   │   │   │   ├── fast_rcnn_r50_fpn.py
│   │   │   │   ├── faster_rcnn_r50_caffe_c4.py
│   │   │   │   ├── faster_rcnn_r50_fpn.py
│   │   │   │   ├── mask_rcnn_r50_caffe_c4.py
│   │   │   │   ├── mask_rcnn_r50_fpn.py
│   │   │   │   ├── retinanet_r50_fpn.py
│   │   │   │   ├── rpn_r50_caffe_c4.py
│   │   │   │   ├── rpn_r50_fpn.py
│   │   │   │   └── ssd300.py
│   │   │   └── schedules/
│   │   │       ├── schedule_1x.py
│   │   │       ├── schedule_20e.py
│   │   │       └── schedule_2x.py
│   │   └── lsnet/
│   │       ├── lsnet_bbox_cpv_res2_101_fpn_dconv_c3-c5_mstrain_2x_coco.py
│   │       ├── lsnet_bbox_cpv_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py
│   │       ├── lsnet_bbox_r50_fpn_1x_coco.py
│   │       ├── lsnet_bbox_r50_fpn_mstrain_2x_coco.py
│   │       ├── lsnet_bbox_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py.py
│   │       ├── lsnet_bbox_x101_fpn_mstrain_2x_coco.py
│   │       ├── lsnet_pose_bbox_r50_fpn_1x_coco.py
│   │       ├── lsnet_pose_bbox_r50_fpn_mstrain_2x_coco.py
│   │       ├── lsnet_pose_bbox_res2_101_fpn_dconv_c3-c5_mstrain_2x_coco.py
│   │       ├── lsnet_pose_bbox_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py
│   │       ├── lsnet_pose_kbox_res2_101_fpn_dconv_c3-c5_mstrain_2x_coco.py
│   │       ├── lsnet_pose_kbox_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py
│   │       ├── lsnet_segm_r50_fpn_1x_coco.py
│   │       ├── lsnet_segm_r50_fpn_mstrain_2x_coco.py
│   │       ├── lsnet_segm_res2_101_fpn_dconv_c3-c5_mstrain_30e_coco.py
│   │       ├── lsnet_segm_x101_fpn_dconv_c3-c5_mstrain_30e_coco.py
│   │       └── lsnet_segm_x101_fpn_mstrain_30e_coco.py
│   ├── docker/
│   │   └── Dockerfile
│   ├── docs/
│   │   ├── Makefile
│   │   ├── api.rst
│   │   ├── changelog.md
│   │   ├── compatibility.md
│   │   ├── conf.py
│   │   ├── config.md
│   │   ├── getting_started.md
│   │   ├── index.rst
│   │   ├── install.md
│   │   ├── make.bat
│   │   ├── model_zoo.md
│   │   ├── projects.md
│   │   ├── robustness_benchmarking.md
│   │   └── tutorials/
│   │       ├── data_pipeline.md
│   │       ├── finetune.md
│   │       ├── new_dataset.md
│   │       └── new_modules.md
│   ├── mmcv/
│   │   ├── .dockerignore
│   │   ├── .github/
│   │   │   └── workflows/
│   │   │       ├── build.yml
│   │   │       └── publish-to-pypi.yml
│   │   ├── .gitignore
│   │   ├── .pre-commit-config.yaml
│   │   ├── .readthedocs.yml
│   │   ├── CONTRIBUTING.md
│   │   ├── Dockerfile
│   │   ├── LICENSE
│   │   ├── MANIFEST.in
│   │   ├── README.rst
│   │   ├── docs/
│   │   │   ├── Makefile
│   │   │   ├── api.rst
│   │   │   ├── cnn.md
│   │   │   ├── conf.py
│   │   │   ├── image.md
│   │   │   ├── index.rst
│   │   │   ├── io.md
│   │   │   ├── make.bat
│   │   │   ├── model_zoo.md
│   │   │   ├── requirements.txt
│   │   │   ├── runner.md
│   │   │   ├── utils.md
│   │   │   ├── video.md
│   │   │   └── visualization.md
│   │   ├── examples/
│   │   │   ├── config_cifar10.py
│   │   │   ├── dist_train_cifar10.sh
│   │   │   ├── resnet_cifar.py
│   │   │   └── train_cifar10.py
│   │   ├── mmcv/
│   │   │   ├── __init__.py
│   │   │   ├── arraymisc/
│   │   │   │   ├── __init__.py
│   │   │   │   └── quantization.py
│   │   │   ├── cnn/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── alexnet.py
│   │   │   │   ├── bricks/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── activation.py
│   │   │   │   │   ├── conv.py
│   │   │   │   │   ├── conv_module.py
│   │   │   │   │   ├── hsigmoid.py
│   │   │   │   │   ├── hswish.py
│   │   │   │   │   ├── non_local.py
│   │   │   │   │   ├── norm.py
│   │   │   │   │   ├── padding.py
│   │   │   │   │   ├── registry.py
│   │   │   │   │   ├── scale.py
│   │   │   │   │   └── upsample.py
│   │   │   │   ├── resnet.py
│   │   │   │   ├── utils/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── flops_counter.py
│   │   │   │   │   └── weight_init.py
│   │   │   │   └── vgg.py
│   │   │   ├── fileio/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── file_client.py
│   │   │   │   ├── handlers/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── base.py
│   │   │   │   │   ├── json_handler.py
│   │   │   │   │   ├── pickle_handler.py
│   │   │   │   │   └── yaml_handler.py
│   │   │   │   ├── io.py
│   │   │   │   └── parse.py
│   │   │   ├── image/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── colorspace.py
│   │   │   │   ├── geometric.py
│   │   │   │   ├── io.py
│   │   │   │   └── photometric.py
│   │   │   ├── model_zoo/
│   │   │   │   ├── deprecated.json
│   │   │   │   └── open_mmlab.json
│   │   │   ├── parallel/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── _functions.py
│   │   │   │   ├── collate.py
│   │   │   │   ├── data_container.py
│   │   │   │   ├── data_parallel.py
│   │   │   │   ├── distributed.py
│   │   │   │   ├── distributed_deprecated.py
│   │   │   │   ├── registry.py
│   │   │   │   ├── scatter_gather.py
│   │   │   │   └── utils.py
│   │   │   ├── runner/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── base_runner.py
│   │   │   │   ├── checkpoint.py
│   │   │   │   ├── dist_utils.py
│   │   │   │   ├── epoch_based_runner.py
│   │   │   │   ├── hooks/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── checkpoint.py
│   │   │   │   │   ├── closure.py
│   │   │   │   │   ├── hook.py
│   │   │   │   │   ├── iter_timer.py
│   │   │   │   │   ├── logger/
│   │   │   │   │   │   ├── __init__.py
│   │   │   │   │   │   ├── base.py
│   │   │   │   │   │   ├── mlflow.py
│   │   │   │   │   │   ├── pavi.py
│   │   │   │   │   │   ├── tensorboard.py
│   │   │   │   │   │   ├── text.py
│   │   │   │   │   │   └── wandb.py
│   │   │   │   │   ├── lr_updater.py
│   │   │   │   │   ├── memory.py
│   │   │   │   │   ├── momentum_updater.py
│   │   │   │   │   ├── optimizer.py
│   │   │   │   │   └── sampler_seed.py
│   │   │   │   ├── iter_based_runner.py
│   │   │   │   ├── log_buffer.py
│   │   │   │   ├── optimizer/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── builder.py
│   │   │   │   │   └── default_constructor.py
│   │   │   │   ├── priority.py
│   │   │   │   └── utils.py
│   │   │   ├── utils/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── config.py
│   │   │   │   ├── env.py
│   │   │   │   ├── logging.py
│   │   │   │   ├── misc.py
│   │   │   │   ├── parrots_wrapper.py
│   │   │   │   ├── path.py
│   │   │   │   ├── progressbar.py
│   │   │   │   ├── registry.py
│   │   │   │   └── timer.py
│   │   │   ├── version.py
│   │   │   ├── video/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── io.py
│   │   │   │   ├── optflow.py
│   │   │   │   ├── optflow_warp/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── flow_warp.cpp
│   │   │   │   │   ├── flow_warp.hpp
│   │   │   │   │   └── flow_warp_module.pyx
│   │   │   │   └── processing.py
│   │   │   └── visualization/
│   │   │       ├── __init__.py
│   │   │       ├── color.py
│   │   │       ├── image.py
│   │   │       └── optflow.py
│   │   ├── requirements.txt
│   │   ├── setup.cfg
│   │   ├── setup.py
│   │   └── tests/
│   │       ├── data/
│   │       │   ├── config/
│   │       │   │   ├── a.b.py
│   │       │   │   ├── a.py
│   │       │   │   ├── b.json
│   │       │   │   ├── base.py
│   │       │   │   ├── c.yaml
│   │       │   │   ├── code.py
│   │       │   │   ├── d.py
│   │       │   │   ├── delete.py
│   │       │   │   ├── e.py
│   │       │   │   ├── f.py
│   │       │   │   ├── g.py
│   │       │   │   ├── i_base.py
│   │       │   │   ├── i_child.py
│   │       │   │   ├── l.py
│   │       │   │   ├── l1.py
│   │       │   │   ├── l2.yaml
│   │       │   │   ├── l3.json
│   │       │   │   ├── l4.py
│   │       │   │   ├── m.py
│   │       │   │   └── n.py
│   │       │   ├── demo.lmdb/
│   │       │   │   ├── data.mdb
│   │       │   │   └── lock.mdb
│   │       │   ├── filelist.txt
│   │       │   ├── for_scan/
│   │       │   │   ├── 1.json
│   │       │   │   ├── 1.txt
│   │       │   │   ├── 2.json
│   │       │   │   ├── 2.txt
│   │       │   │   └── sub/
│   │       │   │       ├── 1.json
│   │       │   │       └── 1.txt
│   │       │   ├── mapping.txt
│   │       │   ├── model_zoo/
│   │       │   │   ├── deprecated.json
│   │       │   │   ├── mmcv_home/
│   │       │   │   │   ├── open_mmlab.json
│   │       │   │   │   ├── test.pth
│   │       │   │   │   └── val.pth
│   │       │   │   └── open_mmlab.json
│   │       │   ├── optflow.flo
│   │       │   └── patches/
│   │       │       ├── 0.npy
│   │       │       ├── 1.npy
│   │       │       ├── 2.npy
│   │       │       ├── 3.npy
│   │       │       ├── 4.npy
│   │       │       ├── pad0_0.npy
│   │       │       ├── pad0_1.npy
│   │       │       ├── pad0_2.npy
│   │       │       ├── pad0_3.npy
│   │       │       ├── pad0_4.npy
│   │       │       ├── pad_0.npy
│   │       │       ├── pad_1.npy
│   │       │       ├── pad_2.npy
│   │       │       ├── pad_3.npy
│   │       │       ├── pad_4.npy
│   │       │       ├── scale_0.npy
│   │       │       ├── scale_1.npy
│   │       │       ├── scale_2.npy
│   │       │       ├── scale_3.npy
│   │       │       └── scale_4.npy
│   │       ├── test_arraymisc.py
│   │       ├── test_cnn/
│   │       │   ├── test_build_layers.py
│   │       │   ├── test_conv_module.py
│   │       │   ├── test_flops_counter.py
│   │       │   ├── test_hsigmoid.py
│   │       │   ├── test_hswish.py
│   │       │   ├── test_non_local.py
│   │       │   ├── test_scale.py
│   │       │   └── test_weight_init.py
│   │       ├── test_config.py
│   │       ├── test_fileclient.py
│   │       ├── test_fileio.py
│   │       ├── test_image/
│   │       │   ├── test_colorspace.py
│   │       │   ├── test_geometric.py
│   │       │   ├── test_io.py
│   │       │   └── test_photometric.py
│   │       ├── test_load_model_zoo.py
│   │       ├── test_logging.py
│   │       ├── test_misc.py
│   │       ├── test_optimizer.py
│   │       ├── test_parallel.py
│   │       ├── test_path.py
│   │       ├── test_progressbar.py
│   │       ├── test_registry.py
│   │       ├── test_runner/
│   │       │   ├── test_dist_utils.py
│   │       │   ├── test_hooks.py
│   │       │   └── test_runner.py
│   │       ├── test_timer.py
│   │       ├── test_video/
│   │       │   ├── test_optflow.py
│   │       │   ├── test_processing.py
│   │       │   └── test_reader.py
│   │       └── test_visualization.py
│   ├── mmdet/
│   │   ├── VERSION
│   │   ├── __init__.py
│   │   ├── apis/
│   │   │   ├── __init__.py
│   │   │   ├── inference.py
│   │   │   ├── test.py
│   │   │   └── train.py
│   │   ├── core/
│   │   │   ├── __init__.py
│   │   │   ├── anchor/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── anchor_generator.py
│   │   │   │   ├── builder.py
│   │   │   │   ├── point_generator.py
│   │   │   │   └── utils.py
│   │   │   ├── bbox/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── assigners/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── approx_max_iou_assigner.py
│   │   │   │   │   ├── assign_result.py
│   │   │   │   │   ├── atss_assigner.py
│   │   │   │   │   ├── base_assigner.py
│   │   │   │   │   ├── center_region_assigner.py
│   │   │   │   │   ├── centroid_assigner.py
│   │   │   │   │   ├── fcos_assigner.py
│   │   │   │   │   ├── max_iou_assigner.py
│   │   │   │   │   ├── point_assigner.py
│   │   │   │   │   ├── point_assigner_v2.py
│   │   │   │   │   ├── point_ct_assigner.py
│   │   │   │   │   └── point_hm_assigner.py
│   │   │   │   ├── builder.py
│   │   │   │   ├── coder/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── base_bbox_coder.py
│   │   │   │   │   ├── delta_xywh_bbox_coder.py
│   │   │   │   │   ├── legacy_delta_xywh_bbox_coder.py
│   │   │   │   │   ├── pseudo_bbox_coder.py
│   │   │   │   │   └── tblr_bbox_coder.py
│   │   │   │   ├── demodata.py
│   │   │   │   ├── iou_calculators/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── builder.py
│   │   │   │   │   └── iou2d_calculator.py
│   │   │   │   ├── samplers/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── base_sampler.py
│   │   │   │   │   ├── combined_sampler.py
│   │   │   │   │   ├── instance_balanced_pos_sampler.py
│   │   │   │   │   ├── iou_balanced_neg_sampler.py
│   │   │   │   │   ├── ohem_sampler.py
│   │   │   │   │   ├── pseudo_sampler.py
│   │   │   │   │   ├── random_sampler.py
│   │   │   │   │   ├── sampling_result.py
│   │   │   │   │   └── score_hlr_sampler.py
│   │   │   │   └── transforms.py
│   │   │   ├── evaluation/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── bbox_overlaps.py
│   │   │   │   ├── class_names.py
│   │   │   │   ├── eval_hooks.py
│   │   │   │   ├── mean_ap.py
│   │   │   │   └── recall.py
│   │   │   ├── fp16/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── decorators.py
│   │   │   │   ├── hooks.py
│   │   │   │   └── utils.py
│   │   │   ├── mask/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── mask_target.py
│   │   │   │   ├── structures.py
│   │   │   │   └── utils.py
│   │   │   ├── post_processing/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── bbox_nms.py
│   │   │   │   └── merge_augs.py
│   │   │   └── utils/
│   │   │       ├── __init__.py
│   │   │       ├── dist_utils.py
│   │   │       └── misc.py
│   │   ├── datasets/
│   │   │   ├── __init__.py
│   │   │   ├── builder.py
│   │   │   ├── cityscapes.py
│   │   │   ├── coco.py
│   │   │   ├── coco_pose.py
│   │   │   ├── custom.py
│   │   │   ├── dataset_wrappers.py
│   │   │   ├── deepfashion.py
│   │   │   ├── lvis.py
│   │   │   ├── pipelines/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── auto_augment.py
│   │   │   │   ├── compose.py
│   │   │   │   ├── formating.py
│   │   │   │   ├── formating_reppointsv2.py
│   │   │   │   ├── instaboost.py
│   │   │   │   ├── loading.py
│   │   │   │   ├── loading_reppointsv2.py
│   │   │   │   ├── test_time_aug.py
│   │   │   │   └── transforms.py
│   │   │   ├── samplers/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── distributed_sampler.py
│   │   │   │   └── group_sampler.py
│   │   │   ├── voc.py
│   │   │   ├── wider_face.py
│   │   │   └── xml_style.py
│   │   ├── models/
│   │   │   ├── __init__.py
│   │   │   ├── backbones/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── detectors_resnet.py
│   │   │   │   ├── detectors_resnext.py
│   │   │   │   ├── hourglass.py
│   │   │   │   ├── hrnet.py
│   │   │   │   ├── mobilenet.py
│   │   │   │   ├── regnet.py
│   │   │   │   ├── res2net.py
│   │   │   │   ├── resnet.py
│   │   │   │   ├── resnext.py
│   │   │   │   └── ssd_vgg.py
│   │   │   ├── builder.py
│   │   │   ├── dense_heads/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── anchor_free_head.py
│   │   │   │   ├── anchor_head.py
│   │   │   │   ├── atss_head.py
│   │   │   │   ├── base_dense_head.py
│   │   │   │   ├── dense_reppoints_head.py
│   │   │   │   ├── dense_reppoints_v2_head.py
│   │   │   │   ├── fcos_head.py
│   │   │   │   ├── fovea_head.py
│   │   │   │   ├── free_anchor_retina_head.py
│   │   │   │   ├── fsaf_head.py
│   │   │   │   ├── ga_retina_head.py
│   │   │   │   ├── ga_rpn_head.py
│   │   │   │   ├── gfl_head.py
│   │   │   │   ├── guided_anchor_head.py
│   │   │   │   ├── lscpvnet_head.py
│   │   │   │   ├── lsnet_head.py
│   │   │   │   ├── nasfcos_head.py
│   │   │   │   ├── pisa_retinanet_head.py
│   │   │   │   ├── pisa_ssd_head.py
│   │   │   │   ├── reppoints_head.py
│   │   │   │   ├── reppoints_v2_head.py
│   │   │   │   ├── retina_head.py
│   │   │   │   ├── retina_sepbn_head.py
│   │   │   │   ├── rpn_head.py
│   │   │   │   ├── rpn_test_mixin.py
│   │   │   │   └── ssd_head.py
│   │   │   ├── detectors/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── atss.py
│   │   │   │   ├── base.py
│   │   │   │   ├── cascade_rcnn.py
│   │   │   │   ├── dense_reppoints_detector.py
│   │   │   │   ├── dense_reppoints_v2_detector.py
│   │   │   │   ├── fast_rcnn.py
│   │   │   │   ├── faster_rcnn.py
│   │   │   │   ├── fcos.py
│   │   │   │   ├── fovea.py
│   │   │   │   ├── fsaf.py
│   │   │   │   ├── gfl.py
│   │   │   │   ├── grid_rcnn.py
│   │   │   │   ├── htc.py
│   │   │   │   ├── lscpvnet.py
│   │   │   │   ├── lsnet.py
│   │   │   │   ├── mask_rcnn.py
│   │   │   │   ├── mask_scoring_rcnn.py
│   │   │   │   ├── nasfcos.py
│   │   │   │   ├── point_rend.py
│   │   │   │   ├── reppoints_detector.py
│   │   │   │   ├── reppoints_v2_detector.py
│   │   │   │   ├── retinanet.py
│   │   │   │   ├── rpn.py
│   │   │   │   ├── single_stage.py
│   │   │   │   └── two_stage.py
│   │   │   ├── losses/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── accuracy.py
│   │   │   │   ├── ae_loss.py
│   │   │   │   ├── balanced_l1_loss.py
│   │   │   │   ├── chamfer_loss.py
│   │   │   │   ├── cross_entropy_loss.py
│   │   │   │   ├── cross_iou_loss.py
│   │   │   │   ├── focal_loss.py
│   │   │   │   ├── gaussian_focal_loss.py
│   │   │   │   ├── gfocal_loss.py
│   │   │   │   ├── ghm_loss.py
│   │   │   │   ├── iou_loss.py
│   │   │   │   ├── mse_loss.py
│   │   │   │   ├── pisa_loss.py
│   │   │   │   ├── smooth_l1_loss.py
│   │   │   │   └── utils.py
│   │   │   ├── necks/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── bfp.py
│   │   │   │   ├── fpn.py
│   │   │   │   ├── fpn_carafe.py
│   │   │   │   ├── hrfpn.py
│   │   │   │   ├── nas_fpn.py
│   │   │   │   ├── nasfcos_fpn.py
│   │   │   │   ├── pafpn.py
│   │   │   │   └── rfp.py
│   │   │   ├── roi_heads/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── base_roi_head.py
│   │   │   │   ├── bbox_heads/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── bbox_head.py
│   │   │   │   │   ├── convfc_bbox_head.py
│   │   │   │   │   └── double_bbox_head.py
│   │   │   │   ├── cascade_roi_head.py
│   │   │   │   ├── double_roi_head.py
│   │   │   │   ├── dynamic_roi_head.py
│   │   │   │   ├── grid_roi_head.py
│   │   │   │   ├── htc_roi_head.py
│   │   │   │   ├── mask_heads/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── coarse_mask_head.py
│   │   │   │   │   ├── fcn_mask_head.py
│   │   │   │   │   ├── fused_semantic_head.py
│   │   │   │   │   ├── grid_head.py
│   │   │   │   │   ├── htc_mask_head.py
│   │   │   │   │   ├── mask_point_head.py
│   │   │   │   │   └── maskiou_head.py
│   │   │   │   ├── mask_scoring_roi_head.py
│   │   │   │   ├── pisa_roi_head.py
│   │   │   │   ├── point_rend_roi_head.py
│   │   │   │   ├── roi_extractors/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   ├── base_roi_extractor.py
│   │   │   │   │   ├── generic_roi_extractor.py
│   │   │   │   │   └── single_level_roi_extractor.py
│   │   │   │   ├── shared_heads/
│   │   │   │   │   ├── __init__.py
│   │   │   │   │   └── res_layer.py
│   │   │   │   ├── standard_roi_head.py
│   │   │   │   └── test_mixins.py
│   │   │   └── utils/
│   │   │       ├── __init__.py
│   │   │       └── res_layer.py
│   │   ├── ops/
│   │   │   ├── __init__.py
│   │   │   ├── carafe/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── carafe.py
│   │   │   │   ├── grad_check.py
│   │   │   │   ├── setup.py
│   │   │   │   └── src/
│   │   │   │       ├── carafe_ext.cpp
│   │   │   │       ├── carafe_naive_ext.cpp
│   │   │   │       └── cuda/
│   │   │   │           ├── carafe_cuda.cpp
│   │   │   │           ├── carafe_cuda_kernel.cu
│   │   │   │           ├── carafe_naive_cuda.cpp
│   │   │   │           └── carafe_naive_cuda_kernel.cu
│   │   │   ├── chamfer_2d/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── dist_chamfer_2d.py
│   │   │   │   └── src/
│   │   │   │       ├── chamfer_2d.cu
│   │   │   │       └── chamfer_cuda.cpp
│   │   │   ├── context_block.py
│   │   │   ├── conv_ws.py
│   │   │   ├── corner_pool/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── corner_pool.py
│   │   │   │   └── src/
│   │   │   │       └── corner_pool.cpp
│   │   │   ├── dcn/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── deform_conv.py
│   │   │   │   ├── deform_pool.py
│   │   │   │   └── src/
│   │   │   │       ├── cuda/
│   │   │   │       │   ├── deform_conv_cuda.cpp
│   │   │   │       │   ├── deform_conv_cuda_kernel.cu
│   │   │   │       │   ├── deform_pool_cuda.cpp
│   │   │   │       │   └── deform_pool_cuda_kernel.cu
│   │   │   │       ├── deform_conv_ext.cpp
│   │   │   │       └── deform_pool_ext.cpp
│   │   │   ├── generalized_attention.py
│   │   │   ├── masked_conv/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── masked_conv.py
│   │   │   │   └── src/
│   │   │   │       ├── cuda/
│   │   │   │       │   ├── masked_conv2d_cuda.cpp
│   │   │   │       │   └── masked_conv2d_kernel.cu
│   │   │   │       └── masked_conv2d_ext.cpp
│   │   │   ├── merge_cells.py
│   │   │   ├── nms/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── nms_wrapper.py
│   │   │   │   └── src/
│   │   │   │       ├── cpu/
│   │   │   │       │   └── nms_cpu.cpp
│   │   │   │       ├── cuda/
│   │   │   │       │   ├── nms_cuda.cpp
│   │   │   │       │   └── nms_kernel.cu
│   │   │   │       └── nms_ext.cpp
│   │   │   ├── non_local.py
│   │   │   ├── plugin.py
│   │   │   ├── point_sample.py
│   │   │   ├── roi_align/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── gradcheck.py
│   │   │   │   ├── roi_align.py
│   │   │   │   └── src/
│   │   │   │       ├── cpu/
│   │   │   │       │   └── roi_align_v2.cpp
│   │   │   │       ├── cuda/
│   │   │   │       │   ├── roi_align_kernel.cu
│   │   │   │       │   └── roi_align_kernel_v2.cu
│   │   │   │       └── roi_align_ext.cpp
│   │   │   ├── roi_pool/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── gradcheck.py
│   │   │   │   ├── roi_pool.py
│   │   │   │   └── src/
│   │   │   │       ├── cuda/
│   │   │   │       │   └── roi_pool_kernel.cu
│   │   │   │       └── roi_pool_ext.cpp
│   │   │   ├── saconv.py
│   │   │   ├── sigmoid_focal_loss/
│   │   │   │   ├── __init__.py
│   │   │   │   ├── sigmoid_focal_loss.py
│   │   │   │   └── src/
│   │   │   │       ├── cuda/
│   │   │   │       │   └── sigmoid_focal_loss_cuda.cu
│   │   │   │       └── sigmoid_focal_loss_ext.cpp
│   │   │   ├── utils/
│   │   │   │   ├── __init__.py
│   │   │   │   └── src/
│   │   │   │       └── compiling_info.cpp
│   │   │   └── wrappers.py
│   │   └── utils/
│   │       ├── __init__.py
│   │       ├── collect_env.py
│   │       ├── contextmanagers.py
│   │       ├── logger.py
│   │       ├── profiling.py
│   │       └── util_mixins.py
│   ├── pytest.ini
│   ├── requirements/
│   │   ├── build.txt
│   │   ├── docs.txt
│   │   ├── optional.txt
│   │   ├── readthedocs.txt
│   │   ├── runtime.txt
│   │   └── tests.txt
│   ├── requirements.txt
│   ├── setup.py
│   ├── tests/
│   │   ├── async_benchmark.py
│   │   ├── test_anchor.py
│   │   ├── test_assigner.py
│   │   ├── test_async.py
│   │   ├── test_backbone.py
│   │   ├── test_config.py
│   │   ├── test_dataset.py
│   │   ├── test_forward.py
│   │   ├── test_fp16.py
│   │   ├── test_heads.py
│   │   ├── test_losses.py
│   │   ├── test_masks.py
│   │   ├── test_necks.py
│   │   ├── test_ops/
│   │   │   ├── test_corner_pool.py
│   │   │   ├── test_merge_cells.py
│   │   │   ├── test_nms.py
│   │   │   ├── test_soft_nms.py
│   │   │   └── test_wrappers.py
│   │   ├── test_pipelines/
│   │   │   ├── test_formatting.py
│   │   │   ├── test_loading.py
│   │   │   ├── test_models_aug_test.py
│   │   │   └── test_transform.py
│   │   ├── test_pisa_heads.py
│   │   ├── test_roi_extractor.py
│   │   └── test_sampler.py
│   ├── tools/
│   │   ├── analyze_logs.py
│   │   ├── benchmark.py
│   │   ├── browse_dataset.py
│   │   ├── coco_error_analysis.py
│   │   ├── convert_datasets/
│   │   │   ├── cityscapes.py
│   │   │   └── pascal_voc.py
│   │   ├── detectron2pytorch.py
│   │   ├── dist_test.sh
│   │   ├── dist_train.sh
│   │   ├── fuse_conv_bn.py
│   │   ├── gen_coco_lsvr.py
│   │   ├── get_flops.py
│   │   ├── print_config.py
│   │   ├── publish_model.py
│   │   ├── pytorch2onnx.py
│   │   ├── regnet2mmdet.py
│   │   ├── robustness_eval.py
│   │   ├── slurm_test.sh
│   │   ├── slurm_train.sh
│   │   ├── test.py
│   │   ├── test_robustness.py
│   │   ├── train.py
│   │   └── upgrade_model_version.py
│   └── visualization/
│       └── 000.txt
└── logs/
    └── 000.txt

SYMBOL INDEX (2934 symbols across 398 files)

FILE: code/cocoapi/lvis/lvis/colormap.py
  function colormap (line 6) | def colormap(rgb=False):

FILE: code/cocoapi/lvis/lvis/eval.py
  class LVISEval (line 13) | class LVISEval:
    method __init__ (line 14) | def __init__(self, lvis_gt, lvis_dt, iou_type='segm'):
    method _to_mask (line 54) | def _to_mask(self, anns, lvis):
    method _prepare (line 59) | def _prepare(self):
    method _prepare_freq_group (line 110) | def _prepare_freq_group(self):
    method evaluate (line 118) | def evaluate(self):
    method _get_gt_dt (line 146) | def _get_gt_dt(self, img_id, cat_id):
    method compute_iou (line 165) | def compute_iou(self, img_id, cat_id):
    method evaluate_img (line 191) | def evaluate_img(self, img_id, cat_id, area_rng):
    method accumulate (line 288) | def accumulate(self):
    method _summarize (line 411) | def _summarize(self,
    method summarize (line 443) | def summarize(self):
    method run (line 467) | def run(self):
    method print_results (line 473) | def print_results(self):
    method get_results (line 506) | def get_results(self):
  class Params (line 512) | class Params:
    method __init__ (line 513) | def __init__(self, iou_type):

FILE: code/cocoapi/lvis/lvis/lvis.py
  class LVIS (line 18) | class LVIS:
    method __init__ (line 19) | def __init__(self, annotation_path):
    method _load_json (line 34) | def _load_json(self, path):
    method _create_index (line 38) | def _create_index(self):
    method get_ann_ids (line 63) | def get_ann_ids(self, img_ids=None, cat_ids=None, area_rng=None):
    method get_cat_ids (line 97) | def get_cat_ids(self):
    method get_img_ids (line 105) | def get_img_ids(self):
    method _load_helper (line 113) | def _load_helper(self, _dict, ids):
    method load_anns (line 119) | def load_anns(self, ids=None):
    method load_cats (line 130) | def load_cats(self, ids):
    method load_imgs (line 142) | def load_imgs(self, ids):
    method download (line 153) | def download(self, save_dir, img_ids=None):
    method ann_to_rle (line 169) | def ann_to_rle(self, ann):
    method ann_to_mask (line 193) | def ann_to_mask(self, ann):

FILE: code/cocoapi/lvis/lvis/results.py
  class LVISResults (line 10) | class LVISResults(LVIS):
    method __init__ (line 11) | def __init__(self, lvis_gt, results, max_dets=300):
    method limit_dets_per_image (line 75) | def limit_dets_per_image(self, anns, max_dets):
    method get_top_results (line 88) | def get_top_results(self, img_id, score_thrs):

FILE: code/cocoapi/lvis/lvis/vis.py
  class LVISVis (line 14) | class LVISVis:
    method __init__ (line 15) | def __init__(self, lvis_gt, lvis_dt=None, img_dir=None, dpi=75):
    method coco_segm_to_poly (line 53) | def coco_segm_to_poly(self, _list):
    method get_synset (line 59) | def get_synset(self, idx):
    method setup_figure (line 65) | def setup_figure(self, img, title='', dpi=75):
    method vis_bbox (line 75) | def vis_bbox(self, ax, bbox, box_alpha=0.5, edgecolor='g', linestyle='...
    method vis_text (line 89) | def vis_text(self, ax, bbox, text, color='w'):
    method vis_mask (line 101) | def vis_mask(self, ax, segm, color):
    method get_color (line 111) | def get_color(self, idx):
    method load_img (line 115) | def load_img(self, img_id):
    method vis_img (line 124) | def vis_img(self,
    method vis_result (line 162) | def vis_result(self,

FILE: code/cocoapi/pycocotools/common/gason.cpp
  function isspace (line 52) | static inline bool isspace(char c) {
  function isdelim (line 56) | static inline bool isdelim(char c) {
  function isdigit (line 60) | static inline bool isdigit(char c) {
  function isxdigit (line 64) | static inline bool isxdigit(char c) {
  function char2int (line 68) | static inline int char2int(char c) {
  function string2double (line 74) | static double string2double(char *s, char **endptr) {
  function JsonNode (line 120) | static inline JsonNode *insertAfter(JsonNode *tail, JsonNode *node) {
  function JsonValue (line 128) | static inline JsonValue listToValue(JsonTag tag, JsonNode *tail) {
  function jsonParse (line 137) | int jsonParse(char *s, char **endptr, JsonValue *value, JsonAllocator &a...

FILE: code/cocoapi/pycocotools/common/gason.h
  type JsonTag (line 8) | enum JsonTag {
  type JsonNode (line 18) | struct JsonNode
  function JsonNode (line 54) | JsonNode *toNode() const {
  type JsonNode (line 60) | struct JsonNode {
  type JsonIterator (line 66) | struct JsonIterator {
  function JsonIterator (line 86) | inline JsonIterator end(JsonValue) {

FILE: code/cocoapi/pycocotools/common/maskApi.c
  function uint (line 11) | uint umin( uint a, uint b ) { return (a<b) ? a : b; }
  function uint (line 12) | uint umax( uint a, uint b ) { return (a>b) ? a : b; }
  function rleInit (line 14) | void rleInit( RLE *R, siz h, siz w, siz m, uint *cnts ) {
  function rleFree (line 19) | void rleFree( RLE *R ) {
  function rlesInit (line 23) | void rlesInit( RLE **R, siz n ) {
  function rlesFree (line 28) | void rlesFree( RLE **R, siz n ) {
  function rleEncode (line 32) | void rleEncode( RLE *R, const byte *M, siz h, siz w, siz n ) {
  function rleDecode (line 43) | void rleDecode( const RLE *R, byte *M, siz n ) {
  function rleMerge (line 49) | void rleMerge( const RLE *R, RLE *M, siz n, int intersect ) {
  function rleArea (line 72) | void rleArea( const RLE *R, siz n, uint *a ) {
  function rleIou (line 77) | void rleIou( RLE *dt, RLE *gt, siz m, siz n, byte *iscrowd, double *o ) {
  function rleNms (line 98) | void rleNms( RLE *dt, siz n, uint *keep, double thr ) {
  function bbIou (line 109) | void bbIou( BB dt, BB gt, siz m, siz n, byte *iscrowd, double *o ) {
  function bbNms (line 122) | void bbNms( BB dt, siz n, uint *keep, double thr ) {
  function rleToBbox (line 133) | void rleToBbox( const RLE *R, BB bb, siz n ) {
  function rleFrBbox (line 149) | void rleFrBbox( RLE *R, const BB bb, siz h, siz w, siz n ) {
  function uintCompare (line 158) | int uintCompare(const void *a, const void *b) {
  function rleFrPoly (line 162) | void rleFrPoly( RLE *R, const double *xy, siz k, siz h, siz w ) {
  function rleFrString (line 218) | void rleFrString( RLE *R, char *s, siz h, siz w ) {

FILE: code/cocoapi/pycocotools/common/maskApi.h
  type uint (line 9) | typedef unsigned int uint;
  type siz (line 10) | typedef unsigned long siz;
  type byte (line 11) | typedef unsigned char byte;
  type RLE (line 13) | typedef struct { siz h, w, m; uint *cnts; } RLE;

FILE: code/cocoapi/pycocotools/pycocotools/coco.py
  function _isArrayLike (line 64) | def _isArrayLike(obj):
  class COCO (line 68) | class COCO:
    method __init__ (line 69) | def __init__(self, annotation_file=None):
    method createIndex (line 96) | def createIndex(self):
    method info (line 127) | def info(self):
    method getAnnIds (line 135) | def getAnnIds(self, imgIds=[], catIds=[], areaRng=[], iscrowd=None):
    method get_ann_ids (line 174) | def get_ann_ids(self, img_ids=[], cat_ids=[], area_rng=[], iscrowd=None):
    method getCatIds (line 177) | def getCatIds(self, catNms=[], supNms=[], catIds=[]):
    method get_cat_ids (line 205) | def get_cat_ids(self, cat_names=[], sup_names=[], cat_ids=[]):
    method getImgIds (line 208) | def getImgIds(self, imgIds=[], catIds=[]):
    method get_img_ids (line 229) | def get_img_ids(self, img_ids=[], cat_ids=[]):
    method loadAnns (line 232) | def loadAnns(self, ids=[]):
    method loadCats (line 245) | def loadCats(self, ids=[]):
    method loadImgs (line 258) | def loadImgs(self, ids=[]):
    method showAnns (line 271) | def showAnns(self, anns, draw_bbox=False):
    method loadRes (line 367) | def loadRes(self, resFile):
    method download (line 436) | def download(self, tarDir=None, imgIds=[]):
    method loadNumpyAnnotations (line 462) | def loadNumpyAnnotations(self, data):
    method annToRLE (line 486) | def annToRLE(self, ann):
    method annToMask (line 509) | def annToMask(self, ann):

FILE: code/cocoapi/pycocotools/pycocotools/cocoeval.py
  class COCOeval (line 13) | class COCOeval:
    method __init__ (line 63) | def __init__(self, cocoGt=None, cocoDt=None, iouType='segm'):
    method _prepare (line 87) | def _prepare(self):
    method evaluate (line 128) | def evaluate(self):
    method computeIoU (line 170) | def computeIoU(self, imgId, catId):
    method computeOks (line 199) | def computeOks(self, imgId, catId):
    method evaluateImg (line 250) | def evaluateImg(self, imgId, catId, aRng, maxDet):
    method accumulate (line 334) | def accumulate(self, p=None):
    method summarize (line 456) | def summarize(self):
    method __str__ (line 551) | def __str__(self):
  class Params (line 555) | class Params:
    method setDetParams (line 559) | def setDetParams(self):
    method setKpParams (line 578) | def setKpParams(self):
    method __init__ (line 600) | def __init__(self, iouType='segm'):

FILE: code/cocoapi/pycocotools/pycocotools/mask.py
  function encode (line 84) | def encode(bimask):
  function decode (line 92) | def decode(rleObjs):
  function area (line 99) | def area(rleObjs):
  function toBbox (line 106) | def toBbox(rleObjs):

FILE: code/mmcv/examples/resnet_cifar.py
  class BasicBlock (line 8) | class BasicBlock(nn.Module):
    method __init__ (line 11) | def __init__(self, in_planes, planes, stride=1):
    method forward (line 35) | def forward(self, x):
  class Bottleneck (line 43) | class Bottleneck(nn.Module):
    method __init__ (line 46) | def __init__(self, in_planes, planes, stride=1):
    method forward (line 72) | def forward(self, x):
  class ResNet (line 81) | class ResNet(nn.Module):
    method __init__ (line 83) | def __init__(self, block, num_blocks, num_classes=10):
    method _make_layer (line 96) | def _make_layer(self, block, planes, num_blocks, stride):
    method forward (line 104) | def forward(self, x):
  function resnet18 (line 116) | def resnet18():
  function resnet34 (line 120) | def resnet34():
  function resnet50 (line 124) | def resnet50():
  function resnet101 (line 128) | def resnet101():
  function resnet152 (line 132) | def resnet152():

FILE: code/mmcv/examples/train_cifar10.py
  function accuracy (line 20) | def accuracy(output, target, topk=(1, )):
  function batch_processor (line 37) | def batch_processor(model, data, train_mode):
  function get_logger (line 51) | def get_logger(log_level):
  function init_dist (line 58) | def init_dist(backend='nccl', **kwargs):
  function parse_args (line 67) | def parse_args():
  function main (line 79) | def main():

FILE: code/mmcv/mmcv/arraymisc/quantization.py
  function quantize (line 5) | def quantize(arr, min_val, max_val, levels, dtype=np.int64):
  function dequantize (line 32) | def dequantize(arr, min_val, max_val, levels, dtype=np.float64):

FILE: code/mmcv/mmcv/cnn/alexnet.py
  class AlexNet (line 9) | class AlexNet(nn.Module):
    method __init__ (line 16) | def __init__(self, num_classes=-1):
    method init_weights (line 45) | def init_weights(self, pretrained=None):
    method forward (line 55) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/activation.py
  function build_activation_layer (line 13) | def build_activation_layer(cfg):

FILE: code/mmcv/mmcv/cnn/bricks/conv.py
  function build_conv_layer (line 11) | def build_conv_layer(cfg, *args, **kwargs):

FILE: code/mmcv/mmcv/cnn/bricks/conv_module.py
  class ConvModule (line 12) | class ConvModule(nn.Module):
    method __init__ (line 57) | def __init__(self,
    method norm (line 151) | def norm(self):
    method init_weights (line 154) | def init_weights(self):
    method forward (line 174) | def forward(self, x, activate=True, norm=True):

FILE: code/mmcv/mmcv/cnn/bricks/hsigmoid.py
  class HSigmoid (line 7) | class HSigmoid(nn.Module):
    method __init__ (line 15) | def __init__(self):
    method forward (line 18) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/hswish.py
  class HSwish (line 7) | class HSwish(nn.Module):
    method __init__ (line 19) | def __init__(self, inplace=False):
    method forward (line 23) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/non_local.py
  class _NonLocalNd (line 10) | class _NonLocalNd(nn.Module, metaclass=ABCMeta):
    method __init__ (line 32) | def __init__(self,
    method init_weights (line 82) | def init_weights(self, std=0.01, zeros_init=True):
    method embedded_gaussian (line 96) | def embedded_gaussian(self, theta_x, phi_x):
    method dot_product (line 107) | def dot_product(self, theta_x, phi_x):
    method forward (line 115) | def forward(self, x):
  class NonLocal1d (line 160) | class NonLocal1d(_NonLocalNd):
    method __init__ (line 172) | def __init__(self,
  class NonLocal2d (line 188) | class NonLocal2d(_NonLocalNd):
    method __init__ (line 200) | def __init__(self,
  class NonLocal3d (line 216) | class NonLocal3d(_NonLocalNd):
    method __init__ (line 228) | def __init__(self,

FILE: code/mmcv/mmcv/cnn/bricks/norm.py
  function infer_abbr (line 22) | def infer_abbr(class_type):
  function build_norm_layer (line 71) | def build_norm_layer(cfg, num_features, postfix=''):
  function is_norm (line 121) | def is_norm(layer, exclude=None):

FILE: code/mmcv/mmcv/cnn/bricks/padding.py
  function build_padding_layer (line 10) | def build_padding_layer(cfg, *args, **kwargs):

FILE: code/mmcv/mmcv/cnn/bricks/scale.py
  class Scale (line 5) | class Scale(nn.Module):
    method __init__ (line 15) | def __init__(self, scale=1.0):
    method forward (line 19) | def forward(self, x):

FILE: code/mmcv/mmcv/cnn/bricks/upsample.py
  class PixelShufflePack (line 13) | class PixelShufflePack(nn.Module):
    method __init__ (line 27) | def __init__(self, in_channels, out_channels, scale_factor,
    method init_weights (line 41) | def init_weights(self):
    method forward (line 44) | def forward(self, x):
  function build_upsample_layer (line 50) | def build_upsample_layer(cfg, *args, **kwargs):

FILE: code/mmcv/mmcv/cnn/resnet.py
  function conv3x3 (line 11) | def conv3x3(in_planes, out_planes, stride=1, dilation=1):
  class BasicBlock (line 23) | class BasicBlock(nn.Module):
    method __init__ (line 26) | def __init__(self,
    method forward (line 46) | def forward(self, x):
  class Bottleneck (line 65) | class Bottleneck(nn.Module):
    method __init__ (line 68) | def __init__(self,
    method forward (line 111) | def forward(self, x):
  function make_res_layer (line 144) | def make_res_layer(block,
  class ResNet (line 182) | class ResNet(nn.Module):
    method __init__ (line 211) | def __init__(self,
    method init_weights (line 266) | def init_weights(self, pretrained=None):
    method forward (line 279) | def forward(self, x):
    method train (line 295) | def train(self, mode=True):

FILE: code/mmcv/mmcv/cnn/utils/flops_counter.py
  function get_model_complexity_info (line 34) | def get_model_complexity_info(model,
  function flops_to_string (line 114) | def flops_to_string(flops, units='GFLOPs', precision=2):
  function params_to_string (line 157) | def params_to_string(num_params, units=None, precision=2):
  function print_model_with_flops (line 194) | def print_model_with_flops(model,
  function get_model_parameters_number (line 303) | def get_model_parameters_number(model):
  function add_flops_counting_methods (line 316) | def add_flops_counting_methods(net_main_module):
  function compute_average_flops_cost (line 333) | def compute_average_flops_cost(self):
  function start_flops_count (line 351) | def start_flops_count(self):
  function stop_flops_count (line 374) | def stop_flops_count(self):
  function reset_flops_count (line 385) | def reset_flops_count(self):
  function empty_flops_counter_hook (line 396) | def empty_flops_counter_hook(module, input, output):
  function upsample_flops_counter_hook (line 400) | def upsample_flops_counter_hook(module, input, output):
  function relu_flops_counter_hook (line 409) | def relu_flops_counter_hook(module, input, output):
  function linear_flops_counter_hook (line 414) | def linear_flops_counter_hook(module, input, output):
  function pool_flops_counter_hook (line 421) | def pool_flops_counter_hook(module, input, output):
  function bn_flops_counter_hook (line 426) | def bn_flops_counter_hook(module, input, output):
  function deconv_flops_counter_hook (line 435) | def deconv_flops_counter_hook(conv_module, input, output):
  function conv_flops_counter_hook (line 462) | def conv_flops_counter_hook(conv_module, input, output):
  function batch_counter_hook (line 493) | def batch_counter_hook(module, input, output):
  function add_batch_counter_variables_or_reset (line 506) | def add_batch_counter_variables_or_reset(module):
  function add_batch_counter_hook_function (line 511) | def add_batch_counter_hook_function(module):
  function remove_batch_counter_hook_function (line 519) | def remove_batch_counter_hook_function(module):
  function add_flops_counter_variable_or_reset (line 525) | def add_flops_counter_variable_or_reset(module):
  function is_supported_instance (line 535) | def is_supported_instance(module):
  function remove_flops_counter_hook_function (line 541) | def remove_flops_counter_hook_function(module):

FILE: code/mmcv/mmcv/cnn/utils/weight_init.py
  function constant_init (line 6) | def constant_init(module, val, bias=0):
  function xavier_init (line 13) | def xavier_init(module, gain=1, bias=0, distribution='normal'):
  function normal_init (line 23) | def normal_init(module, mean=0, std=1, bias=0):
  function uniform_init (line 29) | def uniform_init(module, a=0, b=1, bias=0):
  function kaiming_init (line 35) | def kaiming_init(module,
  function caffe2_xavier_init (line 52) | def caffe2_xavier_init(module, bias=0):
  function bias_init_with_prob (line 63) | def bias_init_with_prob(prior_prob):

FILE: code/mmcv/mmcv/cnn/vgg.py
  function conv3x3 (line 10) | def conv3x3(in_planes, out_planes, dilation=1):
  function make_vgg_layer (line 20) | def make_vgg_layer(inplanes,
  class VGG (line 38) | class VGG(nn.Module):
    method __init__ (line 62) | def __init__(self,
    method init_weights (line 126) | def init_weights(self, pretrained=None):
    method forward (line 141) | def forward(self, x):
    method train (line 159) | def train(self, mode=True):

FILE: code/mmcv/mmcv/fileio/file_client.py
  class BaseStorageBackend (line 6) | class BaseStorageBackend(metaclass=ABCMeta):
    method get (line 15) | def get(self, filepath):
    method get_text (line 19) | def get_text(self, filepath):
  class CephBackend (line 23) | class CephBackend(BaseStorageBackend):
    method __init__ (line 32) | def __init__(self, path_mapping=None):
    method get (line 43) | def get(self, filepath):
    method get_text (line 52) | def get_text(self, filepath):
  class PetrelBackend (line 56) | class PetrelBackend(BaseStorageBackend):
    method __init__ (line 66) | def __init__(self, path_mapping=None, enable_mc=True):
    method get (line 77) | def get(self, filepath):
    method get_text (line 86) | def get_text(self, filepath):
  class MemcachedBackend (line 90) | class MemcachedBackend(BaseStorageBackend):
    method __init__ (line 100) | def __init__(self, server_list_cfg, client_cfg, sys_path=None):
    method get (line 117) | def get(self, filepath):
    method get_text (line 124) | def get_text(self, filepath):
  class LmdbBackend (line 128) | class LmdbBackend(BaseStorageBackend):
    method __init__ (line 146) | def __init__(self,
    method get (line 165) | def get(self, filepath):
    method get_text (line 176) | def get_text(self, filepath):
  class HardDiskBackend (line 180) | class HardDiskBackend(BaseStorageBackend):
    method get (line 183) | def get(self, filepath):
    method get_text (line 189) | def get_text(self, filepath):
  class FileClient (line 196) | class FileClient:
    method __init__ (line 217) | def __init__(self, backend='disk', **kwargs):
    method _register_backend (line 226) | def _register_backend(cls, name, backend, force=False):
    method register_backend (line 244) | def register_backend(cls, name, backend=None, force=False):
    method get (line 293) | def get(self, filepath):
    method get_text (line 296) | def get_text(self, filepath):

FILE: code/mmcv/mmcv/fileio/handlers/base.py
  class BaseFileHandler (line 5) | class BaseFileHandler(metaclass=ABCMeta):
    method load_from_fileobj (line 8) | def load_from_fileobj(self, file, **kwargs):
    method dump_to_fileobj (line 12) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_str (line 16) | def dump_to_str(self, obj, **kwargs):
    method load_from_path (line 19) | def load_from_path(self, filepath, mode='r', **kwargs):
    method dump_to_path (line 23) | def dump_to_path(self, obj, filepath, mode='w', **kwargs):

FILE: code/mmcv/mmcv/fileio/handlers/json_handler.py
  class JsonHandler (line 7) | class JsonHandler(BaseFileHandler):
    method load_from_fileobj (line 9) | def load_from_fileobj(self, file):
    method dump_to_fileobj (line 12) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_str (line 15) | def dump_to_str(self, obj, **kwargs):

FILE: code/mmcv/mmcv/fileio/handlers/pickle_handler.py
  class PickleHandler (line 7) | class PickleHandler(BaseFileHandler):
    method load_from_fileobj (line 9) | def load_from_fileobj(self, file, **kwargs):
    method load_from_path (line 12) | def load_from_path(self, filepath, **kwargs):
    method dump_to_str (line 16) | def dump_to_str(self, obj, **kwargs):
    method dump_to_fileobj (line 20) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_path (line 24) | def dump_to_path(self, obj, filepath, **kwargs):

FILE: code/mmcv/mmcv/fileio/handlers/yaml_handler.py
  class YamlHandler (line 12) | class YamlHandler(BaseFileHandler):
    method load_from_fileobj (line 14) | def load_from_fileobj(self, file, **kwargs):
    method dump_to_fileobj (line 18) | def dump_to_fileobj(self, obj, file, **kwargs):
    method dump_to_str (line 22) | def dump_to_str(self, obj, **kwargs):

FILE: code/mmcv/mmcv/fileio/io.py
  function load (line 16) | def load(file, file_format=None, **kwargs):
  function dump (line 49) | def dump(obj, file=None, file_format=None, **kwargs):
  function _register_handler (line 87) | def _register_handler(handler, file_formats):
  function register_handler (line 106) | def register_handler(file_formats, **kwargs):

FILE: code/mmcv/mmcv/fileio/parse.py
  function list_from_file (line 2) | def list_from_file(filename, prefix='', offset=0, max_num=0):
  function dict_from_file (line 28) | def dict_from_file(filename, key_type=str):

FILE: code/mmcv/mmcv/image/colorspace.py
  function imconvert (line 6) | def imconvert(img, src, dst):
  function bgr2gray (line 22) | def bgr2gray(img, keepdim=False):
  function rgb2gray (line 39) | def rgb2gray(img, keepdim=False):
  function gray2bgr (line 56) | def gray2bgr(img):
  function gray2rgb (line 70) | def gray2rgb(img):
  function _convert_input_type_range (line 84) | def _convert_input_type_range(img):
  function _convert_output_type_range (line 112) | def _convert_output_type_range(img, dst_type):
  function rgb2ycbcr (line 143) | def rgb2ycbcr(img, y_only=False):
  function bgr2ycbcr (line 177) | def bgr2ycbcr(img, y_only=False):
  function ycbcr2rgb (line 211) | def ycbcr2rgb(img):
  function ycbcr2bgr (line 243) | def ycbcr2bgr(img):
  function convert_color_factory (line 275) | def convert_color_factory(src, dst):

FILE: code/mmcv/mmcv/image/geometric.py
  function _scale_size (line 6) | def _scale_size(size, scale):
  function imresize (line 29) | def imresize(img,
  function imresize_like (line 59) | def imresize_like(img, dst_img, return_scale=False, interpolation='bilin...
  function rescale_size (line 76) | def rescale_size(old_size, scale, return_scale=False):
  function imrescale (line 113) | def imrescale(img, scale, return_scale=False, interpolation='bilinear'):
  function imflip (line 138) | def imflip(img, direction='horizontal'):
  function imflip_ (line 155) | def imflip_(img, direction='horizontal'):
  function imrotate (line 172) | def imrotate(img,
  function bbox_clip (line 216) | def bbox_clip(bboxes, img_shape):
  function bbox_scaling (line 234) | def bbox_scaling(bboxes, scale, clip_shape=None):
  function imcrop (line 260) | def imcrop(img, bboxes, scale=1.0, pad_fill=None):
  function impad (line 314) | def impad(img, shape, pad_val=0):
  function impad_to_multiple (line 339) | def impad_to_multiple(img, divisor, pad_val=0):

FILE: code/mmcv/mmcv/image/io.py
  function use_backend (line 34) | def use_backend(backend):
  function _jpegflag (line 56) | def _jpegflag(flag='color', channel_order='bgr'):
  function _pillow2array (line 72) | def _pillow2array(img, flag='color', channel_order='bgr'):
  function imread (line 123) | def imread(img_or_path, flag='color', channel_order='bgr', backend=None):
  function imfrombytes (line 178) | def imfrombytes(content, flag='color', channel_order='bgr', backend=None):
  function imwrite (line 217) | def imwrite(img, file_path, params=None, auto_mkdir=True):

FILE: code/mmcv/mmcv/image/photometric.py
  function imnormalize (line 5) | def imnormalize(img, mean, std, to_rgb=True):
  function imnormalize_ (line 21) | def imnormalize_(img, mean, std, to_rgb=True):
  function imdenormalize (line 44) | def imdenormalize(img, mean, std, to_bgr=True):
  function iminvert (line 55) | def iminvert(img):
  function solarize (line 67) | def solarize(img, thr=128):
  function posterize (line 81) | def posterize(img, bits):

FILE: code/mmcv/mmcv/parallel/_functions.py
  function scatter (line 6) | def scatter(input, devices, streams=None):
  function synchronize_stream (line 30) | def synchronize_stream(output, devices, streams):
  function get_input_device (line 47) | def get_input_device(input):
  class Scatter (line 60) | class Scatter:
    method forward (line 63) | def forward(target_gpus, input):

FILE: code/mmcv/mmcv/parallel/collate.py
  function collate (line 11) | def collate(batch, samples_per_gpu=1):

FILE: code/mmcv/mmcv/parallel/data_container.py
  function assert_tensor_type (line 7) | def assert_tensor_type(func):
  class DataContainer (line 20) | class DataContainer:
    method __init__ (line 37) | def __init__(self,
    method __repr__ (line 50) | def __repr__(self):
    method __len__ (line 53) | def __len__(self):
    method data (line 57) | def data(self):
    method datatype (line 61) | def datatype(self):
    method cpu_only (line 68) | def cpu_only(self):
    method stack (line 72) | def stack(self):
    method padding_value (line 76) | def padding_value(self):
    method pad_dims (line 80) | def pad_dims(self):
    method size (line 84) | def size(self, *args, **kwargs):
    method dim (line 88) | def dim(self):

FILE: code/mmcv/mmcv/parallel/data_parallel.py
  class MMDataParallel (line 9) | class MMDataParallel(DataParallel):
    method scatter (line 11) | def scatter(self, inputs, kwargs, device_ids):
    method train_step (line 14) | def train_step(self, *inputs, **kwargs):
    method val_step (line 33) | def val_step(self, *inputs, **kwargs):

FILE: code/mmcv/mmcv/parallel/distributed.py
  class MMDistributedDataParallel (line 10) | class MMDistributedDataParallel(DistributedDataParallel):
    method scatter (line 20) | def scatter(self, inputs, kwargs, device_ids):
    method train_step (line 23) | def train_step(self, *inputs, **kwargs):
    method val_step (line 55) | def val_step(self, *inputs, **kwargs):

FILE: code/mmcv/mmcv/parallel/distributed_deprecated.py
  class MMDistributedDataParallel (line 14) | class MMDistributedDataParallel(nn.Module):
    method __init__ (line 16) | def __init__(self,
    method _dist_broadcast_coalesced (line 29) | def _dist_broadcast_coalesced(self, tensors, buffer_size):
    method _sync_params (line 37) | def _sync_params(self):
    method scatter (line 51) | def scatter(self, inputs, kwargs, device_ids):
    method forward (line 54) | def forward(self, *inputs, **kwargs):
    method train_step (line 59) | def train_step(self, *inputs, **kwargs):
    method val_step (line 65) | def val_step(self, *inputs, **kwargs):

FILE: code/mmcv/mmcv/parallel/scatter_gather.py
  function scatter (line 9) | def scatter(inputs, target_gpus, dim=0):
  function scatter_kwargs (line 45) | def scatter_kwargs(inputs, kwargs, target_gpus, dim=0):

FILE: code/mmcv/mmcv/parallel/utils.py
  function is_module_wrapper (line 5) | def is_module_wrapper(module):

FILE: code/mmcv/mmcv/runner/base_runner.py
  class BaseRunner (line 20) | class BaseRunner(metaclass=ABCMeta):
    method __init__ (line 48) | def __init__(self,
    method model_name (line 130) | def model_name(self):
    method rank (line 135) | def rank(self):
    method world_size (line 140) | def world_size(self):
    method hooks (line 146) | def hooks(self):
    method epoch (line 151) | def epoch(self):
    method iter (line 156) | def iter(self):
    method inner_iter (line 161) | def inner_iter(self):
    method max_epochs (line 166) | def max_epochs(self):
    method max_iters (line 171) | def max_iters(self):
    method train (line 176) | def train(self):
    method val (line 180) | def val(self):
    method run (line 184) | def run(self, data_loaders, workflow, **kwargs):
    method save_checkpoint (line 188) | def save_checkpoint(self,
    method current_lr (line 196) | def current_lr(self):
    method current_momentum (line 215) | def current_momentum(self):
    method register_hook (line 246) | def register_hook(self, hook, priority='NORMAL'):
    method call_hook (line 274) | def call_hook(self, fn_name):
    method load_checkpoint (line 284) | def load_checkpoint(self, filename, map_location='cpu', strict=False):
    method resume (line 289) | def resume(self,
    method register_lr_hook (line 309) | def register_lr_hook(self, lr_config):
    method register_momentum_hook (line 327) | def register_momentum_hook(self, momentum_config):
    method register_optimizer_hook (line 347) | def register_optimizer_hook(self, optimizer_config):
    method register_checkpoint_hook (line 357) | def register_checkpoint_hook(self, checkpoint_config):
    method register_logger_hooks (line 367) | def register_logger_hooks(self, log_config):
    method register_training_hooks (line 374) | def register_training_hooks(self,

FILE: code/mmcv/mmcv/runner/checkpoint.py
  function _get_mmcv_home (line 26) | def _get_mmcv_home():
  function load_state_dict (line 37) | def load_state_dict(module, state_dict, strict=False, logger=None):
  function load_url_dist (line 105) | def load_url_dist(url, model_dir=None):
  function get_torchvision_models (line 119) | def get_torchvision_models():
  function get_external_models (line 131) | def get_external_models():
  function get_deprecated_model_names (line 145) | def get_deprecated_model_names():
  function _load_checkpoint (line 154) | def _load_checkpoint(filename, map_location=None):
  function load_checkpoint (line 204) | def load_checkpoint(model,
  function weights_to_cpu (line 242) | def weights_to_cpu(state_dict):
  function save_checkpoint (line 257) | def save_checkpoint(model, filename, optimizer=None, meta=None):

FILE: code/mmcv/mmcv/runner/dist_utils.py
  function init_dist (line 13) | def init_dist(launcher, backend='nccl', **kwargs):
  function _init_dist_pytorch (line 26) | def _init_dist_pytorch(backend, **kwargs):
  function _init_dist_mpi (line 34) | def _init_dist_mpi(backend, **kwargs):
  function _init_dist_slurm (line 38) | def _init_dist_slurm(backend, port=None):
  function get_dist_info (line 70) | def get_dist_info():
  function master_only (line 87) | def master_only(func):

FILE: code/mmcv/mmcv/runner/epoch_based_runner.py
  class EpochBasedRunner (line 14) | class EpochBasedRunner(BaseRunner):
    method train (line 20) | def train(self, data_loader, **kwargs):
    method val (line 49) | def val(self, data_loader, **kwargs):
    method run (line 76) | def run(self, data_loaders, workflow, max_epochs, **kwargs):
    method save_checkpoint (line 127) | def save_checkpoint(self,
  class Runner (line 163) | class Runner(EpochBasedRunner):
    method __init__ (line 166) | def __init__(self, *args, **kwargs):

FILE: code/mmcv/mmcv/runner/hooks/checkpoint.py
  class CheckpointHook (line 9) | class CheckpointHook(Hook):
    method __init__ (line 29) | def __init__(self,
    method after_train_epoch (line 44) | def after_train_epoch(self, runner):
    method after_train_iter (line 67) | def after_train_iter(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/closure.py
  class ClosureHook (line 6) | class ClosureHook(Hook):
    method __init__ (line 8) | def __init__(self, fn_name, fn):

FILE: code/mmcv/mmcv/runner/hooks/hook.py
  class Hook (line 7) | class Hook:
    method before_run (line 9) | def before_run(self, runner):
    method after_run (line 12) | def after_run(self, runner):
    method before_epoch (line 15) | def before_epoch(self, runner):
    method after_epoch (line 18) | def after_epoch(self, runner):
    method before_iter (line 21) | def before_iter(self, runner):
    method after_iter (line 24) | def after_iter(self, runner):
    method before_train_epoch (line 27) | def before_train_epoch(self, runner):
    method before_val_epoch (line 30) | def before_val_epoch(self, runner):
    method after_train_epoch (line 33) | def after_train_epoch(self, runner):
    method after_val_epoch (line 36) | def after_val_epoch(self, runner):
    method before_train_iter (line 39) | def before_train_iter(self, runner):
    method before_val_iter (line 42) | def before_val_iter(self, runner):
    method after_train_iter (line 45) | def after_train_iter(self, runner):
    method after_val_iter (line 48) | def after_val_iter(self, runner):
    method every_n_epochs (line 51) | def every_n_epochs(self, runner, n):
    method every_n_inner_iters (line 54) | def every_n_inner_iters(self, runner, n):
    method every_n_iters (line 57) | def every_n_iters(self, runner, n):
    method end_of_epoch (line 60) | def end_of_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/iter_timer.py
  class IterTimerHook (line 8) | class IterTimerHook(Hook):
    method before_epoch (line 10) | def before_epoch(self, runner):
    method before_iter (line 13) | def before_iter(self, runner):
    method after_iter (line 16) | def after_iter(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/base.py
  class LoggerHook (line 7) | class LoggerHook(Hook):
    method __init__ (line 20) | def __init__(self,
    method log (line 31) | def log(self, runner):
    method before_run (line 34) | def before_run(self, runner):
    method before_epoch (line 40) | def before_epoch(self, runner):
    method after_train_iter (line 43) | def after_train_iter(self, runner):
    method after_train_epoch (line 57) | def after_train_epoch(self, runner):
    method after_val_epoch (line 63) | def after_val_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/mlflow.py
  class MlflowLoggerHook (line 10) | class MlflowLoggerHook(LoggerHook):
    method __init__ (line 12) | def __init__(self,
    method import_mlflow (line 47) | def import_mlflow(self):
    method before_run (line 58) | def before_run(self, runner):
    method log (line 65) | def log(self, runner):
    method after_run (line 78) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/pavi.py
  function is_scalar (line 13) | def is_scalar(val, include_np=True, include_torch=True):
  class PaviLoggerHook (line 35) | class PaviLoggerHook(LoggerHook):
    method __init__ (line 37) | def __init__(self,
    method before_run (line 52) | def before_run(self, runner):
    method log (line 71) | def log(self, runner):
    method after_run (line 96) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/tensorboard.py
  class TensorboardLoggerHook (line 11) | class TensorboardLoggerHook(LoggerHook):
    method __init__ (line 13) | def __init__(self,
    method before_run (line 24) | def before_run(self, runner):
    method log (line 45) | def log(self, runner):
    method after_run (line 74) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/text.py
  class TextLoggerHook (line 15) | class TextLoggerHook(LoggerHook):
    method __init__ (line 32) | def __init__(self,
    method before_run (line 44) | def before_run(self, runner):
    method _get_max_memory (line 52) | def _get_max_memory(self, runner):
    method _log_info (line 61) | def _log_info(self, log_dict, runner):
    method _dump_log (line 123) | def _dump_log(self, log_dict, runner):
    method _round_float (line 134) | def _round_float(self, items):
    method log (line 142) | def log(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/logger/wandb.py
  class WandbLoggerHook (line 10) | class WandbLoggerHook(LoggerHook):
    method __init__ (line 12) | def __init__(self,
    method import_wandb (line 22) | def import_wandb(self):
    method before_run (line 31) | def before_run(self, runner):
    method log (line 40) | def log(self, runner):
    method after_run (line 54) | def after_run(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/lr_updater.py
  class LrUpdaterHook (line 7) | class LrUpdaterHook(Hook):
    method __init__ (line 23) | def __init__(self,
    method _set_lr (line 56) | def _set_lr(self, runner, lr_groups):
    method get_lr (line 66) | def get_lr(self, runner, base_lr):
    method get_regular_lr (line 69) | def get_regular_lr(self, runner):
    method get_warmup_lr (line 83) | def get_warmup_lr(self, cur_iters):
    method before_run (line 94) | def before_run(self, runner):
    method before_train_epoch (line 113) | def before_train_epoch(self, runner):
    method before_train_iter (line 123) | def before_train_iter(self, runner):
  class FixedLrUpdaterHook (line 143) | class FixedLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 145) | def __init__(self, **kwargs):
    method get_lr (line 148) | def get_lr(self, runner, base_lr):
  class StepLrUpdaterHook (line 153) | class StepLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 155) | def __init__(self, step, gamma=0.1, **kwargs):
    method get_lr (line 168) | def get_lr(self, runner, base_lr):
  class ExpLrUpdaterHook (line 183) | class ExpLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 185) | def __init__(self, gamma, **kwargs):
    method get_lr (line 189) | def get_lr(self, runner, base_lr):
  class PolyLrUpdaterHook (line 195) | class PolyLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 197) | def __init__(self, power=1., min_lr=0., **kwargs):
    method get_lr (line 202) | def get_lr(self, runner, base_lr):
  class InvLrUpdaterHook (line 214) | class InvLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 216) | def __init__(self, gamma, power=1., **kwargs):
    method get_lr (line 221) | def get_lr(self, runner, base_lr):
  class CosineAnealingLrUpdaterHook (line 227) | class CosineAnealingLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 229) | def __init__(self, min_lr=None, min_lr_ratio=None, **kwargs):
    method get_lr (line 235) | def get_lr(self, runner, base_lr):
  class CosineRestartLrUpdaterHook (line 251) | class CosineRestartLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 264) | def __init__(self,
    method get_lr (line 283) | def get_lr(self, runner, base_lr):
  function get_position_from_periods (line 303) | def get_position_from_periods(iteration, cumulative_periods):
  class CyclicLrUpdaterHook (line 327) | class CyclicLrUpdaterHook(LrUpdaterHook):
    method __init__ (line 347) | def __init__(self,
    method before_run (line 376) | def before_run(self, runner):
    method get_lr (line 389) | def get_lr(self, runner, base_lr):
  function annealing_cos (line 401) | def annealing_cos(start, end, factor, weight=1):

FILE: code/mmcv/mmcv/runner/hooks/memory.py
  class EmptyCacheHook (line 8) | class EmptyCacheHook(Hook):
    method __init__ (line 10) | def __init__(self, before_epoch=False, after_epoch=True, after_iter=Fa...
    method after_iter (line 15) | def after_iter(self, runner):
    method before_epoch (line 19) | def before_epoch(self, runner):
    method after_epoch (line 23) | def after_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/momentum_updater.py
  class MomentumUpdaterHook (line 5) | class MomentumUpdaterHook(Hook):
    method __init__ (line 7) | def __init__(self,
    method _set_momentum (line 33) | def _set_momentum(self, runner, momentum_groups):
    method get_momentum (line 41) | def get_momentum(self, runner, base_momentum):
    method get_regular_momentum (line 44) | def get_regular_momentum(self, runner):
    method get_warmup_momentum (line 50) | def get_warmup_momentum(self, cur_iters):
    method before_run (line 66) | def before_run(self, runner):
    method before_train_epoch (line 80) | def before_train_epoch(self, runner):
    method before_train_iter (line 86) | def before_train_iter(self, runner):
  class CosineAnealingMomentumUpdaterHook (line 106) | class CosineAnealingMomentumUpdaterHook(MomentumUpdaterHook):
    method __init__ (line 108) | def __init__(self, min_momentum=None, min_momentum_ratio=None, **kwargs):
    method get_momentum (line 114) | def get_momentum(self, runner, base_momentum):
  class CyclicMomentumUpdaterHook (line 130) | class CyclicMomentumUpdaterHook(MomentumUpdaterHook):
    method __init__ (line 149) | def __init__(self,
    method before_run (line 178) | def before_run(self, runner):
    method get_momentum (line 191) | def get_momentum(self, runner, base_momentum):

FILE: code/mmcv/mmcv/runner/hooks/optimizer.py
  class OptimizerHook (line 8) | class OptimizerHook(Hook):
    method __init__ (line 10) | def __init__(self, grad_clip=None):
    method clip_grads (line 13) | def clip_grads(self, params):
    method after_train_iter (line 19) | def after_train_iter(self, runner):

FILE: code/mmcv/mmcv/runner/hooks/sampler_seed.py
  class DistSamplerSeedHook (line 6) | class DistSamplerSeedHook(Hook):
    method before_epoch (line 8) | def before_epoch(self, runner):

FILE: code/mmcv/mmcv/runner/iter_based_runner.py
  class IterLoader (line 15) | class IterLoader:
    method __init__ (line 17) | def __init__(self, dataloader):
    method epoch (line 23) | def epoch(self):
    method __next__ (line 26) | def __next__(self):
    method __len__ (line 38) | def __len__(self):
  class IterBasedRunner (line 42) | class IterBasedRunner(BaseRunner):
    method train (line 48) | def train(self, data_loader, **kwargs):
    method val (line 65) | def val(self, data_loader, **kwargs):
    method run (line 80) | def run(self, data_loaders, workflow, max_iters, **kwargs):
    method resume (line 125) | def resume(self,
    method save_checkpoint (line 160) | def save_checkpoint(self,
    method register_training_hooks (line 197) | def register_training_hooks(self,

FILE: code/mmcv/mmcv/runner/log_buffer.py
  class LogBuffer (line 7) | class LogBuffer:
    method __init__ (line 9) | def __init__(self):
    method clear (line 15) | def clear(self):
    method clear_output (line 20) | def clear_output(self):
    method update (line 24) | def update(self, vars, count=1):
    method average (line 33) | def average(self, n=0):

FILE: code/mmcv/mmcv/runner/optimizer/builder.py
  function register_torch_optimizers (line 12) | def register_torch_optimizers():
  function build_optimizer_constructor (line 28) | def build_optimizer_constructor(cfg):
  function build_optimizer (line 32) | def build_optimizer(model, cfg):

FILE: code/mmcv/mmcv/runner/optimizer/default_constructor.py
  class DefaultOptimizerConstructor (line 11) | class DefaultOptimizerConstructor:
    method __init__ (line 75) | def __init__(self, optimizer_cfg, paramwise_cfg=None):
    method _validate_cfg (line 85) | def _validate_cfg(self):
    method _is_in (line 108) | def _is_in(self, param_group, param_group_list):
    method add_params (line 117) | def add_params(self, params, module, prefix=''):
    method __call__ (line 191) | def __call__(self, model):

FILE: code/mmcv/mmcv/runner/priority.py
  class Priority (line 5) | class Priority(Enum):
  function get_priority (line 36) | def get_priority(priority):

FILE: code/mmcv/mmcv/runner/utils.py
  function get_host_info (line 10) | def get_host_info():
  function get_time_str (line 14) | def get_time_str():
  function obj_from_dict (line 18) | def obj_from_dict(info, parent=None, default_args=None):

FILE: code/mmcv/mmcv/utils/config.py
  class ConfigDict (line 21) | class ConfigDict(Dict):
    method __missing__ (line 23) | def __missing__(self, name):
    method __getattr__ (line 26) | def __getattr__(self, name):
  function add_args (line 39) | def add_args(parser, cfg, prefix=''):
  class Config (line 58) | class Config:
    method _validate_py_syntax (line 85) | def _validate_py_syntax(filename):
    method _file2dict (line 95) | def _file2dict(filename):
    method _merge_a_into_b (line 158) | def _merge_a_into_b(a, b):
    method fromfile (line 177) | def fromfile(filename):
    method auto_argparser (line 182) | def auto_argparser(description=None):
    method __init__ (line 194) | def __init__(self, cfg_dict=None, cfg_text=None, filename=None):
    method filename (line 216) | def filename(self):
    method text (line 220) | def text(self):
    method pretty_text (line 224) | def pretty_text(self):
    method __repr__ (line 317) | def __repr__(self):
    method __len__ (line 320) | def __len__(self):
    method __getattr__ (line 323) | def __getattr__(self, name):
    method __getitem__ (line 326) | def __getitem__(self, name):
    method __setattr__ (line 329) | def __setattr__(self, name, value):
    method __setitem__ (line 334) | def __setitem__(self, name, value):
    method __iter__ (line 339) | def __iter__(self):
    method dump (line 342) | def dump(self, file=None):
    method merge_from_dict (line 358) | def merge_from_dict(self, options):
  class DictAction (line 390) | class DictAction(Action):
    method _parse_int_float_bool (line 398) | def _parse_int_float_bool(val):
    method __call__ (line 411) | def __call__(self, parser, namespace, values, option_string=None):

FILE: code/mmcv/mmcv/utils/logging.py
  function get_logger (line 8) | def get_logger(name, log_file=None, log_level=logging.INFO):
  function print_log (line 68) | def print_log(msg, logger=None, level=logging.INFO):

FILE: code/mmcv/mmcv/utils/misc.py
  function is_str (line 9) | def is_str(x):
  function iter_cast (line 17) | def iter_cast(inputs, dst_type, return_type=None):
  function list_cast (line 42) | def list_cast(inputs, dst_type):
  function tuple_cast (line 50) | def tuple_cast(inputs, dst_type):
  function is_seq_of (line 58) | def is_seq_of(seq, expected_type, seq_type=None):
  function is_list_of (line 82) | def is_list_of(seq, expected_type):
  function is_tuple_of (line 90) | def is_tuple_of(seq, expected_type):
  function slice_list (line 98) | def slice_list(in_list, lens):
  function concat_list (line 124) | def concat_list(in_list):
  function check_prerequisites (line 136) | def check_prerequisites(
  function _check_py_package (line 174) | def _check_py_package(package):
  function _check_executable (line 183) | def _check_executable(cmd):
  function requires_package (line 190) | def requires_package(prerequisites):
  function requires_executable (line 206) | def requires_executable(prerequisites):

FILE: code/mmcv/mmcv/utils/parrots_wrapper.py
  function _get_cuda_home (line 8) | def _get_cuda_home():
  function get_build_config (line 16) | def get_build_config():
  function _get_conv (line 24) | def _get_conv():
  function _get_dataloader (line 32) | def _get_dataloader():
  function _get_extension (line 41) | def _get_extension():
  function _get_pool (line 52) | def _get_pool():
  function _get_norm (line 64) | def _get_norm():
  class SyncBatchNorm (line 83) | class SyncBatchNorm(SyncBatchNorm_):
    method _specify_ddp_gpu_num (line 85) | def _specify_ddp_gpu_num(self, gpu_size):
    method _check_input_dim (line 89) | def _check_input_dim(self, input):

FILE: code/mmcv/mmcv/utils/path.py
  function is_filepath (line 9) | def is_filepath(x):
  function fopen (line 13) | def fopen(filepath, *args, **kwargs):
  function check_file_exist (line 21) | def check_file_exist(filename, msg_tmpl='file "{}" does not exist'):
  function mkdir_or_exist (line 26) | def mkdir_or_exist(dir_name, mode=0o777):
  function symlink (line 33) | def symlink(src, dst, overwrite=True, **kwargs):
  function scandir (line 39) | def scandir(dir_path, suffix=None, recursive=False):
  function find_vcs_root (line 80) | def find_vcs_root(path, markers=('.git', )):

FILE: code/mmcv/mmcv/utils/progressbar.py
  class ProgressBar (line 10) | class ProgressBar:
    method __init__ (line 13) | def __init__(self, task_num=0, bar_width=50, start=True, file=sys.stdo...
    method terminal_width (line 22) | def terminal_width(self):
    method start (line 26) | def start(self):
    method update (line 35) | def update(self):
  function track_progress (line 63) | def track_progress(func, tasks, bar_width=50, file=sys.stdout, **kwargs):
  function init_pool (line 97) | def init_pool(process_num, initializer=None, initargs=None):
  function track_parallel_progress (line 108) | def track_parallel_progress(func,
  function track_iter_progress (line 178) | def track_iter_progress(tasks, bar_width=50, file=sys.stdout):

FILE: code/mmcv/mmcv/utils/registry.py
  class Registry (line 8) | class Registry:
    method __init__ (line 15) | def __init__(self, name):
    method __len__ (line 19) | def __len__(self):
    method __contains__ (line 22) | def __contains__(self, key):
    method __repr__ (line 25) | def __repr__(self):
    method name (line 32) | def name(self):
    method module_dict (line 36) | def module_dict(self):
    method get (line 39) | def get(self, key):
    method _register_module (line 50) | def _register_module(self, module_class, module_name=None, force=False):
    method deprecated_register_module (line 62) | def deprecated_register_module(self, cls=None, force=False):
    method register_module (line 72) | def register_module(self, name=None, force=False, module=None):
  function build_from_cfg (line 128) | def build_from_cfg(cfg, registry, default_args=None):

FILE: code/mmcv/mmcv/utils/timer.py
  class TimerError (line 5) | class TimerError(Exception):
    method __init__ (line 7) | def __init__(self, message):
  class Timer (line 12) | class Timer:
    method __init__ (line 38) | def __init__(self, start=True, print_tmpl=None):
    method is_running (line 45) | def is_running(self):
    method __enter__ (line 49) | def __enter__(self):
    method __exit__ (line 53) | def __exit__(self, type, value, traceback):
    method start (line 57) | def start(self):
    method since_start (line 64) | def since_start(self):
    method since_last_check (line 74) | def since_last_check(self):
  function check_time (line 92) | def check_time(timer_id):

FILE: code/mmcv/mmcv/video/io.py
  class Cache (line 14) | class Cache:
    method __init__ (line 16) | def __init__(self, capacity):
    method capacity (line 23) | def capacity(self):
    method size (line 27) | def size(self):
    method put (line 30) | def put(self, key, val):
    method get (line 37) | def get(self, key, default=None):
  class VideoReader (line 42) | class VideoReader:
    method __init__ (line 64) | def __init__(self, filename, cache_capacity=10):
    method vcap (line 78) | def vcap(self):
    method opened (line 83) | def opened(self):
    method width (line 88) | def width(self):
    method height (line 93) | def height(self):
    method resolution (line 98) | def resolution(self):
    method fps (line 103) | def fps(self):
    method frame_cnt (line 108) | def frame_cnt(self):
    method fourcc (line 113) | def fourcc(self):
    method position (line 118) | def position(self):
    method _get_real_position (line 122) | def _get_real_position(self):
    method _set_real_position (line 125) | def _set_real_position(self, frame_id):
    method read (line 132) | def read(self):
    method get_frame (line 158) | def get_frame(self, frame_id):
    method current_frame (line 185) | def current_frame(self):
    method cvt2frames (line 196) | def cvt2frames(self,
    method __len__ (line 241) | def __len__(self):
    method __getitem__ (line 244) | def __getitem__(self, index):
    method __iter__ (line 257) | def __iter__(self):
    method __next__ (line 261) | def __next__(self):
    method __enter__ (line 270) | def __enter__(self):
    method __exit__ (line 273) | def __exit__(self, exc_type, exc_value, traceback):
  function frames2video (line 277) | def frames2video(frame_dir,

FILE: code/mmcv/mmcv/video/optflow.py
  function flowread (line 10) | def flowread(flow_or_path, quantize=False, concat_axis=0, *args, **kwargs):
  function flowwrite (line 59) | def flowwrite(flow, filename, quantize=False, concat_axis=0, *args, **kw...
  function quantize_flow (line 89) | def quantize_flow(flow, max_val=0.02, norm=True):
  function dequantize_flow (line 117) | def dequantize_flow(dx, dy, max_val=0.02, denorm=True):
  function flow_warp (line 141) | def flow_warp(img, flow, filling_value=0, interpolate_mode='nearest'):

FILE: code/mmcv/mmcv/video/optflow_warp/flow_warp.cpp
  function FlowWarp (line 4) | void FlowWarp(double* img, double* flow, double* out, const int height,
  function BilinearInterpolate (line 34) | void BilinearInterpolate(const double* img, int width, int height, int c...
  function NNInterpolate (line 56) | void NNInterpolate(const double* img, int width, int height, int channels,

FILE: code/mmcv/mmcv/video/optflow_warp/flow_warp.hpp
  function T (line 18) | inline T __min__(T a, T b) {
  function T (line 23) | inline T __max__(T a, T b) {
  function T (line 28) | inline T EnforceRange(const T x, const int MaxValue) {

FILE: code/mmcv/mmcv/video/processing.py
  function convert_video (line 11) | def convert_video(in_file,
  function resize_video (line 55) | def resize_video(in_file,
  function cut_video (line 93) | def cut_video(in_file,
  function concat_video (line 128) | def concat_video(video_list,

FILE: code/mmcv/mmcv/visualization/color.py
  class Color (line 9) | class Color(Enum):
  function color_val (line 24) | def color_val(color):

FILE: code/mmcv/mmcv/visualization/image.py
  function imshow (line 30) | def imshow(img, win_name='', wait_time=0):
  function imshow_bboxes (line 51) | def imshow_bboxes(img,
  function imshow_det_bboxes (line 99) | def imshow_det_bboxes(img,
  function imshow_extremes (line 164) | def imshow_extremes(img,
  function imshow_polygons (line 226) | def imshow_polygons(img,
  function imshow_pose (line 276) | def imshow_pose(img,

FILE: code/mmcv/mmcv/visualization/optflow.py
  function flowshow (line 11) | def flowshow(flow, win_name='', wait_time=0):
  function flow2rgb (line 24) | def flow2rgb(flow, color_wheel=None, unknown_thr=1e6):
  function make_color_wheel (line 76) | def make_color_wheel(bins=None):

FILE: code/mmcv/setup.py
  function choose_requirement (line 12) | def choose_requirement(primary, secondary):
  function readme (line 25) | def readme():
  function get_version (line 31) | def get_version():
  function parse_requirements (line 38) | def parse_requirements(fname='requirements.txt', with_version=True):

FILE: code/mmcv/tests/test_arraymisc.py
  function test_quantize (line 10) | def test_quantize():
  function test_dequantize (line 35) | def test_dequantize():
  function test_joint (line 58) | def test_joint():

FILE: code/mmcv/tests/test_cnn/test_build_layers.py
  function test_build_conv_layer (line 15) | def test_build_conv_layer():
  function test_infer_abbr (line 59) | def test_infer_abbr():
  function test_build_norm_layer (line 96) | def test_build_norm_layer():
  function test_build_activation_layer (line 151) | def test_build_activation_layer():
  function test_build_padding_layer (line 174) | def test_build_padding_layer():
  function test_upsample_layer (line 202) | def test_upsample_layer():
  function test_pixel_shuffle_pack (line 258) | def test_pixel_shuffle_pack():
  function test_is_norm (line 266) | def test_is_norm():

FILE: code/mmcv/tests/test_cnn/test_conv_module.py
  class ExampleConv (line 11) | class ExampleConv(nn.Module):
    method __init__ (line 13) | def __init__(self,
    method forward (line 39) | def forward(self, x):
    method init_weights (line 43) | def init_weights(self):
  function test_conv_module (line 47) | def test_conv_module():
  function test_bias (line 139) | def test_bias():
  function conv_forward (line 160) | def conv_forward(self, x):
  function bn_forward (line 164) | def bn_forward(self, x):
  function relu_forward (line 168) | def relu_forward(self, x):
  function test_order (line 175) | def test_order():

FILE: code/mmcv/tests/test_cnn/test_flops_counter.py
  class ExampleModel (line 45) | class ExampleModel(nn.Module):
    method __init__ (line 47) | def __init__(self):
    method forward (line 51) | def forward(self, imgs):
  function input_constructor (line 56) | def input_constructor(x):
  function test_flops_counter (line 60) | def test_flops_counter():
  function test_flops_to_string (line 115) | def test_flops_to_string():
  function test_params_to_string (line 133) | def test_params_to_string():

FILE: code/mmcv/tests/test_cnn/test_hsigmoid.py
  function test_hsigmoid (line 6) | def test_hsigmoid():

FILE: code/mmcv/tests/test_cnn/test_hswish.py
  function test_hswish (line 7) | def test_hswish():

FILE: code/mmcv/tests/test_cnn/test_non_local.py
  function test_nonlocal (line 9) | def test_nonlocal():

FILE: code/mmcv/tests/test_cnn/test_scale.py
  function test_scale (line 6) | def test_scale():

FILE: code/mmcv/tests/test_cnn/test_weight_init.py
  function test_constant_init (line 11) | def test_constant_init():
  function test_xavier_init (line 23) | def test_xavier_init():
  function test_normal_init (line 35) | def test_normal_init():
  function test_uniform_init (line 45) | def test_uniform_init():
  function test_kaiming_init (line 54) | def test_kaiming_init():
  function test_caffe_xavier_init (line 66) | def test_caffe_xavier_init():
  function test_bias_init_with_prob (line 71) | def test_bias_init_with_prob():

FILE: code/mmcv/tests/test_config.py
  function test_construct (line 13) | def test_construct():
  function test_fromfile (line 64) | def test_fromfile():
  function test_merge_from_base (line 79) | def test_merge_from_base():
  function test_merge_from_multiple_bases (line 99) | def test_merge_from_multiple_bases():
  function test_merge_recursive_bases (line 117) | def test_merge_recursive_bases():
  function test_merge_from_dict (line 129) | def test_merge_from_dict():
  function test_merge_delete (line 138) | def test_merge_delete():
  function test_merge_intermediate_variable (line 149) | def test_merge_intermediate_variable():
  function test_fromfile_in_config (line 163) | def test_fromfile_in_config():
  function test_dict (line 174) | def test_dict():
  function test_setattr (line 219) | def test_setattr():
  function test_pretty_text (line 232) | def test_pretty_text():
  function test_dict_action (line 243) | def test_dict_action():
  function test_dump_mapping (line 259) | def test_dump_mapping():
  function test_reserved_key (line 271) | def test_reserved_key():
  function test_syntax_error (line 277) | def test_syntax_error():

FILE: code/mmcv/tests/test_fileclient.py
  class MockS3Client (line 16) | class MockS3Client:
    method __init__ (line 18) | def __init__(self, enable_mc=True):
    method Get (line 21) | def Get(self, filepath):
  class MockMemcachedClient (line 27) | class MockMemcachedClient:
    method __init__ (line 29) | def __init__(self, server_list_cfg, client_cfg):
    method Get (line 32) | def Get(self, filepath, buffer):
  class TestFileClient (line 37) | class TestFileClient:
    method setup_class (line 40) | def setup_class(cls):
    method test_error (line 46) | def test_error(self):
    method test_disk_backend (line 50) | def test_disk_backend(self):
    method test_ceph_backend (line 72) | def test_ceph_backend(self):
    method test_petrel_backend (line 110) | def test_petrel_backend(self):
    method test_memcached_backend (line 147) | def test_memcached_backend(self):
    method test_lmdb_backend (line 167) | def test_lmdb_backend(self):
    method test_register_backend (line 188) | def test_register_backend(self):

FILE: code/mmcv/tests/test_fileio.py
  function _test_handler (line 11) | def _test_handler(file_format, test_obj, str_checker, mode='r+'):
  function test_json (line 47) | def test_json():
  function test_yaml (line 57) | def test_yaml():
  function test_pickle (line 68) | def test_pickle():
  function test_exception (line 77) | def test_exception():
  function test_register_handler (line 87) | def test_register_handler():
  function test_list_from_file (line 124) | def test_list_from_file():
  function test_dict_from_file (line 138) | def test_dict_from_file():

FILE: code/mmcv/tests/test_image/test_colorspace.py
  function test_bgr2gray (line 12) | def test_bgr2gray():
  function test_rgb2gray (line 24) | def test_rgb2gray():
  function test_gray2bgr (line 36) | def test_gray2bgr():
  function test_gray2rgb (line 44) | def test_gray2rgb():
  function test_bgr2rgb (line 52) | def test_bgr2rgb():
  function test_rgb2bgr (line 61) | def test_rgb2bgr():
  function test_bgr2hsv (line 70) | def test_bgr2hsv():
  function test_convert_input_type_range (line 92) | def test_convert_input_type_range():
  function test_convert_output_type_range (line 109) | def test_convert_output_type_range():
  function test_rgb2ycbcr (line 126) | def test_rgb2ycbcr():
  function test_bgr2ycbcr (line 184) | def test_bgr2ycbcr():
  function test_ycbcr2rgb (line 238) | def test_ycbcr2rgb():
  function test_ycbcr2bgr (line 276) | def test_ycbcr2bgr():
  function test_bgr2hls (line 309) | def test_bgr2hls():
  function test_imconvert (line 347) | def test_imconvert(src, dst, ref):

FILE: code/mmcv/tests/test_image/test_geometric.py
  class TestGeometric (line 12) | class TestGeometric:
    method setup_class (line 15) | def setup_class(cls):
    method test_imresize (line 21) | def test_imresize(self):
    method test_imresize_like (line 38) | def test_imresize_like(self):
    method test_rescale_size (line 43) | def test_rescale_size(self):
    method test_imrescale (line 71) | def test_imrescale(self):
    method test_imflip (line 98) | def test_imflip(self):
    method test_imflip_ (line 130) | def test_imflip_(self):
    method test_imcrop (line 181) | def test_imcrop(self):
    method test_impad (line 223) | def test_impad(self):
    method test_impad_to_multiple (line 259) | def test_impad_to_multiple(self):
    method test_imrotate (line 270) | def test_imrotate(self):

FILE: code/mmcv/tests/test_image/test_io.py
  class TestIO (line 16) | class TestIO:
    method setup_class (line 19) | def setup_class(cls):
    method assert_img_equal (line 31) | def assert_img_equal(self, img, ref_img, ratio_thr=0.999):
    method test_imread (line 38) | def test_imread(self):
    method test_imfrombytes (line 177) | def test_imfrombytes(self):
    method test_imwrite (line 271) | def test_imwrite(self):
    method test_no_turbojpeg (line 284) | def test_no_turbojpeg(self):
    method test_no_pillow (line 291) | def test_no_pillow(self):

FILE: code/mmcv/tests/test_image/test_photometric.py
  class TestPhotometric (line 11) | class TestPhotometric:
    method setup_class (line 14) | def setup_class(cls):
    method test_imnormalize (line 21) | def test_imnormalize(self):
    method test_imnormalize_ (line 31) | def test_imnormalize_(self):
    method test_imdenormalize (line 43) | def test_imdenormalize(self):
    method test_iminvert (line 52) | def test_iminvert(self):
    method test_solarize (line 59) | def test_solarize(self):
    method test_posterize (line 69) | def test_posterize(self):

FILE: code/mmcv/tests/test_load_model_zoo.py
  function test_set_mmcv_home (line 17) | def test_set_mmcv_home():
  function test_default_mmcv_home (line 25) | def test_default_mmcv_home():
  function test_get_external_models (line 36) | def test_get_external_models():
  function test_get_deprecated_models (line 50) | def test_get_deprecated_models():
  function load_url_dist (line 61) | def load_url_dist(url):
  function load (line 65) | def load(filepath, map_location=None):
  function test_load_external_url (line 72) | def test_load_external_url():

FILE: code/mmcv/tests/test_logging.py
  function test_get_logger_rank0 (line 14) | def test_get_logger_rank0():
  function test_get_logger_rank1 (line 43) | def test_get_logger_rank1():
  function test_print_log_print (line 57) | def test_print_log_print(capsys):
  function test_print_log_silent (line 63) | def test_print_log_silent(capsys, caplog):
  function test_print_log_logger (line 70) | def test_print_log_logger(caplog):
  function test_print_log_exception (line 89) | def test_print_log_exception():

FILE: code/mmcv/tests/test_misc.py
  function test_iter_cast (line 7) | def test_iter_cast():
  function test_is_seq_of (line 19) | def test_is_seq_of():
  function test_slice_list (line 30) | def test_slice_list():
  function test_concat_list (line 40) | def test_concat_list():
  function test_requires_package (line 45) | def test_requires_package(capsys):
  function test_requires_executable (line 75) | def test_requires_executable(capsys):

FILE: code/mmcv/tests/test_optimizer.py
  class SubModel (line 12) | class SubModel(nn.Module):
    method __init__ (line 14) | def __init__(self):
    method forward (line 20) | def forward(self, x):
  class ExampleModel (line 24) | class ExampleModel(nn.Module):
    method __init__ (line 26) | def __init__(self):
    method forward (line 34) | def forward(self, x):
  class ExampleDuplicateModel (line 38) | class ExampleDuplicateModel(nn.Module):
    method __init__ (line 40) | def __init__(self):
    method forward (line 50) | def forward(self, x):
  class PseudoDataParallel (line 54) | class PseudoDataParallel(nn.Module):
    method __init__ (line 56) | def __init__(self):
    method forward (line 60) | def forward(self, x):
  function check_default_optimizer (line 69) | def check_default_optimizer(optimizer, model, prefix=''):
  function check_optimizer (line 87) | def check_optimizer(optimizer,
  function test_default_optimizer_constructor (line 152) | def test_default_optimizer_constructor():
  function test_torch_optimizers (line 494) | def test_torch_optimizers():
  function test_build_optimizer_constructor (line 502) | def test_build_optimizer_constructor():
  function test_build_optimizer (line 563) | def test_build_optimizer():

FILE: code/mmcv/tests/test_parallel.py
  function test_is_module_wrapper (line 15) | def test_is_module_wrapper():

FILE: code/mmcv/tests/test_path.py
  function test_is_filepath (line 10) | def test_is_filepath():
  function test_fopen (line 17) | def test_fopen():
  function test_check_file_exist (line 22) | def test_check_file_exist():
  function test_scandir (line 28) | def test_scandir():

FILE: code/mmcv/tests/test_progressbar.py
  function reset_string_io (line 18) | def reset_string_io(io):
  class TestProgressBar (line 23) | class TestProgressBar:
    method test_start (line 25) | def test_start(self):
    method test_update (line 49) | def test_update(self):
    method test_adaptive_length (line 67) | def test_adaptive_length(self):
  function sleep_1s (line 88) | def sleep_1s(num):
  function test_track_progress_list (line 93) | def test_track_progress_list():
  function test_track_progress_iterator (line 104) | def test_track_progress_iterator():
  function test_track_iter_progress (line 116) | def test_track_iter_progress():
  function test_track_enum_progress (line 129) | def test_track_enum_progress():
  function test_track_parallel_progress_list (line 146) | def test_track_parallel_progress_list():
  function test_track_parallel_progress_iterator (line 159) | def test_track_parallel_progress_iterator():

FILE: code/mmcv/tests/test_registry.py
  function test_registry (line 6) | def test_registry():
  function test_build_from_cfg (line 124) | def test_build_from_cfg():

FILE: code/mmcv/tests/test_runner/test_dist_utils.py
  function test_init_dist (line 13) | def test_init_dist(mock_getoutput, mock_dist_init, mock_set_device,

FILE: code/mmcv/tests/test_runner/test_hooks.py
  function test_pavi_hook (line 30) | def test_pavi_hook():
  function test_momentum_runner_hook (line 51) | def test_momentum_runner_hook():
  function test_cosine_runner_hook (line 101) | def test_cosine_runner_hook():
  function test_cosine_restart_lr_update_hook (line 148) | def test_cosine_restart_lr_update_hook():
  function test_mlflow_hook (line 227) | def test_mlflow_hook(log_model):
  function test_wandb_hook (line 252) | def test_wandb_hook():
  function _build_demo_runner (line 271) | def _build_demo_runner():

FILE: code/mmcv/tests/test_runner/test_runner.py
  class OldStyleModel (line 17) | class OldStyleModel(nn.Module):
    method __init__ (line 19) | def __init__(self):
  class Model (line 24) | class Model(OldStyleModel):
    method train_step (line 26) | def train_step(self):
    method val_step (line 29) | def val_step(self):
  function test_epoch_based_runner (line 33) | def test_epoch_based_runner():
  function test_runner_with_parallel (line 108) | def test_runner_with_parallel():
  function test_save_checkpoint (line 130) | def test_save_checkpoint():
  function test_build_lr_momentum_hook (line 147) | def test_build_lr_momentum_hook():

FILE: code/mmcv/tests/test_timer.py
  function test_timer_init (line 9) | def test_timer_init():
  function test_timer_run (line 18) | def test_timer_run():
  function test_timer_context (line 32) | def test_timer_context(capsys):

FILE: code/mmcv/tests/test_video/test_optflow.py
  function test_flowread (line 13) | def test_flowread():
  function test_flowwrite (line 50) | def test_flowwrite():
  function test_quantize_flow (line 75) | def test_quantize_flow():
  function test_dequantize_flow (line 102) | def test_dequantize_flow():
  function test_flow2rgb (line 126) | def test_flow2rgb():
  function test_flow_warp (line 142) | def test_flow_warp():
  function test_make_color_wheel (line 182) | def test_make_color_wheel():

FILE: code/mmcv/tests/test_video/test_processing.py
  class TestVideoEditor (line 9) | class TestVideoEditor:
    method setup_class (line 12) | def setup_class(cls):
    method test_cut_concat_video (line 16) | def test_cut_concat_video(self):
    method test_resize_video (line 34) | def test_resize_video(self):

FILE: code/mmcv/tests/test_video/test_reader.py
  class TestCache (line 13) | class TestCache:
    method test_init (line 15) | def test_init(self):
    method test_put (line 22) | def test_put(self):
    method test_get (line 34) | def test_get(self):
  class TestVideoReader (line 42) | class TestVideoReader:
    method setup_class (line 45) | def setup_class(cls):
    method test_load (line 49) | def test_load(self):
    method test_read (line 60) | def test_read(self):
    method test_slice (line 81) | def test_slice(self):
    method test_current_frame (line 108) | def test_current_frame(self):
    method test_position (line 115) | def test_position(self):
    method test_iterator (line 124) | def test_iterator(self):
    method test_with (line 131) | def test_with(self):
    method test_cvt2frames (line 136) | def test_cvt2frames(self):
    method test_frames2video (line 168) | def test_frames2video(self):

FILE: code/mmcv/tests/test_visualization.py
  function test_color (line 8) | def test_color():

FILE: code/mmdet/apis/inference.py
  function init_detector (line 15) | def init_detector(config, checkpoint=None, device='cuda:0'):
  class LoadImage (line 49) | class LoadImage(object):
    method __call__ (line 52) | def __call__(self, results):
  function inference_detector (line 76) | def inference_detector(model, img):
  function async_inference_detector (line 118) | async def async_inference_detector(model, img):
  function show_result_pyplot (line 146) | def show_result_pyplot(model, img, result, score_thr=0.3, fig_size=(15, ...

FILE: code/mmdet/apis/test.py
  function single_gpu_test (line 16) | def single_gpu_test(model,
  function multi_gpu_test (line 77) | def multi_gpu_test(model, data_loader, tmpdir=None, gpu_collect=False, b...
  function collect_results_cpu (line 135) | def collect_results_cpu(result_part, size, tmpdir=None):
  function collect_results_gpu (line 177) | def collect_results_gpu(result_part, size):

FILE: code/mmdet/apis/train.py
  function set_random_seed (line 14) | def set_random_seed(seed, deterministic=False):
  function train_detector (line 33) | def train_detector(model,

FILE: code/mmdet/core/anchor/anchor_generator.py
  class AnchorGenerator (line 10) | class AnchorGenerator(object):
    method __init__ (line 58) | def __init__(self,
    method num_base_anchors (line 113) | def num_base_anchors(self):
    method num_levels (line 118) | def num_levels(self):
    method gen_base_anchors (line 122) | def gen_base_anchors(self):
    method gen_single_level_base_anchors (line 142) | def gen_single_level_base_anchors(self,
    method _meshgrid (line 187) | def _meshgrid(self, x, y, row_major=True):
    method grid_anchors (line 206) | def grid_anchors(self, featmap_sizes, device='cuda'):
    method single_level_grid_anchors (line 232) | def single_level_grid_anchors(self,
    method valid_flags (line 269) | def valid_flags(self, featmap_sizes, pad_shape, device='cuda'):
    method single_level_valid_flags (line 296) | def single_level_valid_flags(self,
    method __repr__ (line 327) | def __repr__(self):
  class SSDAnchorGenerator (line 347) | class SSDAnchorGenerator(AnchorGenerator):
    method __init__ (line 363) | def __init__(self,
    method gen_base_anchors (line 432) | def gen_base_anchors(self):
    method __repr__ (line 453) | def __repr__(self):
  class LegacyAnchorGenerator (line 471) | class LegacyAnchorGenerator(AnchorGenerator):
    method gen_single_level_base_anchors (line 518) | def gen_single_level_base_anchors(self,
  class LegacySSDAnchorGenerator (line 569) | class LegacySSDAnchorGenerator(SSDAnchorGenerator, LegacyAnchorGenerator):
    method __init__ (line 576) | def __init__(self,

FILE: code/mmdet/core/anchor/builder.py
  function build_anchor_generator (line 6) | def build_anchor_generator(cfg, default_args=None):

FILE: code/mmdet/core/anchor/point_generator.py
  class PointGenerator (line 7) | class PointGenerator(object):
    method _meshgrid (line 9) | def _meshgrid(self, x, y, row_major=True):
    method grid_points (line 17) | def grid_points(self, featmap_size, stride=16, device='cuda'):
    method valid_flags (line 27) | def valid_flags(self, featmap_size, valid_size, device='cuda'):

FILE: code/mmdet/core/anchor/utils.py
  function images_to_levels (line 4) | def images_to_levels(target, num_levels):
  function anchor_inside_flags (line 20) | def anchor_inside_flags(flat_anchors,
  function calc_region (line 49) | def calc_region(bbox, ratio, featmap_size=None):

FILE: code/mmdet/core/bbox/assigners/approx_max_iou_assigner.py
  class ApproxMaxIoUAssigner (line 9) | class ApproxMaxIoUAssigner(MaxIoUAssigner):
    method __init__ (line 39) | def __init__(self,
    method assign (line 59) | def assign(self,

FILE: code/mmdet/core/bbox/assigners/assign_result.py
  class AssignResult (line 6) | class AssignResult(util_mixins.NiceRepr):
    method __init__ (line 43) | def __init__(self, num_gts, gt_inds, max_overlaps, labels=None):
    method num_preds (line 52) | def num_preds(self):
    method set_extra_property (line 56) | def set_extra_property(self, key, value):
    method get_extra_property (line 61) | def get_extra_property(self, key):
    method info (line 66) | def info(self):
    method __nice__ (line 78) | def __nice__(self):
    method random (line 98) | def random(cls, **kwargs):
    method add_gt_ (line 191) | def add_gt_(self, gt_labels):

FILE: code/mmdet/core/bbox/assigners/atss_assigner.py
  class ATSSAssigner (line 10) | class ATSSAssigner(BaseAssigner):
    method __init__ (line 23) | def __init__(self, topk, iou_calculator=dict(type='BboxOverlaps2D')):
    method assign (line 29) | def assign(self,

FILE: code/mmdet/core/bbox/assigners/base_assigner.py
  class BaseAssigner (line 4) | class BaseAssigner(metaclass=ABCMeta):
    method assign (line 8) | def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...

FILE: code/mmdet/core/bbox/assigners/center_region_assigner.py
  function scale_boxes (line 9) | def scale_boxes(bboxes, scale):
  function is_located_in (line 36) | def is_located_in(points, bboxes):
  function bboxes_area (line 54) | def bboxes_area(bboxes):
  class CenterRegionAssigner (line 72) | class CenterRegionAssigner(BaseAssigner):
    method __init__ (line 91) | def __init__(self,
    method get_gt_priorities (line 103) | def get_gt_priorities(self, gt_bboxes):
    method assign (line 121) | def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...
    method assign_one_hot_gt_indices (line 247) | def assign_one_hot_gt_indices(self,

FILE: code/mmdet/core/bbox/assigners/centroid_assigner.py
  class CentroidAssigner (line 10) | class CentroidAssigner(BaseAssigner):
    method __init__ (line 21) | def __init__(self, scale=4, pos_num=3, iou_type='center'):
    method assign (line 26) | def assign(self, points, gt_bboxes, gt_extreme_pts, gt_bboxes_ignore=N...
    method gen_centroid (line 95) | def gen_centroid(self, pts, num_gts):

FILE: code/mmdet/core/bbox/assigners/fcos_assigner.py
  class FCOSAssigner (line 10) | class FCOSAssigner(BaseAssigner):
    method __init__ (line 21) | def __init__(self, strides=[8, 16, 32, 64, 128],
    method assign (line 31) | def assign(self, points, num_points_per_lvl, gt_bboxes, gt_bboxes_igno...

FILE: code/mmdet/core/bbox/assigners/max_iou_assigner.py
  class MaxIoUAssigner (line 10) | class MaxIoUAssigner(BaseAssigner):
    method __init__ (line 40) | def __init__(self,
    method assign (line 60) | def assign(self, bboxes, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...
    method assign_wrt_overlaps (line 127) | def assign_wrt_overlaps(self, overlaps, gt_labels=None):

FILE: code/mmdet/core/bbox/assigners/point_assigner.py
  class PointAssigner (line 9) | class PointAssigner(BaseAssigner):
    method __init__ (line 20) | def __init__(self, scale=4, pos_num=3):
    method assign (line 24) | def assign(self, points, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...

FILE: code/mmdet/core/bbox/assigners/point_assigner_v2.py
  class PointAssignerV2 (line 9) | class PointAssignerV2(BaseAssigner):
    method __init__ (line 20) | def __init__(self, scale=4, pos_num=3):
    method assign (line 24) | def assign(self, points, gt_bboxes, gt_bboxes_ignore=None, gt_labels=N...

FILE: code/mmdet/core/bbox/assigners/point_ct_assigner.py
  class PointCTAssigner (line 13) | class PointCTAssigner(BaseAssigner):
    method assign (line 23) | def assign(self, points, gt_bboxes, gt_contours, sizes):

FILE: code/mmdet/core/bbox/assigners/point_hm_assigner.py
  class PointHMAssigner (line 9) | class PointHMAssigner(BaseAssigner):
    method __init__ (line 20) | def __init__(self, gaussian_bump=False, gaussian_iou=0.7):
    method assign (line 24) | def assign(self, points, gt_bboxes, gt_labels=None):
  function gaussian_radius (line 145) | def gaussian_radius(det_size, min_overlap):

FILE: code/mmdet/core/bbox/builder.py
  function build_assigner (line 8) | def build_assigner(cfg, **default_args):
  function build_sampler (line 13) | def build_sampler(cfg, **default_args):
  function build_bbox_coder (line 18) | def build_bbox_coder(cfg, **default_args):

FILE: code/mmdet/core/bbox/coder/base_bbox_coder.py
  class BaseBBoxCoder (line 4) | class BaseBBoxCoder(metaclass=ABCMeta):
    method __init__ (line 7) | def __init__(self, **kwargs):
    method encode (line 11) | def encode(self, bboxes, gt_bboxes):
    method decode (line 16) | def decode(self, bboxes, bboxes_pred):

FILE: code/mmdet/core/bbox/coder/delta_xywh_bbox_coder.py
  class DeltaXYWHBBoxCoder (line 9) | class DeltaXYWHBBoxCoder(BaseBBoxCoder):
    method __init__ (line 23) | def __init__(self,
    method encode (line 30) | def encode(self, bboxes, gt_bboxes):
    method decode (line 48) | def decode(self,
  function bbox2delta (line 74) | def bbox2delta(proposals, gt, means=(0., 0., 0., 0.), stds=(1., 1., 1., ...
  function delta2bbox (line 120) | def delta2bbox(rois,

FILE: code/mmdet/core/bbox/coder/legacy_delta_xywh_bbox_coder.py
  class LegacyDeltaXYWHBBoxCoder (line 9) | class LegacyDeltaXYWHBBoxCoder(BaseBBoxCoder):
    method __init__ (line 32) | def __init__(self,
    method encode (line 39) | def encode(self, bboxes, gt_bboxes):
    method decode (line 57) | def decode(self,
  function legacy_bbox2delta (line 82) | def legacy_bbox2delta(proposals,
  function legacy_delta2bbox (line 131) | def legacy_delta2bbox(rois,

FILE: code/mmdet/core/bbox/coder/pseudo_bbox_coder.py
  class PseudoBBoxCoder (line 6) | class PseudoBBoxCoder(BaseBBoxCoder):
    method __init__ (line 9) | def __init__(self, **kwargs):
    method encode (line 12) | def encode(self, bboxes, gt_bboxes):
    method decode (line 16) | def decode(self, bboxes, pred_bboxes):

FILE: code/mmdet/core/bbox/coder/tblr_bbox_coder.py
  class TBLRBBoxCoder (line 8) | class TBLRBBoxCoder(BaseBBoxCoder):
    method __init__ (line 22) | def __init__(self, normalizer=4.0):
    method encode (line 26) | def encode(self, bboxes, gt_bboxes):
    method decode (line 45) | def decode(self, bboxes, pred_bboxes, max_shape=None):
  function bboxes2tblr (line 67) | def bboxes2tblr(priors, gts, normalizer=4.0, normalize_by_wh=True):
  function tblr2bboxes (line 113) | def tblr2bboxes(priors,

FILE: code/mmdet/core/bbox/demodata.py
  function ensure_rng (line 5) | def ensure_rng(rng=None):
  function random_boxes (line 30) | def random_boxes(num=1, scale=1, rng=None):

FILE: code/mmdet/core/bbox/iou_calculators/builder.py
  function build_iou_calculator (line 6) | def build_iou_calculator(cfg, default_args=None):

FILE: code/mmdet/core/bbox/iou_calculators/iou2d_calculator.py
  class BboxOverlaps2D (line 7) | class BboxOverlaps2D(object):
    method __call__ (line 10) | def __call__(self, bboxes1, bboxes2, mode='iou', is_aligned=False):
    method __repr__ (line 33) | def __repr__(self):
  function bbox_overlaps (line 39) | def bbox_overlaps(bboxes1, bboxes2, mode='iou', is_aligned=False, eps=1e...

FILE: code/mmdet/core/bbox/samplers/base_sampler.py
  class BaseSampler (line 8) | class BaseSampler(metaclass=ABCMeta):
    method __init__ (line 11) | def __init__(self,
    method _sample_pos (line 25) | def _sample_pos(self, assign_result, num_expected, **kwargs):
    method _sample_neg (line 30) | def _sample_neg(self, assign_result, num_expected, **kwargs):
    method sample (line 34) | def sample(self,

FILE: code/mmdet/core/bbox/samplers/combined_sampler.py
  class CombinedSampler (line 6) | class CombinedSampler(BaseSampler):
    method __init__ (line 9) | def __init__(self, pos_sampler, neg_sampler, **kwargs):
    method _sample_pos (line 14) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 18) | def _sample_neg(self, **kwargs):

FILE: code/mmdet/core/bbox/samplers/instance_balanced_pos_sampler.py
  class InstanceBalancedPosSampler (line 9) | class InstanceBalancedPosSampler(RandomSampler):
    method _sample_pos (line 13) | def _sample_pos(self, assign_result, num_expected, **kwargs):

FILE: code/mmdet/core/bbox/samplers/iou_balanced_neg_sampler.py
  class IoUBalancedNegSampler (line 9) | class IoUBalancedNegSampler(RandomSampler):
    method __init__ (line 29) | def __init__(self,
    method sample_via_interval (line 46) | def sample_via_interval(self, max_overlaps, full_set, num_expected):
    method _sample_neg (line 88) | def _sample_neg(self, assign_result, num_expected, **kwargs):

FILE: code/mmdet/core/bbox/samplers/ohem_sampler.py
  class OHEMSampler (line 9) | class OHEMSampler(BaseSampler):
    method __init__ (line 17) | def __init__(self,
    method hard_mining (line 34) | def hard_mining(self, inds, num_expected, bboxes, labels, feats):
    method _sample_pos (line 52) | def _sample_pos(self,
    method _sample_neg (line 80) | def _sample_neg(self,

FILE: code/mmdet/core/bbox/samplers/pseudo_sampler.py
  class PseudoSampler (line 9) | class PseudoSampler(BaseSampler):
    method __init__ (line 12) | def __init__(self, **kwargs):
    method _sample_pos (line 15) | def _sample_pos(self, **kwargs):
    method _sample_neg (line 19) | def _sample_neg(self, **kwargs):
    method sample (line 23) | def sample(self, assign_result, bboxes, gt_bboxes, **kwargs):

FILE: code/mmdet/core/bbox/samplers/random_sampler.py
  class RandomSampler (line 8) | class RandomSampler(BaseSampler):
    method __init__ (line 20) | def __init__(self,
    method random_choice (line 31) | def random_choice(self, gallery, num):
    method _sample_pos (line 57) | def _sample_pos(self, assign_result, num_expected, **kwargs):
    method _sample_neg (line 67) | def _sample_neg(self, assign_result, num_expected, **kwargs):

FILE: code/mmdet/core/bbox/samplers/sampling_result.py
  class SamplingResult (line 6) | class SamplingResult(util_mixins.NiceRepr):
    method __init__ (line 25) | def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result,
    method bboxes (line 52) | def bboxes(self):
    method to (line 56) | def to(self, device):
    method __nice__ (line 71) | def __nice__(self):
    method info (line 80) | def info(self):
    method random (line 93) | def random(cls, rng=None, **kwargs):

FILE: code/mmdet/core/bbox/samplers/score_hlr_sampler.py
  class ScoreHLRSampler (line 11) | class ScoreHLRSampler(BaseSampler):
    method __init__ (line 35) | def __init__(self,
    method random_choice (line 65) | def random_choice(gallery, num):
    method _sample_pos (line 91) | def _sample_pos(self, assign_result, num_expected, **kwargs):
    method _sample_neg (line 99) | def _sample_neg(self,
    method sample (line 215) | def sample(self,

FILE: code/mmdet/core/bbox/transforms.py
  function bbox_flip (line 5) | def bbox_flip(bboxes, img_shape, direction='horizontal'):
  function polygon_flip (line 30) | def polygon_flip(polygons, img_shape, direction='horizontal'):
  function extreme_flip (line 48) | def extreme_flip(extremes, img_shape, direction='horizontal'):
  function kps_flip (line 69) | def kps_flip(kps, img_shape, direction='horizontal'):
  function bbox_mapping (line 91) | def bbox_mapping(bboxes,
  function bbox_mapping_back (line 103) | def bbox_mapping_back(bboxes,
  function instance_mapping_back (line 115) | def instance_mapping_back(bboxes,
  function bbox2roi (line 139) | def bbox2roi(bbox_list):
  function roi2bbox (line 161) | def roi2bbox(rois):
  function bbox2result (line 180) | def bbox2result(bboxes, labels, num_classes):
  function bbox_extreme2result (line 198) | def bbox_extreme2result(bboxes, extremes, labels, num_classes):
  function bbox_poly2result (line 209) | def bbox_poly2result(bboxes, polygons, labels, num_classes, num_contour_...
  function distance2bbox (line 221) | def distance2bbox(points, distance, max_shape=None):
  function bbox2distance (line 245) | def bbox2distance(points, bbox, max_dis=None, eps=0.1):

FILE: code/mmdet/core/evaluation/bbox_overlaps.py
  function bbox_overlaps (line 4) | def bbox_overlaps(bboxes1, bboxes2, mode='iou', eps=1e-6):

FILE: code/mmdet/core/evaluation/class_names.py
  function wider_face_classes (line 4) | def wider_face_classes():
  function voc_classes (line 8) | def voc_classes():
  function imagenet_det_classes (line 16) | def imagenet_det_classes():
  function imagenet_vid_classes (line 57) | def imagenet_vid_classes():
  function coco_classes (line 67) | def coco_classes():
  function cityscapes_classes (line 85) | def cityscapes_classes():
  function get_classes (line 102) | def get_classes(dataset):

FILE: code/mmdet/core/evaluation/eval_hooks.py
  class EvalHook (line 7) | class EvalHook(Hook):
    method __init__ (line 15) | def __init__(self, dataloader, interval=1, bbox_head=None, **eval_kwar...
    method after_train_epoch (line 24) | def after_train_epoch(self, runner):
    method evaluate (line 32) | def evaluate(self, runner, results):
  class DistEvalHook (line 40) | class DistEvalHook(EvalHook):
    method __init__ (line 52) | def __init__(self,
    method after_train_epoch (line 67) | def after_train_epoch(self, runner):

FILE: code/mmdet/core/evaluation/mean_ap.py
  function average_precision (line 12) | def average_precision(recalls, precisions, mode='area'):
  function tpfp_imagenet (line 59) | def tpfp_imagenet(det_bboxes,
  function tpfp_default (line 153) | def tpfp_default(det_bboxes,
  function get_cls_results (line 240) | def get_cls_results(det_results, annotations, class_id):
  function eval_map (line 267) | def eval_map(det_results,
  function print_map_summary (line 393) | def print_map_summary(mean_ap,

FILE: code/mmdet/core/evaluation/recall.py
  function _recalls (line 10) | def _recalls(all_ious, proposal_nums, thrs):
  function set_recall_param (line 43) | def set_recall_param(proposal_nums, iou_thrs):
  function eval_recalls (line 65) | def eval_recalls(gts,
  function print_recall_summary (line 110) | def print_recall_summary(recalls,
  function plot_num_recall (line 143) | def plot_num_recall(recalls, proposal_nums):
  function plot_iou_recall (line 168) | def plot_iou_recall(recalls, iou_thrs):

FILE: code/mmdet/core/fp16/decorators.py
  function auto_fp16 (line 9) | def auto_fp16(apply_to=None, out_fp32=False):
  function force_fp32 (line 88) | def force_fp32(apply_to=None, out_fp16=False):

FILE: code/mmdet/core/fp16/hooks.py
  class Fp16OptimizerHook (line 11) | class Fp16OptimizerHook(OptimizerHook):
    method __init__ (line 27) | def __init__(self,
    method before_run (line 39) | def before_run(self, runner):
    method copy_grads_to_fp32 (line 51) | def copy_grads_to_fp32(self, fp16_net, fp32_weights):
    method copy_params_to_fp16 (line 59) | def copy_params_to_fp16(self, fp16_net, fp32_weights):
    method after_train_iter (line 64) | def after_train_iter(self, runner):
  function wrap_fp16_model (line 99) | def wrap_fp16_model(model):
  function patch_norm_fp32 (line 118) | def patch_norm_fp32(module):
  function patch_forward_method (line 138) | def patch_forward_method(func, src_type, dst_type, convert_output=True):

FILE: code/mmdet/core/fp16/utils.py
  function cast_tensor_type (line 7) | def cast_tensor_type(inputs, src_type, dst_type):

FILE: code/mmdet/core/mask/mask_target.py
  function mask_target (line 6) | def mask_target(pos_proposals_list, pos_assigned_gt_inds_list, gt_masks_...
  function mask_target_single (line 31) | def mask_target_single(pos_proposals, pos_assigned_gt_inds, gt_masks, cfg):

FILE: code/mmdet/core/mask/structures.py
  class BaseInstanceMasks (line 11) | class BaseInstanceMasks(metaclass=ABCMeta):
    method rescale (line 14) | def rescale(self, scale, interpolation='nearest'):
    method resize (line 28) | def resize(self, out_shape, interpolation='nearest'):
    method flip (line 41) | def flip(self, flip_direction='horizontal'):
    method pad (line 53) | def pad(self, out_shape, pad_val):
    method crop (line 66) | def crop(self, bbox):
    method crop_and_resize (line 78) | def crop_and_resize(self,
    method expand (line 103) | def expand(self, expanded_h, expanded_w, top, left):
    method areas (line 109) | def areas(self):
    method to_ndarray (line 114) | def to_ndarray(self):
    method to_tensor (line 123) | def to_tensor(self, dtype, device):
  class BitmapMasks (line 136) | class BitmapMasks(BaseInstanceMasks):
    method __init__ (line 146) | def __init__(self, masks, height, width):
    method __getitem__ (line 163) | def __getitem__(self, index):
    method __iter__ (line 176) | def __iter__(self):
    method __repr__ (line 179) | def __repr__(self):
    method __len__ (line 186) | def __len__(self):
    method rescale (line 190) | def rescale(self, scale, interpolation='nearest'):
    method resize (line 203) | def resize(self, out_shape, interpolation='nearest'):
    method flip (line 214) | def flip(self, flip_direction='horizontal'):
    method pad (line 227) | def pad(self, out_shape, pad_val=0):
    method crop (line 238) | def crop(self, bbox):
    method crop_and_resize (line 257) | def crop_and_resize(self,
    method expand (line 289) | def expand(self, expanded_h, expanded_w, top, left):
    method areas (line 302) | def areas(self):
    method to_ndarray (line 306) | def to_ndarray(self):
    method to_tensor (line 310) | def to_tensor(self, dtype, device):
  class PolygonMasks (line 315) | class PolygonMasks(BaseInstanceMasks):
    method __init__ (line 330) | def __init__(self, masks, height, width):
    method __getitem__ (line 340) | def __getitem__(self, index):
    method __iter__ (line 363) | def __iter__(self):
    method __repr__ (line 366) | def __repr__(self):
    method __len__ (line 373) | def __len__(self):
    method rescale (line 377) | def rescale(self, scale, interpolation=None):
    method resize (line 386) | def resize(self, out_shape, interpolation=None):
    method flip (line 405) | def flip(self, flip_direction='horizontal', keep_cw=False):
    method crop (line 435) | def crop(self, bbox):
    method pad (line 464) | def pad(self, out_shape, pad_val=0):
    method expand (line 468) | def expand(self, *args, **kwargs):
    method crop_and_resize (line 472) | def crop_and_resize(self,
    method to_bitmap (line 508) | def to_bitmap(self):
    method areas (line 514) | def areas(self):
    method _polygon_area (line 532) | def _polygon_area(self, x, y):
    method to_ndarray (line 548) | def to_ndarray(self):
    method to_tensor (line 558) | def to_tensor(self, dtype, device):
  function polygon_to_bitmap (line 568) | def polygon_to_bitmap(polygons, height, width):

FILE: code/mmdet/core/mask/utils.py
  function split_combined_polys (line 6) | def split_combined_polys(polys, poly_lens, polys_per_mask):
  function encode_mask_results (line 36) | def encode_mask_results(mask_results):
  function get_rle (line 65) | def get_rle(cls_segm, img_h, img_w):
  function encode_poly_results (line 70) | def encode_poly_results(mask_results, img_h, img_w):

FILE: code/mmdet/core/post_processing/bbox_nms.py
  function multiclass_nms (line 7) | def multiclass_nms(multi_bboxes,
  function multiclass_nms_lsvr (line 60) | def multiclass_nms_lsvr(multi_bboxes,
  function multiclass_nms_pts (line 102) | def multiclass_nms_pts(multi_bboxes,
  function multiclass_nms_pts_refine (line 167) | def multiclass_nms_pts_refine(multi_bboxes,

FILE: code/mmdet/core/post_processing/merge_augs.py
  function merge_aug_proposals (line 8) | def merge_aug_proposals(aug_proposals, img_metas, rpn_test_cfg):
  function merge_aug_bboxes (line 48) | def merge_aug_bboxes(aug_bboxes, aug_scores, img_metas, rcnn_test_cfg):
  function merge_aug_scores (line 77) | def merge_aug_scores(aug_scores):
  function merge_aug_masks (line 85) | def merge_aug_masks(aug_masks, img_metas, rcnn_test_cfg, weights=None):

FILE: code/mmdet/core/utils/dist_utils.py
  function _allreduce_coalesced (line 10) | def _allreduce_coalesced(tensors, world_size, bucket_size_mb=-1):
  function allreduce_grads (line 32) | def allreduce_grads(params, coalesce=True, bucket_size_mb=-1):
  class DistOptimizerHook (line 54) | class DistOptimizerHook(OptimizerHook):
    method __init__ (line 57) | def __init__(self, *args, **kwargs):

FILE: code/mmdet/core/utils/misc.py
  function tensor2imgs (line 9) | def tensor2imgs(tensor, mean=(0, 0, 0), std=(1, 1, 1), to_rgb=True):
  function multi_apply (line 35) | def multi_apply(func, *args, **kwargs):
  function unmap (line 57) | def unmap(data, count, inds, fill=0):

FILE: code/mmdet/datasets/builder.py
  function _concat_dataset (line 26) | def _concat_dataset(cfg, default_args=None):
  function build_dataset (line 49) | def build_dataset(cfg, default_args=None):
  function build_dataloader (line 68) | def build_dataloader(dataset,
  function worker_init_fn (line 130) | def worker_init_fn(worker_id, num_workers, rank, seed):

FILE: code/mmdet/datasets/cityscapes.py
  class CityscapesDataset (line 19) | class CityscapesDataset(CocoDataset):
    method _filter_imgs (line 24) | def _filter_imgs(self, min_size=32):
    method _parse_ann_info (line 40) | def _parse_ann_info(self, img_info, ann_info):
    method results2txt (line 94) | def results2txt(self, results, outfile_prefix):
    method format_results (line 160) | def format_results(self, results, txtfile_prefix=None):
    method evaluate (line 193) | def evaluate(self,
    method _evaluate_cityscapes (line 260) | def _evaluate_cityscapes(self, results, txtfile_prefix, logger):

FILE: code/mmdet/datasets/coco.py
  class CocoDataset (line 19) | class CocoDataset(CustomDataset):
    method load_annotations (line 36) | def load_annotations(self, ann_file):
    method get_ann_info (line 57) | def get_ann_info(self, idx):
    method get_cat_ids (line 72) | def get_cat_ids(self, idx):
    method _filter_imgs (line 87) | def _filter_imgs(self, min_size=32):
    method get_subset_by_classes (line 98) | def get_subset_by_classes(self):
    method _parse_ann_info (line 123) | def _parse_ann_info(self, img_info, ann_info):
    method xyxy2xywh (line 188) | def xyxy2xywh(self, bbox):
    method _proposal2json (line 208) | def _proposal2json(self, results):
    method _det2json (line 223) | def _det2json(self, results):
    method _segm2json (line 240) | def _segm2json(self, results):
    method results2json (line 278) | def results2json(self, results, outfile_prefix):
    method fast_eval_recall (line 318) | def fast_eval_recall(self, results, proposal_nums, iou_thrs, logger=No...
    method format_results (line 342) | def format_results(self, results, jsonfile_prefix=None, **kwargs):
    method evaluate (line 370) | def evaluate(self,

FILE: code/mmdet/datasets/coco_pose.py
  class CocoPoseDataset (line 19) | class CocoPoseDataset(CustomDataset):
    method load_annotations (line 23) | def load_annotations(self, ann_file):
    method get_ann_info (line 44) | def get_ann_info(self, idx):
    method get_cat_ids (line 59) | def get_cat_ids(self, idx):
    method _filter_imgs (line 74) | def _filter_imgs(self, min_size=32):
    method get_subset_by_classes (line 85) | def get_subset_by_classes(self):
    method _parse_ann_info (line 110) | def _parse_ann_info(self, img_info, ann_info):
    method xyxy2xywh (line 174) | def xyxy2xywh(self, bbox):
    method _proposal2json (line 194) | def _proposal2json(self, results):
    method _det2json (line 209) | def _det2json(self, results):
    method _kps2json (line 226) | def _kps2json(self, results):
    method _segm2json (line 249) | def _segm2json(self, results):
    method results2json (line 287) | def results2json(self, results, outfile_prefix):
    method fast_eval_recall (line 331) | def fast_eval_recall(self, results, proposal_nums, iou_thrs, logger=No...
    method format_results (line 355) | def format_results(self, results, jsonfile_prefix=None, **kwargs):
    method evaluate (line 383) | def evaluate(self,

FILE: code/mmdet/datasets/custom.py
  class CustomDataset (line 13) | class CustomDataset(Dataset):
    method __init__ (line 50) | def __init__(self,
    method __len__ (line 103) | def __len__(self):
    method load_annotations (line 107) | def load_annotations(self, ann_file):
    method load_proposals (line 111) | def load_proposals(self, proposal_file):
    method get_ann_info (line 115) | def get_ann_info(self, idx):
    method get_cat_ids (line 127) | def get_cat_ids(self, idx):
    method pre_pipeline (line 139) | def pre_pipeline(self, results):
    method _filter_imgs (line 150) | def _filter_imgs(self, min_size=32):
    method _set_group_flag (line 158) | def _set_group_flag(self):
    method _rand_another (line 170) | def _rand_another(self, idx):
    method __getitem__ (line 175) | def __getitem__(self, idx):
    method prepare_train_img (line 195) | def prepare_train_img(self, idx):
    method prepare_test_img (line 214) | def prepare_test_img(self, idx):
    method get_classes (line 233) | def get_classes(cls, classes=None):
    method get_subset_by_classes (line 259) | def get_subset_by_classes(self):
    method format_results (line 262) | def format_results(self, results, **kwargs):
    method evaluate (line 266) | def evaluate(self,

FILE: code/mmdet/datasets/dataset_wrappers.py
  class ConcatDataset (line 12) | class ConcatDataset(_ConcatDataset):
    method __init__ (line 22) | def __init__(self, datasets):
    method get_cat_ids (line 31) | def get_cat_ids(self, idx):
  class RepeatDataset (line 55) | class RepeatDataset(object):
    method __init__ (line 68) | def __init__(self, dataset, times):
    method __getitem__ (line 77) | def __getitem__(self, idx):
    method get_cat_ids (line 80) | def get_cat_ids(self, idx):
    method __len__ (line 92) | def __len__(self):
  class ClassBalancedDataset (line 99) | class ClassBalancedDataset(object):
    method __init__ (line 131) | def __init__(self, dataset, oversample_thr):
    method _get_repeat_factors (line 149) | def _get_repeat_factors(self, dataset, repeat_thr):
    method __getitem__ (line 192) | def __getitem__(self, idx):
    method __len__ (line 196) | def __len__(self):

FILE: code/mmdet/datasets/deepfashion.py
  class DeepFashionDataset (line 6) | class DeepFashionDataset(CocoDataset):

FILE: code/mmdet/datasets/lvis.py
  class LVISDataset (line 15) | class LVISDataset(CocoDataset):
    method load_annotations (line 267) | def load_annotations(self, ann_file):
    method evaluate (line 301) | def evaluate(self,

FILE: code/mmdet/datasets/pipelines/auto_augment.py
  class AutoAugment (line 10) | class AutoAugment(object):
    method __init__ (line 51) | def __init__(self, policies):
    method __call__ (line 65) | def __call__(self, results):
    method __repr__ (line 69) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/compose.py
  class Compose (line 9) | class Compose(object):
    method __init__ (line 17) | def __init__(self, transforms):
    method __call__ (line 29) | def __call__(self, data):
    method __repr__ (line 45) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/formating.py
  function to_tensor (line 11) | def to_tensor(data):
  class ToTensor (line 37) | class ToTensor(object):
    method __init__ (line 44) | def __init__(self, keys):
    method __call__ (line 47) | def __call__(self, results):
    method __repr__ (line 61) | def __repr__(self):
  class ImageToTensor (line 66) | class ImageToTensor(object):
    method __init__ (line 77) | def __init__(self, keys):
    method __call__ (line 80) | def __call__(self, results):
    method __repr__ (line 98) | def __repr__(self):
  class Transpose (line 103) | class Transpose(object):
    method __init__ (line 111) | def __init__(self, keys, order):
    method __call__ (line 115) | def __call__(self, results):
    method __repr__ (line 129) | def __repr__(self):
  class ToDataContainer (line 135) | class ToDataContainer(object):
    method __init__ (line 146) | def __init__(self,
    method __call__ (line 151) | def __call__(self, results):
    method __repr__ (line 169) | def __repr__(self):
  class DefaultFormatBundle (line 174) | class DefaultFormatBundle(object):
    method __call__ (line 191) | def __call__(self, results):
    method _add_default_meta_keys (line 221) | def _add_default_meta_keys(self, results):
    method __repr__ (line 246) | def __repr__(self):
  class Collect (line 251) | class Collect(object):
    method __init__ (line 290) | def __init__(self,
    method __call__ (line 298) | def __call__(self, results):
    method __repr__ (line 320) | def __repr__(self):
  class WrapFieldsToLists (line 326) | class WrapFieldsToLists(object):
    method __call__ (line 347) | def __call__(self, results):
    method __repr__ (line 363) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/formating_reppointsv2.py
  class RPDV2FormatBundle (line 13) | class RPDV2FormatBundle(object):
    method __init__ (line 30) | def __init__(self):
    method __call__ (line 33) | def __call__(self, results):
    method _add_default_meta_keys (line 70) | def _add_default_meta_keys(self, results):
    method __repr__ (line 95) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/instaboost.py
  class InstaBoost (line 7) | class InstaBoost(object):
    method __init__ (line 14) | def __init__(self,
    method _load_anns (line 35) | def _load_anns(self, results):
    method _parse_anns (line 57) | def _parse_anns(self, results, anns, img):
    method __call__ (line 78) | def __call__(self, results):
    method __repr__ (line 94) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/loading.py
  class LoadImageFromFile (line 12) | class LoadImageFromFile(object):
    method __init__ (line 31) | def __init__(self,
    method __call__ (line 40) | def __call__(self, results):
    method __repr__ (line 72) | def __repr__(self):
  class LoadMultiChannelImageFromFiles (line 81) | class LoadMultiChannelImageFromFiles(object):
    method __init__ (line 101) | def __init__(self,
    method __call__ (line 110) | def __call__(self, results):
    method __repr__ (line 155) | def __repr__(self):
  class LoadAnnotations (line 164) | class LoadAnnotations(object):
    method __init__ (line 183) | def __init__(self,
    method _load_bboxes (line 207) | def _load_bboxes(self, results):
    method _load_extremes (line 227) | def _load_extremes(self, results):
    method _load_keypoints (line 242) | def _load_keypoints(self, results):
    method _load_labels (line 257) | def _load_labels(self, results):
    method _poly2mask (line 270) | def _poly2mask(self, mask_ann, img_h, img_w):
    method process_polygons (line 297) | def process_polygons(self, polygons):
    method uniformsample (line 314) | def uniformsample(self, pgtnp_px2, newpnum): # https://github.com/zju3...
    method _polygon_area (line 378) | def _polygon_area(self, poly):
    method filter_tiny_polys (line 396) | def filter_tiny_polys(self, polys):
    method get_cw_poly (line 405) | def get_cw_poly(self, poly):
    method unify_origin_polygon (line 408) | def unify_origin_polygon(self, poly):
    method unify_polygons (line 422) | def unify_polygons(self, polygons, gt_bbox):
    method _load_masks (line 443) | def _load_masks(self, results):
    method _load_semantic_seg (line 469) | def _load_semantic_seg(self, results):
    method __call__ (line 490) | def __call__(self, results):
    method __repr__ (line 517) | def __repr__(self):
  class LoadProposals (line 531) | class LoadProposals(object):
    method __init__ (line 541) | def __init__(self, num_max_proposals=None):
    method __call__ (line 544) | def __call__(self, results):
    method __repr__ (line 570) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/loading_reppointsv2.py
  class LoadRPDV2Annotations (line 9) | class LoadRPDV2Annotations(object):
    method __init__ (line 27) | def __init__(self, num_classes=80):
    method _load_semantic_map_from_box (line 31) | def _load_semantic_map_from_box(self, results):
    method __call__ (line 52) | def __call__(self, results):
    method __repr__ (line 66) | def __repr__(self):
  class LoadDenseRPDV2Annotations (line 73) | class LoadDenseRPDV2Annotations(object):
    method __init__ (line 91) | def __init__(self):
    method mask_to_poly (line 94) | def mask_to_poly(self, mask):
    method _load_semantic_map_from_mask (line 103) | def _load_semantic_map_from_mask(self, results):
    method _load_contours (line 120) | def _load_contours(self, results):
    method __call__ (line 143) | def __call__(self, results):
    method __repr__ (line 159) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/test_time_aug.py
  class MultiScaleFlipAug (line 10) | class MultiScaleFlipAug(object):
    method __init__ (line 52) | def __init__(self,
    method __call__ (line 83) | def __call__(self, results):
    method __repr__ (line 112) | def __repr__(self):

FILE: code/mmdet/datasets/pipelines/transforms.py
  class Resize (line 25) | class Resize(object):
    method __init__ (line 54) | def __init__(self,
    method random_select (line 80) | def random_select(img_scales):
    method random_sample (line 98) | def random_sample(img_scales):
    method random_sample_ratio (line 125) | def random_sample_ratio(img_scale, ratio_range):
    method _random_scale (line 151) | def _random_scale(self, results):
    method _resize_img (line 184) | def _resize_img(self, results):
    method _resize_bboxes (line 209) | def _resize_bboxes(self, results):
    method _resize_extremes (line 218) | def _resize_extremes(self, results):
    method _resize_keypoints (line 228) | def _resize_keypoints(self, results):
    method _resize_masks (line 241) | def _resize_masks(self, results):
    method _resize_seg (line 251) | def _resize_seg(self, results):
    method __call__ (line 262) | def __call__(self, results):
    method __repr__ (line 295) | def __repr__(self):
  class RandomFlip (line 305) | class RandomFlip(object):
    method __init__ (line 318) | def __init__(self, flip_ratio=None, direction='horizontal', keep_poly_...
    method bbox_flip (line 328) | def bbox_flip(self, bboxes, img_shape, direction):
    method extreme_flip (line 354) | def extreme_flip(self, extremes, img_shape, direction):
    method keypoint_flip (line 390) | def keypoint_flip(self, keypoints, img_shape, direction):
    method __call__ (line 409) | def __call__(self, results):
    method __repr__ (line 458) | def __repr__(self):
  class Pad (line 463) | class Pad(object):
    method __init__ (line 476) | def __init__(self, size=None, size_divisor=None, pad_val=0):
    method _pad_img (line 484) | def _pad_img(self, results):
    method _pad_masks (line 497) | def _pad_masks(self, results):
    method _pad_seg (line 503) | def _pad_seg(self, results):
    method __call__ (line 509) | def __call__(self, results):
    method __repr__ (line 524) | def __repr__(self):
  class Normalize (line 533) | class Normalize(object):
    method __init__ (line 545) | def __init__(self, mean, std, to_rgb=True):
    method __call__ (line 550) | def __call__(self, results):
    method __repr__ (line 568) | def __repr__(self):
  class RandomCrop (line 575) | class RandomCrop(object):
    method __init__ (line 591) | def __init__(self, crop_size):
    method __call__ (line 604) | def __call__(self, results):
    method __repr__ (line 670) | def __repr__(self):
  class SegRescale (line 675) | class SegRescale(object):
    method __init__ (line 682) | def __init__(self, scale_factor=1):
    method __call__ (line 685) | def __call__(self, results):
    method __repr__ (line 701) | def __repr__(self):
  class PhotoMetricDistortion (line 706) | class PhotoMetricDistortion(object):
    method __init__ (line 727) | def __init__(self,
    method __call__ (line 737) | def __call__(self, results):
    method __repr__ (line 800) | def __repr__(self):
  class Expand (line 812) | class Expand(object):
    method __init__ (line 825) | def __init__(self,
    method __call__ (line 841) | def __call__(self, results):
    method __repr__ (line 889) | def __repr__(self):
  class MinIoURandomCrop (line 898) | class MinIoURandomCrop(object):
    method __init__ (line 915) | def __init__(self, min_ious=(0.1, 0.3, 0.5, 0.7, 0.9), min_crop_size=0...
    method __call__ (line 929) | def __call__(self, results):
    method __repr__ (line 1022) | def __repr__(self):
  class Corrupt (line 1030) | class Corrupt(object):
    method __init__ (line 1041) | def __init__(self, corruption, severity=1):
    method __call__ (line 1045) | def __call__(self, results):
    method __repr__ (line 1066) | def __repr__(self):
  class Albu (line 1074) | class Albu(object):
    method __init__ (line 1116) | def __init__(self,
    method albu_builder (line 1153) | def albu_builder(self, cfg):
    method mapper (line 1186) | def mapper(d, keymap):
    method __call__ (line 1204) | def __call__(self, results):
    method __repr__ (line 1263) | def __repr__(self):
  class RandomCenterCropPad (line 1269) | class RandomCenterCropPad(object):
    method __init__ (line 1349) | def __init__(self,
    method _get_border (line 1391) | def _get_border(self, border, size):
    method _filter_boxes (line 1408) | def _filter_boxes(self, patch, boxes):
    method _crop_image_and_paste (line 1423) | def _crop_image_and_paste(self, image, center, size):
    method _train_aug (line 1472) | def _train_aug(self, results):
    method _test_aug (line 1538) | def _test_aug(self, results):
    method __call__ (line 1570) | def __call__(self, results):
    method __repr__ (line 1582) | def __repr__(self):

FILE: code/mmdet/datasets/samplers/distributed_sampler.py
  class DistributedSampler (line 5) | class DistributedSampler(_DistributedSampler):
    method __init__ (line 7) | def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True):
    method __iter__ (line 11) | def __iter__(self):

FILE: code/mmdet/datasets/samplers/group_sampler.py
  class GroupSampler (line 10) | class GroupSampler(Sampler):
    method __init__ (line 12) | def __init__(self, dataset, samples_per_gpu=1):
    method __iter__ (line 23) | def __iter__(self):
    method __len__ (line 47) | def __len__(self):
  class DistributedGroupSampler (line 51) | class DistributedGroupSampler(Sampler):
    method __init__ (line 69) | def __init__(self,
    method __iter__ (line 96) | def __iter__(self):
    method __len__ (line 136) | def __len__(self):
    method set_epoch (line 139) | def set_epoch(self, epoch):

FILE: code/mmdet/datasets/voc.py
  class VOCDataset (line 7) | class VOCDataset(XMLDataset):
    method __init__ (line 14) | def __init__(self, **kwargs):
    method evaluate (line 23) | def evaluate(self,

FILE: code/mmdet/datasets/wider_face.py
  class WIDERFaceDataset (line 11) | class WIDERFaceDataset(XMLDataset):
    method __init__ (line 19) | def __init__(self, **kwargs):
    method load_annotations (line 22) | def load_annotations(self, ann_file):

FILE: code/mmdet/datasets/xml_style.py
  class XMLDataset (line 13) | class XMLDataset(CustomDataset):
    method __init__ (line 22) | def __init__(self, min_size=None, **kwargs):
    method load_annotations (line 27) | def load_annotations(self, ann_file):
    method get_subset_by_classes (line 61) | def get_subset_by_classes(self):
    method get_ann_info (line 78) | def get_ann_info(self, idx):
    method get_cat_ids (line 143) | def get_cat_ids(self, idx):

FILE: code/mmdet/models/backbones/detectors_resnet.py
  class Bottleneck (line 10) | class Bottleneck(_Bottleneck):
    method __init__ (line 28) | def __init__(self,
    method init_weights (line 61) | def init_weights(self):
    method rfp_forward (line 66) | def rfp_forward(self, x, rfp_feat):
  class ResLayer (line 113) | class ResLayer(nn.Sequential):
    method __init__ (line 139) | def __init__(self,
  class DetectoRS_ResNet (line 205) | class DetectoRS_ResNet(ResNet):
    method __init__ (line 228) | def __init__(self,
    method make_res_layer (line 277) | def make_res_layer(self, **kwargs):
    method forward (line 281) | def forward(self, x):
    method rfp_forward (line 288) | def rfp_forward(self, x, rfp_feats):

FILE: code/mmdet/models/backbones/detectors_resnext.py
  class Bottleneck (line 10) | class Bottleneck(_Bottleneck):
    method __init__ (line 13) | def __init__(self,
  class DetectoRS_ResNeXt (line 97) | class DetectoRS_ResNeXt(DetectoRS_ResNet):
    method __init__ (line 111) | def __init__(self, groups=1, base_width=4, **kwargs):
    method make_res_layer (line 116) | def make_res_layer(self, **kwargs):

FILE: code/mmdet/models/backbones/hourglass.py
  class HourglassModule (line 9) | class HourglassModule(nn.Module):
    method __init__ (line 23) | def __init__(self,
    method forward (line 70) | def forward(self, x):
  class HourglassNet (line 81) | class HourglassNet(nn.Module):
    method __init__ (line 112) | def __init__(self,
    method init_weights (line 164) | def init_weights(self, pretrained=None):
    method forward (line 174) | def forward(self, x):

FILE: code/mmdet/models/backbones/hrnet.py
  class HRModule (line 12) | class HRModule(nn.Module):
    method __init__ (line 17) | def __init__(self,
    method _check_branches (line 43) | def _check_branches(self, num_branches, num_blocks, in_channels,
    method _make_one_branch (line 60) | def _make_one_branch(self,
    method _make_branches (line 104) | def _make_branches(self, num_branches, block, num_blocks, num_channels):
    method _make_fuse_layers (line 113) | def _make_fuse_layers(self):
    method forward (line 175) | def forward(self, x):
  class HRNet (line 196) | class HRNet(nn.Module):
    method __init__ (line 257) | def __init__(self,
    method norm1 (line 346) | def norm1(self):
    method norm2 (line 351) | def norm2(self):
    method _make_transition_layer (line 355) | def _make_transition_layer(self, num_channels_pre_layer,
    method _make_layer (line 401) | def _make_layer(self, block, inplanes, planes, blocks, stride=1):
    method _make_stage (line 436) | def _make_stage(self, layer_config, in_channels, multiscale_output=True):
    method init_weights (line 465) | def init_weights(self, pretrained=None):
    method forward (line 491) | def forward(self, x):
    method train (line 527) | def train(self, mode=True):

FILE: code/mmdet/models/backbones/mobilenet.py
  class _NewEmptyTensorOp (line 22) | class _NewEmptyTensorOp(torch.autograd.Function):
    method forward (line 24) | def forward(ctx, x, new_shape):
    method backward (line 29) | def backward(ctx, grad):
  class Conv2d (line 34) | class Conv2d(torch.nn.Conv2d):
    method forward (line 35) | def forward(self, x):
  function conv_bn (line 50) | def conv_bn(inp, oup, stride, norm_cfg=dict(type='BN', requires_grad=Tru...
  function conv_1x1_bn (line 58) | def conv_1x1_bn(inp, oup, norm_cfg=dict(type='BN', requires_grad=True)):
  class InvertedResidual (line 66) | class InvertedResidual(nn.Module):
    method __init__ (line 67) | def __init__(self, inp, oup, stride, expand_ratio, norm_cfg=dict(type=...
    method forward (line 100) | def forward(self, x):
  class MobileNetV2 (line 108) | class MobileNetV2(nn.Module):
    method __init__ (line 112) | def __init__(self,
    method _freeze_backbone (line 150) | def _freeze_backbone(self, freeze_at):
    method forward (line 155) | def forward(self, x):
    method init_weights (line 163) | def init_weights(self, pretrained=None):
  function load_url_dist (line 182) | def load_url_dist(url, model_dir=None, map_location=None):
  function _load_checkpoint (line 196) | def _load_checkpoint(filename, map_location=None):
  function load_checkpoint (line 246) | def load_checkpoint(model,

FILE: code/mmdet/models/backbones/regnet.py
  class RegNet (line 11) | class RegNet(ResNet):
    method __init__ (line 83) | def __init__(self,
    method _make_stem_layer (line 204) | def _make_stem_layer(self, in_channels, base_channels):
    method generate_regnet (line 218) | def generate_regnet(self,
    method quantize_float (line 251) | def quantize_float(number, divisor):
    method adjust_width_group (line 263) | def adjust_width_group(self, widths, bottleneck_ratio, groups):
    method get_stages_from_blocks (line 288) | def get_stages_from_blocks(self, widths):
    method forward (line 310) | def forward(self, x):

FILE: code/mmdet/models/backbones/res2net.py
  class Bottle2neck (line 17) | class Bottle2neck(_Bottleneck):
    method __init__ (line 20) | def __init__(self,
    method forward (line 108) | def forward(self, x):
  class Res2Layer (line 165) | class Res2Layer(nn.Sequential):
    method __init__ (line 184) | def __init__(self,
  class Res2Net (line 245) | class Res2Net(ResNet):
    method __init__ (line 302) | def __init__(self,
    method make_res_layer (line 314) | def make_res_layer(self, **kwargs):
    method init_weights (line 321) | def init_weights(self, pretrained=None):

FILE: code/mmdet/models/backbones/resnet.py
  class BasicBlock (line 14) | class BasicBlock(nn.Module):
    method __init__ (line 17) | def __init__(self,
    method norm1 (line 57) | def norm1(self):
    method norm2 (line 62) | def norm2(self):
    method forward (line 66) | def forward(self, x):
  class Bottleneck (line 96) | class Bottleneck(nn.Module):
    method __init__ (line 99) | def __init__(self,
    method make_block_plugins (line 216) | def make_block_plugins(self, in_channels, plugins):
    method forward_plugin (line 240) | def forward_plugin(self, x, plugin_names):
    method norm1 (line 247) | def norm1(self):
    method norm2 (line 252) | def norm2(self):
    method norm3 (line 257) | def norm3(self):
    method forward (line 261) | def forward(self, x):
  class ResNet (line 305) | class ResNet(nn.Module):
    method __init__ (line 364) | def __init__(self,
    method make_stage_plugins (line 452) | def make_stage_plugins(self, plugins, stage_idx):
    method make_res_layer (line 512) | def make_res_layer(self, **kwargs):
    method norm1 (line 517) | def norm1(self):
    method _make_stem_layer (line 521) | def _make_stem_layer(self, in_channels, stem_channels):
    method _freeze_stages (line 569) | def _freeze_stages(self):
    method init_weights (line 587) | def init_weights(self, pretrained=None):
    method forward (line 619) | def forward(self, x):
    method train (line 636) | def train(self, mode=True):
  class ResNetV1d (line 649) | class ResNetV1d(ResNet):
    method __init__ (line 659) | def __init__(self, **kwargs):

FILE: code/mmdet/models/backbones/resnext.py
  class Bottleneck (line 11) | class Bottleneck(_Bottleneck):
    method __init__ (line 14) | def __init__(self,
  class ResNeXt (line 87) | class ResNeXt(ResNet):
    method __init__ (line 120) | def __init__(self, groups=1, base_width=4, **kwargs):
    method make_res_layer (line 125) | def make_res_layer(self, **kwargs):

FILE: code/mmdet/models/backbones/ssd_vgg.py
  class SSDVGG (line 12) | class SSDVGG(VGG):
    method __init__ (line 38) | def __init__(self,
    method init_weights (line 75) | def init_weights(self, pretrained=None):
    method forward (line 102) | def forward(self, x):
    method _make_extra_layers (line 119) | def _make_extra_layers(self, outplanes):
  class L2Norm (line 146) | class L2Norm(nn.Module):
    method __init__ (line 148) | def __init__(self, n_dims, scale=20., eps=1e-10):
    method forward (line 163) | def forward(self, x):

FILE: code/mmdet/models/builder.py
  function build (line 13) | def build(cfg, registry, default_args=None):
  function build_backbone (line 35) | def build_backbone(cfg):
  function build_neck (line 40) | def build_neck(cfg):
  function build_roi_extractor (line 45) | def build_roi_extractor(cfg):
  function build_shared_head (line 50) | def build_shared_head(cfg):
  function build_head (line 55) | def build_head(cfg):
  function build_loss (line 60) | def build_loss(cfg):
  function build_detector (line 65) | def build_detector(cfg, train_cfg=None, test_cfg=None):

FILE: code/mmdet/models/dense_heads/anchor_free_head.py
  class AnchorFreeHead (line 14) | class AnchorFreeHead(BaseDenseHead):
    method __init__ (line 42) | def __init__(self,
    method _init_layers (line 87) | def _init_layers(self):
    method _init_cls_convs (line 93) | def _init_cls_convs(self):
    method _init_reg_convs (line 113) | def _init_reg_convs(self):
    method _init_predictor (line 133) | def _init_predictor(self):
    method init_weights (line 139) | def init_weights(self):
    method _load_from_state_dict (line 151) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
    method forward (line 189) | def forward(self, feats):
    method forward_single (line 207) | def forward_single(self, x):
    method loss (line 232) | def loss(self,
    method get_bboxes (line 261) | def get_bboxes(self,
    method get_targets (line 284) | def get_targets(self, points, gt_bboxes_list, gt_labels_list):
    method _get_points_single (line 298) | def _get_points_single(self,
    method get_points (line 314) | def get_points(self, featmap_sizes, dtype, device, flatten=False):

FILE: code/mmdet/models/dense_heads/anchor_head.py
  class AnchorHead (line 14) | class AnchorHead(BaseDenseHead):
    method __init__ (line 35) | def __init__(self,
    method _init_layers (line 103) | def _init_layers(self):
    method init_weights (line 109) | def init_weights(self):
    method forward_single (line 114) | def forward_single(self, x):
    method forward (line 131) | def forward(self, feats):
    method get_anchors (line 149) | def get_anchors(self, featmap_sizes, img_metas, device='cuda'):
    method _get_targets_single (line 179) | def _get_targets_single(self,
    method get_targets (line 279) | def get_targets(self,
    method loss_single (line 378) | def loss_single(self, cls_score, bbox_pred, anchors, labels, label_wei...
    method loss (line 426) | def loss(self,
    method get_bboxes (line 496) | def get_bboxes(self,
    method _get_bboxes_single (line 574) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/atss_head.py
  function reduce_mean (line 13) | def reduce_mean(tensor):
  class ATSSHead (line 22) | class ATSSHead(AnchorHead):
    method __init__ (line 33) | def __init__(self,
    method _init_layers (line 57) | def _init_layers(self):
    method init_weights (line 94) | def init_weights(self):
    method forward (line 105) | def forward(self, feats):
    method forward_single (line 123) | def forward_single(self, x, scale):
    method loss_single (line 152) | def loss_single(self, anchors, cls_score, bbox_pred, centerness, labels,
    method loss (line 228) | def loss(self,
    method centerness_target (line 302) | def centerness_target(self, anchors, bbox_targets):
    method get_bboxes (line 321) | def get_bboxes(self,
    method _get_bboxes_single (line 380) | def _get_bboxes_single(self,
    method get_targets (line 467) | def get_targets(self,
    method _get_target_single (line 531) | def _get_target_single(self,
    method get_num_level_anchors_inside (line 635) | def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):

FILE: code/mmdet/models/dense_heads/base_dense_head.py
  class BaseDenseHead (line 6) | class BaseDenseHead(nn.Module, metaclass=ABCMeta):
    method __init__ (line 9) | def __init__(self):
    method loss (line 13) | def loss(self, **kwargs):
    method get_bboxes (line 18) | def get_bboxes(self, **kwargs):
    method forward_train (line 22) | def forward_train(self,

FILE: code/mmdet/models/dense_heads/dense_reppoints_head.py
  class DenseRepPointsHead (line 18) | class DenseRepPointsHead(AnchorFreeHead):
    method __init__ (line 36) | def __init__(self,
    method _init_layers (line 108) | def _init_layers(self):
    method init_weights (line 163) | def init_weights(self):
    method points2bbox (line 183) | def points2bbox(self, pts):
    method sample_offset (line 206) | def sample_offset(self, x, flow, padding_mode):
    method compute_offset_feature (line 230) | def compute_offset_feature(self, x, offset, padding_mode):
    method sample_offset_3d (line 252) | def sample_offset_3d(self, x, flow, padding_mode):
    method compute_offset_feature_5d (line 281) | def compute_offset_feature_5d(self, x, offset, padding_mode):
    method forward (line 296) | def forward(self, feats, test=False):
    method forward_pts_head_single (line 307) | def forward_pts_head_single(self, x):
    method forward_mask_head (line 346) | def forward_mask_head(self, mask_feat_list, pts_out_list):
    method forward_mask_head_single (line 371) | def forward_mask_head_single(self, pts, mask_feat):
    method normalize_pts_within_bboxes (line 395) | def normalize_pts_within_bboxes(pts):
    method grid_position_sensitive_group_partition (line 420) | def grid_position_sensitive_group_partition(self, pts, num_group):
    method get_points (line 442) | def get_points(self, featmap_sizes, img_metas):
    method offset_to_pts (line 481) | def offset_to_pts(self, center_list, pred_list):
    method offset_to_pts_img_lvl (line 497) | def offset_to_pts_img_lvl(self, center_list, pred_list):
    method _dense_point_target_single (line 519) | def _dense_point_target_single(self,
    method get_targets (line 618) | def get_targets(self,
    method loss_single (line 715) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine, pts_s...
    method loss (line 786) | def loss(self,
    method get_bboxes (line 883) | def get_bboxes(self,
    method _get_bboxes_single (line 923) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 995) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
  function mask_to_levels (line 1003) | def mask_to_levels(target, mask_index_list):
  function mask_to_poly (line 1019) | def mask_to_poly(mask):
  function distance_sample_pts (line 1029) | def distance_sample_pts(gt_bboxes, gt_masks, cfg, num_pts):

FILE: code/mmdet/models/dense_heads/dense_reppoints_v2_head.py
  class DenseRepPointsV2Head (line 18) | class DenseRepPointsV2Head(AnchorFreeHead):
    method __init__ (line 36) | def __init__(self,
    method _init_layers (line 117) | def _init_layers(self):
    method init_weights (line 198) | def init_weights(self):
    method points2bbox (line 223) | def points2bbox(self, pts):
    method sample_offset (line 246) | def sample_offset(self, x, flow, padding_mode):
    method compute_offset_feature (line 270) | def compute_offset_feature(self, x, offset, padding_mode):
    method sample_offset_3d (line 292) | def sample_offset_3d(self, x, flow, padding_mode):
    method compute_offset_feature_5d (line 321) | def compute_offset_feature_5d(self, x, offset, padding_mode):
    method forward (line 336) | def forward(self, feats, test=False):
    method forward_pts_head_single (line 350) | def forward_pts_head_single(self, x):
    method forward_mask_head (line 411) | def forward_mask_head(self, mask_feat_list, pts_out_list, sem_feat_list):
    method forward_mask_head_single (line 436) | def forward_mask_head_single(self, pts, mask_feat):
    method normalize_pts_within_bboxes (line 460) | def normalize_pts_within_bboxes(pts):
    method grid_position_sensitive_group_partition (line 485) | def grid_position_sensitive_group_partition(self, pts, num_group):
    method get_points (line 507) | def get_points(self, featmap_sizes, img_metas):
    method offset_to_pts (line 546) | def offset_to_pts(self, center_list, pred_list):
    method offset_to_pts_img_lvl (line 562) | def offset_to_pts_img_lvl(self, center_list, pred_list):
    method _dense_point_target_single (line 584) | def _dense_point_target_single(self,
    method get_targets (line 683) | def get_targets(self,
    method _cont_target_single (line 780) | def _cont_target_single(self,
    method get_cont_target (line 803) | def get_cont_target(self,
    method loss_single (line 845) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine, pts_s...
    method loss (line 930) | def loss(self,
    method get_bboxes (line 1073) | def get_bboxes(self,
    method _get_bboxes_single (line 1122) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1260) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
  function mask_to_levels (line 1268) | def mask_to_levels(target, mask_index_list):
  function mask_to_poly (line 1284) | def mask_to_poly(mask):
  function distance_sample_pts (line 1294) | def distance_sample_pts(gt_bboxes, gt_masks, cfg, num_pts):

FILE: code/mmdet/models/dense_heads/fcos_head.py
  class FCOSHead (line 14) | class FCOSHead(AnchorFreeHead):
    method __init__ (line 55) | def __init__(self,
    method _init_layers (line 91) | def _init_layers(self):
    method init_weights (line 97) | def init_weights(self):
    method forward (line 102) | def forward(self, feats):
    method forward_single (line 123) | def forward_single(self, x, scale, stride):
    method loss (line 155) | def loss(self,
    method get_bboxes (line 252) | def get_bboxes(self,
    method _get_bboxes_single (line 309) | def _get_bboxes_single(self,
    method _get_points_single (line 385) | def _get_points_single(self,
    method get_targets (line 397) | def get_targets(self, points, gt_bboxes_list, gt_labels_list):
    method _get_target_single (line 458) | def _get_target_single(self, gt_bboxes, gt_labels, points, regress_ran...
    method centerness_target (line 542) | def centerness_target(self, pos_bbox_targets):

FILE: code/mmdet/models/dense_heads/fovea_head.py
  class FeatureAlign (line 13) | class FeatureAlign(nn.Module):
    method __init__ (line 15) | def __init__(self,
    method init_weights (line 32) | def init_weights(self):
    method forward (line 36) | def forward(self, x, shape):
  class FoveaHead (line 43) | class FoveaHead(AnchorFreeHead):
    method __init__ (line 48) | def __init__(self,
    method _init_layers (line 65) | def _init_layers(self):
    method init_weights (line 105) | def init_weights(self):
    method forward_single (line 110) | def forward_single(self, x):
    method _get_points_single (line 123) | def _get_points_single(self, *args, **kwargs):
    method loss (line 127) | def loss(self,
    method get_targets (line 178) | def get_targets(self, gt_bbox_list, gt_label_list, featmap_sizes, poin...
    method _get_target_single (line 200) | def _get_target_single(self,
    method get_bboxes (line 261) | def get_bboxes(self,
    method _get_bboxes_single (line 292) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/free_anchor_retina_head.py
  class FreeAnchorRetinaHead (line 10) | class FreeAnchorRetinaHead(RetinaHead):
    method __init__ (line 31) | def __init__(self,
    method loss (line 51) | def loss(self,
    method positive_bag_loss (line 217) | def positive_bag_loss(self, matched_cls_prob, matched_box_prob):
    method negative_bag_loss (line 244) | def negative_bag_loss(self, cls_prob, box_prob):

FILE: code/mmdet/models/dense_heads/fsaf_head.py
  class FSAFHead (line 13) | class FSAFHead(RetinaHead):
    method forward_single (line 32) | def forward_single(self, x):
    method init_weights (line 49) | def init_weights(self):
    method _get_targets_single (line 56) | def _get_targets_single(self,
    method loss (line 161) | def loss(self,
    method calculate_accuracy (line 289) | def calculate_accuracy(self, cls_scores, labels_list, pos_inds):
    method collect_loss_level_single (line 320) | def collect_loss_level_single(self, cls_loss, reg_loss, assigned_gt_inds,
    method reweight_loss_single (line 351) | def reweight_loss_single(self, cls_loss, reg_loss, assigned_gt_inds,

FILE: code/mmdet/models/dense_heads/ga_retina_head.py
  class GARetinaHead (line 10) | class GARetinaHead(GuidedAnchorHead):
    method __init__ (line 13) | def __init__(self,
    method _init_layers (line 25) | def _init_layers(self):
    method init_weights (line 72) | def init_weights(self):
    method forward_single (line 88) | def forward_single(self, x):

FILE: code/mmdet/models/dense_heads/ga_rpn_head.py
  class GARPNHead (line 13) | class GARPNHead(RPNTestMixin, GuidedAnchorHead):
    method __init__ (line 16) | def __init__(self, in_channels, **kwargs):
    method _init_layers (line 20) | def _init_layers(self):
    method init_weights (line 26) | def init_weights(self):
    method forward_single (line 31) | def forward_single(self, x):
    method loss (line 40) | def loss(self,
    method _get_bboxes_single (line 63) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/gfl_head.py
  function reduce_mean (line 15) | def reduce_mean(tensor):
  class Integral (line 23) | class Integral(nn.Module):
    method __init__ (line 36) | def __init__(self, reg_max=16):
    method forward (line 42) | def forward(self, x):
  class GFLHead (line 60) | class GFLHead(AnchorHead):
    method __init__ (line 93) | def __init__(self,
    method _init_layers (line 118) | def _init_layers(self):
    method init_weights (line 151) | def init_weights(self):
    method forward (line 161) | def forward(self, feats):
    method forward_single (line 179) | def forward_single(self, x, scale):
    method anchor_center (line 205) | def anchor_center(self, anchors):
    method loss_single (line 218) | def loss_single(self, anchors, cls_score, bbox_pred, labels, label_wei...
    method loss (line 307) | def loss(self,
    method _get_bboxes_single (line 379) | def _get_bboxes_single(self,
    method get_targets (line 459) | def get_targets(self,
    method _get_target_single (line 523) | def _get_target_single(self,
    method get_num_level_anchors_inside (line 627) | def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):

FILE: code/mmdet/models/dense_heads/guided_anchor_head.py
  class FeatureAdaption (line 14) | class FeatureAdaption(nn.Module):
    method __init__ (line 28) | def __init__(self,
    method init_weights (line 45) | def init_weights(self):
    method forward (line 49) | def forward(self, x, shape):
  class GuidedAnchorHead (line 56) | class GuidedAnchorHead(AnchorHead):
    method __init__ (line 89) | def __init__(
    method _init_layers (line 204) | def _init_layers(self):
    method init_weights (line 219) | def init_weights(self):
    method forward_single (line 229) | def forward_single(self, x):
    method forward (line 242) | def forward(self, feats):
    method get_sampled_approxs (line 245) | def get_sampled_approxs(self, featmap_sizes, img_metas, device='cuda'):
    method get_anchors (line 295) | def get_anchors(self,
    method _get_guided_anchors_single (line 347) | def _get_guided_anchors_single(self,
    method ga_loc_targets (line 381) | def ga_loc_targets(self, gt_bboxes_list, featmap_sizes):
    method _ga_shape_target_single (line 483) | def _ga_shape_target_single(self,
    method ga_shape_targets (line 546) | def ga_shape_targets(self,
    method loss_shape_single (line 612) | def loss_shape_single(self, shape_pred, bbox_anchors, bbox_gts,
    method loss_loc_single (line 636) | def loss_loc_single(self, loc_pred, loc_target, loc_weight,
    method loss (line 647) | def loss(self,
    method get_bboxes (line 753) | def get_bboxes(self,
    method _get_bboxes_single (line 797) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/lscpvnet_head.py
  class LSCPVHead (line 15) | class LSCPVHead(AnchorFreeHead):
    method __init__ (line 16) | def __init__(self,
    method _init_layers (line 98) | def _init_layers(self):
    method init_weights (line 181) | def init_weights(self):
    method extreme_points2bbox (line 208) | def extreme_points2bbox(self, pts, y_first=True, extreme=False):
    method get_pred_reg (line 236) | def get_pred_reg(self, raw_reg1, raw_reg2):
    method get_bbox_gt_reg (line 245) | def get_bbox_gt_reg(self, gt_pts, anchor_pts, bbox_weights):
    method forward (line 272) | def forward(self, feats):
    method forward_single1 (line 287) | def forward_single1(self, x):
    method forward_single2 (line 343) | def forward_single2(self, bbox_dcn_offset, bbox_reg_init_sp, fpn_level,
    method get_points (line 389) | def get_points(self, featmap_sizes, img_metas):
    method centers_to_bboxes (line 428) | def centers_to_bboxes(self, point_list):
    method offset_to_pts (line 442) | def offset_to_pts(self, center_list, pred_list):
    method _point_target_single (line 463) | def _point_target_single(self,
    method get_targets (line 538) | def get_targets(self,
    method _hm_target_single (line 605) | def _hm_target_single(self,
    method get_hm_targets (line 651) | def get_hm_targets(self,
    method loss_single (line 717) | def loss_single(self, cls_score, bbox_pts_pred_init, bbox_pts_pred_ref...
    method loss (line 816) | def loss(self,
    method get_bboxes (line 957) | def get_bboxes(self,
    method _get_bboxes_single (line 1001) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1097) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
  class DCNConvModule (line 1105) | class DCNConvModule(nn.Module):
    method __init__ (line 1106) | def __init__(
    method forward (line 1122) | def forward(self, x):

FILE: code/mmdet/models/dense_heads/lsnet_head.py
  class LSHead (line 17) | class LSHead(AnchorFreeHead):
    method __init__ (line 18) | def __init__(self,
    method _init_layers (line 93) | def _init_layers(self):
    method init_weights (line 259) | def init_weights(self):
    method extreme_points2bbox (line 321) | def extreme_points2bbox(self, pts, y_first=True, extreme=False):
    method vectors2bbox (line 349) | def vectors2bbox(self, pts, y_first=True, vector=False):
    method get_pred_reg (line 372) | def get_pred_reg(self, raw_reg1, raw_reg2):
    method get_bbox_gt_reg (line 402) | def get_bbox_gt_reg(self, gt_pts, anchor_pts, bbox_weights):
    method get_poly_gt_reg (line 429) | def get_poly_gt_reg(self, gt_pts, anchor_pts, bbox_weights):
    method forward_train (line 456) | def forward_train(self,
    method forward (line 479) | def forward(self, feats):
    method forward_single1 (line 502) | def forward_single1(self, x):
    method forward_single2 (line 600) | def forward_single2(self, bbox_dcn_offset, bbox_reg_init_sp, segm_dcn_...
    method get_points (line 757) | def get_points(self, featmap_sizes, img_metas):
    method _target_single (line 796) | def _target_single(self,
    method get_targets (line 919) | def get_targets(self,
    method loss_single (line 1021) | def loss_single(self,
    method loss (line 1272) | def loss(self,
    method get_bboxes (line 1439) | def get_bboxes(self,
    method _get_bboxes_single (line 1513) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1670) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...
    method get_border_center (line 1677) | def get_border_center(self, gt_bboxes_list):
    method component_polygon_area (line 1699) | def component_polygon_area(self, poly):
    method process_polygons (line 1717) | def process_polygons(self, gt_masks_list, cls_scores):
    method process_keypoints_with_bbox (line 1758) | def process_keypoints_with_bbox(self, gt_bboxes_list, gt_keypoints_vs_...
    method process_keypoints_with_kbox (line 1786) | def process_keypoints_with_kbox(self, gt_keypoints_vs_list):
  class DCNConvModule (line 1830) | class DCNConvModule(nn.Module):
    method __init__ (line 1831) | def __init__(
    method forward (line 1847) | def forward(self, x):

FILE: code/mmdet/models/dense_heads/nasfcos_head.py
  class NASFCOSHead (line 12) | class NASFCOSHead(FCOSHead):
    method _init_layers (line 21) | def _init_layers(self):
    method init_weights (line 64) | def init_weights(self):

FILE: code/mmdet/models/dense_heads/pisa_retinanet_head.py
  class PISARetinaHead (line 10) | class PISARetinaHead(RetinaHead):
    method loss (line 21) | def loss(self,

FILE: code/mmdet/models/dense_heads/pisa_ssd_head.py
  class PISASSDHead (line 11) | class PISASSDHead(SSDHead):
    method loss (line 13) | def loss(self,

FILE: code/mmdet/models/dense_heads/reppoints_head.py
  class RepPointsHead (line 14) | class RepPointsHead(AnchorFreeHead):
    method __init__ (line 32) | def __init__(self,
    method _init_layers (line 97) | def _init_layers(self):
    method init_weights (line 140) | def init_weights(self):
    method points2bbox (line 154) | def points2bbox(self, pts, y_first=True):
    method gen_grid_from_reg (line 213) | def gen_grid_from_reg(self, reg, previous_boxes):
    method forward (line 247) | def forward(self, feats):
    method forward_single (line 250) | def forward_single(self, x):
    method get_points (line 292) | def get_points(self, featmap_sizes, img_metas):
    method centers_to_bboxes (line 331) | def centers_to_bboxes(self, point_list):
    method offset_to_pts (line 345) | def offset_to_pts(self, center_list, pred_list):
    method _point_target_single (line 366) | def _point_target_single(self,
    method get_targets (line 430) | def get_targets(self,
    method loss_single (line 514) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine,
    method loss (line 551) | def loss(self,
    method get_bboxes (line 634) | def get_bboxes(self,
    method _get_bboxes_single (line 667) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 714) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...

FILE: code/mmdet/models/dense_heads/reppoints_v2_head.py
  class RepPointsV2Head (line 15) | class RepPointsV2Head(AnchorFreeHead):
    method __init__ (line 33) | def __init__(self,
    method _init_layers (line 118) | def _init_layers(self):
    method init_weights (line 193) | def init_weights(self):
    method points2bbox (line 214) | def points2bbox(self, pts, y_first=True):
    method gen_grid_from_reg (line 273) | def gen_grid_from_reg(self, reg, previous_boxes):
    method forward (line 307) | def forward(self, feats):
    method forward_single (line 310) | def forward_single(self, x):
    method get_points (line 378) | def get_points(self, featmap_sizes, img_metas):
    method centers_to_bboxes (line 417) | def centers_to_bboxes(self, point_list):
    method offset_to_pts (line 431) | def offset_to_pts(self, center_list, pred_list):
    method _point_target_single (line 452) | def _point_target_single(self,
    method get_targets (line 516) | def get_targets(self,
    method _hm_target_single (line 600) | def _hm_target_single(self,
    method get_hm_targets (line 646) | def get_hm_targets(self,
    method loss_single (line 711) | def loss_single(self, cls_score, pts_pred_init, pts_pred_refine, hm_sc...
    method loss (line 788) | def loss(self,
    method get_bboxes (line 925) | def get_bboxes(self,
    method _get_bboxes_single (line 967) | def _get_bboxes_single(self,
    method get_num_level_proposals_inside (line 1058) | def get_num_level_proposals_inside(self, num_level_proposals, inside_f...

FILE: code/mmdet/models/dense_heads/retina_head.py
  class RetinaHead (line 9) | class RetinaHead(AnchorHead):
    method __init__ (line 28) | def __init__(self,
    method _init_layers (line 50) | def _init_layers(self):
    method init_weights (line 83) | def init_weights(self):
    method forward_single (line 93) | def forward_single(self, x):

FILE: code/mmdet/models/dense_heads/retina_sepbn_head.py
  class RetinaSepBNHead (line 9) | class RetinaSepBNHead(AnchorHead):
    method __init__ (line 17) | def __init__(self,
    method _init_layers (line 32) | def _init_layers(self):
    method init_weights (line 74) | def init_weights(self):
    method forward (line 84) | def forward(self, feats):

FILE: code/mmdet/models/dense_heads/rpn_head.py
  class RPNHead (line 13) | class RPNHead(RPNTestMixin, AnchorHead):
    method __init__ (line 20) | def __init__(self, in_channels, **kwargs):
    method _init_layers (line 24) | def _init_layers(self):
    method init_weights (line 32) | def init_weights(self):
    method forward_single (line 38) | def forward_single(self, x):
    method loss (line 46) | def loss(self,
    method _get_bboxes_single (line 79) | def _get_bboxes_single(self,

FILE: code/mmdet/models/dense_heads/rpn_test_mixin.py
  class RPNTestMixin (line 9) | class RPNTestMixin(object):
    method async_simple_test_rpn (line 14) | async def async_simple_test_rpn(self, x, img_metas):
    method simple_test_rpn (line 25) | def simple_test_rpn(self, x, img_metas):
    method aug_test_rpn (line 40) | def aug_test_rpn(self, feats, img_metas):

FILE: code/mmdet/models/dense_heads/ssd_head.py
  class SSDHead (line 15) | class SSDHead(AnchorHead):
    method __init__ (line 33) | def __init__(self,
    method init_weights (line 98) | def init_weights(self):
    method forward (line 104) | def forward(self, feats):
    method loss_single (line 128) | def loss_single(self, cls_score, bbox_pred, anchor, labels, label_weig...
    method loss (line 182) | def loss(self,

FILE: code/mmdet/models/detectors/atss.py
  class ATSS (line 6) | class ATSS(SingleStageDetector):
    method __init__ (line 8) | def __init__(self,

FILE: code/mmdet/models/detectors/base.py
  class BaseDetector (line 16) | class BaseDetector(nn.Module, metaclass=ABCMeta):
    method __init__ (line 19) | def __init__(self):
    method with_neck (line 24) | def with_neck(self):
    method with_shared_head (line 31) | def with_shared_head(self):
    method with_bbox (line 37) | def with_bbox(self):
    method with_mask (line 44) | def with_mask(self):
    method extract_feat (line 51) | def extract_feat(self, imgs):
    method extract_feats (line 55) | def extract_feats(self, imgs):
    method forward_train (line 69) | def forward_train(self, imgs, img_metas, **kwargs):
    method async_simple_test (line 83) | async def async_simple_test(self, img, img_metas, **kwargs):
    method simple_test (line 87) | def simple_test(self, img, img_metas, **kwargs):
    method aug_test (line 91) | def aug_test(self, imgs, img_metas, **kwargs):
    method init_weights (line 95) | def init_weights(self, pretrained=None):
    method aforward_test (line 106) | async def aforward_test(self, *, img, img_metas, **kwargs):
    method forward_test (line 124) | def forward_test(self, imgs, img_metas, **kwargs):
    method forward (line 162) | def forward(self, img, img_metas, return_loss=True, **kwargs):
    method _parse_losses (line 176) | def _parse_losses(self, losses):
    method train_step (line 211) | def train_step(self, data, optimizer):
    method val_step (line 245) | def val_step(self, data, optimizer):
    method show_result (line 260) | def show_result(self,

FILE: code/mmdet/models/detectors/cascade_rcnn.py
  class CascadeRCNN (line 6) | class CascadeRCNN(TwoStageDetector):
    method __init__ (line 10) | def __init__(self,
    method show_result (line 27) | def show_result(self, data, result, **kwargs):

FILE: code/mmdet/models/detectors/dense_reppoints_detector.py
  class DenseRepPointsDetector (line 12) | class DenseRepPointsDetector(SingleStageDetector):
    method __init__ (line 14) | def __init__(self,
    method with_mask (line 24) | def with_mask(self):
    method forward_train (line 27) | def forward_train(self,
    method simple_test (line 41) | def simple_test(self, img, img_meta, rescale=False):
    method get_seg_masks (line 67) | def get_seg_masks(self, pts_score, det_pts, det_bboxes, det_labels,
  function pts2result (line 130) | def pts2result(pts, labels, num_classes):

FILE: code/mmdet/models/detectors/dense_reppoints_v2_detector.py
  class DenseRepPointsV2Detector (line 12) | class DenseRepPointsV2Detector(SingleStageDetector):
    method __init__ (line 14) | def __init__(self,
    method with_mask (line 24) | def with_mask(self):
    method forward_train (line 27) | def forward_train(self,
    method simple_test (line 43) | def simple_test(self, img, img_meta, rescale=False):
    method get_seg_masks (line 69) | def get_seg_masks(self, pts_score, det_pts, det_bboxes, det_labels, de...
  function pts2result (line 142) | def pts2result(pts, labels, num_classes):

FILE: code/mmdet/models/detectors/fast_rcnn.py
  class FastRCNN (line 6) | class FastRCNN(TwoStageDetector):
    method __init__ (line 9) | def __init__(self,
    method forward_test (line 24) | def forward_test(self, imgs, img_metas, proposals, **kwargs):

FILE: code/mmdet/models/detectors/faster_rcnn.py
  class FasterRCNN (line 6) | class FasterRCNN(TwoStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/fcos.py
  class FCOS (line 6) | class FCOS(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/fovea.py
  class FOVEA (line 6) | class FOVEA(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/fsaf.py
  class FSAF (line 6) | class FSAF(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/gfl.py
  class GFL (line 6) | class GFL(SingleStageDetector):
    method __init__ (line 8) | def __init__(self,

FILE: code/mmdet/models/detectors/grid_rcnn.py
  class GridRCNN (line 6) | class GridRCNN(TwoStageDetector):
    method __init__ (line 14) | def __init__(self,

FILE: code/mmdet/models/detectors/htc.py
  class HybridTaskCascade (line 6) | class HybridTaskCascade(CascadeRCNN):
    method __init__ (line 9) | def __init__(self, **kwargs):
    method with_semantic (line 13) | def with_semantic(self):

FILE: code/mmdet/models/detectors/lscpvnet.py
  class LSCPVDetector (line 11) | class LSCPVDetector(SingleStageDetector):
    method __init__ (line 13) | def __init__(self,
    method forward_train (line 23) | def forward_train(self,
    method simple_test (line 39) | def simple_test(self, img, img_metas, rescale=False, show=False, out_d...
    method merge_aug_results (line 61) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method aug_test_simple (line 88) | def aug_test_simple(self, imgs, img_metas, rescale=False):
    method merge_aug_vote_results (line 131) | def merge_aug_vote_results(self, aug_bboxes, aug_labels, img_metas):
    method remove_boxes (line 157) | def remove_boxes(self, boxes, min_scale, max_scale):
    method bboxes_vote (line 164) | def bboxes_vote(self, boxes, scores, vote_thresh=0.66):
    method aug_test_vote (line 230) | def aug_test_vote(self, imgs, img_metas, rescale=False):
    method aug_test (line 293) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/lsnet.py
  class LSDetector (line 13) | class LSDetector(SingleStageDetector):
    method __init__ (line 14) | def __init__(self,
    method merge_aug_results (line 27) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method forward_train (line 44) | def forward_train(self,
    method simple_test (line 58) | def simple_test(self, img, img_metas, rescale=False, show=False, out_d...
    method aug_test_simple (line 102) | def aug_test_simple(self, imgs, img_metas, rescale=False):
    method merge_aug_vote_results (line 137) | def merge_aug_vote_results(self, aug_bboxes, aug_vectors, aug_labels, ...
    method remove_boxes (line 156) | def remove_boxes(self, boxes, min_scale, max_scale):
    method bboxes_vote (line 163) | def bboxes_vote(self, boxes, scores, vote_thresh=0.66):
    method instances_vote (line 229) | def instances_vote(self, boxes, vectors, scores, vote_thresh=0.66):
    method aug_test_vote (line 301) | def aug_test_vote(self, imgs, img_metas, rescale=False, show=False, ou...
    method aug_test (line 403) | def aug_test(self, imgs, img_metas, rescale=False, show=False, out_dir...
    method show_result (line 411) | def show_result(self,

FILE: code/mmdet/models/detectors/mask_rcnn.py
  class MaskRCNN (line 6) | class MaskRCNN(TwoStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/mask_scoring_rcnn.py
  class MaskScoringRCNN (line 6) | class MaskScoringRCNN(TwoStageDetector):
    method __init__ (line 12) | def __init__(self,

FILE: code/mmdet/models/detectors/nasfcos.py
  class NASFCOS (line 6) | class NASFCOS(SingleStageDetector):
    method __init__ (line 12) | def __init__(self,

FILE: code/mmdet/models/detectors/point_rend.py
  class PointRend (line 6) | class PointRend(TwoStageDetector):
    method __init__ (line 14) | def __init__(self,

FILE: code/mmdet/models/detectors/reppoints_detector.py
  class RepPointsDetector (line 9) | class RepPointsDetector(SingleStageDetector):
    method __init__ (line 16) | def __init__(self,
    method merge_aug_results (line 27) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method aug_test (line 54) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/reppoints_v2_detector.py
  class RepPointsV2Detector (line 11) | class RepPointsV2Detector(SingleStageDetector):
    method __init__ (line 13) | def __init__(self,
    method forward_train (line 23) | def forward_train(self,
    method merge_aug_results (line 38) | def merge_aug_results(self, aug_bboxes, aug_scores, img_metas):
    method aug_test_simple (line 65) | def aug_test_simple(self, imgs, img_metas, rescale=False):
    method merge_aug_vote_results (line 108) | def merge_aug_vote_results(self, aug_bboxes, aug_labels, img_metas):
    method remove_boxes (line 134) | def remove_boxes(self, boxes, min_scale, max_scale):
    method bboxes_vote (line 140) | def bboxes_vote(self, boxes, scores, vote_thresh=0.66):
    method aug_test_vote (line 206) | def aug_test_vote(self, imgs, img_metas, rescale=False):
    method aug_test (line 267) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/retinanet.py
  class RetinaNet (line 6) | class RetinaNet(SingleStageDetector):
    method __init__ (line 9) | def __init__(self,

FILE: code/mmdet/models/detectors/rpn.py
  class RPN (line 9) | class RPN(BaseDetector):
    method __init__ (line 12) | def __init__(self,
    method init_weights (line 30) | def init_weights(self, pretrained=None):
    method extract_feat (line 43) | def extract_feat(self, img):
    method forward_dummy (line 58) | def forward_dummy(self, img):
    method forward_train (line 64) | def forward_train(self,
    method simple_test (line 94) | def simple_test(self, img, img_metas, rescale=False):
    method aug_test (line 115) | def aug_test(self, imgs, img_metas, rescale=False):
    method show_result (line 141) | def show_result(self, data, result, dataset=None, top_k=20):

FILE: code/mmdet/models/detectors/single_stage.py
  class SingleStageDetector (line 9) | class SingleStageDetector(BaseDetector):
    method __init__ (line 16) | def __init__(self,
    method init_weights (line 34) | def init_weights(self, pretrained=None):
    method extract_feat (line 51) | def extract_feat(self, img):
    method forward_dummy (line 59) | def forward_dummy(self, img):
    method forward_train (line 68) | def forward_train(self,
    method simple_test (line 97) | def simple_test(self, img, img_metas, rescale=False):
    method aug_test (line 119) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/detectors/two_stage.py
  class TwoStageDetector (line 10) | class TwoStageDetector(BaseDetector):
    method __init__ (line 17) | def __init__(self,
    method with_rpn (line 51) | def with_rpn(self):
    method with_roi_head (line 56) | def with_roi_head(self):
    method init_weights (line 60) | def init_weights(self, pretrained=None):
    method extract_feat (line 80) | def extract_feat(self, img):
    method forward_dummy (line 88) | def forward_dummy(self, img):
    method forward_train (line 106) | def forward_train(self,
    method async_simple_test (line 170) | async def async_simple_test(self,
    method simple_test (line 188) | def simple_test(self, img, img_metas, proposals=None, rescale=False):
    method aug_test (line 202) | def aug_test(self, imgs, img_metas, rescale=False):

FILE: code/mmdet/models/losses/accuracy.py
  function accuracy (line 4) | def accuracy(pred, target, topk=1):
  class Accuracy (line 40) | class Accuracy(nn.Module):
    method __init__ (line 42) | def __init__(self, topk=(1, )):
    method forward (line 52) | def forward(self, pred, target):

FILE: code/mmdet/models/losses/ae_loss.py
  function ae_loss_per_image (line 8) | def ae_loss_per_image(tl_preds, br_preds, match):
  class AssociativeEmbeddingLoss (line 70) | class AssociativeEmbeddingLoss(nn.Module):
    method __init__ (line 83) | def __init__(self, pull_weight=0.25, push_weight=0.25):
    method forward (line 88) | def forward(self, pred, target, match):

FILE: code/mmdet/models/losses/balanced_l1_loss.py
  function balanced_l1_loss (line 10) | def balanced_l1_loss(pred,
  class BalancedL1Loss (line 51) | class BalancedL1Loss(nn.Module):
    method __init__ (line 69) | def __init__(self,
    method forward (line 82) | def forward(self,

FILE: code/mmdet/models/losses/chamfer_loss.py
  class ChamferLoss2D (line 9) | class ChamferLoss2D(nn.Module):
    method __init__ (line 10) | def __init__(self, use_cuda=True, loss_weight=1.0, eps=1e-12):
    method forward (line 16) | def forward(self, point_set_1, point_set_2):
  class ChamferDistancePytorch (line 56) | class ChamferDistancePytorch(nn.Module):
    method __init__ (line 63) | def __init__(self, reduction='none'):
    method forward (line 67) | def forward(self, x, y):
    method _cost_matrix (line 87) | def _cost_matrix(x, y, p=2):

FILE: code/mmdet/models/losses/cross_entropy_loss.py
  function cross_entropy (line 9) | def cross_entropy(pred,
  function _expand_binary_labels (line 42) | def _expand_binary_labels(labels, label_weights, label_channels):
  function binary_cross_entropy (line 58) | def binary_cross_entropy(pred,
  function mask_cross_entropy (line 94) | def mask_cross_entropy(pred,
  class CrossEntropyLoss (line 129) | class CrossEntropyLoss(nn.Module):
    method __init__ (line 131) | def __init__(self,
    method forward (line 165) | def forward(self,

FILE: code/mmdet/models/losses/cross_iou_loss.py
  function get_bbox_from_extreme (line 10) | def get_bbox_from_extreme(pred, anchor_pts):
  function get_bbox_from_polygon (line 35) | def get_bbox_from_polygon(pred, anchor_pts):
  function cross_iou_loss (line 62) | def cross_iou_loss(pred, target, loss_type=None, anchor_pts=None, vs=None,
  class CrossIOULoss (line 135) | class CrossIOULoss(nn.Module):
    method __init__ (line 137) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0, loss_t...
    method forward (line 146) | def forward(self,

FILE: code/mmdet/models/losses/focal_loss.py
  function py_sigmoid_focal_loss (line 11) | def py_sigmoid_focal_loss(pred,
  function separate_sigmoid_focal_loss (line 45) | def separate_sigmoid_focal_loss(pred,
  function sigmoid_focal_loss (line 74) | def sigmoid_focal_loss(pred,
  class FocalLoss (line 120) | class FocalLoss(nn.Module):
    method __init__ (line 122) | def __init__(self,
    method forward (line 150) | def forward(self,
  class SEPFocalLoss (line 190) | class SEPFocalLoss(nn.Module):
    method __init__ (line 192) | def __init__(self,
    method forward (line 203) | def forward(self,

FILE: code/mmdet/models/losses/gaussian_focal_loss.py
  function gaussian_focal_loss (line 8) | def gaussian_focal_loss(pred, gaussian_target, alpha=2.0, gamma=4.0):
  class GaussianFocalLoss (line 30) | class GaussianFocalLoss(nn.Module):
    method __init__ (line 47) | def __init__(self,
    method forward (line 58) | def forward(self,

FILE: code/mmdet/models/losses/gfocal_loss.py
  function quality_focal_loss (line 9) | def quality_focal_loss(pred, target, beta=2.0):
  function distribution_focal_loss (line 54) | def distribution_focal_loss(pred, label):
  class QualityFocalLoss (line 80) | class QualityFocalLoss(nn.Module):
    method __init__ (line 95) | def __init__(self,
    method forward (line 107) | def forward(self,
  class DistributionFocalLoss (line 146) | class DistributionFocalLoss(nn.Module):
    method __init__ (line 157) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 162) | def forward(self,

FILE: code/mmdet/models/losses/ghm_loss.py
  function _expand_onehot_labels (line 8) | def _expand_onehot_labels(labels, label_weights, label_channels):
  class GHMC (line 21) | class GHMC(nn.Module):
    method __init__ (line 35) | def __init__(self, bins=10, momentum=0, use_sigmoid=True, loss_weight=...
    method forward (line 50) | def forward(self, pred, target, label_weight, *args, **kwargs):
  class GHMR (line 99) | class GHMR(nn.Module):
    method __init__ (line 113) | def __init__(self, mu=0.02, bins=10, momentum=0, loss_weight=1.0):
    method forward (line 127) | def forward(self, pred, target, label_weight, avg_factor=None):

FILE: code/mmdet/models/losses/iou_loss.py
  function iou_loss (line 12) | def iou_loss(pred, target, eps=1e-6):
  function bounded_iou_loss (line 32) | def bounded_iou_loss(pred, target, beta=0.2, eps=1e-3):
  function giou_loss (line 74) | def giou_loss(pred, target, eps=1e-7):
  function diou_loss (line 119) | def diou_loss(pred, target, eps=1e-7):
  function ciou_loss (line 171) | def ciou_loss(pred, target, eps=1e-7):
  class IoULoss (line 230) | class IoULoss(nn.Module):
    method __init__ (line 241) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 247) | def forward(self,
  class BoundedIoULoss (line 291) | class BoundedIoULoss(nn.Module):
    method __init__ (line 293) | def __init__(self, beta=0.2, eps=1e-3, reduction='mean', loss_weight=1...
    method forward (line 300) | def forward(self,
  class GIoULoss (line 325) | class GIoULoss(nn.Module):
    method __init__ (line 327) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 333) | def forward(self,
  class DIoULoss (line 362) | class DIoULoss(nn.Module):
    method __init__ (line 364) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 370) | def forward(self,
  class CIoULoss (line 400) | class CIoULoss(nn.Module):
    method __init__ (line 402) | def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
    method forward (line 408) | def forward(self,

FILE: code/mmdet/models/losses/mse_loss.py
  function mse_loss (line 9) | def mse_loss(pred, target):
  class MSELoss (line 15) | class MSELoss(nn.Module):
    method __init__ (line 24) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 29) | def forward(self, pred, target, weight=None, avg_factor=None):

FILE: code/mmdet/models/losses/pisa_loss.py
  function isr_p (line 6) | def isr_p(cls_score,
  function carl_loss (line 119) | def carl_loss(cls_score,

FILE: code/mmdet/models/losses/smooth_l1_loss.py
  function smooth_l1_loss (line 9) | def smooth_l1_loss(pred, target, beta=1.0):
  function l1_loss (line 30) | def l1_loss(pred, target):
  class SmoothL1Loss (line 46) | class SmoothL1Loss(nn.Module):
    method __init__ (line 57) | def __init__(self, beta=1.0, reduction='mean', loss_weight=1.0):
    method forward (line 63) | def forward(self,
  class L1Loss (line 98) | class L1Loss(nn.Module):
    method __init__ (line 107) | def __init__(self, reduction='mean', loss_weight=1.0):
    method forward (line 112) | def forward(self,

FILE: code/mmdet/models/losses/utils.py
  function reduce_loss (line 6) | def reduce_loss(loss, reduction):
  function weight_reduce_loss (line 26) | def weight_reduce_loss(loss, weight=None, reduction='mean', avg_factor=N...
  function weighted_loss (line 55) | def weighted_loss(loss_func):

FILE: code/mmdet/models/necks/bfp.py
  class BFP (line 10) | class BFP(nn.Module):
    method __init__ (line 30) | def __init__(self,
    method init_weights (line 65) | def init_weights(self):
    method forward (line 71) | def forward(self, inputs):

FILE: code/mmdet/models/necks/fpn.py
  class FPN (line 10) | class FPN(nn.Module):
    method __init__ (line 65) | def __init__(self,
    method init_weights (line 159) | def init_weights(self):
    method forward (line 166) | def forward(self, inputs):

FILE: code/mmdet/models/necks/fpn_carafe.py
  class FPN_CARAFE (line 9) | class FPN_CARAFE(nn.Module):
    method __init__ (line 33) | def __init__(self,
    method init_weights (line 202) | def init_weights(self):
    method slice_as (line 211) | def slice_as(self, src, dst):
    method tensor_add (line 231) | def tensor_add(self, a, b):
    method forward (line 239) | def forward(self, inputs):

FILE: code/mmdet/models/necks/hrfpn.py
  class HRFPN (line 11) | class HRFPN(nn.Module):
    method __init__ (line 29) | def __init__(self,
    method init_weights (line 72) | def init_weights(self):
    method forward (line 78) | def forward(self, inputs):

FILE: code/mmdet/models/necks/nas_fpn.py
  class NASFPN (line 9) | class NASFPN(nn.Module):
    method __init__ (line 30) | def __init__(self,
    method init_weights (line 123) | def init_weights(self):
    method forward (line 129) | def forward(self, inputs):

FILE: code/mmdet/models/necks/nasfcos_fpn.py
  class NASFCOS_FPN (line 10) | class NASFCOS_FPN(nn.Module):
    method __init__ (line 31) | def __init__(self,
    method forward (line 115) | def forward(self, inputs):
    method init_weights (line 149) | def init_weights(self):

FILE: code/mmdet/models/necks/pafpn.py
  class PAFPN (line 11) | class PAFPN(FPN):
    method __init__ (line 39) | def __init__(self,
    method forward (line 84) | def forward(self, inputs):

FILE: code/mmdet/models/necks/rfp.py
  class ASPP (line 10) | class ASPP(nn.Module):
    method __init__ (line 23) | def __init__(self, in_channels, out_channels, dilations=(1, 3, 6, 1)):
    method init_weights (line 42) | def init_weights(self):
    method forward (line 47) | def forward(self, x):
  class RFP (line 59) | class RFP(FPN):
    method __init__ (line 75) | def __init__(self,
    method init_weights (line 97) | def init_weights(self):
    method forward (line 104) | def forward(self, inputs):

FILE: code/mmdet/models/roi_heads/base_roi_head.py
  class BaseRoIHead (line 8) | class BaseRoIHead(nn.Module, metaclass=ABCMeta):
    method __init__ (line 11) | def __init__(self,
    method with_bbox (line 34) | def with_bbox(self):
    method with_mask (line 39) | def with_mask(self):
    method with_shared_head (line 44) | def with_shared_head(self):
    method init_weights (line 49) | def init_weights(self, pretrained):
    method init_bbox_head (line 59) | def init_bbox_head(self):
    method init_mask_head (line 64) | def init_mask_head(self):
    method init_assigner_sampler (line 69) | def init_assigner_sampler(self):
    method forward_train (line 74) | def forward_train(self,
    method async_simple_test (line 86) | async def async_simple_test(self, x, img_meta, **kwargs):
    method simple_test (line 90) | def simple_test(self,
    method aug_test (line 100) | def aug_test(self, x, proposal_list, img_metas, rescale=False, **kwargs):

FILE: code/mmdet/models/roi_heads/bbox_heads/bbox_head.py
  class BBoxHead (line 13) | class BBoxHead(nn.Module):
    method __init__ (line 17) | def __init__(self,
    method init_weights (line 66) | def init_weights(self):
    method forward (line 76) | def forward(self, x):
    method _get_target_single (line 84) | def _get_target_single(self, pos_bboxes, neg_bboxes, pos_gt_bboxes,
    method get_targets (line 115) | def get_targets(self,
    method loss (line 141) | def loss(self,
    method get_bboxes (line 188) | def get_bboxes(self,
    method refine_bboxes (line 227) | def refine_bboxes(self, rois, labels, bbox_preds, pos_is_gts, img_metas):
    method regress_by_class (line 306) | def regress_by_class(self, rois, label, bbox_pred, img_meta):

FILE: code/mmdet/models/roi_heads/bbox_heads/convfc_bbox_head.py
  class ConvFCBBoxHead (line 9) | class ConvFCBBoxHead(BBoxHead):
    method __init__ (line 20) | def __init__(self,
    method _add_conv_fc_branch (line 85) | def _add_conv_fc_branch(self,
    method init_weights (line 126) | def init_weights(self):
    method forward (line 135) | def forward(self, x):
  class Shared2FCBBoxHead (line 177) | class Shared2FCBBoxHead(ConvFCBBoxHead):
    method __init__ (line 179) | def __init__(self, fc_out_channels=1024, *args, **kwargs):
  class Shared4Conv1FCBBoxHead (line 193) | class Shared4Conv1FCBBoxHead(ConvFCBBoxHead):
    method __init__ (line 195) | def __init__(self, fc_out_channels=1024, *args, **kwargs):

FILE: code/mmdet/models/roi_heads/bbox_heads/double_bbox_head.py
  class BasicResBlock (line 9) | class BasicResBlock(nn.Module):
    method __init__ (line 22) | def __init__(self,
    method forward (line 58) | def forward(self, x):
  class DoubleConvFCBBoxHead (line 72) | class DoubleConvFCBBoxHead(BBoxHead):
    method __init__ (line 86) | def __init__(self,
    method _add_conv_branch (line 121) | def _add_conv_branch(self):
    method _add_fc_branch (line 133) | def _add_fc_branch(self):
    method init_weights (line 143) | def init_weights(self):
    method forward (line 152) | def forward(self, x_cls, x_reg):

FILE: code/mmdet/models/roi_heads/cascade_roi_head.py
  class CascadeRoIHead (line 13) | class CascadeRoIHead(BaseRoIHead, BBoxTestMixin, MaskTestMixin):
    method __init__ (line 19) | def __init__(self,
    method init_bbox_head (line 44) | def init_bbox_head(self, bbox_roi_extractor, bbox_head):
    method init_mask_head (line 64) | def init_mask_head(self, mask_roi_extractor, mask_head):
    method init_assigner_sampler (line 92) | def init_assigner_sampler(self):
    method init_weights (line 102) | def init_weights(self, pretrained):
    method forward_dummy (line 120) | def forward_dummy(self, x, proposals):
    method _bbox_forward (line 138) | def _bbox_forward(self, stage, x, rois):
    method _bbox_forward_train (line 151) | def _bbox_forward_train(self, stage, x, sampling_results, gt_bboxes,
    method _mask_forward (line 166) | def _mask_forward(self, stage, x, rois):
    method _mask_forward_train (line 178) | def _mask_forward_train(self,
    method forward_train (line 202) | def forward_train(self,
    method simple_test (line 289) | def simple_test(self, x, proposal_list, img_metas, rescale=False):
    method aug_test (line 355) | def aug_test(self, features, proposal_list, img_metas, rescale=False):

FILE: code/mmdet/models/roi_heads/double_roi_head.py
  class DoubleHeadRoIHead (line 6) | class DoubleHeadRoIHead(StandardRoIHead):
    method __init__ (line 12) | def __init__(self, reg_roi_scale_factor, **kwargs):
    method _bbox_forward (line 16) | def _bbox_forward(self, x, rois):

FILE: code/mmdet/models/roi_heads/dynamic_roi_head.py
  class DynamicRoIHead (line 11) | class DynamicRoIHead(StandardRoIHead):
    method __init__ (line 14) | def __init__(self, **kwargs):
    method forward_train (line 22) | def forward_train(self,
    method _bbox_forward_train (line 107) | def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
    method update_hyperparameters (line 132) | def update_hyperparameters(self):

FILE: code/mmdet/models/roi_heads/grid_roi_head.py
  class GridRoIHead (line 9) | class GridRoIHead(StandardRoIHead):
    method __init__ (line 15) | def __init__(self, grid_roi_extractor, grid_head, **kwargs):
    method init_weights (line 26) | def init_weights(self, pretrained):
    method _random_jitter (line 38) | def _random_jitter(self, sampling_results, img_metas, amplitude=0.15):
    method forward_dummy (line 63) | def forward_dummy(self, x, proposals):
    method _bbox_forward_train (line 89) | def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
    method simple_test (line 127) | def simple_test(self,

FILE: code/mmdet/models/roi_heads/htc_roi_head.py
  class HybridTaskCascadeRoIHead (line 11) | class HybridTaskCascadeRoIHead(CascadeRoIHead):
    method __init__ (line 17) | def __init__(self,
    method init_weights (line 40) | def init_weights(self, pretrained):
    method with_semantic (line 52) | def with_semantic(self):
    method forward_dummy (line 59) | def forward_dummy(self, x, proposals):
    method _bbox_forward_train (line 94) | def _bbox_forward_train(self,
    method _mask_forward_train (line 121) | def _mask_forward_train(self,
    method _bbox_forward (line 165) | def _bbox_forward(self, stage, x, rois, semantic_feat=None):
    method _mask_forward_test (line 183) | def _mask_forward_test(self, stage, x, bboxes, semantic_feat=None):
    method forward_train (line 212) | def forward_train(self,
    method simple_test (line 337) | def simple_test(self, x, proposal_list, img_metas, rescale=False):
    method aug_test (line 421) | def aug_test(self, img_feats, proposal_list, img_metas, rescale=False):

FILE: code/mmdet/models/roi_heads/mask_heads/coarse_mask_head.py
  class CoarseMaskHead (line 10) | class CoarseMaskHead(FCNMaskHead):
    method __init__ (line 25) | def __init__(self,
    method init_weights (line 72) | def init_weights(self):
    method forward (line 79) | def forward(self, x):

FILE: code/mmdet/models/roi_heads/mask_heads/fcn_mask_head.py
  class FCNMaskHead (line 20) | class FCNMaskHead(nn.Module):
    method __init__ (line 22) | def __init__(self,
    method init_weights (line 106) | def init_weights(self):
    method forward (line 118) | def forward(self, x):
    method get_targets (line 128) | def get_targets(self, sampling_results, gt_masks, rcnn_train_cfg):
    method loss (line 138) | def loss(self, mask_pred, mask_targets, labels):
    method get_seg_masks (line 151) | def get_seg_masks(self, mask_pred, det_bboxes, det_labels, rcnn_test_cfg,
  function _do_paste_mask (line 240) | def _do_paste_mask(masks, boxes, img_h, img_w, skip_empty=True):

FILE: code/mmdet/models/roi_heads/mask_heads/fused_semantic_head.py
  class FusedSemanticHead (line 10) | class FusedSemanticHead(nn.Module):
    method __init__ (line 26) | def __init__(self,
    method init_weights (line 82) | def init_weights(self):
    method forward (line 86) | def forward(self, feats):
    method loss (line 103) | def loss(self, mask_pred, labels):

FILE: code/mmdet/models/roi_heads/mask_heads/grid_head.py
  class GridHead (line 11) | class GridHead(nn.Module):
    method __init__ (line 13) | def __init__(self,
    method init_weights (line 141) | def init_weights(self):
    method forward (line 151) | def forward(self, x):
    method calc_sub_regions (line 189) | def calc_sub_regions(self):
    method get_targets (line 220) | def get_targets(self, sampling_results, rcnn_train_cfg):
    method loss (line 288) | def loss(self, grid_pred, grid_targets):
    method get_bboxes (line 294) | def get_bboxes(self, det_bboxes, grid_pred, img_metas):

FILE: code/mmdet/models/roi_heads/mask_heads/htc_mask_head.py
  class HTCMaskHead (line 8) | class HTCMaskHead(FCNMaskHead):
    method __init__ (line 10) | def __init__(self, with_conv_res=True, *args, **kwargs):
    method init_weights (line 21) | def init_weights(self):
    method forward (line 26) | def forward(self, x, res_feat=None, return_logits=True, return_feat=Tr...

FILE: code/mmdet/models/roi_heads/mask_heads/mask_point_head.py
  class MaskPointHead (line 12) | class MaskPointHead(nn.Module):
    method __init__ (line 37) | def __init__(self,
    method init_weights (line 80) | def init_weights(self):
    method forward (line 85) | def forward(self, fine_grained_feats, coarse_feats):
    method get_targets (line 106) | def get_targets(self, rois, rel_roi_points, sampling_results, gt_masks,
    method _get_target_single (line 146) | def _get_target_single(self, rois, rel_roi_points, pos_assigned_gt_inds,
    method loss (line 164) | def loss(self, point_pred, point_targets, labels):
    method _get_uncertainty (line 187) | def _get_uncertainty(self, mask_pred, labels):
    method get_roi_rel_points_train (line 212) | def get_roi_rel_points_train(self, mask_pred, labels, cfg):
    method get_roi_rel_points_test (line 267) | def get_roi_rel_points_test(self, mask_pred, pred_label, cfg):

FILE: code/mmdet/models/roi_heads/mask_heads/maskiou_head.py
  class MaskIoUHead (line 13) | class MaskIoUHead(nn.Module):
    method __init__ (line 19) | def __init__(self,
    method init_weights (line 65) | def init_weights(self):
    method forward (line 77) | def forward(self, mask_feat, mask_pred):
    method loss (line 92) | def loss(self, mask_iou_pred, mask_iou_targets):
    method get_targets (line 102) | def get_targets(self, sampling_results, gt_masks, mask_pred, mask_targ...
    method _get_area_ratio (line 151) | def _get_area_ratio(self, pos_proposals, pos_assigned_gt_inds, gt_masks):
    method get_mask_scores (line 178) | def get_mask_scores(self, mask_iou_pred, det_bboxes, det_labels):

FILE: code/mmdet/models/roi_heads/mask_scoring_roi_head.py
  class MaskScoringRoIHead (line 9) | class MaskScoringRoIHead(StandardRoIHead):
    method __init__ (line 15) | def __init__(self, mask_iou_head, **kwargs):
    method init_weights (line 20) | def init_weights(self, pretrained):
    method _mask_forward_train (line 30) | def _mask_forward_train(self, x, sampling_results, bbox_feats, gt_masks,
    method simple_test_mask (line 57) | def simple_test_mask(self,

FILE: code/mmdet/models/roi_heads/pisa_roi_head.py
  class PISARoIHead (line 8) | class PISARoIHead(StandardRoIHead):
    method forward_train (line 10) | def forward_train(self,
    method _bbox_forward (line 87) | def _bbox_forward(self, x, rois):
    method _bbox_forward_train (line 100) | def _bbox_forward_train(self,

FILE: code/mmdet/models/roi_heads/point_rend_roi_head.py
  class PointRendRoIHead (line 14) | class PointRendRoIHead(StandardRoIHead):
    method __init__ (line 18) | def __init__(self, point_head, *args, **kwargs):
    method init_point_head (line 23) | def init_point_head(self, point_head):
    method init_weights (line 27) | def init_weights(self, pretrained):
    method _mask_forward_train (line 36) | def _mask_forward_train(self, x, sampling_results, bbox_feats, gt_masks,
    method _mask_point_forward_train (line 51) | def _mask_point_forward_train(self, x, sampling_results, mask_pred,
    method _get_fine_grained_point_feats (line 72) | def _get_fine_grained_point_feats(self, x, rois, rel_roi_points,
    method _mask_point_forward_test (line 97) | def _mask_point_forward_test(self, x, rois, label_pred, mask_pred,
    method simple_test_mask (line 135) | def simple_test_mask(self,
    method aug_test_mask (line 163) | def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):

FILE: code/mmdet/models/roi_heads/roi_extractors/base_roi_extractor.py
  class BaseRoIExtractor (line 9) | class BaseRoIExtractor(nn.Module, metaclass=ABCMeta):
    method __init__ (line 18) | def __init__(self, roi_layer, out_channels, featmap_strides):
    method num_inputs (line 26) | def num_inputs(self):
    method init_weights (line 30) | def init_weights(self):
    method build_roi_layers (line 33) | def build_roi_layers(self, layer_cfg, featmap_strides):
    method roi_rescale (line 58) | def roi_rescale(self, rois, scale_factor):
    method forward (line 83) | def forward(self, feats, rois, roi_scale_factor=None):

FILE: code/mmdet/models/roi_heads/roi_extractors/generic_roi_extractor.py
  class GenericRoIExtractor (line 8) | class GenericRoIExtractor(BaseRoIExtractor):
    method __init__ (line 23) | def __init__(self,
    method forward (line 42) | def forward(self, feats, rois, roi_scale_factor=None):

FILE: code/mmdet/models/roi_heads/roi_extractors/single_level_roi_extractor.py
  class SingleRoIExtractor (line 9) | class SingleRoIExtractor(BaseRoIExtractor):
    method __init__ (line 23) | def __init__(self,
    method map_roi_levels (line 32) | def map_roi_levels(self, rois, num_levels):
    method forward (line 54) | def forward(self, feats, rois, roi_scale_factor=None):

FILE: code/mmdet/models/roi_heads/shared_heads/res_layer.py
  class ResLayer (line 13) | class ResLayer(nn.Module):
    method __init__ (line 15) | def __init__(self,
    method init_weights (line 48) | def init_weights(self, pretrained=None):
    method forward (line 68) | def forward(self, x):
    method train (line 73) | def train(self, mode=True):

FILE: code/mmdet/models/roi_heads/standard_roi_head.py
  class StandardRoIHead (line 10) | class StandardRoIHead(BaseRoIHead, BBoxTestMixin, MaskTestMixin):
    method init_assigner_sampler (line 14) | def init_assigner_sampler(self):
    method init_bbox_head (line 23) | def init_bbox_head(self, bbox_roi_extractor, bbox_head):
    method init_mask_head (line 28) | def init_mask_head(self, mask_roi_extractor, mask_head):
    method init_weights (line 38) | def init_weights(self, pretrained):
    method forward_dummy (line 55) | def forward_dummy(self, x, proposals):
    method forward_train (line 71) | def forward_train(self,
    method _bbox_forward (line 136) | def _bbox_forward(self, x, rois):
    method _bbox_forward_train (line 149) | def _bbox_forward_train(self, x, sampling_results, gt_bboxes, gt_labels,
    method _mask_forward_train (line 164) | def _mask_forward_train(self, x, sampling_results, bbox_feats, gt_masks,
    method _mask_forward (line 201) | def _mask_forward(self, x, rois=None, pos_inds=None, bbox_feats=None):
    method async_simple_test (line 218) | async def async_simple_test(self,
    method simple_test (line 243) | def simple_test(self,
    method aug_test (line 264) | def aug_test(self, x, proposal_list, img_metas, rescale=False):

FILE: code/mmdet/models/roi_heads/test_mixins.py
  class BBoxTestMixin (line 15) | class BBoxTestMixin(object):
    method async_test_bboxes (line 19) | async def async_test_bboxes(self,
    method simple_test_bboxes (line 52) | def simple_test_bboxes(self,
    method aug_test_bboxes (line 73) | def aug_test_bboxes(self, feats, img_metas, proposal_list, rcnn_test_c...
  class MaskTestMixin (line 109) | class MaskTestMixin(object):
    method async_test_mask (line 113) | async def async_test_mask(self,
    method simple_test_mask (line 151) | def simple_test_mask(self,
    method aug_test_mask (line 178) | def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):

FILE: code/mmdet/models/utils/res_layer.py
  class ResLayer (line 5) | class ResLayer(nn.Sequential):
    method __init__ (line 24) | def __init__(self,

FILE: code/mmdet/ops/carafe/carafe.py
  class CARAFENaiveFunction (line 11) | class CARAFENaiveFunction(Function):
    method forward (line 14) | def forward(ctx, features, masks, kernel_size, group_size, scale_factor):
    method backward (line 40) | def backward(ctx, grad_output):
  class CARAFENaive (line 60) | class CARAFENaive(Module):
    method __init__ (line 62) | def __init__(self, kernel_size, group_size, scale_factor):
    method forward (line 71) | def forward(self, features, masks):
  class CARAFEFunction (line 76) | class CARAFEFunction(Function):
    method forward (line 79) | def forward(ctx, features, masks, kernel_size, group_size, scale_factor):
    method backward (line 108) | def backward(ctx, grad_output):
  class CARAFE (line 132) | class CARAFE(Module):
    method __init__ (line 146) | def __init__(self, kernel_size, group_size, scale_factor):
    method forward (line 155) | def forward(self, features, masks):
  class CARAFEPack (line 161) | class CARAFEPack(nn.Module):
    method __init__ (line 182) | def __init__(self,
    method init_weights (line 210) | def init_weights(self):
    method kernel_normalizer (line 216) | def kernel_normalizer(self, mask):
    method feature_reassemble (line 227) | def feature_reassemble(self, x, mask):
    method forward (line 231) | def forward(self, x):

FILE: code/mmdet/ops/carafe/src/carafe_ext.cpp
  function carafe_forward (line 21) | int carafe_forward(at::Tensor features, at::Tensor rfeatures,
  function carafe_backward (line 36) | int carafe_backward(at::Tensor top_grad, at::Tensor rfeatures,
  function PYBIND11_MODULE (line 54) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/carafe/src/carafe_naive_ext.cpp
  function carafe_naive_forward (line 18) | int carafe_naive_forward(at::Tensor features, at::Tensor masks,
  function carafe_naive_backward (line 32) | int carafe_naive_backward(at::Tensor top_grad, at::Tensor features,
  function PYBIND11_MODULE (line 48) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/carafe/src/cuda/carafe_cuda.cpp
  function carafe_forward_cuda (line 34) | int carafe_forward_cuda(at::Tensor features, at::Tensor rfeatures,
  function carafe_backward_cuda (line 68) | int carafe_backward_cuda(at::Tensor top_grad, at::Tensor rfeatures,

FILE: code/mmdet/ops/carafe/src/cuda/carafe_naive_cuda.cpp
  function carafe_naive_forward_cuda (line 28) | int carafe_naive_forward_cuda(at::Tensor features, at::Tensor masks,
  function carafe_naive_backward_cuda (line 48) | int carafe_naive_backward_cuda(at::Tensor top_grad, at::Tensor features,

FILE: code/mmdet/ops/chamfer_2d/dist_chamfer_2d.py
  class ChamferFunction2D (line 10) | class ChamferFunction2D(Function):
    method forward (line 12) | def forward(ctx, xyz1, xyz2):
    method backward (line 34) | def backward(ctx, graddist1, graddist2, gradidx1, gradidx2):
  class Chamfer2D (line 51) | class Chamfer2D(nn.Module):
    method __init__ (line 52) | def __init__(self):
    method forward (line 55) | def forward(self, input1, input2):

FILE: code/mmdet/ops/chamfer_2d/src/chamfer_cuda.cpp
  function chamfer_forward (line 17) | int chamfer_forward(at::Tensor xyz1, at::Tensor xyz2, at::Tensor dist1, ...
  function chamfer_backward (line 22) | int chamfer_backward(at::Tensor xyz1, at::Tensor xyz2, at::Tensor gradxy...
  function PYBIND11_MODULE (line 30) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/context_block.py
  function last_zero_init (line 6) | def last_zero_init(m):
  class ContextBlock (line 13) | class ContextBlock(nn.Module):
    method __init__ (line 27) | def __init__(self,
    method reset_parameters (line 66) | def reset_parameters(self):
    method spatial_pool (line 76) | def spatial_pool(self, x):
    method forward (line 102) | def forward(self, x):

FILE: code/mmdet/ops/conv_ws.py
  function conv_ws_2d (line 7) | def conv_ws_2d(input,
  class ConvWS2d (line 24) | class ConvWS2d(nn.Conv2d):
    method __init__ (line 26) | def __init__(self,
    method forward (line 47) | def forward(self, x):
  class ConvAWS2d (line 53) | class ConvAWS2d(nn.Conv2d):
    method __init__ (line 76) | def __init__(self,
    method _get_weight (line 99) | def _get_weight(self, weight):
    method forward (line 107) | def forward(self, x):
    method _load_from_state_dict (line 112) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...

FILE: code/mmdet/ops/corner_pool/corner_pool.py
  class TopPoolFunction (line 10) | class TopPoolFunction(Function):
    method forward (line 13) | def forward(ctx, input):
    method backward (line 19) | def backward(ctx, grad_output):
  class BottomPoolFunction (line 25) | class BottomPoolFunction(Function):
    method forward (line 28) | def forward(ctx, input):
    method backward (line 34) | def backward(ctx, grad_output):
  class LeftPoolFunction (line 40) | class LeftPoolFunction(Function):
    method forward (line 43) | def forward(ctx, input):
    method backward (line 49) | def backward(ctx, grad_output):
  class RightPoolFunction (line 55) | class RightPoolFunction(Function):
    method forward (line 58) | def forward(ctx, input):
    method backward (line 64) | def backward(ctx, grad_output):
  class CornerPool (line 70) | class CornerPool(nn.Module):
    method __init__ (line 100) | def __init__(self, mode):
    method forward (line 106) | def forward(self, x):
  class CornerPoolPack (line 119) | class CornerPoolPack(nn.Module):
    method __init__ (line 120) | def __init__(self, dim, pool1, pool2, conv_cfg=None, norm_cfg=None, fi...
    method forward (line 158) | def forward(self, x):
  class TLPool (line 179) | class TLPool(CornerPoolPack):
    method __init__ (line 180) | def __init__(self, dim, conv_cfg=None, norm_cfg=None, first_kernel_siz...
  class BRPool (line 184) | class BRPool(CornerPoolPack):
    method __init__ (line 185) | def __init__(self, dim, conv_cfg=None, norm_cfg=None, first_kernel_siz...

FILE: code/mmdet/ops/corner_pool/src/corner_pool.cpp
  function bottom_pool_forward (line 7) | at::Tensor bottom_pool_forward(at::Tensor input) {
  function bottom_pool_backward (line 26) | at::Tensor bottom_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function left_pool_forward (line 68) | at::Tensor left_pool_forward(at::Tensor input) {
  function left_pool_backward (line 87) | at::Tensor left_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function right_pool_forward (line 129) | at::Tensor right_pool_forward(at::Tensor input) {
  function right_pool_backward (line 148) | at::Tensor right_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function top_pool_forward (line 190) | at::Tensor top_pool_forward(at::Tensor input) {
  function top_pool_backward (line 209) | at::Tensor top_pool_backward(at::Tensor input, at::Tensor grad_output) {
  function PYBIND11_MODULE (line 251) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/dcn/deform_conv.py
  class DeformConvFunction (line 15) | class DeformConvFunction(Function):
    method forward (line 18) | def forward(ctx,
    method backward (line 62) | def backward(ctx, grad_output):
    method _output_size (line 99) | def _output_size(input, weight, padding, dilation, stride):
  class ModulatedDeformConvFunction (line 114) | class ModulatedDeformConvFunction(Function):
    method forward (line 117) | def forward(ctx,
    method backward (line 153) | def backward(ctx, grad_output):
    method _infer_shape (line 175) | def _infer_shape(ctx, input, weight):
  class PyramidDeformConvFunction (line 188) | class PyramidDeformConvFunction(Function):
    method forward (line 191) | def forward(ctx,
    method backward (line 237) | def backward(ctx, grad_output):
    method _output_size (line 275) | def _output_size(input, weight, padding, dilation, stride):
  class DeformConv (line 295) | class DeformConv(nn.Module):
    method __init__ (line 297) | def __init__(self,
    method reset_parameters (line 334) | def reset_parameters(self):
    method forward (line 341) | def forward(self, x, offset):
  class DeformConvPack (line 361) | class DeformConvPack(DeformConv):
    method __init__ (line 387) | def __init__(self, *args, **kwargs):
    method init_offset (line 401) | def init_offset(self):
    method forward (line 405) | def forward(self, x):
    method _load_from_state_dict (line 410) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
  class ModulatedDeformConv (line 438) | class ModulatedDeformConv(nn.Module):
    method __init__ (line 440) | def __init__(self,
    method init_weights (line 473) | def init_weights(self):
    method forward (line 482) | def forward(self, x, offset, mask):
  class ModulatedDeformConvPack (line 489) | class ModulatedDeformConvPack(ModulatedDeformConv):
    method __init__ (line 507) | def __init__(self, *args, **kwargs):
    method init_weights (line 521) | def init_weights(self):
    method forward (line 527) | def forward(self, x):
    method _load_from_state_dict (line 536) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
  class PyramidDeformConv (line 565) | class PyramidDeformConv(nn.Module):
    method __init__ (line 567) | def __init__(self,
    method reset_parameters (line 604) | def reset_parameters(self):
    method forward (line 611) | def forward(self, x, offset, scale_h, scale_w):

FILE: code/mmdet/ops/dcn/deform_pool.py
  class DeformRoIPoolingFunction (line 10) | class DeformRoIPoolingFunction(Function):
    method forward (line 13) | def forward(ctx,
    method backward (line 60) | def backward(ctx, grad_output):
  class DeformRoIPooling (line 82) | class DeformRoIPooling(nn.Module):
    method __init__ (line 84) | def __init__(self,
    method forward (line 103) | def forward(self, data, rois, offset):
  class DeformRoIPoolingPack (line 113) | class DeformRoIPoolingPack(DeformRoIPooling):
    method __init__ (line 115) | def __init__(self,
    method forward (line 149) | def forward(self, data, rois):
  class ModulatedDeformRoIPoolingPack (line 177) | class ModulatedDeformRoIPoolingPack(DeformRoIPooling):
    method __init__ (line 179) | def __init__(self,
    method forward (line 232) | def forward(self, data, rois):

FILE: code/mmdet/ops/dcn/src/cuda/deform_conv_cuda.cpp
  function shape_check (line 92) | void shape_check(at::Tensor input, at::Tensor offset, at::Tensor *gradOu...
  function pyramid_shape_check (line 182) | void pyramid_shape_check(at::Tensor input, at::Tensor offset, at::Tensor...
  function deform_conv_forward_cuda (line 274) | int deform_conv_forward_cuda(at::Tensor input, at::Tensor weight,
  function deform_conv_backward_input_cuda (line 384) | int deform_conv_backward_input_cuda(at::Tensor input, at::Tensor offset,
  function deform_conv_backward_parameters_cuda (line 498) | int deform_conv_backward_parameters_cuda(
  function modulated_deform_conv_cuda_forward (line 613) | void modulated_deform_conv_cuda_forward(
  function modulated_deform_conv_cuda_backward (line 694) | void modulated_deform_conv_cuda_backward(
  function pyramid_deform_conv_forward_cuda (line 811) | int pyramid_deform_conv_forward_cuda(at::Tensor input, at::Tensor weight,
  function pyramid_deform_conv_backward_input_cuda (line 921) | int pyramid_deform_conv_backward_input_cuda(at::Tensor input, at::Tensor...
  function pyramid_deform_conv_backward_parameters_cuda (line 1038) | int pyramid_deform_conv_backward_parameters_cuda(

FILE: code/mmdet/ops/dcn/src/cuda/deform_pool_cuda.cpp
  function deform_psroi_pooling_cuda_forward (line 31) | void deform_psroi_pooling_cuda_forward(
  function deform_psroi_pooling_cuda_backward (line 56) | void deform_psroi_pooling_cuda_backward(

FILE: code/mmdet/ops/dcn/src/deform_conv_ext.cpp
  function deform_conv_forward (line 74) | int deform_conv_forward(at::Tensor input, at::Tensor weight,
  function deform_conv_backward_input (line 92) | int deform_conv_backward_input(at::Tensor input, at::Tensor offset,
  function deform_conv_backward_parameters (line 111) | int deform_conv_backward_parameters(
  function modulated_deform_conv_forward (line 129) | void modulated_deform_conv_forward(
  function modulated_deform_conv_backward (line 149) | void modulated_deform_conv_backward(
  function pyramid_deform_conv_forward (line 171) | int pyramid_deform_conv_forward(at::Tensor input, at::Tensor weight,
  function pyramid_deform_conv_backward_input (line 190) | int pyramid_deform_conv_backward_input(at::Tensor input, at::Tensor offset,
  function pyramid_deform_conv_backward_parameters (line 209) | int pyramid_deform_conv_backward_parameters(
  function PYBIND11_MODULE (line 227) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/dcn/src/deform_pool_ext.cpp
  function deform_psroi_pooling_forward (line 29) | void deform_psroi_pooling_forward(
  function deform_psroi_pooling_backward (line 46) | void deform_psroi_pooling_backward(
  function PYBIND11_MODULE (line 66) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: code/mmdet/ops/generalized_attention.py
  class GeneralizedAttention (line 10) | class GeneralizedAttention(nn.Module):
    method __init__ (line 34) | def __init__(self,
    method get_position_embedding (line 153) | def get_position_embedding(self,
    method forward (line 197) | def forward(self, x_input):
    method init_weights (line 375) | def init_weights(self):

FILE: code/mmdet/ops/masked_conv/masked_conv.py
  class MaskedConv2dFunction (line 12) | class MaskedConv2dFunction(Function):
    method forward (line 15) | def forward(ctx, features, mask, weight, bias, padding=0, stride=1):
    method backward (line 57) | def backward(ctx, grad_output):
  class MaskedConv2d (li

[
  {
    "path": "README.md",
    "chars": 14023,
    "preview": "### The trained models are temporarily unavailable, but you can train the code using reasonable computational resource.\n"
  },
  {
    "path": "checkpoints/000.txt",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "code/LICENSE",
    "chars": 1162,
    "preview": "    MIT License\n\n    Copyright (c) Microsoft Corporation. All rights reserved.\n\n    Permission is hereby granted, free o"
  },
  {
    "path": "code/ThirdPartyNotices.txt",
    "chars": 12725,
    "preview": "************************************************************************\n\nTHIRD-PARTY SOFTWARE NOTICES AND INFORMATION\n\n"
  },
  {
    "path": "code/cocoapi/.github/workflows/build.yml",
    "chars": 1217,
    "preview": "# This workflow will install Python dependencies, run tests and lint with a variety of Python versions\n# For more inform"
  },
  {
    "path": "code/cocoapi/.github/workflows/deploy.yml",
    "chars": 823,
    "preview": "name: deploy\n\non: push\n\njobs:\n  build-n-publish:\n    runs-on: ubuntu-latest\n    if: startsWith(github.event.ref, 'refs/t"
  },
  {
    "path": "code/cocoapi/.gitignore",
    "chars": 2306,
    "preview": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packagi"
  },
  {
    "path": "code/cocoapi/.isort.cfg",
    "chars": 63,
    "preview": "[settings]\nknown_third_party = cv2,matplotlib,numpy,setuptools\n"
  },
  {
    "path": "code/cocoapi/.pre-commit-config.yaml",
    "chars": 738,
    "preview": "repos:\n  - repo: https://gitlab.com/pycqa/flake8.git\n    rev: 3.8.0\n    hooks:\n      - id: flake8\n  - repo: https://gith"
  },
  {
    "path": "code/cocoapi/MANIFEST.in",
    "chars": 68,
    "preview": "include pycocotools/pycocotools/*.pyx\ninclude lvis/requirements.txt\n"
  },
  {
    "path": "code/cocoapi/README.md",
    "chars": 1148,
    "preview": "# OpenMMLab cocoapi\n\nIn this repo, we merged COCO and LVIS API into one repo.\n\nFor bug fixes and better compatability wi"
  },
  {
    "path": "code/cocoapi/license.txt",
    "chars": 1529,
    "preview": "Copyright (c) 2014, Piotr Dollar and Tsung-Yi Lin\nAll rights reserved.\n\nRedistribution and use in source and binary form"
  },
  {
    "path": "code/cocoapi/lvis/lvis/__init__.py",
    "chars": 189,
    "preview": "from .eval import LVISEval\nfrom .lvis import LVIS\nfrom .results import LVISResults\nfrom .vis import LVISVis\n\n__all__ = ["
  },
  {
    "path": "code/cocoapi/lvis/lvis/colormap.py",
    "chars": 3866,
    "preview": "\"\"\"An awesome colormap for really neat visualizations. Taken from detectron.\"\"\"\n\nimport numpy as np\n\n\ndef colormap(rgb=F"
  },
  {
    "path": "code/cocoapi/lvis/lvis/eval.py",
    "chars": 20762,
    "preview": "import datetime\nimport logging\nfrom collections import OrderedDict, defaultdict\n\nimport numpy as np\n\nimport pycocotools."
  },
  {
    "path": "code/cocoapi/lvis/lvis/lvis.py",
    "chars": 6094,
    "preview": "\"\"\"\nAPI for accessing LVIS Dataset: https://lvisdataset.org.\n\nLVIS API is a Python API that assists in loading, parsing "
  },
  {
    "path": "code/cocoapi/lvis/lvis/results.py",
    "chars": 3266,
    "preview": "import logging\nfrom collections import defaultdict\nfrom copy import deepcopy\n\nimport pycocotools.mask as mask_utils\n\nfro"
  },
  {
    "path": "code/cocoapi/lvis/lvis/vis.py",
    "chars": 7053,
    "preview": "import logging\nimport os\n\nimport cv2\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom matplotlib.patches import P"
  },
  {
    "path": "code/cocoapi/lvis/requirements.txt",
    "chars": 157,
    "preview": "cycler>=0.10.0\nCython>=0.29.12\nkiwisolver>=1.1.0\nmatplotlib>=3.1.1\nnumpy>=1.18.2\nopencv-python>=4.1.0.25\npyparsing>=2.4."
  },
  {
    "path": "code/cocoapi/lvis/setup.py",
    "chars": 1158,
    "preview": "\"\"\"LVIS (pronounced ‘el-vis’): is a new dataset for Large Vocabulary Instance\nSegmentation. We collect over 2 million hi"
  },
  {
    "path": "code/cocoapi/pycocotools/MANIFEST.in",
    "chars": 73,
    "preview": "include common/*.cpp common/*.h common/*.c\ninclude pycocotools/_mask.pyx\n"
  },
  {
    "path": "code/cocoapi/pycocotools/Makefile",
    "chars": 200,
    "preview": "all:\n    # install pycocotools locally\n\tpython setup.py build_ext --inplace\n\trm -rf build\n\ninstall:\n\t# install pycocotoo"
  },
  {
    "path": "code/cocoapi/pycocotools/common/gason.cpp",
    "chars": 9540,
    "preview": "// https://github.com/vivkin/gason - pulled January 10, 2016\n#include \"gason.h\"\n#include <stdlib.h>\n\n#define JSON_ZONE_S"
  },
  {
    "path": "code/cocoapi/pycocotools/common/gason.h",
    "chars": 3483,
    "preview": "// https://github.com/vivkin/gason - pulled January 10, 2016\n#pragma once\n\n#include <stdint.h>\n#include <stddef.h>\n#incl"
  },
  {
    "path": "code/cocoapi/pycocotools/common/maskApi.c",
    "chars": 8308,
    "preview": "/**************************************************************************\n* Microsoft COCO Toolbox.      version 2.0\n*"
  },
  {
    "path": "code/cocoapi/pycocotools/common/maskApi.h",
    "chars": 2176,
    "preview": "/**************************************************************************\n* Microsoft COCO Toolbox.      version 2.0\n*"
  },
  {
    "path": "code/cocoapi/pycocotools/pycocoDemo.ipynb",
    "chars": 1790308,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 1,\n   \"metadata\": {\n    \"collapsed\": true\n   },\n   \"outp"
  },
  {
    "path": "code/cocoapi/pycocotools/pycocoEvalDemo.ipynb",
    "chars": 4456,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 1,\n   \"metadata\": {\n    \"collapsed\": false\n   },\n   \"out"
  },
  {
    "path": "code/cocoapi/pycocotools/pycocotools/__init__.py",
    "chars": 44,
    "preview": "__author__ = 'tylin'\n__version__ = '12.0.2'\n"
  },
  {
    "path": "code/cocoapi/pycocotools/pycocotools/_mask.pyx",
    "chars": 11440,
    "preview": "# distutils: language = c\n# distutils: sources = ../common/maskApi.c\n\n#*************************************************"
  },
  {
    "path": "code/cocoapi/pycocotools/pycocotools/coco.py",
    "chars": 20636,
    "preview": "__author__ = 'tylin'\n__version__ = '2.0'\n# Interface for accessing the Microsoft COCO dataset.\n\n# Microsoft COCO is a la"
  },
  {
    "path": "code/cocoapi/pycocotools/pycocotools/cocoeval.py",
    "chars": 25707,
    "preview": "__author__ = 'tsungyi'\n\nimport copy\nimport datetime\nimport time\nfrom collections import defaultdict\n\nimport numpy as np\n"
  },
  {
    "path": "code/cocoapi/pycocotools/pycocotools/mask.py",
    "chars": 4630,
    "preview": "__author__ = 'tsungyi'\n\nimport pycocotools._mask as _mask\n\n# Interface for manipulating masks stored in RLE format.\n#\n# "
  },
  {
    "path": "code/cocoapi/pycocotools/setup.py",
    "chars": 922,
    "preview": "import numpy as np\nfrom setuptools import Extension, setup\n\n# To compile and install locally run \"python setup.py build_"
  },
  {
    "path": "code/configs/_base_/datasets/cityscapes_detection.py",
    "chars": 1918,
    "preview": "dataset_type = 'CityscapesDataset'\ndata_root = 'data/cityscapes/'\nimg_norm_cfg = dict(\n    mean=[123.675, 116.28, 103.53"
  },
  {
    "path": "code/configs/_base_/datasets/cityscapes_instance.py",
    "chars": 1944,
    "preview": "dataset_type = 'CityscapesDataset'\ndata_root = 'data/cityscapes/'\nimg_norm_cfg = dict(\n    mean=[123.675, 116.28, 103.53"
  },
  {
    "path": "code/configs/_base_/datasets/coco_detection.py",
    "chars": 1692,
    "preview": "dataset_type = 'CocoDataset'\ndata_root = 'data/coco/'\nimg_norm_cfg = dict(\n    mean=[123.675, 116.28, 103.53], std=[58.3"
  },
  {
    "path": "code/configs/_base_/datasets/coco_instance.py",
    "chars": 1718,
    "preview": "dataset_type = 'CocoDataset'\ndata_root = 'data/coco/'\nimg_norm_cfg = dict(\n    mean=[123.675, 116.28, 103.53], std=[58.3"
  },
  {
    "path": "code/configs/_base_/datasets/coco_instance_semantic.py",
    "chars": 1903,
    "preview": "dataset_type = 'CocoDataset'\ndata_root = 'data/coco/'\nimg_norm_cfg = dict(\n    mean=[123.675, 116.28, 103.53], std=[58.3"
  },
  {
    "path": "code/configs/_base_/datasets/coco_lsvr.py",
    "chars": 1786,
    "preview": "dataset_type = 'CocoDataset'\ndata_root = '/home/ma-user/work/duankaiwen/coco/'\nimg_norm_cfg = dict(\n    mean=[123.675, 1"
  },
  {
    "path": "code/configs/_base_/datasets/coco_pose.py",
    "chars": 1794,
    "preview": "dataset_type = 'CocoPoseDataset'\ndata_root = '/home/ma-user/work/duankaiwen/coco/'\nimg_norm_cfg = dict(\n    mean=[123.67"
  },
  {
    "path": "code/configs/_base_/datasets/deepfashion.py",
    "chars": 1888,
    "preview": "# dataset settings\ndataset_type = 'DeepFashionDataset'\ndata_root = 'data/DeepFashion/In-shop/'\nimg_norm_cfg = dict(\n    "
  },
  {
    "path": "code/configs/_base_/datasets/lvis_instance.py",
    "chars": 736,
    "preview": "_base_ = 'coco_instance.py'\ndataset_type = 'LVISDataset'\ndata_root = 'data/lvis/'\ndata = dict(\n    samples_per_gpu=2,\n  "
  },
  {
    "path": "code/configs/_base_/datasets/voc0712.py",
    "chars": 1916,
    "preview": "# dataset settings\ndataset_type = 'VOCDataset'\ndata_root = 'data/VOCdevkit/'\nimg_norm_cfg = dict(\n    mean=[123.675, 116"
  },
  {
    "path": "code/configs/_base_/datasets/wider_face.py",
    "chars": 2011,
    "preview": "# dataset settings\ndataset_type = 'WIDERFaceDataset'\ndata_root = 'data/WIDERFace/'\nimg_norm_cfg = dict(mean=[123.675, 11"
  },
  {
    "path": "code/configs/_base_/default_runtime.py",
    "chars": 319,
    "preview": "checkpoint_config = dict(interval=1)\n# yapf:disable\nlog_config = dict(\n    interval=50,\n    hooks=[\n        dict(type='T"
  },
  {
    "path": "code/configs/_base_/models/cascade_mask_rcnn_r50_fpn.py",
    "chars": 6590,
    "preview": "# model settings\nmodel = dict(\n    type='CascadeRCNN',\n    pretrained='torchvision://resnet50',\n    backbone=dict(\n     "
  },
  {
    "path": "code/configs/_base_/models/cascade_rcnn_r50_fpn.py",
    "chars": 5972,
    "preview": "# model settings\nmodel = dict(\n    type='CascadeRCNN',\n    pretrained='torchvision://resnet50',\n    backbone=dict(\n     "
  },
  {
    "path": "code/configs/_base_/models/fast_rcnn_r50_fpn.py",
    "chars": 1903,
    "preview": "# model settings\nmodel = dict(\n    type='FastRCNN',\n    pretrained='torchvision://resnet50',\n    backbone=dict(\n        "
  },
  {
    "path": "code/configs/_base_/models/faster_rcnn_r50_caffe_c4.py",
    "chars": 3452,
    "preview": "# model settings\nnorm_cfg = dict(type='BN', requires_grad=False)\nmodel = dict(\n    type='FasterRCNN',\n    pretrained='op"
  },
  {
    "path": "code/configs/_base_/models/faster_rcnn_r50_fpn.py",
    "chars": 3380,
    "preview": "model = dict(\n    type='FasterRCNN',\n    pretrained='torchvision://resnet50',\n    backbone=dict(\n        type='ResNet',\n"
  },
  {
    "path": "code/configs/_base_/models/mask_rcnn_r50_caffe_c4.py",
    "chars": 3827,
    "preview": "# model settings\nnorm_cfg = dict(type='BN', requires_grad=False)\nmodel = dict(\n    type='MaskRCNN',\n    pretrained='open"
  },
  {
    "path": "code/configs/_base_/models/mask_rcnn_r50_fpn.py",
    "chars": 3838,
    "preview": "# model settings\nmodel = dict(\n    type='MaskRCNN',\n    pretrained='torchvision://resnet50',\n    backbone=dict(\n        "
  },
  {
    "path": "code/configs/_base_/models/retinanet_r50_fpn.py",
    "chars": 1651,
    "preview": "# model settings\nmodel = dict(\n    type='RetinaNet',\n    pretrained='torchvision://resnet50',\n    backbone=dict(\n       "
  },
  {
    "path": "code/configs/_base_/models/rpn_r50_caffe_c4.py",
    "chars": 1655,
    "preview": "# model settings\nmodel = dict(\n    type='RPN',\n    pretrained='open-mmlab://detectron2/resnet50_caffe',\n    backbone=dic"
  },
  {
    "path": "code/configs/_base_/models/rpn_r50_fpn.py",
    "chars": 1699,
    "preview": "# model settings\nmodel = dict(\n    type='RPN',\n    pretrained='torchvision://resnet50',\n    backbone=dict(\n        type="
  },
  {
    "path": "code/configs/_base_/models/ssd300.py",
    "chars": 1389,
    "preview": "# model settings\ninput_size = 300\nmodel = dict(\n    type='SingleStageDetector',\n    pretrained='open-mmlab://vgg16_caffe"
  },
  {
    "path": "code/configs/_base_/schedules/schedule_1x.py",
    "chars": 283,
    "preview": "# optimizer\noptimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)\noptimizer_config = dict(grad_clip=N"
  },
  {
    "path": "code/configs/_base_/schedules/schedule_20e.py",
    "chars": 284,
    "preview": "# optimizer\noptimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)\noptimizer_config = dict(grad_clip=N"
  },
  {
    "path": "code/configs/_base_/schedules/schedule_2x.py",
    "chars": 284,
    "preview": "# optimizer\noptimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)\noptimizer_config = dict(grad_clip=N"
  },
  {
    "path": "code/configs/lsnet/lsnet_bbox_cpv_res2_101_fpn_dconv_c3-c5_mstrain_2x_coco.py",
    "chars": 1953,
    "preview": "_base_ = './lsnet_bbox_cpv_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py'\nmodel = dict(\n    pretrained='../checkpoints/pretrai"
  },
  {
    "path": "code/configs/lsnet/lsnet_bbox_cpv_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py",
    "chars": 4336,
    "preview": "_base_ = './lsnet_bbox_r50_fpn_mstrain_2x_coco.py'\nnorm_cfg = dict(type='GN', num_groups=32, requires_grad=True)\nmodel ="
  },
  {
    "path": "code/configs/lsnet/lsnet_bbox_r50_fpn_1x_coco.py",
    "chars": 2113,
    "preview": "_base_ = [\n    '../_base_/datasets/coco_lsvr.py',\n    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.p"
  },
  {
    "path": "code/configs/lsnet/lsnet_bbox_r50_fpn_mstrain_2x_coco.py",
    "chars": 791,
    "preview": "_base_ = './lsnet_bbox_r50_fpn_1x_coco.py'\n# learning policy\nlr_config = dict(step=[16, 22])\ntotal_epochs = 24\n#multi-sc"
  },
  {
    "path": "code/configs/lsnet/lsnet_bbox_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py.py",
    "chars": 1777,
    "preview": "_base_ = './lsnet_bbox_r50_fpn_mstrain_2x_coco.py'\nmodel = dict(\n    pretrained='../checkpoints/pretrained/resnext101_64"
  },
  {
    "path": "code/configs/lsnet/lsnet_bbox_x101_fpn_mstrain_2x_coco.py",
    "chars": 448,
    "preview": "_base_ = './lsnet_bbox_r50_fpn_mstrain_2x_coco.py'\nmodel = dict(\n    pretrained='../checkpoints/pretrained/resnext101_64"
  },
  {
    "path": "code/configs/lsnet/lsnet_pose_bbox_r50_fpn_1x_coco.py",
    "chars": 2312,
    "preview": "_base_ = [\n    '../_base_/datasets/coco_pose.py',\n    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.p"
  },
  {
    "path": "code/configs/lsnet/lsnet_pose_bbox_r50_fpn_mstrain_2x_coco.py",
    "chars": 817,
    "preview": "_base_ = './lsnet_pose_bbox_r50_fpn_1x_coco.py'\n# learning policy\nlr_config = dict(step=[16, 22])\ntotal_epochs = 24\n#mul"
  },
  {
    "path": "code/configs/lsnet/lsnet_pose_bbox_res2_101_fpn_dconv_c3-c5_mstrain_2x_coco.py",
    "chars": 2495,
    "preview": "_base_ = './lsnet_pose_bbox_r50_fpn_mstrain_2x_coco.py'\n\nlr_config = dict(step=[54, 56])\ntotal_epochs = 60\n\nmodel = dict"
  },
  {
    "path": "code/configs/lsnet/lsnet_pose_bbox_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py",
    "chars": 2597,
    "preview": "_base_ = './lsnet_pose_bbox_r50_fpn_mstrain_2x_coco.py'\n\nlr_config = dict(step=[54, 56])\ntotal_epochs = 60\n\nmodel = dict"
  },
  {
    "path": "code/configs/lsnet/lsnet_pose_kbox_res2_101_fpn_dconv_c3-c5_mstrain_2x_coco.py",
    "chars": 2982,
    "preview": "_base_ = './lsnet_pose_bbox_res2_101_fpn_dconv_c3-c5_mstrain_2x_coco.py'\n\nlr_config = dict(step=[12, 20])\ntotal_epochs ="
  },
  {
    "path": "code/configs/lsnet/lsnet_pose_kbox_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py",
    "chars": 2960,
    "preview": "_base_ = './lsnet_pose_bbox_x101_fpn_dconv_c3-c5_mstrain_2x_coco.py'\n\nlr_config = dict(step=[12, 20])\ntotal_epochs = 24\n"
  },
  {
    "path": "code/configs/lsnet/lsnet_segm_r50_fpn_1x_coco.py",
    "chars": 2832,
    "preview": "_base_ = [\n    '../_base_/datasets/coco_lsvr.py',\n    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.p"
  },
  {
    "path": "code/configs/lsnet/lsnet_segm_r50_fpn_mstrain_2x_coco.py",
    "chars": 899,
    "preview": "_base_ = './lsnet_segm_r50_fpn_1x_coco.py'\n# learning policy\nlr_config = dict(step=[16, 22])\ntotal_epochs = 24\n#multi-sc"
  },
  {
    "path": "code/configs/lsnet/lsnet_segm_res2_101_fpn_dconv_c3-c5_mstrain_30e_coco.py",
    "chars": 1709,
    "preview": "_base_ = './lsnet_segm_r50_fpn_mstrain_2x_coco.py'\n\nlr_config = dict(step=[28, 30])\ntotal_epochs = 30\n\nmodel = dict(\n   "
  },
  {
    "path": "code/configs/lsnet/lsnet_segm_x101_fpn_dconv_c3-c5_mstrain_30e_coco.py",
    "chars": 1829,
    "preview": "_base_ = './lsnet_segm_r50_fpn_mstrain_2x_coco.py'\n\nlr_config = dict(step=[28, 30])\ntotal_epochs = 30\n\nmodel = dict(\n   "
  },
  {
    "path": "code/configs/lsnet/lsnet_segm_x101_fpn_mstrain_30e_coco.py",
    "chars": 501,
    "preview": "_base_ = './lsnet_segm_r50_fpn_mstrain_2x_coco.py'\n\nlr_config = dict(step=[28, 30])\ntotal_epochs = 30\n\nmodel = dict(\n   "
  },
  {
    "path": "code/docker/Dockerfile",
    "chars": 740,
    "preview": "ARG PYTORCH=\"1.5\"\nARG CUDA=\"10.1\"\nARG CUDNN=\"7\"\n\nFROM pytorch/pytorch:${PYTORCH}-cuda${CUDA}-cudnn${CUDNN}-devel\n\nENV TO"
  },
  {
    "path": "code/docs/Makefile",
    "chars": 634,
    "preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the "
  },
  {
    "path": "code/docs/api.rst",
    "chars": 1333,
    "preview": "API Reference\n=================\n\nmmdet.apis\n--------------\n.. automodule:: mmdet.apis\n    :members:\n\nmmdet.core\n--------"
  },
  {
    "path": "code/docs/changelog.md",
    "chars": 18869,
    "preview": "## Changelog\n\n### v2.2.0 (1/7/2020)\n\n**Highlights**\n- Support new methods: [DetectoRS](https://arxiv.org/abs/2006.02334)"
  },
  {
    "path": "code/docs/compatibility.md",
    "chars": 7143,
    "preview": "# Compatibility with MMDetection 1.x\n\nMMDetection 2.0 goes through a big refactoring and addresses many legacy issues. I"
  },
  {
    "path": "code/docs/conf.py",
    "chars": 2653,
    "preview": "# Configuration file for the Sphinx documentation builder.\n#\n# This file only contains a selection of the most common op"
  },
  {
    "path": "code/docs/config.md",
    "chars": 30323,
    "preview": "# Config System\nWe incorporate modular and inheritance design into our config system, which is convenient to conduct var"
  },
  {
    "path": "code/docs/getting_started.md",
    "chars": 16991,
    "preview": "# Getting Started\n\nThis page provides basic tutorials about the usage of MMDetection.\nFor installation instructions, ple"
  },
  {
    "path": "code/docs/index.rst",
    "chars": 424,
    "preview": "Welcome to MMDetection's documentation!\n=======================================\n\n.. toctree::\n   :maxdepth: 2\n\n   instal"
  },
  {
    "path": "code/docs/install.md",
    "chars": 5144,
    "preview": "## Installation\n\n### Requirements\n\n- Linux or macOS (Windows is not currently officially supported)\n- Python 3.6+\n- PyTo"
  },
  {
    "path": "code/docs/make.bat",
    "chars": 760,
    "preview": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-bu"
  },
  {
    "path": "code/docs/model_zoo.md",
    "chars": 12370,
    "preview": "# Benchmark and Model Zoo\n\n## Mirror sites\n\nWe use AWS as the main site to host our model zoo, and maintain a mirror on "
  },
  {
    "path": "code/docs/projects.md",
    "chars": 5617,
    "preview": "# Projects\n\nThere are many projects built upon MMDetection.\nSome of them are published in top-tier conferences (CVPR, IC"
  },
  {
    "path": "code/docs/robustness_benchmarking.md",
    "chars": 5502,
    "preview": "# Corruption Benchmarking\n\n## Introduction\n\nWe provide tools to test object detection and instance segmentation models o"
  },
  {
    "path": "code/docs/tutorials/data_pipeline.md",
    "chars": 4892,
    "preview": "# Tutorial 3: Custom Data Pipelines\n\n## Design of Data pipelines\n\nFollowing typical conventions, we use `Dataset` and `D"
  },
  {
    "path": "code/docs/tutorials/finetune.md",
    "chars": 3804,
    "preview": "# Tutorial 1: Finetuning Models\n\nDetectors pre-trained on the COCO dataset can serve as a good pre-trained model for oth"
  },
  {
    "path": "code/docs/tutorials/new_dataset.md",
    "chars": 9863,
    "preview": "# Tutorial 2: Adding New Dataset\n\n## Customize datasets by reorganizing data\n\n### Reorganize dataset to existing format\n"
  },
  {
    "path": "code/docs/tutorials/new_modules.md",
    "chars": 11629,
    "preview": "# Tutorial 4: Adding New Modules\n\n## Customize optimizer\n\nA customized optimizer could be defined as following.\n\nAssume "
  },
  {
    "path": "code/mmcv/.dockerignore",
    "chars": 65,
    "preview": ".git\n.gitignore\n*.egg-info\n.eggs/\n.mypy-cache\npip-wheel-metadata\n"
  },
  {
    "path": "code/mmcv/.github/workflows/build.yml",
    "chars": 1777,
    "preview": "# This workflow will install Python dependencies, run tests and lint with a variety of Python versions\n# For more inform"
  },
  {
    "path": "code/mmcv/.github/workflows/publish-to-pypi.yml",
    "chars": 506,
    "preview": "name: deploy\n\non: push\n\njobs:\n  build-n-publish:\n    runs-on: ubuntu-latest\n    if: startsWith(github.event.ref, 'refs/t"
  },
  {
    "path": "code/mmcv/.gitignore",
    "chars": 1304,
    "preview": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# C extensions\n*.so\n\n# Distribution / packagi"
  },
  {
    "path": "code/mmcv/.pre-commit-config.yaml",
    "chars": 784,
    "preview": "exclude: ^tests/data/\nrepos:\n  - repo: https://gitlab.com/pycqa/flake8.git\n    rev: 3.8.0\n    hooks:\n      - id: flake8\n"
  },
  {
    "path": "code/mmcv/.readthedocs.yml",
    "chars": 125,
    "preview": "version: 2\n\npython:\n  version: 3.7\n  install:\n    - requirements: requirements.txt\n    - requirements: docs/requirements"
  },
  {
    "path": "code/mmcv/CONTRIBUTING.md",
    "chars": 1609,
    "preview": "# Contributing to MMCV\n\nAll kinds of contributions are welcome, including but not limited to the following.\n\n- Fixes (ty"
  },
  {
    "path": "code/mmcv/Dockerfile",
    "chars": 67,
    "preview": "FROM python:3.7\n\nWORKDIR /mmcv\n\nCOPY . /mmcv\n\nRUN pip install -e .\n"
  },
  {
    "path": "code/mmcv/LICENSE",
    "chars": 11415,
    "preview": "Copyright (c) Open-MMLab. All rights reserved.\n\n                                 Apache License\n                        "
  },
  {
    "path": "code/mmcv/MANIFEST.in",
    "chars": 163,
    "preview": "include mmcv/video/optflow_warp/*.hpp mmcv/video/optflow_warp/*.pyx\ninclude requirements.txt\ninclude mmcv/model_zoo/open"
  },
  {
    "path": "code/mmcv/README.rst",
    "chars": 1605,
    "preview": "MMCV\n====\n\n.. image:: https://img.shields.io/pypi/v/mmcv\n  :target: https://pypi.org/project/mmcv\n\n.. image:: https://gi"
  },
  {
    "path": "code/mmcv/docs/Makefile",
    "chars": 581,
    "preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS    =\nSPHI"
  },
  {
    "path": "code/mmcv/docs/api.rst",
    "chars": 510,
    "preview": "API Documentation\n=================\n\n\nfileio\n-------\n.. automodule:: mmcv.fileio\n    :members:\n\nimage\n------\n.. automodu"
  },
  {
    "path": "code/mmcv/docs/cnn.md",
    "chars": 2694,
    "preview": "## CNN\n\nWe provide some building bricks for CNNs, includeing layer building, module bundles and weight initialization.\n\n"
  },
  {
    "path": "code/mmcv/docs/conf.py",
    "chars": 5485,
    "preview": "#\n# Configuration file for the Sphinx documentation builder.\n#\n# This file does only contain a selection of the most com"
  },
  {
    "path": "code/mmcv/docs/image.md",
    "chars": 3837,
    "preview": "## Image\n\nThis module provides some image processing methods, which requires `opencv` to be installed.\n\n### Read/Write/S"
  },
  {
    "path": "code/mmcv/docs/index.rst",
    "chars": 268,
    "preview": ".. include:: ../README.rst\n\nContents\n========\n\n.. toctree::\n   :maxdepth: 2\n\n   io.md\n   image.md\n   video.md\n   visuali"
  },
  {
    "path": "code/mmcv/docs/io.md",
    "chars": 2989,
    "preview": "## File IO\n\nThis module provides two universal API to load and dump files of different formats.\n\n### Load and dump data\n"
  },
  {
    "path": "code/mmcv/docs/make.bat",
    "chars": 752,
    "preview": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-bu"
  },
  {
    "path": "code/mmcv/docs/model_zoo.md",
    "chars": 1633,
    "preview": "## Model Zoo\nBesides torchvision pre-trained models, we also provide pre-trained models of following CNN:\n* VGG Caffe\n* "
  },
  {
    "path": "code/mmcv/docs/requirements.txt",
    "chars": 6,
    "preview": "torch\n"
  },
  {
    "path": "code/mmcv/docs/runner.md",
    "chars": 169,
    "preview": "## Runner\n\nThe runner module aims to help users to start training with less code, while stays\nflexible and configurable."
  },
  {
    "path": "code/mmcv/docs/utils.md",
    "chars": 4003,
    "preview": "## Utils\n\n### Config\n\n`Config` class is used for manipulating config and config files. It supports\nloading configs from "
  },
  {
    "path": "code/mmcv/docs/video.md",
    "chars": 3029,
    "preview": "## Video\n\nThis module provides the following functionalities.\n\n- A `VideoReader` class with friendly apis to read and co"
  },
  {
    "path": "code/mmcv/docs/visualization.md",
    "chars": 527,
    "preview": "## Visualization\n\n`mmcv` can show images and annotations (currently supported types include bounding boxes).\n\n```python\n"
  },
  {
    "path": "code/mmcv/examples/config_cifar10.py",
    "chars": 855,
    "preview": "# model settings\nmodel = 'resnet18'\n# dataset settings\ndata_root = '/mnt/SSD/dataset/cifar10'\nmean = [0.4914, 0.4822, 0."
  },
  {
    "path": "code/mmcv/examples/dist_train_cifar10.sh",
    "chars": 151,
    "preview": "#!/usr/bin/env bash\n\nPYTHON=${PYTHON:-\"python\"}\n\n$PYTHON -m torch.distributed.launch --nproc_per_node=$2 train_cifar10.p"
  },
  {
    "path": "code/mmcv/examples/resnet_cifar.py",
    "chars": 4139,
    "preview": "# copied from\n# https://github.com/kuangliu/pytorch-cifar/blob/master/models/resnet.py\n\nimport torch.nn as nn\nimport tor"
  },
  {
    "path": "code/mmcv/examples/train_cifar10.py",
    "chars": 5418,
    "preview": "import logging\nimport os\nfrom argparse import ArgumentParser\nfrom collections import OrderedDict\n\nimport resnet_cifar\nim"
  },
  {
    "path": "code/mmcv/mmcv/__init__.py",
    "chars": 356,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\n# flake8: noqa\nfrom .arraymisc import *\nfrom .fileio import *\nfrom .ima"
  },
  {
    "path": "code/mmcv/mmcv/arraymisc/__init__.py",
    "chars": 134,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .quantization import dequantize, quantize\n\n__all__ = ['quantize', "
  },
  {
    "path": "code/mmcv/mmcv/arraymisc/quantization.py",
    "chars": 1825,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport numpy as np\n\n\ndef quantize(arr, min_val, max_val, levels, dtype="
  },
  {
    "path": "code/mmcv/mmcv/cnn/__init__.py",
    "chars": 1245,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .alexnet import AlexNet\nfrom .bricks import (ACTIVATION_LAYERS, CO"
  },
  {
    "path": "code/mmcv/mmcv/cnn/alexnet.py",
    "chars": 1980,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport logging\n\nimport torch.nn as nn\n\nfrom ..runner import load_checkp"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/__init__.py",
    "chars": 844,
    "preview": "from .activation import build_activation_layer\nfrom .conv import build_conv_layer\nfrom .conv_module import ConvModule\nfr"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/activation.py",
    "chars": 648,
    "preview": "import torch.nn as nn\n\nfrom mmcv.utils import build_from_cfg\nfrom .registry import ACTIVATION_LAYERS\n\nfor module in [\n  "
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/conv.py",
    "chars": 1404,
    "preview": "from torch import nn\n\nfrom .registry import CONV_LAYERS\n\nCONV_LAYERS.register_module('Conv1d', module=nn.Conv1d)\nCONV_LA"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/conv_module.py",
    "chars": 7653,
    "preview": "import warnings\n\nimport torch.nn as nn\n\nfrom ..utils import constant_init, kaiming_init\nfrom .activation import build_ac"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/hsigmoid.py",
    "chars": 441,
    "preview": "import torch.nn as nn\n\nfrom .registry import ACTIVATION_LAYERS\n\n\n@ACTIVATION_LAYERS.register_module()\nclass HSigmoid(nn."
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/hswish.py",
    "chars": 565,
    "preview": "import torch.nn as nn\n\nfrom .registry import ACTIVATION_LAYERS\n\n\n@ACTIVATION_LAYERS.register_module()\nclass HSwish(nn.Mo"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/non_local.py",
    "chars": 8338,
    "preview": "from abc import ABCMeta\n\nimport torch\nimport torch.nn as nn\n\nfrom ..utils import constant_init, normal_init\nfrom .conv_m"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/norm.py",
    "chars": 5015,
    "preview": "import inspect\n\nimport torch.nn as nn\n\nfrom mmcv.utils import is_tuple_of\nfrom mmcv.utils.parrots_wrapper import SyncBat"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/padding.py",
    "chars": 1079,
    "preview": "import torch.nn as nn\n\nfrom .registry import PADDING_LAYERS\n\nPADDING_LAYERS.register_module('zero', module=nn.ZeroPad2d)"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/registry.py",
    "chars": 244,
    "preview": "from mmcv.utils import Registry\n\nCONV_LAYERS = Registry('conv layer')\nNORM_LAYERS = Registry('norm layer')\nACTIVATION_LA"
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/scale.py",
    "chars": 529,
    "preview": "import torch\nimport torch.nn as nn\n\n\nclass Scale(nn.Module):\n    \"\"\"A learnable scale parameter.\n\n    This layer scales "
  },
  {
    "path": "code/mmcv/mmcv/cnn/bricks/upsample.py",
    "chars": 2896,
    "preview": "import torch.nn as nn\nimport torch.nn.functional as F\n\nfrom ..utils import xavier_init\nfrom .registry import UPSAMPLE_LA"
  },
  {
    "path": "code/mmcv/mmcv/cnn/resnet.py",
    "chars": 9943,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport logging\n\nimport torch.nn as nn\nimport torch.utils.checkpoint as "
  },
  {
    "path": "code/mmcv/mmcv/cnn/utils/__init__.py",
    "chars": 469,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .flops_counter import get_model_complexity_info\nfrom .weight_init "
  },
  {
    "path": "code/mmcv/mmcv/cnn/utils/flops_counter.py",
    "chars": 21001,
    "preview": "# Modified from flops-counter.pytorch by Vladislav Sovrasov\n# original repo: https://github.com/sovrasov/flops-counter.p"
  },
  {
    "path": "code/mmcv/mmcv/cnn/utils/weight_init.py",
    "chars": 2203,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport numpy as np\nimport torch.nn as nn\n\n\ndef constant_init(module, va"
  },
  {
    "path": "code/mmcv/mmcv/cnn/vgg.py",
    "chars": 6041,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport logging\n\nimport torch.nn as nn\n\nfrom ..runner import load_checkp"
  },
  {
    "path": "code/mmcv/mmcv/fileio/__init__.py",
    "chars": 479,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .file_client import BaseStorageBackend, FileClient\nfrom .handlers "
  },
  {
    "path": "code/mmcv/mmcv/fileio/file_client.py",
    "chars": 9651,
    "preview": "import inspect\nimport warnings\nfrom abc import ABCMeta, abstractmethod\n\n\nclass BaseStorageBackend(metaclass=ABCMeta):\n  "
  },
  {
    "path": "code/mmcv/mmcv/fileio/handlers/__init__.py",
    "chars": 279,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .base import BaseFileHandler\nfrom .json_handler import JsonHandler"
  },
  {
    "path": "code/mmcv/mmcv/fileio/handlers/base.py",
    "chars": 689,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom abc import ABCMeta, abstractmethod\n\n\nclass BaseFileHandler(metacla"
  },
  {
    "path": "code/mmcv/mmcv/fileio/handlers/json_handler.py",
    "chars": 381,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport json\n\nfrom .base import BaseFileHandler\n\n\nclass JsonHandler(Base"
  },
  {
    "path": "code/mmcv/mmcv/fileio/handlers/pickle_handler.py",
    "chars": 796,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport pickle\n\nfrom .base import BaseFileHandler\n\n\nclass PickleHandler("
  },
  {
    "path": "code/mmcv/mmcv/fileio/handlers/yaml_handler.py",
    "chars": 666,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport yaml\n\ntry:\n    from yaml import CLoader as Loader, CDumper as Du"
  },
  {
    "path": "code/mmcv/mmcv/fileio/io.py",
    "chars": 3739,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom pathlib import Path\n\nfrom ..utils import is_list_of, is_str\nfrom ."
  },
  {
    "path": "code/mmcv/mmcv/fileio/parse.py",
    "chars": 1680,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\ndef list_from_file(filename, prefix='', offset=0, max_num=0):\n    \"\"\"Lo"
  },
  {
    "path": "code/mmcv/mmcv/image/__init__.py",
    "chars": 1169,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .colorspace import (bgr2gray, bgr2hls, bgr2hsv, bgr2rgb, bgr2ycbcr"
  },
  {
    "path": "code/mmcv/mmcv/image/colorspace.py",
    "chars": 9908,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport cv2\nimport numpy as np\n\n\ndef imconvert(img, src, dst):\n    \"\"\"Co"
  },
  {
    "path": "code/mmcv/mmcv/image/geometric.py",
    "chars": 11276,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport cv2\nimport numpy as np\n\n\ndef _scale_size(size, scale):\n    \"\"\"Re"
  },
  {
    "path": "code/mmcv/mmcv/image/io.py",
    "chars": 8352,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport io\nimport os.path as osp\nfrom pathlib import Path\n\nimport cv2\nim"
  },
  {
    "path": "code/mmcv/mmcv/image/photometric.py",
    "chars": 2528,
    "preview": "import cv2\nimport numpy as np\n\n\ndef imnormalize(img, mean, std, to_rgb=True):\n    \"\"\"Normalize an image with mean and st"
  },
  {
    "path": "code/mmcv/mmcv/model_zoo/deprecated.json",
    "chars": 217,
    "preview": "{\n  \"resnet50_caffe\": \"detectron/resnet50_caffe\",\n  \"resnet50_caffe_bgr\": \"detectron2/resnet50_caffe_bgr\",\n  \"resnet101_"
  },
  {
    "path": "code/mmcv/mmcv/model_zoo/open_mmlab.json",
    "chars": 4757,
    "preview": "{\n  \"vgg16_caffe\": \"https://open-mmlab.s3.ap-northeast-2.amazonaws.com/pretrain/third_party/vgg16_caffe-292e1171.pth\",\n "
  },
  {
    "path": "code/mmcv/mmcv/parallel/__init__.py",
    "chars": 506,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .collate import collate\nfrom .data_container import DataContainer\n"
  },
  {
    "path": "code/mmcv/mmcv/parallel/_functions.py",
    "chars": 2598,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport torch\nfrom torch.nn.parallel._functions import _get_stream\n\n\ndef"
  },
  {
    "path": "code/mmcv/mmcv/parallel/collate.py",
    "chars": 3715,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom collections.abc import Mapping, Sequence\n\nimport torch\nimport torc"
  },
  {
    "path": "code/mmcv/mmcv/parallel/data_container.py",
    "chars": 2366,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport functools\n\nimport torch\n\n\ndef assert_tensor_type(func):\n\n    @fu"
  },
  {
    "path": "code/mmcv/mmcv/parallel/data_parallel.py",
    "chars": 2057,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom itertools import chain\n\nfrom torch.nn.parallel import DataParallel"
  },
  {
    "path": "code/mmcv/mmcv/parallel/distributed.py",
    "chars": 3501,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport torch\nfrom torch.nn.parallel.distributed import (DistributedData"
  },
  {
    "path": "code/mmcv/mmcv/parallel/distributed_deprecated.py",
    "chars": 2720,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport torch\nimport torch.distributed as dist\nimport torch.nn as nn\nfro"
  },
  {
    "path": "code/mmcv/mmcv/parallel/registry.py",
    "chars": 264,
    "preview": "from torch.nn.parallel import DataParallel, DistributedDataParallel\n\nfrom mmcv.utils import Registry\n\nMODULE_WRAPPERS = "
  },
  {
    "path": "code/mmcv/mmcv/parallel/scatter_gather.py",
    "chars": 2124,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport torch\nfrom torch.nn.parallel._functions import Scatter as OrigSc"
  },
  {
    "path": "code/mmcv/mmcv/parallel/utils.py",
    "chars": 709,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .registry import MODULE_WRAPPERS\n\n\ndef is_module_wrapper(module):\n"
  },
  {
    "path": "code/mmcv/mmcv/runner/__init__.py",
    "chars": 1748,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .base_runner import BaseRunner\nfrom .checkpoint import (_load_chec"
  },
  {
    "path": "code/mmcv/mmcv/runner/base_runner.py",
    "chars": 14659,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport logging\nimport os.path as osp\nimport warnings\nfrom abc import AB"
  },
  {
    "path": "code/mmcv/mmcv/runner/checkpoint.py",
    "chars": 10515,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport os\nimport os.path as osp\nimport pkgutil\nimport time\nimport warni"
  },
  {
    "path": "code/mmcv/mmcv/runner/dist_utils.py",
    "chars": 2838,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport functools\nimport os\nimport subprocess\n\nimport torch\nimport torch"
  },
  {
    "path": "code/mmcv/mmcv/runner/epoch_based_runner.py",
    "chars": 6886,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport os.path as osp\nimport time\nimport warnings\n\nimport torch\n\nimport"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/__init__.py",
    "chars": 848,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .checkpoint import CheckpointHook\nfrom .closure import ClosureHook"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/checkpoint.py",
    "chars": 3488,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport os\n\nfrom ..dist_utils import master_only\nfrom .hook import HOOKS"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/closure.py",
    "chars": 270,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .hook import HOOKS, Hook\n\n\n@HOOKS.register_module()\nclass ClosureH"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/hook.py",
    "chars": 1428,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom mmcv.utils import Registry\n\nHOOKS = Registry('hook')\n\n\nclass Hook:"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/iter_timer.py",
    "chars": 447,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport time\n\nfrom .hook import HOOKS, Hook\n\n\n@HOOKS.register_module()\nc"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/logger/__init__.py",
    "chars": 399,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .base import LoggerHook\nfrom .mlflow import MlflowLoggerHook\nfrom "
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/logger/base.py",
    "chars": 2148,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom abc import ABCMeta, abstractmethod\n\nfrom ..hook import Hook\n\n\nclas"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/logger/mlflow.py",
    "chars": 2739,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport numbers\n\nfrom ...dist_utils import master_only\nfrom ..hook impor"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/logger/pavi.py",
    "chars": 3135,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport numbers\nimport os.path as osp\n\nimport numpy as np\nimport torch\n\n"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/logger/tensorboard.py",
    "chars": 2810,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport os.path as osp\n\nfrom mmcv.utils import TORCH_VERSION\nfrom ...dis"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/logger/text.py",
    "chars": 6844,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport datetime\nimport os.path as osp\nfrom collections import OrderedDi"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/logger/wandb.py",
    "chars": 1614,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport numbers\n\nfrom ...dist_utils import master_only\nfrom ..hook impor"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/lr_updater.py",
    "chars": 15289,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom math import cos, pi\n\nfrom .hook import HOOKS, Hook\n\n\nclass LrUpdat"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/memory.py",
    "chars": 658,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport torch\n\nfrom .hook import HOOKS, Hook\n\n\n@HOOKS.register_module()\n"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/momentum_updater.py",
    "chars": 8155,
    "preview": "from .hook import HOOKS, Hook\nfrom .lr_updater import annealing_cos\n\n\nclass MomentumUpdaterHook(Hook):\n\n    def __init__"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/optimizer.py",
    "chars": 970,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom torch.nn.utils import clip_grad\n\nfrom .hook import HOOKS, Hook\n\n\n@"
  },
  {
    "path": "code/mmcv/mmcv/runner/hooks/sampler_seed.py",
    "chars": 235,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom .hook import HOOKS, Hook\n\n\n@HOOKS.register_module()\nclass DistSamp"
  },
  {
    "path": "code/mmcv/mmcv/runner/iter_based_runner.py",
    "chars": 8572,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nimport os.path as osp\nimport time\n\nimport torch\nfrom torch.optim import"
  },
  {
    "path": "code/mmcv/mmcv/runner/log_buffer.py",
    "chars": 1192,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom collections import OrderedDict\n\nimport numpy as np\n\n\nclass LogBuff"
  },
  {
    "path": "code/mmcv/mmcv/runner/optimizer/__init__.py",
    "chars": 322,
    "preview": "from .builder import (OPTIMIZER_BUILDERS, OPTIMIZERS, build_optimizer,\n                      build_optimizer_constructor"
  },
  {
    "path": "code/mmcv/mmcv/runner/optimizer/builder.py",
    "chars": 1298,
    "preview": "import copy\nimport inspect\n\nimport torch\n\nfrom ...utils import Registry, build_from_cfg\n\nOPTIMIZERS = Registry('optimize"
  },
  {
    "path": "code/mmcv/mmcv/runner/optimizer/default_constructor.py",
    "chars": 9618,
    "preview": "import warnings\n\nimport torch\nfrom torch.nn import GroupNorm, LayerNorm\n\nfrom mmcv.utils import _BatchNorm, _InstanceNor"
  },
  {
    "path": "code/mmcv/mmcv/runner/priority.py",
    "chars": 1385,
    "preview": "# Copyright (c) Open-MMLab. All rights reserved.\nfrom enum import Enum\n\n\nclass Priority(Enum):\n    \"\"\"Hook priority leve"
  }
]

// ... and 461 more files (download for full content)