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

supervisely/nn/inference/gui/serving_gui.py

@@ -0,0 +1,223 @@
+from functools import wraps
+from typing import Callable, Dict, List, Optional, Union
+
+import yaml
+
+import supervisely.app.widgets as Widgets
+from supervisely.sly_logger import logger
+from supervisely.task.progress import Progress
+
+
+class ServingGUI:
+    def __init__(self) -> None:
+        self._device_select = Widgets.SelectCudaDevice(include_cpu_option=True)
+        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.serve_container = Widgets.Container(
+            [
+                self._device_field,
+                self._download_progress,
+                self._success_label,
+                self._serve_button,
+                self._change_model_button,
+            ],
+        )
+        self.serve_model_card = Widgets.Card(
+            title="Serve Model",
+            description="Download and deploy the model on the selected device.",
+            content=self.serve_container,
+        )
+
+        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
+        )  # pylint: disable=method-hidden
+
+        self.on_change_model_callbacks: List[Callable] = [ServingGUI._hide_info_after_change]
+        self.on_serve_callbacks: List[Callable] = []
+
+        @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()
+
+    @property
+    def serve_button(self) -> Widgets.Button:
+        return self._serve_button
+
+    @property
+    def download_progress(self) -> Widgets.Progress:
+        return self._download_progress
+
+    @property
+    def device(self) -> str:
+        return self._device_select.get_device()
+
+    def get_device(self) -> str:
+        return self._device_select.get_device()
+
+    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._select.enable()
+        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 set_deployed(self, device: str = None):
+        if device is not None:
+            self._device_select.set_device(device)
+        self._success_label.text = f"Model has been successfully loaded on {self._device_select.get_device().upper()} device"
+        self._success_label.show()
+        self._serve_button.hide()
+        self._device_select._select.disable()
+        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:  # pylint: disable=method-hidden
+        return Widgets.Container([self.serve_model_card])
+
+    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)

supervisely/nn/inference/gui/serving_gui_template.py

@@ -0,0 +1,240 @@
+from os.path import join
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+
+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,
+    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
+
+
+class ServingGUITemplate(ServingGUI):
+    def __init__(
+        self,
+        framework_name: str,
+        models: Optional[str] = None,
+        app_options: Optional[str] = None,
+    ):
+        if not isinstance(framework_name, str):
+            raise ValueError("'framework_name' must be a string")
+        super().__init__()
+
+        self.api = Api.from_env()
+        self.team_id = sly_env.team_id()
+
+        self.framework_name = framework_name
+        self.models = self._load_models(models) if models else []
+        self.app_options = self._load_app_options(app_options) if app_options else {}
+
+        base_widgets = self._initialize_layout()
+        extra_widgets = self._initialize_extra_widgets()
+
+        self.widgets = base_widgets + extra_widgets
+        self.card = self._get_card()
+
+    def _get_card(self) -> Card:
+        return Card(
+            title="Select Model",
+            description="Select the model to deploy and press the 'Serve' button.",
+            content=Container(widgets=self.widgets, gap=10),
+            overflow="unset",
+        )
+
+    def _initialize_layout(self) -> List[Widget]:
+        # Pretrained models
+        use_pretrained_models = self.app_options.get("pretrained_models", True)
+        use_custom_models = self.app_options.get("custom_models", True)
+
+        if not use_pretrained_models and not use_custom_models:
+            raise ValueError(
+                "At least one of 'pretrained_models' or 'custom_models' must be enabled."
+            )
+
+        if use_pretrained_models and self.models is not None:
+            self.pretrained_models_table = PretrainedModelsSelector(self.models)
+        else:
+            self.pretrained_models_table = None
+
+        # 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)
+        else:
+            self.experiment_selector = None
+
+        # Tabs
+        tabs = []
+        if self.pretrained_models_table is not None:
+            tabs.append(
+                (
+                    ModelSource.PRETRAINED,
+                    "Publicly available models",
+                    self.pretrained_models_table,
+                )
+            )
+        if self.experiment_selector is not None:
+            tabs.append(
+                (
+                    ModelSource.CUSTOM,
+                    "Models trained in Supervisely",
+                    self.experiment_selector,
+                )
+            )
+        if tabs:
+            titles, descriptions, content = zip(*tabs)
+            self.model_source_tabs = RadioTabs(
+                titles=titles,
+                descriptions=descriptions,
+                contents=content,
+            )
+        else:
+            self.model_source_tabs = None
+
+        # Runtime
+        default_runtime = RuntimeType.PYTORCH
+        available_runtimes = {
+            value.lower(): value
+            for name, value in vars(RuntimeType).items()
+            if not name.startswith("__")  # exclude private attributes
+        }
+        supported_runtimes_input = self.app_options.get("supported_runtimes", [default_runtime])
+        supported_runtimes = [
+            available_runtimes[runtime.lower()]
+            for runtime in supported_runtimes_input
+            if runtime.lower() in available_runtimes
+        ]
+
+        if len(supported_runtimes) > 1:
+            self.runtime_select = SelectString(supported_runtimes)
+            runtime_field = Field(self.runtime_select, "Runtime", "Select a runtime for inference.")
+        else:
+            self.runtime_select = None
+            runtime_field = None
+
+        # Layout
+        card_widgets = [self.model_source_tabs]
+        if runtime_field is not None:
+            card_widgets.append(runtime_field)
+        return card_widgets
+
+    def _initialize_extra_widgets(self) -> List[Widget]:
+        return []
+
+    @property
+    def model_source(self) -> str:
+        return self.model_source_tabs.get_active_tab()
+
+    @property
+    def model_info(self) -> Dict[str, Any]:
+        return self._get_selected_row()
+
+    @property
+    def model_name(self) -> Optional[str]:
+        if self.model_source == ModelSource.PRETRAINED:
+            model_meta = self.model_info.get("meta", {})
+            return model_meta.get("model_name")
+        else:
+            return self.model_info.get("model_name")
+
+    @property
+    def model_files(self) -> List[str]:
+        if self.model_source == ModelSource.PRETRAINED:
+            model_meta = self.model_info.get("meta", {})
+            return model_meta.get("model_files", {})
+        else:
+            return self.experiment_selector.get_model_files()
+
+    @property
+    def runtime(self) -> str:
+        if self.runtime_select is not None:
+            return self.runtime_select.get_value()
+        return RuntimeType.PYTORCH
+
+    def get_params_from_gui(self) -> Dict[str, Any]:
+        return {
+            "model_source": self.model_source,
+            "model_files": self.model_files,
+            "model_info": self.model_info,
+            "device": self.device,
+            "runtime": self.runtime,
+        }
+
+    # Loaders
+    def _load_models(self, models: str) -> List[Dict[str, Any]]:
+        """
+        Loads models from the provided file or list of model configurations.
+        """
+        if isinstance(models, str):
+            if sly_fs.file_exists(models) and sly_fs.get_file_ext(models) == ".json":
+                models = sly_json.load_json_file(models)
+            else:
+                raise ValueError("File not found or invalid file format.")
+        else:
+            raise ValueError(
+                "Invalid models file. Please provide a valid '.json' file with list of model configurations."
+            )
+
+        if not isinstance(models, list):
+            raise ValueError("models parameters must be a list of dicts")
+        for item in models:
+            if not isinstance(item, dict):
+                raise ValueError(f"Each item in models must be a dict.")
+            model_meta = item.get("meta")
+            if model_meta is None:
+                raise ValueError(
+                    "Model metadata not found. Please update provided models parameter to include key 'meta'."
+                )
+            model_files = model_meta.get("model_files")
+            if model_files is None:
+                raise ValueError(
+                    "Model files not found in model metadata. "
+                    "Please update provided models oarameter to include key 'model_files' in 'meta' key."
+                )
+        return models
+
+    def _load_app_options(self, app_options: str = None) -> Dict[str, Any]:
+        """
+        Loads the app_options parameter to ensure it is in the correct format.
+        """
+        if app_options is None:
+            return {}
+
+        if isinstance(app_options, str):
+            if sly_fs.file_exists(app_options) and sly_fs.get_file_ext(app_options) in [
+                ".yaml",
+                ".yml",
+            ]:
+                with open(app_options, "r") as file:
+                    app_options = yaml.safe_load(file)
+        else:
+            raise ValueError(
+                "Invalid app_options file provided. Please provide a valid '.yaml' or '.yml' file with app_options."
+            )
+        if not isinstance(app_options, dict):
+            raise ValueError("app_options must be a dict")
+        return app_options
+
+    def _get_selected_row(self) -> Dict[str, Any]:
+        if self.model_source == ModelSource.PRETRAINED and self.pretrained_models_table:
+            return self.pretrained_models_table.get_selected_row()
+        elif self.model_source == ModelSource.CUSTOM and self.experiment_selector:
+            return self.experiment_selector.get_selected_experiment_info()
+        return {}