supervisely 6.73.286__tar.gz → 6.73.288__tar.gz

{supervisely-6.73.286/supervisely.egg-info → supervisely-6.73.288}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.286
+Version: 6.73.288
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/annotation/annotation.py

@@ -543,7 +543,7 @@ class Annotation:
             image_id=take_with_default(image_id, self.image_id),
         )
 
-    def _add_labels_impl(self, dest, labels):
+    def _add_labels_impl(self, dest: List, labels: List[Label]):
         """
         The function _add_labels_impl extend list of the labels of the current Annotation object
         :param dest: destination list of the Label class objects
@@ -554,7 +554,15 @@ class Annotation:
             if self.img_size.count(None) == 0:
                 # image has resolution in DB
                 canvas_rect = Rectangle.from_size(self.img_size)
-                dest.extend(label.crop(canvas_rect))
+                try:
+                    dest.extend(label.crop(canvas_rect))
+                except Exception:
+                    logger.error(
+                        f"Cannot crop label of '{label.obj_class.name}' class "
+                        "when extend list of the labels of the current Annotation object",
+                        exc_info=True,
+                    )
+                    raise
             else:
                 # image was uploaded by link and does not have resolution in DB
                 # add label without normalization and validation

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/api/annotation_api.py

@@ -1403,37 +1403,33 @@ class AnnotationApi(ModuleApi):
                 progress_cb(len(response.content))
 
             result = response.json()
-            # Convert annotation to pixel coordinate system
-            result[ApiField.ANNOTATION] = Annotation._to_pixel_coordinate_system_json(
-                result[ApiField.ANNOTATION]
+        # Convert annotation to pixel coordinate system
+        result[ApiField.ANNOTATION] = Annotation._to_pixel_coordinate_system_json(
+            result[ApiField.ANNOTATION]
+        )
+        # check if there are any AlphaMask geometries in the batch
+        additonal_geometries = defaultdict(int)
+        labels = result[ApiField.ANNOTATION][AnnotationJsonFields.LABELS]
+        for idx, label in enumerate(labels):
+            if label[LabelJsonFields.GEOMETRY_TYPE] == AlphaMask.geometry_name():
+                figure_id = label[LabelJsonFields.ID]
+                additonal_geometries[figure_id] = idx
+
+        # if so, download them separately and update the annotation
+        if len(additonal_geometries) > 0:
+            figure_ids = list(additonal_geometries.keys())
+            figures = await self._api.image.figure.download_geometries_batch_async(
+                figure_ids,
+                (progress_cb if progress_cb is not None and progress_cb_type == "size" else None),
+                semaphore=semaphore,
             )
-            # check if there are any AlphaMask geometries in the batch
-            additonal_geometries = defaultdict(int)
-            labels = result[ApiField.ANNOTATION][AnnotationJsonFields.LABELS]
-            for idx, label in enumerate(labels):
-                if label[LabelJsonFields.GEOMETRY_TYPE] == AlphaMask.geometry_name():
-                    figure_id = label[LabelJsonFields.ID]
-                    additonal_geometries[figure_id] = idx
-
-            # if so, download them separately and update the annotation
-            if len(additonal_geometries) > 0:
-                figure_ids = list(additonal_geometries.keys())
-                figures = await self._api.image.figure.download_geometries_batch_async(
-                    figure_ids,
-                    (
-                        progress_cb
-                        if progress_cb is not None and progress_cb_type == "size"
-                        else None
-                    ),
-                    semaphore=semaphore,
-                )
-                for figure_id, geometry in zip(figure_ids, figures):
-                    label_idx = additonal_geometries[figure_id]
-                    labels[label_idx].update({BITMAP: geometry})
-            ann_info = self._convert_json_info(result)
-            if progress_cb is not None and progress_cb_type == "number":
-                progress_cb(1)
-            return ann_info
+            for figure_id, geometry in zip(figure_ids, figures):
+                label_idx = additonal_geometries[figure_id]
+                labels[label_idx].update({BITMAP: geometry})
+        ann_info = self._convert_json_info(result)
+        if progress_cb is not None and progress_cb_type == "number":
+            progress_cb(1)
+        return ann_info
 
     async def download_batch_async(
         self,

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/api/api.py

@@ -66,10 +66,10 @@ import supervisely.io.env as sly_env
 from supervisely._utils import camel_to_snake, is_community, is_development
 from supervisely.api.module_api import ApiField
 from supervisely.io.network_exceptions import (
+    RetryableRequestException,
     process_requests_exception,
     process_requests_exception_async,
     process_unhandled_request,
-    RetryableRequestException,
 )
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.sly_logger import logger
@@ -380,6 +380,7 @@ class Api:
         self.async_httpx_client: httpx.AsyncClient = None
         self.httpx_client: httpx.Client = None
         self._semaphore = None
+        self._instance_version = None
 
     @classmethod
     def normalize_server_address(cls, server_address: str) -> str:
@@ -515,11 +516,14 @@ class Api:
                 # '6.9.13'
         """
         try:
-            version = self.post("instance.version", {}).json().get(ApiField.VERSION)
+            if self._instance_version is None:
+                self._instance_version = (
+                    self.post("instance.version", {}).json().get(ApiField.VERSION)
+                )
         except Exception as e:
             logger.warning(f"Failed to get instance version from server: {e}")
-            version = "unknown"
-        return version
+            self._instance_version = "unknown"
+        return self._instance_version
 
     def is_version_supported(self, version: Optional[str] = None) -> Union[bool, None]:
         """Check if the given version is lower or equal to the current Supervisely instance version.

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/api/entity_annotation/figure_api.py

@@ -642,13 +642,13 @@ class FigureApi(RemoveableBulkModuleApi):
                 response = await self._api.post_async(
                     "figures.bulk.download.geometry", {ApiField.IDS: batch_ids}
                 )
-            decoder = MultipartDecoder.from_response(response)
-            for part in decoder.parts:
-                content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
-                # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
-                # The regex has 2 capture group: one for the prefix and one for the actual name value.
-                figure_id = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
-                yield figure_id, part.content
+                decoder = MultipartDecoder.from_response(response)
+                for part in decoder.parts:
+                    content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
+                    # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
+                    # The regex has 2 capture group: one for the prefix and one for the actual name value.
+                    figure_id = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
+                    yield figure_id, part.content
 
     async def download_geometries_batch_async(
         self,

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/api/image_api.py

@@ -4456,26 +4456,26 @@ class ImageApi(RemoveableBulkModuleApi):
                 json=json_body,
                 headers=headers,
             )
-        decoder = MultipartDecoder.from_response(response)
-        for part in decoder.parts:
-            content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
-            # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
-            # The regex has 2 capture group: one for the prefix and one for the actual name value.
-            img_id = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
-            if check_hash:
-                hhash = part.headers.get("x-content-checksum-sha256", None)
-                if hhash is not None:
-                    downloaded_bytes_hash = get_bytes_hash(part)
-                    if hhash != downloaded_bytes_hash:
-                        raise RuntimeError(
-                            f"Downloaded hash of image with ID:{img_id} does not match the expected hash: {downloaded_bytes_hash} != {hhash}"
-                        )
-            if progress_cb is not None and progress_cb_type == "number":
-                progress_cb(1)
-            elif progress_cb is not None and progress_cb_type == "size":
-                progress_cb(len(part.content))
+            decoder = MultipartDecoder.from_response(response)
+            for part in decoder.parts:
+                content_utf8 = part.headers[b"Content-Disposition"].decode("utf-8")
+                # Find name="1245" preceded by a whitespace, semicolon or beginning of line.
+                # The regex has 2 capture group: one for the prefix and one for the actual name value.
+                img_id = int(re.findall(r'(^|[\s;])name="(\d*)"', content_utf8)[0][1])
+                if check_hash:
+                    hhash = part.headers.get("x-content-checksum-sha256", None)
+                    if hhash is not None:
+                        downloaded_bytes_hash = get_bytes_hash(part)
+                        if hhash != downloaded_bytes_hash:
+                            raise RuntimeError(
+                                f"Downloaded hash of image with ID:{img_id} does not match the expected hash: {downloaded_bytes_hash} != {hhash}"
+                            )
+                if progress_cb is not None and progress_cb_type == "number":
+                    progress_cb(1)
+                elif progress_cb is not None and progress_cb_type == "size":
+                    progress_cb(len(part.content))
 
-            yield img_id, part.content
+                yield img_id, part.content
 
     async def get_list_generator_async(
         self,

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/geometry/graph.py

@@ -9,6 +9,7 @@ from typing import Dict, List, Optional, Tuple, Union
 import cv2
 import numpy as np
 
+from supervisely import logger
 from supervisely.geometry.constants import (
     CLASS_ID,
     CREATED_AT,
@@ -215,6 +216,8 @@ class GraphNodes(Geometry):
             updated_at=updated_at,
             created_at=created_at,
         )
+        if len(nodes) == 0:
+            raise ValueError("Empty list of nodes is not allowed for GraphNodes")
         self._nodes = nodes
         if isinstance(nodes, (list, tuple)):
             self._nodes = {}
@@ -593,6 +596,10 @@ class GraphNodes(Geometry):
 
             rectangle = figure.to_bbox()
         """
+        if self._nodes is None or len(self._nodes) == 0:
+            logger.warning(
+                f"Cannot create a bounding box from {self.name()} with empty nodes. Geometry ID: {self.sly_id} "
+            )
         return Rectangle.from_geometries_list(
             [Point.from_point_location(node.location) for node in self._nodes.values()]
         )

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/geometry/rectangle.py

@@ -476,7 +476,7 @@ class Rectangle(Geometry):
         return cls(0, 0, size[0] - 1, size[1] - 1)
 
     @classmethod
-    def from_geometries_list(cls, geometries: List[sly.geometry.geometry]) -> Rectangle:
+    def from_geometries_list(cls, geometries: List[Geometry]) -> Rectangle:
         """
         Create Rectangle from given geometry objects.
 
@@ -494,6 +494,8 @@ class Rectangle(Geometry):
             geom_objs = [sly.Point(100, 200), sly.Polyline([sly.PointLocation(730, 2104), sly.PointLocation(2479, 402)])]
             figure_from_geom_objs = sly.Rectangle.from_geometries_list(geom_objs)
         """
+        if geometries is None or len(geometries) == 0:
+            raise ValueError("No geometries provided to create a Rectangle.")
         bboxes = [g.to_bbox() for g in geometries]
         top = min(bbox.top for bbox in bboxes)
         left = min(bbox.left for bbox in bboxes)

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/base_benchmark.py

@@ -620,6 +620,9 @@ class BaseBenchmark:
     def get_eval_result(self):
         if self._eval_results is None:
             self._eval_results = self.evaluator.get_eval_result()
+            if not self._eval_results.inference_info:
+                self._eval_results.inference_info["gt_project_id"] = self.gt_project_info.id
+                self._eval_results.inference_info["dt_project_id"] = self.dt_project_info.id
         return self._eval_results
 
     def get_diff_project_info(self):

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/base_evaluator.py

@@ -16,7 +16,7 @@ class BaseEvalResult:
 
     def __init__(self, directory: Optional[str] = None):
         self.directory = directory
-        self.inference_info: Dict = None
+        self.inference_info: Dict = {}
         self.speedtest_info: Dict = None
         self.eval_data: Dict = None
         self.mp = None

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/instance_segmentation/text_templates.py

@@ -14,7 +14,7 @@ definitions = SimpleNamespace(
 )
 
 docs_url = (
-    "https://docs.supervisely.com/neural-networks/model-evaluation-benchmark/instant-segmentation"
+    "https://docs.supervisely.com/neural-networks/model-evaluation-benchmark/instance-segmentation"
 )
 
 # <i class="zmdi zmdi-check-circle" style="color: #13ce66; margin-right: 5px"></i>
@@ -44,6 +44,7 @@ markdown_overview = """
 {}
 - **IoU threshold**: {}
 - **Optimal confidence threshold**: {} (calculated automatically), <a href="{}" target="_blank">learn more</a>.
+- **Averaging across IoU thresholds:** {}, <a href="{}" target="_blank">learn more</a>.
 
 Learn more about Model Benchmark, implementation details, and how to use the charts in our <a href="{}" target="_blank">Technical Report</a>.
 """
@@ -60,7 +61,7 @@ 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_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
 

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/object_detection/metric_provider.py

@@ -90,13 +90,16 @@ class MetricProvider:
         self.iouThrs = params["iouThrs"]
         self.recThrs = params["recThrs"]
 
+        # Evaluation params
         eval_params = params.get("evaluation_params", {})
         self.iou_threshold = eval_params.get("iou_threshold", 0.5)
         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}
+        if self.iou_threshold_per_class is not None:
+            # TODO: temporary solution
+            eval_params["average_across_iou_thresholds"] = False
+        self.average_across_iou_thresholds = eval_params.get("average_across_iou_thresholds", True)
 
     def calculate(self):
         self.m_full = _MetricProvider(
@@ -199,9 +202,10 @@ class MetricProvider:
         }
 
     def AP_per_class(self):
-        s = self.coco_precision[:, :, :, 0, 2]
+        s = self.coco_precision[:, :, :, 0, 2].copy()
         s[s == -1] = np.nan
         ap = np.nanmean(s, axis=(0, 1))
+        ap = np.nan_to_num(ap, nan=0)
         return ap
 
     def AP_custom_per_class(self):
@@ -212,6 +216,7 @@ class MetricProvider:
                 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)
+        ap = np.nan_to_num(ap, nan=0)
         return ap
 
     def AP_custom(self):
@@ -284,6 +289,14 @@ class _MetricProvider:
         self.fp_not_confused_matches = [m for m in self.fp_matches if not m["miss_cls"]]
         self.ious = np.array([m["iou"] for m in self.tp_matches])
 
+        # Evaluation params
+        self.params = params
+        self.iou_idx_per_class = np.array(
+            [params["iou_idx_per_class"][cat_id] for cat_id in self.cat_ids]
+        )[:, None]
+        eval_params = params.get("evaluation_params", {})
+        self.average_across_iou_thresholds = eval_params.get("average_across_iou_thresholds", True)
+        
     def _init_counts(self):
         cat_ids = self.cat_ids
         iouThrs = self.iouThrs
@@ -328,14 +341,22 @@ class _MetricProvider:
         self.true_positives = true_positives
         self.false_negatives = false_negatives
         self.false_positives = false_positives
-        self.TP_count = int(self.true_positives[:, 0].sum(0))
-        self.FP_count = int(self.false_positives[:, 0].sum(0))
-        self.FN_count = int(self.false_negatives[:, 0].sum(0))
+        self.TP_count = int(self._take_iou_thresholds(true_positives).sum())
+        self.FP_count = int(self._take_iou_thresholds(false_positives).sum())
+        self.FN_count = int(self._take_iou_thresholds(false_negatives).sum())
 
+    def _take_iou_thresholds(self, x):
+        return np.take_along_axis(x, self.iou_idx_per_class, axis=1)
+    
     def base_metrics(self):
-        tp = self.true_positives
-        fp = self.false_positives
-        fn = self.false_negatives
+        if self.average_across_iou_thresholds:
+            tp = self.true_positives
+            fp = self.false_positives
+            fn = self.false_negatives
+        else:
+            tp = self._take_iou_thresholds(self.true_positives)
+            fp = self._take_iou_thresholds(self.false_positives)
+            fn = self._take_iou_thresholds(self.false_negatives)
         confuse_count = len(self.confused_matches)
 
         mAP = self.coco_mAP
@@ -358,9 +379,14 @@ class _MetricProvider:
         }
 
     def per_class_metrics(self):
-        tp = self.true_positives.mean(1)
-        fp = self.false_positives.mean(1)
-        fn = self.false_negatives.mean(1)
+        if self.average_across_iou_thresholds:
+            tp = self.true_positives.mean(1)
+            fp = self.false_positives.mean(1)
+            fn = self.false_negatives.mean(1)
+        else:
+            tp = self._take_iou_thresholds(self.true_positives).flatten()
+            fp = self._take_iou_thresholds(self.false_positives).flatten()
+            fn = self._take_iou_thresholds(self.false_negatives).flatten()
         pr = tp / (tp + fp)
         rc = tp / (tp + fn)
         f1 = 2 * pr * rc / (pr + rc)

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/object_detection/text_templates.py

@@ -44,6 +44,7 @@ markdown_overview = """
 {}
 - **IoU threshold**: {}
 - **Optimal confidence threshold**: {} (calculated automatically), <a href="{}" target="_blank">learn more</a>.
+- **Averaging across IoU thresholds:** {}, <a href="{}" target="_blank">learn more</a>.
 
 Learn more about Model Benchmark, implementation details, and how to use the charts in our <a href="{}" target="_blank">Technical Report</a>.
 """
@@ -65,7 +66,7 @@ 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_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
 

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/object_detection/vis_metrics/confidence_score.py

@@ -72,13 +72,13 @@ class ConfidenceScore(DetectionVisMetric):
             self.eval_result.dfsp_down,
             x="scores",
             y=["precision", "recall", "f1"],
-            labels={"value": "Value", "variable": "Metric", "scores": "Confidence Score"},
+            labels={"value": "Metric", "variable": "Metric", "scores": "Confidence Score"},
             width=None,
             height=500,
             color_discrete_map=color_map,
         )
         fig.update_traces(
-            hovertemplate="Confidence Score: %{x:.2f}<br>Value: %{y:.2f}<extra></extra>"
+            hovertemplate="Confidence score: %{x:.2f}<br>Metric: %{y:.2f}<extra></extra>"
         )
         fig.update_layout(yaxis=dict(range=[0, 1]), xaxis=dict(range=[0, 1], tick0=0, dtick=0.1))
 

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/object_detection/vis_metrics/f1_score_at_different_iou.py

@@ -39,7 +39,7 @@ class F1ScoreAtDifferentIOU(DetectionVisMetric):
             np.concatenate([self.eval_result.dfsp_down["scores"].values[:, None], f1s_down.T], 1),
             columns=["scores"] + iou_names,
         )
-        labels = {"value": "Value", "variable": "IoU threshold", "scores": "Confidence Score"}
+        labels = {"value": "F1-score", "variable": "IoU threshold", "scores": "Confidence Score"}
 
         fig = px.line(
             df,
@@ -51,19 +51,19 @@ class F1ScoreAtDifferentIOU(DetectionVisMetric):
             height=500,
         )
         fig.update_traces(
-            hovertemplate="Confidence Score: %{x:.2f}<br>Value: %{y:.2f}<extra></extra>"
+            hovertemplate="Confidence Score: %{x:.2f}<br>F1-score: %{y:.2f}<extra></extra>"
         )
         fig.update_layout(yaxis=dict(range=[0, 1]), xaxis=dict(range=[0, 1], tick0=0, dtick=0.1))
 
         # add annotations for maximum F1-Score for each IoU threshold
         for i, iou in enumerate(iou_names):
-            argmax_f1 = f1s[i].argmax()
+            argmax_f1 = np.nanargmax(f1s[i])
             max_f1 = f1s[i][argmax_f1]
             score = self.eval_result.mp.m_full.score_profile["scores"][argmax_f1]
             fig.add_annotation(
                 x=score,
                 y=max_f1,
-                text=f"Best score: {score:.2f}",
+                text=f"Best conf: {score:.2f}",
                 showarrow=True,
                 arrowhead=1,
                 arrowcolor="black",

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/object_detection/vis_metrics/outcome_counts_per_class.py

@@ -86,11 +86,10 @@ class PerClassOutcomeCounts(DetectionVisMetric):
         import plotly.express as px  # pylint: disable=import-error
 
         # Per-class Counts
-        iou_thres = 0
-
-        tp = self.eval_result.mp.true_positives[:, iou_thres]
-        fp = self.eval_result.mp.false_positives[:, iou_thres]
-        fn = self.eval_result.mp.false_negatives[:, iou_thres]
+        mp = self.eval_result.mp
+        tp = mp.m._take_iou_thresholds(mp.true_positives).flatten()
+        fp = mp.m._take_iou_thresholds(mp.false_positives).flatten()
+        fn = mp.m._take_iou_thresholds(mp.false_negatives).flatten()
 
         # normalize
         support = tp + fn

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/object_detection/vis_metrics/overview.py

@@ -20,7 +20,7 @@ class Overview(DetectionVisMetric):
         url = self.eval_result.inference_info.get("checkpoint_url")
         link_text = self.eval_result.inference_info.get("custom_checkpoint_path")
         if link_text is None:
-            link_text = url
+            link_text = url or ""
         link_text = link_text.replace("_", "\_")
 
         model_name = self.eval_result.inference_info.get("model_name") or "Custom"
@@ -31,6 +31,7 @@ class Overview(DetectionVisMetric):
 
         # link to scroll to the optimal confidence section
         opt_conf_url = self.vis_texts.docs_url + "#f1-optimal-confidence-threshold"
+        average_url = self.vis_texts.docs_url + "#averaging-iou-thresholds"
 
         iou_threshold = self.eval_result.mp.iou_threshold
         if self.eval_result.different_iou_thresholds_per_class:
@@ -52,6 +53,8 @@ class Overview(DetectionVisMetric):
             iou_threshold,
             round(self.eval_result.mp.f1_optimal_conf, 4),
             opt_conf_url,
+            self.eval_result.mp.average_across_iou_thresholds,
+            average_url,
             self.vis_texts.docs_url,
         ]
 

{supervisely-6.73.286 → supervisely-6.73.288}/supervisely/nn/benchmark/object_detection/vis_metrics/precision_avg_per_class.py

@@ -32,8 +32,7 @@ class PerClassAvgPrecision(DetectionVisMetric):
         import plotly.express as px  # pylint: disable=import-error
 
         # AP per-class
-        ap_per_class = self.eval_result.mp.coco_precision[:, :, :, 0, 2].mean(axis=(0, 1))
-        ap_per_class[ap_per_class == -1] = 0  # -1 is a placeholder for no GT
+        ap_per_class = self.eval_result.mp.AP_per_class()
         labels = dict(r="Average Precision", theta="Class")
         fig = px.scatter_polar(
             r=ap_per_class,