|
|
| """
|
| Backward compatibility of configs.
|
|
|
| Instructions to bump version:
|
| + It's not needed to bump version if new keys are added.
|
| It's only needed when backward-incompatible changes happen
|
| (i.e., some existing keys disappear, or the meaning of a key changes)
|
| + To bump version, do the following:
|
| 1. Increment _C.VERSION in defaults.py
|
| 2. Add a converter in this file.
|
|
|
| Each ConverterVX has a function "upgrade" which in-place upgrades config from X-1 to X,
|
| and a function "downgrade" which in-place downgrades config from X to X-1
|
|
|
| In each function, VERSION is left unchanged.
|
|
|
| Each converter assumes that its input has the relevant keys
|
| (i.e., the input is not a partial config).
|
| 3. Run the tests (test_config.py) to make sure the upgrade & downgrade
|
| functions are consistent.
|
| """
|
|
|
| import logging
|
| from typing import List, Optional, Tuple
|
|
|
| from .config import CfgNode as CN
|
| from .defaults import _C
|
|
|
| __all__ = ["upgrade_config", "downgrade_config"]
|
|
|
|
|
| def upgrade_config(cfg: CN, to_version: Optional[int] = None) -> CN:
|
| """
|
| Upgrade a config from its current version to a newer version.
|
|
|
| Args:
|
| cfg (CfgNode):
|
| to_version (int): defaults to the latest version.
|
| """
|
| cfg = cfg.clone()
|
| if to_version is None:
|
| to_version = _C.VERSION
|
|
|
| assert cfg.VERSION <= to_version, "Cannot upgrade from v{} to v{}!".format(
|
| cfg.VERSION, to_version
|
| )
|
| for k in range(cfg.VERSION, to_version):
|
| converter = globals()["ConverterV" + str(k + 1)]
|
| converter.upgrade(cfg)
|
| cfg.VERSION = k + 1
|
| return cfg
|
|
|
|
|
| def downgrade_config(cfg: CN, to_version: int) -> CN:
|
| """
|
| Downgrade a config from its current version to an older version.
|
|
|
| Args:
|
| cfg (CfgNode):
|
| to_version (int):
|
|
|
| Note:
|
| A general downgrade of arbitrary configs is not always possible due to the
|
| different functionalities in different versions.
|
| The purpose of downgrade is only to recover the defaults in old versions,
|
| allowing it to load an old partial yaml config.
|
| Therefore, the implementation only needs to fill in the default values
|
| in the old version when a general downgrade is not possible.
|
| """
|
| cfg = cfg.clone()
|
| assert cfg.VERSION >= to_version, "Cannot downgrade from v{} to v{}!".format(
|
| cfg.VERSION, to_version
|
| )
|
| for k in range(cfg.VERSION, to_version, -1):
|
| converter = globals()["ConverterV" + str(k)]
|
| converter.downgrade(cfg)
|
| cfg.VERSION = k - 1
|
| return cfg
|
|
|
|
|
| def guess_version(cfg: CN, filename: str) -> int:
|
| """
|
| Guess the version of a partial config where the VERSION field is not specified.
|
| Returns the version, or the latest if cannot make a guess.
|
|
|
| This makes it easier for users to migrate.
|
| """
|
| logger = logging.getLogger(__name__)
|
|
|
| def _has(name: str) -> bool:
|
| cur = cfg
|
| for n in name.split("."):
|
| if n not in cur:
|
| return False
|
| cur = cur[n]
|
| return True
|
|
|
|
|
| ret = None
|
| if _has("MODEL.WEIGHT") or _has("TEST.AUG_ON"):
|
| ret = 1
|
|
|
| if ret is not None:
|
| logger.warning("Config '{}' has no VERSION. Assuming it to be v{}.".format(filename, ret))
|
| else:
|
| ret = _C.VERSION
|
| logger.warning(
|
| "Config '{}' has no VERSION. Assuming it to be compatible with latest v{}.".format(
|
| filename, ret
|
| )
|
| )
|
| return ret
|
|
|
|
|
| def _rename(cfg: CN, old: str, new: str) -> None:
|
| old_keys = old.split(".")
|
| new_keys = new.split(".")
|
|
|
| def _set(key_seq: List[str], val: str) -> None:
|
| cur = cfg
|
| for k in key_seq[:-1]:
|
| if k not in cur:
|
| cur[k] = CN()
|
| cur = cur[k]
|
| cur[key_seq[-1]] = val
|
|
|
| def _get(key_seq: List[str]) -> CN:
|
| cur = cfg
|
| for k in key_seq:
|
| cur = cur[k]
|
| return cur
|
|
|
| def _del(key_seq: List[str]) -> None:
|
| cur = cfg
|
| for k in key_seq[:-1]:
|
| cur = cur[k]
|
| del cur[key_seq[-1]]
|
| if len(cur) == 0 and len(key_seq) > 1:
|
| _del(key_seq[:-1])
|
|
|
| _set(new_keys, _get(old_keys))
|
| _del(old_keys)
|
|
|
|
|
| class _RenameConverter:
|
| """
|
| A converter that handles simple rename.
|
| """
|
|
|
| RENAME: List[Tuple[str, str]] = []
|
|
|
| @classmethod
|
| def upgrade(cls, cfg: CN) -> None:
|
| for old, new in cls.RENAME:
|
| _rename(cfg, old, new)
|
|
|
| @classmethod
|
| def downgrade(cls, cfg: CN) -> None:
|
| for old, new in cls.RENAME[::-1]:
|
| _rename(cfg, new, old)
|
|
|
|
|
| class ConverterV1(_RenameConverter):
|
| RENAME = [("MODEL.RPN_HEAD.NAME", "MODEL.RPN.HEAD_NAME")]
|
|
|
|
|
| class ConverterV2(_RenameConverter):
|
| """
|
| A large bulk of rename, before public release.
|
| """
|
|
|
| RENAME = [
|
| ("MODEL.WEIGHT", "MODEL.WEIGHTS"),
|
| ("MODEL.PANOPTIC_FPN.SEMANTIC_LOSS_SCALE", "MODEL.SEM_SEG_HEAD.LOSS_WEIGHT"),
|
| ("MODEL.PANOPTIC_FPN.RPN_LOSS_SCALE", "MODEL.RPN.LOSS_WEIGHT"),
|
| ("MODEL.PANOPTIC_FPN.INSTANCE_LOSS_SCALE", "MODEL.PANOPTIC_FPN.INSTANCE_LOSS_WEIGHT"),
|
| ("MODEL.PANOPTIC_FPN.COMBINE_ON", "MODEL.PANOPTIC_FPN.COMBINE.ENABLED"),
|
| (
|
| "MODEL.PANOPTIC_FPN.COMBINE_OVERLAP_THRESHOLD",
|
| "MODEL.PANOPTIC_FPN.COMBINE.OVERLAP_THRESH",
|
| ),
|
| (
|
| "MODEL.PANOPTIC_FPN.COMBINE_STUFF_AREA_LIMIT",
|
| "MODEL.PANOPTIC_FPN.COMBINE.STUFF_AREA_LIMIT",
|
| ),
|
| (
|
| "MODEL.PANOPTIC_FPN.COMBINE_INSTANCES_CONFIDENCE_THRESHOLD",
|
| "MODEL.PANOPTIC_FPN.COMBINE.INSTANCES_CONFIDENCE_THRESH",
|
| ),
|
| ("MODEL.ROI_HEADS.SCORE_THRESH", "MODEL.ROI_HEADS.SCORE_THRESH_TEST"),
|
| ("MODEL.ROI_HEADS.NMS", "MODEL.ROI_HEADS.NMS_THRESH_TEST"),
|
| ("MODEL.RETINANET.INFERENCE_SCORE_THRESHOLD", "MODEL.RETINANET.SCORE_THRESH_TEST"),
|
| ("MODEL.RETINANET.INFERENCE_TOPK_CANDIDATES", "MODEL.RETINANET.TOPK_CANDIDATES_TEST"),
|
| ("MODEL.RETINANET.INFERENCE_NMS_THRESHOLD", "MODEL.RETINANET.NMS_THRESH_TEST"),
|
| ("TEST.DETECTIONS_PER_IMG", "TEST.DETECTIONS_PER_IMAGE"),
|
| ("TEST.AUG_ON", "TEST.AUG.ENABLED"),
|
| ("TEST.AUG_MIN_SIZES", "TEST.AUG.MIN_SIZES"),
|
| ("TEST.AUG_MAX_SIZE", "TEST.AUG.MAX_SIZE"),
|
| ("TEST.AUG_FLIP", "TEST.AUG.FLIP"),
|
| ]
|
|
|
| @classmethod
|
| def upgrade(cls, cfg: CN) -> None:
|
| super().upgrade(cfg)
|
|
|
| if cfg.MODEL.META_ARCHITECTURE == "RetinaNet":
|
| _rename(
|
| cfg, "MODEL.RETINANET.ANCHOR_ASPECT_RATIOS", "MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS"
|
| )
|
| _rename(cfg, "MODEL.RETINANET.ANCHOR_SIZES", "MODEL.ANCHOR_GENERATOR.SIZES")
|
| del cfg["MODEL"]["RPN"]["ANCHOR_SIZES"]
|
| del cfg["MODEL"]["RPN"]["ANCHOR_ASPECT_RATIOS"]
|
| else:
|
| _rename(cfg, "MODEL.RPN.ANCHOR_ASPECT_RATIOS", "MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS")
|
| _rename(cfg, "MODEL.RPN.ANCHOR_SIZES", "MODEL.ANCHOR_GENERATOR.SIZES")
|
| del cfg["MODEL"]["RETINANET"]["ANCHOR_SIZES"]
|
| del cfg["MODEL"]["RETINANET"]["ANCHOR_ASPECT_RATIOS"]
|
| del cfg["MODEL"]["RETINANET"]["ANCHOR_STRIDES"]
|
|
|
| @classmethod
|
| def downgrade(cls, cfg: CN) -> None:
|
| super().downgrade(cfg)
|
|
|
| _rename(cfg, "MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS", "MODEL.RPN.ANCHOR_ASPECT_RATIOS")
|
| _rename(cfg, "MODEL.ANCHOR_GENERATOR.SIZES", "MODEL.RPN.ANCHOR_SIZES")
|
| cfg.MODEL.RETINANET.ANCHOR_ASPECT_RATIOS = cfg.MODEL.RPN.ANCHOR_ASPECT_RATIOS
|
| cfg.MODEL.RETINANET.ANCHOR_SIZES = cfg.MODEL.RPN.ANCHOR_SIZES
|
| cfg.MODEL.RETINANET.ANCHOR_STRIDES = []
|
|
|
