[Enhance] Separate installation for each tasks on release task (#1869)

* separte_import

* align with pre commit

* update unit test code

* add separate task env pre  merge test & aplly it to github action

* add multiprocess to requirement

Author: eunwoosh

.github/workflows/pre_merge.yml

@@ -62,14 +62,69 @@ jobs:
           curl -Os https://uploader.codecov.io/latest/linux/codecov
           chmod +x codecov
           ./codecov -t ${{ secrets.CODECOV_TOKEN }} --sha $COMMIT_ID -Z true -U $HTTP_PROXY -f .tox/coverage.xml
-  Pre-Merge-Integration-Test:
+  Pre-Merge-Integration-Common-Test:
     runs-on: [self-hosted, linux, x64, dev]
     needs: Pre-Merge-Unit-Test
-    timeout-minutes: 360
+    timeout-minutes: 120
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+      - name: Install dependencies
+        run: python -m pip install -r requirements/dev.txt
+      - name: Integration-testing
+        run: tox -e pre-merge -- tests/integration/cli/test_cli.py
+  Pre-Merge-Integration-Cls-Test:
+    runs-on: [self-hosted, linux, x64, dev]
+    needs: Pre-Merge-Unit-Test
+    timeout-minutes: 120
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+      - name: Install dependencies
+        run: python -m pip install -r requirements/dev.txt
+      - name: Integration-testing
+        run: tox -e pre-merge-cls
+  Pre-Merge-Integration-Det-Test:
+    runs-on: [self-hosted, linux, x64, dev]
+    needs: Pre-Merge-Unit-Test
+    timeout-minutes: 120
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+      - name: Install dependencies
+        run: python -m pip install -r requirements/dev.txt
+      - name: Integration-testing
+        run: tox -e pre-merge-det
+  Pre-Merge-Integration-Seg-Test:
+    runs-on: [self-hosted, linux, x64, dev]
+    needs: Pre-Merge-Unit-Test
+    timeout-minutes: 120
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+      - name: Install dependencies
+        run: python -m pip install -r requirements/dev.txt
+      - name: Integration-testing
+        run: tox -e pre-merge-seg
+  Pre-Merge-Integration-Action-Test:
+    runs-on: [self-hosted, linux, x64, dev]
+    needs: Pre-Merge-Unit-Test
+    timeout-minutes: 120
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+      - name: Install dependencies
+        run: python -m pip install -r requirements/dev.txt
+      - name: Integration-testing
+        run: tox -e pre-merge-action
+  Pre-Merge-Integration-Anomaly-Test:
+    runs-on: [self-hosted, linux, x64, dev]
+    needs: Pre-Merge-Unit-Test
+    timeout-minutes: 120
     steps:
       - name: Checkout repository
         uses: actions/checkout@v3
       - name: Install dependencies
         run: python -m pip install -r requirements/dev.txt
       - name: Integration-testing
-        run: tox -e pre-merge -- tests/integration/cli
+        run: tox -e pre-merge-anomaly

otx/__init__.py

@@ -5,3 +5,28 @@
 
 __version__ = "1.0.0"
 # NOTE: Sync w/ otx/api/usecases/exportable_code/demo/requirements.txt
+
+MMCLS_AVAILABLE = True
+MMDET_AVAILABLE = True
+MMSEG_AVAILABLE = True
+MMACTION_AVAILABLE = True
+
+try:
+    import mmcls  # noqa: F401
+except ImportError:
+    MMCLS_AVAILABLE = False
+
+try:
+    import mmdet  # noqa: F401
+except ImportError:
+    MMDET_AVAILABLE = False
+
+try:
+    import mmseg  # noqa: F401
+except ImportError:
+    MMSEG_AVAILABLE = False
+
+try:
+    import mmaction  # noqa: F401
+except ImportError:
+    MMACTION_AVAILABLE = False

otx/cli/__init__.py

@@ -5,4 +5,7 @@
 
 import os
 
-os.environ["FEATURE_FLAGS_OTX_ACTION_TASKS"] = "1"
+from otx import MMACTION_AVAILABLE
+
+if MMACTION_AVAILABLE:
+    os.environ["FEATURE_FLAGS_OTX_ACTION_TASKS"] = "1"

otx/mpa/det/explainer.py

@@ -13,9 +13,9 @@
     build_dataset,
 )
 from otx.algorithms.detection.adapters.mmdet.data import ImageTilingDataset
+from otx.mpa.modules.hooks.det_saliency_map_hook import DetSaliencyMapHook
 from otx.mpa.modules.hooks.recording_forward_hooks import (
     ActivationMapHook,
-    DetSaliencyMapHook,
     EigenCamHook,
 )
 from otx.mpa.registry import STAGES

otx/mpa/det/inferrer.py

@@ -18,9 +18,9 @@
     build_dataset,
 )
 from otx.algorithms.detection.adapters.mmdet.data import ImageTilingDataset
+from otx.mpa.modules.hooks.det_saliency_map_hook import DetSaliencyMapHook
 from otx.mpa.modules.hooks.recording_forward_hooks import (
     ActivationMapHook,
-    DetSaliencyMapHook,
     FeatureVectorHook,
 )
 from otx.mpa.registry import STAGES

otx/mpa/modules/hooks/__init__.py

@@ -3,6 +3,8 @@
 #
 
 # flake8: noqa
+from otx import MMDET_AVAILABLE
+
 from . import (
     adaptive_training_hooks,
     checkpoint_hook,
@@ -22,3 +24,6 @@
     unbiased_teacher_hook,
     workflow_hooks,
 )
+
+if MMDET_AVAILABLE:
+    from . import det_saliency_map_hook

otx/mpa/modules/hooks/det_saliency_map_hook.py

@@ -0,0 +1,108 @@
+from typing import List, Tuple, Union
+
+import torch
+import torch.nn.functional as F
+
+from otx.mpa.modules.models.heads.custom_atss_head import CustomATSSHead
+from otx.mpa.modules.models.heads.custom_ssd_head import CustomSSDHead
+from otx.mpa.modules.models.heads.custom_vfnet_head import CustomVFNetHead
+from otx.mpa.modules.models.heads.custom_yolox_head import CustomYOLOXHead
+
+from .recording_forward_hooks import BaseRecordingForwardHook
+
+
+class DetSaliencyMapHook(BaseRecordingForwardHook):
+    """Saliency map hook for object detection models."""
+
+    def __init__(self, module: torch.nn.Module) -> None:
+        super().__init__(module)
+        self._neck = module.neck if module.with_neck else None
+        self._bbox_head = module.bbox_head
+        self._num_cls_out_channels = module.bbox_head.cls_out_channels  # SSD-like heads also have background class
+        if hasattr(module.bbox_head, "anchor_generator"):
+            self._num_anchors = module.bbox_head.anchor_generator.num_base_anchors
+        else:
+            self._num_anchors = [1] * 10
+
+    def func(
+        self,
+        x: Union[torch.Tensor, List[torch.Tensor], Tuple[torch.Tensor]],
+        _: int = -1,
+        cls_scores_provided: bool = False,
+    ) -> torch.Tensor:
+        """
+        Generate the saliency map from raw classification head output, then normalizing to (0, 255).
+
+        :param x: Feature maps from backbone/FPN or classification scores from cls_head
+        :param cls_scores_provided: If True - use 'x' as is, otherwise forward 'x' through the classification head
+        :return: Class-wise Saliency Maps. One saliency map per each class - [batch, class_id, H, W]
+        """
+        if cls_scores_provided:
+            cls_scores = x
+        else:
+            cls_scores = self._get_cls_scores_from_feature_map(x)
+
+        bs, _, h, w = cls_scores[-1].size()
+        saliency_maps = torch.empty(bs, self._num_cls_out_channels, h, w)
+        for batch_idx in range(bs):
+            cls_scores_anchorless = []
+            for scale_idx, cls_scores_per_scale in enumerate(cls_scores):
+                cls_scores_anchor_grouped = cls_scores_per_scale[batch_idx].reshape(
+                    self._num_anchors[scale_idx], (self._num_cls_out_channels), *cls_scores_per_scale.shape[-2:]
+                )
+                cls_scores_out, _ = cls_scores_anchor_grouped.max(dim=0)
+                cls_scores_anchorless.append(cls_scores_out.unsqueeze(0))
+            cls_scores_anchorless_resized = []
+            for cls_scores_anchorless_per_level in cls_scores_anchorless:
+                cls_scores_anchorless_resized.append(
+                    F.interpolate(cls_scores_anchorless_per_level, (h, w), mode="bilinear")
+                )
+            saliency_maps[batch_idx] = torch.cat(cls_scores_anchorless_resized, dim=0).mean(dim=0)
+
+        saliency_maps = saliency_maps.reshape((bs, self._num_cls_out_channels, -1))
+        max_values, _ = torch.max(saliency_maps, -1)
+        min_values, _ = torch.min(saliency_maps, -1)
+        saliency_maps = 255 * (saliency_maps - min_values[:, :, None]) / (max_values - min_values + 1e-12)[:, :, None]
+        saliency_maps = saliency_maps.reshape((bs, self._num_cls_out_channels, h, w))
+        saliency_maps = saliency_maps.to(torch.uint8)
+        return saliency_maps
+
+    def _get_cls_scores_from_feature_map(self, x: torch.Tensor) -> List:
+        """Forward features through the classification head of the detector."""
+        with torch.no_grad():
+            if self._neck is not None:
+                x = self._neck(x)
+
+            if isinstance(self._bbox_head, CustomSSDHead):
+                cls_scores = []
+                for feat, cls_conv in zip(x, self._bbox_head.cls_convs):
+                    cls_scores.append(cls_conv(feat))
+            elif isinstance(self._bbox_head, CustomATSSHead):
+                cls_scores = []
+                for cls_feat in x:
+                    for cls_conv in self._bbox_head.cls_convs:
+                        cls_feat = cls_conv(cls_feat)
+                    cls_score = self._bbox_head.atss_cls(cls_feat)
+                    cls_scores.append(cls_score)
+            elif isinstance(self._bbox_head, CustomVFNetHead):
+                # Not clear how to separate cls_scores from bbox_preds
+                cls_scores, _, _ = self._bbox_head(x)
+            elif isinstance(self._bbox_head, CustomYOLOXHead):
+
+                def forward_single(x, cls_convs, conv_cls):
+                    """Forward feature of a single scale level."""
+                    cls_feat = cls_convs(x)
+                    cls_score = conv_cls(cls_feat)
+                    return cls_score
+
+                map_results = map(
+                    forward_single, x, self._bbox_head.multi_level_cls_convs, self._bbox_head.multi_level_conv_cls
+                )
+                cls_scores = list(map_results)
+            else:
+                raise NotImplementedError(
+                    "Not supported detection head provided. "
+                    "DetSaliencyMapHook supports only the following single stage detectors: "
+                    "YOLOXHead, ATSSHead, SSDHead, VFNetHead."
+                )
+        return cls_scores

otx/mpa/modules/hooks/recording_forward_hooks.py

@@ -15,16 +15,14 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import List, Sequence, Tuple, Union
+from typing import Sequence, Union
 
 import torch
-import torch.nn.functional as F
-from mmcls.models.necks.gap import GlobalAveragePooling
 
-from otx.mpa.modules.models.heads.custom_atss_head import CustomATSSHead
-from otx.mpa.modules.models.heads.custom_ssd_head import CustomSSDHead
-from otx.mpa.modules.models.heads.custom_vfnet_head import CustomVFNetHead
-from otx.mpa.modules.models.heads.custom_yolox_head import CustomYOLOXHead
+from otx import MMCLS_AVAILABLE
+
+if MMCLS_AVAILABLE:
+    from mmcls.models.necks.gap import GlobalAveragePooling
 
 
 class BaseRecordingForwardHook(ABC):
@@ -130,103 +128,6 @@ def func(feature_map: Union[torch.Tensor, Sequence[torch.Tensor]]) -> torch.Tens
         return feature_vector
 
 
-class DetSaliencyMapHook(BaseRecordingForwardHook):
-    """Saliency map hook for object detection models."""
-
-    def __init__(self, module: torch.nn.Module) -> None:
-        super().__init__(module)
-        self._neck = module.neck if module.with_neck else None
-        self._bbox_head = module.bbox_head
-        self._num_cls_out_channels = module.bbox_head.cls_out_channels  # SSD-like heads also have background class
-        if hasattr(module.bbox_head, "anchor_generator"):
-            self._num_anchors = module.bbox_head.anchor_generator.num_base_anchors
-        else:
-            self._num_anchors = [1] * 10
-
-    def func(
-        self,
-        x: Union[torch.Tensor, List[torch.Tensor], Tuple[torch.Tensor]],
-        _: int = -1,
-        cls_scores_provided: bool = False,
-    ) -> torch.Tensor:
-        """
-        Generate the saliency map from raw classification head output, then normalizing to (0, 255).
-
-        :param x: Feature maps from backbone/FPN or classification scores from cls_head
-        :param cls_scores_provided: If True - use 'x' as is, otherwise forward 'x' through the classification head
-        :return: Class-wise Saliency Maps. One saliency map per each class - [batch, class_id, H, W]
-        """
-        if cls_scores_provided:
-            cls_scores = x
-        else:
-            cls_scores = self._get_cls_scores_from_feature_map(x)
-
-        bs, _, h, w = cls_scores[-1].size()
-        saliency_maps = torch.empty(bs, self._num_cls_out_channels, h, w)
-        for batch_idx in range(bs):
-            cls_scores_anchorless = []
-            for scale_idx, cls_scores_per_scale in enumerate(cls_scores):
-                cls_scores_anchor_grouped = cls_scores_per_scale[batch_idx].reshape(
-                    self._num_anchors[scale_idx], (self._num_cls_out_channels), *cls_scores_per_scale.shape[-2:]
-                )
-                cls_scores_out, _ = cls_scores_anchor_grouped.max(dim=0)
-                cls_scores_anchorless.append(cls_scores_out.unsqueeze(0))
-            cls_scores_anchorless_resized = []
-            for cls_scores_anchorless_per_level in cls_scores_anchorless:
-                cls_scores_anchorless_resized.append(
-                    F.interpolate(cls_scores_anchorless_per_level, (h, w), mode="bilinear")
-                )
-            saliency_maps[batch_idx] = torch.cat(cls_scores_anchorless_resized, dim=0).mean(dim=0)
-
-        saliency_maps = saliency_maps.reshape((bs, self._num_cls_out_channels, -1))
-        max_values, _ = torch.max(saliency_maps, -1)
-        min_values, _ = torch.min(saliency_maps, -1)
-        saliency_maps = 255 * (saliency_maps - min_values[:, :, None]) / (max_values - min_values + 1e-12)[:, :, None]
-        saliency_maps = saliency_maps.reshape((bs, self._num_cls_out_channels, h, w))
-        saliency_maps = saliency_maps.to(torch.uint8)
-        return saliency_maps
-
-    def _get_cls_scores_from_feature_map(self, x: torch.Tensor) -> List:
-        """Forward features through the classification head of the detector."""
-        with torch.no_grad():
-            if self._neck is not None:
-                x = self._neck(x)
-
-            if isinstance(self._bbox_head, CustomSSDHead):
-                cls_scores = []
-                for feat, cls_conv in zip(x, self._bbox_head.cls_convs):
-                    cls_scores.append(cls_conv(feat))
-            elif isinstance(self._bbox_head, CustomATSSHead):
-                cls_scores = []
-                for cls_feat in x:
-                    for cls_conv in self._bbox_head.cls_convs:
-                        cls_feat = cls_conv(cls_feat)
-                    cls_score = self._bbox_head.atss_cls(cls_feat)
-                    cls_scores.append(cls_score)
-            elif isinstance(self._bbox_head, CustomVFNetHead):
-                # Not clear how to separate cls_scores from bbox_preds
-                cls_scores, _, _ = self._bbox_head(x)
-            elif isinstance(self._bbox_head, CustomYOLOXHead):
-
-                def forward_single(x, cls_convs, conv_cls):
-                    """Forward feature of a single scale level."""
-                    cls_feat = cls_convs(x)
-                    cls_score = conv_cls(cls_feat)
-                    return cls_score
-
-                map_results = map(
-                    forward_single, x, self._bbox_head.multi_level_cls_convs, self._bbox_head.multi_level_conv_cls
-                )
-                cls_scores = list(map_results)
-            else:
-                raise NotImplementedError(
-                    "Not supported detection head provided. "
-                    "DetSaliencyMapHook supports only the following single stage detectors: "
-                    "YOLOXHead, ATSSHead, SSDHead, VFNetHead."
-                )
-        return cls_scores
-
-
 class ReciproCAMHook(BaseRecordingForwardHook):
     """
     Implementation of recipro-cam for class-wise saliency map
@@ -280,7 +181,7 @@ def _predict_from_feature_map(self, x: torch.Tensor) -> torch.Tensor:
         return logits
 
     def _get_mosaic_feature_map(self, feature_map: torch.Tensor, c: int, h: int, w: int) -> torch.Tensor:
-        if self._neck is not None and isinstance(self._neck, GlobalAveragePooling):
+        if MMCLS_AVAILABLE and self._neck is not None and isinstance(self._neck, GlobalAveragePooling):
             """
             Optimization workaround for the GAP case (simulate GAP with more simple compute graph)
             Possible due to static sparsity of mosaic_feature_map