Merge remote-tracking branch 'origin/master' into vs/py_test_struct

Author: sovrasov

docs/source/python/models/detection_model.md

@@ -1,5 +1,46 @@
 # Detection Model
 
+## Description
+
+Detection model aims to detect objects in an image. The model outputs a list of detected objects, each containing a bounding box, score and class label.
+
+## OpenVINO Model Specifications
+
+### Inputs
+
+A single input image of shape (H, W, 3) where H and W are the height and width of the image, respectively.
+
+### Outputs
+
+Detection model outputs a list of detection objects (i.e `list[Detection]`) wrapped in `DetectionResult`, each object containing the following attributes:
+
+- `score` (float) - Confidence score of the object.
+- `id` (int) - Class label of the object.
+- `str_label` (str) - String label of the object.
+- `xmin` (int) - X-coordinate of the top-left corner of the bounding box.
+- `ymin` (int) - Y-coordinate of the top-left corner of the bounding box.
+- `xmax` (int) - X-coordinate of the bottom-right corner of the bounding box.
+- `ymax` (int) - Y-coordinate of the bottom-right corner of the bounding box.
+
+## Example
+
+```python
+import cv2
+from model_api.models import SSD
+
+# Load the model
+model = SSD.create_model("model.xml")
+
+# Forward pass
+predictions = model(image)
+
+# Iterate over the segmented objects
+for pred_obj in predictions.objects:
+    pred_score = pred_obj.score
+    label_id = pred_obj.id
+    bbox = [pred_obj.xmin, pred_obj.ymin, pred_obj.xmax, pred_obj.ymax]
+```
+
 ```{eval-rst}
 .. automodule:: model_api.models.detection_model
    :members:

docs/source/python/models/instance_segmentation.md

@@ -1,5 +1,48 @@
 # Instance Segmentation
 
+## Description
+
+Instance segmentation model aims to detect and segment objects in an image. It is an extension of object detection, where each object is segmented into a separate mask. The model outputs a list of segmented objects, each containing a mask, bounding box, score and class label.
+
+## OpenVINO Model Specifications
+
+### Inputs
+
+A single input image of shape (H, W, 3) where H and W are the height and width of the image, respectively.
+
+### Outputs
+
+Instance segmentation model outputs a list of segmented objects (i.e `list[SegmentedObject]`)wrapped in `InstanceSegmentationResult.segmentedObjects`, each containing the following attributes:
+
+- `mask` (numpy.ndarray) - A binary mask of the object.
+- `score` (float) - Confidence score of the object.
+- `id` (int) - Class label of the object.
+- `str_label` (str) - String label of the object.
+- `xmin` (int) - X-coordinate of the top-left corner of the bounding box.
+- `ymin` (int) - Y-coordinate of the top-left corner of the bounding box.
+- `xmax` (int) - X-coordinate of the bottom-right corner of the bounding box.
+- `ymax` (int) - Y-coordinate of the bottom-right corner of the bounding box.
+
+## Example
+
+```python
+import cv2
+from model_api.models import MaskRCNNModel
+
+# Load the model
+model = MaskRCNNModel.create_model("model.xml")
+
+# Forward pass
+predictions = model(image)
+
+# Iterate over the segmented objects
+for pred_obj in predictions.segmentedObjects:
+    pred_mask = pred_obj.mask
+    pred_score = pred_obj.score
+    label_id = pred_obj.id
+    bbox = [pred_obj.xmin, pred_obj.ymin, pred_obj.xmax, pred_obj.ymax]
+```
+
 ```{eval-rst}
 .. automodule:: model_api.models.instance_segmentation
    :members:

docs/source/python/models/keypoint_detection.md

@@ -1,5 +1,55 @@
 # Keypoint Detection
 
+## Description
+
+Keypoint detection model aims to detect a set of pre-defined keypoints on a cropped object.
+If a crop is not tight enough, quality of keypoints degrades. Having this model and an
+object detector, one can organize keypoint detection for all objects of interest presented on an image (top-down approach).
+
+## Models
+
+Top-down keypoint detection pipeline uses detections that come from any appropriate detector,
+and a keypoints regression model acting on crops.
+
+### Parameters
+
+The following parameters can be provided via python API or RT Info embedded into OV model:
+
+- `labels`(`list(str)`) : a list of keypoints names.
+
+## OpenVINO Model Specifications
+
+### Inputs
+
+A single `NCHW` tensor representing a batch of images.
+
+### Outputs
+
+Two vectors in Simple Coordinate Classification Perspective ([SimCC](https://arxiv.org/abs/2107.03332)) format:
+
+- `pred_x` (B, N, D1) - `x` coordinate representation, where `N` is the number of keypoints.
+- `pred_y` (B, N, D2) - `y` coordinate representation, where `N` is the number of keypoints.
+
+## Example
+
+```python
+import cv2
+from model_api.models import TopDownKeypointDetectionPipeline, Detection, KeypointDetectionModel
+
+model = KeypointDetectionModel.create_model("kp_model.xml")
+# a list of detections in (x_min, y_min, x_max, y_max, score, class_id) format
+detections = [Detection(0, 0, 100, 100, 1.0, 0)]
+top_down_pipeline = TopDownKeypointDetectionPipeline(model)
+predictions = top_down_detector.predict(image, detections)
+
+# iterating over a list of DetectedKeypoints. Each of the items corresponds to a detection
+for obj_keypoints in predictions:
+    for point in obj_keypoints.keypoints.astype(np.int32):
+        cv2.circle(
+            image, point, radius=0, color=(0, 255, 0), thickness=5
+        )
+```
+
 ```{eval-rst}
 .. automodule:: model_api.models.keypoint_detection
    :members:

model_api/python/model_api/adapters/inference_adapter.py

@@ -5,7 +5,7 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Set, Tuple
+from typing import Any
 
 
 @dataclass

model_api/python/model_api/adapters/openvino_adapter.py

@@ -301,7 +301,7 @@ def await_any(self) -> None:
     def _get_meta_from_ngraph(self, layers_info):
         for node in self.model.get_ordered_ops():
             layer_name = node.get_friendly_name()
-            if layer_name not in layers_info.keys():
+            if layer_name not in layers_info:
                 continue
             layers_info[layer_name].meta = node.get_attributes()
             layers_info[layer_name].type = node.get_type_name()
@@ -339,9 +339,9 @@ def embed_preprocessing(
         ppp = PrePostProcessor(self.model)
 
         # Change the input type to the 8-bit image
-        if dtype == int:
+        if dtype is int:
             ppp.input(input_idx).tensor().set_element_type(Type.u8)
-        elif dtype == float:
+        elif dtype is float:
             ppp.input(input_idx).tensor().set_element_type(Type.f32)
 
         ppp.input(input_idx).tensor().set_layout(ov.Layout("NHWC")).set_color_format(

model_api/python/model_api/adapters/ovms_adapter.py

@@ -185,7 +185,7 @@ def _verify_model_available(client, model_name, model_version):
 def _prepare_inputs(dict_data, inputs_meta):
     inputs = {}
     for input_name, input_data in dict_data.items():
-        if input_name not in inputs_meta.keys():
+        if input_name not in inputs_meta:
             raise ValueError("Input data does not match model inputs")
         input_info = inputs_meta[input_name]
         model_precision = _tf2np_precision[input_info["dtype"]]

model_api/python/model_api/adapters/utils.py

@@ -6,8 +6,8 @@
 from __future__ import annotations  # TODO: remove when Python3.9 support is dropped
 
 import math
+from collections.abc import Callable
 from functools import partial
-from typing import Callable, Optional
 
 import cv2
 import numpy as np

model_api/python/model_api/models/__init__.py

@@ -11,25 +11,26 @@
 from .instance_segmentation import MaskRCNNModel
 from .keypoint_detection import KeypointDetectionModel, TopDownKeypointDetectionPipeline
 from .model import Model
-from .sam_models import SAMDecoder, SAMImageEncoder
-from .segmentation import SalientObjectDetectionModel, SegmentationModel
-from .ssd import SSD
-from .utils import (
+from .result_types import (
     AnomalyResult,
     ClassificationResult,
     Contour,
     DetectedKeypoints,
     Detection,
     DetectionResult,
-    DetectionWithLandmarks,
     ImageResultWithSoftPrediction,
     InstanceSegmentationResult,
-    OutputTransform,
     PredictedMask,
     SegmentedObject,
     SegmentedObjectWithRects,
     VisualPromptingResult,
     ZSLVisualPromptingResult,
+)
+from .sam_models import SAMDecoder, SAMImageEncoder
+from .segmentation import SalientObjectDetectionModel, SegmentationModel
+from .ssd import SSD
+from .utils import (
+    OutputTransform,
     add_rotated_rects,
     get_contours,
 )
@@ -62,8 +63,6 @@
     "ClassificationModel",
     "Contour",
     "DetectionModel",
-    "DetectionWithLandmarks",
-    "ImageMattingWithBackground",
     "ImageModel",
     "ImageResultWithSoftPrediction",
     "InstanceSegmentationResult",
@@ -77,11 +76,9 @@
     "MaskRCNNModel",
     "Model",
     "OutputTransform",
-    "PortraitBackgroundMatting",
     "SalientObjectDetectionModel",
     "SegmentationModel",
     "SSD",
-    "VideoBackgroundMatting",
     "YOLO",
     "YoloV3ONNX",
     "YoloV4",
@@ -95,7 +92,6 @@
     "Prompt",
     "Detection",
     "DetectionResult",
-    "DetectionWithLandmarks",
     "DetectedKeypoints",
     "classification_models",
     "detection_models",

model_api/python/model_api/models/action_classification.py

@@ -12,8 +12,9 @@
 from model_api.adapters.utils import RESIZE_TYPES, InputTransform
 
 from .model import Model
+from .result_types import ClassificationResult
 from .types import BooleanValue, ListValue, NumericalValue, StringValue
-from .utils import ClassificationResult, load_labels
+from .utils import load_labels
 
 if TYPE_CHECKING:
     from model_api.adapters.inference_adapter import InferenceAdapter
@@ -99,7 +100,10 @@ def parameters(cls) -> dict[str, Any]:
                     description="Path to file with labels. Overrides the labels, if they sets via 'labels' parameter",
                 ),
                 "mean_values": ListValue(
-                    description="Normalization values, which will be subtracted from image channels for image-input layer during preprocessing",
+                    description=(
+                        "Normalization values, which will be subtracted from image channels "
+                        "for image-input layer during preprocessing"
+                    ),
                     default_value=[],
                 ),
                 "pad_value": NumericalValue(

model_api/python/model_api/models/anomaly.py

@@ -17,8 +17,8 @@
 from model_api.adapters.inference_adapter import InferenceAdapter
 
 from .image_model import ImageModel
+from .result_types import AnomalyResult
 from .types import ListValue, NumericalValue, StringValue
-from .utils import AnomalyResult
 
 
 class AnomalyDetection(ImageModel):