Merge branch 'main' of https://github.com/openvinotoolkit/geti-sdk

geti_sdk/data_models/enums/domain.py

@@ -30,6 +30,7 @@ class Domain(Enum):
     ANOMALY_SEGMENTATION = "ANOMALY_SEGMENTATION"
     INSTANCE_SEGMENTATION = "INSTANCE_SEGMENTATION"
     ROTATED_DETECTION = "ROTATED_DETECTION"
+    ANOMALY = "ANOMALY"
 
     def __str__(self) -> str:
         """

geti_sdk/deployment/deployed_model.py

@@ -25,6 +25,7 @@
 import numpy as np
 from model_api.adapters import OpenvinoAdapter, OVMSAdapter
 from model_api.models import Model as model_api_Model
+from model_api.tilers import DetectionTiler, InstanceSegmentationTiler, Tiler
 from openvino.runtime import Core
 from packaging.version import Version
 
@@ -63,6 +64,11 @@
 SEGMENTATION_SALIENCY_KEY = "soft_prediction"
 FEATURE_VECTOR_KEY = "feature_vector"
 
+TILER_MAPPING = {
+    Domain.DETECTION: DetectionTiler,
+    Domain.INSTANCE_SEGMENTATION: InstanceSegmentationTiler,
+}
+
 OVMS_TIMEOUT = 10  # Max time to wait for OVMS models to become available
 
 
@@ -95,6 +101,8 @@ def __attrs_post_init__(self):
         self._feature_vector_location: Optional[str] = None
 
         self._converter: Optional[InferenceResultsToPredictionConverter] = None
+        self._tiling_enabled: bool = False
+        self._tiler: Optional[Tiler] = None
 
     @property
     def model_data_path(self) -> str:
@@ -288,6 +296,11 @@ def load_inference_model(
         )
         self._parse_label_schema_from_dict(label_dictionary)
 
+        # Load a Results-to-Prediction converter
+        self._converter = ConverterFactory.create_converter(
+            self.label_schema, configuration
+        )
+
         model = model_api_Model.create_model(
             model=model_adapter,
             model_type=model_type,
@@ -297,10 +310,24 @@ def load_inference_model(
         )
         self._inference_model = model
 
-        # Load a Results-to-Prediction converter
-        self._converter = ConverterFactory.create_converter(
-            self.label_schema, configuration
-        )
+        # Extract tiling parameters, if applicable
+        tiling_parameters = configuration_json.get("tiling_parameters", None)
+
+        enable_tiling = False
+        if tiling_parameters is not None:
+            enable_tiling = tiling_parameters.get("enable_tiling", False)
+            if isinstance(enable_tiling, dict):
+                enable_tiling = enable_tiling.get("value", False)
+
+        if enable_tiling:
+            logging.info("Tiling is enabled for this model, initializing Tiler")
+            tiler_type = TILER_MAPPING.get(self._converter.domain, None)
+            if tiler_type is None:
+                raise ValueError(
+                    f"Tiling is not supported for domain {self._converter.domain}"
+                )
+            self._tiler = tiler_type(model=model, execution_mode="sync")
+            self._tiling_enabled = True
 
         # TODO: This is a workaround to fix the issue that causes the output blob name
         #  to be unset. Remove this once it has been fixed on ModelAPI side
@@ -563,22 +590,32 @@ def infer(self, image: np.ndarray, explain: bool = False) -> Prediction:
             image
         :return: Dictionary containing the model outputs
         """
-        preprocessed_image, metadata = self._preprocess(image)
-        # metadata is a dict with keys 'original_shape' and 'resized_shape'
-        inference_results: Dict[str, np.ndarray] = self._inference_model.infer_sync(
-            preprocessed_image
-        )
-        postprocessing_results = self._postprocess(inference_results, metadata=metadata)
+        if not self._tiling_enabled:
+            preprocessed_image, metadata = self._preprocess(image)
+            # metadata is a dict with keys 'original_shape' and 'resized_shape'
+            inference_results: Dict[str, np.ndarray] = self._inference_model.infer_sync(
+                preprocessed_image
+            )
+            postprocessing_results = self._postprocess(
+                inference_results, metadata=metadata
+            )
+        else:
+            postprocessing_results = self._tiler(image)
 
         prediction = self._converter.convert_to_prediction(
-            postprocessing_results, image_shape=metadata["original_shape"]
+            postprocessing_results, image_shape=image.shape
         )
 
         # Add optional explainability outputs
         if explain:
-            saliency_map, repr_vector = self._postprocess_explain_outputs(
-                inference_results=inference_results, metadata=metadata
-            )
+            if not self._tiling_enabled:
+                saliency_map, repr_vector = self._postprocess_explain_outputs(
+                    inference_results=inference_results, metadata=metadata
+                )
+            else:
+                repr_vector = postprocessing_results.feature_vector
+                saliency_map = postprocessing_results.saliency_map
+
             prediction.feature_vector = repr_vector
             result_medium = ResultMedium(name="saliency map", type="saliency map")
             result_medium.data = saliency_map

geti_sdk/deployment/predictions_postprocessing/results_converter/results_to_prediction_converter.py

@@ -50,6 +50,16 @@
 class InferenceResultsToPredictionConverter(metaclass=abc.ABCMeta):
     """Interface for the converter"""
 
+    @property
+    @abc.abstractmethod
+    def domain(self) -> Domain:
+        """
+        Return the domain for which the converter applies
+
+        :return: The task domain for which the label converter applies
+        """
+        raise NotImplementedError
+
     @abc.abstractmethod
     def convert_to_prediction(self, predictions: NamedTuple, **kwargs) -> Prediction:
         """
@@ -68,6 +78,8 @@ class ClassificationToPredictionConverter(InferenceResultsToPredictionConverter)
     :param label_schema: LabelSchema containing the label info of the task
     """
 
+    domain = Domain.CLASSIFICATION
+
     def __init__(self, label_schema: LabelSchema):
         all_labels = label_schema.get_labels(include_empty=True)
         # add empty labels if only one non-empty label exits
@@ -119,6 +131,8 @@ class DetectionToPredictionConverter(InferenceResultsToPredictionConverter):
     :param configuration: optional model configuration setting
     """
 
+    domain = Domain.DETECTION
+
     def __init__(
         self, label_schema: LabelSchema, configuration: Optional[Dict[str, Any]] = None
     ):
@@ -191,6 +205,8 @@ class RotatedRectToPredictionConverter(DetectionToPredictionConverter):
     :param label_schema: LabelSchema containing the label info of the task
     """
 
+    domain = Domain.ROTATED_DETECTION
+
     def convert_to_prediction(
         self, predictions: InstanceSegmentationResult, **kwargs
     ) -> Prediction:
@@ -256,6 +272,8 @@ def convert_to_prediction(
 class MaskToAnnotationConverter(InferenceResultsToPredictionConverter):
     """Converts DetectionBox Predictions ModelAPI to Prediction object."""
 
+    domain = Domain.INSTANCE_SEGMENTATION
+
     def __init__(
         self, label_schema: LabelSchema, configuration: Optional[Dict[str, Any]] = None
     ):
@@ -337,6 +355,8 @@ class SegmentationToPredictionConverter(InferenceResultsToPredictionConverter):
     :param label_schema: LabelSchema containing the label info of the task
     """
 
+    domain = Domain.SEGMENTATION
+
     def __init__(self, label_schema: LabelSchema):
         self.labels = label_schema.get_labels(include_empty=False)
         # NB: index=0 is reserved for the background label
@@ -366,6 +386,8 @@ class AnomalyToPredictionConverter(InferenceResultsToPredictionConverter):
     :param label_schema: LabelSchema containing the label info of the task
     """
 
+    domain = Domain.ANOMALY
+
     def __init__(self, label_schema: LabelSchema):
         self.labels = label_schema.get_labels(include_empty=False)
         self.normal_label = next(