A registry to map strings to classes or functions. Registered object could be built from registry. Meanwhile, registered functions could be c

A base data interface that supports Tensor-like and dict-like operations. A typical data elements refer to predicted results or ground truth

Optimizer wrapper provides a common interface for updating parameters. Optimizer wrapper provides a unified interface for single precision tr

Petrel storage backend (for internal usage). PetrelBackend supports reading and writing data to multiple clusters. If the file path contains

Save checkpoints periodically. Args: interval (int): The saving period. If ``by_epoch=True``, interval indicates epochs, othe

r"""BaseDataset for open source projects in OpenMMLab. The annotation format is shown as follows. .. code-block:: none {

A training helper for PyTorch. Runner object can be built from config by ``runner = Runner.from_cfg(cfg)`` where the ``cfg`` usually contains

A facility for config and config files. It supports common file formats as configs: python/json/yaml. ``Config.fromfile`` can parse a diction

A dictionary container of :obj:`OptimWrapper`. If runner is training with multiple optimizers, all optimizer wrappers should be managed by :o

MMEngine provides a Visualizer class that uses the ``Matplotlib`` library as the backend. It has the following functions: - Basic drawing met

A general file client to access files in different backends. The client loads a file or text in a specified backend from its path and returns

Base hook class. All hooks should inherit from this class.

Provides access to per-submodule model flop count obtained by tracing a model with pytorch's jit tracing functionality. By default, comes wit

A dictionary for config which has the same interface as python's built- in dictionary and can be used as a normal dictionary. The Config clas

Collect logs from different components of ``Runner`` and write them to terminal, JSON file, tensorboard and wandb .etc. ``LoggerHook`` is use

Default constructor for optimizers. By default, each parameter share the same optimizer settings, and we provide an argument ``paramwise_cfg`

Raw local storage backend.

LazyObject is used to lazily initialize the imported module during parsing the configuration file. During parsing process, the syntax like:

Unified storage format for different log types. ``HistoryBuffer`` records the history of log for further statistics. Examples: >>> h

Early stop the training when the monitored metric reached a plateau. Args: monitor (str): The monitored metric key to decide early stoppi

A log processor used to format log information collected from ``runner.message_hub.log_scalars``. ``LogProcessor`` instance is built by runne

A subclass of :class:`OptimWrapper` that supports automatic mixed precision training based on torch.cuda.amp. ``AmpOptimWrapper`` provides a

Wrapper class to compose multiple :class:`BaseMetric` instances. Args: metrics (dict or BaseMetric or Sequence): The config of metrics.

Support training model with FullyShardedDataParallel (FSDP). Keyword Args: model_wrapper (dict, optional): Config dict for model wrapper.

A hook to analyze performance during training and inference. PyTorch Profiler is a tool that allows the collection of the performance metrics

Reduce the learning rate of each parameter group when a metric has stopped improving. Models often benefit from reducing the learning rate by

Reduce the momentum of each parameter group when a metric has stopped improving. Models often benefit from reducing the momentum by a factor of

Reduce the parameters of each parameter group when a metric has stopped improving. Models often benefit from reducing the parameters by a factor o

Decays the specified learning rate in each parameter group by gamma once the number of epoch reaches one of the milestones. Notice that such decay

Image pre-processor for normalization and bgr to rgb conversion. Accepts the data sampled by the dataloader, and preprocesses it into the for

Decays the learning rate of each parameter group by linearly changing small multiplicative factor until the number of epoch reaches a pre-defined

Decays the parameter value of each parameter group by gamma every step_size epochs. Notice that such decay can happen simultaneously with othe

Decays the momentum of each parameter group by linearly changing small multiplicative factor until the number of epoch reaches a pre-defined m

Decays the momentum of each parameter group by gamma every step_size epochs. Notice that such decay can happen simultaneously with other changes

The default data sampler for both distributed and non-distributed environment. It has several differences from the PyTorch ``DistributedSampl

Decays the parameter value of each parameter group by linearly changing small multiplicative factor until the number of epoch reaches a pre-define

Decays the learning rate of each parameter group by gamma every step_size epochs. Notice that such decay can happen simultaneously with other

Raise error when failed to parse pure Python style config files.

Decays the momentum of each parameter group by gamma every epoch. Args: optimizer (Optimizer or OptimWrapper): optimizer or Wrapped

Local visualization backend class. It can write image, config, scalars, etc. to the local hard disk. You can get the drawing backend thro

Wandb visualization backend class. Examples: >>> from mmengine.visualization import WandbVisBackend >>> import numpy as np

A subclass of :class:`OptimWrapper` that supports automatic mixed precision training based on apex.amp. ``ApexOptimWrapper`` provides a unifi

Compose multiple transforms sequentially. Args: transforms (Sequence[dict, callable], optional): Sequence of transform object

A wrapper of concatenated dataset. Same as ``torch.utils.data.dataset.ConcatDataset`` and support lazy_init. Note: ``ConcatDataset``

r"""Set the parameter value of each parameter group using a cosine annealing schedule, where :math:`\eta_{max}` is set to the initial value and

Decays the learning rate of each parameter group by gamma every epoch. Args: optimizer (Optimizer or OptimWrapper): Wrapped optimizer.

Decays the parameter value of each parameter group by gamma every epoch. Args: optimizer (Optimizer or BaseOptimWrapper): optimizer or Wr

MLflow visualization backend class. It can write images, config, scalars, etc. to a mlflow file. Examples: >>> from mmengine.vis

Aim visualization backend class. Examples: >>> from mmengine.visualization import AimVisBackend >>> import numpy as np >>

Clearml visualization backend class. It requires `clearml`_ to be installed. Examples: >>> from mmengine.visualization import ClearML

r"""Set the momentum of each parameter group using a cosine annealing schedule, where :math:`\eta_{max}` is set to the initial value and :math

DVCLive visualization backend class. Examples: >>> from mmengine.visualization import DVCLiveVisBackend >>> import numpy as np

It's designed for iteration-based runner and yields a mini-batch indices each time. The implementation logic is referred to https://githu

Neptune visualization backend class. Examples: >>> from mmengine.visualization import NeptuneVisBackend >>> from mmengine import

A network with nested submodules for testing the ability to correctly capture scope information.

Tensorboard visualization backend class. It can write images, config, scalars, etc. to a tensorboard file. Examples: >>> from mm

r"""Set the learning rate of each parameter group using a cosine annealing schedule, where :math:`\eta_{max}` is set to the initial value and

Sets the momentum of each parameter group according to the cosine annealing with restarts scheme. The cosine restart policy anneals the moment

Sets the parameters of each parameter group according to the cosine annealing with restarts scheme. The cosine restart policy anneals the para

A Hook to apply Exponential Moving Average (EMA) on the model during training. Note: - EMAHook takes priority over CheckpointHook.

r"""Implements the exponential moving average (EMA) of the model. All parameters are updated by the formula as below: .. math::

A distributed model wrapper used for training,testing and validation in loop. Different from DistributedDataParallel, MMDistributedDataParall

Decays the specified momentum in each parameter group by gamma once the number of epoch reaches one of the milestones. Notice that such decay can

A hook to update some hyper-parameters in optimizer, e.g., learning rate and momentum.

Sets the learning rate of each parameter group according to the cosine annealing with restarts scheme. The cosine restart policy anneals the l

Data structure for instance-level annotations or predictions. Subclass of :class:`BaseDataElement`. All value in `data_fields` should have th

Formatted logger used to record messages. ``MMLogger`` can create formatted logger to log message with different log levels and get instance

Decays the specified parameter in each parameter group by gamma once the number of epoch reaches one of the milestones. Notice that such decay can

NPUProfiler to analyze performance during training. NPU Profiling is used to count the device execution time of all operators. The torch_npu.

Provides access to per-submodule model activation count obtained by tracing a model with pytorch's jit tracing functionality. By default, com

Dump model predictions to a pickle file for offline evaluation. Args: out_file_path (str): Path of the dumped file. Must end with '.pkl'

Provides access to per-submodule model statistics obtained by tracing a model with pytorch's jit tracing functionality. Calculates a statisti

A wrapper for sharding Module parameters across data parallel workers. Different from FullyShardedDataParallel, MMFullyShardedDataParallel im

A DistributedDataParallel wrapper for models in MMGeneration. In MMedting and MMGeneration there is a need to wrap different modules in the m

Decays the momentum of each parameter group in a polynomial decay scheme. Notice that such decay can happen simultaneously with other changes

Implements the stochastic weight averaging (SWA) of the model. Stochastic Weight Averaging was proposed in `Averaging Weights Leads to Wider

A tool that counts the average running time of a function or a method. Users can use it as a decorator or context manager to calculate the average

Base data pre-processor used for copying data to the target device. Subclasses inherit from ``BaseDataPreprocessor`` could override the forwa

A wrapper of class balanced dataset. Suitable for training on class imbalanced datasets like LVIS. Following the sampling strategy in the `pa

Decays the momentum value of each parameter group by a small constant factor until the number of epoch reaches a pre-defined milestone: ``end``.

HTTP and HTTPS storage bachend.

Convert the import syntax to the assignment of :class:`mmengine.config.LazyObject` and preload the base variable before parsing the configurat

The attribute of the LazyObject. When parsing the configuration file, the imported syntax will be parsed as the assignment ``LazyObject``. Du

Message hub for component interaction. MessageHub is created and accessed in the same way as ManagerMixin. ``MessageHub`` will record log inf

r"""Exponential moving average (EMA) with momentum annealing strategy. Args: model (nn.Module): The model to be averaged. momentu

r"""Sets the learning rate of each parameter group according to the 1cycle learning rate policy. The 1cycle policy anneals the learning rate from