| | |
| | from contextlib import contextmanager |
| | from typing import Dict, Iterator, List, Optional, Tuple |
| |
|
| | import torch |
| | import torch.nn as nn |
| |
|
| | from .optimizer_wrapper import OptimWrapper |
| |
|
| |
|
| | class OptimWrapperDict(OptimWrapper): |
| | """A dictionary container of :obj:`OptimWrapper`. |
| | |
| | If runner is training with multiple optimizers, all optimizer wrappers |
| | should be managed by :obj:`OptimWrapperDict` which is built by |
| | ``CustomOptimWrapperConstructor``. ``OptimWrapperDict`` will load and save |
| | the state dictionary of all optimizer wrappers. |
| | |
| | Consider the semantic ambiguity of calling :meth:``update_params``, |
| | :meth:`backward` of all optimizer wrappers, ``OptimWrapperDict`` will not |
| | implement these methods. |
| | |
| | Examples: |
| | >>> import torch.nn as nn |
| | >>> from torch.optim import SGD |
| | >>> from mmengine.optim import OptimWrapperDict, OptimWrapper |
| | >>> model1 = nn.Linear(1, 1) |
| | >>> model2 = nn.Linear(1, 1) |
| | >>> optim_wrapper1 = OptimWrapper(SGD(model1.parameters(), lr=0.1)) |
| | >>> optim_wrapper2 = OptimWrapper(SGD(model2.parameters(), lr=0.1)) |
| | >>> optim_wrapper_dict = OptimWrapperDict(model1=optim_wrapper1, |
| | >>> model2=optim_wrapper2) |
| | |
| | Note: |
| | The optimizer wrapper contained in ``OptimWrapperDict`` can be accessed |
| | in the same way as `dict`. |
| | |
| | Args: |
| | **optim_wrappers: A dictionary of ``OptimWrapper`` instance. |
| | """ |
| |
|
| | def __init__(self, **optim_wrapper_dict: OptimWrapper): |
| | for key, value in optim_wrapper_dict.items(): |
| | assert isinstance(value, OptimWrapper), ( |
| | '`OptimWrapperDict` only accept OptimWrapper instance, ' |
| | f'but got {key}: {type(value)}') |
| | self.optim_wrappers = optim_wrapper_dict |
| |
|
| | def update_params(self, |
| | loss: torch.Tensor, |
| | step_kwargs: Optional[Dict] = None, |
| | zero_kwargs: Optional[Dict] = None) -> None: |
| | """Update all optimizer wrappers would lead to a duplicate backward |
| | errors, and OptimWrapperDict does not know which optimizer wrapper |
| | should be updated. |
| | |
| | Therefore, this method is not implemented. The optimizer wrapper of |
| | OptimWrapperDict should be accessed and call its `update_params. |
| | """ |
| | raise NotImplementedError('`update_params` should be called by each ' |
| | 'optimizer separately`') |
| |
|
| | def backward(self, loss: torch.Tensor, **kwargs) -> None: |
| | """Since OptimWrapperDict doesn't know which optimizer wrapper's |
| | backward method should be called (``loss_scaler`` maybe different in |
| | different :obj:AmpOptimWrapper), this method is not implemented. |
| | |
| | The optimizer wrapper of OptimWrapperDict should be accessed and call |
| | its `backward. |
| | """ |
| | raise NotImplementedError('`backward` should be called by each ' |
| | 'optimizer separately`') |
| |
|
| | def step(self, **kwargs) -> None: |
| | """Since the backward method is not implemented, the step should not be |
| | implemented either.""" |
| | raise NotImplementedError('`step` should be called by each ' |
| | 'optimizer separately`') |
| |
|
| | def zero_grad(self, **kwargs) -> None: |
| | """Set the gradients of all optimizer wrappers to zero.""" |
| | for optim_wrapper in self.optim_wrappers.values(): |
| | optim_wrapper.zero_grad() |
| |
|
| | @contextmanager |
| | def optim_context(self, model: nn.Module): |
| | """``optim_context`` should be called by each optimizer separately.""" |
| | raise NotImplementedError( |
| | '`optim_context` should be called by each optimizer separately') |
| |
|
| | def initialize_count_status(self, model: nn.Module, cur_iter, |
| | max_iters) -> None: |
| | """Do nothing but provide unified interface for :obj:`OptimWrapper` |
| | |
| | Since ``OptimWrapperDict`` does not know the correspondence between |
| | model and optimizer wrapper. ``initialize_iter_status`` will do nothing |
| | and each optimizer wrapper should call ``initialize_iter_status`` |
| | separately. |
| | """ |
| | return |
| |
|
| | @property |
| | def param_groups(self): |
| | """Returns the parameter groups of each OptimWrapper.""" |
| | param_groups = dict() |
| | for key, value in self.optim_wrappers.items(): |
| | param_groups[key] = value.param_groups |
| | return param_groups |
| |
|
| | def get_lr(self) -> Dict[str, List[float]]: |
| | """Get the learning rate of all optimizers. |
| | |
| | Returns: |
| | Dict[str, List[float]]: Learning rate of all optimizers. |
| | """ |
| | lr_dict = dict() |
| | for name, optim_wrapper in self.optim_wrappers.items(): |
| | lr_dict[f'{name}.lr'] = optim_wrapper.get_lr()['lr'] |
| | return lr_dict |
| |
|
| | def get_momentum(self) -> Dict[str, List[float]]: |
| | """Get the momentum of all optimizers. |
| | |
| | Returns: |
| | Dict[str, List[float]]: momentum of all optimizers. |
| | """ |
| | momentum_dict = dict() |
| | for name, optim_wrapper in self.optim_wrappers.items(): |
| | momentum_dict[f'{name}.momentum'] = optim_wrapper.get_momentum( |
| | )['momentum'] |
| | return momentum_dict |
| |
|
| | def state_dict(self) -> dict: |
| | """Get the state dictionary of all optimizer wrappers. |
| | |
| | Returns: |
| | dict: Each key-value pair in the dictionary represents the name |
| | and state dictionary of corresponding :obj:`OptimWrapper`. |
| | """ |
| | state_dict = dict() |
| | for name, optim_wrapper in self.optim_wrappers.items(): |
| | state_dict[name] = optim_wrapper.state_dict() |
| | return state_dict |
| |
|
| | def load_state_dict(self, state_dict: dict) -> None: |
| | """Load the state dictionary from the ``state_dict``. |
| | |
| | Args: |
| | state_dict (dict): Each key-value pair in `state_dict` represents |
| | the name and the state dictionary of corresponding |
| | :obj:`OptimWrapper`. |
| | """ |
| | for name, _state_dict in state_dict.items(): |
| | assert name in self.optim_wrappers, ( |
| | f'Mismatched `state_dict`! cannot found {name} in ' |
| | 'OptimWrapperDict') |
| | self.optim_wrappers[name].load_state_dict(_state_dict) |
| |
|
| | def items(self) -> Iterator[Tuple[str, OptimWrapper]]: |
| | """A generator to get the name and corresponding |
| | :obj:`OptimWrapper`""" |
| | yield from self.optim_wrappers.items() |
| |
|
| | def values(self) -> Iterator[OptimWrapper]: |
| | """A generator to get :obj:`OptimWrapper`""" |
| | yield from self.optim_wrappers.values() |
| |
|
| | def keys(self) -> Iterator[str]: |
| | """A generator to get the name of :obj:`OptimWrapper`""" |
| | yield from self.optim_wrappers.keys() |
| |
|
| | def __getitem__(self, key: str) -> OptimWrapper: |
| | assert key in self.optim_wrappers, ( |
| | f'Cannot find {key} in OptimWrapperDict, please check ' |
| | 'your optimizer constructor.') |
| | return self.optim_wrappers[key] |
| |
|
| | def __contains__(self, key: str) -> bool: |
| | return key in self.optim_wrappers |
| |
|
| | def __len__(self) -> int: |
| | return len(self.optim_wrappers) |
| |
|
| | def __repr__(self) -> str: |
| | desc = '' |
| | for name, optim_wrapper in self.optim_wrappers.items(): |
| | desc += f'name: {name}\n' |
| | desc += repr(optim_wrapper) |
| | return desc |
| |
|
