supervisely 6.73.419__py3-none-any.whl → 6.73.421__py3-none-any.whl

supervisely/app/widgets/select_dataset_tree/select_dataset_tree.py

@@ -141,6 +141,10 @@ class SelectDatasetTree(Widget):
         self._select_dataset = None
         self._width = width
 
+        # Flags
+        self._team_is_selectable = team_is_selectable
+        self._workspace_is_selectable = workspace_is_selectable
+
         # List of widgets will be used to create a Container.
         self._widgets = []
 
@@ -165,11 +169,25 @@ class SelectDatasetTree(Widget):
         for widget in self._widgets:
             widget.disable()
 
+        if hasattr(self, "_select_team"):
+            if not self._team_is_selectable:
+                self._select_team.disable()
+        if hasattr(self, "_select_workspace"):
+            if not self._workspace_is_selectable:
+                self._select_workspace.disable()
+
     def enable(self) -> None:
         """Enable the widget in the UI."""
         for widget in self._widgets:
             widget.enable()
 
+        if hasattr(self, "_select_team"):
+            if not self._team_is_selectable:
+                self._select_team.disable()
+        if hasattr(self, "_select_workspace"):
+            if not self._workspace_is_selectable:
+                self._select_workspace.disable()
+
     @property
     def team_id(self) -> int:
         """The ID of the team selected in the widget.

supervisely/app/widgets/tabs/tabs.py

@@ -1,9 +1,10 @@
-from typing import List, Optional, Dict
-from supervisely.app import StateJson
-from supervisely.app.widgets import Widget
 import traceback
-from supervisely import logger
+from typing import Dict, List, Optional
 
+from supervisely import logger
+from supervisely.app import StateJson
+from supervisely.app.content import DataJson
+from supervisely.app.widgets import Widget
 
 try:
     from typing import Literal
@@ -34,7 +35,7 @@ class Tabs(Widget):
             raise ValueError("You can specify up to 10 tabs.")
         if len(set(labels)) != len(labels):
             raise ValueError("All of tab labels should be unique.")
-        self._items = []
+        self._items: List[Tabs.TabPane] = []
         for label, widget in zip(labels, contents):
             self._items.append(Tabs.TabPane(label=label, content=widget))
         self._value = labels[0]
@@ -43,7 +44,10 @@ class Tabs(Widget):
         super().__init__(widget_id=widget_id, file_path=__file__)
 
     def get_json_data(self) -> Dict:
-        return {"type": self._type}
+        return {
+            "type": self._type,
+            "tabsOptions": {item.name: {"disabled": False} for item in self._items},
+        }
 
     def get_json_state(self) -> Dict:
         return {"value": self._value}
@@ -56,6 +60,18 @@ class Tabs(Widget):
     def get_active_tab(self) -> str:
         return StateJson()[self.widget_id]["value"]
 
+    def disable_tab(self, tab_name: str):
+        if tab_name not in [item.name for item in self._items]:
+            raise ValueError(f"Tab with name '{tab_name}' does not exist.")
+        DataJson()[self.widget_id]["tabsOptions"][tab_name]["disabled"] = True
+        DataJson().send_changes()
+
+    def enable_tab(self, tab_name: str):
+        if tab_name not in [item.name for item in self._items]:
+            raise ValueError(f"Tab with name '{tab_name}' does not exist.")
+        DataJson()[self.widget_id]["tabsOptions"][tab_name]["disabled"] = False
+        DataJson().send_changes()
+
     def click(self, func):
         route_path = self.get_route_path(Tabs.Routes.CLICK)
         server = self._sly_app.get_server()

supervisely/app/widgets/tabs/template.html

@@ -11,7 +11,11 @@
   %}
 >
   {% for tab_pane in widget._items %}
-  <el-tab-pane label="{{{tab_pane.label}}}" name="{{{tab_pane.name}}}">
+  <el-tab-pane
+    label="{{{tab_pane.label}}}"
+    name="{{{tab_pane.name}}}"
+    :disabled="data.{{{widget.widget_id}}}.tabsOptions['{{{tab_pane.name}}}'].disabled"
+  >
     {{{ tab_pane.content }}}
   </el-tab-pane>
   {% endfor %}

supervisely/nn/artifacts/__init__.py

@@ -1,6 +1,6 @@
 from supervisely.nn.artifacts.detectron2 import Detectron2
 from supervisely.nn.artifacts.hrda import HRDA
-from supervisely.nn.artifacts.mmclassification import MMClassification
+from supervisely.nn.artifacts.mmclassification import MMClassification, MMPretrain
 from supervisely.nn.artifacts.mmdetection import MMDetection, MMDetection3
 from supervisely.nn.artifacts.mmsegmentation import MMSegmentation
 from supervisely.nn.artifacts.ritm import RITM

supervisely/nn/artifacts/artifacts.py

@@ -68,6 +68,7 @@ class BaseTrainArtifacts:
         self._pattern: str = None
         self._available_task_types: List[str] = []
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     @property
     def team_id(self) -> int:
@@ -209,6 +210,13 @@ class BaseTrainArtifacts:
         """
         return self._require_runtime
 
+    @property
+    def has_benchmark_evaluation(self):
+        """
+        Whether the framework has integrated benchmark evaluation.
+        """
+        return self._has_benchmark_evaluation
+
     def is_valid_artifacts_path(self, path):
         """
         Check if the provided path is valid and follows specified session path pattern.
@@ -610,9 +618,9 @@ class BaseTrainArtifacts:
             date_time = parsed_datetime.strftime("%Y-%m-%d %H:%M:%S")
 
             experiment_info_data = {
-                "experiment_name": f"Unknown {self.framework_name} experiment",
+                "experiment_name": f"{self.framework_name} experiment",
                 "framework_name": self.framework_name,
-                "model_name": f"Unknown {self.framework_name} model",
+                "model_name": f"{self.framework_name} model",
                 "task_type": train_info.task_type,
                 "project_id": project_id,
                 "task_id": train_info.task_id,

supervisely/nn/artifacts/detectron2.py

@@ -25,6 +25,7 @@ class Detectron2(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/detectron2/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["instance segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/artifacts/hrda.py

@@ -20,6 +20,7 @@ class HRDA(BaseTrainArtifacts):
         # self._config_file = "config.py"
         # self._available_task_types: List[str] = ["semantic segmentation"]
         # self._require_runtime = False
+        # self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         raise NotImplementedError

supervisely/nn/artifacts/mmclassification.py

@@ -21,6 +21,7 @@ class MMClassification(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmclassification/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["classification"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")
@@ -44,3 +45,22 @@ class MMClassification(BaseTrainArtifacts):
 
     def get_config_path(self, artifacts_folder: str) -> str:
         return None
+
+
+class MMPretrain(MMClassification):
+    def __init__(self, team_id: int):
+        super().__init__(team_id)
+
+        self._app_name = "Train MMPretrain"
+        self._slug = "supervisely-ecosystem/mmpretrain/supervisely/train"
+        self._serve_app_name = "Serve MMPretrain"
+        self._serve_slug = "supervisely-ecosystem/mmpretrain/supervisely/serve"
+        self._framework_name = "MMPretrain"
+        self._framework_folder = "/mmclassification-v2"
+        self._weights_folder = "checkpoints"
+        self._task_type = "classification"
+        self._weights_ext = ".pth"
+        self._pattern = re_compile(r"^/mmclassification-v2/\d+_[^/]+/?$")
+        self._available_task_types: List[str] = ["classification"]
+        self._require_runtime = False
+        self._has_benchmark_evaluation = False

supervisely/nn/artifacts/mmdetection.py

@@ -26,6 +26,7 @@ class MMDetection(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmdetection/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["object detection", "instance segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")
@@ -63,8 +64,8 @@ class MMDetection3(BaseTrainArtifacts):
         super().__init__(team_id)
 
         self._app_name = "Train MMDetection 3.0"
-        self._slug = "Serve MMDetection 3.0"
-        self._serve_app_name = "supervisely-ecosystem/train-mmdetection-v3"
+        self._slug = "supervisely-ecosystem/train-mmdetection-v3"
+        self._serve_app_name = "Serve MMDetection 3.0"
         self._serve_slug = "supervisely-ecosystem/serve-mmdetection-v3"
         self._framework_name = "MMDetection 3.0"
         self._framework_folder = "/mmdetection-3"
@@ -75,7 +76,8 @@ class MMDetection3(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmdetection-3/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["object detection", "instance segmentation"]
         self._require_runtime = False
-        
+        self._has_benchmark_evaluation = True
+
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")
         if len(parts) < 3:

supervisely/nn/artifacts/mmsegmentation.py

@@ -22,6 +22,7 @@ class MMSegmentation(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/mmsegmentation/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["instance segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         return artifacts_folder.split("/")[2].split("_")[0]

supervisely/nn/artifacts/ritm.py

@@ -22,6 +22,7 @@ class RITM(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/RITM_training/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["interactive segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/artifacts/rtdetr.py

@@ -22,6 +22,7 @@ class RTDETR(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/RT-DETR/[^/]+/\d+/?$")
         self._available_task_types: List[str] = ["object detection"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         return artifacts_folder.split("/")[-1]

supervisely/nn/artifacts/unet.py

@@ -22,6 +22,7 @@ class UNet(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/unet/\d+_[^/]+/?$")
         self._available_task_types: List[str] = ["semantic segmentation"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/artifacts/utils.py

@@ -4,6 +4,7 @@ from supervisely.nn.artifacts import (
     YOLOv5v2,
     YOLOv8,
     MMClassification,
+    MMPretrain,
     MMSegmentation,
     MMDetection,
     MMDetection3,
@@ -19,6 +20,7 @@ class FrameworkName:
     YOLOV5V2 = "YOLOv5 2.0"
     YOLOV8 = "YOLOv8+"
     MMCLASSIFICATION = "MMClassification"
+    MMPRETRAIN = "MMPretrain"
     MMSEGMENTATION = "MMSegmentation"
     MMDETECTION = "MMDetection"
     MMDETECTION3 = "MMDetection 3.0"
@@ -34,6 +36,7 @@ class FrameworkMapper:
         FrameworkName.YOLOV5V2: YOLOv5v2,
         FrameworkName.YOLOV8: YOLOv8,
         FrameworkName.MMCLASSIFICATION: MMClassification,
+        FrameworkName.MMPRETRAIN: MMPretrain,
         FrameworkName.MMSEGMENTATION: MMSegmentation,
         FrameworkName.MMDETECTION: MMDetection,
         FrameworkName.MMDETECTION3: MMDetection3,

supervisely/nn/artifacts/yolov5.py

@@ -22,6 +22,7 @@ class YOLOv5(BaseTrainArtifacts):
         self._pattern = re_compile(r"^/yolov5_train/[^/]+/\d+/?$")
         self._available_task_types: List[str] = ["object detection"]
         self._require_runtime = False
+        self._has_benchmark_evaluation = False
 
     def get_task_id(self, artifacts_folder: str) -> str:
         return artifacts_folder.split("/")[-1]
@@ -55,3 +56,4 @@ class YOLOv5v2(YOLOv5):
         self._config_file = None
         self._pattern = re_compile(r"^/yolov5_2.0_train/[^/]+/\d+/?$")
         self._available_task_types: List[str] = ["object detection"]
+        self._has_benchmark_evaluation = False

supervisely/nn/artifacts/yolov8.py

@@ -28,6 +28,7 @@ class YOLOv8(BaseTrainArtifacts):
             "pose estimation",
         ]
         self._require_runtime = True
+        self._has_benchmark_evaluation = True
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/benchmark/semantic_segmentation/metric_provider.py

@@ -70,24 +70,24 @@ class MetricProvider:
 
     def json_metrics(self):
         return {
-            "mIoU": self.eval_data.loc["mean"]["IoU"] * 100,
-            "mE_boundary_oU": self.eval_data.loc["mean"]["E_boundary_oU"] * 100,
-            "mFP_boundary_oU": self.eval_data.loc["mean"]["FP_boundary_oU"] * 100,
-            "mFN_boundary_oU": self.eval_data.loc["mean"]["FN_boundary_oU"] * 100,
-            "mE_boundary_oU_renormed": self.eval_data.loc["mean"]["E_boundary_oU_renormed"] * 100,
-            "mE_extent_oU": self.eval_data.loc["mean"]["E_extent_oU"] * 100,
-            "mFP_extent_oU": self.eval_data.loc["mean"]["FP_extent_oU"] * 100,
-            "mFN_extent_oU": self.eval_data.loc["mean"]["FN_extent_oU"] * 100,
-            "mE_extent_oU_renormed": self.eval_data.loc["mean"]["E_extent_oU_renormed"] * 100,
-            "mE_segment_oU": self.eval_data.loc["mean"]["E_segment_oU"] * 100,
-            "mFP_segment_oU": self.eval_data.loc["mean"]["FP_segment_oU"] * 100,
-            "mFN_segment_oU": self.eval_data.loc["mean"]["FN_segment_oU"] * 100,
-            "mE_segment_oU_renormed": self.eval_data.loc["mean"]["E_segment_oU_renormed"] * 100,
-            "mPrecision": self.eval_data.loc["mean"]["precision"] * 100,
-            "mRecall": self.eval_data.loc["mean"]["recall"] * 100,
-            "mF1_score": self.eval_data.loc["mean"]["F1_score"] * 100,
-            "PixelAcc": self.pixel_accuracy * 100,
-            "mBoundaryIoU": self.eval_data.loc["mean"]["boundary_IoU"] * 100,
+            "mIoU": self.eval_data.loc["mean"]["IoU"],
+            "mE_boundary_oU": self.eval_data.loc["mean"]["E_boundary_oU"],
+            "mFP_boundary_oU": self.eval_data.loc["mean"]["FP_boundary_oU"],
+            "mFN_boundary_oU": self.eval_data.loc["mean"]["FN_boundary_oU"],
+            "mE_boundary_oU_renormed": self.eval_data.loc["mean"]["E_boundary_oU_renormed"],
+            "mE_extent_oU": self.eval_data.loc["mean"]["E_extent_oU"],
+            "mFP_extent_oU": self.eval_data.loc["mean"]["FP_extent_oU"],
+            "mFN_extent_oU": self.eval_data.loc["mean"]["FN_extent_oU"],
+            "mE_extent_oU_renormed": self.eval_data.loc["mean"]["E_extent_oU_renormed"],
+            "mE_segment_oU": self.eval_data.loc["mean"]["E_segment_oU"],
+            "mFP_segment_oU": self.eval_data.loc["mean"]["FP_segment_oU"],
+            "mFN_segment_oU": self.eval_data.loc["mean"]["FN_segment_oU"],
+            "mE_segment_oU_renormed": self.eval_data.loc["mean"]["E_segment_oU_renormed"],
+            "mPrecision": self.eval_data.loc["mean"]["precision"],
+            "mRecall": self.eval_data.loc["mean"]["recall"],
+            "mF1_score": self.eval_data.loc["mean"]["F1_score"],
+            "PixelAcc": self.pixel_accuracy,
+            "mBoundaryIoU": self.eval_data.loc["mean"]["boundary_IoU"],
         }
 
     def metric_table(self):

supervisely/nn/experiments.py

@@ -54,6 +54,8 @@ class ExperimentInfo:
     """Number of images in the validation set"""
     datetime: Optional[str] = None
     """Date and time when the experiment was started"""
+    experiment_report_id: Optional[int] = None
+    """ID of the experiment report"""
     evaluation_report_id: Optional[int] = None
     """ID of the model benchmark evaluation report"""
     evaluation_report_link: Optional[str] = None
@@ -62,6 +64,12 @@ class ExperimentInfo:
     """Evaluation metrics"""
     logs: Optional[dict] = None
     """Dictionary with link and type of logger"""
+    train_collection_id: Optional[int] = None
+    """ID of the collection with train images"""
+    val_collection_id: Optional[int] = None
+    """ID of the collection with validation images"""
+    project_version: Optional[int] = None
+    """Version of the project"""
 
     def __init__(self, **kwargs):
         required_fieds = {
@@ -82,6 +90,7 @@ class ExperimentInfo:
         for field in fields(self.__class__):
             value = getattr(self, field.name)
             data[field.name] = value
+        return data
 
 
 def get_experiment_infos(api: Api, team_id: int, framework_name: str) -> List[ExperimentInfo]:

supervisely/nn/inference/gui/serving_gui_template.py

@@ -1,3 +1,4 @@
+import os
 from os.path import join
 from typing import Any, Dict, List, Optional, Union
 
@@ -7,14 +8,25 @@ import supervisely.io.env as sly_env
 import supervisely.io.fs as sly_fs
 import supervisely.io.json as sly_json
 from supervisely import Api
-from supervisely.app.widgets import Card, Container, Field, RadioTabs, SelectString, Text, Widget
-from supervisely.app.widgets.experiment_selector.experiment_selector import ExperimentSelector
+from supervisely.app.widgets import (
+    Card,
+    Container,
+    Field,
+    RadioTabs,
+    SelectString,
+    Text,
+    Widget,
+)
+from supervisely.app.widgets.experiment_selector.experiment_selector import (
+    ExperimentSelector,
+)
 from supervisely.app.widgets.pretrained_models_selector.pretrained_models_selector import (
     PretrainedModelsSelector,
 )
 from supervisely.nn.experiments import get_experiment_infos
 from supervisely.nn.inference.gui.serving_gui import ServingGUI
 from supervisely.nn.utils import ModelSource, RuntimeType, _get_model_name
+from supervisely.nn.experiments import ExperimentInfo
 
 
 class ServingGUITemplate(ServingGUI):
@@ -67,7 +79,7 @@ class ServingGUITemplate(ServingGUI):
         # Custom models
         if use_custom_models:
             experiments = get_experiment_infos(self.api, self.team_id, self.framework_name)
-            self.experiment_selector = ExperimentSelector(self.team_id, experiments)
+            self.experiment_selector = ExperimentSelector(self.api, self.team_id, experiments)
         else:
             self.experiment_selector = None
 
@@ -132,11 +144,13 @@ class ServingGUITemplate(ServingGUI):
 
         if self.runtime_select is not None:
             self.runtime_select.value_changed(lambda _: self._update_export_message())
+
         if self.experiment_selector is not None:
-            self.experiment_selector.value_changed(lambda _: self._update_export_message())
-            for task_type in self.experiment_selector.rows:
-                for row in self.experiment_selector.rows[task_type]:
-                    row.checkpoints_selector.value_changed(lambda _: self._update_export_message())
+            self.experiment_selector.selection_changed(lambda _: self._update_export_message())
+            self.experiment_selector.checkpoint_changed(
+                lambda row, _: self._update_export_message()
+            )
+
         if self.pretrained_models_table is not None:
             self.pretrained_models_table.model_changed(lambda _: self._update_export_message())
 
@@ -156,7 +170,12 @@ class ServingGUITemplate(ServingGUI):
 
     @property
     def model_info(self) -> Dict[str, Any]:
-        return self._get_selected_row()
+        model_info = self._get_selected_row()
+        if isinstance(model_info, ExperimentInfo):
+            # model info requires json format
+            # to match types of pretrained and custom model info
+            model_info = model_info.to_json()
+        return model_info
 
     @property
     def model_name(self) -> Optional[str]:
@@ -171,7 +190,14 @@ class ServingGUITemplate(ServingGUI):
             model_meta = self.model_info.get("meta", {})
             return model_meta.get("model_files", {})
         else:
-            return self.experiment_selector.get_model_files()
+            experiment_info = self.experiment_selector.get_selected_experiment_info()
+            artifacts_dir = experiment_info.artifacts_dir
+            model_files = experiment_info.model_files
+            full_model_files = {
+                name: os.path.join(artifacts_dir, file) for name, file in model_files.items()
+            }
+            full_model_files["checkpoint"] = self.experiment_selector.get_selected_checkpoint_path()
+            return full_model_files
 
     @property
     def runtime(self) -> str:
@@ -235,10 +261,10 @@ class ServingGUITemplate(ServingGUI):
 
         checkpoint_name = None
         if self.model_source == ModelSource.CUSTOM and self.experiment_selector is not None:
-            selected_row = self.experiment_selector.get_selected_row()
-            if selected_row is None:
+            selected_experiment_info = self.experiment_selector.get_selected_experiment_info()
+            if selected_experiment_info is None:
                 return
-            checkpoint_name = selected_row.get_selected_checkpoint_name()
+            checkpoint_name = self.experiment_selector.get_selected_checkpoint_name()
             if checkpoint_name is None:
                 return
 
@@ -250,7 +276,7 @@ class ServingGUITemplate(ServingGUI):
                 if key.lower().startswith(runtime.lower()):
                     available = True
                     break
-            if checkpoint_name != selected_row.best_checkpoint:
+            if checkpoint_name != selected_experiment_info.best_checkpoint:
                 available = False
 
         if available: