MMCV implements registry to manage different modules that share similar functionalities, e.g., backbones, head, and necks, in detectors. Most projects in OpenMMLab use registry to manage modules of datasets and models, such as MMDetection, MMDetection3D, MMClassification, MMEditing, etc.

What is registry

In MMCV, registry can be regarded as a mapping that maps a class to a string. These classes contained by a single registry usually have similar APIs but implement different algorithms or support different datasets. With the registry, users can find and instantiate the class through its corresponding string, and use the instantiated module as they want. One typical example is the config systems in most OpenMMLab projects, which use the registry to create hooks, runners, models, and datasets, through configs. The API reference could be find here.

To manage your modules in the codebase by Registry, there are three steps as below.

  1. Create a build method (optional, in most cases you can just use the default one).

  2. Create a registry.

  3. Use this registry to manage the modules.

build_func argument of Registry is to customize how to instantiate the class instance, the default one is build_from_cfg implemented here.

A Simple Example

Here we show a simple example of using registry to manage modules in a package. You can find more practical examples in OpenMMLab projects.

Assuming we want to implement a series of Dataset Converter for converting different formats of data to the expected data format. We create a directory as a package named converters. In the package, we first create a file to implement builders, named converters/, as below

from mmcv.utils import Registry
# create a registry for converters
CONVERTERS = Registry('converter')

Then we can implement different converters in the package. For example, implement Converter1 in converters/

from .builder import CONVERTERS

# use the registry to manage the module
class Converter1(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

The key step to use registry for managing the modules is to register the implemented module into the registry CONVERTERS through @CONVERTERS.register_module() when you are creating the module. By this way, a mapping between a string and the class is built and maintained by CONVERTERS as below

'Converter1' -> <class 'Converter1'>

If the module is successfully registered, you can use this converter through configs as

converter_cfg = dict(type='Converter1', a=a_value, b=b_value)
converter =

Customize Build Function

Suppose we would like to customize how converters are built, we could implement a customized build_func and pass it into the registry.

from mmcv.utils import Registry

# create a build function
def build_converter(cfg, registry, *args, **kwargs):
    cfg_ = cfg.copy()
    converter_type = cfg_.pop('type')
    if converter_type not in registry:
        raise KeyError(f'Unrecognized converter type {converter_type}')
        converter_cls = registry.get(converter_type)

    converter = converter_cls(*args, **kwargs, **cfg_)
    return converter

# create a registry for converters and pass ``build_converter`` function
CONVERTERS = Registry('converter', build_func=build_converter)


In this example, we demonstrate how to use the build_func argument to customize the way to build a class instance. The functionality is similar to the default build_from_cfg. In most cases, default one would be sufficient. build_model_from_cfg is also implemented to build PyTorch module in nn.Sequentail, you may directly use them instead of implementing by yourself.

Hierarchy Registry

You could also build modules from more than one OpenMMLab frameworks, e.g. you could use all backbones in MMClassification for object detectors in MMDetection, you may also combine an object detection model in MMDetection and semantic segmentation model in MMSegmentation.

All MODELS registries of downstream codebases are children registries of MMCV’s MODELS registry. Basically, there are two ways to build a module from child or sibling registries.

  1. Build from children registries.

    For example:

    In MMDetection we define:

    from mmcv.utils import Registry
    from mmcv.cnn import MODELS as MMCV_MODELS
    MODELS = Registry('model', parent=MMCV_MODELS)
    class NetA(nn.Module):
        def forward(self, x):
            return x

    In MMClassification we define:

    from mmcv.utils import Registry
    from mmcv.cnn import MODELS as MMCV_MODELS
    MODELS = Registry('model', parent=MMCV_MODELS)
    class NetB(nn.Module):
        def forward(self, x):
            return x + 1

    We could build two net in either MMDetection or MMClassification by:

    from mmdet.models import MODELS
    net_a ='NetA'))
    net_b ='mmcls.NetB'))


    from mmcls.models import MODELS
    net_a ='mmdet.NetA'))
    net_b ='NetB'))
  2. Build from parent registry.

    The shared MODELS registry in MMCV is the parent registry for all downstream codebases (root registry):

    from mmcv.cnn import MODELS as MMCV_MODELS
    net_a ='mmdet.NetA'))
    net_b ='mmcls.NetB'))
Read the Docs v: v1.3.14
On Read the Docs
Project Home

Free document hosting provided by Read the Docs.