supervisely 6.73.242__py3-none-any.whl → 6.73.244__py3-none-any.whl

supervisely/nn/artifacts/yolov8.py

@@ -1,5 +1,6 @@
 from os.path import join
 from re import compile as re_compile
+from typing import List
 
 from supervisely.nn.artifacts.artifacts import BaseTrainArtifacts
 
@@ -8,7 +9,7 @@ class YOLOv8(BaseTrainArtifacts):
     def __init__(self, team_id: int):
         super().__init__(team_id)
 
-        self._app_name = "Train YOLOv8"
+        self._app_name = "Train YOLOv8 | v9 | v10 | v11"
         self._framework_folder = "/yolov8_train"
         self._weights_folder = "weights"
         self._task_type = None
@@ -17,6 +18,11 @@ class YOLOv8(BaseTrainArtifacts):
         self._pattern = re_compile(
             r"^/yolov8_train/(object detection|instance segmentation|pose estimation)/[^/]+/\d+/?$"
         )
+        self._available_task_types: List[str] = [
+            "object detection",
+            "instance segmentation",
+            "pose estimation",
+        ]
 
     def get_task_id(self, artifacts_folder: str) -> str:
         parts = artifacts_folder.split("/")

supervisely/nn/experiments.py

@@ -0,0 +1,113 @@
+from concurrent.futures import ThreadPoolExecutor
+from json import JSONDecodeError
+from os.path import dirname, join
+from typing import Any, Dict, List, NamedTuple
+
+import requests
+
+from supervisely import logger
+from supervisely.api.api import Api, ApiField
+
+
+class ExperimentInfo(NamedTuple):
+    experiment_name: str
+    """Name of the experiment. Defined by the user in the training app"""
+    framework_name: str
+    """Name of the framework used in the experiment"""
+    model_name: str
+    """Name of the model used in the experiment. Defined by the user in the training app"""
+    task_type: str
+    """Task type of the experiment"""
+    project_id: int
+    """Project ID in Supervisely"""
+    task_id: int
+    """Task ID in Supervisely"""
+    model_files: Dict[str, str]
+    """Dictionary with paths to model files that needs to be downloaded for training"""
+    checkpoints: List[str]
+    """List of relative paths to checkpoints"""
+    best_checkpoint: str
+    """Name of the best checkpoint. Defined by the user in the training app"""
+    app_state: str
+    """Path to file with settings that were used in the app"""
+    model_meta: str
+    """Path to file with model metadata such as model name, project id, project name and classes used for training"""
+    train_val_split: str
+    """Path to train and validation splits, which contains IDs of the images used in each split"""
+    hyperparameters: str
+    """Path to .yaml file with hyperparameters used in the experiment"""
+    artifacts_dir: str
+    """Path to the directory with artifacts"""
+    datetime: str
+    """Date and time when the experiment was started"""
+    evaluation_report_id: int
+    """ID of the evaluation report"""
+    eval_metrics: Dict[str, Any]
+    """Evaluation metrics"""
+
+
+def get_experiment_infos(api: Api, team_id: int, framework_name: str) -> List[ExperimentInfo]:
+    """
+    Get experiments from the specified framework folder for Train v2
+
+    :param api: Supervisely API client
+    :type api: Api
+    :param team_id: Team ID
+    :type team_id: int
+    :param framework_name: Name of the framework
+    :type framework_name: str
+    :return: List of ExperimentInfo objects
+    :rtype: List[ExperimentInfo]
+    :Usage example:
+
+     .. code-block:: python
+
+        import supervisely as sly
+
+        api = sly.Api.from_env()
+        team_id = sly.env.team_id()
+        framework_name = "rt-detr"
+        experiment_infos = sly.nn.training.experiments.get_experiment_infos(api, team_id, framework_name)
+    """
+    metadata_name = "experiment_info.json"
+    experiments_folder = "/experiments"
+    experiment_infos = []
+
+    file_infos = api.file.list(team_id, experiments_folder, recursive=True, return_type="fileinfo")
+    sorted_file_infos = []
+    for file_info in file_infos:
+        if not file_info.path.endswith(metadata_name):
+            continue
+
+        experiment_dir = dirname(file_info.path)
+        if experiment_dir.endswith(framework_name):
+            experiment_path = join(experiment_dir, metadata_name)
+            sorted_file_infos.append(experiment_path)
+
+    def fetch_experiment_data(file_info):
+        try:
+            response = api.post(
+                "file-storage.download",
+                {ApiField.TEAM_ID: team_id, ApiField.PATH: file_info},
+                stream=True,
+            )
+            response.raise_for_status()
+            response_json = response.json()
+            required_fields = {field for field in ExperimentInfo._fields}
+            if not required_fields.issubset(response_json.keys()):
+                logger.debug(
+                    f"Missing required fields in JSON from '{experiment_path}': {required_fields - response_json.keys()}"
+                )
+                return None
+            return ExperimentInfo(**response_json)
+        except requests.exceptions.RequestException as e:
+            logger.debug(f"Failed to fetch train metadata from '{experiment_path}': {e}")
+        except JSONDecodeError as e:
+            logger.debug(f"Failed to decode JSON from '{experiment_path}': {e}")
+        return None
+
+    with ThreadPoolExecutor() as executor:
+        experiment_infos = list(executor.map(fetch_experiment_data, sorted_file_infos))
+
+    experiment_infos = [info for info in experiment_infos if info is not None]
+    return experiment_infos

supervisely/nn/inference/gui/__init__.py

@@ -1 +1,3 @@
-from supervisely.nn.inference.gui.gui import BaseInferenceGUI, InferenceGUI, ServingGUI
+from supervisely.nn.inference.gui.gui import BaseInferenceGUI, InferenceGUI
+from supervisely.nn.inference.gui.serving_gui import ServingGUI
+from supervisely.nn.inference.gui.serving_gui_template import ServingGUITemplate

supervisely/nn/inference/gui/gui.py

@@ -5,10 +5,9 @@
 from functools import wraps
 from typing import Callable, Dict, List, Optional, Union
 
-import yaml
-
 import supervisely.app.widgets as Widgets
 import supervisely.io.env as env
+import yaml
 from supervisely import Api
 from supervisely._utils import abs_url, is_debug_with_sly_net, is_development
 from supervisely.api.file_api import FileApi
@@ -97,7 +96,9 @@ class InferenceGUI(BaseInferenceGUI):
         self._serve_button = Widgets.Button("SERVE")
         self._success_label = Widgets.DoneLabel()
         self._success_label.hide()
-        self._download_progress = Widgets.Progress("Downloading model...", hide_on_finish=True)
+        self._download_progress = Widgets.Progress(
+            "Downloading model...", hide_on_finish=True
+        )
         self._download_progress.hide()
         self._change_model_button = Widgets.Button(
             "STOP AND CHOOSE ANOTHER MODEL", button_type="danger"
@@ -123,7 +124,9 @@ class InferenceGUI(BaseInferenceGUI):
         self._model_classes_widget = Widgets.ClassesTable(selectable=False)
         self._model_classes_plug = Widgets.Text("No classes provided")
         self._model_classes_widget_container = Widgets.Field(
-            content=Widgets.Container([self._model_classes_widget, self._model_classes_plug]),
+            content=Widgets.Container(
+                [self._model_classes_widget, self._model_classes_plug]
+            ),
             title="Model classes",
             description="List of classes model predicts",
         )
@@ -152,7 +155,9 @@ class InferenceGUI(BaseInferenceGUI):
 
         self._model_full_info_card.collapse()
         self._additional_ui_content = []
-        self.get_ui = self.__add_content_and_model_info_to_default_ui(self._model_full_info_card)
+        self.get_ui = self.__add_content_and_model_info_to_default_ui(
+            self._model_full_info_card
+        )
 
         tabs_titles = []
         tabs_contents = []
@@ -166,7 +171,9 @@ class InferenceGUI(BaseInferenceGUI):
                 def update_table(selected_model):
                     cols = [
                         model_key
-                        for model_key in self._models[selected_model]["checkpoints"][0].keys()
+                        for model_key in self._models[selected_model]["checkpoints"][
+                            0
+                        ].keys()
                     ]
                     rows = [
                         [value for param_name, value in model.items()]
@@ -255,7 +262,9 @@ class InferenceGUI(BaseInferenceGUI):
             custom_tab_content = Widgets.Container(custom_tab_widgets)
             tabs_titles.append("Custom models")
             tabs_contents.append(custom_tab_content)
-            tabs_descriptions.append("Models trained in Supervisely and located in Team Files")
+            tabs_descriptions.append(
+                "Models trained in Supervisely and located in Team Files"
+            )
 
         self._tabs = Widgets.RadioTabs(
             titles=tabs_titles,
@@ -263,7 +272,9 @@ class InferenceGUI(BaseInferenceGUI):
             descriptions=tabs_descriptions,
         )
 
-        self.on_change_model_callbacks: List[CallbackT] = [InferenceGUI._hide_info_after_change]
+        self.on_change_model_callbacks: List[CallbackT] = [
+            InferenceGUI._hide_info_after_change
+        ]
         self.on_serve_callbacks: List[CallbackT] = []
 
         @self.serve_button.click
@@ -334,7 +345,9 @@ class InferenceGUI(BaseInferenceGUI):
 
         table_subtitles, cols = self._get_table_subtitles(cols)
         if self._models_table is None:
-            self._models_table = Widgets.RadioTable(cols, rows, subtitles=table_subtitles)
+            self._models_table = Widgets.RadioTable(
+                cols, rows, subtitles=table_subtitles
+            )
         else:
             self._models_table.set_data(cols, rows, subtitles=table_subtitles)
 
@@ -470,15 +483,21 @@ class InferenceGUI(BaseInferenceGUI):
         try:
             classes = inference.get_classes()
         except NotImplementedError:
-            logger.warn(f"get_classes() function not implemented for {type(inference)} object.")
+            logger.warn(
+                f"get_classes() function not implemented for {type(inference)} object."
+            )
         except AttributeError:
-            logger.warn("Probably, get_classes() function not working without model deploy.")
+            logger.warn(
+                "Probably, get_classes() function not working without model deploy."
+            )
         except Exception as exc:
             logger.warn("Skip getting classes info due to exception")
             logger.exception(exc)
 
         if classes is None or len(classes) == 0:
-            logger.warn(f"get_classes() function return {classes}; skip classes processing.")
+            logger.warn(
+                f"get_classes() function return {classes}; skip classes processing."
+            )
             return None
         return classes
 
@@ -518,223 +537,3 @@ class InferenceGUI(BaseInferenceGUI):
             return wrapper
 
         return decorator(self.get_ui)
-
-
-class ServingGUI:
-    def __init__(self) -> None:
-        device_values = []
-        device_names = []
-        try:
-            import torch
-
-            if torch.cuda.is_available():
-                gpus = torch.cuda.device_count()
-                for i in range(gpus):
-                    device_values.append(f"cuda:{i}")
-                    device_names.append(f"{torch.cuda.get_device_name(i)} (cuda:{i})")
-        except:
-            pass
-        device_values.append("cpu")
-        device_names.append("CPU")
-
-        self._device_select = Widgets.SelectString(
-            values=device_values,
-            labels=device_names,
-            width_percent=30,
-        )
-        self._device_field = Widgets.Field(self._device_select, title="Device")
-        self._serve_button = Widgets.Button("SERVE")
-        self._success_label = Widgets.DoneLabel()
-        self._success_label.hide()
-        self._download_progress = Widgets.Progress("Downloading model...", hide_on_finish=True)
-        self._download_progress.hide()
-        self._change_model_button = Widgets.Button(
-            "STOP AND CHOOSE ANOTHER MODEL", button_type="danger"
-        )
-        self._change_model_button.hide()
-
-        self._model_inference_settings_widget = Widgets.Editor(
-            readonly=True, restore_default_button=False
-        )
-        self._model_inference_settings_container = Widgets.Field(
-            self._model_inference_settings_widget,
-            title="Inference settings",
-            description="Model allows user to configure the following parameters on prediction phase",
-        )
-
-        self._model_info_widget = Widgets.ModelInfo()
-        self._model_info_widget_container = Widgets.Field(
-            self._model_info_widget,
-            title="Session Info",
-            description="Basic information about the deployed model",
-        )
-
-        self._model_classes_widget = Widgets.ClassesTable(selectable=False)
-        self._model_classes_plug = Widgets.Text("No classes provided")
-        self._model_classes_widget_container = Widgets.Field(
-            content=Widgets.Container([self._model_classes_widget, self._model_classes_plug]),
-            title="Model classes",
-            description="List of classes model predicts",
-        )
-
-        self._model_full_info = Widgets.Container(
-            [
-                self._model_info_widget_container,
-                self._model_inference_settings_container,
-                self._model_classes_widget_container,
-            ]
-        )
-        self._model_full_info.hide()
-        self._before_deploy_msg = Widgets.Text("Deploy model to see the information.")
-
-        self._model_full_info_card = Widgets.Card(
-            title="Full model info",
-            description="Inference settings, session parameters and model classes",
-            collapsable=True,
-            content=Widgets.Container(
-                [
-                    self._model_full_info,
-                    self._before_deploy_msg,
-                ]
-            ),
-        )
-
-        self._model_full_info_card.collapse()
-        self._additional_ui_content = []
-        self.get_ui = self.__add_content_and_model_info_to_default_ui(self._model_full_info_card)
-
-        self.on_change_model_callbacks: List[CallbackT] = [ServingGUI._hide_info_after_change]
-        self.on_serve_callbacks: List[CallbackT] = []
-
-        @self.serve_button.click
-        def serve_model():
-            self.deploy_with_current_params()
-
-        @self._change_model_button.click
-        def change_model():
-            for cb in self.on_change_model_callbacks:
-                cb(self)
-            self.change_model()
-
-    def deploy_with_current_params(self):
-        for cb in self.on_serve_callbacks:
-            cb(self)
-        self.set_deployed()
-
-    def change_model(self):
-        self._success_label.text = ""
-        self._success_label.hide()
-        self._serve_button.show()
-        self._device_select.enable()
-        self._change_model_button.hide()
-        Progress("model deployment canceled", 1).iter_done_report()
-
-    def _hide_info_after_change(self):
-        self._model_full_info_card.collapse()
-        self._model_full_info.hide()
-        self._before_deploy_msg.show()
-
-    def get_device(self) -> str:
-        return self._device_select.get_value()
-
-    @property
-    def serve_button(self) -> Widgets.Button:
-        return self._serve_button
-
-    @property
-    def download_progress(self) -> Widgets.Progress:
-        return self._download_progress
-
-    def set_deployed(self, device: str = None):
-        if device is not None:
-            self._device_select.set_value(device)
-        self._success_label.text = f"Model has been successfully loaded on {self._device_select.get_value().upper()} device"
-        self._success_label.show()
-        self._serve_button.hide()
-        self._device_select.disable()
-        self._change_model_button.show()
-        Progress("Model deployed", 1).iter_done_report()
-
-    def show_deployed_model_info(self, inference):
-        self.set_inference_settings(inference)
-        self.set_project_meta(inference)
-        self.set_model_info(inference)
-        self._before_deploy_msg.hide()
-        self._model_full_info.show()
-        self._model_full_info_card.uncollapse()
-
-    def set_inference_settings(self, inference):
-        if len(inference.custom_inference_settings_dict.keys()) == 0:
-            inference_settings_str = "# inference settings dict is empty"
-        else:
-            inference_settings_str = yaml.dump(inference.custom_inference_settings_dict)
-        self._model_inference_settings_widget.set_text(inference_settings_str, "yaml")
-        self._model_inference_settings_widget.show()
-
-    def set_project_meta(self, inference):
-        if self._get_classes_from_inference(inference) is None:
-            logger.warn("Skip loading project meta.")
-            self._model_classes_widget.hide()
-            self._model_classes_plug.show()
-            return
-
-        self._model_classes_widget.set_project_meta(inference.model_meta)
-        self._model_classes_plug.hide()
-        self._model_classes_widget.show()
-
-    def set_model_info(self, inference):
-        info = inference.get_human_readable_info(replace_none_with="Not provided")
-        self._model_info_widget.set_model_info(inference.task_id, info)
-
-    def _get_classes_from_inference(self, inference) -> Optional[List[str]]:
-        classes = None
-        try:
-            classes = inference.get_classes()
-        except NotImplementedError:
-            logger.warn(f"get_classes() function not implemented for {type(inference)} object.")
-        except AttributeError:
-            logger.warn("Probably, get_classes() function not working without model deploy.")
-        except Exception as exc:
-            logger.warn("Skip getting classes info due to exception")
-            logger.exception(exc)
-
-        if classes is None or len(classes) == 0:
-            logger.warn(f"get_classes() function return {classes}; skip classes processing.")
-            return None
-        return classes
-
-    def get_ui(self) -> Widgets.Widget:
-        return Widgets.Container(
-            [
-                self._device_field,
-                self._download_progress,
-                self._success_label,
-                self._serve_button,
-                self._change_model_button,
-            ],
-            gap=3,
-        )
-
-    def add_content_to_default_ui(
-        self, widgets: Union[Widgets.Widget, List[Widgets.Widget]]
-    ) -> None:
-        if isinstance(widgets, List):
-            self._additional_ui_content.extend(widgets)
-        else:
-            self._additional_ui_content.append(widgets)
-
-    def __add_content_and_model_info_to_default_ui(
-        self,
-        model_info_widget: Widgets.Widget,
-    ) -> Callable:
-        def decorator(get_ui):
-            @wraps(get_ui)
-            def wrapper(*args, **kwargs):
-                ui = get_ui(*args, **kwargs)
-                content = [ui, *self._additional_ui_content, model_info_widget]
-                ui_with_info = Widgets.Container(content)
-                return ui_with_info
-
-            return wrapper
-
-        return decorator(self.get_ui)