Cover utils

Author: sovrasov

model_api/python/model_api/adapters/openvino_adapter.py

@@ -380,7 +380,7 @@ def embed_preprocessing(
                 ppp.input(input_idx).tensor().set_shape(input_shape)
                 ppp.input(input_idx).preprocess().custom(
                     RESIZE_MODE_MAP[resize_mode](
-                        target_shape,
+                        (target_shape[0], target_shape[1]),
                         INTERPOLATION_MODE_MAP[interpolation_mode],
                         pad_value,
                     ),

model_api/python/model_api/adapters/utils.py

@@ -7,12 +7,12 @@
 
 import math
 from functools import partial
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import cv2
 import numpy as np
 from openvino import Model, OVAny, Type, layout_helpers
-from openvino.runtime import Output
+from openvino.runtime import Input, Node, Output
 from openvino.runtime import opset10 as opset
 from openvino.runtime.utils.decorators import custom_preprocess_function
 
@@ -21,11 +21,11 @@
 
 
 class Layout:
-    def __init__(self, layout="") -> None:
+    def __init__(self, layout: str = "") -> None:
         self.layout = layout
 
     @staticmethod
-    def from_shape(shape):
+    def from_shape(shape: list[int] | tuple[int, ...]) -> str:
         """Create Layout from given shape"""
         if len(shape) == 2:
             return "NC"
@@ -40,7 +40,7 @@ def from_shape(shape):
         raise RuntimeError(msg)
 
     @staticmethod
-    def from_openvino(input):
+    def from_openvino(input: Input):
         """Create Layout from openvino input"""
         return layout_helpers.get_layout(input).to_string().strip("[]").replace(",", "")
 
@@ -75,7 +75,7 @@ def parse_layouts(layout_string: str) -> dict | None:
         return user_layouts
 
 
-def resize_image_letterbox_graph(input: Output, size, interpolation, pad_value):
+def resize_image_letterbox_graph(input: Output, size: tuple[int, int], interpolation: str, pad_value: int) -> Node:
     if not isinstance(pad_value, int):
         msg = "pad_value must be int"
         raise RuntimeError(msg)
@@ -157,7 +157,7 @@ def resize_image_letterbox_graph(input: Output, size, interpolation, pad_value):
     )
 
 
-def crop_resize_graph(input: Output, size):
+def crop_resize_graph(input: Output, size: tuple[int, int]) -> Node:
     h_axis = 1
     w_axis = 2
     desired_aspect_ratio = size[1] / size[0]  # width / height
@@ -288,11 +288,11 @@ def crop_resize_graph(input: Output, size):
 
 def resize_image_graph(
     input: Output,
-    size,
-    keep_aspect_ratio,
-    interpolation,
-    pad_value,
-):
+    size: tuple[int, int],
+    keep_aspect_ratio: bool,
+    interpolation: str,
+    pad_value: int,
+) -> Node:
     if not isinstance(pad_value, int):
         msg = "pad_value must be int"
         raise RuntimeError(msg)
@@ -365,7 +365,7 @@ def resize_image_graph(
     )
 
 
-def resize_image(size, interpolation, pad_value):
+def resize_image(size: tuple[int, int], interpolation: str, pad_value: int) -> Callable:
     return custom_preprocess_function(
         partial(
             resize_image_graph,
@@ -377,7 +377,7 @@ def resize_image(size, interpolation, pad_value):
     )
 
 
-def resize_image_with_aspect(size, interpolation, pad_value):
+def resize_image_with_aspect(size: tuple[int, int], interpolation: str, pad_value: int) -> Callable:
     return custom_preprocess_function(
         partial(
             resize_image_graph,
@@ -389,11 +389,11 @@ def resize_image_with_aspect(size, interpolation, pad_value):
     )
 
 
-def crop_resize(size, interpolation, pad_value):
+def crop_resize(size: tuple[int, int], interpolation: str, pad_value: int) -> Callable:
     return custom_preprocess_function(partial(crop_resize_graph, size=size))
 
 
-def resize_image_letterbox(size, interpolation, pad_value):
+def resize_image_letterbox(size: tuple[int, int], interpolation: str, pad_value: int) -> Callable:
     return custom_preprocess_function(
         partial(
             resize_image_letterbox_graph,
@@ -404,8 +404,8 @@ def resize_image_letterbox(size, interpolation, pad_value):
     )
 
 
-def load_parameters_from_onnx(onnx_model):
-    parameters = {}
+def load_parameters_from_onnx(onnx_model: Any) -> dict[str, Any]:
+    parameters: dict[str, Any] = {}
 
     def insert_hierarchical(keys, val, root_dict):
         if len(keys) == 1:
@@ -423,7 +423,7 @@ def insert_hierarchical(keys, val, root_dict):
     return parameters
 
 
-def get_rt_info_from_dict(rt_info_dict, path):
+def get_rt_info_from_dict(rt_info_dict: dict[str, Any], path: list[str]) -> OVAny:
     value = rt_info_dict
     try:
         value = rt_info_dict
@@ -436,13 +436,13 @@ def get_rt_info_from_dict(rt_info_dict, path):
 
 
 def resize_image_ocv(
-    image,
-    size,
-    keep_aspect_ratio=False,
-    is_pad=False,
-    pad_value=0,
-    interpolation=cv2.INTER_LINEAR,
-):
+    image: np.ndarray,
+    size: tuple[int, int],
+    keep_aspect_ratio: bool = False,
+    is_pad: bool = False,
+    pad_value: int = 0,
+    interpolation: int = cv2.INTER_LINEAR,
+) -> np.ndarray:
     if keep_aspect_ratio:
         h, w = image.shape[:2]
         scale = min(size[1] / h, size[0] / w)
@@ -460,7 +460,11 @@ def resize_image_ocv(
     return cv2.resize(image, size, interpolation=interpolation)
 
 
-def resize_image_with_aspect_ocv(image, size, interpolation=cv2.INTER_LINEAR):
+def resize_image_with_aspect_ocv(
+    image: np.ndarray,
+    size: tuple[int, int],
+    interpolation: int = cv2.INTER_LINEAR,
+) -> np.ndarray:
     return resize_image_ocv(
         image,
         size,
@@ -472,11 +476,11 @@ def resize_image_with_aspect_ocv(image, size, interpolation=cv2.INTER_LINEAR):
 
 
 def resize_image_letterbox_ocv(
-    image,
-    size,
-    interpolation=cv2.INTER_LINEAR,
-    pad_value=0,
-):
+    image: np.ndarray,
+    size: tuple[int, int],
+    interpolation: int = cv2.INTER_LINEAR,
+    pad_value: int = 0,
+) -> np.ndarray:
     ih, iw = image.shape[0:2]
     w, h = size
     scale = min(w / iw, h / ih)
@@ -493,7 +497,7 @@ def resize_image_letterbox_ocv(
     )
 
 
-def crop_resize_ocv(image, size):
+def crop_resize_ocv(image: np.ndarray, size: tuple[int, int]) -> np.ndarray:
     desired_aspect_ratio = size[1] / size[0]  # width / height
     if desired_aspect_ratio == 1:
         if image.shape[0] > image.shape[1]:
@@ -522,7 +526,7 @@ def crop_resize_ocv(image, size):
 }
 
 
-INTERPOLATION_TYPES = {
+INTERPOLATION_TYPES: dict[str, int] = {
     "LINEAR": cv2.INTER_LINEAR,
     "CUBIC": cv2.INTER_CUBIC,
     "NEAREST": cv2.INTER_NEAREST,
@@ -533,9 +537,9 @@ def crop_resize_ocv(image, size):
 class InputTransform:
     def __init__(
         self,
-        reverse_input_channels=False,
-        mean_values=None,
-        scale_values=None,
+        reverse_input_channels: bool = False,
+        mean_values: list[float] | None = None,
+        scale_values: list[float] | None = None,
     ):
         self.reverse_input_channels = reverse_input_channels
         self.is_trivial = not (reverse_input_channels or mean_values or scale_values)

model_api/python/model_api/models/classification.py

@@ -19,6 +19,7 @@
 from model_api.models.image_model import ImageModel
 from model_api.models.result_types import ClassificationResult
 from model_api.models.types import BooleanValue, ListValue, NumericalValue, StringValue
+from model_api.models.utils import softmax
 
 if TYPE_CHECKING:
     from model_api.adapters.inference_adapter import InferenceAdapter
@@ -232,7 +233,7 @@ def get_all_probs(self, logits: np.ndarray) -> np.ndarray:
             cls_heads_info = self.hierarchical_info["cls_heads_info"]
             for i in range(cls_heads_info["num_multiclass_heads"]):
                 logits_begin, logits_end = cls_heads_info["head_idx_to_logits_range"][str(i)]
-                probs[logits_begin:logits_end] = softmax_numpy(
+                probs[logits_begin:logits_end] = softmax(
                     logits[logits_begin:logits_end],
                 )
 
@@ -242,7 +243,7 @@ def get_all_probs(self, logits: np.ndarray) -> np.ndarray:
         elif self.embedded_topk:
             probs = logits.reshape(-1)
         else:
-            probs = softmax_numpy(logits.reshape(-1))
+            probs = softmax(logits.reshape(-1))
         return probs
 
     def get_hierarchical_predictions(self, logits: np.ndarray):
@@ -252,7 +253,7 @@ def get_hierarchical_predictions(self, logits: np.ndarray):
         for i in range(cls_heads_info["num_multiclass_heads"]):
             logits_begin, logits_end = cls_heads_info["head_idx_to_logits_range"][str(i)]
             head_logits = logits[logits_begin:logits_end]
-            head_logits = softmax_numpy(head_logits)
+            head_logits = softmax(head_logits)
             j = np.argmax(head_logits)
             label_str = cls_heads_info["all_groups"][i][j]
             predicted_labels.append(label_str)
@@ -290,7 +291,7 @@ def get_multiclass_predictions(self, outputs: dict) -> list[tuple[int, str, floa
             scoresTensor = outputs[self.out_layer_names[1]][0]
             labels = [self.labels[i] if self.labels else "" for i in indicesTensor]
         else:
-            scoresTensor = softmax_numpy(outputs[self.out_layer_names[0]][0])
+            scoresTensor = softmax(outputs[self.out_layer_names[0]][0])
             indicesTensor = [np.argmax(scoresTensor)]
             labels = [self.labels[i] if self.labels else "" for i in indicesTensor]
         return list(zip(indicesTensor, labels, scoresTensor))
@@ -352,11 +353,6 @@ def sigmoid_numpy(x: np.ndarray) -> np.ndarray:
     return 1.0 / (1.0 + np.exp(-x))
 
 
-def softmax_numpy(x: np.ndarray, eps: float = 1e-9) -> np.ndarray:
-    x = np.exp(x - np.max(x))
-    return x / (np.sum(x) + eps)
-
-
 class GreedyLabelsResolver:
     def __init__(self, hierarchical_config: dict) -> None:
         self.label_to_idx = hierarchical_config["cls_heads_info"]["label_to_idx"]

model_api/python/model_api/models/utils.py

@@ -10,10 +10,10 @@
 import cv2
 import numpy as np
 
-from model_api.models.result_types import Contour, SegmentedObject, SegmentedObjectWithRects
+from model_api.models.result_types import Contour, Detection, SegmentedObject, SegmentedObjectWithRects
 
 
-def add_rotated_rects(segmented_objects):
+def add_rotated_rects(segmented_objects: list[SegmentedObject]) -> list[SegmentedObjectWithRects]:
     objects_with_rects = []
     for segmented_object in segmented_objects:
         mask = segmented_object.mask.astype(np.uint8)
@@ -32,7 +32,7 @@ def add_rotated_rects(segmented_objects):
 
 def get_contours(
     segmentedObjects: list[SegmentedObject | SegmentedObjectWithRects],
-):
+) -> list[Contour]:
     combined_contours = []
     for obj in segmentedObjects:
         contours, _ = cv2.findContours(
@@ -49,7 +49,7 @@ def get_contours(
     return combined_contours
 
 
-def clip_detections(detections, size):
+def clip_detections(detections: list[Detection], size: tuple[int, int]) -> list[Detection]:
     for detection in detections:
         detection.xmin = min(max(round(detection.xmin), 0), size[1])
         detection.ymin = min(max(round(detection.ymin), 0), size[0])
@@ -94,7 +94,16 @@ def load_labels(label_file):
         return [x.strip() for x in f]
 
 
-def nms(x1, y1, x2, y2, scores, thresh, include_boundaries=False, keep_top_k=0):
+def nms(
+    x1: np.ndarray,
+    y1: np.ndarray,
+    x2: np.ndarray,
+    y2: np.ndarray,
+    scores: np.ndarray,
+    thresh: float,
+    include_boundaries: bool = False,
+    keep_top_k: int = 0,
+) -> list[int]:
     b = 1 if include_boundaries else 0
     areas = (x2 - x1 + b) * (y2 - y1 + b)
     order = scores.argsort()[::-1]
@@ -130,9 +139,9 @@ def nms(x1, y1, x2, y2, scores, thresh, include_boundaries=False, keep_top_k=0):
 
 
 def multiclass_nms(
-    detections,
-    iou_threshold=0.45,
-    max_num=200,
+    detections: np.ndarray,
+    iou_threshold: float = 0.45,
+    max_num: int = 200,
 ):
     """Multi-class NMS.
 
@@ -158,14 +167,14 @@ def multiclass_nms(
     offsets = labels.astype(boxes.dtype) * (max_coordinate + 1)
     boxes_for_nms = boxes + offsets[:, None]
 
-    keep = nms(*boxes_for_nms.T, scores, iou_threshold)
+    keep = nms(*boxes_for_nms.T, scores=scores, thresh=iou_threshold)
     if max_num > 0:
         keep = keep[:max_num]
     keep = np.array(keep)
     det = detections[keep]
     return det, keep
 
 
-def softmax(logits, axis=None, keepdims=False):
+def softmax(logits: np.ndarray, eps: float = 1e-9, axis=None, keepdims: bool = False) -> np.ndarray:
     exp = np.exp(logits - np.max(logits))
-    return exp / np.sum(exp, axis=axis, keepdims=keepdims)
+    return exp / (np.sum(exp, axis=axis, keepdims=keepdims) + eps)