supervisely 6.73.237__py3-none-any.whl → 6.73.239__py3-none-any.whl

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/confusion_matrix.py

@@ -0,0 +1,92 @@
+from typing import Dict
+
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
+
+
+class ConfusionMatrix(SemanticSegmVisMetric):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.clickable = True
+        self._keypair_sep = "-"
+
+    @property
+    def md(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            "confusion_matrix",
+            "Confusion Matrix",
+            text=self.vis_texts.markdown_confusion_matrix,
+        )
+
+    @property
+    def chart(self) -> ChartWidget:
+        chart = ChartWidget("confusion_matrix", self.get_figure())
+        chart.set_click_data(
+            self.explore_modal_table.id,
+            self.get_click_data(),
+            chart_click_extra="'getKey': (payload) => `${payload.points[0].y}${'-'}${payload.points[0].x}`, 'keySeparator': '-',",
+        )
+        return chart
+
+    def get_figure(self):
+        import plotly.graph_objects as go  # pylint: disable=import-error
+
+        fig = go.Figure()
+
+        # # Confusion Matrix figure
+        confusion_matrix, class_names = self.eval_result.mp.confusion_matrix
+
+        x = class_names
+        y = x[::-1].copy()
+        if len(x) >= 20:
+            text_anns = [[str(el) for el in row] for row in confusion_matrix]
+        else:
+            text_anns = [
+                [
+                    f"Predicted: {pred}<br>Ground Truth: {gt}<br> Probability: {confusion_matrix[ig][ip]}"
+                    for ip, pred in enumerate(x)
+                ]
+                for ig, gt in enumerate(y)
+            ]
+
+        fig.add_trace(
+            go.Heatmap(
+                z=confusion_matrix,
+                x=x,
+                y=y,
+                colorscale="Viridis",
+                showscale=False,
+                text=text_anns,
+                hoverinfo="text",
+            )
+        )
+
+        fig.update_layout(xaxis_title="Predicted", yaxis_title="Ground Truth")
+        if len(x) <= 20:
+            fig.update_layout(width=600, height=600)
+        return fig
+
+    def get_click_data(self) -> Dict:
+        res = dict(projectMeta=self.eval_result.pred_project_meta.to_json())
+        res["layoutTemplate"] = [None, None, None]
+        res["clickData"] = {}
+
+        _, class_names = self.eval_result.mp.confusion_matrix
+        for ig, gt_key in enumerate(class_names):
+            for ip, pred_key in enumerate(class_names):
+                key = f"{gt_key}{self._keypair_sep}{pred_key}"
+                res["clickData"][key] = {}
+                res["clickData"][key]["imagesIds"] = []
+
+                cmat_key = str(ig) + "_" + str(ip)
+                for name in self.eval_result.mp.cmat_cell_img_names[cmat_key]:
+                    gt_img_id = self.eval_result.images_map[name]
+                    pred_img_id = self.eval_result.matched_pair_data[gt_img_id].pred_image_info.id
+                    res["clickData"][key]["imagesIds"].append(pred_img_id)
+                title = f"Confusion Matrix. GT: '{gt_key}' ― Predicted: '{pred_key}'"
+                res["clickData"][key]["title"] = title
+
+        return res

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/explore_predictions.py

@@ -0,0 +1,84 @@
+from typing import Dict
+
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import GalleryWidget, MarkdownWidget
+
+
+class ExplorePredictions(SemanticSegmVisMetric):
+    MARKDOWN = "explore_predictions"
+    GALLERY = "explore_predictions"
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.clickable = True
+
+    @property
+    def md(self) -> MarkdownWidget:
+        text = self.vis_texts.markdown_explorer
+        return MarkdownWidget(self.MARKDOWN, "Explore Predictions", text)
+
+    def gallery(self, opacity) -> GalleryWidget:
+        gallery = GalleryWidget(self.GALLERY, columns_number=3, opacity=opacity)
+        gallery.set_project_meta(self.eval_result.filtered_project_meta)
+        gallery.add_image_left_header("Compare with GT")
+
+        gallery.set_images(
+            image_infos=self.eval_result.sample_images,
+            ann_infos=self.eval_result.sample_anns,
+        )
+        gallery._gallery._update_filters()
+
+        # set click data for diff gallery
+        self.explore_modal_table.set_click_data(
+            self.diff_modal_table.id,
+            self.get_click_data(),
+            get_key="(payload) => `${payload.annotation.image_id || payload.annotation.imageId}`",
+        )
+
+        gallery.set_click_data(
+            self.diff_modal_table.id,
+            self.get_click_data(),
+            get_key="(payload) => `${payload.annotation.image_id || payload.annotation.imageId}`",
+        )
+
+        # set click data for explore gallery
+        gallery.set_show_all_data(
+            self.explore_modal_table.id,
+            self.get_all_data(),
+        )
+        return gallery
+
+    def get_all_data(self) -> dict:
+        res = {}
+
+        res["layoutTemplate"] = [None, None, None]
+        click_data = res.setdefault("clickData", {})
+        explore = click_data.setdefault("explore", {})
+        explore["title"] = "Explore all predictions"
+        images_ids = [d.pred_image_info.id for d in self.eval_result.matched_pair_data.values()]
+        explore["imagesIds"] = images_ids
+
+        return res
+
+    def get_click_data(self) -> Dict:
+        res = {}
+
+        res["layoutTemplate"] = [
+            {"columnTitle": "Original Image"},
+            {"columnTitle": "Ground Truth Masks"},
+            {"columnTitle": "Predicted Masks"},
+        ]
+
+        click_data = res.setdefault("clickData", {})
+
+        for pairs_data in self.eval_result.matched_pair_data.values():
+            gt = pairs_data.gt_image_info
+            pred = pairs_data.pred_image_info
+            diff = pairs_data.diff_image_info
+            assert gt.name == pred.name == diff.name
+            key = click_data.setdefault(str(pred.id), {})
+            key["imagesIds"] = [diff.id, gt.id, pred.id]
+            key["title"] = f"Image: {pred.name}"
+        return res

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/frequently_confused.py

@@ -0,0 +1,101 @@
+from typing import Dict
+
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
+
+
+class FrequentlyConfused(SemanticSegmVisMetric):
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.clickable = True
+        self._keypair_sep = "-"
+
+    @property
+    def md(self) -> MarkdownWidget:
+        if self.is_empty:
+            text = self.vis_texts.markdown_frequently_confused_empty
+        else:
+            text = self.vis_texts.markdown_frequently_confused
+        return MarkdownWidget("frequently_confused", "Frequently Confused Classes", text=text)
+
+    @property
+    def chart(self) -> ChartWidget:
+        chart = ChartWidget("frequently_confused", self.get_figure())
+        chart.set_click_data(
+            self.explore_modal_table.id,
+            self.get_click_data(),
+            chart_click_extra="'getKey': (payload) => `${payload.points[0].x}`, 'keySeparator': '-',",
+        )
+        return chart
+
+    @property
+    def is_empty(self) -> bool:
+        probs, indexes_2d = self.eval_result.mp.frequently_confused
+        return len(probs) == 0
+
+    def get_figure(self):
+        import plotly.graph_objects as go  # pylint: disable=import-error
+
+        fig = go.Figure()
+
+        # Frequency of Confused Classes figure
+        probs, indexes_2d = self.eval_result.mp.frequently_confused
+        confused_classes = []
+        for idx in indexes_2d:
+            gt_idx, pred_idx = idx[0], idx[1]
+            gt_class = self.eval_result.mp.eval_data.index[gt_idx]
+            pred_class = self.eval_result.mp.eval_data.index[pred_idx]
+            confused_classes.append(f"{gt_class}-{pred_class}")
+
+        fig = go.Figure()
+        fig.add_trace(
+            go.Bar(
+                x=confused_classes,
+                y=probs,
+                orientation="v",
+                text=probs,
+                marker=dict(color=probs, colorscale="Reds"),
+            )
+        )
+        fig.update_traces(hovertemplate="Class Pair: %{x}<br>Probability: %{y:.2f}<extra></extra>")
+        fig.update_layout(
+            xaxis_title="Class Pair",
+            yaxis_title="Probability",
+            yaxis_range=[0, max(probs) + 0.1],
+            yaxis=dict(showticklabels=False),
+            font=dict(size=24),
+            width=1000 if len(confused_classes) > 10 else 600,
+        )
+
+        return fig
+
+    def get_click_data(self) -> Dict:
+        if self.is_empty:
+            return
+        res = dict(projectMeta=self.eval_result.pred_project_meta.to_json())
+
+        res["layoutTemplate"] = [None, None, None]
+        res["clickData"] = {}
+
+        _, class_names = self.eval_result.mp.confusion_matrix
+        _, indexes_2d = self.eval_result.mp.frequently_confused
+        for idx in indexes_2d:
+            gt_idx, pred_idx = idx[0], idx[1]
+            gt_key = class_names[gt_idx]
+            pred_key = class_names[pred_idx]
+            key = f"{gt_key}{self._keypair_sep}{pred_key}"
+
+            res["clickData"][key] = {}
+            res["clickData"][key]["imagesIds"] = []
+            idx_key = str(gt_idx) + "_" + str(pred_idx)
+            for name in self.eval_result.mp.cmat_cell_img_names[idx_key]:
+                gt_img_id = self.eval_result.images_map[name]
+                pred_img_id = self.eval_result.matched_pair_data[gt_img_id].pred_image_info.id
+                res["clickData"][key]["imagesIds"].append(pred_img_id)
+
+            title = f"Confused classes. GT: '{gt_key}' ― Predicted: '{pred_key}'"
+            res["clickData"][key]["title"] = title
+        return res

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/iou_eou.py

@@ -0,0 +1,45 @@
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
+
+
+class IntersectionErrorOverUnion(SemanticSegmVisMetric):
+
+    @property
+    def md(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            "intersection_error_over_union",
+            "Intersection & Error Over Union",
+            text=self.vis_texts.markdown_iou,
+        )
+
+    @property
+    def chart(self) -> ChartWidget:
+        return ChartWidget("intersection_error_over_union", self.get_figure())
+
+    def get_figure(self):
+        import plotly.graph_objects as go  # pylint: disable=import-error
+
+        fig = go.Figure()
+
+        # Intersection & Error Over Union figure
+        labels = ["mIoU", "mBoundaryEoU", "mExtentEoU", "mSegmentEoU"]
+        values = [
+            self.eval_result.mp.iou,
+            self.eval_result.mp.boundary_eou,
+            self.eval_result.mp.extent_eou,
+            self.eval_result.mp.segment_eou,
+        ]
+        fig.add_trace(
+            go.Pie(
+                labels=labels,
+                values=values,
+                hole=0.5,
+                textposition="outside",
+                textinfo="percent+label",
+                marker=dict(colors=["#8ACAA1", "#FFE4B5", "#F7ADAA", "#dd3f3f"]),
+            )
+        )
+
+        return fig

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

@@ -0,0 +1,60 @@
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
+
+
+class KeyMetrics(SemanticSegmVisMetric):
+
+    @property
+    def md(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            "markdown_header",
+            "Key Metrics",
+            text=self.vis_texts.markdown_key_metrics,
+        )
+
+    @property
+    def chart(self) -> ChartWidget:
+        return ChartWidget("base_metrics_chart", self.get_figure())
+
+    def get_figure(self):
+        import plotly.graph_objects as go  # pylint: disable=import-error
+
+        fig = go.Figure()
+        metrics = self.eval_result.mp.key_metrics().copy()
+        metrics["mPixel accuracy"] = round(metrics["mPixel accuracy"] * 100, 2)
+        fig.add_trace(
+            go.Scatterpolar(
+                r=list(metrics.values()) + [list(metrics.values())[0]],
+                theta=list(metrics.keys()) + [list(metrics.keys())[0]],
+                # fill="toself",
+                hovertemplate="%{theta}: %{r:.2f}<extra></extra>",
+            )
+        )
+
+        fig.update_layout(
+            showlegend=False,
+            polar=dict(
+                radialaxis=dict(
+                    range=[0, 100],
+                    ticks="outside",
+                ),
+                angularaxis=dict(rotation=90, direction="clockwise"),
+            ),
+            dragmode=False,
+            margin=dict(l=25, r=25, t=25, b=25),
+            modebar=dict(
+                remove=[
+                    "zoom2d",
+                    "pan2d",
+                    "select2d",
+                    "lasso2d",
+                    "zoomIn2d",
+                    "zoomOut2d",
+                    "autoScale2d",
+                    "resetScale2d",
+                ]
+            ),
+        )
+        return fig

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/model_predictions.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from supervisely.api.image_api import ImageApi, ImageInfo
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import MarkdownWidget, TableWidget
+
+
+class ModelPredictions(SemanticSegmVisMetric):
+    MARKDOWN = "model_predictions"
+    TABLE = "model_predictions"
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.clickable = True
+        self._row_ids = None  #  TODO: check if this is used
+
+    @property
+    def md(self) -> MarkdownWidget:
+        text = self.vis_texts.markdown_predictions_table
+        return MarkdownWidget(self.MARKDOWN, "Prediction details for every image", text)
+
+    @property
+    def table(self) -> TableWidget:
+        df = self.eval_result.mp.metric_table().round(2)
+
+        # tmp = set([d.pred_image_info.name for d in self.eval_result.matched_pair_data.values()])
+        # df = df[df["Image name"].isin(tmp)]
+        columns_options = [
+            {"maxWidth": "225px"},
+            {"maxValue": 1, "tooltip": "Pixel accuracy"},
+            {"maxValue": 1, "tooltip": "Precision (positive predictive value)"},
+            {"maxValue": 1, "tooltip": "Recall (sensitivity)"},
+            {"maxValue": 1, "tooltip": "F1 score (harmonic mean of precision and recall)"},
+            {"maxValue": 1, "tooltip": "IoU (Intersection over Union)"},
+            {"maxValue": 1, "tooltip": "Boundary IoU"},
+            {"maxValue": 1, "tooltip": "Boundary EoU"},
+            {"maxValue": 1, "tooltip": "Extent EoU"},
+            {"maxValue": 1, "tooltip": "Segment EoU"},
+            {"maxValue": 1, "tooltip": "Boundary EoU renormed"},
+            {"maxValue": 1, "tooltip": "Extent EoU renormed"},
+            {"maxValue": 1, "tooltip": "Segment EoU renormed"},
+        ]
+
+        # columns = df.columns.tolist()[1:]  # exclude sly_id
+        columns = df.columns.tolist()
+        content = []
+
+        # key_mapping = {}
+        # for old, new in zip(ImageInfo._fields, ImageApi.info_sequence()):
+        #     key_mapping[old] = new
+
+        self._row_ids = []
+        df = df.replace({float("nan"): None})  # replace NaN / float("nan") with None
+
+        for row in df.values.tolist():
+            # sly_id = row.pop(0)
+            # info = self.eval_result.matched_pair_data[sly_id].gt_image_info
+            name = row[0]
+
+            dct = {
+                "row": row,
+                "id": name,
+                "items": row,
+            }
+
+            self._row_ids.append(dct["id"])
+            content.append(dct)
+
+        data = {
+            "columns": columns,
+            "columnsOptions": columns_options,
+            "content": content,
+        }
+        table = TableWidget(
+            name=self.TABLE,
+            data=data,
+            fix_columns=1,
+        )
+        table.set_click_data(
+            self.explore_modal_table.id,
+            self.get_click_data(),
+        )
+        return table
+
+    def get_click_data(self) -> Dict:
+        res = {}
+        res["layoutTemplate"] = [
+            {"columnTitle": "Original Image"},
+            {"columnTitle": "Ground Truth Masks"},
+            {"columnTitle": "Predicted Masks"},
+        ]
+        click_data = res.setdefault("clickData", {})
+
+        for pairs_data in self.eval_result.matched_pair_data.values():
+            gt = pairs_data.gt_image_info
+            pred = pairs_data.pred_image_info
+            diff = pairs_data.diff_image_info
+            assert gt.name == pred.name == diff.name
+            key = click_data.setdefault(str(pred.name), {})
+            key["imagesIds"] = [diff.id, gt.id, pred.id]
+            key["title"] = f"Image: {pred.name}"
+
+        return res

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

@@ -0,0 +1,112 @@
+import datetime
+from typing import List
+
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import MarkdownWidget
+
+
+class Overview(SemanticSegmVisMetric):
+
+    def get_header(self, user_login: str) -> MarkdownWidget:
+        current_date = datetime.datetime.now().strftime("%d %B %Y, %H:%M")
+        header_text = self.vis_texts.markdown_header.format(
+            self.eval_result.name, user_login, current_date
+        )
+        header = MarkdownWidget("markdown_header", "Header", text=header_text)
+        return header
+
+    @property
+    def overview_md(self) -> List[MarkdownWidget]:
+        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 = link_text.replace("_", "\_")
+
+        model_name = self.eval_result.inference_info.get("model_name") or "Custom"
+        checkpoint_name = self.eval_result.inference_info.get("deploy_params", {}).get(
+            "checkpoint_name", ""
+        )
+
+        # Note about validation dataset
+        classes_str, note_about_images, starter_app_info = self._get_overview_info()
+
+        formats = [
+            model_name.replace("_", "\_"),
+            checkpoint_name.replace("_", "\_"),
+            self.eval_result.inference_info.get("architecture"),
+            self.eval_result.inference_info.get("task_type"),
+            self.eval_result.inference_info.get("runtime"),
+            url,
+            link_text,
+            self.eval_result.gt_project_info.id,
+            self.eval_result.gt_project_info.name,
+            classes_str,
+            note_about_images,
+            starter_app_info,
+            self.vis_texts.docs_url,
+        ]
+
+        md = MarkdownWidget(
+            "markdown_overview",
+            "Overview",
+            text=self.vis_texts.markdown_overview.format(*formats),
+        )
+        md.is_info_block = True
+        md.width_fit_content = True
+        return md
+
+    def _get_overview_info(self):
+        classes_cnt = len(self.eval_result.classes_whitelist)
+        classes_str = "classes" if classes_cnt > 1 else "class"
+        classes_str = f"{classes_cnt} {classes_str}"
+
+        evaluator_session, train_session, images_str = None, None, ""
+        gt_project_id = self.eval_result.gt_project_info.id
+        gt_dataset_ids = self.eval_result.gt_dataset_ids
+        gt_images_cnt = self.eval_result.val_images_cnt
+        train_info = self.eval_result.train_info
+        evaluator_app_info = self.eval_result.evaluator_app_info
+        total_imgs_cnt = self.eval_result.gt_project_info.items_count
+        if gt_images_cnt is not None:
+            val_imgs_cnt = gt_images_cnt
+        elif gt_dataset_ids is not None:
+            datasets = self.eval_result.gt_dataset_infos
+            val_imgs_cnt = sum(ds.items_count for ds in datasets)
+        else:
+            val_imgs_cnt = total_imgs_cnt
+
+        if train_info:
+            train_task_id = train_info.get("app_session_id")
+            if train_task_id:
+                app_id = self.eval_result.task_info["meta"]["app"]["id"]
+                train_session = f'- **Training dashboard**:  <a href="/apps/{app_id}/sessions/{train_task_id}" target="_blank">open</a>'
+
+            train_imgs_cnt = train_info.get("images_count")
+            images_str = f", {train_imgs_cnt} images in train, {val_imgs_cnt} images in validation"
+
+        if gt_images_cnt is not None:
+            images_str += (
+                f", total {total_imgs_cnt} images. Evaluated using subset - {val_imgs_cnt} images"
+            )
+        elif gt_dataset_ids is not None:
+            links = [
+                f'<a href="/projects/{gt_project_id}/datasets/{ds.id}" target="_blank">{ds.name}</a>'
+                for ds in datasets
+            ]
+            images_str += f", total {total_imgs_cnt} images. Evaluated on the dataset{'s' if len(links) > 1 else ''}: {', '.join(links)}"
+        else:
+            images_str += f", total {total_imgs_cnt} images. Evaluated on the whole project ({val_imgs_cnt} images)"
+
+        if evaluator_app_info:
+            evaluator_task_id = evaluator_app_info.get("id")
+            evaluator_app_id = evaluator_app_info.get("meta", {}).get("app", {}).get("id")
+            evaluator_app_name = evaluator_app_info.get("meta", {}).get("app", {}).get("name")
+            if evaluator_task_id and evaluator_app_id and evaluator_app_name:
+                evaluator_session = f'- **Evaluator app session**:  <a href="/apps/{evaluator_app_id}/sessions/{evaluator_task_id}" target="_blank">open</a>'
+
+        starter_app_info = train_session or evaluator_session or ""
+
+        return classes_str, images_str, starter_app_info

supervisely/nn/benchmark/semantic_segmentation/vis_metrics/renormalized_error_ou.py

@@ -0,0 +1,48 @@
+from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
+    SemanticSegmVisMetric,
+)
+from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
+
+
+class RenormalizedErrorOverUnion(SemanticSegmVisMetric):
+
+    @property
+    def md(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            "renormalized_error_over_union",
+            "Renormalized Error over Union",
+            text=self.vis_texts.markdown_renormalized_error_ou,
+        )
+
+    @property
+    def chart(self) -> ChartWidget:
+        return ChartWidget("intersection_error_over_union", self.get_figure())
+
+    def get_figure(self):
+        import plotly.graph_objects as go  # pylint: disable=import-error
+
+        fig = go.Figure()
+
+        # Renormalized Error over Union figure
+        labels = ["Boundary EoU", "Extent EoU", "Segment EoU"]
+        values = [
+            self.eval_result.mp.boundary_renormed_eou,
+            self.eval_result.mp.extent_renormed_eou,
+            self.eval_result.mp.segment_renormed_eou,
+        ]
+        fig.add_trace(
+            go.Bar(
+                x=labels,
+                y=values,
+                orientation="v",
+                text=values,
+                width=[0.5, 0.5, 0.5],
+                textposition="outside",
+                marker_color=["#FFE4B5", "#F7ADAA", "#dd3f3f"],
+                hovertemplate="%{x}: %{y:.2f}<extra></extra>",
+            )
+        )
+        fig.update_traces(hovertemplate="%{x}: %{y:.2f}<extra></extra>")
+        fig.update_layout(width=600)
+
+        return fig