supervisely 6.73.283__py3-none-any.whl → 6.73.285__py3-none-any.whl

supervisely/_utils.py

@@ -83,6 +83,15 @@ def take_with_default(v, default):
     return v if v is not None else default
 
 
+def find_value_by_keys(d: Dict, keys: List[str], default=object()):
+    for key in keys:
+        if key in d:
+            return d[key]
+    if default is object():
+        raise KeyError(f"None of the keys {keys} are in the dictionary.")
+    return default
+
+
 def batched(seq, batch_size=50):
     for i in range(0, len(seq), batch_size):
         yield seq[i : i + batch_size]

supervisely/api/entity_annotation/figure_api.py

@@ -81,6 +81,9 @@ class FigureInfo(NamedTuple):
         if self.geometry_meta is not None:
             return Rectangle(*self.geometry_meta["bbox"], sly_id=self.id)
 
+    def to_json(self):
+        return FigureApi.convert_info_to_json(self)
+
 
 class FigureApi(RemoveableBulkModuleApi):
     """

supervisely/api/module_api.py

@@ -3,7 +3,16 @@ import asyncio
 from collections import namedtuple
 from copy import deepcopy
 from math import ceil
-from typing import TYPE_CHECKING, Any, AsyncGenerator, List, NamedTuple, Optional, Tuple
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Dict,
+    List,
+    NamedTuple,
+    Optional,
+    Tuple,
+)
 
 import requests
 
@@ -602,6 +611,8 @@ class ApiField:
     """"""
     WITH_SHARED = "withShared"
     """"""
+    USE_DIRECT_PROGRESS_MESSAGES = "useDirectProgressMessages"
+    """"""
     EXTRA_FIELDS = "extraFields"
     """"""
     CUSTOM_SORT = "customSort"
@@ -861,6 +872,29 @@ class ModuleApiBase(_JsonConvertibleModule):
                     raise RuntimeError("Can not parse field {!r}".format(field_name))
             return self.InfoType(*field_values)
 
+    @classmethod
+    def convert_info_to_json(cls, info: NamedTuple) -> Dict:
+        """_convert_info_to_json"""
+
+        def _create_nested_dict(keys, value):
+            if len(keys) == 1:
+                return {keys[0]: value}
+            else:
+                return {keys[0]: _create_nested_dict(keys[1:], value)}
+
+        json_info = {}
+        for field_name, value in zip(cls.info_sequence(), info):
+            if type(field_name) is str:
+                json_info[field_name] = value
+            elif isinstance(field_name, tuple):
+                if len(field_name[0]) == 0:
+                    json_info[field_name[1]] = value
+                else:
+                    json_info.update(_create_nested_dict(field_name[0], value))
+            else:
+                raise RuntimeError("Can not parse field {!r}".format(field_name))
+        return json_info
+
     def _get_response_by_id(self, id, method, id_field, fields=None):
         """_get_response_by_id"""
         try:

supervisely/api/video/video_api.py

@@ -1361,7 +1361,7 @@ class VideoApi(RemoveableBulkModuleApi):
         :return: None
         """
 
-        response = self._api.post(
+        self._api.post(
             "videos.notify-annotation-tool",
             {
                 "type": "videos:tracking-error",

supervisely/api/video_annotation_tool_api.py

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 from supervisely.api.module_api import ApiField, ModuleApiBase
 from supervisely.collection.str_enum import StrEnum
@@ -21,6 +21,7 @@ class VideoAnnotationToolAction(StrEnum):
     """"""
     ENTITIES_SET_INTITY = "entities/setEntity"
     """"""
+    DIRECT_TRACKING_PROGRESS = "figures/setDirectTrackingProgress"
 
 
 class VideoAnnotationToolApi(ModuleApiBase):
@@ -51,7 +52,7 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_ENABLE_CONTROLS,
             {},
         )
-        
+
     def disable_submit_button(self, session_id: str) -> Dict[str, Any]:
         """Disables submit button of the labeling jobs.
 
@@ -65,7 +66,7 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_DISABLE_SUBMIT,
             {},
         )
-        
+
     def enable_submit_button(self, session_id: str) -> Dict[str, Any]:
         """Enables submit button of the labeling jobs.
 
@@ -79,7 +80,7 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_ENABLE_SUBMIT,
             {},
         )
-        
+
     def disable_confirm_button(self, session_id: str) -> Dict[str, Any]:
         """Disables confirm button of the labeling jobs.
 
@@ -93,10 +94,10 @@ class VideoAnnotationToolApi(ModuleApiBase):
             VideoAnnotationToolAction.JOBS_DISABLE_CONFIRM,
             {},
         )
-    
+
     def enable_confirm_button(self, session_id: str) -> Dict[str, Any]:
         """Enables confirm button of the labeling jobs.
-        
+
         :param session_id: ID of the session in the Video Labeling Tool which confirm button should be enabled.
         :type session_id: str
         :return: Response from API server in JSON format.
@@ -132,12 +133,62 @@ class VideoAnnotationToolApi(ModuleApiBase):
             },
         )
 
+    def set_direct_tracking_progress(
+        self,
+        session_id: str,
+        video_id: int,
+        track_id: str,
+        frame_range: Tuple,
+        progress_current: int,
+        progress_total: int,
+    ):
+        payload = {
+            ApiField.TRACK_ID: track_id,
+            ApiField.VIDEO_ID: video_id,
+            ApiField.FRAME_RANGE: frame_range,
+            ApiField.PROGRESS: {
+                ApiField.CURRENT: progress_current,
+                ApiField.TOTAL: progress_total,
+            },
+        }
+        return self._act(session_id, VideoAnnotationToolAction.DIRECT_TRACKING_PROGRESS, payload)
+
+    def set_direct_tracking_error(
+        self,
+        session_id: str,
+        video_id: int,
+        track_id: str,
+        message: str,
+    ):
+        payload = {
+            ApiField.TRACK_ID: track_id,
+            ApiField.VIDEO_ID: video_id,
+            ApiField.TYPE: "error",
+            ApiField.ERROR: {ApiField.MESSAGE: message},
+        }
+        return self._act(session_id, VideoAnnotationToolAction.DIRECT_TRACKING_PROGRESS, payload)
+
+    def set_direct_tracking_warning(
+        self,
+        session_id: str,
+        video_id: int,
+        track_id: str,
+        message: str,
+    ):
+        payload = {
+            ApiField.TRACK_ID: track_id,
+            ApiField.VIDEO_ID: video_id,
+            ApiField.TYPE: "warning",
+            ApiField.MESSAGE: message,
+        }
+        return self._act(session_id, VideoAnnotationToolAction.DIRECT_TRACKING_PROGRESS, payload)
+
     def _act(self, session_id: int, action: VideoAnnotationToolAction, payload: dict):
         data = {
             ApiField.SESSION_ID: session_id,
             ApiField.ACTION: str(action),
             ApiField.PAYLOAD: payload,
         }
-        resp = self._api.post("/annotation-tool.run-action", data)
+        resp = self._api.post("annotation-tool.run-action", data)
 
         return resp.json()

supervisely/nn/benchmark/base_benchmark.py

@@ -1,5 +1,6 @@
 import os
-from typing import Callable, List, Optional, Tuple, Union
+from pathlib import Path
+from typing import Callable, List, Optional, Tuple, Union, Type
 
 import numpy as np
 
@@ -80,7 +81,7 @@ class BaseBenchmark:
         self.report_id = None
         self._validate_evaluation_params()
 
-    def _get_evaluator_class(self) -> type:
+    def _get_evaluator_class(self) -> Type[BaseEvaluator]:
         raise NotImplementedError()
 
     @property
@@ -95,6 +96,10 @@ class BaseBenchmark:
     def key_metrics(self):
         eval_results = self.get_eval_result()
         return eval_results.key_metrics
+    
+    @property
+    def primary_metric_name(self) -> str:
+        return self._get_evaluator_class().eval_result_cls.PRIMARY_METRIC
 
     def run_evaluation(
         self,
@@ -492,6 +497,8 @@ class BaseBenchmark:
                 "It should be defined in the subclass of BaseBenchmark (e.g. ObjectDetectionBenchmark)."
             )
         eval_result = self.get_eval_result()
+        self._dump_key_metrics(eval_result)
+
         layout_dir = self.get_layout_results_dir()
         self.visualizer = self.visualizer_cls(  # pylint: disable=not-callable
             self.api, [eval_result], layout_dir, self.pbar
@@ -621,3 +628,7 @@ class BaseBenchmark:
             self.diff_project_info = eval_result.diff_project_info
             return self.diff_project_info
         return None
+
+    def _dump_key_metrics(self, eval_result: BaseEvaluator):
+        path = str(Path(self.get_eval_results_dir(), "key_metrics.json"))
+        json.dump_json_file(eval_result.key_metrics, path)

supervisely/nn/benchmark/base_evaluator.py

@@ -12,6 +12,8 @@ from supervisely.task.progress import tqdm_sly
 
 
 class BaseEvalResult:
+    PRIMARY_METRIC = None
+
     def __init__(self, directory: Optional[str] = None):
         self.directory = directory
         self.inference_info: Dict = None

supervisely/nn/benchmark/comparison/detection_visualization/text_templates.py

@@ -87,6 +87,11 @@ In this section you can visually assess the model performance through examples.
 > Filtering options allow you to adjust the confidence threshold (only for predictions) and the model's false outcomes (only for differences). Differences are calculated only for the optimal confidence threshold, allowing you to focus on the most accurate predictions made by the model.
 """
 
+markdown_different_iou_thresholds_warning = """### IoU Thresholds Mismatch
+
+<i class="zmdi zmdi-alert-polygon" style="color: #f5a623; margin-right: 5px"></i> The models were evaluated using different IoU thresholds. Since these thresholds varied between models and classes, it may have led to unfair comparison. For fair model comparison, we suggest using the same IoU threshold across models.
+"""
+
 markdown_explore_difference = """## Explore Predictions
 
 In this section, you can explore predictions made by different models side-by-side. This helps you to understand the differences in predictions made by each model, and to identify which model performs better in different scenarios.

supervisely/nn/benchmark/comparison/detection_visualization/vis_metrics/overview.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from typing import List
 
 from supervisely._utils import abs_url
@@ -15,6 +16,7 @@ class Overview(BaseVisMetrics):
     MARKDOWN_OVERVIEW = "markdown_overview"
     MARKDOWN_OVERVIEW_INFO = "markdown_overview_info"
     MARKDOWN_COMMON_OVERVIEW = "markdown_common_overview"
+    MARKDOWN_DIFF_IOU = "markdown_different_iou_thresholds_warning"
     CHART = "chart_key_metrics"
 
     def __init__(self, vis_texts, eval_results: List[EvalResult]) -> None:
@@ -237,3 +239,26 @@ class Overview(BaseVisMetrics):
             ),
         )
         return fig
+
+    @property
+    def not_matched_iou_per_class_thresholds_md(self) -> MarkdownWidget:
+        if all([not r.different_iou_thresholds_per_class for r in self.eval_results]):
+            return None
+
+        iou_thrs_map = defaultdict(set)
+        matched = True
+        for eval_result in self.eval_results:
+            for cat_id, iou_thr in eval_result.mp.iou_threshold_per_class.items():
+                iou_thrs_map[cat_id].add(iou_thr)
+                if len(iou_thrs_map[cat_id]) > 1:
+                    matched = False
+                    break
+
+        if matched:
+            return None
+
+        return MarkdownWidget(
+            name="markdown_different_iou_thresholds_warning",
+            title="IoU per class thresholds mismatch",
+            text=self.vis_texts.markdown_different_iou_thresholds_warning,
+        )

supervisely/nn/benchmark/comparison/detection_visualization/visualizer.py

@@ -50,10 +50,9 @@ class DetectionComparisonVisualizer(BaseComparisonVisualizer):
         self.overviews = self._create_overviews(overview)
         self.overview_md = overview.overview_md
         self.key_metrics_md = self._create_key_metrics()
-        self.key_metrics_table = overview.get_table_widget(
-            latency=speedtest.latency, fps=speedtest.fps
-        )
+        self.key_metrics_table = overview.get_table_widget(speedtest.latency, speedtest.fps)
         self.overview_chart = overview.chart_widget
+        self.iou_per_class_thresholds_md = overview.not_matched_iou_per_class_thresholds_md
 
         columns_number = len(self.comparison.eval_results) + 1  # +1 for GT
         self.explore_predictions_modal_gallery = self._create_explore_modal_table(columns_number)
@@ -154,6 +153,13 @@ class DetectionComparisonVisualizer(BaseComparisonVisualizer):
             (0, self.header),
             (1, self.overview_md),
             (0, self.overviews),
+        ]
+
+        if self.iou_per_class_thresholds_md is not None:
+            is_anchors_widgets.append((0, self.iou_per_class_thresholds_md))
+
+        is_anchors_widgets += [
+            # Key Metrics
             (1, self.key_metrics_md),
             (0, self.key_metrics_table),
             (0, self.overview_chart),

supervisely/nn/benchmark/instance_segmentation/evaluator.py

@@ -14,6 +14,7 @@ from supervisely.nn.benchmark.utils import calculate_metrics, read_coco_datasets
 
 class InstanceSegmentationEvalResult(ObjectDetectionEvalResult):
     mp_cls = MetricProvider
+    PRIMARY_METRIC = "mAP"
 
     @classmethod
     def from_evaluator(

supervisely/nn/benchmark/instance_segmentation/text_templates.py

@@ -60,6 +60,13 @@ Here, we comprehensively assess the model's performance by presenting a broad se
 - **Calibration Score**: This score represents the consistency of predicted probabilities (or <abbr title="{}">confidence scores</abbr>) made by the model. We evaluate how well predicted probabilities align with actual outcomes. A well-calibrated model means that when it predicts an object with, say, 80% confidence, approximately 80% of those predictions should actually be correct.
 """
 
+markdown_AP_custom_description = """> * AP_custom - Average Precision with different IoU thresholds for each class, that was set in evaluation params by the user."""
+
+markdown_iou_per_class = """### IoU Threshold per Class
+
+The model is evaluated using different IoU thresholds for each class.
+"""
+
 markdown_explorer = """## Explore Predictions
 In this section you can visually assess the model performance through examples. This helps users better understand model capabilities and limitations, giving an intuitive grasp of prediction quality in different scenarios.
 

supervisely/nn/benchmark/object_detection/evaluator.py

@@ -19,6 +19,7 @@ from supervisely.nn.benchmark.visualization.vis_click_data import ClickData, IdM
 
 class ObjectDetectionEvalResult(BaseEvalResult):
     mp_cls = MetricProvider
+    PRIMARY_METRIC = "mAP"
 
     def _read_files(self, path: str) -> None:
         """Read all necessary files from the directory"""
@@ -92,6 +93,10 @@ class ObjectDetectionEvalResult(BaseEvalResult):
     def key_metrics(self):
         return self.mp.key_metrics()
 
+    @property
+    def different_iou_thresholds_per_class(self) -> bool:
+        return self.mp.iou_threshold_per_class is not None
+
 
 class ObjectDetectionEvaluator(BaseEvaluator):
     EVALUATION_PARAMS_YAML_PATH = f"{Path(__file__).parent}/evaluation_params.yaml"
@@ -120,12 +125,19 @@ class ObjectDetectionEvaluator(BaseEvaluator):
 
     @classmethod
     def validate_evaluation_params(cls, evaluation_params: dict) -> None:
+        available_thres = [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95]
         iou_threshold = evaluation_params.get("iou_threshold")
         if iou_threshold is not None:
-            assert iou_threshold in [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95], (
-                f"iou_threshold must be one of [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95], "
-                f"but got {iou_threshold}"
+            assert iou_threshold in available_thres, (
+                f"iou_threshold must be one of {available_thres}, " f"but got {iou_threshold}"
             )
+        iou_threshold_per_class = evaluation_params.get("iou_threshold_per_class")
+        if iou_threshold_per_class is not None:
+            for class_name, iou_thres in iou_threshold_per_class.items():
+                assert iou_thres in available_thres, (
+                    f"class {class_name}: iou_threshold_per_class must be one of {available_thres}, "
+                    f"but got {iou_thres}"
+                )
 
     def _convert_to_coco(self):
         cocoGt_json = sly2coco(

supervisely/nn/benchmark/object_detection/metric_provider.py

@@ -92,7 +92,11 @@ class MetricProvider:
 
         eval_params = params.get("evaluation_params", {})
         self.iou_threshold = eval_params.get("iou_threshold", 0.5)
-        self.iou_threshold_idx = np.searchsorted(self.iouThrs, self.iou_threshold)
+        self.iou_threshold_idx = np.where(np.isclose(self.iouThrs, self.iou_threshold))[0][0]
+
+        # IoU per class (optional)
+        self.iou_threshold_per_class = eval_params.get("iou_threshold_per_class")
+        self.iou_idx_per_class = params.get("iou_idx_per_class")  # {cat id: iou_idx}
 
     def calculate(self):
         self.m_full = _MetricProvider(
@@ -142,6 +146,8 @@ class MetricProvider:
     def json_metrics(self):
         base = self.base_metrics()
         iou_name = int(self.iou_threshold * 100)
+        if self.iou_threshold_per_class is not None:
+            iou_name = "_custom"
         ap_by_class = self.AP_per_class().tolist()
         ap_by_class = dict(zip(self.cat_names, ap_by_class))
         ap_custom_by_class = self.AP_custom_per_class().tolist()
@@ -166,6 +172,8 @@ class MetricProvider:
 
     def key_metrics(self):
         iou_name = int(self.iou_threshold * 100)
+        if self.iou_threshold_per_class is not None:
+            iou_name = "_custom"
         json_metrics = self.json_metrics()
         json_metrics.pop("AP_by_class")
         json_metrics.pop(f"AP{iou_name}_by_class")
@@ -174,6 +182,8 @@ class MetricProvider:
     def metric_table(self):
         table = self.json_metrics()
         iou_name = int(self.iou_threshold * 100)
+        if self.iou_threshold_per_class is not None:
+            iou_name = "_custom"
         return {
             "mAP": table["mAP"],
             "AP50": table["AP50"],
@@ -196,6 +206,10 @@ class MetricProvider:
 
     def AP_custom_per_class(self):
         s = self.coco_precision[self.iou_threshold_idx, :, :, 0, 2]
+        s = s.copy()
+        if self.iou_threshold_per_class is not None:
+            for cat_id, iou_idx in self.iou_idx_per_class.items():
+                s[:, cat_id - 1] = self.coco_precision[iou_idx, :, cat_id - 1, 0, 2]
         s[s == -1] = np.nan
         ap = np.nanmean(s, axis=0)
         return ap
@@ -280,6 +294,9 @@ class _MetricProvider:
             ious.append(match["iou"])
             cats.append(cat_id_to_idx[match["category_id"]])
         ious = np.array(ious) + np.spacing(1)
+        if 0.8999999999999999 in iouThrs:
+            iouThrs = iouThrs.copy()
+            iouThrs[iouThrs == 0.8999999999999999] = 0.9
         iou_idxs = np.searchsorted(iouThrs, ious) - 1
         cats = np.array(cats)
         # TP
@@ -452,6 +469,9 @@ class _MetricProvider:
         )
         scores = np.array([m["score"] for m in matches_sorted])
         ious = np.array([m["iou"] if m["type"] == "TP" else 0.0 for m in matches_sorted])
+        if 0.8999999999999999 in iouThrs:
+            iouThrs = iouThrs.copy()
+            iouThrs[iouThrs == 0.8999999999999999] = 0.9
         iou_idxs = np.searchsorted(iouThrs, ious + np.spacing(1))
 
         # Check

supervisely/nn/benchmark/object_detection/text_templates.py

@@ -65,6 +65,13 @@ Here, we comprehensively assess the model's performance by presenting a broad se
 - **Calibration Score**: This score represents the consistency of predicted probabilities (or <abbr title="{}">confidence scores</abbr>) made by the model. We evaluate how well predicted probabilities align with actual outcomes. A well-calibrated model means that when it predicts an object with, say, 80% confidence, approximately 80% of those predictions should actually be correct.
 """
 
+markdown_AP_custom_description = """> * AP_custom - Average Precision with different IoU thresholds for each class, that was set in evaluation params by the user."""
+
+markdown_iou_per_class = """### IoU Threshold per Class
+
+The model is evaluated using different IoU thresholds for each class.
+"""
+
 markdown_explorer = """## Explore Predictions
 In this section you can visually assess the model performance through examples. This helps users better understand model capabilities and limitations, giving an intuitive grasp of prediction quality in different scenarios.
 

supervisely/nn/benchmark/object_detection/vis_metrics/key_metrics.py

@@ -29,6 +29,8 @@ class KeyMetrics(DetectionVisMetric):
         columns = ["metrics", "values"]
         content = []
         for metric, value in self.eval_result.mp.metric_table().items():
+            if metric == "AP_custom":
+                metric += "*"
             row = [metric, round(value, 2)]
             dct = {
                 "row": row,
@@ -134,3 +136,13 @@ class KeyMetrics(DetectionVisMetric):
             ]
 
         return res
+
+    @property
+    def custom_ap_description_md(self) -> MarkdownWidget:
+        if not self.eval_result.different_iou_thresholds_per_class:
+            return None
+        return MarkdownWidget(
+            "custom_ap_description",
+            "Custom AP per Class",
+            self.vis_texts.markdown_AP_custom_description,
+        )

supervisely/nn/benchmark/object_detection/vis_metrics/overview.py

@@ -2,7 +2,7 @@ import datetime
 from typing import List
 
 from supervisely.nn.benchmark.object_detection.base_vis_metric import DetectionVisMetric
-from supervisely.nn.benchmark.visualization.widgets import MarkdownWidget
+from supervisely.nn.benchmark.visualization.widgets import MarkdownWidget, TableWidget
 
 
 class Overview(DetectionVisMetric):
@@ -32,6 +32,10 @@ class Overview(DetectionVisMetric):
         # link to scroll to the optimal confidence section
         opt_conf_url = self.vis_texts.docs_url + "#f1-optimal-confidence-threshold"
 
+        iou_threshold = self.eval_result.mp.iou_threshold
+        if self.eval_result.different_iou_thresholds_per_class:
+            iou_threshold = "Different IoU thresholds for each class (see the table below)"
+
         formats = [
             model_name.replace("_", "\_"),
             checkpoint_name.replace("_", "\_"),
@@ -45,7 +49,7 @@ class Overview(DetectionVisMetric):
             classes_str,
             note_about_images,
             starter_app_info,
-            self.eval_result.mp.iou_threshold,
+            iou_threshold,
             round(self.eval_result.mp.f1_optimal_conf, 4),
             opt_conf_url,
             self.vis_texts.docs_url,
@@ -112,3 +116,38 @@ class Overview(DetectionVisMetric):
         starter_app_info = train_session or evaluator_session or ""
 
         return classes_str, images_str, starter_app_info
+    
+    @property
+    def iou_per_class_md(self) -> List[MarkdownWidget]:
+        if not self.eval_result.different_iou_thresholds_per_class:
+            return None
+
+        return MarkdownWidget(
+            "markdown_iou_per_class",
+            "Different IoU thresholds for each class",
+            text=self.vis_texts.markdown_iou_per_class,
+        )
+
+    @property
+    def iou_per_class_table(self) -> TableWidget:
+        if not self.eval_result.different_iou_thresholds_per_class:
+            return None
+
+        content = []
+        for name, thr in self.eval_result.mp.iou_threshold_per_class.items():
+            row = [name, round(thr, 2)]
+            dct = {"row": row, "id": name, "items": row}
+            content.append(dct)
+
+        data = {
+            "columns": ["Class name", "IoU threshold"],
+            "columnsOptions": [{"disableSort": True}, {}],
+            "content": content,
+        }
+        return TableWidget(
+            name="table_iou_per_class",
+            data=data,
+            fix_columns=1,
+            width="60%",
+            main_column="Class name",
+        )

supervisely/nn/benchmark/object_detection/visualizer.py

@@ -90,11 +90,16 @@ class ObjectDetectionVisualizer(BaseVisualizer):
         self.header = overview.get_header(me.login)
         self.overview_md = overview.md
 
+        # IOU Per Class (optional)
+        self.iou_per_class_md = overview.iou_per_class_md
+        self.iou_per_class_table = overview.iou_per_class_table
+
         # Key Metrics
         key_metrics = KeyMetrics(self.vis_texts, self.eval_result)
         self.key_metrics_md = key_metrics.md
         self.key_metrics_table = key_metrics.table
         self.overview_chart = key_metrics.chart
+        self.custom_ap_description = key_metrics.custom_ap_description_md
 
         # Explore Predictions
         explore_predictions = ExplorePredictions(
@@ -238,9 +243,24 @@ class ObjectDetectionVisualizer(BaseVisualizer):
             # Overview
             (0, self.header),
             (1, self.overview_md),
+        ]
+
+        if self.iou_per_class_table is not None:
+            is_anchors_widgets += [
+                (0, self.iou_per_class_md),
+                (0, self.iou_per_class_table),
+            ]
+
+        is_anchors_widgets += [
             # KeyMetrics
             (1, self.key_metrics_md),
             (0, self.key_metrics_table),
+        ]
+
+        if self.custom_ap_description is not None:
+            is_anchors_widgets.append((0, self.custom_ap_description))
+
+        is_anchors_widgets += [
             (0, self.overview_chart),
             # ExplorePredictions
             (1, self.explore_predictions_md),

supervisely/nn/benchmark/semantic_segmentation/evaluator.py

@@ -25,6 +25,7 @@ from supervisely.sly_logger import logger
 
 class SemanticSegmentationEvalResult(BaseEvalResult):
     mp_cls = MetricProvider
+    PRIMARY_METRIC = "mIoU"
 
     def _read_files(self, path: str) -> None:
         """Read all necessary files from the directory"""