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

supervisely/nn/benchmark/comparison/semantic_segmentation/visualizer.py

@@ -0,0 +1,159 @@
+from typing import List
+
+import supervisely.nn.benchmark.comparison.semantic_segmentation.text_templates as texts
+from supervisely.nn.benchmark.comparison.base_visualizer import BaseComparisonVisualizer
+from supervisely.nn.benchmark.comparison.semantic_segmentation.vis_metrics import (
+    ClasswiseErrorAnalysis,
+    ExplorePredictions,
+    FrequentlyConfused,
+    IntersectionErrorOverUnion,
+    Overview,
+    RenormalizedErrorOverUnion,
+    Speedtest,
+)
+from supervisely.nn.benchmark.semantic_segmentation.evaluator import (
+    SemanticSegmentationEvalResult,
+)
+from supervisely.nn.benchmark.visualization.widgets import (
+    ContainerWidget,
+    MarkdownWidget,
+    SidebarWidget,
+)
+
+
+class SemanticSegmentationComparisonVisualizer(BaseComparisonVisualizer):
+    vis_texts = texts
+    ann_opacity = 0.7
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.eval_results: List[SemanticSegmentationEvalResult]
+
+    def _create_widgets(self):
+        # Modal Gellery
+        self.diff_modal = self._create_diff_modal_table()
+        self.explore_modal = self._create_explore_modal_table(
+            click_gallery_id=self.diff_modal.id, hover_text="Compare with GT"
+        )
+
+        # Notifcation
+        self.clickable_label = self._create_clickable_label()
+
+        # Speedtest init here for overview
+        speedtest = Speedtest(self.vis_texts, self.comparison.eval_results)
+
+        # Overview
+        overview = Overview(self.vis_texts, self.comparison.eval_results)
+        overview.team_id = self.comparison.team_id
+        self.header = self._create_header()
+        self.overviews = self._create_overviews(overview, grid_cols=2)
+        self.overview_md = overview.overview_md
+        self.key_metrics_md = self._create_key_metrics()
+        self.key_metrics_table = overview.get_table_widget(
+            latency=speedtest.latency, fps=speedtest.fps
+        )
+        self.overview_chart = overview.chart_widget
+
+        # Explore Predictions
+        columns_number = len(self.comparison.eval_results) + 1  # +1 for GT
+        self.explore_predictions_modal_gallery = self._create_explore_modal_table(columns_number)
+        explore_predictions = ExplorePredictions(
+            self.vis_texts,
+            self.comparison.eval_results,
+            explore_modal_table=self.explore_predictions_modal_gallery,
+        )
+        self.explore_predictions_md = explore_predictions.difference_predictions_md
+        self.explore_predictions_gallery = explore_predictions.explore_gallery
+
+        # IntersectionErrorOverUnion
+        iou_eou = IntersectionErrorOverUnion(self.vis_texts, self.comparison.eval_results)
+        self.iou_eou_md = iou_eou.md
+        self.iou_eou_chart = iou_eou.chart
+
+        # RenormalizedErrorOverUnion
+        reou = RenormalizedErrorOverUnion(self.vis_texts, self.comparison.eval_results)
+        self.reou_md = reou.md
+        self.reou_chart = reou.chart
+
+        # ClasswiseErrorAnalysis
+        classwise_ea = ClasswiseErrorAnalysis(self.vis_texts, self.comparison.eval_results)
+        self.classwise_ea_md = classwise_ea.md
+        self.classwise_ea_chart = classwise_ea.chart
+
+        # FrequentlyConfused
+        frequently_confused = FrequentlyConfused(self.vis_texts, self.comparison.eval_results)
+        self.frequently_confused_md = frequently_confused.md
+        self.frequently_confused_chart = frequently_confused.chart
+
+        # # SpeedTest
+        self.speedtest_present = not speedtest.is_empty()
+        self.speedtest_multiple_batch_sizes = False
+
+        if self.speedtest_present:
+            self.speedtest_md_intro = speedtest.md_intro
+            self.speedtest_intro_table = speedtest.intro_table
+            self.speed_inference_time_md = speedtest.inference_time_md
+            self.speed_inference_time_table = speedtest.inference_time_table
+            self.speed_fps_md = speedtest.fps_md
+            self.speed_fps_table = speedtest.fps_table
+            self.speedtest_multiple_batch_sizes = speedtest.multiple_batche_sizes()
+            if self.speedtest_multiple_batch_sizes:
+                self.speed_batch_inference_md = speedtest.batch_inference_md
+                self.speed_chart = speedtest.chart
+
+    def _create_layout(self):
+        is_anchors_widgets = [
+            # Overview
+            (0, self.header),
+            (1, self.overview_md),
+            (0, self.overviews),
+            (1, self.key_metrics_md),
+            (0, self.key_metrics_table),
+            (0, self.overview_chart),
+            # Explore Predictions
+            (1, self.explore_predictions_md),
+            (0, self.explore_predictions_gallery),
+            # IntersectionErrorOverUnion
+            (1, self.iou_eou_md),
+            (0, self.iou_eou_chart),
+            # RenormalizedErrorOverUnion
+            (1, self.reou_md),
+            (0, self.reou_chart),
+            # ClasswiseErrorAnalysis
+            (1, self.classwise_ea_md),
+            (0, self.classwise_ea_chart),
+            # FrequentlyConfused
+            (1, self.frequently_confused_md),
+            (0, self.frequently_confused_chart),
+        ]
+        if self.speedtest_present:
+            is_anchors_widgets.extend(
+                [
+                    # SpeedTest
+                    (1, self.speedtest_md_intro),
+                    (0, self.speedtest_intro_table),
+                    (0, self.speed_inference_time_md),
+                    (0, self.speed_inference_time_table),
+                    (0, self.speed_fps_md),
+                    (0, self.speed_fps_table),
+                ]
+            )
+            if self.speedtest_multiple_batch_sizes:
+                is_anchors_widgets.append((0, self.speed_batch_inference_md))
+                is_anchors_widgets.append((0, self.speed_chart))
+        anchors = []
+        for is_anchor, widget in is_anchors_widgets:
+            if is_anchor:
+                anchors.append(widget.id)
+
+        sidebar = SidebarWidget(widgets=[i[1] for i in is_anchors_widgets], anchors=anchors)
+        layout = ContainerWidget(
+            widgets=[sidebar, self.explore_modal, self.explore_predictions_modal_gallery],
+            name="main_container",
+        )
+        return layout
+
+    def _create_key_metrics(self) -> MarkdownWidget:
+        return MarkdownWidget(
+            "markdown_key_metrics", "Key Metrics", text=self.vis_texts.markdown_key_metrics
+        )

supervisely/nn/benchmark/instance_segmentation/evaluator.py

@@ -39,7 +39,7 @@ class InstanceSegmentationEvaluator(ObjectDetectionEvaluator):
         except AssertionError as e:
             raise ValueError(
                 f"{e}. Please make sure that your GT and DT projects are correct. "
-                "If GT project has nested datasets and DT project was crated with NN app, "
+                "If GT project has nested datasets and DT project was created with NN app, "
                 "try to use newer version of NN app."
             )
 

supervisely/nn/benchmark/object_detection/evaluator.py

@@ -104,7 +104,7 @@ class ObjectDetectionEvaluator(BaseEvaluator):
         except AssertionError as e:
             raise ValueError(
                 f"{e}. Please make sure that your GT and DT projects are correct. "
-                "If GT project has nested datasets and DT project was crated with NN app, "
+                "If GT project has nested datasets and DT project was created with NN app, "
                 "try to use newer version of NN app."
             )
         self.cocoGt, self.cocoDt = read_coco_datasets(self.cocoGt_json, self.cocoDt_json)

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

@@ -24,9 +24,7 @@ class Overview(DetectionVisMetric):
         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", ""
-        )
+        checkpoint_name = self.eval_result.checkpoint_name
 
         # Note about validation dataset
         classes_str, note_about_images, starter_app_info = self._get_overview_info()

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

@@ -69,4 +69,7 @@ class Precision(DetectionVisMetric):
             )
         fig.update_xaxes(title_text="Class")
         fig.update_yaxes(title_text="Precision", range=[0, 1])
+        fig.update_layout(
+            width=700 if len(sorted_by_precision) < 10 else None,
+        )
         return fig

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

@@ -68,4 +68,7 @@ class Recall(DetectionVisMetric):
             )
         fig.update_xaxes(title_text="Class")
         fig.update_yaxes(title_text="Recall", range=[0, 1])
+        fig.update_layout(
+            width=700 if len(sorted_by_f1) < 10 else None,
+        )
         return fig

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

@@ -50,7 +50,7 @@ class RecallVsPrecision(DetectionVisMetric):
                 marker=dict(color=orange_color),
             )
         )
-        fig.update_layout(barmode="group")
+        fig.update_layout(barmode="group", width=800 if len(sorted_by_f1) < 10 else None)
         fig.update_xaxes(title_text="Class")
         fig.update_yaxes(title_text="Value", range=[0, 1])
         return fig

supervisely/nn/benchmark/object_detection/visualizer.py

@@ -56,21 +56,17 @@ class ObjectDetectionVisualizer(BaseVisualizer):
         self._widgets = False
         self.ann_opacity = 0.4
 
-        diff_project_info, diff_dataset_infos, existed = self._get_or_create_diff_project()
+        diff_project_info, diff_dataset_infos, _ = self._get_or_create_diff_project()
         self.eval_result.diff_project_info = diff_project_info
         self.eval_result.diff_dataset_infos = diff_dataset_infos
         self.eval_result.matched_pair_data = {}
 
         self.gt_project_path = str(Path(self.workdir).parent / "gt_project")
         self.pred_project_path = str(Path(self.workdir).parent / "pred_project")
-        if not existed:
-            self.update_diff_annotations()
-        else:
-            self._init_match_data()
+        self.update_diff_annotations()
 
         # set filtered project meta
         self.eval_result.filtered_project_meta = self._get_filtered_project_meta(self.eval_result)
-
         self._get_sample_data_for_gallery()
 
     @property
@@ -222,10 +218,9 @@ class ObjectDetectionVisualizer(BaseVisualizer):
 
         # Speedtest init here for overview
         speedtest = Speedtest(self.vis_texts, self.eval_result)
-        self.speedtest_present = False
+        self.speedtest_present = not speedtest.is_empty()
         self.speedtest_batch_sizes_cnt = speedtest.num_batche_sizes
-        if not speedtest.is_empty():
-            self.speedtest_present = True
+        if self.speedtest_present:
             self.speedtest_md_intro = speedtest.intro_md
             self.speedtest_table_md = speedtest.table_md
             self.speedtest_table = speedtest.table
@@ -393,7 +388,7 @@ class ObjectDetectionVisualizer(BaseVisualizer):
 
         pred_tag_list = []
         with self.pbar(
-            message="Visualizations: Creating diff_project", total=pred_project.total_items
+            message="Visualizations: Creating difference project", total=pred_project.total_items
         ) as progress:
             logger.debug(
                 "Creating diff project data",

supervisely/nn/benchmark/semantic_segmentation/evaluator.py

@@ -97,7 +97,13 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
         meta_path = Path(project_path) / "meta.json"
         meta = ProjectMeta.from_json(load_json_file(meta_path))
 
-        palette = [obj.color for obj in meta.obj_classes if obj.name in self.classes_whitelist]
+        palette = []
+        for cls_name in self.classes_whitelist:
+            obj_cls = meta.get_obj_class(cls_name)
+            if obj_cls is None:
+                palette.append((0, 0, 0))
+            else:
+                palette.append(obj_cls.color)
 
         return palette
 
@@ -123,7 +129,11 @@ class SemanticSegmentationEvaluator(BaseEvaluator):
                 continue
 
             palette = self._get_palette(src_dir)
-            bg_color = palette[self.classes_whitelist.index(self.bg_cls_name)]
+            bg_cls_idx = self.classes_whitelist.index(self.bg_cls_name)
+            try:
+                bg_color = palette[bg_cls_idx]
+            except IndexError:
+                bg_color = (0, 0, 0)
             output_dir.mkdir(parents=True)
             temp_seg_dir = src_dir + "_temp"
             if not os.path.exists(temp_seg_dir):

supervisely/nn/benchmark/semantic_segmentation/metric_provider.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 import numpy as np
 
@@ -65,7 +65,7 @@ class MetricProvider:
 
         # frequently confused classes
         self.frequently_confused = self.get_frequently_confused(
-            eval_data["confusion_matrix"].copy()
+            eval_data["confusion_matrix"].copy(), n_pairs=20
         )
 
     def json_metrics(self):
@@ -114,18 +114,17 @@ class MetricProvider:
         confusion_matrix = confusion_matrix[::-1]
         return confusion_matrix, class_names
 
-    def get_frequently_confused(self, confusion_matrix: np.ndarray):
-        n_pairs = 20
+    def get_frequently_confused(self, confusion_matrix: np.ndarray, n_pairs: Optional[int] = None):
 
-        non_diagonal_indexes = {}
+        non_diagonal_ids = {}
         for i, idx in enumerate(np.ndindex(confusion_matrix.shape)):
             if idx[0] != idx[1]:
-                non_diagonal_indexes[i] = idx
+                non_diagonal_ids[i] = idx
 
         indexes_1d = np.argsort(confusion_matrix, axis=None)
-        indexes_2d = [
-            non_diagonal_indexes[idx] for idx in indexes_1d if idx in non_diagonal_indexes
-        ][-n_pairs:]
+        indexes_2d = [non_diagonal_ids[idx] for idx in indexes_1d if idx in non_diagonal_ids]
+        if n_pairs is not None:
+            indexes_2d = indexes_2d[:n_pairs]
         indexes_2d = np.asarray(indexes_2d[::-1])
 
         rows = indexes_2d[:, 0]

supervisely/nn/benchmark/semantic_segmentation/text_templates.py

@@ -40,7 +40,7 @@ We provide a comprehensive model performance analysis using a set of metrics, in
 
 - **Pixel accuracy**: reflects the percent of image pixels which were correctly classified.
 - **Precision**: reflects the number of correctly predicted positive segmentations divided by the total number of predicted positive segmentations.
-- **Recall8**: reflects the number of correctly predicted positive segmentations divided by the number of all samples that should have been segmented as positive.
+- **Recall**: reflects the number of correctly predicted positive segmentations divided by the number of all samples that should have been segmented as positive.
 - **F1-score**: reflects the tradeoff between precision and recall. It is equivalent to the Dice coefficient and calculated as a harmonic mean of precision and recall.
 - **Intersection over union (IoU, also known as the Jaccard index)**: measures the overlap between ground truth mask and predicted mask. It is calculated as the ratio of the intersection of the two masks areas to their combined areas.
 - **Boundary intersection over union**: a segmentation consistency measure that first computes the sets of ground truth  and predicted masks pixels that are located within the distance d from each contour and then computes intersection over union of these two sets. Pixel distance parameter d (pixel width of the boundary region) controls the sensitivity of the metric, it is usually set as 2% of the image diagonal for normal resolution images and 0.5% of the image diagonal for high resolution images.
@@ -72,7 +72,7 @@ The pie chart below demonstrates what the model lacked in order to show the perf
 
 markdown_renormalized_error_ou = """## Renormalized Error Over Union
 
-The pie chart below is dedicated to decomposition of postprocessed variant of error over union which takes into consideration cause and effect relationships between different types of segmentation errors. Error over union decomposition has its own pitfalls. It is important to understand that models which tend to produce segment errors (when entire segments are mispredicted and there is no intersection between ground truth and predicted mask) will face less occasions to produce boundary and extent errors - as a result, boundary and extent error over union values will be underestimated.
+The chart below is dedicated to decomposition of postprocessed variant of error over union which takes into consideration cause and effect relationships between different types of segmentation errors. Error over union decomposition has its own pitfalls. It is important to understand that models which tend to produce segment errors (when entire segments are mispredicted and there is no intersection between ground truth and predicted mask) will face less occasions to produce boundary and extent errors - as a result, boundary and extent error over union values will be underestimated.
 
 In terms of localization, segment error is more fundamental than extent, while extent error is more fundamental than boundary. In order to overcome this problem, renormalized error over union proposes a slightly different calculation method - by removing more fundamental errors from the denominator - read more in our <a href="{}" target="_blank">technical report</a>
 """.format(

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

@@ -1,7 +1,11 @@
 from supervisely.nn.benchmark.semantic_segmentation.base_vis_metric import (
     SemanticSegmVisMetric,
 )
-from supervisely.nn.benchmark.visualization.widgets import ChartWidget, MarkdownWidget
+from supervisely.nn.benchmark.visualization.widgets import (
+    ChartWidget,
+    MarkdownWidget,
+    TableWidget,
+)
 
 
 class KeyMetrics(SemanticSegmVisMetric):
@@ -14,6 +18,32 @@ class KeyMetrics(SemanticSegmVisMetric):
             text=self.vis_texts.markdown_key_metrics,
         )
 
+    @property
+    def table(self) -> TableWidget:
+        columns = ["metrics", "values"]
+        content = []
+
+        metrics = self.eval_result.mp.key_metrics().copy()
+        metrics["mPixel accuracy"] = round(metrics["mPixel accuracy"] * 100, 2)
+
+        for metric, value in metrics.items():
+            row = [metric, round(value, 2)]
+            dct = {"row": row, "id": metric, "items": row}
+            content.append(dct)
+
+        columns_options = [{"disableSort": True}, {"disableSort": True}]
+        data = {"columns": columns, "columnsOptions": columns_options, "content": content}
+
+        table = TableWidget(
+            name="table_key_metrics",
+            data=data,
+            fix_columns=1,
+            width="60%",
+            show_header_controls=False,
+            main_column=columns[0],
+        )
+        return table
+
     @property
     def chart(self) -> ChartWidget:
         return ChartWidget("base_metrics_chart", self.get_figure())

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

@@ -26,9 +26,7 @@ class Overview(SemanticSegmVisMetric):
         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", ""
-        )
+        checkpoint_name = self.eval_result.checkpoint_name
 
         # Note about validation dataset
         classes_str, note_about_images, starter_app_info = self._get_overview_info()

supervisely/nn/benchmark/semantic_segmentation/visualizer.py

@@ -93,6 +93,7 @@ class SemanticSegmentationVisualizer(BaseVisualizer):
         # key metrics
         key_metrics = KeyMetrics(self.vis_texts, self.eval_result)
         self.key_metrics_md = key_metrics.md
+        self.key_metrics_table = key_metrics.table
         self.key_metrics_chart = key_metrics.chart
 
         # explore predictions
@@ -143,15 +144,14 @@ class SemanticSegmentationVisualizer(BaseVisualizer):
         self.acknowledgement_md = acknowledgement.md
 
         # SpeedTest
-        self.speedtest_present = False
-        self.speedtest_multiple_batch_sizes = False
         speedtest = Speedtest(self.vis_texts, self.eval_result)
-        if not speedtest.is_empty():
-            self.speedtest_present = True
+        self.speedtest_present = not speedtest.is_empty()
+        self.speedtest_multiple_batch_sizes = False
+        if self.speedtest_present:
             self.speedtest_md_intro = speedtest.intro_md
             self.speedtest_intro_table = speedtest.intro_table
-            if speedtest.multiple_batche_sizes():
-                self.speedtest_multiple_batch_sizes = True
+            self.speedtest_multiple_batch_sizes = speedtest.multiple_batche_sizes()
+            if self.speedtest_multiple_batch_sizes:
                 self.speedtest_batch_inference_md = speedtest.batch_size_md
                 self.speedtest_chart = speedtest.chart
 
@@ -166,6 +166,7 @@ class SemanticSegmentationVisualizer(BaseVisualizer):
             (0, self.header),
             (1, self.overview_md),
             (1, self.key_metrics_md),
+            (0, self.key_metrics_table),
             (0, self.key_metrics_chart),
             (1, self.explore_predictions_md),
             (0, self.explore_predictions_gallery),

supervisely/nn/benchmark/utils/semantic_segmentation/evaluator.py

@@ -63,29 +63,11 @@ class Evaluator:
         :param boundary_implementation: Choose "exact" for the euclidean pixel distance.
             The Boundary IoU paper uses the L1 distance ("fast").
         """
-        global torch, np, GPU
+        global torch, np, GPU, numpy
         import torch  # pylint: disable=import-error
 
-        if torch.cuda.is_available():
-            GPU = True
-            logger.info("Using GPU for evaluation.")
-            try:
-                # gpu-compatible numpy analogue
-                import cupy as np  # pylint: disable=import-error
-
-                global numpy
-                import numpy as numpy
-            except:
-                logger.warning(
-                    "Failed to import cupy. Use cupy official documentation to install this "
-                    "module: https://docs.cupy.dev/en/stable/install.html"
-                )
-        else:
-            GPU = False
-            import numpy as np
-
-            global numpy
-            numpy = np
+        numpy = np
+        GPU = False
 
         self.progress = progress or tqdm_sly
         self.class_names = class_names

supervisely/nn/benchmark/visualization/renderer.py

@@ -20,6 +20,7 @@ class Renderer:
         layout: BaseWidget,
         base_dir: str = "./output",
         template: str = None,
+        report_name: str = "Model Evaluation Report.lnk",
     ) -> None:
         if template is None:
             template = (
@@ -28,6 +29,9 @@ class Renderer:
         self.main_template = template
         self.layout = layout
         self.base_dir = base_dir
+        self.report_name = report_name
+        self._report = None
+        self._lnk = None
 
         if Path(base_dir).exists():
             if not dir_empty(base_dir):
@@ -81,20 +85,31 @@ class Renderer:
                 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")
+        src = self._save_report_link(api, team_id, remote_dir)
+        dst = Path(remote_dir).joinpath(self.report_name)
+        self._lnk = api.file.upload(team_id=team_id, src=src, dst=str(dst))
         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")
+    def _save_report_link(self, api: Api, team_id: int, remote_dir: str):
+        report_link = self._get_report_path(api, team_id, remote_dir)
+        pth = Path(self.base_dir).joinpath(self.report_name)
         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)
+    def _get_report_link(self, api: Api, team_id: int, remote_dir: str):
+        path = self._get_report_path(api, team_id, remote_dir)
+        return f"{api.server_address}{path}"
 
-        report_link = "/model-benchmark?id=" + str(vue_template_info.id)
-        return report_link
+    def _get_report_path(self, api: Api, team_id: int, remote_dir: str):
+        template_path = Path(remote_dir).joinpath("template.vue")
+        self._report = api.file.get_info_by_path(team_id, str(template_path))
+        return "/model-benchmark?id=" + str(self._report.id)
+
+    @property
+    def report(self):
+        return self._report
+
+    @property
+    def lnk(self):
+        return self._lnk

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

@@ -79,6 +79,7 @@ class GalleryWidget(BaseWidget):
                 column_index=idx % self.columns_number,
                 project_meta=project_metas[idx % self.columns_number],
                 ignore_tags_filtering=skip_tags_filtering[idx % self.columns_number],
+                call_update=idx == len(image_infos) - 1,
             )
 
     def _get_init_data(self):

supervisely/nn/inference/inference.py

@@ -133,6 +133,7 @@ class Inference:
             if self.INFERENCE_SETTINGS is not None:
                 custom_inference_settings = self.INFERENCE_SETTINGS
             else:
+                logger.debug("Custom inference settings are not provided.")
                 custom_inference_settings = {}
         if isinstance(custom_inference_settings, str):
             if fs.file_exists(custom_inference_settings):

supervisely/nn/training/gui/gui.py

@@ -14,6 +14,7 @@ from supervisely.nn.training.gui.hyperparameters_selector import Hyperparameters
 from supervisely.nn.training.gui.input_selector import InputSelector
 from supervisely.nn.training.gui.model_selector import ModelSelector
 from supervisely.nn.training.gui.train_val_splits_selector import TrainValSplitsSelector
+from supervisely.nn.training.gui.training_artifacts import TrainingArtifacts
 from supervisely.nn.training.gui.training_logs import TrainingLogs
 from supervisely.nn.training.gui.training_process import TrainingProcess
 from supervisely.nn.training.gui.utils import set_stepper_step, wrap_button_click
@@ -50,7 +51,9 @@ class TrainGUI:
         if is_production():
             self.task_id = sly_env.task_id()
         else:
-            self.task_id = "debug-session"
+            self.task_id = sly_env.task_id(raise_not_found=False)
+            if self.task_id is None:
+                self.task_id = "debug-session"
 
         self.framework_name = framework_name
         self.models = models
@@ -86,17 +89,22 @@ class TrainGUI:
         # 7. Training logs
         self.training_logs = TrainingLogs(self.app_options)
 
+        # 8. Training Artifacts
+        self.training_artifacts = TrainingArtifacts(self.app_options)
+
         # Stepper layout
+        self.steps = [
+            self.input_selector.card,
+            self.train_val_splits_selector.card,
+            self.classes_selector.card,
+            self.model_selector.card,
+            self.hyperparameters_selector.card,
+            self.training_process.card,
+            self.training_logs.card,
+            self.training_artifacts.card,
+        ]
         self.stepper = Stepper(
-            widgets=[
-                self.input_selector.card,
-                self.train_val_splits_selector.card,
-                self.classes_selector.card,
-                self.model_selector.card,
-                self.hyperparameters_selector.card,
-                self.training_process.card,
-                self.training_logs.card,
-            ],
+            widgets=self.steps,
         )
         # ------------------------------------------------- #
 
@@ -265,6 +273,20 @@ class TrainGUI:
 
         self.layout: Widget = self.stepper
 
+    def set_next_step(self):
+        current_step = self.stepper.get_active_step()
+        self.stepper.set_active_step(current_step + 1)
+
+    def set_previous_step(self):
+        current_step = self.stepper.get_active_step()
+        self.stepper.set_active_step(current_step - 1)
+
+    def set_first_step(self):
+        self.stepper.set_active_step(1)
+
+    def set_last_step(self):
+        self.stepper.set_active_step(len(self.steps))
+
     def enable_select_buttons(self):
         """
         Makes all select buttons in the GUI available for interaction.