supervisely 6.73.254__py3-none-any.whl → 6.73.256__py3-none-any.whl

supervisely/api/api.py

@@ -69,6 +69,7 @@ from supervisely.io.network_exceptions import (
     process_requests_exception,
     process_requests_exception_async,
     process_unhandled_request,
+    RetryableRequestException,
 )
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.sly_logger import logger
@@ -1283,16 +1284,20 @@ class Api:
                         Api._raise_for_status_httpx(resp)
 
                     hhash = resp.headers.get("x-content-checksum-sha256", None)
-                    for chunk in resp.iter_raw(chunk_size):
-                        yield chunk, hhash
-                        total_streamed += len(chunk)
+                    try:
+                        for chunk in resp.iter_raw(chunk_size):
+                            yield chunk, hhash
+                            total_streamed += len(chunk)
+                    except Exception as e:
+                        raise RetryableRequestException(repr(e))
+
                     if expected_size != 0 and total_streamed != expected_size:
                         raise ValueError(
                             f"Streamed size does not match the expected: {total_streamed} != {expected_size}"
                         )
                     logger.trace(f"Streamed size: {total_streamed}, expected size: {expected_size}")
                     return
-            except (httpx.RequestError, httpx.HTTPStatusError) as e:
+            except (httpx.RequestError, httpx.HTTPStatusError, RetryableRequestException) as e:
                 if (
                     isinstance(e, httpx.HTTPStatusError)
                     and resp.status_code == 400
@@ -1531,9 +1536,12 @@ class Api:
 
                     # received hash of the content to check integrity of the data stream
                     hhash = resp.headers.get("x-content-checksum-sha256", None)
-                    async for chunk in resp.aiter_raw(chunk_size):
-                        yield chunk, hhash
-                        total_streamed += len(chunk)
+                    try:
+                        async for chunk in resp.aiter_raw(chunk_size):
+                            yield chunk, hhash
+                            total_streamed += len(chunk)
+                    except Exception as e:
+                        raise RetryableRequestException(repr(e))
 
                     if expected_size != 0 and total_streamed != expected_size:
                         raise ValueError(
@@ -1541,7 +1549,7 @@ class Api:
                         )
                     logger.trace(f"Streamed size: {total_streamed}, expected size: {expected_size}")
                     return
-            except (httpx.RequestError, httpx.HTTPStatusError) as e:
+            except (httpx.RequestError, httpx.HTTPStatusError, RetryableRequestException) as e:
                 if (
                     isinstance(e, httpx.HTTPStatusError)
                     and resp.status_code == 400

supervisely/api/file_api.py

@@ -1361,11 +1361,22 @@ class FileApi(ModuleApiBase):
            # Output: /My_App_Test_001
         """
         res_dir = dir_path.rstrip("/")
-        suffix = 1
-        while self.dir_exists(team_id, res_dir):
-            res_dir = dir_path.rstrip("/") + f"_{suffix:03d}"
-            suffix += 1
-        return res_dir
+        if not self.dir_exists(team_id, res_dir + "/"):
+            return res_dir
+
+        low, high = 0, 1
+        while self.dir_exists(team_id, f"{res_dir}_{high:03d}/"):
+            low = high
+            high *= 2
+
+        while low < high:
+            mid = (low + high) // 2
+            if self.dir_exists(team_id, f"{res_dir}_{mid:03d}/"):
+                low = mid + 1
+            else:
+                high = mid
+
+        return f"{res_dir}_{low:03d}"
 
     def upload_directory(
         self,

supervisely/api/task_api.py

@@ -821,10 +821,12 @@ class TaskApi(ModuleApiBase, ModuleWithStatus):
         )
         return resp.json()
 
-    def set_output_report(self, task_id: int, file_id: int, file_name: str) -> Dict:
+    def set_output_report(
+        self, task_id: int, file_id: int, file_name: str, description: Optional[str] = "Report"
+    ) -> Dict:
         """set_output_report"""
         return self._set_custom_output(
-            task_id, file_id, file_name, description="Report", icon="zmdi zmdi-receipt"
+            task_id, file_id, file_name, description=description, icon="zmdi zmdi-receipt"
         )
 
     def _set_custom_output(

supervisely/app/widgets/field/field.py

@@ -58,14 +58,12 @@ class Field(Widget):
             image_url: Optional[str] = None,
         ) -> Field.Icon:
             if zmdi_class is None and image_url is None:
-                raise ValueError("One of the arguments has to be defined: zmdi_class or image_url")
-            if zmdi_class is not None and image_url is not None:
                 raise ValueError(
-                    "Only one of the arguments has to be defined: zmdi_class or image_url"
+                    "One of the arguments has to be defined: zmdi_class or image_url"
                 )
-            if image_url is not None and (color_rgb is not None or bg_color_rgb is not None):
+            if zmdi_class is not None and image_url is not None:
                 raise ValueError(
-                    "Arguments color_rgb / bg_color_rgb can not be used with image_url at the same time"
+                    "Only one of the arguments has to be defined: zmdi_class or image_url"
                 )
 
             if image_url is None and color_rgb is None:
@@ -104,6 +102,7 @@ class Field(Widget):
                 res["bgColor"] = sly_color.rgb2hex(self._bg_color)
             if self._image_url is not None:
                 res["imageUrl"] = self._image_url
+                res["bgColor"] = sly_color.rgb2hex(self._bg_color)
             return res
 
     def __init__(
@@ -123,9 +122,13 @@ class Field(Widget):
         self._icon = icon
         self._content = content
         if self._title_url is not None and self._title is None:
-            raise ValueError("Title can not be specified only as url without text value")
+            raise ValueError(
+                "Title can not be specified only as url without text value"
+            )
         if self._description_url is not None and self._description is None:
-            raise ValueError("Description can not be specified only as url without text value")
+            raise ValueError(
+                "Description can not be specified only as url without text value"
+            )
 
         super().__init__(widget_id=widget_id, file_path=__file__)
 

supervisely/app/widgets/grid_gallery_v2/grid_gallery_v2.py

@@ -144,6 +144,7 @@ class GridGalleryV2(Widget):
         title: str = "",
         column_index: int = None,
         ignore_tags_filtering: Union[bool, List[str]] = False,
+        call_update: bool = True,
     ):
         column_index = self.get_column_index(incoming_value=column_index)
         cell_uuid = str(
@@ -168,7 +169,8 @@ class GridGalleryV2(Widget):
             }
         )
 
-        self._update()
+        if call_update:
+            self._update()
         return cell_uuid
 
     def clean_up(self):

supervisely/io/network_exceptions.py

@@ -28,6 +28,14 @@ RETRY_STATUS_CODES = {
 }
 
 
+class RetryableRequestException(Exception):
+    """Exception that indicates that the request should be retried."""
+
+    def __init__(self, message, response=None):
+        super().__init__(message)
+        self.response = response
+
+
 async def process_requests_exception_async(
     external_logger,
     exc,
@@ -50,6 +58,8 @@ async def process_requests_exception_async(
     except Exception:
         pass
 
+    is_retryable_exception = isinstance(exc, RetryableRequestException)
+
     is_connection_error = isinstance(
         exc,
         (
@@ -82,7 +92,7 @@ async def process_requests_exception_async(
         except (AttributeError, ValueError):
             pass
 
-    if is_connection_error or is_server_retryable_error:
+    if any([is_connection_error, is_server_retryable_error, is_retryable_exception]):
         await process_retryable_request_async(
             external_logger,
             exc,
@@ -136,6 +146,8 @@ def process_requests_exception(
     except Exception:
         pass
 
+    is_retryable_exception = isinstance(exc, RetryableRequestException)
+
     is_connection_error = isinstance(
         exc,
         (
@@ -168,7 +180,7 @@ def process_requests_exception(
         except (AttributeError, ValueError):
             pass
 
-    if is_connection_error or is_server_retryable_error:
+    if any([is_connection_error, is_server_retryable_error, is_retryable_exception]):
         process_retryable_request(
             external_logger,
             exc,

supervisely/nn/benchmark/base_benchmark.py

@@ -74,6 +74,8 @@ class BaseBenchmark:
         self.train_info = None
         self.evaluator_app_info = None
         self.evaluation_params = evaluation_params
+        self.visualizer = None
+        self.remote_vis_dir = None
         self._eval_results = None
         self.report_id = None
         self._validate_evaluation_params()
@@ -379,7 +381,7 @@ class BaseBenchmark:
             logger.info(f"Found GT annotations in {gt_path}")
         if not os.path.exists(dt_path):
             with self.pbar(
-                message="Evaluation: Downloading Pred annotations", total=self.num_items
+                message="Evaluation: Downloading prediction annotations", total=self.num_items
             ) as p:
                 download_project(
                     self.api,
@@ -490,11 +492,12 @@ class BaseBenchmark:
                 "It should be defined in the subclass of BaseBenchmark (e.g. ObjectDetectionBenchmark)."
             )
         eval_result = self.get_eval_result()
-        vis = self.visualizer_cls(  # pylint: disable=not-callable
-            self.api, [eval_result], self.get_layout_results_dir(), self.pbar
+        layout_dir = self.get_layout_results_dir()
+        self.visualizer = self.visualizer_cls(  # pylint: disable=not-callable
+            self.api, [eval_result], layout_dir, self.pbar
         )
         with self.pbar(message="Visualizations: Rendering layout", total=1) as p:
-            vis.visualize()
+            self.visualizer.visualize()
             p.update(1)
 
     def _get_or_create_diff_project(self) -> Tuple[ProjectInfo, bool]:
@@ -540,37 +543,16 @@ class BaseBenchmark:
         return diff_project_info, is_existed
 
     def upload_visualizations(self, dest_dir: str):
-        layout_dir = self.get_layout_results_dir()
-        assert not fs.dir_empty(
-            layout_dir
-        ), f"The layout dir {layout_dir!r} is empty. You should run visualizations before uploading results."
-
-        # self.api.file.remove_dir(self.team_id, dest_dir, silent=True)
-
-        remote_dir = dest_dir
-        with self.pbar(
-            message="Visualizations: Uploading layout",
-            total=get_directory_size(layout_dir),
-            unit="B",
-            unit_scale=True,
-        ) as p:
-            remote_dir = self.api.file.upload_directory(
-                self.team_id,
-                layout_dir,
-                dest_dir,
-                replace_if_conflict=True,
-                change_name_if_conflict=False,
-                progress_size_cb=p,
-            )
-
-        logger.info(f"Uploaded to: {remote_dir!r}")
+        self.remote_vis_dir = self.visualizer.upload_results(self.team_id, dest_dir, self.pbar)
+        return self.remote_vis_dir
 
-        template_path = os.path.join(remote_dir, "template.vue")
-        vue_template_info = self.api.file.get_info_by_path(self.team_id, template_path)
-        report_link = f"{self.api.server_address}/model-benchmark?id={vue_template_info.id}"
-        logger.info(f"Open url: {report_link}")
+    @property
+    def report(self):
+        return self.visualizer.renderer.report
 
-        return remote_dir
+    @property
+    def lnk(self):
+        return self.visualizer.renderer.lnk
 
     def upload_report_link(self, remote_dir: str):
         template_path = os.path.join(remote_dir, "template.vue")
@@ -578,16 +560,25 @@ class BaseBenchmark:
         self.report_id = vue_template_info.id
 
         report_link = "/model-benchmark?id=" + str(vue_template_info.id)
-        local_path = os.path.join(self.get_layout_results_dir(), "open.lnk")
+
+        lnk_name = "Model Evaluation Report.lnk"
+        local_path = os.path.join(self.get_layout_results_dir(), lnk_name)
         with open(local_path, "w") as file:
             file.write(report_link)
 
-        remote_path = os.path.join(remote_dir, "open.lnk")
+        remote_path = os.path.join(remote_dir, lnk_name)
         file_info = self.api.file.upload(self.team_id, local_path, remote_path)
 
         logger.info(f"Report link: {report_link}")
         return file_info
 
+    def get_report_link(self) -> str:
+        if self.remote_vis_dir is None:
+            raise ValueError("Visualizations are not uploaded yet.")
+        return self.visualizer.renderer._get_report_link(
+            self.api, self.team_id, self.remote_vis_dir
+        )
+
     def _merge_metas(self, gt_project_id, pred_project_id):
         gt_meta = self.api.project.get_meta(gt_project_id)
         gt_meta = ProjectMeta.from_json(gt_meta)
@@ -623,3 +614,10 @@ class BaseBenchmark:
         if self._eval_results is None:
             self._eval_results = self.evaluator.get_eval_result()
         return self._eval_results
+
+    def get_diff_project_info(self):
+        eval_result = self.get_eval_result()
+        if hasattr(eval_result, "diff_project_info"):
+            self.diff_project_info = eval_result.diff_project_info
+            return self.diff_project_info
+        return None

supervisely/nn/benchmark/base_evaluator.py

@@ -7,6 +7,7 @@ from typing import Dict, List, Optional, Union
 import yaml
 
 from supervisely.app.widgets import SlyTqdm
+from supervisely.io.fs import get_file_name_with_ext
 from supervisely.task.progress import tqdm_sly
 
 
@@ -40,6 +41,14 @@ class BaseEvalResult:
             or self.inference_info.get("model_name")
         )
 
+    @property
+    def short_name(self) -> str:
+        if not self.name:
+            return
+        if len(self.name) > 20:
+            return self.name[:9] + "..." + self.name[-7:]
+        return self.name
+
     @property
     def gt_project_id(self) -> int:
         return self.inference_info.get("gt_project_id")
@@ -79,11 +88,28 @@ class BaseEvalResult:
     def _prepare_data(self) -> None:
         """Prepare data to allow easy access to the data"""
         raise NotImplementedError()
-    
+
     @property
     def key_metrics(self):
         raise NotImplementedError()
 
+    @property
+    def checkpoint_name(self):
+        if self.inference_info is None:
+            return None
+
+        deploy_params = self.inference_info.get("deploy_params", {})
+        name = None
+        if deploy_params:
+            name = deploy_params.get("checkpoint_name")  # not TrainApp
+            if name is None:
+                name = deploy_params.get("model_files", {}).get("checkpoint")
+                if name is not None:
+                    name = get_file_name_with_ext(name)
+        if name is None:
+            name = self.inference_info.get("checkpoint_name", "")
+        return name
+
 
 class BaseEvaluator:
     EVALUATION_PARAMS_YAML_PATH: str = None

supervisely/nn/benchmark/base_visualizer.py

@@ -61,6 +61,7 @@ class BaseVisMetric(BaseVisMetrics):
 
 class BaseVisualizer:
     cv_task = None
+    report_name = "Model Evaluation Report.lnk"
 
     def __init__(
         self,
@@ -141,7 +142,7 @@ class BaseVisualizer:
     def visualize(self):
         if self.renderer is None:
             layout = self._create_layout()
-            self.renderer = Renderer(layout, self.workdir)
+            self.renderer = Renderer(layout, self.workdir, report_name=self.report_name)
         return self.renderer.visualize()
 
     def upload_results(self, team_id: int, remote_dir: str, progress=None):
@@ -178,19 +179,15 @@ class BaseVisualizer:
             diff_ds_infos.append(diff_dataset)
             return diff_dataset
 
+        is_existed = False
         project_name = self._generate_diff_project_name(self.eval_result.pred_project_info.name)
         workspace_id = self.eval_result.pred_project_info.workspace_id
-        project_info = self.api.project.get_info_by_name(
-            workspace_id, project_name, raise_error=False
+        project_info = self.api.project.create(
+            workspace_id, project_name, change_name_if_conflict=True
         )
-        is_existed = project_info is not None
-        if not is_existed:
-            project_info = self.api.project.create(
-                workspace_id, project_name, change_name_if_conflict=True
-            )
-            pred_datasets = {ds.id: ds for ds in self.eval_result.pred_dataset_infos}
-            for dataset in pred_datasets:
-                _get_or_create_diff_dataset(dataset, pred_datasets)
+        pred_datasets = {ds.id: ds for ds in self.eval_result.pred_dataset_infos}
+        for dataset in pred_datasets:
+            _get_or_create_diff_dataset(dataset, pred_datasets)
         return project_info, diff_ds_infos, is_existed
 
     def _generate_diff_project_name(self, pred_project_name):

supervisely/nn/benchmark/comparison/base_visualizer.py

@@ -0,0 +1,147 @@
+import datetime
+from pathlib import Path
+from typing import Optional
+
+from supervisely.api.module_api import ApiField
+from supervisely.nn.benchmark.comparison.semantic_segmentation.vis_metrics import (
+    Overview,
+)
+from supervisely.nn.benchmark.visualization.renderer import Renderer
+from supervisely.nn.benchmark.visualization.widgets import (
+    ContainerWidget,
+    GalleryWidget,
+    MarkdownWidget,
+)
+from supervisely.project.project_meta import ProjectMeta
+
+
+class BaseComparisonVisualizer:
+    vis_texts = None
+    ann_opacity = None
+    report_name = "Model Comparison Report.lnk"
+
+    def __init__(self, comparison):
+        self.comparison = comparison
+        self.api = comparison.api
+        self.eval_results = comparison.eval_results
+        self.gt_project_info = None
+        self.gt_project_meta = None
+        # self._widgets_created = False
+
+        for eval_result in self.eval_results:
+            eval_result.api = self.api  # add api to eval_result for overview widget
+            self._get_eval_project_infos(eval_result)
+
+        self._create_widgets()
+        layout = self._create_layout()
+
+        self.renderer = Renderer(
+            layout,
+            str(Path(self.comparison.workdir, "visualizations")),
+            report_name=self.report_name,
+        )
+
+    def visualize(self):
+        return self.renderer.visualize()
+
+    def upload_results(self, team_id: int, remote_dir: str, progress=None):
+        return self.renderer.upload_results(self.api, team_id, remote_dir, progress)
+
+    def _create_widgets(self):
+        raise NotImplementedError("Have to implement in subclasses")
+
+    def _create_layout(self):
+        raise NotImplementedError("Have to implement in subclasses")
+
+    def _create_header(self) -> MarkdownWidget:
+        """Creates header widget"""
+        me = self.api.user.get_my_info().login
+        current_date = datetime.datetime.now().strftime("%d %B %Y, %H:%M")
+        header_main_text = " ∣ ".join(  #  vs. or | or ∣
+            eval_res.name for eval_res in self.comparison.eval_results
+        )
+        header_text = self.vis_texts.markdown_header.format(header_main_text, me, current_date)
+        header = MarkdownWidget("markdown_header", "Header", text=header_text)
+        return header
+
+    def _create_overviews(self, vm: Overview, grid_cols: Optional[int] = None) -> ContainerWidget:
+        """Creates overview widgets"""
+        overview_widgets = vm.overview_widgets
+        if grid_cols is None:
+            grid_cols = 2
+            if len(overview_widgets) > 2:
+                grid_cols = 3
+            if len(overview_widgets) % 4 == 0:
+                grid_cols = 4
+        return ContainerWidget(
+            overview_widgets,
+            name="overview_container",
+            title="Overview",
+            grid=True,
+            grid_cols=grid_cols,
+        )
+
+    def _create_explore_modal_table(
+        self, columns_number=3, click_gallery_id=None, hover_text=None
+    ) -> GalleryWidget:
+        gallery = GalleryWidget(
+            "all_predictions_modal_gallery",
+            is_modal=True,
+            columns_number=columns_number,
+            click_gallery_id=click_gallery_id,
+            opacity=self.ann_opacity,
+        )
+        gallery.set_project_meta(self.eval_results[0].pred_project_meta)
+        if hover_text:
+            gallery.add_image_left_header(hover_text)
+        return gallery
+
+    def _create_diff_modal_table(self, columns_number=3) -> GalleryWidget:
+        gallery = GalleryWidget(
+            "diff_predictions_modal_gallery",
+            is_modal=True,
+            columns_number=columns_number,
+            opacity=self.ann_opacity,
+        )
+        gallery.set_project_meta(self.eval_results[0].pred_project_meta)
+        return gallery
+
+    def _create_clickable_label(self):
+        return MarkdownWidget("clickable_label", "", text=self.vis_texts.clickable_label)
+
+    def _get_eval_project_infos(self, eval_result):
+        # get project infos
+        if self.gt_project_info is None:
+            self.gt_project_info = self.api.project.get_info_by_id(eval_result.gt_project_id)
+        eval_result.gt_project_info = self.gt_project_info
+        eval_result.pred_project_info = self.api.project.get_info_by_id(eval_result.pred_project_id)
+
+        # get project metas
+        if self.gt_project_meta is None:
+            self.gt_project_meta = ProjectMeta.from_json(
+                self.api.project.get_meta(eval_result.gt_project_id)
+            )
+        eval_result.gt_project_meta = self.gt_project_meta
+        eval_result.pred_project_meta = ProjectMeta.from_json(
+            self.api.project.get_meta(eval_result.pred_project_id)
+        )
+
+        # get dataset infos
+        filters = None
+        if eval_result.gt_dataset_ids is not None:
+            filters = [
+                {
+                    ApiField.FIELD: ApiField.ID,
+                    ApiField.OPERATOR: "in",
+                    ApiField.VALUE: eval_result.gt_dataset_ids,
+                }
+            ]
+        eval_result.gt_dataset_infos = self.api.dataset.get_list(
+            eval_result.gt_project_id,
+            filters=filters,
+            recursive=True,
+        )
+
+        # eval_result.pred_dataset_infos = self.api.dataset.get_list(
+        #     eval_result.pred_project_id, recursive=True
+        # )

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

@@ -4,7 +4,7 @@ from supervisely.nn.benchmark.comparison.detection_visualization.vis_metrics.avg
 from supervisely.nn.benchmark.comparison.detection_visualization.vis_metrics.calibration_score import (
     CalibrationScore,
 )
-from supervisely.nn.benchmark.comparison.detection_visualization.vis_metrics.explore_predicttions import (
+from supervisely.nn.benchmark.comparison.detection_visualization.vis_metrics.explore_predictions import (
     ExplorePredictions,
 )
 from supervisely.nn.benchmark.comparison.detection_visualization.vis_metrics.localization_accuracy import (

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

@@ -1,10 +1,8 @@
-from supervisely.nn.benchmark.comparison.detection_visualization.vis_metrics.vis_metric import (
-    BaseVisMetric,
-)
+from supervisely.nn.benchmark.base_visualizer import BaseVisMetrics
 from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
 
 
-class AveragePrecisionByClass(BaseVisMetric):
+class AveragePrecisionByClass(BaseVisMetrics):
     MARKDOWN_CLASS_AP = "markdown_class_ap_polar"
     MARKDOWN_CLASS_AP_BAR = "markdown_class_ap_bar"
 
@@ -43,8 +41,8 @@ class AveragePrecisionByClass(BaseVisMetric):
                         x=eval_result.mp.cat_names,
                         y=ap_per_class,
                         name=trace_name,
-                        width=0.2,
-                        marker=dict(color=eval_result.color),
+                        width=0.2 if cls_cnt >= 5 else None,
+                        marker=dict(color=eval_result.color, line=dict(width=0.7)),
                     )
                 )
 
@@ -116,7 +114,7 @@ class AveragePrecisionByClass(BaseVisMetric):
                     {
                         "type": "tag",
                         "tagId": "confidence",
-                        "value": [eval_result.f1_optimal_conf, 1],
+                        "value": [eval_result.mp.f1_optimal_conf, 1],
                     },
                     {"type": "tag", "tagId": "outcome", "value": "TP"},
                     {"type": "specific_objects", "tagId": None, "value": list(obj_ids)},

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

@@ -1,6 +1,4 @@
-from supervisely.nn.benchmark.comparison.detection_visualization.vis_metrics.vis_metric import (
-    BaseVisMetric,
-)
+from supervisely.nn.benchmark.base_visualizer import BaseVisMetrics
 from supervisely.nn.benchmark.visualization.widgets import (
     ChartWidget,
     CollapseWidget,
@@ -10,7 +8,7 @@ from supervisely.nn.benchmark.visualization.widgets import (
 )
 
 
-class CalibrationScore(BaseVisMetric):
+class CalibrationScore(BaseVisMetrics):
     @property
     def header_md(self) -> MarkdownWidget:
         text_template = self.vis_texts.markdown_calibration_score_1
@@ -139,7 +137,7 @@ class CalibrationScore(BaseVisMetric):
                     x=eval_result.dfsp_down["scores"],
                     y=eval_result.dfsp_down["f1"],
                     mode="lines",
-                    name=f"[{i+1}] {eval_result.model_name}",
+                    name=f"[{i+1}] {eval_result.name}",
                     line=dict(color=eval_result.color),
                     hovertemplate="Confidence Score: %{x:.2f}<br>Value: %{y:.2f}<extra></extra>",
                 )
@@ -194,7 +192,7 @@ class CalibrationScore(BaseVisMetric):
                     x=pred_probs,
                     y=true_probs,
                     mode="lines+markers",
-                    name=f"[{i+1}] {eval_result.model_name}",
+                    name=f"[{i+1}] {eval_result.name}",
                     line=dict(color=eval_result.color),
                     hovertemplate=f"{eval_result.name}<br>"
                     + "Confidence Score: %{x:.2f}<br>Fraction of True Positives: %{y:.2f}<extra></extra>",