supervisely 6.73.238__py3-none-any.whl → 6.73.240__py3-none-any.whl

supervisely/nn/benchmark/{visualization/text_templates/object_detection_text.py → object_detection/text_templates.py}

@@ -13,6 +13,10 @@ definitions = SimpleNamespace(
     iou_threshold="The IoU threshold is a predefined value (set to 0.5 in many benchmarks) that determines the minimum acceptable IoU score for a predicted bounding box to be considered a correct prediction. When the IoU of a predicted box and actual box is higher than this IoU threshold, the prediction is considered correct. Some metrics will evaluate the model with different IoU thresholds to provide more insights about the model's performance.",
 )
 
+docs_url = (
+    "https://docs.supervisely.com/neural-networks/model-evaluation-benchmark/object-detection"
+)
+
 # <i class="zmdi zmdi-check-circle" style="color: #13ce66; margin-right: 5px"></i>
 clickable_label = """
 > <span style="color: #5a6772">
@@ -35,9 +39,11 @@ markdown_overview = """
 - **Architecture**: {}
 - **Task type**: {}
 - **Runtime**: {}
-- **Checkpoint file**: <a href="{}" target="_blank">{}</a>
+- **Checkpoint file**: <a class="checkpoint-url" href="{}" target="_blank">{}</a>
 - **Ground Truth project**: <a href="/projects/{}/datasets" target="_blank">{}</a>, {}{}
 {}
+- **IoU threshold**: {}
+- **Optimal confidence threshold**: {} (calculated automatically), <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>.
 """
@@ -97,18 +103,15 @@ markdown_experts = """
 markdown_how_to_use = """
 """
 
-markdown_outcome_counts = (
-    """## Outcome Counts
+markdown_outcome_counts = """## Outcome Counts
 
 This chart is used to evaluate the overall model performance by breaking down all predictions into <abbr title="{}">True Positives</abbr> (TP), <abbr title="{}">False Positives</abbr> (FP), and <abbr title="{}">False Negatives</abbr> (FN). This helps to visually assess the type of errors the model often encounters.
 
 """
-    + clickable_label
-)
 
 markdown_R = """## Recall
 
-This section measures the ability of the model to detect **all relevant instances in the dataset**. In other words, it answers the question: “Of all instances in the dataset, how many of them is the model managed to find out?”
+This section measures the ability of the model to detect **all relevant instances in the dataset**. In other words, it answers the question: "Of all instances in the dataset, how many of them is the model managed to find out?"
 
 To measure this, we calculate **Recall**. Recall counts errors, when the model does not detect an object that actually is present in a dataset and should be detected. Recall is calculated as the portion of correct predictions (true positives) over all instances in the dataset (true positives + false negatives).
 """
@@ -118,8 +121,7 @@ notification_recall = {
     "description": "The model correctly found <b>{} of {}</b> total instances in the dataset.",
 }
 
-markdown_R_perclass = (
-    """### Per-class Recall
+markdown_R_perclass = """### Per-class Recall
 
 This chart further analyzes Recall, breaking it down to each class in separate.
 
@@ -128,15 +130,13 @@ Since the overall recall is calculated as an average across all classes, we prov
 _Bars in the chart are sorted by <abbr title="{}">F1-score</abbr> to keep a unified order of classes between different charts._
 
 """
-    + clickable_label
-)
 
 
 markdown_P = """## Precision
 
-This section measures the accuracy of all predictions made by the model. In other words, it answers the question: “Of all predictions made by the model, how many of them are actually correct?”.
+This section measures the accuracy of all predictions made by the model. In other words, it answers the question: "Of all predictions made by the model, how many of them are actually correct?".
 
-To measure this, we calculate **Precision**. Precision counts errors, when the model predicts an object (bounding box), but the image has no objects of the predicted class in this place. Precision is calculated as a portion of correct predictions (true positives) over all model’s predictions (true positives + false positives).
+To measure this, we calculate **Precision**. Precision counts errors, when the model predicts an object (bounding box), but the image has no objects of the predicted class in this place. Precision is calculated as a portion of correct predictions (true positives) over all model's predictions (true positives + false positives).
 """
 
 notification_precision = {
@@ -144,8 +144,7 @@ notification_precision = {
     "description": "The model correctly predicted <b>{} of {}</b> predictions made by the model in total.",
 }
 
-markdown_P_perclass = (
-    """### Per-class Precision
+markdown_P_perclass = """### Per-class Precision
 
 This chart further analyzes Precision, breaking it down to each class in separate.
 
@@ -154,20 +153,15 @@ Since the overall precision is computed as an average across all classes, we pro
 _Bars in the chart are sorted by <abbr title="{}">F1-score</abbr> to keep a unified order of classes between different charts._
 
 """
-    + clickable_label
-)
 
 
-markdown_PR = (
-    """## Recall vs. Precision
+markdown_PR = """## Recall vs. Precision
 
 This section compares Precision and Recall in one graph, identifying **imbalance** between these two.
 
 _Bars in the chart are sorted by <abbr title="{}">F1-score</abbr> to keep a unified order of classes between different charts._
 
 """
-    + clickable_label
-)
 
 
 markdown_pr_curve = """## Precision-Recall Curve
@@ -199,39 +193,34 @@ notification_ap = {
     "description": "",
 }
 
-markdown_pr_by_class = (
-    """### Precision-Recall Curve by Class
+markdown_pr_by_class = """### Precision-Recall Curve by Class
 
 In this plot, you can evaluate PR curve for each class individually.
 
 """
-    + clickable_label
-)
 
-markdown_confusion_matrix = (
-    """## Confusion Matrix
+markdown_confusion_matrix = """## Confusion Matrix
 
 Confusion matrix helps to find the number of confusions between different classes made by the model.
 Each row of the matrix represents the instances in a ground truth class, while each column represents the instances in a predicted class.
 The diagonal elements represent the number of correct predictions for each class (True Positives), and the off-diagonal elements show misclassifications.
 
 """
-    + clickable_label
-)
 
+markdown_frequently_confused_empty = """### Frequently Confused Classes
+
+No frequently confused class pairs found
+"""
 
-markdown_frequently_confused = (
-    """### Frequently Confused Classes
+markdown_frequently_confused = """### Frequently Confused Classes
 
 This chart displays the most frequently confused pairs of classes. In general, it finds out which classes visually seem very similar to the model.
 
-The chart calculates the **probability of confusion** between different pairs of classes. For instance, if the probability of confusion for the pair “{} - {}” is {}, this means that when the model predicts either “{}” or “{}”, there is a {}% chance that the model might mistakenly predict one instead of the other.
+The chart calculates the **probability of confusion** between different pairs of classes. For instance, if the probability of confusion for the pair "{} - {}" is {}, this means that when the model predicts either "{}" or "{}", there is a {}% chance that the model might mistakenly predict one instead of the other.
 
 The measure is class-symmetric, meaning that the probability of confusing a {} with a {} is equal to the probability of confusing a {} with a {}.
 
 """
-    + clickable_label
-)
 
 
 markdown_localization_accuracy = """## Localization Accuracy (IoU)
@@ -317,14 +306,11 @@ Additionally, it provides a view of how predicted probabilities are distributed.
 Ideally, the green histogram (TP predictions) should have higher confidence scores and be shifted to the right, indicating that the model is sure about its correct predictions, and the red histogram (FP predictions) should have lower confidence scores and be shifted to the left.
 """
 
-markdown_class_ap = (
-    """## Average Precision by Class
+markdown_class_ap = """## Average Precision by Class
 
 A quick visual comparison of the model performance across all classes. Each axis in the chart represents a different class, and the distance to the center indicates the <abbr title="{}">Average Precision</abbr> (AP) for that class.
 
 """
-    + clickable_label
-)
 
 
 markdown_class_outcome_counts_1 = """### Outcome Counts by Class
@@ -338,16 +324,38 @@ markdown_normalization = """Normalization is used for better interclass comparis
 If normalization is off, the chart will display the total count of instances that correspond to outcome type (one of TP, FP or FN). This mode is identical to the main Outcome Counts graph on the top of the page. However, when normalization is off, you may encounter a class imbalance problem. Visually, bars that correspond to classes with many instances in the dataset will be much larger than others. This complicates the visual analysis.
 """
 
-markdown_class_outcome_counts_2 = (
-    """You can switch the plot view between normalized and absolute values.
+markdown_class_outcome_counts_2 = """You can switch the plot view between normalized and absolute values.
 
 _Bars in the chart are sorted by <abbr title="{}">F1-score</abbr> to keep a unified order of classes between different charts._
 
 """
-    + clickable_label
-)
 
 empty = """### {}
 
 > {}
 """
+
+
+markdown_speedtest_intro = """## Inference Speed
+
+This is a speed test benchmark for this model. The model was tested with the following configuration:
+
+- **Device**: {}
+- **Hardware**: {}
+- **Runtime**: {}
+"""
+
+markdown_speedtest_table = """
+The table below shows the speed test results. For each test, the time taken to process one batch of images is shown, as well as the model's throughput (i.e, the number of images processed per second, or FPS). Results are averaged across **{}** iterations.
+"""
+
+markdown_real_time_inference = """## Real-time Inference
+
+This chart compares different runtimes and devices (CPU or GPU)."""
+
+# We additionally divide **predict** procedure into three stages: pre-process, inference, and post-process. Each bar in this chart consists of these three stages. For example, in the chart you can find how long the post-process phase lasts in a CPU device with an ONNXRuntime environment."""
+
+
+markdown_speedtest_chart = """
+This chart shows how the model's speed changes with different batch sizes . As the batch size increases, you can observe an increase in FPS (images per second).
+"""

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

@@ -0,0 +1,48 @@
+from supervisely.nn.benchmark.object_detection.vis_metrics.confidence_distribution import (
+    ConfidenceDistribution,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.confidence_score import (
+    ConfidenceScore,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.confusion_matrix import (
+    ConfusionMatrix,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.explore_predictions import (
+    ExplorePredictions,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.f1_score_at_different_iou import (
+    F1ScoreAtDifferentIOU,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.frequently_confused import (
+    FrequentlyConfused,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.iou_distribution import (
+    IOUDistribution,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.key_metrics import KeyMetrics
+from supervisely.nn.benchmark.object_detection.vis_metrics.model_predictions import (
+    ModelPredictions,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.outcome_counts import (
+    OutcomeCounts,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.outcome_counts_per_class import (
+    PerClassOutcomeCounts,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.overview import Overview
+from supervisely.nn.benchmark.object_detection.vis_metrics.pr_curve import PRCurve
+from supervisely.nn.benchmark.object_detection.vis_metrics.pr_curve_by_class import (
+    PRCurveByClass,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.precision import Precision
+from supervisely.nn.benchmark.object_detection.vis_metrics.precision_avg_per_class import (
+    PerClassAvgPrecision,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.recall import Recall
+from supervisely.nn.benchmark.object_detection.vis_metrics.recall_vs_precision import (
+    RecallVsPrecision,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.reliability_diagram import (
+    ReliabilityDiagram,
+)
+from supervisely.nn.benchmark.object_detection.vis_metrics.speedtest import Speedtest

supervisely/nn/benchmark/{visualization → object_detection}/vis_metrics/confidence_distribution.py

@@ -1,40 +1,37 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 import numpy as np
 
-from supervisely.nn.benchmark.visualization.vis_metric_base import MetricVis
-from supervisely.nn.benchmark.visualization.vis_widgets import Schema, Widget
-
-if TYPE_CHECKING:
-    from supervisely.nn.benchmark.visualization.visualizer import Visualizer
+from supervisely.nn.benchmark.object_detection.base_vis_metric import DetectionVisMetric
+from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
 
 
-class ConfidenceDistribution(MetricVis):
+class ConfidenceDistribution(DetectionVisMetric):
+    MARKDOWN = "confidence_distribution"
+    CHART = "confidence_distribution"
 
-    def __init__(self, loader: Visualizer) -> None:
-        super().__init__(loader)
-        self.schema = Schema(
-            self._loader.vis_texts,
-            markdown_confidence_distribution=Widget.Markdown(
-                title="Confidence Distribution",
-                is_header=True,
-                formats=[
-                    self._loader.vis_texts.definitions.true_positives,
-                    self._loader.vis_texts.definitions.false_positives,
-                ],
+    @property
+    def md(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            self.MARKDOWN,
+            "Confidence Distribution",
+            self.vis_texts.markdown_confidence_distribution.format(
+                self.vis_texts.definitions.true_positives,
+                self.vis_texts.definitions.false_positives,
             ),
-            chart=Widget.Chart(),
         )
 
-    def get_figure(self, widget: Widget):  # -> Optional[go.Figure]:
+    @property
+    def chart(self) -> ChartWidget:
+        return ChartWidget(self.CHART, self._get_figure())
+
+    def _get_figure(self):  # -> go.Figure:
         import plotly.graph_objects as go  # pylint: disable=import-error
 
-        f1_optimal_conf, best_f1 = self._loader.mp.m_full.get_f1_optimal_conf()
+        f1_optimal_conf, best_f1 = self.eval_result.mp.m_full.get_f1_optimal_conf()
 
         # Histogram of confidence scores (TP vs FP)
-        scores_tp, scores_fp = self._loader.mp.m_full.scores_tp_and_fp()
+        scores_tp, scores_fp = self.eval_result.mp.m_full.scores_tp_and_fp()
 
         tp_y, tp_x = np.histogram(scores_tp, bins=40, range=[0, 1])
         fp_y, fp_x = np.histogram(scores_fp, bins=40, range=[0, 1])
@@ -102,7 +99,6 @@ class ConfidenceDistribution(MetricVis):
 
             fig.update_layout(
                 barmode="overlay",
-                # title="Histogram of Confidence Scores (TP vs FP)",
                 width=800,
                 height=500,
             )

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

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from supervisely.nn.benchmark.object_detection.base_vis_metric import DetectionVisMetric
+from supervisely.nn.benchmark.visualization.widgets import (
+    ChartWidget,
+    CollapseWidget,
+    MarkdownWidget,
+    NotificationWidget,
+)
+
+
+class ConfidenceScore(DetectionVisMetric):
+    MARKDOWN_CONFIDENCE_SCORE = "confidence_score"
+    NOTIFICATION = "confidence_score"
+    MARKDOWN_CONFIDENCE_SCORE_2 = "confidence_score_2"
+    MARKDOWN_CONFIDENCE_SCORE_3 = "calibration_score_3"
+    COLLAPSE_TITLE = "confidence_score_collapse"
+    CHART = "confidence_score"
+
+    @property
+    def md_confidence_score(self) -> MarkdownWidget:
+        text = self.vis_texts.markdown_confidence_score_1
+        text = text.format(self.vis_texts.definitions.confidence_threshold)
+        return MarkdownWidget(self.MARKDOWN_CONFIDENCE_SCORE, "Confidence Score Profile", text)
+
+    @property
+    def notification(self) -> NotificationWidget:
+        title, _ = self.vis_texts.notification_f1.values()
+        return NotificationWidget(
+            self.NOTIFICATION,
+            title.format(self.eval_result.mp.f1_optimal_conf.round(4)),
+        )
+
+    @property
+    def chart(self) -> ChartWidget:
+        return ChartWidget(name=self.CHART, figure=self._get_figure())
+
+    @property
+    def md_confidence_score_2(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            self.MARKDOWN_CONFIDENCE_SCORE_2,
+            "",
+            self.vis_texts.markdown_confidence_score_2,
+        )
+
+    @property
+    def collapse_conf_score(self) -> CollapseWidget:
+        md = MarkdownWidget(
+            self.COLLAPSE_TITLE,
+            "How to plot Confidence Profile?",
+            self.vis_texts.markdown_plot_confidence_profile,
+        )
+        return CollapseWidget([md])
+
+    @property
+    def md_confidence_score_3(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            self.MARKDOWN_CONFIDENCE_SCORE_3,
+            "",
+            self.vis_texts.markdown_calibration_score_3,
+        )
+
+    def _get_figure(self):  # -> go.Figure:
+        import plotly.express as px  # pylint: disable=import-error
+
+        color_map = {
+            "Precision": "#1f77b4",
+            "Recall": "orange",
+        }
+
+        fig = px.line(
+            self.eval_result.dfsp_down,
+            x="scores",
+            y=["precision", "recall", "f1"],
+            labels={"value": "Value", "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>"
+        )
+        fig.update_layout(yaxis=dict(range=[0, 1]), xaxis=dict(range=[0, 1], tick0=0, dtick=0.1))
+
+        if (
+            self.eval_result.mp.f1_optimal_conf is not None
+            and self.eval_result.mp.best_f1 is not None
+        ):
+            # Add vertical line for the best threshold
+            fig.add_shape(
+                type="line",
+                x0=self.eval_result.mp.f1_optimal_conf,
+                x1=self.eval_result.mp.f1_optimal_conf,
+                y0=0,
+                y1=self.eval_result.mp.best_f1,
+                line=dict(color="gray", width=2, dash="dash"),
+            )
+            fig.add_annotation(
+                x=self.eval_result.mp.f1_optimal_conf,
+                y=self.eval_result.mp.best_f1 + 0.04,
+                text=f"F1-optimal threshold: {self.eval_result.mp.f1_optimal_conf:.2f}",
+                showarrow=False,
+            )
+        fig.update_layout(
+            dragmode=False,
+            modebar=dict(
+                remove=[
+                    "zoom2d",
+                    "pan2d",
+                    "select2d",
+                    "lasso2d",
+                    "zoomIn2d",
+                    "zoomOut2d",
+                    "autoScale2d",
+                    "resetScale2d",
+                ]
+            ),
+        )
+        return fig

supervisely/nn/benchmark/{visualization → object_detection}/vis_metrics/confusion_matrix.py

@@ -1,36 +1,44 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import Dict
 
 import numpy as np
 import pandas as pd
 
-from supervisely.nn.benchmark.visualization.vis_metric_base import MetricVis
-from supervisely.nn.benchmark.visualization.vis_widgets import Schema, Widget
+from supervisely.nn.benchmark.object_detection.base_vis_metric import DetectionVisMetric
+from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
 
-if TYPE_CHECKING:
-    from supervisely.nn.benchmark.visualization.visualizer import Visualizer
 
+class ConfusionMatrix(DetectionVisMetric):
+    MARKDOWN = "confusion_matrix"
+    CHART = "confusion_matrix"
 
-class ConfusionMatrix(MetricVis):
-
-    def __init__(self, loader: Visualizer) -> None:
-        super().__init__(loader)
-
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
         self.clickable = True
-        self.schema = Schema(
-            self._loader.vis_texts,
-            markdown_confusion_matrix=Widget.Markdown(title="Confusion Matrix", is_header=True),
-            chart=Widget.Chart(),
+        self._keypair_sep: str = "-"
+
+    @property
+    def md(self) -> MarkdownWidget:
+        text = self.vis_texts.markdown_confusion_matrix
+        return MarkdownWidget(self.MARKDOWN, "Confusion Matrix", text)
+
+    @property
+    def chart(self) -> ChartWidget:
+        chart = ChartWidget(self.CHART, 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}${'-'}${payload.points[0].y}`, 'keySeparator': '-',",
         )
+        return chart
 
-    def get_figure(self, widget: Widget.Chart):  # -> Optional[go.Figure]:
+    def _get_figure(self):  # -> go.Figure:
         import plotly.express as px  # pylint: disable=import-error
 
-        confusion_matrix = self._loader.mp.confusion_matrix()
-        # Confusion Matrix
+        confusion_matrix = self.eval_result.mp.confusion_matrix()
         # TODO: Green-red
-        cat_names = self._loader.mp.cat_names
+        cat_names = self.eval_result.mp.cat_names
         none_name = "(None)"
 
         with np.errstate(divide="ignore"):
@@ -53,6 +61,7 @@ class ConfusionMatrix(MetricVis):
         fig.update_traces(
             customdata=confusion_matrix,
             hovertemplate="Objects Count: %{customdata}<br>Predicted: %{y}<br>Ground Truth: %{x}",
+            colorscale="Viridis",
         )
 
         # Text on cells
@@ -62,18 +71,21 @@ class ConfusionMatrix(MetricVis):
         # fig.show()
         return fig
 
-    def get_click_data(self, widget: Widget.Chart) -> Optional[dict]:
-        res = dict(projectMeta=self._loader.dt_project_meta.to_json())
+    def get_click_data(self) -> Dict:
+        res = dict(projectMeta=self.eval_result.pred_project_meta.to_json())
         res["layoutTemplate"] = [None, None, None]
         res["clickData"] = {}
 
-        for (pred_key, gt_key), matches_data in self._loader.click_data.confusion_matrix.items():
+        for (
+            pred_key,
+            gt_key,
+        ), matches_data in self.eval_result.click_data.confusion_matrix.items():
             key = gt_key + self._keypair_sep + pred_key
             res["clickData"][key] = {}
             res["clickData"][key]["imagesIds"] = []
             gt_title = f"GT: '{gt_key}'" if gt_key != "(None)" else "No GT Objects"
             pred_title = f"Predicted: '{pred_key}'" if pred_key != "(None)" else "No Predictions"
-            res["clickData"][key]["title"] = f"Confusion Matrix. {gt_title} – {pred_title}"
+            res["clickData"][key]["title"] = f"Confusion Matrix. {gt_title} ― {pred_title}"
 
             img_ids = set()
             obj_ids = set()

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

@@ -0,0 +1,129 @@
+from typing import Dict
+
+from supervisely.nn.benchmark.object_detection.base_vis_metric import DetectionVisMetric
+from supervisely.nn.benchmark.visualization.widgets import GalleryWidget, MarkdownWidget
+
+
+class ExplorePredictions(DetectionVisMetric):
+    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:
+        optimal_conf = self.eval_result.mp.f1_optimal_conf
+        default_filters = [{"confidence": [optimal_conf, 1]}]
+        gallery = GalleryWidget(
+            self.GALLERY, columns_number=3, filters=default_filters, opacity=opacity
+        )
+        gallery.add_image_left_header("Compare with GT")
+        gallery.set_project_meta(self.eval_result.filtered_project_meta)
+
+        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_diff_data(),
+            get_key="(payload) => `${payload.annotation.imageId}`",
+        )
+
+        # set click data for explore gallery
+        gallery.set_click_data(
+            self.diff_modal_table.id,
+            self.get_diff_data(),
+            get_key="(payload) => `${payload.annotation.image_id}`",
+        )
+
+        gallery.set_show_all_data(
+            self.explore_modal_table.id,
+            self.get_click_data(),
+        )
+        return gallery
+
+    def get_click_data(self) -> dict:
+        res = {}
+
+        res["layoutTemplate"] = [{"skipObjectTagsFiltering": ["outcome"]}] * 3
+        click_data = res.setdefault("clickData", {})
+        explore = click_data.setdefault("explore", {})
+        explore["filters"] = [
+            {
+                "type": "tag",
+                "tagId": "confidence",
+                "value": [self.eval_result.mp.f1_optimal_conf, 1],
+            }
+        ]
+        explore["title"] = "Explore all predictions"
+        images_ids = explore.setdefault("imagesIds", [])
+
+        images_ids.extend(
+            [d.pred_image_info.id for d in self.eval_result.matched_pair_data.values()]
+        )
+
+        return res
+
+    def get_diff_data(self) -> Dict:
+        res = {}
+
+        res["layoutTemplate"] = [
+            {"skipObjectTagsFiltering": True, "columnTitle": "Ground Truth"},
+            {"skipObjectTagsFiltering": ["outcome"], "columnTitle": "Prediction"},
+            {"skipObjectTagsFiltering": ["confidence"], "columnTitle": "Difference"},
+        ]
+
+        click_data = res.setdefault("clickData", {})
+
+        default_filters = [
+            {
+                "type": "tag",
+                "tagId": "confidence",
+                "value": [self.eval_result.mp.f1_optimal_conf, 1],
+            },
+        ]
+        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
+            for img_id in [gt.id, pred.id, diff.id]:
+                key = click_data.setdefault(str(img_id), {})
+                key["imagesIds"] = [gt.id, pred.id, diff.id]
+                key["filters"] = default_filters
+                key["title"] = f"Image: {gt.name}"
+
+                object_bindings = []
+                for img in [pred, diff]:
+                    if img == pred:
+                        ann_json = pairs_data.pred_annotation.to_json()
+                    else:
+                        ann_json = pairs_data.diff_annotation.to_json()
+                    for obj in ann_json["objects"]:
+                        for tag in obj["tags"]:
+                            if tag["name"] == "matched_gt_id":
+                                object_bindings.append(
+                                    [
+                                        {
+                                            "id": obj["id"],
+                                            "annotationKey": img.id,
+                                        },
+                                        {
+                                            "id": int(tag["value"]),
+                                            "annotationKey": gt.id if img == pred else pred.id,
+                                        },
+                                    ]
+                                )
+                key["objectsBindings"] = object_bindings
+
+        return res