Test/instance

mmtune/apis/tune.py

@@ -19,7 +19,7 @@ def tune(task_processor: BaseTask, tune_config: Config,
     assert hasattr(tune_config, 'metric')
     assert hasattr(tune_config, 'mode') and tune_config.mode in ['min', 'max']
 
-    tune_artifact_dir = osp.join(task_processor.ARGS.work_dir, 'artifact')
+    tune_artifact_dir = osp.join(task_processor.args.work_dir, 'artifact')
     mmcv.mkdir_or_exist(tune_artifact_dir)
 
     return ray.tune.run(
@@ -29,10 +29,10 @@ def tune(task_processor: BaseTask, tune_config: Config,
         name=exp_name,
         resources_per_trial=None
         if hasattr(trainable, 'default_resource_request') else dict(
-            cpu=task_processor.ARGS.num_workers *  # noqa W504
-            task_processor.ARGS.num_cpus_per_worker,
-            gpu=task_processor.ARGS.num_workers *  # noqa W504
-            task_processor.ARGS.num_gpus_per_worker),
+            cpu=task_processor.args.num_workers *  # noqa W504
+            task_processor.args.num_cpus_per_worker,
+            gpu=task_processor.args.num_workers *  # noqa W504
+            task_processor.args.num_gpus_per_worker),
         stop=build_stopper(tune_config.stop)
         if hasattr(tune_config, 'stop') else None,
         config=build_space(tune_config.space)

mmtune/mm/tasks/base.py

@@ -13,41 +13,36 @@
 @TASKS.register_module()
 class BaseTask(metaclass=ABCMeta):
     """Wrap the apis of target task."""
-    BASE_CFG: Optional[ImmutableContainer] = None
-    ARGS: Optional[argparse.Namespace] = None
-    REWRITERS: List[dict] = []
 
-    @classmethod
-    def set_base_cfg(cls, base_cfg: Config) -> None:
-        BaseTask.BASE_CFG = ImmutableContainer(base_cfg, 'base')
+    def __init__(self):
+        self.base_cfg: Optional[ImmutableContainer] = None
+        self.args: Optional[argparse.Namespace] = None
+        self.rewriters: List[dict] = []
 
-    @classmethod
-    def set_args(cls, args: argparse.Namespace) -> None:
-        BaseTask.ARGS = args
+    def set_base_cfg(self, base_cfg: Config) -> None:
+        self.base_cfg = ImmutableContainer(base_cfg, 'base')
 
-    @classmethod
-    def set_rewriters(cls, rewriters: List[dict] = []) -> None:
-        BaseTask.REWRITERS = rewriters
+    def set_args(self, args: argparse.Namespace) -> None:
+        self.args = args
+
+    def set_rewriters(self, rewriters: List[dict] = []) -> None:
+        self.rewriters = rewriters
 
-    @classmethod
     @abstractmethod
     def add_arguments(
-        cls,
+        self,
         parser: Optional[argparse.ArgumentParser] = None
     ) -> argparse.ArgumentParser:
         pass
 
-    @classmethod
-    def contextaware_run(cls, status, *args, **kwargs) -> None:
+    def contextaware_run(self, status, *args, **kwargs) -> None:
         context_manager = ContextManager(**status)
-        return context_manager(cls.run)(*args, **kwargs)
+        return context_manager(self.run)(*args, **kwargs)
 
-    @classmethod
     @abstractmethod
-    def run(cls, *args, **kwargs) -> None:
+    def run(self, *args, **kwargs) -> None:
         pass
 
-    @classmethod
     @abstractmethod
-    def create_trainable(cls, *args, **kwargs) -> ray.tune.Trainable:
+    def create_trainable(self, *args, **kwargs) -> ray.tune.Trainable:
         pass

mmtune/mm/tasks/blackbox.py

@@ -1,4 +1,5 @@
 import argparse
+from abc import ABCMeta
 from functools import partial
 from typing import Callable, Optional
 
@@ -7,23 +8,21 @@
 
 
 @TASKS.register_module()
-class BloackBoxTask(BaseTask):
+class BloackBoxTask(BaseTask, metaclass=ABCMeta):
 
-    @classmethod
     def add_arguments(
-        cls,
+        self,
         parser: Optional[argparse.ArgumentParser] = None
     ) -> argparse.ArgumentParser:
 
         if parser is None:
-            parser = argparse.ArgumentParser(description='Train a segmentor')
+            parser = argparse.ArgumentParser(description='black box')
         return parser
 
-    @classmethod
-    def create_trainable(cls) -> Callable:
+    def create_trainable(self) -> Callable:
         return partial(
-            cls.contextaware_run,
+            self.contextaware_run,
             dict(
-                base_cfg=BloackBoxTask.BASE_CFG,
-                args=BloackBoxTask.ARGS,
-                rewriters=BaseTask.REWRITERS))
+                base_cfg=self.BASE_CFG,
+                args=self.ARGS,
+                rewriters=self.REWRITERS))

mmtune/mm/tasks/mmseg.py

@@ -17,9 +17,8 @@
 @TASKS.register_module()
 class MMSegmentation(MMTrainBasedTask):
 
-    @classmethod
     def add_arguments(
-        cls,
+        self,
         parser: Optional[argparse.ArgumentParser] = None
     ) -> argparse.ArgumentParser:
 
@@ -62,24 +61,21 @@ def add_arguments(
             help='resume from the latest checkpoint automatically.')
         return parser
 
-    @classmethod
-    def build_model(cls,
+    def build_model(self,
                     cfg: Config,
                     train_cfg: Optional[Config] = None,
                     test_cfg: Optional[Config] = None) -> torch.nn.Module:
         from mmseg.models.builder import build_segmentor
         return build_segmentor(cfg, train_cfg, test_cfg)
 
-    @classmethod
     def build_dataset(
-            cls,
+            self,
             cfg: Config,
             default_args: Optional[Config] = None) -> torch.utils.data.Dataset:
         from mmseg.datasets.builder import build_dataset
         return build_dataset(cfg, default_args)
 
-    @classmethod
-    def train_model(cls,
+    def train_model(self,
                     model: torch.nn.Module,
                     dataset: torch.utils.data.Dataset,
                     cfg: Config,
@@ -92,8 +88,7 @@ def train_model(cls,
                         meta)
         return
 
-    @classmethod
-    def run(cls, *args, **kwargs):
+    def run(self, *args, **kwargs):
         from mmseg import __version__
         from mmseg.apis import init_random_seed, set_random_seed
         from mmseg.utils import collect_env, get_root_logger, setup_multi_processes
@@ -165,7 +160,7 @@ def run(cls, *args, **kwargs):
         meta['seed'] = seed
         meta['exp_name'] = osp.basename(args.config)
 
-        model = cls.build_model(
+        model = self.build_model(
             cfg.model,
             train_cfg=cfg.get('train_cfg'),
             test_cfg=cfg.get('test_cfg'))
@@ -174,11 +169,11 @@ def run(cls, *args, **kwargs):
         # SyncBN is not support for DP
         logger.info(model)
 
-        datasets = [cls.build_dataset(cfg.data.train)]
+        datasets = [self.build_dataset(cfg.data.train)]
         if len(cfg.workflow) == 2:
             val_dataset = copy.deepcopy(cfg.data.val)
             val_dataset.pipeline = cfg.data.train.pipeline
-            datasets.append(cls.build_dataset(val_dataset))
+            datasets.append(self.build_dataset(val_dataset))
         if cfg.checkpoint_config is not None:
             # save mmseg version, config file content and class names in
             # checkpoints as meta data
@@ -191,7 +186,7 @@ def run(cls, *args, **kwargs):
         model.CLASSES = datasets[0].CLASSES
         # passing checkpoint meta for saving best checkpoint
         meta.update(cfg.checkpoint_config.meta)
-        cls.train_model(
+        self.train_model(
             model,
             datasets,
             cfg,

mmtune/mm/tasks/mmtrainbase.py

@@ -15,44 +15,41 @@
 @TASKS.register_module()
 class MMTrainBasedTask(BaseTask):
 
-    @classmethod
     @abstractmethod
-    def build_model(cls, cfg: mmcv.Config, **kwargs) -> torch.nn.Module:
+    def build_model(self, cfg: mmcv.Config, **kwargs) -> torch.nn.Module:
         pass
 
-    @classmethod
     @abstractmethod
-    def build_dataset(cls, cfg: mmcv.Config,
+    def build_dataset(self, cfg: mmcv.Config,
                       **kwargs) -> torch.utils.data.Dataset:
         pass
 
-    @classmethod
     @abstractmethod
-    def train_model(cls, model: torch.nn.Module,
+    def train_model(self, model: torch.nn.Module,
                     dataset: torch.utils.data.Dataset, cfg: mmcv.Config,
                     **kwargs) -> None:
         pass
 
-    @classmethod
-    def contextaware_run(cls, status, backend, *args, **kwargs) -> None:
+
+    def contextaware_run(self, status, backend, *args, **kwargs) -> None:
         from mmtune.mm import hooks  # noqa F401
         if backend == 'nccl' and os.getenv('NCCL_BLOCKING_WAIT') is None:
             os.environ['NCCL_BLOCKING_WAIT'] = '0'
         context_manager = ContextManager(**status)
-        return context_manager(cls.run)(*args, **kwargs)
+        return context_manager(self.run)(*args, **kwargs)
 
-    @classmethod
-    def create_trainable(cls, backend: str = 'nccl') -> ray.tune.trainable:
+    def create_trainable(self, backend: str = 'nccl') -> ray.tune.trainable:
         assert backend in ['gloo', 'nccl']
 
         return DistributedTrainableCreator(
             partial(
-                cls.contextaware_run,
+                self.contextaware_run,
                 dict(
-                    base_cfg=cls.BASE_CFG,
-                    args=cls.ARGS,
-                    rewriters=cls.REWRITERS), backend),
+                    base_cfg=self.base_cfg,
+                    args=self.args,
+                    rewriters=self.rewriters), backend),
             backend=backend,
-            num_workers=cls.ARGS.num_workers,
-            num_gpus_per_worker=cls.ARGS.num_gpus_per_worker,
-            num_cpus_per_worker=cls.ARGS.num_cpus_per_worker)
+            num_workers=self.args.num_workers,
+            num_gpus_per_worker=self.args.num_cpus_per_worker,
+            num_cpus_per_worker=self.args.num_cpus_per_worker)
+

mmtune/mm/tasks/sphere.py

@@ -9,8 +9,7 @@
 @TASKS.register_module()
 class Sphere(BloackBoxTask):
 
-    @classmethod
-    def run(cls, *args, **kwargs):
+    def run(self, *args, **kwargs):
         args = kwargs['args']
         cfg = Config.fromfile(args.config)