supervisely 6.73.214__py3-none-any.whl → 6.73.216__py3-none-any.whl

supervisely/nn/benchmark/comparison/model_comparison.py

@@ -0,0 +1,84 @@
+import random
+from pathlib import Path
+from typing import List, Optional
+
+from supervisely.api.api import Api
+from supervisely.app.widgets import SlyTqdm
+from supervisely.imaging.color import get_predefined_colors, rgb2hex
+from supervisely.nn.benchmark.comparison.detection_visualization.visualizer import (
+    DetectionComparisonVisualizer,
+)
+from supervisely.nn.benchmark.visualization.evaluation_result import EvalResult
+from supervisely.task.progress import tqdm_sly
+
+
+class ModelComparison:
+
+    def __init__(
+        self,
+        api: Api,
+        remote_eval_dirs: List[str],
+        progress: Optional[SlyTqdm] = None,
+        workdir: Optional[str] = "./benchmark/comparison",
+    ):
+        self.api = api
+        self.progress = progress or tqdm_sly
+        self.workdir = workdir
+        self.remote_eval_dirs = remote_eval_dirs
+        self.evaluation_results: List[EvalResult] = []
+
+        colors = get_predefined_colors(len(remote_eval_dirs) * 5)  # for better visualizations
+        random.shuffle(colors)
+        for i, eval_dir in enumerate(remote_eval_dirs):
+            local_path = str(Path(self.workdir, "eval_data"))
+            eval_result = EvalResult(eval_dir, local_path, self.api, self.progress)
+            self.evaluation_results.append(eval_result)
+            eval_result.color = rgb2hex(colors[i])
+
+        self.task_type = self.evaluation_results[0].inference_info.get("task_type")
+        self._validate_eval_data()
+
+        self.visualizer: DetectionComparisonVisualizer = None
+        self.remote_dir = None
+
+    def _validate_eval_data(self):
+        """
+        Validate the evaluation data before running the comparison.
+        Make sure the benchmarks are done on the same project and datasets.
+        """
+        task_type = None
+        img_names = None
+        cat_names = None
+        for eval_result in self.evaluation_results:
+            next_task_type = eval_result.cv_task
+            if not task_type is None:
+                assert task_type == next_task_type, "Task types are different in the evaluations."
+            task_type = next_task_type
+            next_img_names = set(
+                [img.get("file_name") for img in eval_result.coco_gt.imgs.values()]
+            )
+            if not img_names is None:
+                assert img_names == next_img_names, "Images are different in the evaluations."
+            img_names = next_img_names
+            next_cat_names = set([cat.get("name") for cat in eval_result.coco_gt.cats.values()])
+            if not cat_names is None:
+                assert cat_names == next_cat_names, "Categories are different in the evaluations."
+            cat_names = next_cat_names
+
+    def get_metrics(self):
+        pass
+
+    def visualize(self):
+        if self.visualizer is None:
+            self.visualizer = DetectionComparisonVisualizer(self)
+        self.visualizer.visualize()
+
+    def upload_results(self, team_id: int, remote_dir: str, progress=None) -> str:
+        self.remote_dir = self.visualizer.upload_results(team_id, remote_dir, progress)
+        return self.remote_dir
+
+    def get_report_link(self) -> str:
+        if self.remote_dir is None:
+            raise ValueError("Results are not uploaded yet.")
+        report_link = self.remote_dir.rstrip("/") + "/template.vue"
+        return report_link

supervisely/nn/benchmark/evaluation/coco/metric_provider.py

@@ -89,7 +89,9 @@ class MetricProvider:
         self.coco_precision = coco_metrics["precision"]
         self.iouThrs = params["iouThrs"]
         self.recThrs = params["recThrs"]
-        self.iou_threshold = params["evaluation_params"]["iou_threshold"]
+
+        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)
 
     def calculate(self):
@@ -136,7 +138,7 @@ class MetricProvider:
         self._scores_tp_and_fp = self.m_full.scores_tp_and_fp()
         self._maximum_calibration_error = self.m_full.maximum_calibration_error()
         self._expected_calibration_error = self.m_full.expected_calibration_error()
-    
+
     def json_metrics(self):
         base = self.base_metrics()
         iou_name = int(self.iou_threshold * 100)
@@ -146,8 +148,8 @@ class MetricProvider:
         ap_custom_by_class = dict(zip(self.cat_names, ap_custom_by_class))
         return {
             "mAP": base["mAP"],
-            "AP50": self.coco_metrics["AP50"],
-            "AP75": self.coco_metrics["AP75"],
+            "AP50": self.coco_metrics.get("AP50"),
+            "AP75": self.coco_metrics.get("AP75"),
             f"AP{iou_name}": self.AP_custom(),
             "f1": base["f1"],
             "precision": base["precision"],
@@ -161,7 +163,7 @@ class MetricProvider:
             "AP_by_class": ap_by_class,
             f"AP{iou_name}_by_class": ap_custom_by_class,
         }
-    
+
     def metric_table(self):
         table = self.json_metrics()
         iou_name = int(self.iou_threshold * 100)
@@ -190,10 +192,10 @@ class MetricProvider:
         s[s == -1] = np.nan
         ap = np.nanmean(s, axis=0)
         return ap
-    
+
     def AP_custom(self):
         return np.nanmean(self.AP_custom_per_class())
-    
+
     def base_metrics(self):
         base = self._base_metrics
         calibration_score = 1 - self._expected_calibration_error

supervisely/nn/benchmark/visualization/evaluation_result.py

@@ -0,0 +1,266 @@
+import pickle
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import pandas as pd
+
+from supervisely.annotation.annotation import ProjectMeta
+from supervisely.api.api import Api
+from supervisely.api.dataset_api import DatasetInfo
+from supervisely.api.project_api import ProjectInfo
+from supervisely.app.widgets import SlyTqdm
+from supervisely.io.env import team_id
+from supervisely.io.fs import dir_empty, mkdir
+from supervisely.io.json import load_json_file
+from supervisely.nn.benchmark.evaluation.coco.metric_provider import MetricProvider
+from supervisely.nn.benchmark.visualization.vis_click_data import ClickData, IdMapper
+from supervisely.sly_logger import logger
+from supervisely.task.progress import tqdm_sly
+
+
+# class ImageComparisonData:
+#     def __init__(
+#         self,
+#         gt_image_info: ImageInfo = None,
+#         pred_image_info: ImageInfo = None,
+#         diff_image_info: ImageInfo = None,
+#         gt_annotation: Annotation = None,
+#         pred_annotation: Annotation = None,
+#         diff_annotation: Annotation = None,
+#     ):
+#         self.gt_image_info = gt_image_info
+#         self.pred_image_info = pred_image_info
+#         self.diff_image_info = diff_image_info
+#         self.gt_annotation = gt_annotation
+#         self.pred_annotation = pred_annotation
+#         self.diff_annotation = diff_annotation
+
+
+class EvalResult:
+
+    def __init__(
+        self,
+        eval_dir: str,
+        workdir: str,
+        api: Api,
+        progress: Optional[SlyTqdm] = None,
+    ):
+        from pycocotools.coco import COCO  # pylint: disable=import-error
+
+        self.eval_dir = eval_dir
+        self.report_path = Path(eval_dir, "visualizations", "template.vue").as_posix()
+        self.workdir = workdir
+        self.api = api
+        self.team_id = team_id()
+        self.local_dir = str(Path(self.workdir, self.eval_dir.lstrip("/")))
+        self.progress = progress or tqdm_sly
+
+        self.coco_gt: COCO = None
+        self.coco_dt: COCO = None
+        self.inference_info: Dict = None
+        self.speedtest_info: Dict = None
+        self.eval_data: Dict = None
+        self.mp: MetricProvider = None
+        self.df_score_profile: pd.DataFrame = None
+        self.dfsp_down: pd.DataFrame = None
+        self.f1_optimal_conf: float = None
+        self.click_data: ClickData = None
+        # self.comparison_data: Dict[int, ImageComparisonData] = {}
+        self.color = None
+
+        self._gt_project_info = None
+        self._gt_project_meta = None
+        self._gt_dataset_infos = None
+        self._dt_project_id = None
+        self._dt_project_meta = None
+
+        self._load_eval_data()
+        self._read_eval_data()
+
+    @property
+    def cv_task(self):
+        return self.inference_info.get("task_type")
+
+    @property
+    def name(self) -> str:
+        model_name = self.inference_info.get("model_name", self.eval_dir)
+        return self.inference_info.get("deploy_params", {}).get("checkpoint_name", model_name)
+
+    @property
+    def gt_project_id(self) -> int:
+        return self.inference_info.get("gt_project_id")
+
+    @property
+    def gt_project_info(self) -> ProjectInfo:
+        if self._gt_project_info is None:
+            gt_project_id = self.inference_info.get("gt_project_id")
+            self._gt_project_info = self.api.project.get_info_by_id(gt_project_id)
+        return self._gt_project_info
+
+    @property
+    def gt_project_meta(self) -> ProjectMeta:
+        if self._gt_project_meta is None:
+            self._gt_project_meta = ProjectMeta.from_json(
+                self.api.project.get_meta(self.gt_project_id)
+            )
+        return self._gt_project_meta
+
+    @property
+    def gt_dataset_ids(self) -> List[int]:
+        return self.inference_info.get("gt_dataset_ids", None)
+
+    @property
+    def gt_dataset_infos(self) -> List[DatasetInfo]:
+        if self._gt_dataset_infos is None:
+            filters = None
+            if self.gt_dataset_ids is not None:
+                filters = [{"field": "id", "operator": "in", "value": self.gt_dataset_ids}]
+            self._gt_dataset_infos = self.api.dataset.get_list(
+                self.gt_project_id,
+                filters=filters,
+                recursive=True,
+            )
+        return self._gt_dataset_infos
+
+    @property
+    def dt_project_id(self):
+        if self._dt_project_id is None:
+            self._dt_project_id = self.inference_info.get("dt_project_id")
+        return self._dt_project_id
+
+    @property
+    def dt_project_meta(self):
+        if self._dt_project_meta is None:
+            self._dt_project_meta = ProjectMeta.from_json(
+                self.api.project.get_meta(self.dt_project_id)
+            )
+        return self._dt_project_meta
+
+    @property
+    def train_info(self):
+        return self.inference_info.get("train_info", None)  # TODO: check
+
+    @property
+    def gt_images_ids(self):
+        return self.inference_info.get("gt_images_ids", None)  # TODO: check
+
+    @property
+    def classes_whitelist(self):
+        return self.inference_info.get("inference_settings", {}).get("classes", [])  # TODO: check
+
+    def _load_eval_data(self):
+        if not dir_empty(self.local_dir):
+            return
+        if not self.api.storage.dir_exists(self.team_id, self.eval_dir):
+            raise ValueError(f"Directory {self.eval_dir} not found in storage.")
+        mkdir(self.local_dir)
+        dir_name = Path(self.eval_dir).name
+        with self.progress(
+            message=f"Downloading evaluation data from {dir_name}",
+            total=self.api.storage.get_directory_size(self.team_id, self.eval_dir),
+            unit="B",
+            unit_scale=True,
+            unit_divisor=1024,
+        ) as pbar:
+            self.api.storage.download_directory(
+                self.team_id, self.eval_dir, self.local_dir, progress_cb=pbar.update
+            )
+
+    # def _load_projects(self):
+    #     projects_dir = Path(self.local_dir, "projects")
+    #     items_total = self.gt_images_ids
+    #     if items_total is None:
+    #         items_total = sum(self.gt_dataset_infos, key=lambda x: x.items_count)
+    #     with self.progress(
+    #         message=f"Downloading GT project {self.gt_project_info.name} and datasets",
+    #         total=items_total,
+    #     ) as pbar:
+    #         download_project(
+    #             self.api,
+    #             self.gt_project_info.id,
+    #             str(projects_dir),
+    #             dataset_ids=self.gt_dataset_ids,
+    #             progress_cb=pbar.update,
+    #         )
+
+    def _read_eval_data(self):
+        from pycocotools.coco import COCO  # pylint: disable=import-error
+
+        gt_path = str(Path(self.local_dir, "evaluation", "cocoGt.json"))
+        dt_path = str(Path(self.local_dir, "evaluation", "cocoDt.json"))
+        coco_gt, coco_dt = COCO(gt_path), COCO(dt_path)
+        self.coco_gt = coco_gt
+        self.coco_dt = coco_dt
+        self.eval_data = pickle.load(
+            open(Path(self.local_dir, "evaluation", "eval_data.pkl"), "rb")
+        )
+        self.inference_info = load_json_file(
+            Path(self.local_dir, "evaluation", "inference_info.json")
+        )
+        speedtest_info_path = Path(self.local_dir, "speedtest", "speedtest.json")
+        if speedtest_info_path.exists():
+            self.speedtest_info = load_json_file(
+                Path(self.local_dir, "speedtest", "speedtest.json")
+            )
+
+        self.mp = MetricProvider(
+            self.eval_data["matches"],
+            self.eval_data["coco_metrics"],
+            self.eval_data["params"],
+            self.coco_gt,
+            self.coco_dt,
+        )
+        self.mp.calculate()
+
+        self.df_score_profile = pd.DataFrame(
+            self.mp.confidence_score_profile(), columns=["scores", "precision", "recall", "f1"]
+        )
+
+        # downsample
+        if len(self.df_score_profile) > 5000:
+            self.dfsp_down = self.df_score_profile.iloc[:: len(self.df_score_profile) // 1000]
+        else:
+            self.dfsp_down = self.df_score_profile
+
+        self.f1_optimal_conf = self.mp.get_f1_optimal_conf()[0]
+        if self.f1_optimal_conf is None:
+            self.f1_optimal_conf = 0.01
+            logger.warning("F1 optimal confidence cannot be calculated. Using 0.01 as default.")
+
+        # Click data
+        gt_id_mapper = IdMapper(self.coco_gt.dataset)
+        dt_id_mapper = IdMapper(self.coco_dt.dataset)
+
+        self.click_data = ClickData(self.mp.m, gt_id_mapper, dt_id_mapper)
+
+    # def _update_comparison_data(
+    #     self,
+    #     gt_image_id: int,
+    #     gt_image_info: ImageInfo = None,
+    #     pred_image_info: ImageInfo = None,
+    #     diff_image_info: ImageInfo = None,
+    #     gt_annotation: Annotation = None,
+    #     pred_annotation: Annotation = None,
+    #     diff_annotation: Annotation = None,
+    # ):
+    #     comparison_data = self.comparison_data.get(gt_image_id, None)
+    #     if comparison_data is None:
+    #         self.comparison_data[gt_image_id] = ImageComparisonData(
+    #             gt_image_info=gt_image_info,
+    #             pred_image_info=pred_image_info,
+    #             diff_image_info=diff_image_info,
+    #             gt_annotation=gt_annotation,
+    #             pred_annotation=pred_annotation,
+    #             diff_annotation=diff_annotation,
+    #         )
+    #     else:
+    #         for attr, value in {
+    #             "gt_image_info": gt_image_info,
+    #             "pred_image_info": pred_image_info,
+    #             "diff_image_info": diff_image_info,
+    #             "gt_annotation": gt_annotation,
+    #             "pred_annotation": pred_annotation,
+    #             "diff_annotation": diff_annotation,
+    #         }.items():
+    #             if value is not None:
+    #                 setattr(comparison_data, attr, value)

supervisely/nn/benchmark/visualization/renderer.py

@@ -0,0 +1,100 @@
+import json
+from pathlib import Path
+from typing import Optional
+
+from jinja2 import Template
+
+from supervisely.api.api import Api
+from supervisely.io.fs import dir_empty, get_directory_size
+from supervisely.nn.benchmark.visualization.widgets import BaseWidget
+from supervisely.task.progress import tqdm_sly
+
+
+class Renderer:
+    """
+    Base class for rendering visualizations of Evaluation Report.
+    """
+
+    def __init__(
+        self,
+        layout: BaseWidget,
+        base_dir: str = "./output",
+        template: str = None,
+    ) -> None:
+        if template is None:
+            template = (
+                Path(__file__).parents[1].joinpath("visualization/report_template.html").read_text()
+            )
+        self.main_template = template
+        self.layout = layout
+        self.base_dir = base_dir
+
+        if Path(base_dir).exists():
+            if not dir_empty(base_dir):
+                raise ValueError(f"Output directory {base_dir} is not empty.")
+
+    @property
+    def _template_data(self):
+        return {"layout": self.layout.to_html()}
+
+    def render(self):
+        return Template(self.main_template).render(self._template_data)
+
+    def get_state(self):
+        return {}
+
+    def save(self) -> None:
+        self.layout.save_data(self.base_dir)
+        state = self.layout.get_state()
+        with open(Path(self.base_dir).joinpath("state.json"), "w") as f:
+            json.dump(state, f)
+        template = self.render()
+        with open(Path(self.base_dir).joinpath("template.vue"), "w") as f:
+            f.write(template)
+        return template
+
+    def visualize(self):
+        return self.save()
+
+    def upload_results(
+        self, api: Api, team_id: int, remote_dir: str, progress: Optional[tqdm_sly] = None
+    ) -> str:
+        if dir_empty(self.base_dir):
+            raise RuntimeError(
+                "No visualizations to upload. You should call visualize method first."
+            )
+        if progress is None:
+            progress = tqdm_sly
+        dir_total = get_directory_size(self.base_dir)
+        dir_name = Path(remote_dir).name
+        with progress(
+            message=f"Uploading visualizations to {dir_name}",
+            total=dir_total,
+            unit="B",
+            unit_scale=True,
+            unit_divisor=1024,
+        ) as pbar:
+            remote_dir = api.file.upload_directory(
+                team_id,
+                self.base_dir,
+                remote_dir,
+                change_name_if_conflict=True,
+                progress_size_cb=pbar,
+            )
+        src = self.save_report_link(api, team_id, remote_dir)
+        api.file.upload(team_id=team_id, src=src, dst=remote_dir.rstrip("/") + "/open.lnk")
+        return remote_dir
+
+    def save_report_link(self, api: Api, team_id: int, remote_dir: str):
+        report_link = self.get_report_link(api, team_id, remote_dir)
+        pth = Path(self.base_dir).joinpath("open.lnk")
+        with open(pth, "w") as f:
+            f.write(report_link)
+        return str(pth)
+
+    def get_report_link(self, api: Api, team_id: int, remote_dir: str):
+        template_path = remote_dir.rstrip("/") + "/" + "template.vue"
+        vue_template_info = api.file.get_info_by_path(team_id, template_path)
+
+        report_link = "/model-benchmark?id=" + str(vue_template_info.id)
+        return report_link

supervisely/nn/benchmark/visualization/report_template.html

@@ -0,0 +1,46 @@
+<div class="model-benchmark-body">
+
+    <sly-style>
+        .model-benchmark-body .sly-markdown-widget .markdown-body { padding: 0;
+        font-family: inherit; }
+        .model-benchmark-body .sly-markdown-widget .markdown-body h2 {
+        font-size: 18px; font-weight: 600; margin-bottom:
+        0px; border: 0; }
+        .model-benchmark-body .sly-markdown-widget .markdown-body h3 { color:
+        #949bab; font-size: 18px; margin-bottom:
+        7px; }
+        .model-benchmark-body .sly-markdown-widget .markdown-body p {
+        margin-bottom: 12px; }
+        .model-benchmark-body .el-collapse { margin: 15px 0; box-shadow: 0 1px
+        2px rgba(0, 0, 0, 0.1); border-radius:
+        7px; width: fit-content; }
+        .model-benchmark-body .el-collapse .el-collapse-item__header {
+        background: transparent; padding-right: 15px; }
+        .model-benchmark-body .model-info-block { display: flex; gap: 10px;
+        align-items: center; margin: 0 0 15px;
+        color: #778592; font-size: 13px; }
+        .model-benchmark-body .model-info-block > div { display: flex; gap: 4px;
+        align-items: center; }
+        /* , .model-benchmark-body .sly-markdown-widget
+        .markdown-body>*:last-child */
+        .model-benchmark-body .sly-iw-notification-box
+        .notification-box.notification-box-info { width: fit-content; }
+        .model-benchmark-body h1 { font-size: 20px; font-weight: bold;
+        margin-bottom: 5px; }
+        .model-benchmark-body .overview-info-block { background: #f4f7fb; border-radius: 12px;
+            padding: 20px; }
+        .model-benchmark-body .width-fit-content { width: fit-content;}
+        .model-benchmark-body .overview-info-block ul { list-style: none;
+        padding: 0; }
+        .model-benchmark-body .overview-info-block ul p { padding: 0; }
+        .model-benchmark-body .overview-info-block .checkpoint-url { display:
+        inline-block; width: 250px; white-space: nowrap; overflow: hidden;
+        text-overflow: ellipsis; vertical-align: middle; }
+        .model-benchmark-body .sly-sidebar-widget .main-wrapper .sidebar-panel {
+        top: 10px; }
+
+    </sly-style>
+
+    {{ layout }}
+
+</div>

supervisely/nn/benchmark/visualization/visualizer.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import os
 import json
+import os
 import pickle
 from typing import TYPE_CHECKING, Dict, List, Tuple
 

supervisely/nn/benchmark/visualization/widgets/__init__.py

@@ -0,0 +1,17 @@
+from supervisely.nn.benchmark.visualization.widgets.chart.chart import ChartWidget
+from supervisely.nn.benchmark.visualization.widgets.collapse.collapse import (
+    CollapseWidget,
+)
+from supervisely.nn.benchmark.visualization.widgets.container.container import (
+    ContainerWidget,
+)
+from supervisely.nn.benchmark.visualization.widgets.gallery.gallery import GalleryWidget
+from supervisely.nn.benchmark.visualization.widgets.markdown.markdown import (
+    MarkdownWidget,
+)
+from supervisely.nn.benchmark.visualization.widgets.notification.notification import (
+    NotificationWidget,
+)
+from supervisely.nn.benchmark.visualization.widgets.sidebar.sidebar import SidebarWidget
+from supervisely.nn.benchmark.visualization.widgets.table.table import TableWidget
+from supervisely.nn.benchmark.visualization.widgets.widget import BaseWidget

supervisely/nn/benchmark/visualization/widgets/chart/chart.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+from typing import Dict
+
+from jinja2 import Template
+
+from supervisely.io.fs import ensure_base_path
+from supervisely.nn.benchmark.visualization.widgets.widget import BaseWidget
+
+
+class ChartWidget(BaseWidget):
+    def __init__(
+        self,
+        name: str,
+        figure,  # plotly figure
+    ) -> None:
+        super().__init__(name)
+        self.radio_group = "radio_group"  # TODO: fix
+        self.switch_key = "switch_key"  # TODO: fix
+
+        self.figure = figure
+        self.click_data = None
+        self.click_gallery_id = None
+        self.chart_click_extra = None
+
+    def save_data(self, basepath: str) -> None:
+        # init data
+        basepath = basepath.rstrip("/")
+        ensure_base_path(basepath + self.data_source)
+
+        with open(basepath + self.data_source, "w") as f:
+            json.dump(self.get_init_data(), f)
+
+        # click data
+        if self.click_data is not None:
+            ensure_base_path(basepath + self.click_data_source)
+            with open(basepath + self.click_data_source, "w") as f:
+                json.dump(self.click_data, f)
+
+    def set_click_data(
+        self, gallery_id: str, click_data: Dict, chart_click_extra: str = ""
+    ) -> None:
+        self.click_data = click_data
+        self.click_gallery_id = gallery_id
+        self.chart_click_extra = chart_click_extra
+
+    def _get_template_data(self):
+        return {
+            "widget_id": self.id,
+            "radio_group": self.radio_group,
+            "switch_key": self.switch_key,
+            "init_data_source": self.data_source,
+            "click_handled": self.click_data is not None,
+            "chart_click_data_source": self.click_data_source,
+            "gallery_id": self.click_gallery_id,
+            "chart_click_extra": self.chart_click_extra,
+        }
+
+    def to_html(self) -> str:
+        template_str = Path(__file__).parent / "template.html"
+        return Template(template_str.read_text()).render(self._get_template_data())
+
+    def get_init_data(self):
+        return {
+            "selected": None,
+            "galleryContent": "",
+            "dialogVisible": False,
+            "chartContent": json.loads(self.figure.to_json()),
+        }
+
+    def get_state(self) -> Dict:
+        return {}

supervisely/nn/benchmark/visualization/widgets/chart/template.html

@@ -0,0 +1,16 @@
+<div style="margin-top: 20px; margin-bottom: 20px;">
+    <sly-iw-chart iw-widget-id="{{ widget_id }}" {% if switchable %}
+        v-show="state.{{ radio_group }} === '{{ switch_key }}'" {% endif %} :actions="{
+            'init': {
+                'dataSource': '{{ init_data_source }}',
+            },
+            {% if click_handled %}
+            'chart-click': {
+                'dataSource': '{{ chart_click_data_source }}',
+                {{ chart_click_extra }}
+                'galleryId': '{{ gallery_id }}',
+                'limit': 9
+            },
+            {% endif %}
+        }" :command="command" :data="data" />
+</div>