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

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.

supervisely/nn/training/gui/training_artifacts.py

@@ -0,0 +1,145 @@
+from typing import Any, Dict
+
+from supervisely import Api
+from supervisely.app.widgets import (
+    Card,
+    Container,
+    Empty,
+    Field,
+    Flexbox,
+    FolderThumbnail,
+    ReportThumbnail,
+    Text,
+)
+
+PYTORCH_ICON = "https://img.icons8.com/?size=100&id=jH4BpkMnRrU5&format=png&color=000000"
+ONNX_ICON = "https://artwork.lfaidata.foundation/projects/onnx/icon/color/onnx-icon-color.png"
+TRT_ICON = "https://img.icons8.com/?size=100&id=yqf95864UzeQ&format=png&color=000000"
+
+
+class TrainingArtifacts:
+    title = "Training Artifacts"
+    description = "All outputs of the training process will appear here"
+    lock_message = "Artifacts will be available after training is completed"
+
+    def __init__(self, app_options: Dict[str, Any]):
+        self.display_widgets = []
+        self.success_message_text = (
+            "Training completed. Training artifacts were uploaded to Team Files. "
+            "You can find and open tensorboard logs in the artifacts folder via the "
+            "<a href='https://ecosystem.supervisely.com/apps/tensorboard-logs-viewer' target='_blank'>Tensorboard</a> app."
+        )
+        self.app_options = app_options
+
+        # GUI Components
+        self.validator_text = Text("")
+        self.validator_text.hide()
+        self.display_widgets.extend([self.validator_text])
+
+        # Outputs
+        self.artifacts_thumbnail = FolderThumbnail()
+        self.artifacts_thumbnail.hide()
+
+        self.artifacts_field = Field(
+            title="Artifacts",
+            description="Contains all outputs of the training process",
+            content=self.artifacts_thumbnail,
+        )
+        self.artifacts_field.hide()
+        self.display_widgets.extend([self.artifacts_field])
+
+        # Optional Model Benchmark
+        if app_options.get("model_benchmark", False):
+            self.model_benchmark_report_thumbnail = ReportThumbnail()
+            self.model_benchmark_report_thumbnail.hide()
+
+            self.model_benchmark_fail_text = Text(
+                text="Model evaluation did not finish successfully. Please check the app logs for details.",
+                status="error",
+            )
+            self.model_benchmark_fail_text.hide()
+
+            self.model_benchmark_widgets = Container(
+                [self.model_benchmark_report_thumbnail, self.model_benchmark_fail_text]
+            )
+
+            self.model_benchmark_report_field = Field(
+                title="Model Benchmark",
+                description="Evaluation report of the trained model",
+                content=self.model_benchmark_widgets,
+            )
+            self.model_benchmark_report_field.hide()
+            self.display_widgets.extend([self.model_benchmark_report_field])
+        # -------------------------------- #
+
+        # PyTorch, ONNX, TensorRT demo
+        self.inference_demo_field = []
+        model_demo = self.app_options.get("demo", None)
+        if model_demo is not None:
+            pytorch_demo_link = model_demo.get("pytorch", None)
+            if pytorch_demo_link is not None:
+                pytorch_icon = Field.Icon(image_url=PYTORCH_ICON, bg_color_rgb=[255, 255, 255])
+                self.pytorch_instruction = Field(
+                    title="PyTorch",
+                    description="Open file",
+                    description_url=pytorch_demo_link,
+                    icon=pytorch_icon,
+                    content=Empty(),
+                )
+                self.pytorch_instruction.hide()
+                self.inference_demo_field.extend([self.pytorch_instruction])
+
+            onnx_demo_link = model_demo.get("onnx", None)
+            if onnx_demo_link is not None:
+                if self.app_options.get("export_onnx_supported", False):
+                    onnx_icon = Field.Icon(image_url=ONNX_ICON, bg_color_rgb=[255, 255, 255])
+                    self.onnx_instruction = Field(
+                        title="ONNX",
+                        description="Open file",
+                        description_url=onnx_demo_link,
+                        icon=onnx_icon,
+                        content=Empty(),
+                    )
+                    self.onnx_instruction.hide()
+                    self.inference_demo_field.extend([self.onnx_instruction])
+
+            trt_demo_link = model_demo.get("tensorrt", None)
+            if trt_demo_link is not None:
+                if self.app_options.get("export_tensorrt_supported", False):
+                    trt_icon = Field.Icon(image_url=TRT_ICON, bg_color_rgb=[255, 255, 255])
+                    self.trt_instruction = Field(
+                        title="TensorRT",
+                        description="Open file",
+                        description_url=trt_demo_link,
+                        icon=trt_icon,
+                        content=Empty(),
+                    )
+                    self.trt_instruction.hide()
+                    self.inference_demo_field.extend([self.trt_instruction])
+
+            demo_overview_link = model_demo.get("overview", None)
+            self.inference_demo_field = Field(
+                title="How to run inference",
+                description="Instructions on how to use your checkpoints outside of Supervisely Platform",
+                content=Flexbox(self.inference_demo_field),
+                title_url=demo_overview_link,
+            )
+            self.inference_demo_field.hide()
+            self.display_widgets.extend([self.inference_demo_field])
+        # -------------------------------- #
+
+        self.container = Container(self.display_widgets)
+        self.card = Card(
+            title=self.title,
+            description=self.description,
+            content=self.container,
+            lock_message=self.lock_message,
+        )
+        self.card.lock()
+
+    @property
+    def widgets_to_disable(self) -> list:
+        return []
+
+    def validate_step(self) -> bool:
+        return True

supervisely/nn/training/gui/training_process.py

@@ -23,23 +23,18 @@ class TrainingProcess:
 
     def __init__(self, app_options: Dict[str, Any]):
         self.display_widgets = []
-        self.success_message_text = (
-            "Training completed. Training artifacts were uploaded to Team Files. "
-            "You can find and open tensorboard logs in the artifacts folder via the "
-            "<a href='https://ecosystem.supervisely.com/apps/tensorboard-logs-viewer' target='_blank'>Tensorboard</a> app."
-        )
         self.app_options = app_options
 
         # GUI Components
         # Optional Select CUDA device
         if self.app_options.get("device_selector", False):
             self.select_device = SelectCudaDevice()
-            self.select_cuda_device_field = Field(
+            self.select_device_field = Field(
                 title="Select CUDA device",
                 description="The device on which the model will be trained",
                 content=self.select_device,
             )
-            self.display_widgets.extend([self.select_cuda_device_field])
+            self.display_widgets.extend([self.select_device_field])
         # -------------------------------- #
 
         self.experiment_name_input = Input("Enter experiment name")
@@ -63,26 +58,15 @@ class TrainingProcess:
         self.validator_text = Text("")
         self.validator_text.hide()
 
-        self.artifacts_thumbnail = FolderThumbnail()
-        self.artifacts_thumbnail.hide()
-
         self.display_widgets.extend(
             [
                 self.experiment_name_field,
                 button_container,
                 self.validator_text,
-                self.artifacts_thumbnail,
             ]
         )
         # -------------------------------- #
 
-        # Optional Model Benchmark
-        if app_options.get("model_benchmark", False):
-            self.model_benchmark_report_thumbnail = ReportThumbnail()
-            self.model_benchmark_report_thumbnail.hide()
-            self.display_widgets.extend([self.model_benchmark_report_thumbnail])
-        # -------------------------------- #
-
         self.container = Container(self.display_widgets)
         self.card = Card(
             title=self.title,
@@ -96,7 +80,7 @@ class TrainingProcess:
     def widgets_to_disable(self) -> list:
         widgets = [self.experiment_name_input]
         if self.app_options.get("device_selector", False):
-            widgets.append(self.experiment_name_input)
+            widgets.extend([self.select_device, self.select_device_field])
         return widgets
 
     def validate_step(self) -> bool: