[Feature] Support MPS device.

mmcls/__init__.py

@@ -48,7 +48,7 @@ def digit_version(version_str: str, length: int = 4):
 
 
 mmcv_minimum_version = '1.4.2'
-mmcv_maximum_version = '1.6.0'
+mmcv_maximum_version = '1.7.0'
 mmcv_version = digit_version(mmcv.__version__)
 
 

mmcls/apis/train.py

@@ -5,13 +5,13 @@
 import numpy as np
 import torch
 import torch.distributed as dist
-from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
 from mmcv.runner import (DistSamplerSeedHook, Fp16OptimizerHook,
                          build_optimizer, build_runner, get_dist_info)
 
 from mmcls.core import DistEvalHook, DistOptimizerHook, EvalHook
 from mmcls.datasets import build_dataloader, build_dataset
-from mmcls.utils import get_root_logger
+from mmcls.utils import (get_root_logger, wrap_distributed_model,
+                         wrap_non_distributed_model)
 
 
 def init_random_seed(seed=None, device='cuda'):
@@ -128,27 +128,15 @@ def train_model(model,
         find_unused_parameters = cfg.get('find_unused_parameters', False)
         # Sets the `find_unused_parameters` parameter in
         # torch.nn.parallel.DistributedDataParallel
-        model = MMDistributedDataParallel(
-            model.cuda(),
+        model = wrap_distributed_model(
+            model,
+            cfg.device,
             device_ids=[torch.cuda.current_device()],
             broadcast_buffers=False,
             find_unused_parameters=find_unused_parameters)
     else:
-        if device == 'cpu':
-            warnings.warn(
-                'The argument `device` is deprecated. To use cpu to train, '
-                'please refers to https://mmclassification.readthedocs.io/en'
-                '/latest/getting_started.html#train-a-model')
-            model = model.cpu()
-        elif device == 'ipu':
-            model = model.cpu()
-        else:
-            model = MMDataParallel(model, device_ids=cfg.gpu_ids)
-            if not model.device_ids:
-                from mmcv import __version__, digit_version
-                assert digit_version(__version__) >= (1, 4, 4), \
-                    'To train with CPU, please confirm your mmcv version ' \
-                    'is not lower than v1.4.4'
+        model = wrap_non_distributed_model(
+            model, cfg.device, device_ids=cfg.gpu_ids)
 
     # build runner
     optimizer = build_optimizer(model, cfg.optimizer)

mmcls/utils/__init__.py

@@ -1,8 +1,12 @@
 # Copyright (c) OpenMMLab. All rights reserved.
 from .collect_env import collect_env
+from .device import auto_select_device
+from .distribution import wrap_distributed_model, wrap_non_distributed_model
 from .logger import get_root_logger, load_json_log
 from .setup_env import setup_multi_processes
 
 __all__ = [
-    'collect_env', 'get_root_logger', 'load_json_log', 'setup_multi_processes'
+    'collect_env', 'get_root_logger', 'load_json_log', 'setup_multi_processes',
+    'wrap_non_distributed_model', 'wrap_distributed_model',
+    'auto_select_device'
 ]

mmcls/utils/device.py

@@ -0,0 +1,15 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmcv
+import torch
+from mmcv.utils import digit_version
+
+
+def auto_select_device() -> str:
+    mmcv_version = digit_version(mmcv.__version__)
+    if mmcv_version >= digit_version('1.6.0'):
+        from mmcv.device import get_device
+        return get_device()
+    elif torch.cuda.is_available():
+        return 'cuda'
+    else:
+        return 'cpu'

mmcls/utils/distribution.py

@@ -0,0 +1,58 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+
+
+def wrap_non_distributed_model(model, device='cuda', dim=0, *args, **kwargs):
+    """Wrap module in non-distributed environment by device type.
+
+    - For CUDA, wrap as :obj:`mmcv.parallel.MMDataParallel`.
+    - For MPS, wrap as :obj:`mmcv.device.mps.MPSDataParallel`.
+    - For CPU & IPU, not wrap the model.
+
+    Args:
+        model(:class:`nn.Module`): model to be parallelized.
+        device(str): device type, cuda, cpu or mlu. Defaults to cuda.
+        dim(int): Dimension used to scatter the data. Defaults to 0.
+
+    Returns:
+        model(nn.Module): the model to be parallelized.
+    """
+    if device == 'cuda':
+        from mmcv.parallel import MMDataParallel
+        model = MMDataParallel(model.cuda(), dim=dim, *args, **kwargs)
+    elif device == 'cpu':
+        model = model.cpu()
+    elif device == 'ipu':
+        model = model.cpu()
+    elif device == 'mps':
+        from mmcv.device import mps
+        model = mps.MPSDataParallel(model.to('mps'), dim=dim, *args, **kwargs)
+    else:
+        raise RuntimeError(f'Unavailable device "{device}"')
+
+    return model
+
+
+def wrap_distributed_model(model, device='cuda', *args, **kwargs):
+    """Build DistributedDataParallel module by device type.
+
+    - For CUDA, wrap as :obj:`mmcv.parallel.MMDistributedDataParallel`.
+    - Other device types are not supported by now.
+
+    Args:
+        model(:class:`nn.Module`): module to be parallelized.
+        device(str): device type, mlu or cuda.
+
+    Returns:
+        model(:class:`nn.Module`): the module to be parallelized
+
+    References:
+        .. [1] https://pytorch.org/docs/stable/generated/torch.nn.parallel.
+               DistributedDataParallel.html
+    """
+    if device == 'cuda':
+        from mmcv.parallel import MMDistributedDataParallel
+        model = MMDistributedDataParallel(model.cuda(), *args, **kwargs)
+    else:
+        raise RuntimeError(f'Unavailable device "{device}"')
+
+    return model

tools/test.py

@@ -8,14 +8,15 @@
 import numpy as np
 import torch
 from mmcv import DictAction
-from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
 from mmcv.runner import (get_dist_info, init_dist, load_checkpoint,
                          wrap_fp16_model)
 
 from mmcls.apis import multi_gpu_test, single_gpu_test
 from mmcls.datasets import build_dataloader, build_dataset
 from mmcls.models import build_classifier
-from mmcls.utils import get_root_logger, setup_multi_processes
+from mmcls.utils import (auto_select_device, get_root_logger,
+                         setup_multi_processes, wrap_distributed_model,
+                         wrap_non_distributed_model)
 
 
 def parse_args():
@@ -92,11 +93,7 @@ def parse_args():
         default='none',
         help='job launcher')
     parser.add_argument('--local_rank', type=int, default=0)
-    parser.add_argument(
-        '--device',
-        choices=['cpu', 'cuda', 'ipu'],
-        default='cuda',
-        help='device used for testing')
+    parser.add_argument('--device', help='device used for testing')
     args = parser.parse_args()
     if 'LOCAL_RANK' not in os.environ:
         os.environ['LOCAL_RANK'] = str(args.local_rank)
@@ -130,6 +127,7 @@ def main():
                       'in `gpu_ids` now.')
     else:
         cfg.gpu_ids = [args.gpu_id]
+    cfg.device = args.device or auto_select_device()
 
     # init distributed env first, since logger depends on the dist info.
     if args.launcher == 'none':
@@ -144,7 +142,7 @@ def main():
     # The default loader config
     loader_cfg = dict(
         # cfg.gpus will be ignored if distributed
-        num_gpus=1 if args.device == 'ipu' else len(cfg.gpu_ids),
+        num_gpus=1 if cfg.device == 'ipu' else len(cfg.gpu_ids),
         dist=distributed,
         round_up=True,
     )
@@ -182,29 +180,24 @@ def main():
         CLASSES = ImageNet.CLASSES
 
     if not distributed:
-        if args.device == 'cpu':
-            model = model.cpu()
-        elif args.device == 'ipu':
+        model = wrap_non_distributed_model(
+            model, device=cfg.device, device_ids=cfg.gpu_ids)
+        if cfg.device == 'ipu':
             from mmcv.device.ipu import cfg2options, ipu_model_wrapper
             opts = cfg2options(cfg.runner.get('options_cfg', {}))
             if fp16_cfg is not None:
                 model.half()
             model = ipu_model_wrapper(model, opts, fp16_cfg=fp16_cfg)
             data_loader.init(opts['inference'])
-        else:
-            model = MMDataParallel(model, device_ids=cfg.gpu_ids)
-            if not model.device_ids:
-                assert mmcv.digit_version(mmcv.__version__) >= (1, 4, 4), \
-                    'To test with CPU, please confirm your mmcv version ' \
-                    'is not lower than v1.4.4'
         model.CLASSES = CLASSES
-        show_kwargs = {} if args.show_options is None else args.show_options
+        show_kwargs = args.show_options or {}
         outputs = single_gpu_test(model, data_loader, args.show, args.show_dir,
                                   **show_kwargs)
     else:
-        model = MMDistributedDataParallel(
-            model.cuda(),
-            device_ids=[torch.cuda.current_device()],
+        model = wrap_distributed_model(
+            model,
+            device=cfg.device,
+            device_ids=[int(os.environ['LOCAL_RANK'])],
             broadcast_buffers=False)
         outputs = multi_gpu_test(model, data_loader, args.tmpdir,
                                  args.gpu_collect)

tools/train.py

@@ -16,7 +16,8 @@
 from mmcls.apis import init_random_seed, set_random_seed, train_model
 from mmcls.datasets import build_dataset
 from mmcls.models import build_classifier
-from mmcls.utils import collect_env, get_root_logger, setup_multi_processes
+from mmcls.utils import (auto_select_device, collect_env, get_root_logger,
+                         setup_multi_processes)
 
 
 def parse_args():
@@ -162,7 +163,8 @@ def main():
     logger.info(f'Config:\n{cfg.pretty_text}')
 
     # set random seeds
-    seed = init_random_seed(args.seed)
+    cfg.device = args.device or auto_select_device()
+    seed = init_random_seed(args.seed, device=cfg.device)
     seed = seed + dist.get_rank() if args.diff_seed else seed
     logger.info(f'Set random seed to {seed}, '
                 f'deterministic: {args.deterministic}')
@@ -195,7 +197,7 @@ def main():
         distributed=distributed,
         validate=(not args.no_validate),
         timestamp=timestamp,
-        device=args.device,
+        device=cfg.device,
         meta=meta)