def test_registry(self) -> None: """ Test registering and accessing objects in the Registry. """ OBJECT_REGISTRY = Registry("OBJECT") @OBJECT_REGISTRY.register() class Object1: pass with self.assertRaises(Exception) as err: OBJECT_REGISTRY.register(Object1) self.assertTrue( "An object named 'Object1' was already registered in 'OBJECT' registry!" in str(err.exception) ) self.assertEqual(OBJECT_REGISTRY.get("Object1"), Object1) with self.assertRaises(KeyError) as err: OBJECT_REGISTRY.get("Object2") self.assertTrue( "No object named 'Object2' found in 'OBJECT' registry!" in str(err.exception) )
from fvcore.common.registry import Registry D2LAYER_REGISTRY = Registry("D2LAYER_REGISTRY") # noqa F401 isort:skip D2LAYER_REGISTRY.__doc__ = """ """ def build_d2layer(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ name = cfg.name return D2LAYER_REGISTRY.get(name)(cfg=cfg, **kwargs)
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved from fvcore.common.registry import Registry DISCRIMINATOR_REGISTRY = Registry("DISCRIMINATOR_REGISTRY") # noqa F401 isort:skip DISCRIMINATOR_REGISTRY.__doc__ = """ """ GENERATOR_REGISTRY = Registry("GENERATOR_REGISTRY") # noqa F401 isort:skip GENERATOR_REGISTRY.__doc__ = """ """ def build_discriminator(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ name = cfg.name return DISCRIMINATOR_REGISTRY.get(name)(cfg=cfg, **kwargs) def build_generator(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ name = cfg.name return GENERATOR_REGISTRY.get(name)(cfg=cfg, **kwargs)
""" @author: Yuhao Cheng @contact: yuhao.cheng[at]outlook.com """ from fvcore.common.registry import Registry LOSS_REGISTRY = Registry("LOSS") LOSS_REGISTRY.__doc__ = """ Registry for loss function classes """
from fvcore.common.registry import Registry RESNEST_DATASETS_REGISTRY = Registry('RESNEST_DATASETS') def get_dataset(dataset_name): return RESNEST_DATASETS_REGISTRY.get(dataset_name)
#!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. """Model construction functions.""" import torch from fvcore.common.registry import Registry MODEL_REGISTRY = Registry("MODEL") MODEL_REGISTRY.__doc__ = """ Registry for video model. The registered object will be called with `obj(cfg)`. The call should return a `torch.nn.Module` object. """ def build_model(cfg, gpu_id=None): """ Builds the video model. Args: cfg (configs): configs that contains the hyper-parameters to build the backbone. Details can be seen in slowfast/config/defaults.py. gpu_id (Optional[int]): specify the gpu index to build model. """ if torch.cuda.is_available(): assert ( cfg.NUM_GPUS <= torch.cuda.device_count() ), "Cannot use more GPU devices than available" else: assert (
if BASE_KEY in cfg: cfg[BASE_KEY] = reroute_config_path(cfg[BASE_KEY]) return cfg def mock_unsafe_load(f): cfg = _unsafe_load(f) if BASE_KEY in cfg: cfg[BASE_KEY] = reroute_config_path(cfg[BASE_KEY]) return cfg with mock.patch("yaml.safe_load", side_effect=mock_safe_load): with mock.patch("yaml.unsafe_load", side_effect=mock_unsafe_load): yield CONFIG_SCALING_METHOD_REGISTRY = Registry("CONFIG_SCALING_METHOD") def auto_scale_world_size(cfg, new_world_size): """ Usually the config file is written for a specific number of devices, this method scales the config (in-place!) according to the actual world size using the pre-registered scaling methods specified as cfg.SOLVER.AUTO_SCALING_METHODS. Note for registering scaling methods: - The method will only be called when scaling is needed. It won't be called if SOLVER.REFERENCE_WORLD_SIZE is 0 or equal to target world size. Thus cfg.SOLVER.REFERENCE_WORLD_SIZE will always be positive. - The method updates cfg in-place, no return is required. - No need for changing SOLVER.REFERENCE_WORLD_SIZE.
# os.environ["CUDA_VISIBLE_DEVICES"]="0" from fastai.vision import * from fastai.vision.models import WideResNet from fvcore.common.registry import Registry UNET_ENCODE = Registry("UNET_ENCODE") @UNET_ENCODE.register() def resnet18(): return nn.Sequential(*list(models.resnet18( pretrained=True).children())[:-2]) @UNET_ENCODE.register() def densenet121(): return nn.Sequential(*list(models.densenet121( pretrained=True).children())[0]) @UNET_ENCODE.register() def densenet169(): return nn.Sequential(*list(models.densenet169( pretrained=True).children())[0]) @UNET_ENCODE.register() def densenet201(): return nn.Sequential(*list(models.densenet201( pretrained=True).children())[0])
import contextlib import copy import logging from typing import List import mock import yaml from d2go.registry.builtin import CONFIG_UPDATER_REGISTRY from detectron2.config import CfgNode as _CfgNode from fvcore.common.registry import Registry from .utils import reroute_config_path logger = logging.getLogger(__name__) CONFIG_CUSTOM_PARSE_REGISTRY = Registry("CONFIG_CUSTOM_PARSE") DEFAULTS_GENERATOR_KEY = "_DEFAULTS_" def _opts_to_dict(opts: List[str]): ret = {} for full_key, v in zip(opts[0::2], opts[1::2]): keys = full_key.split(".") cur = ret for key in keys[:-1]: if key not in cur: cur[key] = {} cur = cur[key] cur[keys[-1]] = v return ret
##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ## Created by: Hang Zhang ## Email: [email protected] ## Copyright (c) 2020 ## ## LICENSE file in the root directory of this source tree ##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ import torch from torchvision.transforms import * from .transforms import * from fvcore.common.registry import Registry RESNEST_TRANSFORMS_REGISTRY = Registry('RESNEST_TRANSFORMS') def get_transform(dataset_name): return RESNEST_TRANSFORMS_REGISTRY.get(dataset_name.lower()) @RESNEST_TRANSFORMS_REGISTRY.register() def imagenet(base_size=None, crop_size=224, rand_aug=False): normalize = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) base_size = base_size if base_size is not None else int(1.0 * crop_size / 0.875) train_transforms = [] val_transforms = [] if rand_aug: from .autoaug import RandAugment train_transforms.append(RandAugment(2, 12))
""" @author: Yuhao Cheng @contact: yuhao.cheng[at]outlook.com """ from fvcore.common.registry import Registry HOOK_REGISTRY = Registry("HOOK") HOOK_REGISTRY.__doc__ = """ Registry for hook functional classes """
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved from fvcore.common.registry import Registry GAN_METRIC_REGISTRY = Registry("GAN_METRIC_REGISTRY") # noqa F401 isort:skip GAN_METRIC_REGISTRY.__doc__ = """ """ def build_GAN_metric_dict(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ if cfg.GAN_metric.get('names') is None: return {} ret_dict = {} for name in cfg.GAN_metric.names: ret_dict.update( {name: GAN_METRIC_REGISTRY.get(name)(cfg=cfg, **kwargs)}) return ret_dict def build_GAN_metric(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ metric = GAN_METRIC_REGISTRY.get(cfg.name)(cfg=cfg, **kwargs) return metric
from fvcore.common.registry import Registry RESNEST_MODELS_REGISTRY = Registry('RESNEST_MODELS') def get_model(model_name): return RESNEST_MODELS_REGISTRY.get(model_name)
from fvcore.common.registry import Registry OPS_REGISTRY = Registry("OPS_REGISTRY") # noqa F401 isort:skip OPS_REGISTRY.__doc__ = """ """ def build_ops(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ name = cfg.name return OPS_REGISTRY.get(name)(cfg=cfg, **kwargs) LAYER_REGISTRY = Registry("LAYER_REGISTRY") # noqa F401 isort:skip LAYER_REGISTRY.__doc__ = """ """ def build_layer(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ name = cfg.name return LAYER_REGISTRY.get(name)(cfg=cfg, **kwargs)
from fvcore.common.registry import Registry import torch.nn as nn BACKBONE_REGISTRY = Registry("BACKBONE") BACKBONE_REGISTRY.__doc__ = """ Registry for backbones, which extract feature maps from images The registered object must be a callable that accepts two arguments: 1. A :class:`detectron2.config.CfgNode` 2. A :class:`detectron2.layers.ShapeSpec`, which contains the input shape specification. It must returns an instance of :class:`Backbone`. """ def build_backbone(cfg): """ Build a backbone from `cfg.MODEL.BACKBONE.NAME`. Returns: an instance of :class:`Backbone` """ backbone_name = cfg.MODEL.BACKBONE.NAME backbone = BACKBONE_REGISTRY.get(backbone_name)(cfg) return backbone def get_norm(cfg, out_channels, momentum=0.1): """ Args: norm (str or callable): either one of BN, SyncBN, FrozenBN, GN; or a callable that takes a channel number and returns the normalization layer as a nn.Module.
""" @author: Yuhao Cheng @contact: yuhao.cheng[at]outlook.com """ from fvcore.common.registry import Registry ENGINE_REGISTRY = Registry("ENGINE") ENGINE_REGISTRY.__doc__ = """ Registry for hook functional classes """
# def build_optimizer(cfg, **kwargs): # """ # Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. # Note that it does not load any weights from ``cfg``. # """ # return OPTIMIZER_REGISTRY.get(cfg.name)(cfg, **kwargs) # # # import logging from fvcore.common.registry import Registry from template_lib.utils import register_modules REGISTRY = Registry("OPTIMIZER_REGISTRY") # noqa F401 isort:skip OPTIMIZER_REGISTRY = REGISTRY REGISTRY.__doc__ = """ """ def _build(cfg, **kwargs): logging.getLogger('tl').info(f"Building {cfg.name} ...") register_modules(register_modules=cfg.get('register_modules', {})) ret = REGISTRY.get(cfg.name)(cfg=cfg, **kwargs) REGISTRY._obj_map.clear() return ret def build_optimizer(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``.
""" @author: Yuhao Cheng @contact: yuhao.cheng[at]outlook.com """ from fvcore.common.registry import Registry DATASET_REGISTRY = Registry("DATASET") DATASET_REGISTRY.__doc__ = """ Registry for dataset classes """ DATASET_FACTORY_REGISTRY = Registry("DATASET_FACTORY") DATASET_FACTORY_REGISTRY.__doc__ = """ Registry for dataset factory classes """ EVAL_METHOD_REGISTRY = Registry("EVAL_METHOD") EVAL_METHOD_REGISTRY.__doc__ = """ Registry for eval method classes """
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved from fvcore.common.registry import Registry DATASET_MAPPER_REGISTRY = Registry( "DATASET_MAPPER_REGISTRY") # noqa F401 isort:skip DATASET_MAPPER_REGISTRY.__doc__ = """ """ def build_dataset_mapper(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ name = cfg.name if name.lower() == 'none': return None return DATASET_MAPPER_REGISTRY.get(name)(cfg=cfg, **kwargs)
import logging from fvcore.common.registry import Registry from template_lib.utils import register_modules REGISTRY = Registry("MODEL_REGISTRY") # noqa F401 isort:skip MODEL_REGISTRY = REGISTRY REGISTRY.__doc__ = """ """ def _build(cfg, **kwargs): logging.getLogger('tl').info(f"Building {cfg.name} ...") register_modules(register_modules=cfg.get('register_modules', {})) ret = REGISTRY.get(cfg.name)(cfg=cfg, **kwargs) REGISTRY._obj_map.clear() return ret def build_model(cfg, **kwargs): """ Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. Note that it does not load any weights from ``cfg``. """ return _build(cfg, **kwargs)
# # # def build_d2distributions(cfg, **kwargs): # """ # Build the whole model architecture, defined by ``cfg.MODEL.META_ARCHITECTURE``. # Note that it does not load any weights from ``cfg``. # """ # return D2DISTRIBUTIONS_REGISTRY.get(cfg.name)(cfg, **kwargs) # import logging from fvcore.common.registry import Registry from template_lib.utils import register_modules REGISTRY = Registry("DISTRIBUTIONS_REGISTRY") # noqa F401 isort:skip DISTRIBUTIONS_REGISTRY = REGISTRY REGISTRY.__doc__ = """ """ def _build(cfg, **kwargs): logging.getLogger('tl').info(f"Building {cfg.name} ...") register_modules(register_modules=cfg.get('register_modules', {})) ret = REGISTRY.get(cfg.name)(cfg=cfg, **kwargs) REGISTRY._obj_map.clear() return ret def build_distributions(cfg, **kwargs):
""" model construction function """ import torch import torch.nn as nn from fvcore.common.registry import Registry from torch.nn import init DATASET_REGISTRY=Registry("DATASET") def build_dataset(dataset_name,mode,cfg,): """ :param cfg: :param dataset_name: avenue :param mode: train /test :return: """ # print("MODEL_REGISTRY", MODEL_REGISTRY.__dict__) name=dataset_name.capitalize() # init model with xavier return DATASET_REGISTRY.get(name)(cfg,mode) if __name__=="__main__": print("dataset register")
""" @author: Yuhao Cheng @contact: yuhao.cheng[at]outlook.com """ from fvcore.common.registry import Registry META_ARCH_REGISTRY = Registry("META_ARCH") META_ARCH_REGISTRY.__doc__ = """ Registry for meta-architectures, i.e. the whole model. The registered object will be called with `obj(cfg)` and expected to return a `nn.Module` object. """ BASE_ARCH_REGISTRY = Registry("BASE_ARCH") BASE_ARCH_REGISTRY.__doc__ = """ Registry for base-architectures, i.e. the backbone model. The registered object will be called with `obj(cfg)` and expected to return a `nn.Module` object. """ AUX_ARCH_REGISTRY = Registry("AUX_ARCH") AUX_ARCH_REGISTRY.__doc__ = """ Registry for auxiliary-architectures, i.e. the backbone model. The registered object will be called with `obj(cfg)` and expected to return a `nn.Module` object. """