[HOTFIX][RELEASE1.0] Fix missing classes in the first incremental round & cleanup classification utils (#1839)

* Cleanup

* Fix missing classes in cls checkpoint

* Fix linters

* Add debug comment

* Fix default dump_feature=True for Geti

---------

Co-authored-by: Songki Choi <[email protected]>

Author: sovrasov

otx/algorithms/classification/adapters/mmcls/utils/__init__.py

@@ -3,17 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from .builder import build_classifier
-from .config_utils import (
-    patch_config,
-    patch_datasets,
-    patch_evaluation,
-    prepare_for_training,
-)
+from .config_utils import patch_datasets, patch_evaluation
 
 __all__ = [
-    "patch_config",
+    "build_classifier",
     "patch_datasets",
     "patch_evaluation",
-    "prepare_for_training",
-    "build_classifier",
 ]

otx/algorithms/classification/adapters/mmcls/utils/config_utils.py

@@ -14,153 +14,23 @@
 # See the License for the specific language governing permissions
 # and limitations under the License.
 
-import math
-from typing import List, Optional, Union
+from typing import List, Optional
 
 from mmcv import Config, ConfigDict
 
 from otx.algorithms.common.adapters.mmcv.utils import (
-    get_configs_by_keys,
     get_configs_by_pairs,
     get_dataset_configs,
     get_meta_keys,
-    is_epoch_based_runner,
     patch_color_conversion,
-    prepare_work_dir,
-    remove_from_config,
-    remove_from_configs_by_type,
-    update_config,
-)
-from otx.api.entities.label import Domain, LabelEntity
-from otx.api.utils.argument_checks import (
-    DirectoryPathCheck,
-    check_input_parameters_type,
 )
+from otx.api.entities.label import Domain
+from otx.api.utils.argument_checks import check_input_parameters_type
 from otx.mpa.utils.logger import get_logger
 
 logger = get_logger()
 
 
-@check_input_parameters_type({"work_dir": DirectoryPathCheck})
-def patch_config(
-    config: Config,
-    work_dir: str,
-    labels: List[LabelEntity],
-):  # pylint: disable=too-many-branches
-    """Update config function."""
-
-    # Add training cancelation hook.
-    if "custom_hooks" not in config:
-        config.custom_hooks = []
-    if "CancelTrainingHook" not in {hook.type for hook in config.custom_hooks}:
-        config.custom_hooks.append(ConfigDict({"type": "CancelTrainingHook"}))
-
-    # Remove high level data pipelines definition leaving them only inside `data` section.
-    remove_from_config(config, "train_pipeline")
-    remove_from_config(config, "test_pipeline")
-    remove_from_config(config, "train_pipeline_strong")
-    # Remove cancel interface hook
-    remove_from_configs_by_type(config.custom_hooks, "CancelInterfaceHook")
-
-    config.checkpoint_config.max_keep_ckpts = 5
-    config.checkpoint_config.interval = config.evaluation.get("interval", 1)
-
-    set_data_classes(config, labels)
-
-    config.gpu_ids = range(1)
-    config.work_dir = work_dir
-
-
-@check_input_parameters_type()
-def patch_model_config(
-    config: Config,
-    labels: List[LabelEntity],
-):
-    """Patch model config."""
-    set_num_classes(config, len(labels))
-
-
-@check_input_parameters_type()
-def patch_adaptive_repeat_dataset(
-    config: Union[Config, ConfigDict],
-    num_samples: int,
-    decay: float = -0.002,
-    factor: float = 30,
-):
-    """Patch the repeat times and training epochs adatively.
-
-    Frequent dataloading inits and evaluation slow down training when the
-    sample size is small. Adjusting epoch and dataset repetition based on
-    empirical exponential decay improves the training time by applying high
-    repeat value to small sample size dataset and low repeat value to large
-    sample.
-
-    :param config: mmcv config
-    :param num_samples: number of training samples
-    :param decay: decaying rate
-    :param factor: base repeat factor
-    """
-    data_train = config.data.train
-    if data_train.type == "RepeatDataset" and getattr(data_train, "adaptive_repeat_times", False):
-        if is_epoch_based_runner(config.runner):
-            cur_epoch = config.runner.max_epochs
-            new_repeat = max(round(math.exp(decay * num_samples) * factor), 1)
-            new_epoch = math.ceil(cur_epoch / new_repeat)
-            if new_epoch == 1:
-                return
-            config.runner.max_epochs = new_epoch
-            data_train.times = new_repeat
-
-
-@check_input_parameters_type()
-def prepare_for_training(
-    config: Union[Config, ConfigDict],
-    data_config: ConfigDict,
-) -> Union[Config, ConfigDict]:
-    """Prepare configs for training phase."""
-    prepare_work_dir(config)
-
-    train_num_samples = 0
-    for subset in ["train", "val", "test"]:
-        data_config_ = data_config.data.get(subset)
-        config_ = config.data.get(subset)
-        if data_config_ is None:
-            continue
-        for key in ["otx_dataset", "labels"]:
-            found = get_configs_by_keys(data_config_, key, return_path=True)
-            if len(found) == 0:
-                continue
-            assert len(found) == 1
-            if subset == "train" and key == "otx_dataset":
-                found_value = list(found.values())[0]
-                if found_value:
-                    train_num_samples = len(found_value)
-            update_config(config_, found)
-
-    if train_num_samples > 0:
-        patch_adaptive_repeat_dataset(config, train_num_samples)
-
-    return config
-
-
-@check_input_parameters_type()
-def set_data_classes(config: Config, labels: List[LabelEntity]):
-    """Setter data classes into config."""
-    # Save labels in data configs.
-    for subset in ("train", "val", "test"):
-        for cfg in get_dataset_configs(config, subset):
-            cfg.labels = labels
-
-
-@check_input_parameters_type()
-def set_num_classes(config: Config, num_classes: int):
-    """Set num classes."""
-    head_names = ["head"]
-    for head_name in head_names:
-        if head_name in config.model:
-            config.model[head_name].num_classes = num_classes
-
-
 @check_input_parameters_type()
 def patch_datasets(
     config: Config,

otx/algorithms/classification/tasks/inference.py

@@ -215,7 +215,7 @@ def unload(self):
         self.cleanup()
 
     @check_input_parameters_type()
-    def export(self, export_type: ExportType, output_model: ModelEntity, dump_features: bool = False):
+    def export(self, export_type: ExportType, output_model: ModelEntity, dump_features: bool = True):
         """Export function of OTX Classification Task."""
 
         logger.info("Exporting the model")

otx/algorithms/detection/tasks/inference.py

@@ -238,7 +238,7 @@ def unload(self):
         self.cleanup()
 
     @check_input_parameters_type()
-    def export(self, export_type: ExportType, output_model: ModelEntity, dump_features: bool = False):
+    def export(self, export_type: ExportType, output_model: ModelEntity, dump_features: bool = True):
         """Export function of OTX Detection Task."""
         # copied from OTX inference_task.py
         logger.info("Exporting the model")

otx/api/usecases/tasks/interfaces/export_interface.py

@@ -20,7 +20,7 @@ class IExportTask(metaclass=abc.ABCMeta):
     """A base interface class for tasks which can export their models."""
 
     @abc.abstractmethod
-    def export(self, export_type: ExportType, output_model: ModelEntity, dump_features: bool = False):
+    def export(self, export_type: ExportType, output_model: ModelEntity, dump_features: bool = True):  # FIXME: False
         """This method defines the interface for export.
 
         Args:

otx/mpa/cls/stage.py

@@ -153,11 +153,11 @@ def configure_classes(self, cfg):
         data_classes = Stage.get_data_classes(cfg)
 
         if cfg.get("model_classes", []):
-            cfg.model.head.num_classes = len(cfg.model_classes)
+            cfg.model.head.num_classes = len(cfg.model_classes)  # read from prev model label_schema
         elif model_classes:
-            cfg.model.head.num_classes = len(model_classes)
+            cfg.model.head.num_classes = len(model_classes)  # read from ckpt meta
         elif data_classes:
-            cfg.model.head.num_classes = len(data_classes)
+            cfg.model.head.num_classes = len(data_classes)  # read from env label_schema
         self.model_meta["CLASSES"] = model_classes
 
         if not train_data_cfg.get("new_classes", False):  # when train_data_cfg doesn't have 'new_classes' key

otx/mpa/cls/trainer.py

@@ -62,14 +62,15 @@ def run(self, model_cfg, model_ckpt, data_cfg, **kwargs):  # noqa: C901
             cfg.checkpoint_config.meta = dict(mmcls_version=__version__)
             if hasattr(repr_ds, "tasks"):
                 cfg.checkpoint_config.meta["tasks"] = repr_ds.tasks
-            else:
+            if hasattr(repr_ds, "CLASSES"):
                 cfg.checkpoint_config.meta["CLASSES"] = repr_ds.CLASSES
             if "task_adapt" in cfg:
                 if hasattr(self, "model_tasks"):  # for incremnetal learning
                     cfg.checkpoint_config.meta.update({"tasks": self.model_tasks})
                     # instead of update(self.old_tasks), update using "self.model_tasks"
-                else:
+                if self.model_classes:
                     cfg.checkpoint_config.meta.update({"CLASSES": self.model_classes})
+                    # FIXME:self.dst_classes?
 
         self.configure_samples_per_gpu(cfg, "train", self.distributed)
         self.configure_fp16_optimizer(cfg, self.distributed)

tests/unit/algorithms/classification/adapters/mmcls/test_cls_config_builder.py

@@ -2,18 +2,10 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-import tempfile
-
 import pytest
 from mmcv.utils import Config
 
-from otx.algorithms.classification.adapters.mmcls.utils import (
-    patch_config,
-    patch_evaluation,
-)
-from otx.algorithms.common.adapters.mmcv.utils import get_dataset_configs
-from otx.api.entities.id import ID
-from otx.api.entities.label import Domain, LabelEntity
+from otx.algorithms.classification.adapters.mmcls.utils import patch_evaluation
 from tests.test_suite.e2e_test_system import e2e_pytest_unit
 
 
@@ -27,41 +19,6 @@ def otx_default_cls_config():
     return conf
 
 
-@pytest.fixture
-def otx_default_labels():
-    return [
-        LabelEntity(name=name, domain=Domain.CLASSIFICATION, is_empty=False, id=ID(i))
-        for i, name in enumerate(["a", "b"])
-    ]
-
-
-@e2e_pytest_unit
-def test_patch_config(otx_default_cls_config, otx_default_labels) -> None:
-    """Test patch_config function.
-
-    <Steps>
-        1. Check work_dir
-        2. Check removed high level pipelines
-        3. Check checkpoint config update
-        4. Check dataset labels
-    """
-
-    with tempfile.TemporaryDirectory() as work_dir:
-        patch_config(otx_default_cls_config, work_dir, otx_default_labels)
-        assert otx_default_cls_config.work_dir == work_dir
-
-        assert otx_default_cls_config.get("train_pipeline", None) is None
-        assert otx_default_cls_config.get("test_pipeline", None) is None
-        assert otx_default_cls_config.get("train_pipeline_strong", None) is None
-
-        assert otx_default_cls_config.checkpoint_config.max_keep_ckpts > 0
-        assert otx_default_cls_config.checkpoint_config.interval > 0
-
-        for subset in ("train", "val", "test"):
-            for cfg in get_dataset_configs(otx_default_cls_config, subset):
-                assert len(cfg.labels) == len(otx_default_labels)
-
-
 @e2e_pytest_unit
 def test_patch_evaluation(otx_default_cls_config) -> None:
     """Test patch_evaluation function.