Initial commit

docs/en/advanced_guides/how_to.md

+This tutorial collects answers to any `How to xxx with MMDetection`. Feel free to update this doc if you meet new questions about `How to` and find the answers!
+
+# Use backbone network through MMPretrain
+
+The model registry in MMDet, MMPreTrain, MMSeg all inherit from the root registry in MMEngine. This allows these repositories to directly use the modules already implemented by each other. Therefore, users can use backbone networks from MMPretrain in MMDetection without implementing a network that already exists in MMPretrain.
+
+## Use backbone network implemented in MMPretrain
+
+Suppose you want to use `MobileNetV3-small` as the backbone network of `RetinaNet`, the example config is as the following.
+
+```python
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+# please install mmpretrain
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+pretrained = 'https://download.openmmlab.com/mmclassification/v0/mobilenet_v3/convert/mobilenet_v3_small-8427ecf0.pth'
+model = dict(
+    backbone=dict(
+        _delete_=True, # Delete the backbone field in _base_
+        type='mmpretrain.MobileNetV3', # Using MobileNetV3 from mmpretrain
+        arch='small',
+        out_indices=(3, 8, 11), # Modify out_indices
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint=pretrained,
+            prefix='backbone.')), # The pre-trained weights of backbone network in mmpretrain have prefix='backbone.'. The prefix in the keys will be removed so that these weights can be normally loaded.
+    # Modify in_channels
+    neck=dict(in_channels=[24, 48, 96], start_level=0))
+```
+
+## Use backbone network in TIMM through MMPretrain
+
+MMPretrain also provides a wrapper for the PyTorch Image Models (timm) backbone network, users can directly use the backbone network in timm through MMPretrain. Suppose you want to use [EfficientNet-B1](../../../configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py) as the backbone network of RetinaNet, the example config is as the following.
+
+```python
+# https://github.com/open-mmlab/mmdetection/blob/main/configs/timm_example/retinanet_timm-efficientnet-b1_fpn_1x_coco.py
+
+_base_ = [
+    '../_base_/models/retinanet_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+
+# please install mmpretrain
+# import mmpretrain.models to trigger register_module in mmpretrain
+custom_imports = dict(imports=['mmpretrain.models'], allow_failed_imports=False)
+model = dict(
+    backbone=dict(
+        _delete_=True, # Delete the backbone field in _base_
+        type='mmpretrain.TIMMBackbone', # Using timm from mmpretrain
+        model_name='efficientnet_b1',
+        features_only=True,
+        pretrained=True,
+        out_indices=(1, 2, 3, 4)), # Modify out_indices
+    neck=dict(in_channels=[24, 40, 112, 320])) # Modify in_channels
+
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0001)
+```
+
+`type='mmpretrain.TIMMBackbone'` means use the `TIMMBackbone` class from MMPretrain in MMDetection, and the model used is `EfficientNet-B1`, where `mmpretrain` means the MMPretrain repo and `TIMMBackbone` means the TIMMBackbone wrapper implemented in MMPretrain.
+
+For the principle of the Hierarchy Registry, please refer to the [MMEngine document](https://github.com/open-mmlab/mmengine/blob/main/docs/en/tutorials/config.md). For how to use other backbones in MMPretrain, you can refer to the [MMPretrain document](https://mmpretrain.readthedocs.io/en/latest/user_guides/config.html).
+
+# Use Mosaic augmentation
+
+If you want to use `Mosaic` in training, please make sure that you use `MultiImageMixDataset` at the same time. Taking the 'Faster R-CNN' algorithm as an example, you should modify the values of `train_pipeline` and `train_dataset` in the config as below:
+
+```python
+# Open configs/faster_rcnn/faster-rcnn_r50_fpn_1x_coco.py directly and add the following fields
+data_root = 'data/coco/'
+dataset_type = 'CocoDataset'
+img_scale=(1333, 800)
+
+train_pipeline = [
+    dict(type='Mosaic', img_scale=img_scale, pad_val=114.0),
+    dict(
+        type='RandomAffine',
+        scaling_ratio_range=(0.1, 2),
+        border=(-img_scale[0] // 2, -img_scale[1] // 2)), # The image will be enlarged by 4 times after Mosaic processing,so we use affine transformation to restore the image size.
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+
+train_dataset = dict(
+    _delete_ = True, # remove unnecessary Settings
+    type='MultiImageMixDataset',
+    dataset=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_train2017.json',
+        img_prefix=data_root + 'train2017/',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', with_bbox=True)
+        ],
+        filter_empty_gt=False,
+    ),
+    pipeline=train_pipeline
+    )
+
+data = dict(
+    train=train_dataset
+    )
+```
+
+# Unfreeze backbone network after freezing the backbone in the config
+
+If you have freezed the backbone network in the config and want to unfreeze it after some epoches, you can write a hook function to do it.  Taking the Faster R-CNN with the resnet backbone as an example, you can freeze one stage of the backbone network and  add a `custom_hooks` in the config as below:
+
+```python
+_base_ = [
+    '../_base_/models/faster-rcnn_r50_fpn.py',
+    '../_base_/datasets/coco_detection.py',
+    '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py'
+]
+model = dict(
+    # freeze one stage of the backbone network.
+    backbone=dict(frozen_stages=1),
+)
+custom_hooks = [dict(type="UnfreezeBackboneEpochBasedHook", unfreeze_epoch=1)]
+```
+
+Meanwhile write the hook class `UnfreezeBackboneEpochBasedHook` in `mmdet/core/hook/unfreeze_backbone_epoch_based_hook.py`
+
+```python
+from mmengine.model import is_model_wrapper
+from mmengine.hooks import Hook
+from mmdet.registry import HOOKS
+
+
+@HOOKS.register_module()
+class UnfreezeBackboneEpochBasedHook(Hook):
+    """Unfreeze backbone network Hook.
+
+    Args:
+        unfreeze_epoch (int): The epoch unfreezing the backbone network.
+    """
+
+    def __init__(self, unfreeze_epoch=1):
+        self.unfreeze_epoch = unfreeze_epoch
+
+    def before_train_epoch(self, runner):
+        # Unfreeze the backbone network.
+        # Only valid for resnet.
+        if runner.epoch == self.unfreeze_epoch:
+            model = runner.model
+            if is_model_wrapper(model):
+                model = model.module
+            backbone = model.backbone
+            if backbone.frozen_stages >= 0:
+                if backbone.deep_stem:
+                    backbone.stem.train()
+                    for param in backbone.stem.parameters():
+                        param.requires_grad = True
+                else:
+                    backbone.norm1.train()
+                    for m in [backbone.conv1, backbone.norm1]:
+                        for param in m.parameters():
+                            param.requires_grad = True
+
+            for i in range(1, backbone.frozen_stages + 1):
+                m = getattr(backbone, f'layer{i}')
+                m.train()
+                for param in m.parameters():
+                    param.requires_grad = True
+```
+
+# Get the channels of a new backbone
+
+If you want to get the channels of a new backbone, you can build this backbone alone and input a pseudo image to get each stage output.
+
+Take `ResNet` as an example:
+
+```python
+from mmdet.models import ResNet
+import torch
+self = ResNet(depth=18)
+self.eval()
+inputs = torch.rand(1, 3, 32, 32)
+level_outputs = self.forward(inputs)
+for level_out in level_outputs:
+    print(tuple(level_out.shape))
+
+```
+
+Output of the above script is as below:
+
+```python
+(1, 64, 8, 8)
+(1, 128, 4, 4)
+(1, 256, 2, 2)
+(1, 512, 1, 1)
+```
+
+Users can get the channels of the new backbone by Replacing the `ResNet(depth=18)` in this script with their customized backbone.
+
+# Use Detectron2 Model in MMDetection
+
+Users can use Detectron2Wrapper to run Detectron2's model in MMDetection. We provide examples of [Faster R-CNN](../../../configs/misc/d2_faster-rcnn_r50-caffe_fpn_ms-90k_coco.py),
+[Mask R-CNN](../../../configs/misc/d2_mask-rcnn_r50-caffe_fpn_ms-90k_coco.py), and [RetinaNet](../../../configs/misc/d2_retinanet_r50-caffe_fpn_ms-90k_coco.py) in MMDetection.
+
+The algorithm components in config file should be the same as those of in Detectron2. During setup, we will first initialize the default settings, which can be found in [Detectron2](https://github.com/facebookresearch/detectron2/blob/main/detectron2/config/defaults.py).
+Then, the settings in config file will overwrite the default settings and the model will be built with these settings.
+The input data will first convert to Detectron2's type and feed into Detectron2's model.
+During inference the results calculate from Detectron2's model will reconvert back to the MMDetection's type.
+
+## Use Detectron2's pre-trained weights
+
+The weight initialization in `Detectron2Wrapper` will not use the logic of MMDetection. Users can set `model.d2_detector.weights=xxx` to load pre-trained weights.
+For example, we can use `model.d2_detector.weights='detectron2://ImageNetPretrained/MSRA/R-50.pkl'` to load the pre-trained ResNet-50 or use
+`model.d2_detector.weights='detectron2://COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x/137260431/model_final_a54504.pkl'` to load the pre-trained Mask R-CNN weights proposed in Detectron2.
+
+**Note:** Detectron2's pretrained model cannot be loaded directly by using `load_from`, it should be first converted via `tools/model_converters/detectron2_to_mmdet.py`
+
+For inference of released detectron2 checkpoints, users should first use `tools/model_converters/detectron2_to_mmdet.py` to convert Detectron2 checkpoint to MMDetection.
+
+```shell
+python tools/model_converters/detectron2_to_mmdet.py ${Detectron2 ckpt path} ${MMDetectron ckpt path}
+```

docs/en/advanced_guides/index.rst

+Basic Concepts
+***************
+
+.. toctree::
+   :maxdepth: 1
+
+   data_flow.md
+   structures.md
+   models.md
+   datasets.md
+   transforms.md
+   evaluation.md
+   engine.md
+   conventions.md
+
+Component Customization
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   customize_models.md
+   customize_losses.md
+   customize_dataset.md
+   customize_transforms.md
+   customize_runtime.md
+
+How to
+************************
+
+.. toctree::
+   :maxdepth: 1
+
+   how_to.md

docs/en/advanced_guides/models.md

+# Models

docs/en/advanced_guides/structures.md

+# Structures

docs/en/advanced_guides/transforms.md

+# Data Transforms (Need to update)
+
+## Design of Data transforms pipeline
+
+Following typical conventions, we use `Dataset` and `DataLoader` for data loading
+with multiple workers. `Dataset` returns a dict of data items corresponding
+the arguments of models' forward method.
+
+The data transforms pipeline and the dataset is decomposed. Usually a dataset
+defines how to process the annotations and a data transforms pipeline defines all the steps to prepare a data dict.
+A pipeline consists of a sequence of data transforms. Each operation takes a dict as input and also output a dict for the next transform.
+
+We present a classical pipeline in the following figure. The blue blocks are pipeline operations. With the pipeline going on, each operator can add new keys (marked as green) to the result dict or update the existing keys (marked as orange).
+![pipeline figure](../../../resources/data_pipeline.png)
+
+Here is a pipeline example for Faster R-CNN.
+
+```python
+train_pipeline = [  # Training data processing pipeline
+    dict(type='LoadImageFromFile', backend_args=backend_args),  # First pipeline to load images from file path
+    dict(
+        type='LoadAnnotations',  # Second pipeline to load annotations for current image
+        with_bbox=True),  # Whether to use bounding box, True for detection
+    dict(
+        type='Resize',  # Pipeline that resize the images and their annotations
+        scale=(1333, 800),  # The largest scale of image
+        keep_ratio=True  # Whether to keep the ratio between height and width
+        ),
+    dict(
+        type='RandomFlip',  # Augmentation pipeline that flip the images and their annotations
+        prob=0.5),  # The probability to flip
+    dict(type='PackDetInputs')  # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
+]
+test_pipeline = [  # Testing data processing pipeline
+    dict(type='LoadImageFromFile', backend_args=backend_args),  # First pipeline to load images from file path
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),  # Pipeline that resize the images
+    dict(
+        type='PackDetInputs',  # Pipeline that formats the annotation data and decides which keys in the data should be packed into data_samples
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+```

docs/en/api.rst

+mmdet.apis
+--------------
+.. automodule:: mmdet.apis
+    :members:
+
+mmdet.datasets
+--------------
+
+datasets
+^^^^^^^^^^
+.. automodule:: mmdet.datasets
+    :members:
+
+api_wrappers
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.datasets.api_wrappers
+    :members:
+
+samplers
+^^^^^^^^^^
+.. automodule:: mmdet.datasets.samplers
+    :members:
+
+transforms
+^^^^^^^^^^^^
+.. automodule:: mmdet.datasets.transforms
+    :members:
+
+mmdet.engine
+--------------
+
+hooks
+^^^^^^^^^^
+.. automodule:: mmdet.engine.hooks
+    :members:
+
+optimizers
+^^^^^^^^^^^^^^^
+.. automodule:: mmdet.engine.optimizers
+    :members:
+
+runner
+^^^^^^^^^^
+.. automodule:: mmdet.engine.runner
+    :members:
+
+schedulers
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.engine.schedulers
+    :members:
+
+mmdet.evaluation
+--------------------
+
+functional
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.evaluation.functional
+    :members:
+
+metrics
+^^^^^^^^^^
+.. automodule:: mmdet.evaluation.metrics
+    :members:
+
+
+mmdet.models
+--------------
+
+backbones
+^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.backbones
+    :members:
+
+data_preprocessors
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.data_preprocessors
+    :members:
+
+dense_heads
+^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.dense_heads
+    :members:
+
+detectors
+^^^^^^^^^^
+.. automodule:: mmdet.models.detectors
+    :members:
+
+layers
+^^^^^^^^^^
+.. automodule:: mmdet.models.layers
+    :members:
+
+losses
+^^^^^^^^^^
+.. automodule:: mmdet.models.losses
+    :members:
+
+necks
+^^^^^^^^^^^^
+.. automodule:: mmdet.models.necks
+    :members:
+
+roi_heads
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.roi_heads
+    :members:
+
+seg_heads
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.seg_heads
+    :members:
+
+task_modules
+^^^^^^^^^^^^^
+.. automodule:: mmdet.models.task_modules
+    :members:
+
+test_time_augs
+^^^^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.models.test_time_augs
+    :members:
+
+utils
+^^^^^^^^^^
+.. automodule:: mmdet.models.utils
+    :members:
+
+
+mmdet.structures
+--------------------
+
+structures
+^^^^^^^^^^^^^^^^^
+.. automodule:: mmdet.structures
+    :members:
+
+bbox
+^^^^^^^^^^
+.. automodule:: mmdet.structures.bbox
+    :members:
+
+mask
+^^^^^^^^^^
+.. automodule:: mmdet.structures.mask
+    :members:
+
+mmdet.testing
+----------------
+.. automodule:: mmdet.testing
+    :members:
+
+mmdet.visualization
+--------------------
+.. automodule:: mmdet.visualization
+    :members:
+
+mmdet.utils
+--------------
+.. automodule:: mmdet.utils
+    :members:

docs/en/conf.py

+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/main/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import subprocess
+import sys
+
+import pytorch_sphinx_theme
+
+sys.path.insert(0, os.path.abspath('../..'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'MMDetection'
+copyright = '2018-2021, OpenMMLab'
+author = 'MMDetection Authors'
+version_file = '../../mmdet/version.py'
+
+
+def get_version():
+    with open(version_file, 'r') as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+# The full version, including alpha/beta/rc tags
+release = get_version()
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'myst_parser',
+    'sphinx_markdown_tables',
+    'sphinx_copybutton',
+]
+
+myst_enable_extensions = ['colon_fence']
+myst_heading_anchors = 3
+
+autodoc_mock_imports = [
+    'matplotlib', 'pycocotools', 'terminaltables', 'mmdet.version', 'mmcv.ops'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = {
+    '.rst': 'restructuredtext',
+    '.md': 'markdown',
+}
+
+# The main toctree document.
+master_doc = 'index'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = 'sphinx_rtd_theme'
+html_theme = 'pytorch_sphinx_theme'
+html_theme_path = [pytorch_sphinx_theme.get_html_theme_path()]
+
+html_theme_options = {
+    'menu': [
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/open-mmlab/mmdetection'
+        },
+    ],
+    # Specify the language of shared menu
+    'menu_lang':
+    'en'
+}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+html_css_files = ['css/readthedocs.css']
+
+# -- Extension configuration -------------------------------------------------
+# Ignore >>> when copying code
+copybutton_prompt_text = r'>>> |\.\.\. '
+copybutton_prompt_is_regexp = True
+
+
+def builder_inited_handler(app):
+    subprocess.run(['./stat.py'])
+
+
+def setup(app):
+    app.connect('builder-inited', builder_inited_handler)

docs/en/dataset_zoo.md

+# Dataset Zoo

docs/en/get_started.md

+# GET STARTED
+
+## Prerequisites
+
+In this section, we demonstrate how to prepare an environment with PyTorch.
+
+MMDetection works on Linux, Windows, and macOS. It requires Python 3.7+, CUDA 9.2+, and PyTorch 1.8+.
+
+```{note}
+If you are experienced with PyTorch and have already installed it, just skip this part and jump to the [next section](#installation). Otherwise, you can follow these steps for the preparation.
+```
+
+**Step 0.** Download and install Miniconda from the [official website](https://docs.conda.io/en/latest/miniconda.html).
+
+**Step 1.** Create a conda environment and activate it.
+
+```shell
+conda create --name openmmlab python=3.8 -y
+conda activate openmmlab
+```
+
+**Step 2.** Install PyTorch following [official instructions](https://pytorch.org/get-started/locally/), e.g.
+
+On GPU platforms:
+
+```shell
+conda install pytorch torchvision -c pytorch
+```
+
+On CPU platforms:
+
+```shell
+conda install pytorch torchvision cpuonly -c pytorch
+```
+
+## Installation
+
+We recommend that users follow our best practices to install MMDetection. However, the whole process is highly customizable. See [Customize Installation](#customize-installation) section for more information.
+
+### Best Practices
+
+**Step 0.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**Note:** In MMCV-v2.x, `mmcv-full` is rename to `mmcv`, if you want to install `mmcv` without CUDA ops, you can use `mim install "mmcv-lite>=2.0.0rc1"` to install the lite version.
+
+**Step 1.** Install MMDetection.
+
+Case a: If you develop and run mmdet directly, install it from source:
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection.git
+cd mmdetection
+pip install -v -e .
+# "-v" means verbose, or more output
+# "-e" means installing a project in editable mode,
+# thus any local modifications made to the code will take effect without reinstallation.
+```
+
+Case b: If you use mmdet as a dependency or third-party package, install it with MIM:
+
+```shell
+mim install mmdet
+```
+
+## Verify the installation
+
+To verify whether MMDetection is installed correctly, we provide some sample codes to run an inference demo.
+
+**Step 1.** We need to download config and checkpoint files.
+
+```shell
+mim download mmdet --config rtmdet_tiny_8xb32-300e_coco --dest .
+```
+
+The downloading will take several seconds or more, depending on your network environment. When it is done, you will find two files `rtmdet_tiny_8xb32-300e_coco.py` and `rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth` in your current folder.
+
+**Step 2.** Verify the inference demo.
+
+Case a: If you install MMDetection from source, just run the following command.
+
+```shell
+python demo/image_demo.py demo/demo.jpg rtmdet_tiny_8xb32-300e_coco.py --weights rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth --device cpu
+```
+
+You will see a new image `demo.jpg` on your `./outputs/vis` folder, where bounding boxes are plotted on cars, benches, etc.
+
+Case b: If you install MMDetection with MIM, open your python interpreter and copy&paste the following codes.
+
+```python
+from mmdet.apis import init_detector, inference_detector
+
+config_file = 'rtmdet_tiny_8xb32-300e_coco.py'
+checkpoint_file = 'rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'
+model = init_detector(config_file, checkpoint_file, device='cpu')  # or device='cuda:0'
+inference_detector(model, 'demo/demo.jpg')
+```
+
+You will see a list of `DetDataSample`, and the predictions are in the `pred_instance`, indicating the detected bounding boxes, labels, and scores.
+
+## Tracking Installation
+
+We recommend that users follow our best practices to install MMDetection for tracking task.
+
+### Best Practices
+
+**Step 0.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+pip install -U openmim
+mim install mmengine
+mim install "mmcv>=2.0.0"
+```
+
+**Step 1.** Install MMDetection.
+
+Case a: If you develop and run mmdet directly, install it from source:
+
+```shell
+git clone https://github.com/open-mmlab/mmdetection.git
+cd mmdetection
+pip install -v -e . -r requirements/tracking.txt
+# "-v" means verbose, or more output
+# "-e" means installing a project in editable mode,
+# thus any local modifications made to the code will take effect without reinstallation.
+```
+
+Case b: If you use mmdet as a dependency or third-party package, install it with MIM:
+
+```shell
+mim install mmdet[tracking]
+```
+
+**Step 2.** Install TrackEval.
+
+```shell
+pip install git+https://github.com/JonathonLuiten/TrackEval.git
+```
+
+## Verify the installation
+
+To verify whether MMDetection is installed correctly, we provide some sample codes to run an inference demo.
+
+**Step 1.** We need to download config and checkpoint files.
+
+```shell
+mim download mmdet --config bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval --dest .
+```
+
+The downloading will take several seconds or more, depending on your network environment. When it is done, you will find two files `bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py` and `bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth` in your current folder.
+
+**Step 2.** Verify the inference demo.
+
+Case a: If you install MMDetection from source, just run the following command.
+
+```shell
+python demo/mot_demo.py demo/demo_mot.mp4 bytetrack_yolox_x_8xb4-amp-80e_crowdhuman-mot17halftrain_test-mot17halfval.py --checkpoint bytetrack_yolox_x_crowdhuman_mot17-private-half_20211218_205500-1985c9f0.pth --out mot.mp4
+```
+
+You will see a new video `mot.mp4` on your folder, where bounding boxes are plotted on person.
+
+Case b: If you install MMDetection with MIM, open your python interpreter and demo/mot_demo.py, then run it like Case a.
+
+### Customize Installation
+
+#### CUDA versions
+
+When installing PyTorch, you need to specify the version of CUDA. If you are not clear on which to choose, follow our recommendations:
+
+- For Ampere-based NVIDIA GPUs, such as GeForce 30 series and NVIDIA A100, CUDA 11 is a must.
+- For older NVIDIA GPUs, CUDA 11 is backward compatible, but CUDA 10.2 offers better compatibility and is more lightweight.
+
+Please make sure the GPU driver satisfies the minimum version requirements. See [this table](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#cuda-major-component-versions__table-cuda-toolkit-driver-versions) for more information.
+
+```{note}
+Installing CUDA runtime libraries is enough if you follow our best practices, because no CUDA code will be compiled locally. However, if you hope to compile MMCV from source or develop other CUDA operators, you need to install the complete CUDA toolkit from NVIDIA's [website](https://developer.nvidia.com/cuda-downloads), and its version should match the CUDA version of PyTorch. i.e., the specified version of cudatoolkit in the `conda install` command.
+```
+
+#### Install MMEngine without MIM
+
+To install MMEngine with pip instead of MIM, please follow [MMEngine installation guides](https://mmengine.readthedocs.io/en/latest/get_started/installation.html).
+
+For example, you can install MMEngine by the following command.
+
+```shell
+pip install mmengine
+```
+
+#### Install MMCV without MIM
+
+MMCV contains C++ and CUDA extensions, thus depending on PyTorch in a complex way. MIM solves such dependencies automatically and makes the installation easier. However, it is not a must.
+
+To install MMCV with pip instead of MIM, please follow [MMCV installation guides](https://mmcv.readthedocs.io/en/2.x/get_started/installation.html). This requires manually specifying a find-url based on the PyTorch version and its CUDA version.
+
+For example, the following command installs MMCV built for PyTorch 1.12.x and CUDA 11.6.
+
+```shell
+pip install "mmcv>=2.0.0" -f https://download.openmmlab.com/mmcv/dist/cu116/torch1.12.0/index.html
+```
+
+#### Install on CPU-only platforms
+
+MMDetection can be built for CPU-only environments. In CPU mode you can train (requires MMCV version >= 2.0.0rc1), test, or infer a model.
+
+However, some functionalities are gone in this mode:
+
+- Deformable Convolution
+- Modulated Deformable Convolution
+- ROI pooling
+- Deformable ROI pooling
+- CARAFE
+- SyncBatchNorm
+- CrissCrossAttention
+- MaskedConv2d
+- Temporal Interlace Shift
+- nms_cuda
+- sigmoid_focal_loss_cuda
+- bbox_overlaps
+
+If you try to train/test/infer a model containing the above ops, an error will be raised.
+The following table lists affected algorithms.
+
+|                        Operator                         |                                          Model                                           |
+| :-----------------------------------------------------: | :--------------------------------------------------------------------------------------: |
+| Deformable Convolution/Modulated Deformable Convolution | DCN, Guided Anchoring, RepPoints, CentripetalNet, VFNet, CascadeRPN, NAS-FCOS, DetectoRS |
+|                      MaskedConv2d                       |                                     Guided Anchoring                                     |
+|                         CARAFE                          |                                          CARAFE                                          |
+|                      SyncBatchNorm                      |                                         ResNeSt                                          |
+
+#### Install on Google Colab
+
+[Google Colab](https://colab.research.google.com/) usually has PyTorch installed,
+thus we only need to install MMEngine, MMCV, and MMDetection with the following commands.
+
+**Step 1.** Install [MMEngine](https://github.com/open-mmlab/mmengine) and [MMCV](https://github.com/open-mmlab/mmcv) using [MIM](https://github.com/open-mmlab/mim).
+
+```shell
+!pip3 install openmim
+!mim install mmengine
+!mim install "mmcv>=2.0.0,<2.1.0"
+```
+
+**Step 2.** Install MMDetection from the source.
+
+```shell
+!git clone https://github.com/open-mmlab/mmdetection.git
+%cd mmdetection
+!pip install -e .
+```
+
+**Step 3.** Verification.
+
+```python
+import mmdet
+print(mmdet.__version__)
+# Example output: 3.0.0, or an another version.
+```
+
+```{note}
+Within Jupyter, the exclamation mark `!` is used to call external executables and `%cd` is a [magic command](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-cd) to change the current working directory of Python.
+```
+
+#### Use MMDetection with Docker
+
+We provide a [Dockerfile](../../docker/Dockerfile) to build an image. Ensure that your [docker version](https://docs.docker.com/engine/install/) >=19.03.
+
+```shell
+# build an image with PyTorch 1.9, CUDA 11.1
+# If you prefer other versions, just modified the Dockerfile
+docker build -t mmdetection docker/
+```
+
+Run it with
+
+```shell
+docker run --gpus all --shm-size=8g -it -v {DATA_DIR}:/mmdetection/data mmdetection
+```
+
+### Troubleshooting
+
+If you have some issues during the installation, please first view the [FAQ](notes/faq.md) page.
+You may [open an issue](https://github.com/open-mmlab/mmdetection/issues/new/choose) on GitHub if no solution is found.
+
+### Use Multiple Versions of MMDetection in Development
+
+Training and testing scripts have already been modified in `PYTHONPATH` in order to make sure the scripts are using their own versions of MMDetection.
+
+To install the default version of MMDetection in your environment, you can exclude the follow code in the relative scripts:
+
+```shell
+PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
+```

docs/en/index.rst

+Welcome to MMDetection's documentation!
+=======================================
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Get Started
+
+   overview.md
+   get_started.md
+
+.. toctree::
+   :maxdepth: 2
+   :caption: User Guides
+
+   user_guides/index.rst
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Advanced Guides
+
+   advanced_guides/index.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Migration
+
+   migration/migration.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: API Reference
+
+   api.rst
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Model Zoo
+
+   model_zoo.md
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Notes
+
+   notes/contribution_guide.md
+   notes/projects.md
+   notes/changelog.md
+   notes/changelog_v2.x.md
+   notes/faq.md
+   notes/compatibility.md
+
+.. toctree::
+   :caption: Switch Language
+
+   switch_language.md
+
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`search`

docs/en/make.bat

+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd

docs/en/migration.md

+# Migration

docs/en/migration/api_and_registry_migration.md

+# Migrate API and Registry from MMDetection 2.x to 3.x

docs/en/migration/config_migration.md

+# Migrate Configuration File from MMDetection 2.x to 3.x
+
+The configuration file of MMDetection 3.x has undergone significant changes in comparison to the 2.x version. This document explains how to migrate 2.x configuration files to 3.x.
+
+In the previous tutorial [Learn about Configs](../user_guides/config.md), we used Mask R-CNN as an example to introduce the configuration file structure of MMDetection 3.x. Here, we will follow the same structure to demonstrate how to migrate 2.x configuration files to 3.x.
+
+## Model Configuration
+
+There have been no major changes to the model configuration in 3.x compared to 2.x. For the model's backbone, neck, head, as well as train_cfg and test_cfg, the parameters remain the same as in version 2.x.
+
+On the other hand, we have added the `DataPreprocessor` module in MMDetection 3.x. The configuration for the `DataPreprocessor` module is located in `model.data_preprocessor`. It is used to preprocess the input data, such as normalizing input images and padding images of different sizes into batches, and loading images from memory to VRAM. This configuration replaces the `Normalize` and `Pad` modules in `train_pipeline` and `test_pipeline` of the earlier version.
+
+<table class="docutils">
+<tr>
+<td>2.x Config</td>
+<td>
+
+```python
+# Image normalization parameters
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    to_rgb=True)
+pipeline=[
+    ...,
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size_divisor=32),  # Padding the image to multiples of 32
+    ...
+]
+```
+
+</td>
+<tr>
+<td>3.x Config</td>
+<td>
+
+```python
+model = dict(
+    data_preprocessor=dict(
+        type='DetDataPreprocessor',
+        # Image normalization parameters
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        bgr_to_rgb=True,
+        # Image padding parameters
+        pad_mask=True,  # In instance segmentation, the mask needs to be padded
+        pad_size_divisor=32)  # Padding the image to multiples of 32
+)
+
+```
+
+</td>
+</tr>
+</table>
+
+## Dataset and Evaluator Configuration
+
+The dataset and evaluator configurations have undergone major changes compared to version 2.x. We will introduce how to migrate from version 2.x to version 3.x from three aspects: Dataloader and Dataset, Data transform pipeline, and Evaluator configuration.
+
+### Dataloader and Dataset Configuration
+
+In the new version, we set the data loading settings consistent with PyTorch's official DataLoader,
+making it easier for users to understand and get started with.
+We put the data loading settings for training, validation, and testing separately in `train_dataloader`, `val_dataloader`, and `test_dataloader`.
+Users can set different parameters for these dataloaders.
+The input parameters are basically the same as those required by [PyTorch DataLoader](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader).
+
+This way, we put the unconfigurable parameters in version 2.x, such as `sampler`, `batch_sampler`, and `persistent_workers`, in the configuration file, so that users can set dataloader parameters more flexibly.
+
+Users can set the dataset configuration through `train_dataloader.dataset`, `val_dataloader.dataset`, and `test_dataloader.dataset`, which correspond to `data.train`, `data.val`, and `data.test` in version 2.x.
+
+<table class="docutils">
+<tr>
+<td>2.x Config</td>
+<td>
+
+```python
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_train2017.json',
+        img_prefix=data_root + 'train2017/',
+        pipeline=train_pipeline),
+    val=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        img_prefix=data_root + 'val2017/',
+        pipeline=test_pipeline),
+    test=dict(
+        type=dataset_type,
+        ann_file=data_root + 'annotations/instances_val2017.json',
+        img_prefix=data_root + 'val2017/',
+        pipeline=test_pipeline))
+```
+
+</td>
+<tr>
+<td>3.x Config</td>
+<td>
+
+```python
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,  # Avoid recreating subprocesses after each iteration
+    sampler=dict(type='DefaultSampler', shuffle=True),  # Default sampler, supports both distributed and non-distributed training
+    batch_sampler=dict(type='AspectRatioBatchSampler'),  # Default batch_sampler, used to ensure that images in the batch have similar aspect ratios, so as to better utilize graphics memory
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_train2017.json',
+        data_prefix=dict(img='train2017/'),
+        filter_cfg=dict(filter_empty_gt=True, min_size=32),
+        pipeline=train_pipeline))
+# In version 3.x, validation and test dataloaders can be configured independently
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=2,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        ann_file='annotations/instances_val2017.json',
+        data_prefix=dict(img='val2017/'),
+        test_mode=True,
+        pipeline=test_pipeline))
+test_dataloader = val_dataloader  # The configuration of the testing dataloader is the same as that of the validation dataloader, which is omitted here
+
+```
+
+</td>
+</tr>
+</table>
+
+### Data Transform Pipeline Configuration
+
+As mentioned earlier, we have separated the normalization and padding configurations for images from the `train_pipeline` and `test_pipeline`, and have placed them in `model.data_preprocessor` instead. Hence, in the 3.x version of the pipeline, we no longer require the `Normalize` and `Pad` transforms.
+
+At the same time, we have also refactored the transform responsible for packing the data format, and have merged the `Collect` and `DefaultFormatBundle` transforms into `PackDetInputs`. This transform is responsible for packing the data from the data pipeline into the input format of the model. For more details on the input format conversion, please refer to the [data flow documentation](../advanced_guides/data_flow.md).
+
+Below, we will use the `train_pipeline` of Mask R-CNN as an example, to demonstrate how to migrate from the 2.x configuration to the 3.x configuration:
+
+<table class="docutils">
+<tr>
+<td>2.x Config</td>
+<td>
+
+```python
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
+    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='Normalize', **img_norm_cfg),
+    dict(type='Pad', size_divisor=32),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
+]
+```
+
+</td>
+<tr>
+<td>3.x Config</td>
+<td>
+
+```python
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', with_bbox=True),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PackDetInputs')
+]
+```
+
+</td>
+</tr>
+</table>
+
+For the `test_pipeline`, apart from removing the `Normalize` and `Pad` transforms, we have also separated the data augmentation for testing (TTA) from the normal testing process, and have removed `MultiScaleFlipAug`. For more information on how to use the new TTA version, please refer to the [TTA documentation](../advanced_guides/tta.md).
+
+Below, we will again use the `test_pipeline` of Mask R-CNN as an example, to demonstrate how to migrate from the 2.x configuration to the 3.x configuration:
+
+<table class="docutils">
+<tr>
+<td>2.x Config</td>
+<td>
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(1333, 800),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(type='Normalize', **img_norm_cfg),
+            dict(type='Pad', size_divisor=32),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img']),
+        ])
+]
+```
+
+</td>
+<tr>
+<td>3.x Config</td>
+<td>
+
+```python
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(1333, 800), keep_ratio=True),
+    dict(
+        type='PackDetInputs',
+        meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
+                   'scale_factor'))
+]
+```
+
+</td>
+</tr>
+</table>
+
+In addition, we have also refactored some data augmentation transforms. The following table lists the mapping between the transforms used in the 2.x version and the 3.x version:
+
+<table class="docutils">
+<thead>
+  <tr>
+    <th>Name</th>
+    <th>2.x Config</th>
+    <th>3.x Config</th>
+  </tr>
+</thead>
+<tbody>
+  <tr>
+    <td>Resize</td>
+<td>
+
+```python
+dict(type='Resize',
+     img_scale=(1333, 800),
+     keep_ratio=True)
+```
+
+</td>
+
+<td>
+
+```python
+dict(type='Resize',
+     scale=(1333, 800),
+     keep_ratio=True)
+```
+
+</td>
+  </tr>
+  <tr>
+    <td>RandomResize</td>
+<td>
+
+```python
+dict(
+    type='Resize',
+    img_scale=[
+        (1333, 640), (1333, 800)],
+    multiscale_mode='range',
+    keep_ratio=True)
+```
+
+</td>
+<td>
+
+```python
+dict(
+    type='RandomResize',
+    scale=[
+        (1333, 640), (1333, 800)],
+    keep_ratio=True)
+```
+
+</td>
+  </tr>
+  <tr>
+    <td>RandomChoiceResize</td>
+<td>
+
+```python
+dict(
+    type='Resize',
+    img_scale=[
+        (1333, 640), (1333, 672),
+        (1333, 704), (1333, 736),
+        (1333, 768), (1333, 800)],
+    multiscale_mode='value',
+    keep_ratio=True)
+```
+
+</td>
+<td>
+
+```python
+dict(
+    type='RandomChoiceResize',
+    scales=[
+        (1333, 640), (1333, 672),
+        (1333, 704), (1333, 736),
+        (1333, 768), (1333, 800)],
+    keep_ratio=True)
+```
+
+</td>
+  </tr>
+
+<tr>
+    <td>RandomFlip</td>
+<td>
+
+```python
+dict(type='RandomFlip', flip_ratio=0.5)
+```
+
+</td>
+<td>
+
+```python
+dict(type='RandomFlip', prob=0.5)
+```
+
+</td>
+  </tr>
+
+</tbody>
+</table>
+
+### 评测器配置
+
+In version 3.x, model accuracy evaluation is no longer tied to the dataset, but is instead accomplished through the use of an Evaluator.
+The Evaluator configuration is divided into two parts: `val_evaluator` and `test_evaluator`. The `val_evaluator` is used for validation dataset evaluation, while the `test_evaluator` is used for testing dataset evaluation.
+This corresponds to the `evaluation` field in version 2.x.
+
+The following table shows the corresponding relationship between Evaluators in version 2.x and 3.x.
+
+<table class="docutils">
+<thead>
+  <tr>
+    <th>Metric Name</th>
+    <th>2.x Config</th>
+    <th>3.x Config</th>
+  </tr>
+</thead>
+<tbody>
+  <tr>
+    <td>COCO</td>
+<td>
+
+```python
+data = dict(
+    val=dict(
+        type='CocoDataset',
+        ann_file=data_root + 'annotations/instances_val2017.json'))
+evaluation = dict(metric=['bbox', 'segm'])
+```
+
+</td>
+
+<td>
+
+```python
+val_evaluator = dict(
+    type='CocoMetric',
+    ann_file=data_root + 'annotations/instances_val2017.json',
+    metric=['bbox', 'segm'],
+    format_only=False)
+```
+
+</td>
+  </tr>
+  <tr>
+    <td>Pascal VOC</td>
+<td>
+
+```python
+data = dict(
+    val=dict(
+        type=dataset_type,
+        ann_file=data_root + 'VOC2007/ImageSets/Main/test.txt'))
+evaluation = dict(metric='mAP')
+```
+
+</td>
+<td>
+
+```python
+val_evaluator = dict(
+    type='VOCMetric',
+    metric='mAP',
+    eval_mode='11points')
+```
+
+</td>
+  </tr>
+  <tr>
+    <td>OpenImages</td>
+<td>
+
+```python
+data = dict(
+    val=dict(
+        type='OpenImagesDataset',
+        ann_file=data_root + 'annotations/validation-annotations-bbox.csv',
+        img_prefix=data_root + 'OpenImages/validation/',
+        label_file=data_root + 'annotations/class-descriptions-boxable.csv',
+        hierarchy_file=data_root +
+        'annotations/bbox_labels_600_hierarchy.json',
+        meta_file=data_root + 'annotations/validation-image-metas.pkl',
+        image_level_ann_file=data_root +
+        'annotations/validation-annotations-human-imagelabels-boxable.csv'))
+evaluation = dict(interval=1, metric='mAP')
+```
+
+</td>
+<td>
+
+```python
+val_evaluator = dict(
+    type='OpenImagesMetric',
+    iou_thrs=0.5,
+    ioa_thrs=0.5,
+    use_group_of=True,
+    get_supercategory=True)
+```
+
+</td>
+  </tr>
+
+<tr>
+    <td>CityScapes</td>
+<td>
+
+```python
+data = dict(
+    val=dict(
+        type='CityScapesDataset',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        img_prefix=data_root + 'leftImg8bit/val/',
+        pipeline=test_pipeline))
+evaluation = dict(metric=['bbox', 'segm'])
+```
+
+</td>
+<td>
+
+```python
+val_evaluator = [
+    dict(
+        type='CocoMetric',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        metric=['bbox', 'segm']),
+    dict(
+        type='CityScapesMetric',
+        ann_file=data_root +
+        'annotations/instancesonly_filtered_gtFine_val.json',
+        seg_prefix=data_root + '/gtFine/val',
+        outfile_prefix='./work_dirs/cityscapes_metric/instance')
+]
+```
+
+</td>
+  </tr>
+
+</tbody>
+</table>
+
+## Configuration for Training and Testing
+
+<table class="docutils">
+<tr>
+<td>2.x Config</td>
+<td>
+
+```python
+runner = dict(
+    type='EpochBasedRunner',  # Type of training loop
+    max_epochs=12)  # Maximum number of training epochs
+evaluation = dict(interval=2)  # Interval for evaluation, check the performance every 2 epochs
+```
+
+</td>
+<tr>
+<td>3.x Config</td>
+<td>
+
+```python
+train_cfg = dict(
+    type='EpochBasedTrainLoop',  # Type of training loop, please refer to https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/loops.py
+    max_epochs=12,  # Maximum number of training epochs
+    val_interval=2)  # Interval for validation, check the performance every 2 epochs
+val_cfg = dict(type='ValLoop')  # Type of validation loop
+test_cfg = dict(type='TestLoop')  # Type of testing loop
+```
+
+</td>
+</tr>
+</table>
+
+## Optimization Configuration
+
+The configuration for optimizer and gradient clipping is moved to the `optim_wrapper` field.
+The following table shows the correspondences for optimizer configuration between 2.x version and 3.x version:
+
+<table class="docutils">
+<tr>
+<td>2.x Config</td>
+<td>
+
+```python
+optimizer = dict(
+    type='SGD',  # Optimizer: Stochastic Gradient Descent
+    lr=0.02,  # Base learning rate
+    momentum=0.9,  # SGD with momentum
+    weight_decay=0.0001)  # Weight decay
+optimizer_config = dict(grad_clip=None)  # Configuration for gradient clipping, set to None to disable
+```
+
+</td>
+<tr>
+<td>3.x Config</td>
+<td>
+
+```python
+optim_wrapper = dict(  # Configuration for the optimizer wrapper
+    type='OptimWrapper',  # Type of optimizer wrapper, you can switch to AmpOptimWrapper to enable mixed precision training
+    optimizer=dict(  # Optimizer configuration, supports various PyTorch optimizers, please refer to https://pytorch.org/docs/stable/optim.html#algorithms
+        type='SGD',  # SGD
+        lr=0.02,  # Base learning rate
+        momentum=0.9,  # SGD with momentum
+        weight_decay=0.0001),  # Weight decay
+    clip_grad=None,  # Configuration for gradient clipping, set to None to disable. For usage, please see https://mmengine.readthedocs.io/en/latest/tutorials/optimizer.html
+    )
+```
+
+</td>
+</tr>
+</table>
+
+The configuration for learning rate is also moved from the `lr_config` field to the `param_scheduler` field. The `param_scheduler` configuration is more similar to PyTorch's learning rate scheduler and more flexible. The following table shows the correspondences for learning rate configuration between 2.x version and 3.x version:
+
+<table class="docutils">
+<tr>
+<td>2.x Config</td>
+<td>
+
+```python
+lr_config = dict(
+    policy='step',  # Use multi-step learning rate strategy during training
+    warmup='linear',  # Use linear learning rate warmup
+    warmup_iters=500,  # End warmup at iteration 500
+    warmup_ratio=0.001,  # Coefficient for learning rate warmup
+    step=[8, 11],  # Learning rate decay at which epochs
+    gamma=0.1)  # Learning rate decay coefficient
+
+```
+
+</td>
+<tr>
+<td>3.x Config</td>
+<td>
+
+```python
+param_scheduler = [
+    dict(
+        type='LinearLR',  # Use linear learning rate warmup
+        start_factor=0.001, # Coefficient for learning rate warmup
+        by_epoch=False,  # Update the learning rate during warmup at each iteration
+        begin=0,  # Starting from the first iteration
+        end=500),  # End at the 500th iteration
+    dict(
+        type='MultiStepLR',  # Use multi-step learning rate strategy during training
+        by_epoch=True,  # Update the learning rate at each epoch
+        begin=0,   # Starting from the first epoch
+        end=12,  # Ending at the 12th epoch
+        milestones=[8, 11],  # Learning rate decay at which epochs
+        gamma=0.1)  # Learning rate decay coefficient
+]
+
+```
+
+</td>
+</tr>
+</table>
+
+For information on how to migrate other learning rate adjustment policies, please refer to the [learning rate migration document of MMEngine](https://mmengine.readthedocs.io/zh_CN/latest/migration/param_scheduler.html).
+
+## Migration of Other Configurations
+
+### Configuration for Saving Checkpoints
+
+<table class="docutils">
+<thead>
+  <tr>
+    <th>Function</th>
+    <th>2.x Config</th>
+    <th>3.x Config</th>
+  </tr>
+</thead>
+<tbody>
+  <tr>
+    <td>Set Save Interval</td>
+<td>
+
+```python
+checkpoint_config = dict(
+    interval=1)
+```
+
+</td>
+
+<td>
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        interval=1))
+```
+
+</td>
+  </tr>
+
+<tr>
+    <td>Save Best Model</td>
+<td>
+
+```python
+evaluation = dict(
+    save_best='auto')
+```
+
+</td>
+<td>
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        save_best='auto'))
+```
+
+</td>
+  </tr>
+
+<tr>
+    <td>Keep Latest Model</td>
+<td>
+
+```python
+checkpoint_config = dict(
+    max_keep_ckpts=3)
+```
+
+</td>
+<td>
+
+```python
+default_hooks = dict(
+    checkpoint=dict(
+        type='CheckpointHook',
+        max_keep_ckpts=3))
+```
+
+</td>
+  </tr>
+
+</tbody>
+</table>
+
+### Logging Configuration
+
+In MMDetection 3.x, the logging and visualization of the log are carried out respectively by the logger and visualizer in MMEngine. The following table shows the comparison between the configuration of printing logs and visualizing logs in MMDetection 2.x and 3.x.
+
+<table class="docutils">
+<thead>
+  <tr>
+    <th>Function</th>
+    <th>2.x Config</th>
+    <th>3.x Config</th>
+  </tr>
+</thead>
+<tbody>
+  <tr>
+    <td>Set Log Printing Interval</td>
+<td>
+
+```python
+log_config = dict(interval=50)
+```
+
+</td>
+
+<td>
+
+```python
+default_hooks = dict(
+    logger=dict(type='LoggerHook', interval=50))
+# Optional: set moving average window size
+log_processor = dict(
+    type='LogProcessor', window_size=50)
+```
+
+</td>
+  </tr>
+
+<tr>
+    <td>Use TensorBoard or WandB to visualize logs</td>
+<td>
+
+```python
+log_config = dict(
+    interval=50,
+    hooks=[
+        dict(type='TextLoggerHook'),
+        dict(type='TensorboardLoggerHook'),
+        dict(type='MMDetWandbHook',
+             init_kwargs={
+                'project': 'mmdetection',
+                'group': 'maskrcnn-r50-fpn-1x-coco'
+             },
+             interval=50,
+             log_checkpoint=True,
+             log_checkpoint_metadata=True,
+             num_eval_images=100)
+    ])
+```
+
+</td>
+<td>
+
+```python
+vis_backends = [
+    dict(type='LocalVisBackend'),
+    dict(type='TensorboardVisBackend'),
+    dict(type='WandbVisBackend',
+         init_kwargs={
+            'project': 'mmdetection',
+            'group': 'maskrcnn-r50-fpn-1x-coco'
+         })
+]
+visualizer = dict(
+    type='DetLocalVisualizer',
+    vis_backends=vis_backends,
+    name='visualizer')
+```
+
+</td>
+  </tr>
+
+</tbody>
+</table>
+
+For visualization-related tutorials, please refer to [Visualization Tutorial](../user_guides/visualization.md) of MMDetection.
+
+### Runtime Configuration
+
+The runtime configuration fields in version 3.x have been adjusted, and the specific correspondence is as follows:
+
+<table class="docutils">
+<thead>
+  <tr>
+    <th>2.x Config</th>
+    <th>3.x Config</th>
+  </tr>
+</thead>
+<tbody>
+
+<tr>
+<td>
+
+```python
+cudnn_benchmark = False
+opencv_num_threads = 0
+mp_start_method = 'fork'
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+
+
+```
+
+</td>
+<td>
+
+```python
+env_cfg = dict(
+    cudnn_benchmark=False,
+    mp_cfg=dict(mp_start_method='fork',
+                opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'))
+log_level = 'INFO'
+load_from = None
+resume = False
+```
+
+</td>
+  </tr>
+
+</tbody>
+</table>

docs/en/migration/dataset_migration.md

+# Migrate dataset from MMDetection 2.x to 3.x

docs/en/migration/migration.md

+# Migrating from MMDetection 2.x to 3.x
+
+MMDetection 3.x is a significant update that includes many changes to API and configuration files. This document aims to help users migrate from MMDetection 2.x to 3.x.
+We divided the migration guide into the following sections:
+
+- [Configuration file migration](./config_migration.md)
+- [API and Registry migration](./api_and_registry_migration.md)
+- [Dataset migration](./dataset_migration.md)
+- [Model migration](./model_migration.md)
+- [Frequently Asked Questions](./migration_faq.md)
+
+If you encounter any problems during the migration process, feel free to raise an issue. We also welcome contributions to this document.

docs/en/migration/migration_faq.md

+# Migration FAQ

docs/en/migration/model_migration.md

+# Migrate models from MMDetection 2.x to 3.x

docs/en/model_zoo.md

+# Benchmark and Model Zoo
+
+## Mirror sites
+
+We only use aliyun to maintain the model zoo since MMDetection V2.0. The model zoo of V1.x has been deprecated.
+
+## Common settings
+
+- All models were trained on `coco_2017_train`, and tested on the `coco_2017_val`.
+- We use distributed training.
+- All pytorch-style pretrained backbones on ImageNet are from PyTorch model zoo, caffe-style pretrained backbones are converted from the newly released model from detectron2.
+- For fair comparison with other codebases, we report the GPU memory as the maximum value of `torch.cuda.max_memory_allocated()` for all 8 GPUs. Note that this value is usually less than what `nvidia-smi` shows.
+- We report the inference time as the total time of network forwarding and post-processing, excluding the data loading time. Results are obtained with the script [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) which computes the average time on 2000 images.
+
+## ImageNet Pretrained Models
+
+It is common to initialize from backbone models pre-trained on ImageNet classification task. All pre-trained  model links can be found at [open_mmlab](https://github.com/open-mmlab/mmcv/blob/master/mmcv/model_zoo/open_mmlab.json).  According to `img_norm_cfg` and source of weight, we can divide all the ImageNet  pre-trained  model weights into some cases:
+
+- TorchVision:  Corresponding to torchvision weight, including ResNet50, ResNet101. The `img_norm_cfg` is `dict(mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)`.
+- Pycls:  Corresponding to [pycls](https://github.com/facebookresearch/pycls) weight, including RegNetX. The `img_norm_cfg` is `dict(   mean=[103.530, 116.280, 123.675], std=[57.375, 57.12, 58.395], to_rgb=False)`.
+- MSRA styles: Corresponding to [MSRA](https://github.com/KaimingHe/deep-residual-networks) weights, including ResNet50_Caffe and ResNet101_Caffe. The `img_norm_cfg` is `dict(   mean=[103.530, 116.280, 123.675], std=[1.0, 1.0, 1.0], to_rgb=False)`.
+- Caffe2 styles:  Currently only contains ResNext101_32x8d. The `img_norm_cfg` is `dict(mean=[103.530, 116.280, 123.675], std=[57.375, 57.120, 58.395], to_rgb=False)`.
+- Other styles: E.g SSD which corresponds to `img_norm_cfg` is `dict(mean=[123.675, 116.28, 103.53], std=[1, 1, 1], to_rgb=True)` and YOLOv3 which corresponds to `img_norm_cfg` is `dict(mean=[0, 0, 0], std=[255., 255., 255.], to_rgb=True)`.
+
+The detailed table of the commonly used backbone models in MMDetection is listed below :
+
+| model            | source      | link                                                                                                                                                                                                   | description                                                                                                                                                                                                                                      |
+| ---------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ResNet50         | TorchVision | [torchvision's ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth)                                                                                                                   | From [torchvision's ResNet-50](https://download.pytorch.org/models/resnet50-19c8e357.pth).                                                                                                                                                       |
+| ResNet101        | TorchVision | [torchvision's ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth)                                                                                                                 | From [torchvision's ResNet-101](https://download.pytorch.org/models/resnet101-5d3b4d8f.pth).                                                                                                                                                     |
+| RegNetX          | Pycls       | [RegNetX_3.2gf](https://download.openmmlab.com/pretrain/third_party/regnetx_3.2gf-c2599b0f.pth), [RegNetX_800mf](https://download.openmmlab.com/pretrain/third_party/regnetx_800mf-1f4be4c7.pth). etc. | From [pycls](https://github.com/facebookresearch/pycls).                                                                                                                                                                                         |
+| ResNet50_Caffe   | MSRA        | [MSRA's ResNet-50](https://download.openmmlab.com/pretrain/third_party/resnet50_caffe-788b5fa3.pth)                                                                                                    | Converted copy of [Detectron2's R-50.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-50.pkl) model. The original weight comes from [MSRA's original ResNet-50](https://github.com/KaimingHe/deep-residual-networks).    |
+| ResNet101_Caffe  | MSRA        | [MSRA's ResNet-101](https://download.openmmlab.com/pretrain/third_party/resnet101_caffe-3ad79236.pth)                                                                                                  | Converted copy of [Detectron2's R-101.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/MSRA/R-101.pkl) model. The original weight comes from [MSRA's original ResNet-101](https://github.com/KaimingHe/deep-residual-networks). |
+| ResNext101_32x8d | Caffe2      | [Caffe2 ResNext101_32x8d](https://download.openmmlab.com/pretrain/third_party/resnext101_32x8d-1516f1aa.pth)                                                                                           | Converted copy of [Detectron2's X-101-32x8d.pkl](https://dl.fbaipublicfiles.com/detectron2/ImageNetPretrained/FAIR/X-101-32x8d.pkl) model. The ResNeXt-101-32x8d model trained with Caffe2 at FB.                                                |
+
+## Baselines
+
+### RPN
+
+Please refer to [RPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/rpn) for details.
+
+### Faster R-CNN
+
+Please refer to [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn) for details.
+
+### Mask R-CNN
+
+Please refer to [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn) for details.
+
+### Fast R-CNN (with pre-computed proposals)
+
+Please refer to [Fast R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/fast_rcnn) for details.
+
+### RetinaNet
+
+Please refer to [RetinaNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet) for details.
+
+### Cascade R-CNN and Cascade Mask R-CNN
+
+Please refer to [Cascade R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/cascade_rcnn) for details.
+
+### Hybrid Task Cascade (HTC)
+
+Please refer to [HTC](https://github.com/open-mmlab/mmdetection/blob/main/configs/htc) for details.
+
+### SSD
+
+Please refer to [SSD](https://github.com/open-mmlab/mmdetection/blob/main/configs/ssd) for details.
+
+### Group Normalization (GN)
+
+Please refer to [Group Normalization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn) for details.
+
+### Weight Standardization
+
+Please refer to [Weight Standardization](https://github.com/open-mmlab/mmdetection/blob/main/configs/gn+ws) for details.
+
+### Deformable Convolution v2
+
+Please refer to [Deformable Convolutional Networks](https://github.com/open-mmlab/mmdetection/blob/main/configs/dcn) for details.
+
+### CARAFE: Content-Aware ReAssembly of FEatures
+
+Please refer to [CARAFE](https://github.com/open-mmlab/mmdetection/blob/main/configs/carafe) for details.
+
+### Instaboost
+
+Please refer to [Instaboost](https://github.com/open-mmlab/mmdetection/blob/main/configs/instaboost) for details.
+
+### Libra R-CNN
+
+Please refer to [Libra R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/libra_rcnn) for details.
+
+### Guided Anchoring
+
+Please refer to [Guided Anchoring](https://github.com/open-mmlab/mmdetection/blob/main/configs/guided_anchoring) for details.
+
+### FCOS
+
+Please refer to [FCOS](https://github.com/open-mmlab/mmdetection/blob/main/configs/fcos) for details.
+
+### FoveaBox
+
+Please refer to [FoveaBox](https://github.com/open-mmlab/mmdetection/blob/main/configs/foveabox) for details.
+
+### RepPoints
+
+Please refer to [RepPoints](https://github.com/open-mmlab/mmdetection/blob/main/configs/reppoints) for details.
+
+### FreeAnchor
+
+Please refer to [FreeAnchor](https://github.com/open-mmlab/mmdetection/blob/main/configs/free_anchor) for details.
+
+### Grid R-CNN (plus)
+
+Please refer to [Grid R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/grid_rcnn) for details.
+
+### GHM
+
+Please refer to [GHM](https://github.com/open-mmlab/mmdetection/blob/main/configs/ghm) for details.
+
+### GCNet
+
+Please refer to [GCNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/gcnet) for details.
+
+### HRNet
+
+Please refer to [HRNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/hrnet) for details.
+
+### Mask Scoring R-CNN
+
+Please refer to [Mask Scoring R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/ms_rcnn) for details.
+
+### Train from Scratch
+
+Please refer to [Rethinking ImageNet Pre-training](https://github.com/open-mmlab/mmdetection/blob/main/configs/scratch) for details.
+
+### NAS-FPN
+
+Please refer to [NAS-FPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/nas_fpn) for details.
+
+### ATSS
+
+Please refer to [ATSS](https://github.com/open-mmlab/mmdetection/blob/main/configs/atss) for details.
+
+### FSAF
+
+Please refer to [FSAF](https://github.com/open-mmlab/mmdetection/blob/main/configs/fsaf) for details.
+
+### RegNetX
+
+Please refer to [RegNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet) for details.
+
+### Res2Net
+
+Please refer to [Res2Net](https://github.com/open-mmlab/mmdetection/blob/main/configs/res2net) for details.
+
+### GRoIE
+
+Please refer to [GRoIE](https://github.com/open-mmlab/mmdetection/blob/main/configs/groie) for details.
+
+### Dynamic R-CNN
+
+Please refer to [Dynamic R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/dynamic_rcnn) for details.
+
+### PointRend
+
+Please refer to [PointRend](https://github.com/open-mmlab/mmdetection/blob/main/configs/point_rend) for details.
+
+### DetectoRS
+
+Please refer to [DetectoRS](https://github.com/open-mmlab/mmdetection/blob/main/configs/detectors) for details.
+
+### Generalized Focal Loss
+
+Please refer to [Generalized Focal Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/gfl) for details.
+
+### CornerNet
+
+Please refer to [CornerNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/cornernet) for details.
+
+### YOLOv3
+
+Please refer to [YOLOv3](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolo) for details.
+
+### PAA
+
+Please refer to [PAA](https://github.com/open-mmlab/mmdetection/blob/main/configs/paa) for details.
+
+### SABL
+
+Please refer to [SABL](https://github.com/open-mmlab/mmdetection/blob/main/configs/sabl) for details.
+
+### CentripetalNet
+
+Please refer to [CentripetalNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centripetalnet) for details.
+
+### ResNeSt
+
+Please refer to [ResNeSt](https://github.com/open-mmlab/mmdetection/blob/main/configs/resnest) for details.
+
+### DETR
+
+Please refer to [DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/detr) for details.
+
+### Deformable DETR
+
+Please refer to [Deformable DETR](https://github.com/open-mmlab/mmdetection/blob/main/configs/deformable_detr) for details.
+
+### AutoAssign
+
+Please refer to [AutoAssign](https://github.com/open-mmlab/mmdetection/blob/main/configs/autoassign) for details.
+
+### YOLOF
+
+Please refer to [YOLOF](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolof) for details.
+
+### Seesaw Loss
+
+Please refer to [Seesaw Loss](https://github.com/open-mmlab/mmdetection/blob/main/configs/seesaw_loss) for details.
+
+### CenterNet
+
+Please refer to [CenterNet](https://github.com/open-mmlab/mmdetection/blob/main/configs/centernet) for details.
+
+### YOLOX
+
+Please refer to [YOLOX](https://github.com/open-mmlab/mmdetection/blob/main/configs/yolox) for details.
+
+### PVT
+
+Please refer to [PVT](https://github.com/open-mmlab/mmdetection/blob/main/configs/pvt) for details.
+
+### SOLO
+
+Please refer to [SOLO](https://github.com/open-mmlab/mmdetection/blob/main/configs/solo) for details.
+
+### QueryInst
+
+Please refer to [QueryInst](https://github.com/open-mmlab/mmdetection/blob/main/configs/queryinst) for details.
+
+### PanopticFPN
+
+Please refer to [PanopticFPN](https://github.com/open-mmlab/mmdetection/blob/main/configs/panoptic_fpn) for details.
+
+### MaskFormer
+
+Please refer to [MaskFormer](https://github.com/open-mmlab/mmdetection/blob/main/configs/maskformer) for details.
+
+### DyHead
+
+Please refer to [DyHead](https://github.com/open-mmlab/mmdetection/blob/main/configs/dyhead) for details.
+
+### Mask2Former
+
+Please refer to [Mask2Former](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask2former) for details.
+
+### Efficientnet
+
+Please refer to [Efficientnet](https://github.com/open-mmlab/mmdetection/blob/main/configs/efficientnet) for details.
+
+### Other datasets
+
+We also benchmark some methods on [PASCAL VOC](https://github.com/open-mmlab/mmdetection/blob/main/configs/pascal_voc), [Cityscapes](https://github.com/open-mmlab/mmdetection/blob/main/configs/cityscapes), [OpenImages](https://github.com/open-mmlab/mmdetection/blob/main/configs/openimages) and [WIDER FACE](https://github.com/open-mmlab/mmdetection/blob/main/configs/wider_face).
+
+### Pre-trained Models
+
+We also train [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn) and [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn) using ResNet-50 and [RegNetX-3.2G](https://github.com/open-mmlab/mmdetection/blob/main/configs/regnet) with multi-scale training and longer schedules. These models serve as strong pre-trained models for downstream tasks for convenience.
+
+## Speed benchmark
+
+### Training Speed benchmark
+
+We provide [analyze_logs.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/analyze_logs.py) to get average time of iteration in training. You can find examples in [Log Analysis](https://mmdetection.readthedocs.io/en/latest/useful_tools.html#log-analysis).
+
+We compare the training speed of Mask R-CNN with some other popular frameworks (The data is copied from [detectron2](https://github.com/facebookresearch/detectron2/blob/main/docs/notes/benchmarks.md/)).
+For mmdetection, we benchmark with [mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_poly-1x_coco_v1.py), which should have the same setting with [mask_rcnn_R_50_FPN_noaug_1x.yaml](https://github.com/facebookresearch/detectron2/blob/main/configs/Detectron1-Comparisons/mask_rcnn_R_50_FPN_noaug_1x.yaml) of detectron2.
+We also provide the [checkpoint](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_compare_20200518-10127928.pth) and [training log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug/mask_rcnn_r50_caffe_fpn_poly_1x_coco_no_aug_20200518_105755.log.json) for reference. The throughput is computed as the average throughput in iterations 100-500 to skip GPU warmup time.
+
+| Implementation                                                                         | Throughput (img/s) |
+| -------------------------------------------------------------------------------------- | ------------------ |
+| [Detectron2](https://github.com/facebookresearch/detectron2)                           | 62                 |
+| [MMDetection](https://github.com/open-mmlab/mmdetection)                               | 61                 |
+| [maskrcnn-benchmark](https://github.com/facebookresearch/maskrcnn-benchmark/)          | 53                 |
+| [tensorpack](https://github.com/tensorpack/tensorpack/tree/master/examples/FasterRCNN) | 50                 |
+| [simpledet](https://github.com/TuSimple/simpledet/)                                    | 39                 |
+| [Detectron](https://github.com/facebookresearch/Detectron)                             | 19                 |
+| [matterport/Mask_RCNN](https://github.com/matterport/Mask_RCNN/)                       | 14                 |
+
+### Inference Speed Benchmark
+
+We provide [benchmark.py](https://github.com/open-mmlab/mmdetection/blob/main/tools/analysis_tools/benchmark.py) to benchmark the inference latency.
+The script benchmarkes the model with 2000 images and calculates the average time ignoring first 5 times. You can change the output log interval (defaults: 50) by setting `LOG-INTERVAL`.
+
+```shell
+python tools/benchmark.py ${CONFIG} ${CHECKPOINT} [--log-interval $[LOG-INTERVAL]] [--fuse-conv-bn]
+```
+
+The latency of all models in our model zoo is benchmarked without setting `fuse-conv-bn`, you can get a lower latency by setting it.
+
+## Comparison with Detectron2
+
+We compare mmdetection with [Detectron2](https://github.com/facebookresearch/detectron2.git) in terms of speed and performance.
+We use the commit id [185c27e](https://github.com/facebookresearch/detectron2/tree/185c27e4b4d2d4c68b5627b3765420c6d7f5a659)(30/4/2020) of detectron.
+For fair comparison, we install and run both frameworks on the same machine.
+
+### Hardware
+
+- 8 NVIDIA Tesla V100 (32G) GPUs
+- Intel(R) Xeon(R) Gold 6148 CPU @ 2.40GHz
+
+### Software environment
+
+- Python 3.7
+- PyTorch 1.4
+- CUDA 10.1
+- CUDNN 7.6.03
+- NCCL 2.4.08
+
+### Performance
+
+| Type                                                                                                                            | Lr schd | Detectron2                                                                                                                           | mmdetection | Download                                                                                                                                                                                                                                                                                                                                                         |
+| ------------------------------------------------------------------------------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------ | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Faster R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/faster_rcnn/faster-rcnn_r50-caffe_fpn_ms-1x_coco.py) | 1x      | [37.9](https://github.com/facebookresearch/detectron2/blob/main/configs/COCO-Detection/faster_rcnn_R_50_FPN_1x.yaml)                 | 38.0        | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco-5324cff8.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco/faster_rcnn_r50_caffe_fpn_mstrain_1x_coco_20200429_234554.log.json)             |
+| [Mask R-CNN](https://github.com/open-mmlab/mmdetection/blob/main/configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py)  | 1x      | [38.6 & 35.2](https://github.com/facebookresearch/detectron2/blob/main/configs/COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_1x.yaml) | 38.8 & 35.4 | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco-dbecf295.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco/mask_rcnn_r50_caffe_fpn_mstrain-poly_1x_coco_20200430_054239.log.json) |
+| [Retinanet](https://github.com/open-mmlab/mmdetection/blob/main/configs/retinanet/retinanet_r50-caffe_fpn_ms-1x_coco.py)        | 1x      | [36.5](https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-Detection/retinanet_R_50_FPN_1x.yaml)                 | 37.0        | [model](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco-586977a0.pth) \| [log](https://download.openmmlab.com/mmdetection/v2.0/benchmark/retinanet_r50_caffe_fpn_mstrain_1x_coco/retinanet_r50_caffe_fpn_mstrain_1x_coco_20200430_014748.log.json)                     |
+
+### Training Speed
+
+The training speed is measure with s/iter. The lower, the better.
+
+| Type         | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 0.210      | 0.216       |
+| Mask R-CNN   | 0.261      | 0.265       |
+| Retinanet    | 0.200      | 0.205       |
+
+### Inference Speed
+
+The inference speed is measured with fps (img/s) on a single GPU, the higher, the better.
+To be consistent with Detectron2, we report the pure inference speed (without the time of data loading).
+For Mask R-CNN, we exclude the time of RLE encoding in post-processing.
+We also include the officially reported speed in the parentheses, which is slightly higher
+than the results tested on our server due to differences of hardwares.
+
+| Type         | Detectron2  | mmdetection |
+| ------------ | ----------- | ----------- |
+| Faster R-CNN | 25.6 (26.3) | 22.2        |
+| Mask R-CNN   | 22.5 (23.3) | 19.6        |
+| Retinanet    | 17.8 (18.2) | 20.6        |
+
+### Training memory
+
+| Type         | Detectron2 | mmdetection |
+| ------------ | ---------- | ----------- |
+| Faster R-CNN | 3.0        | 3.8         |
+| Mask R-CNN   | 3.4        | 3.9         |
+| Retinanet    | 3.9        | 3.4         |

docs/en/notes/changelog.md

+# Changelog of v3.x
+
+## v3.3.0 (05/01/2024)
+
+### Highlights
+
+Grounding-DINO is a state-of-the-art open-set detection model that tackles multiple vision tasks including Open-Vocabulary Detection (OVD), Phrase Grounding (PG), and Referring Expression Comprehension (REC). Its effectiveness has led to its widespread adoption as a mainstream architecture for various downstream applications. However, despite its significance, the original Grounding-DINO model lacks comprehensive public technical details due to the unavailability of its training code. To bridge this gap, we present MM-Grounding-DINO, an open-source, comprehensive, and user-friendly baseline, which is built with the MMDetection toolbox. It adopts abundant vision datasets for pre-training and various detection and grounding datasets for fine-tuning. We give a comprehensive analysis of each reported result and detailed settings for reproduction. The extensive experiments on the benchmarks mentioned demonstrate that our MM-Grounding-DINO-Tiny outperforms the Grounding-DINO-Tiny baseline. We release all our models to the research community.
+
+### New Features
+
+- Add RTMDet Swin / ConvNeXt backbone and results (#11259)
+- Add `odinw` configs and evaluation results of `GLIP` (#11175)
+- Add optional score threshold option to `coco_error_analysis.py` (#11117)
+- Add new configs for `panoptic_fpn` (#11109)
+- Replace partially weighted download links with OpenXLab for the `Faster-RCNN` (#11173)
+
+### Bug Fixes
+
+- Fix `Grounding DINO` nan when class tokens exceeds 256 (#11066)
+- Fix the `CO-DETR` config files error (#11325)
+- Fix `CO-DETR` load_from url in config (#11220)
+- Fixed mask shape after Albu postprocess (#11280)
+- Fix bug in `convert_coco_format`  and `youtubevis2coco` (#11251, #11086)
+
+### Contributors
+
+A total of 15 developers contributed to this release.
+
+Thank @adnan-mujagic, @Cycyes, @ilcopione, @returnL, @honeybadger78, @okotaku, @xushilin1, @keyhsw, @guyleaf, @Crescent-Saturn, @LRJKD, @aaronzs, @Divadi, @AwePhD, @hhaAndroid
+
+## v3.2.0 (12/10/2023)
+
+### Highlights
+
+**(1) Detection Transformer SOTA Model Collection**
+
+- Supported four updated and stronger SOTA Transformer models: DDQ, CO-DETR, AlignDETR, and H-DINO.
+- Based on CO-DETR, MMDet released a model with a COCO performance of 64.1 mAP.
+- Algorithms such as DINO support AMP/Checkpoint/FrozenBN, which can effectively reduce memory usage.
+
+**(2) Comprehensive Performance Comparison between CNN and Transformer**
+
+RF100 consists of a dataset collection of 100 real-world datasets, including 7 domains. It can be used to assess the performance differences of Transformer models like DINO and CNN-based algorithms under different scenarios and data volumes. Users can utilize this benchmark to quickly evaluate the robustness of their algorithms in various scenarios.
+
+**(3) Support for GLIP and Grounding DINO fine-tuning, the only algorithm library that supports Grounding DINO fine-tuning**
+
+The Grounding DINO algorithm in MMDet is the only library that supports fine-tuning. Its performance is one point higher than the official version, and of course, GLIP also outperforms the official version.
+We also provide a detailed process for training and evaluating Grounding DINO on custom datasets. Everyone is welcome to give it a try.
+
+**(4) Support for the open-vocabulary detection algorithm Detic and multi-dataset joint training.**
+
+**(5) Training detection models using FSDP and DeepSpeed.**
+
+**(6) Support for the V3Det dataset, a large-scale detection dataset with over 13,000 categories.**
+
+### New Features
+
+- Support CO-DETR/DDQ/AlignDETR/H-DINO
+- Support GLIP and Grounding DINO fine-tuning
+- Support Detic and Multi-Datasets training (#10926)
+- Support V3Det and benchmark (#10938)
+- Support Roboflow 100 Benchmark (#10915)
+- Add custom dataset of grounding dino (#11012)
+- Release RTMDet-X p6 (#10993)
+- Support AMP of DINO (#10827)
+- Support FrozenBN (#10845)
+- Add new configuration files for `QDTrack/DETR/RTMDet/MaskRCNN/DINO/DeformableDETR/MaskFormer` algorithm
+- Add a new script to support the WBF (#10808)
+- Add `large_image_demo` (#10719)
+- Support download dataset from OpenXLab (#10799)
+- Update to support torch2onnx for DETR series models (#10910)
+- Translation into Chinese of an English document (#10744, #10756, #10805, #10848)
+
+### Bug Fixes
+
+- Fix name error in DETR metafile.yml (#10595)
+- Fix device of the tensors in `set_nms` (#10574)
+- Remove some unicode chars from `en/` docs (#10648)
+- Fix download dataset with mim script. (#10727)
+- Fix export to torchserve (#10694)
+- Fix typo in `mask-rcnn_r50_fpn_1x-wandb_coco` (#10757)
+- Fix `eval_recalls` error in `voc_metric` (#10770)
+- Fix torch version comparison (#10934)
+- Fix incorrect behavior to access train pipeline from ConcatDataset in `analyze_results.py` (#11004)
+
+### Improvements
+
+- Update `useful_tools.md` (#10587)
+- Update Instance segmentation Tutorial (#10711)
+- Update `train.py` to compat with new config (#11025)
+- Support `torch2onnx` for maskformer series (#10782)
+
+### Contributors
+
+A total of 36 developers contributed to this release.
+
+Thank @YQisme, @nskostas, @max-unfinity, @evdcush, @Xiangxu-0103, @ZhaoCake, @RangeKing, @captainIT, @ODAncona, @aaronzs, @zeyuanyin, @gotjd709, @Musiyuan, @YanxingLiu, @RunningLeon, @ytzfhqs, @zhangzhidaSunny, @yeungkong, @crazysteeaam, @timerring, @okotaku, @apatsekin, @Morty-Xu, @Markson-Young, @ZhaoQiiii, @Kuro96, @PhoenixZ810, @yhcao6, @myownskyW7, @jiongjiongli, @Johnson-Wang, @ryylcc, @guyleaf, @agpeshal, @SimonGuoNjust, @hhaAndroid
+
+## v3.1.0 (30/6/2023)
+
+### Highlights
+
+- Supports tracking algorithms including multi-object tracking (MOT) algorithms SORT, DeepSORT, StrongSORT, OCSORT, ByteTrack, QDTrack, and video instance segmentation (VIS) algorithm MaskTrackRCNN, Mask2Former-VIS.
+- Support [ViTDet](../../../projects/ViTDet)
+- Supports inference and evaluation of multimodal algorithms [GLIP](../../../configs/glip) and [XDecoder](../../../projects/XDecoder), and also supports datasets such as COCO semantic segmentation, COCO Caption, ADE20k general segmentation, and RefCOCO. GLIP fine-tuning will be supported in the future.
+- Provides a [gradio demo](https://github.com/open-mmlab/mmdetection/blob/dev-3.x/projects/gradio_demo/README.md) for image type tasks of MMDetection, making it easy for users to experience.
+
+### New Features
+
+- Support DSDL Dataset (#9801)
+- Support iSAID dataset (#10028)
+- Support VISION dataset (#10530)
+- Release SoftTeacher checkpoints (#10119)
+- Release `centernet-update_r50-caffe_fpn_ms-1x_coco` checkpoints  (#10327)
+- Support SIoULoss (#10290)
+- Support Eqlv2 loss (#10120)
+- Support CopyPaste when mask is not available (#10509)
+- Support MIM to download ODL dataset (#10460)
+- Support new config (#10566)
+
+### Bug Fixes
+
+- Fix benchmark scripts error in windows (#10128)
+- Fix error of `YOLOXModeSwitchHook` does not switch the mode when resumed from the checkpoint after switched (#10116)
+- Fix pred and weight dims unmatch in SmoothL1Loss (#10423)
+
+### Improvements
+
+- Update MMDet_Tutorial.ipynb (#10081)
+- Support to hide inference progress (#10519)
+- Replace mmcls with mmpretrain  (#10545)
+
+### Contributors
+
+A total of 29 developers contributed to this release.
+
+Thanks @lovelykite, @minato-ellie, @freepoet, @wufan-tb, @yalibian, @keyakiluo, @gihanjayatilaka, @i-aki-y, @xin-li-67, @RangeKing, @JingweiZhang12, @MambaWong, @lucianovk, @tall-josh, @xiuqhou, @jamiechoi1995, @YQisme, @yechenzhi, @bjzhb666, @xiexinch, @jamiechoi1995, @yarkable, @Renzhihan, @nijkah, @amaizr, @Lum1104, @zwhus, @Czm369, @hhaAndroid
+
+## v3.0.0 (6/4/2023)
+
+### Highlights
+
+- Support Semi-automatic annotation Base [Label-Studio](../../../projects/LabelStudio) (#10039)
+- Support [EfficientDet](../../../projects/EfficientDet) in projects (#9810)
+
+### New Features
+
+- File I/O migration and reconstruction (#9709)
+- Release DINO Swin-L 36e model (#9927)
+
+### Bug Fixes
+
+- Fix benchmark script (#9865)
+- Fix the crop method of PolygonMasks (#9858)
+- Fix Albu augmentation with the mask shape (#9918)
+- Fix `RTMDetIns` prior generator device error (#9964)
+- Fix `img_shape` in data pipeline (#9966)
+- Fix cityscapes import error (#9984)
+- Fix `solov2_r50_fpn_ms-3x_coco.py` config error (#10030)
+- Fix Conditional DETR AP and Log (#9889)
+- Fix accepting an unexpected argument local-rank in PyTorch 2.0 (#10050)
+- Fix `common/ms_3x_coco-instance.py` config error (#10056)
+- Fix compute flops error (#10051)
+- Delete `data_root` in `CocoOccludedSeparatedMetric` to fix bug (#9969)
+- Unifying metafile.yml (#9849)
+
+### Improvements
+
+- Added BoxInst r101 config (#9967)
+- Added config migration guide (#9960)
+- Added more social networking links (#10021)
+- Added RTMDet config introduce (#10042)
+- Added visualization docs (#9938, #10058)
+- Refined data_prepare docs (#9935)
+- Added support for setting the cache_size_limit parameter of dynamo in PyTorch 2.0 (#10054)
+- Updated coco_metric.py (#10033)
+- Update type hint (#10040)
+
+### Contributors
+
+A total of 19 developers contributed to this release.
+
+Thanks @IRONICBo, @vansin, @RangeKing, @Ghlerrix, @okotaku, @JosonChan1998, @zgzhengSE, @bobo0810, @yechenzh, @Zheng-LinXiao, @LYMDLUT, @yarkable, @xiejiajiannb, @chhluo, @BIGWangYuDong, @RangiLy, @zwhus, @hhaAndroid, @ZwwWayne
+
+## v3.0.0rc6 (24/2/2023)
+
+### Highlights
+
+- Support [Boxinst](../../../configs/boxinst), [Objects365 Dataset](../../../configs/objects365), and [Separated and Occluded COCO metric](../user_guides/useful_tools.md#COCO-Separated-&-Occluded-Mask-Metric)
+- Support [ConvNeXt-V2](../../../projects/ConvNeXt-V2), [DiffusionDet](../../../projects/DiffusionDet), and inference of [EfficientDet](../../../projects/EfficientDet) and [Detic](../../../projects/Detic) in `Projects`
+- Refactor [DETR](../../../configs/detr) series and support [Conditional-DETR](../../../configs/conditional_detr), [DAB-DETR](../../../configs/dab_detr), and [DINO](../../../configs/detr)
+- Support `DetInferencer` for inference, Test Time Augmentation, and automatically importing modules from registry
+- Support RTMDet-Ins ONNXRuntime and TensorRT [deployment](../../../configs/rtmdet/README.md#deployment-tutorial)
+- Support [calculating FLOPs of detectors](../user_guides/useful_tools.md#Model-Complexity)
+
+### New Features
+
+- Support [Boxinst](https://arxiv.org/abs/2012.02310) (#9525)
+- Support [Objects365 Dataset](https://openaccess.thecvf.com/content_ICCV_2019/papers/Shao_Objects365_A_Large-Scale_High-Quality_Dataset_for_Object_Detection_ICCV_2019_paper.pdf) (#9600)
+- Support [ConvNeXt-V2](http://arxiv.org/abs/2301.00808) in `Projects` (#9619)
+- Support [DiffusionDet](https://arxiv.org/abs/2211.09788) in `Projects` (#9639, #9768)
+- Support [Detic](http://arxiv.org/abs/2201.02605) inference in `Projects` (#9645)
+- Support [EfficientDet](https://arxiv.org/abs/1911.09070) inference in `Projects` (#9645)
+- Support [Separated and Occluded COCO metric](https://arxiv.org/abs/2210.10046) (#9710)
+- Support auto import modules from registry (#9143)
+- Refactor DETR series and support Conditional-DETR, DAB-DETR and DINO (#9646)
+- Support `DetInferencer` for inference (#9561)
+- Support Test Time Augmentation (#9452)
+- Support calculating FLOPs of detectors (#9777)
+
+### Bug Fixes
+
+- Fix deprecating old type alias due to new version of numpy (#9625, #9537)
+- Fix VOC metrics (#9784)
+- Fix the wrong link of RTMDet-x log (#9549)
+- Fix RTMDet link in README (#9575)
+- Fix MMDet get flops error (#9589)
+- Fix `use_depthwise` in RTMDet (#9624)
+- Fix `albumentations` augmentation post process with masks (#9551)
+- Fix DETR series Unit Test (#9647)
+- Fix `LoadPanopticAnnotations` bug (#9703)
+- Fix `isort` CI (#9680)
+- Fix amp pooling overflow (#9670)
+- Fix docstring about noise in DINO (#9747)
+- Fix potential bug in `MultiImageMixDataset` (#9764)
+
+### Improvements
+
+- Replace NumPy transpose with PyTorch permute to speed-up (#9762)
+- Deprecate `sklearn` (#9725)
+- Add RTMDet-Ins deployment guide (#9823)
+- Update RTMDet config and README (#9603)
+- Replace the models used in the tutorial document with RTMDet (#9843)
+- Adjust the minimum supported python version to 3.7 (#9602)
+- Support modifying palette through configuration (#9445)
+- Update README document in `Project` (#9599)
+- Replace `github` with `gitee` in `.pre-commit-config-zh-cn.yaml` file (#9586)
+- Use official `isort` in `.pre-commit-config.yaml` file (#9701)
+- Change MMCV minimum version to `2.0.0rc4` for `dev-3.x` (#9695)
+- Add Chinese version of single_stage_as_rpn.md and test_results_submission.md (#9434)
+- Add OpenDataLab download link (#9605, #9738)
+- Add type hints of several layers (#9346)
+- Add typehint for `DarknetBottleneck` (#9591)
+- Add dockerfile (#9659)
+- Add twitter, discord, medium, and youtube link (#9775)
+- Prepare for merging refactor-detr (#9656)
+- Add metafile to ConditionalDETR, DABDETR and DINO (#9715)
+- Support to modify `non_blocking` parameters (#9723)
+- Comment repeater visualizer register (#9740)
+- Update user guide: `finetune.md` and `inference.md` (#9578)
+
+### New Contributors
+
+- @NoFish-528 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9346>
+- @137208 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9434>
+- @lyviva made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9625>
+- @zwhus made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9589>
+- @zylo117 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9670>
+- @chg0901 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9740>
+- @DanShouzhu made their first contribution in https://github.com/open-mmlab/mmdetection/pull/9578
+
+### Contributors
+
+A total of 27 developers contributed to this release.
+
+Thanks @JosonChan1998, @RangeKing, @NoFish-528, @likyoo, @Xiangxu-0103, @137208, @PeterH0323, @tianleiSHI, @wufan-tb, @lyviva, @zwhus, @jshilong, @Li-Qingyun, @sanbuphy, @zylo117, @triple-Mu, @KeiChiTse, @LYMDLUT, @nijkah, @chg0901, @DanShouzhu, @zytx121, @vansin, @BIGWangYuDong, @hhaAndroid, @RangiLyu, @ZwwWayne
+
+## v3.0.0rc5 (26/12/2022)
+
+### Highlights
+
+- Support [RTMDet](https://arxiv.org/abs/2212.07784) instance segmentation models. The technical report of RTMDet is on [arxiv](https://arxiv.org/abs/2212.07784)
+- Support SSHContextModule in paper [SSH: Single Stage Headless Face Detector](https://arxiv.org/abs/1708.03979).
+
+### New Features
+
+- Support [RTMDet](https://arxiv.org/abs/2212.07784) instance segmentation models and improve RTMDet test config (#9494)
+- Support SSHContextModule in paper [SSH: Single Stage Headless Face Detector](https://arxiv.org/abs/1708.03979) (#8953)
+- Release [CondInst](https://arxiv.org/abs/2003.05664) pre-trained model (#9406)
+
+### Bug Fixes
+
+- Fix CondInst predict error when `batch_size` is greater than 1 in inference (#9400)
+- Fix the bug of visualization when the dtype of the pipeline output image is not uint8 in browse dataset (#9401)
+- Fix `analyze_logs.py` to plot mAP and calculate train time correctly (#9409)
+- Fix backward inplace error with `PAFPN` (#9450)
+- Fix config import links in model converters (#9441)
+- Fix `DeformableDETRHead` object has no attribute `loss_single` (#9477)
+- Fix the logic of pseudo bboxes predicted by teacher model in SemiBaseDetector (#9414)
+- Fix demo API in instance segmentation tutorial (#9226)
+- Fix `analyze_results` (#9380)
+- Fix the error that Readthedocs API cannot be displayed (#9510)
+- Fix the error when there are no prediction results and support visualize the groundtruth of TTA (#9840)
+
+### Improvements
+
+- Remove legacy `builder.py` (#9479)
+- Make sure the pipeline argument shape is in `(width, height)` order (#9324)
+- Add `.pre-commit-config-zh-cn.yaml` file (#9388)
+- Refactor dataset metainfo to lowercase (#9469)
+- Add PyTorch 1.13 checking in CI (#9478)
+- Adjust `FocalLoss` and `QualityFocalLoss` to allow different kinds of targets (#9481)
+- Refactor `setup.cfg` (#9370)
+- Clip saturation value to valid range `[0, 1]` (#9391)
+- Only keep meta and state_dict when publishing model (#9356)
+- Add segm evaluator in ms-poly_3x_coco_instance config (#9524)
+- Update deployment guide (#9527)
+- Update zh_cn `faq.md` (#9396)
+- Update `get_started` (#9480)
+- Update the zh_cn user_guides of `useful_tools.md` and `useful_hooks.md` (#9453)
+- Add type hints for `bfp` and `channel_mapper` (#9410)
+- Add type hints of several losses (#9397)
+- Add type hints and update docstring for task modules (#9468)
+
+### New Contributors
+
+- @lihua199710 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9388>
+- @twmht made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9450>
+- @tianleiSHI made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9453>
+- @kitecats made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9481>
+- @QJC123654 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9468>
+
+### Contributors
+
+A total of 20 developers contributed to this release.
+
+Thanks @liuyanyi, @RangeKing, @lihua199710, @MambaWong, @sanbuphy, @Xiangxu-0103, @twmht, @JunyaoHu, @Chan-Sun, @tianleiSHI, @zytx121, @kitecats, @QJC123654, @JosonChan1998, @lvhan028, @Czm369, @BIGWangYuDong, @RangiLyu, @hhaAndroid, @ZwwWayne
+
+## v3.0.0rc4 (23/11/2022)
+
+### Highlights
+
+- Support [CondInst](https://arxiv.org/abs/2003.05664)
+- Add `projects/` folder, which will be a place for some experimental models/features.
+- Support [SparseInst](https://arxiv.org/abs/2203.12827) in [`projects`](./projects/SparseInst/README.md)
+
+### New Features
+
+- Support [CondInst](https://arxiv.org/abs/2003.05664) (#9223)
+- Add `projects/` folder, which will be a place for some experimental models/features (#9341)
+- Support [SparseInst](https://arxiv.org/abs/2203.12827) in [`projects`](./projects/SparseInst/README.md) (#9377)
+
+### Bug Fixes
+
+- Fix `pixel_decoder_type` discrimination in MaskFormer Head. (#9176)
+- Fix wrong padding value in cached MixUp (#9259)
+- Rename `utils/typing.py` to `utils/typing_utils.py` to fix `collect_env` error (#9265)
+- Fix resume arg conflict (#9287)
+- Fix the configs of Faster R-CNN with caffe backbone (#9319)
+- Fix torchserve and update related documentation (#9343)
+- Fix bbox refine bug with sigmooid activation (#9538)
+
+### Improvements
+
+- Update the docs of GIoU Loss in README (#8810)
+- Handle dataset wrapper in `inference_detector` (#9144)
+- Update the type of `counts` in COCO's compressed RLE (#9274)
+- Support saving config file in `print_config` (#9276)
+- Update docs about video inference (#9305)
+- Update guide about model deployment (#9344)
+- Fix doc typos of useful tools (#9177)
+- Allow to resume from specific checkpoint in CLI (#9284)
+- Update FAQ about windows installation issues of pycocotools (#9292)
+
+### New Contributors
+
+- @Daa98 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9274>
+- @lvhan028 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9344>
+
+### Contributors
+
+A total of 12 developers contributed to this release.
+
+Thanks @sanbuphy, @Czm369, @Daa98, @jbwang1997, @BIGWangYuDong, @JosonChan1998, @lvhan028, @RunningLeon, @RangiLyu, @Daa98, @ZwwWayne, @hhaAndroid
+
+## v3.0.0rc3 (4/11/2022)
+
+Upgrade the minimum version requirement of MMEngine to 0.3.0 to use `ignore_key` of `ConcatDataset` for training VOC datasets (#9058)
+
+### Highlights
+
+- Support [CrowdDet](https://arxiv.org/abs/2003.09163) and [EIoU Loss](https://ieeexplore.ieee.org/document/9429909)
+- Support training detection models in Detectron2
+- Refactor Fast R-CNN
+
+### New Features
+
+- Support [CrowdDet](https://arxiv.org/abs/2003.09163) (#8744)
+- Support training detection models in Detectron2 with examples of Mask R-CNN, Faster R-CNN, and RetinaNet (#8672)
+- Support [EIoU Loss](https://ieeexplore.ieee.org/document/9429909) (#9086)
+
+### Bug Fixes
+
+- Fix `XMLDataset` image size error (#9216)
+- Fix bugs of empty_instances when predicting without nms in roi_head (#9015)
+- Fix the config file of DETR (#9158)
+- Fix SOLOv2 cannot dealing with empty gt image (#9192)
+- Fix inference demo (#9153)
+- Add `ignore_key` in VOC `ConcatDataset` (#9058)
+- Fix dumping results issue in test scripts. (#9241)
+- Fix configs of training coco subsets on MMDet 3.x (#9225)
+- Fix corner2hbox of HorizontalBoxes for supporting empty bboxes (#9140)
+
+### Improvements
+
+- Refactor Fast R-CNN (#9132)
+- Clean requirements of mmcv-full due to SyncBN (#9207)
+- Support training detection models in detectron2 (#8672)
+- Add `box_type` support for `DynamicSoftLabelAssigner` (#9179)
+- Make scipy as a default dependency in runtime (#9187)
+- Update eval_metric (#9062)
+- Add `seg_map_suffix` in `BaseDetDataset` (#9088)
+
+### New Contributors
+
+- @Wwupup made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9086>
+- @sanbuphy made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9153>
+- @cxiang26 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9158>
+- @JosonChan1998 made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9225>
+
+### Contributors
+
+A total of 13 developers contributed to this release.
+
+Thanks @wanghonglie, @Wwupup, @sanbuphy, @BIGWangYuDong, @liuyanyi, @cxiang26, @jbwang1997, @ZwwWayne, @yuyoujiang, @RangiLyu, @hhaAndroid, @JosonChan1998, @Czm369
+
+## v3.0.0rc2 (21/10/2022)
+
+### Highlights
+
+- Support [imagenet pre-training](configs/rtmdet/cspnext_imagenet_pretrain) for RTMDet's backbone
+
+### New Features
+
+- Support [imagenet pre-training](configs/rtmdet/cspnext_imagenet_pretrain) for RTMDet's backbone (#8887)
+- Add `CrowdHumanDataset` and Metric (#8430)
+- Add `FixShapeResize` to support resize of fixed shape (#8665)
+
+### Bug Fixes
+
+- Fix `ConcatDataset` Import Error (#8909)
+- Fix `CircleCI` and `readthedoc` build failed (#8980, #8963)
+- Fix bitmap mask translate when `out_shape` is different (#8993)
+- Fix inconsistency in `Conv2d` weight channels (#8948)
+- Fix bugs when plotting loss curve by analyze_logs.py (#8944)
+- Fix type change of labels in `albumentations` (#9074)
+- Fix some docs and types error (#8818)
+- Update memory occupation of `RTMDet` in metafile (#9098)
+- Fix wrong arguments of `OpenImageMetrics` in the config (#9061)
+
+### Improvements
+
+- Refactor standard roi head with `box type` (#8658)
+- Support mask concatenation in `BitmapMasks` and `PolygonMasks` (#9006)
+- Update PyTorch and dependencies' version in dockerfile (#8845)
+- Update `robustness_eval.py` and `print_config` (#8452)
+- Make compatible with `ConfigDict` and `dict` in `dense_heads` (#8942)
+- Support logging coco metric copypaste (#9012)
+- Remove `Normalize` transform (#8913)
+- Support jittering the color of different instances of the same class (#8988)
+- Add assertion for missing key in `PackDetInputs` (#8982)
+
+### New Contributors
+
+- @Chan-Sun made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/8909>
+- @MambaWong made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/8913>
+- @yuyoujiang made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/8437>
+- @sltlls made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/8944>
+- @Nioolek made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/8845>
+- @wufan-tb made their first contribution in <https://github.com/open-mmlab/mmdetection/pull/9061>
+
+### Contributors
+
+A total of 13 developers contributed to this release.
+
+Thanks @RangiLyu, @jbwang1997, @wanghonglie, @Chan-Sun, @RangeKing, @chhluo, @MambaWong, @yuyoujiang, @hhaAndroid, @sltlls, @Nioolek, @ZwwWayne, @wufan-tb
+
+## v3.0.0rc1 (26/9/2022)
+
+### Highlights
+
+- Release a high-precision, low-latency single-stage object detector [RTMDet](configs/rtmdet).
+
+### Bug Fixes
+
+- Fix UT to be compatible with PyTorch 1.6 (#8707)
+- Fix `NumClassCheckHook` bug when model is wrapped (#8794)
+- Update the right URL of R-50-FPN with BoundedIoULoss (#8805)
+- Fix potential bug of indices in RandAugment (#8826)
+- Fix some types and links (#8839, #8820, #8793, #8868)
+- Fix incorrect background fill values in `FSAF` and `RepPoints` Head (#8813)
+
+### Improvements
+
+- Refactored anchor head and base head with `box type` (#8625)
+- Refactored `SemiBaseDetector` and `SoftTeacher` (#8786)
+- Add list to dict keys to avoid modify loss dict (#8828)
+- Update `analyze_results.py` , `analyze_logs.py` and `loading.py` (#8430, #8402, #8784)
+- Support dump results in `test.py` (#8814)
+- Check empty predictions in `DetLocalVisualizer._draw_instances` (#8830)
+- Fix `floordiv` warning in `SOLO` (#8738)
+
+### Contributors
+
+A total of 16 developers contributed to this release.
+
+Thanks @ZwwWayne, @jbwang1997, @Czm369, @ice-tong, @Zheng-LinXiao, @chhluo, @RangiLyu, @liuyanyi, @wanghonglie, @levan92, @JiayuXu0, @nye0, @hhaAndroid, @xin-li-67, @shuxp, @zytx121
+
+## v3.0.0rc0 (31/8/2022)
+
+We are excited to announce the release of MMDetection 3.0.0rc0. MMDet 3.0.0rc0 is the first version of MMDetection 3.x, a part of the OpenMMLab 2.0 projects. Built upon the new [training engine](https://github.com/open-mmlab/mmengine), MMDet 3.x unifies the interfaces of the dataset, models, evaluation, and visualization with faster training and testing speed. It also provides a general semi-supervised object detection framework and strong baselines.
+
+### Highlights
+
+1. **New engine**. MMDet 3.x is based on [MMEngine](https://github.com/open-mmlab/mmengine), which provides a universal and powerful runner that allows more flexible customizations and significantly simplifies the entry points of high-level interfaces.
+
+2. **Unified interfaces**. As a part of the OpenMMLab 2.0 projects, MMDet 3.x unifies and refactors the interfaces and internal logic of training, testing, datasets, models, evaluation, and visualization. All the OpenMMLab 2.0 projects share the same design in those interfaces and logic to allow the emergence of multi-task/modality algorithms.
+
+3. **Faster speed**. We optimize the training and inference speed for common models and configurations, achieving a faster or similar speed than [Detection2](https://github.com/facebookresearch/detectron2/). Model details of benchmark will be updated in [this note](./benchmark.md#comparison-with-detectron2).
+
+4. **General semi-supervised object detection**. Benefitting from the unified interfaces, we support a general semi-supervised learning framework that works with all the object detectors supported in MMDet 3.x. Please refer to [semi-supervised object detection](../user_guides/semi_det.md) for details.
+
+5. **Strong baselines**. We release strong baselines of many popular models to enable fair comparisons among state-of-the-art models.
+
+6. **New features and algorithms**:
+
+   - Enable all the single-stage detectors to serve as region proposal networks
+   - [SoftTeacher](https://arxiv.org/abs/2106.09018)
+   - [the updated CenterNet](https://arxiv.org/abs/2103.07461)
+
+7. **More documentation and tutorials**. We add a bunch of documentation and tutorials to help users get started more smoothly. Read it [here](https://mmdetection.readthedocs.io/en/3.x/).
+
+### Breaking Changes
+
+MMDet 3.x has undergone significant changes for better design, higher efficiency, more flexibility, and more unified interfaces.
+Besides the changes in API, we briefly list the major breaking changes in this section.
+We will update the [migration guide](../migration.md) to provide complete details and migration instructions.
+Users can also refer to the [API doc](https://mmdetection.readthedocs.io/en/3.x/) for more details.
+
+#### Dependencies
+
+- MMDet 3.x runs on PyTorch>=1.6. We have deprecated the support of PyTorch 1.5 to embrace mixed precision training and other new features since PyTorch 1.6. Some models can still run on PyTorch 1.5, but the full functionality of MMDet 3.x is not guaranteed.
+- MMDet 3.x relies on MMEngine to run. MMEngine is a new foundational library for training deep learning models of OpenMMLab and is the core dependency of OpenMMLab 2.0 projects. The dependencies of file IO and training are migrated from MMCV 1.x to MMEngine.
+- MMDet 3.x relies on MMCV>=2.0.0rc0. Although MMCV no longer maintains the training functionalities since 2.0.0rc0, MMDet 3.x relies on the data transforms, CUDA operators, and image processing interfaces in MMCV. Note that the package `mmcv` is the version that provides pre-built CUDA operators and `mmcv-lite` does not since MMCV 2.0.0rc0, while `mmcv-full` has been deprecated since 2.0.0rc0.
+
+#### Training and testing
+
+- MMDet 3.x uses Runner in [MMEngine](https://github.com/open-mmlab/mmengine) rather than that in MMCV. The new Runner implements and unifies the building logic of the dataset, model, evaluation, and visualizer. Therefore, MMDet 3.x no longer maintains the building logic of those modules in `mmdet.train.apis` and `tools/train.py`. Those codes have been migrated into [MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py). Please refer to the [migration guide of Runner in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for more details.
+- The Runner in MMEngine also supports testing and validation. The testing scripts are also simplified, which has similar logic to that in training scripts to build the runner.
+- The execution points of hooks in the new Runner have been enriched to allow more flexible customization. Please refer to the [migration guide of Hook in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/hook.html) for more details.
+- Learning rate and momentum schedules have been migrated from Hook to [Parameter Scheduler in MMEngine](https://mmengine.readthedocs.io/en/latest/tutorials/param_scheduler.html). Please refer to the [migration guide of Parameter Scheduler in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/param_scheduler.html) for more details.
+
+#### Configs
+
+- The [Runner in MMEngine](https://github.com/open-mmlab/mmengine/blob/main/mmengine/runner/runner.py) uses a different config structure to ease the understanding of the components in the runner. Users can read the [config example of MMDet 3.x](../user_guides/config.md) or refer to the [migration guide in MMEngine](https://mmengine.readthedocs.io/en/latest/migration/runner.html) for migration details.
+- The file names of configs and models are also refactored to follow the new rules unified across OpenMMLab 2.0 projects. The names of checkpoints are not updated for now as there is no BC-breaking of model weights between MMDet 3.x and 2.x. We will progressively replace all the model weights with those trained in MMDet 3.x. Please refer to the [user guides of config](../user_guides/config.md) for more details.
+
+#### Dataset
+
+The Dataset classes implemented in MMDet 3.x all inherit from the `BaseDetDataset`, which inherits from the [BaseDataset in MMEngine](https://mmengine.readthedocs.io/en/latest/advanced_tutorials/basedataset.html). In addition to the changes in interfaces, there are several changes in Dataset in MMDet 3.x.
+
+- All the datasets support serializing the internal data list to reduce the memory when multiple workers are built for data loading.
+- The internal data structure in the dataset is changed to be self-contained (without losing information like class names in MMDet 2.x) while keeping simplicity.
+- The evaluation functionality of each dataset has been removed from the dataset so that some specific evaluation metrics like COCO AP can be used to evaluate the prediction on other datasets.
+
+#### Data Transforms
+
+The data transforms in MMDet 3.x all inherits from `BaseTransform` in MMCV>=2.0.0rc0, which defines a new convention in OpenMMLab 2.0 projects.
+Besides the interface changes, there are several changes listed below:
+
+- The functionality of some data transforms (e.g., `Resize`) are decomposed into several transforms to simplify and clarify the usages.
+- The format of data dict processed by each data transform is changed according to the new data structure of dataset.
+- Some inefficient data transforms (e.g., normalization and padding) are moved into data preprocessor of model to improve data loading and training speed.
+- The same data transforms in different OpenMMLab 2.0 libraries have the same augmentation implementation and the logic given the same arguments, i.e., `Resize` in MMDet 3.x and MMSeg 1.x will resize the image in the exact same manner given the same arguments.
+
+#### Model
+
+The models in MMDet 3.x all inherit from `BaseModel` in MMEngine, which defines a new convention of models in OpenMMLab 2.0 projects.
+Users can refer to [the tutorial of the model in MMengine](https://mmengine.readthedocs.io/en/latest/tutorials/model.html) for more details.
+Accordingly, there are several changes as the following:
+
+- The model interfaces, including the input and output formats, are significantly simplified and unified following the new convention in MMDet 3.x.
+  Specifically, all the input data in training and testing are packed into `inputs` and `data_samples`, where `inputs` contains model inputs like a list of image tensors, and `data_samples` contains other information of the current data sample such as ground truths, region proposals, and model predictions. In this way, different tasks in MMDet 3.x can share the same input arguments, which makes the models more general and suitable for multi-task learning and some flexible training paradigms like semi-supervised learning.
+- The model has a data preprocessor module, which is used to pre-process the input data of the model. In MMDet 3.x, the data preprocessor usually does the necessary steps to form the input images into a batch, such as padding. It can also serve as a place for some special data augmentations or more efficient data transformations like normalization.
+- The internal logic of the model has been changed. In MMdet 2.x, model uses `forward_train`, `forward_test`, `simple_test`, and `aug_test` to deal with different model forward logics. In MMDet 3.x and OpenMMLab 2.0, the forward function has three modes: 'loss', 'predict', and 'tensor' for training, inference, and tracing or other purposes, respectively.
+  The forward function calls `self.loss`, `self.predict`, and `self._forward` given the modes 'loss', 'predict', and 'tensor', respectively.
+
+#### Evaluation
+
+The evaluation in MMDet 2.x strictly binds with the dataset. In contrast, MMDet 3.x decomposes the evaluation from dataset so that all the detection datasets can evaluate with COCO AP and other metrics implemented in MMDet 3.x.
+MMDet 3.x mainly implements corresponding metrics for each dataset, which are manipulated by [Evaluator](https://mmengine.readthedocs.io/en/latest/design/evaluator.html) to complete the evaluation.
+Users can build an evaluator in MMDet 3.x to conduct offline evaluation, i.e., evaluate predictions that may not produce in MMDet 3.x with the dataset as long as the dataset and the prediction follow the dataset conventions. More details can be found in the [tutorial in mmengine](https://mmengine.readthedocs.io/en/latest/tutorials/evaluation.html).
+
+#### Visualization
+
+The functions of visualization in MMDet 2.x are removed. Instead, in OpenMMLab 2.0 projects, we use [Visualizer](https://mmengine.readthedocs.io/en/latest/design/visualization.html) to visualize data. MMDet 3.x implements `DetLocalVisualizer` to allow visualization of ground truths, model predictions, feature maps, etc., at any place. It also supports sending the visualization data to any external visualization backends such as Tensorboard.
+
+### Improvements
+
+- Optimized training and testing speed of FCOS, RetinaNet, Faster R-CNN, Mask R-CNN, and Cascade R-CNN. The training speed of those models with some common training strategies is also optimized, including those with synchronized batch normalization and mixed precision training.
+- Support mixed precision training of all the models. However, some models may get undesirable performance due to some numerical issues. We will update the documentation and list the results (accuracy of failure) of mixed precision training.
+- Release strong baselines of some popular object detectors. Their accuracy and pre-trained checkpoints will be released.
+
+### Bug Fixes
+
+- DeepFashion dataset: the config and results have been updated.
+
+### New Features
+
+1. Support a general semi-supervised learning framework that works with all the object detectors supported in MMDet 3.x. Please refer to [semi-supervised object detection](../user_guides/semi_det.md) for details.
+2. Enable all the single-stage detectors to serve as region proposal networks. We give [an example of using FCOS as RPN](../user_guides/single_stage_as_rpn.md).
+3. Support a semi-supervised object detection algorithm: [SoftTeacher](https://arxiv.org/abs/2106.09018).
+4. Support [the updated CenterNet](https://arxiv.org/abs/2103.07461).
+5. Support data structures `HorizontalBoxes` and `BaseBoxes` to encapsulate different kinds of bounding boxes. We are migrating to use data structures of boxes to replace the use of pure tensor boxes. This will unify the usages of different kinds of bounding boxes in MMDet 3.x and MMRotate 1.x to simplify the implementation and reduce redundant codes.
+
+### Planned changes
+
+We list several planned changes of MMDet 3.0.0rc0 so that the community could more comprehensively know the progress of MMDet 3.x. Feel free to create a PR, issue, or discussion if you are interested, have any suggestions and feedback, or want to participate.
+
+1. Test-time augmentation: which is supported in MMDet 2.x, is not implemented in this version due to the limited time slot. We will support it in the following releases with a new and simplified design.
+2. Inference interfaces: unified inference interfaces will be supported in the future to ease the use of released models.
+3. Interfaces of useful tools that can be used in Jupyter Notebook or Colab: more useful tools that are implemented in the `tools` directory will have their python interfaces so that they can be used in Jupyter Notebook, Colab, and downstream libraries.
+4. Documentation: we will add more design docs, tutorials, and migration guidance so that the community can deep dive into our new design, participate the future development, and smoothly migrate downstream libraries to MMDet 3.x.
+5. Wandb visualization: MMDet 2.x supports data visualization since v2.25.0, which has not been migrated to MMDet 3.x for now. Since WandB provides strong visualization and experiment management capabilities, a `DetWandBVisualizer` and maybe a hook are planned to fully migrate those functionalities from MMDet 2.x.
+6. Full support of WiderFace dataset (#8508) and Fast R-CNN: we are verifying their functionalities and will fix related issues soon.
+7. Migrate DETR-series algorithms (#8655, #8533) and YOLOv3 on IPU (#8552) from MMDet 2.x.
+
+### Contributors
+
+A total of 11 developers contributed to this release.
+Thanks @shuxp, @wanghonglie, @Czm369, @BIGWangYuDong, @zytx121, @jbwang1997, @chhluo, @jshilong, @RangiLyu, @hhaAndroid, @ZwwWayne