supervisely 6.73.389__py3-none-any.whl → 6.73.391__py3-none-any.whl

supervisely/app/widgets/experiment_selector/experiment_selector.py

@@ -142,6 +142,14 @@ class ExperimentSelector(Widget):
         @property
         def checkpoints_selector(self) -> Select:
             return self._checkpoints_widget
+        
+        @property
+        def experiment_info(self) -> ExperimentInfo:
+            return self._experiment_info
+
+        @property
+        def best_checkpoint(self) -> str:
+            return self.experiment_info.best_checkpoint
 
         @property
         def session_link(self) -> str:
@@ -459,6 +467,12 @@ class ExperimentSelector(Widget):
             return
         selected_row = self.get_selected_row()
         return selected_row.get_selected_checkpoint_path()
+    
+    def get_selected_checkpoint_name(self) -> str:
+        if len(self._rows) == 0:
+            return
+        selected_row = self.get_selected_row()
+        return selected_row.get_selected_checkpoint_name()
 
     def get_model_files(self) -> Dict[str, str]:
         """
@@ -485,9 +499,12 @@ class ExperimentSelector(Widget):
         }
         return deploy_params
 
-    def set_active_row(self, row_index: int) -> None:
-        if row_index < 0 or row_index > len(self._rows) - 1:
+    def set_active_row(self, row_index: int, task_type: str = None) -> None:
+        if task_type is None:
+            task_type = self.get_selected_task_type()
+        if row_index < 0 or row_index > len(self._rows[task_type]) - 1:
             raise ValueError(f'Row with index "{row_index}" does not exist')
+        self.set_active_task_type(task_type)
         StateJson()[self.widget_id]["selectedRow"] = row_index
         StateJson().send_changes()
 
@@ -495,7 +512,7 @@ class ExperimentSelector(Widget):
         for task_type in self._rows:
             for i, row in enumerate(self._rows[task_type]):
                 if row.task_id == task_id:
-                    self.set_active_row(i)
+                    self.set_active_row(i, task_type)
                     return
 
     def get_by_task_id(self, task_id: int) -> Union[ModelRow, None]:

supervisely/app/widgets/experiment_selector/template.html

@@ -1,82 +1,61 @@
-<link rel="stylesheet" href="./sly/css/app/widgets/custom_models_selector/style.css"/>
+<link rel="stylesheet" href="./sly/css/app/widgets/custom_models_selector/style.css" />
 
-<div
-    {% if widget._changes_handled == true %}
-    @change="post('/{{{widget.widget_id}}}/value_changed')"
-    {% endif %}
-    >
+<div {% if widget._changes_handled==true %} @change="post('/{{{widget.widget_id}}}/value_changed')" {% endif %}>
 
     <div v-if="Object.keys(data.{{{widget.widget_id}}}.rowsHtml).length === 0"> You don't have any custom models</div>
     <div v-else>
 
         <div v-if="data.{{{widget.widget_id}}}.taskTypes.length > 1">
-            <sly-field
-            title="Task Type"
-            >
-                <el-radio-group
-                    class="multi-line mt10"
-                    :value="state.{{{widget.widget_id}}}.selectedTaskType"
-    
-                    {% if widget._task_type_changes_handled == true %}
-                        @input="(evt) => {state.{{{widget.widget_id}}}.selectedTaskType = evt; state.{{{widget.widget_id}}}.selectedRow = 0; post('/{{{widget.widget_id}}}/task_type_changed')}"
+            <sly-field title="Task Type">
+                <el-radio-group class="multi-line mt10" :value="state.{{{widget.widget_id}}}.selectedTaskType" {% if
+                    widget._task_type_changes_handled==true %}
+                    @input="(evt) => {state.{{{widget.widget_id}}}.selectedTaskType = evt; state.{{{widget.widget_id}}}.selectedRow = 0; post('/{{{widget.widget_id}}}/task_type_changed')}"
                     {% else %}
-                        @input="(evt) => {state.{{{widget.widget_id}}}.selectedTaskType = evt; state.{{{widget.widget_id}}}.selectedRow = 0;}"
-                    {% endif %}
-                    >
-    
-                    <el-radio 
-                        v-for="(item, idx) in {{{widget._task_types}}}"
-                        :key="item"
-                        :label="item"
-                        >
-                            {{ item }}
+                    @input="(evt) => {state.{{{widget.widget_id}}}.selectedTaskType = evt; state.{{{widget.widget_id}}}.selectedRow = 0;}"
+                    {% endif %}>
+
+                    <el-radio v-for="(item, idx) in {{{widget._task_types}}}" :key="item" :label="item">
+                        {{ item }}
                     </el-radio>
                 </el-radio-group>
-        </sly-field>
-    </div>
+            </sly-field>
+        </div>
 
         <div>
-        
-    <table class="custom-models-selector-table">
-        <thead>
-        <tr>
-            <th v-for="col in data.{{{widget.widget_id}}}.columns">
-                <div> {{col}} </div>
-            </th>
-        </tr> 
-        </thead>
-        <tbody>
-        <tr v-for="row, ridx in data.{{{widget.widget_id}}}.rowsHtml[state.{{{widget.widget_id}}}.selectedTaskType]">
-            <td v-for="col, vidx in row">
-                <div v-if="vidx === 0" style="display: flex;">
-                    <el-radio
-                    style="display: flex;"
-                    v-model="state.{{{widget.widget_id}}}.selectedRow"
-                    :label="ridx"
-                    >&#8205;</el-radio>
-                    
-                    <sly-html-compiler :params="{ridx: ridx, vidx: vidx}" :template="col" :data="data" :state="state"></sly-html-compiler>
-                    
-                </div>
-
-                <div v-else>
 
-                    <sly-html-compiler :params="{ridx: ridx, vidx: vidx}" :template="col" :data="data" :state="state">
-                    </sly-html-compiler>
-
-                </div>
-
-            </td>
-        </tr>
-        </tbody>
-    </table>
-</div>
-    <div class="mt10" v-if="{{{widget.show_custom_checkpoint_path}}}"
-    >
-    {{{widget.show_custom_checkpoint_path_checkbox}}}
-    <div class="mt10">
-    {{{widget.custom_tab_widgets}}}
-</div>
-</div>
-</div>
-</div>
+            <table class="custom-models-selector-table">
+                <thead>
+                    <tr>
+                        <th v-for="col in data.{{{widget.widget_id}}}.columns">
+                            <div> {{col}} </div>
+                        </th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr
+                        v-for="row, ridx in data.{{{widget.widget_id}}}.rowsHtml[state.{{{widget.widget_id}}}.selectedTaskType]">
+                        <td v-for="col, vidx in row">
+                            <div v-if="vidx === 0" style="display: flex;">
+                                <el-radio style="display: flex;" v-model="state.{{{widget.widget_id}}}.selectedRow"
+                                    :label="ridx">&#8205;</el-radio>
+
+                                <sly-html-compiler :params="{ridx: ridx, vidx: vidx}" :template="col" :data="data"
+                                    :state="state"></sly-html-compiler>
+
+                            </div>
+
+                            <div v-else>
+
+                                <sly-html-compiler :params="{ridx: ridx, vidx: vidx}" :template="col" :data="data"
+                                    :state="state">
+                                </sly-html-compiler>
+
+                            </div>
+
+                        </td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+    </div>
+</div>

supervisely/app/widgets/report_thumbnail/report_thumbnail.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Literal, Optional
 
 from supervisely._utils import abs_url, is_debug_with_sly_net, is_development
 from supervisely.api.file_api import FileInfo
@@ -16,11 +16,13 @@ class ReportThumbnail(Widget):
         title: Optional[str] = None,
         color: Optional[str] = "#dcb0ff",
         bg_color: Optional[str] = "#faebff",
+        report_type: Literal["model_benchmark", "experiment"] = "model_benchmark",
     ):
         self._id: int = None
         self._info: FileInfo = None
         self._description: str = None
         self._url: str = None
+        self._report_type = report_type
         self._set_info(info)
         self._title = title
         self._color = color if _validate_hex_color(color) else "#dcb0ff"
@@ -54,13 +56,26 @@ class ReportThumbnail(Widget):
             return
         self._id = info.id
         self._info = info
-        self._description = "Open the Model Benchmark evaluation report."
-        lnk = f"/model-benchmark?id={info.id}"
+        if self._report_type == "model_benchmark":
+            self._description = "Open the Model Benchmark evaluation report."
+            lnk = f"/model-benchmark?id={info.id}"
+        elif self._report_type == "experiment":
+            self._description = "Open the Experiment report."
+            lnk = f"/nn/experiments/{info.id}"
+        else:
+            raise ValueError(f"Invalid report type: {self._report_type}")
+
         lnk = abs_url(lnk) if is_development() or is_debug_with_sly_net() else lnk
         # self._description = info.path
         self._url = lnk
 
-    def set(self, info: FileInfo = None):
+    def set(
+        self,
+        info: FileInfo = None,
+        report_type: Optional[Literal["model_benchmark", "experiment"]] = None,
+    ):
+        if report_type is not None:
+            self._report_type = report_type
         self._set_info(info)
         self.update_data()
         DataJson().send_changes()

supervisely/decorators/profile.py

@@ -1,5 +1,6 @@
 import functools
 import time
+
 from supervisely.sly_logger import logger
 
 
@@ -21,6 +22,25 @@ def timeit(func):
     return wrapper_timer
 
 
+def timeit_with_result(func):
+    """Measures execution time and stores it in function's 'elapsed' attribute."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.perf_counter()
+        try:
+            result = func(*args, **kwargs)
+            return result
+        finally:
+            wrapper.elapsed = time.perf_counter() - start_time
+            logger.debug(
+                f"Function '{func.__name__}' finished in {wrapper.elapsed:.2f} seconds (≈ {wrapper.elapsed/60:.2f} minutes)"
+            )
+
+    wrapper.elapsed = None  # Initial value before first call
+    return wrapper
+
+
 def update_fields(func):
     """Update state field after executing function"""
 

supervisely/nn/benchmark/utils/detection/utlis.py

@@ -24,5 +24,12 @@ def read_coco_datasets(cocoGt_json, cocoDt_json):
     cocoGt = COCO()
     cocoGt.dataset = cocoGt_json
     cocoGt.createIndex()
+
+    # Fix key error in pycocotools
+    info = cocoGt.dataset.get("info", None)
+    if info is None:
+        cocoGt.dataset["info"] = {}
+    # ------------------------------ #
+
     cocoDt = cocoGt.loadRes(cocoDt_json["annotations"])
     return cocoGt, cocoDt

supervisely/nn/experiments.py

@@ -20,6 +20,10 @@ class ExperimentInfo:
     """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"""
+    base_checkpoint: str
+    """Name of the base checkpoint used for training"""
+    base_checkpoint_link: str
+    """Link to the base checkpoint used for training. URL in case of pretrained model, or Team Files path in case of custom model."""
     task_type: str
     """Task type of the experiment"""
     project_id: int

supervisely/nn/inference/gui/serving_gui_template.py

@@ -7,17 +7,8 @@ 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 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,
 )
@@ -133,6 +124,27 @@ class ServingGUITemplate(ServingGUI):
         card_widgets = [self.model_source_tabs]
         if runtime_field is not None:
             card_widgets.append(runtime_field)
+
+        # Runtime exported checkpoint message
+        self._export_msg = Text("")
+        self._export_msg.hide()
+        card_widgets.append(self._export_msg)
+
+        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())
+        if self.pretrained_models_table is not None:
+            self.pretrained_models_table.model_changed(lambda _: self._update_export_message())
+
+        if self.model_source_tabs is not None:
+            self.model_source_tabs.value_changed(lambda _: self._update_export_message())
+
+        self._update_export_message()
+
         return card_widgets
 
     def _initialize_extra_widgets(self) -> List[Widget]:
@@ -204,3 +216,51 @@ class ServingGUITemplate(ServingGUI):
         elif self.model_source == ModelSource.CUSTOM and self.experiment_selector:
             return self.experiment_selector.get_selected_experiment_info()
         return {}
+
+    def _update_export_message(self):
+        self._export_msg.hide()
+
+        runtime = self.runtime
+        non_conversion_runtimes = [RuntimeType.ONNXRUNTIME, RuntimeType.TENSORRT]
+        if runtime not in non_conversion_runtimes:
+            return
+
+        if self.model_source == ModelSource.PRETRAINED:
+            self._export_msg.set(
+                "Checkpoint will be converted before deployment.",
+                "info",
+            )
+            self._export_msg.show()
+            return
+
+        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:
+                return
+            checkpoint_name = selected_row.get_selected_checkpoint_name()
+            if checkpoint_name is None:
+                return
+
+        model_info = self.model_info or {}
+        export_info = model_info.get("export", {})
+        available = False
+        if isinstance(export_info, dict):
+            for key in export_info.keys():
+                if key.lower().startswith(runtime.lower()):
+                    available = True
+                    break
+            if checkpoint_name != selected_row.best_checkpoint:
+                available = False
+
+        if available:
+            self._export_msg.set(
+                "Runtime checkpoint exists – no conversion needed.",
+                "info",
+            )
+        else:
+            self._export_msg.set(
+                "Checkpoint will be converted before deployment.",
+                "info",
+            )
+        self._export_msg.show()

supervisely/nn/inference/inference.py

@@ -34,6 +34,7 @@ import supervisely.io.env as sly_env
 import supervisely.io.fs as sly_fs
 import supervisely.io.json as sly_json
 import supervisely.nn.inference.gui as GUI
+from supervisely.nn.experiments import ExperimentInfo
 from supervisely import DatasetInfo, batched
 from supervisely._utils import (
     add_callback,
@@ -277,6 +278,19 @@ class Inference:
             self.gui.on_serve_callbacks.append(on_serve_callback)
             self._initialize_app_layout()
 
+            train_task_id = os.getenv("modal.state.trainTaskId")
+            if train_task_id:
+                try:
+                    train_task_id = int(train_task_id)
+                    logger.info(f"Setting best checkpoint from training task id: {train_task_id}")
+                    experiment_info = self.api.nn.get_experiment_info(train_task_id)
+                    self._set_checkpoint_from_experiment_info(experiment_info)
+                    self.gui.deploy_with_current_params()
+                except Exception as e:
+                    logger.warning(f"Failed to set checkpoint from training task id: {repr(e)}")
+                    logger.info("Resetting UI to default state")
+                    self._reset_gui_state()
+
         self._inference_requests = {}
         max_workers = 1 if not multithread_inference else None
         self._executor = ThreadPoolExecutor(max_workers=max_workers)
@@ -748,7 +762,10 @@ class Inference:
         """
         team_id = sly_env.team_id()
         local_model_files = {}
-        for file in model_files:
+        
+        # Sort files to download 'checkpoint' first
+        files_order = sorted(model_files.keys(), key=lambda x: (0 if x == "checkpoint" else 1, x))
+        for file in files_order:
             file_url = model_files[file]
             file_info = self.api.file.get_info_by_path(team_id, file_url)
             if file_info is None:
@@ -773,11 +790,66 @@ class Inference:
                     )
             else:
                 self.api.file.download(team_id, file_url, file_path)
+
+            if file == "checkpoint":
+                try:
+                    extracted_files = self._extract_model_files_from_checkpoint(file_path)
+                    local_model_files.update(extracted_files)
+                    if extracted_files:
+                        local_model_files[file] = file_path
+                        return local_model_files
+                except Exception as e:
+                    logger.debug(f"Failed to process checkpoint '{file_name}' to extract auxiliary files: {repr(e)}")
+                    logger.debug("Model files will be downloaded from Team Files")
+                    local_model_files[file] = file_path
+                    continue
+            
             local_model_files[file] = file_path
         if log_progress:
             self.gui.download_progress.hide()
         return local_model_files
 
+    def _extract_model_files_from_checkpoint(self, checkpoint_path: str) -> dict:
+        extracted_files: dict = {}
+        file_ext = sly_fs.get_file_ext(checkpoint_path)
+        if file_ext not in (".pth", ".pt"):
+            return extracted_files
+
+        import torch  # pylint: disable=import-error
+
+        logger.debug(f"Reading checkpoint: {checkpoint_path}")
+        checkpoint = torch.load(checkpoint_path, map_location="cpu")
+
+        # 1. Extract additional model files embedded into checkpoint (if any)
+        ckpt_files = checkpoint.get("model_files", None)
+        if ckpt_files and isinstance(ckpt_files, dict):
+            for file_key, file_info in ckpt_files.items():
+                try:
+                    content = file_info["content"]
+                    fname = file_info.get("name", f"{file_key}.txt")
+                    dst_path = os.path.join(self.model_dir, fname)
+                    # Overwrite if exists
+                    if os.path.exists(dst_path):
+                        sly_fs.silent_remove(dst_path)
+                    with open(dst_path, "w") as f:
+                        f.write(content)
+                    extracted_files[file_key] = dst_path
+                except Exception as e:
+                    logger.debug(f"Failed to write '{file_key}' from checkpoint to disk: {repr(e)}")
+
+        # 2. Extract project meta (if present)
+        model_meta = checkpoint.get("model_meta", None)
+        if model_meta is not None:
+            try:
+                meta_path = os.path.join(self.model_dir, "model_meta.json")
+                if os.path.exists(meta_path):
+                    sly_fs.silent_remove(meta_path)
+                sly_json.dump_json_file(model_meta, meta_path)
+            except Exception as e:
+                logger.debug(f"Failed to dump model_meta from checkpoint: {repr(e)}")
+
+        return extracted_files
+
     def _load_model(self, deploy_params: dict):
         self.model_source = deploy_params.get("model_source")
         self.device = deploy_params.get("device")
@@ -910,11 +982,20 @@ class Inference:
         if isinstance(model_meta, dict):
             self._model_meta = ProjectMeta.from_json(model_meta)
         elif isinstance(model_meta, str):
-            remote_artifacts_dir = model_info["artifacts_dir"]
-            model_meta_url = os.path.join(remote_artifacts_dir, model_meta)
-            model_meta_path = self.download(model_meta_url)
-            model_meta = sly_json.load_json_file(model_meta_path)
-            self._model_meta = ProjectMeta.from_json(model_meta)
+            model_meta_path = os.path.join(self.model_dir, "model_meta.json")
+            if os.path.exists(model_meta_path):
+                logger.debug("Reading model meta from checkpoint")
+                model_meta = sly_json.load_json_file(model_meta_path)
+                self._model_meta = ProjectMeta.from_json(model_meta)
+                sly_fs.silent_remove(model_meta_path)
+            else:
+                remote_artifacts_dir = model_info["artifacts_dir"]
+                model_meta_url = os.path.join(remote_artifacts_dir, model_meta)
+                model_meta_path = self.download(model_meta_url)
+                model_meta = sly_json.load_json_file(model_meta_path)
+                self._model_meta = ProjectMeta.from_json(model_meta)
+                sly_fs.silent_remove(model_meta_path)
+
         else:
             raise ValueError(
                 "model_meta should be a dict or a name of '.json' file in experiment artifacts folder in Team Files"
@@ -3741,6 +3822,27 @@ class Inference:
                     f"Checkpoint {checkpoint_url} not found in Team Files. Cannot set workflow input"
                 )
 
+    def _set_checkpoint_from_experiment_info(self, experiment_info: ExperimentInfo):
+        try:
+            if not isinstance(self.gui, GUI.ServingGUITemplate) or self.gui.experiment_selector is None:
+                return
+
+            task_id = experiment_info.task_id
+            self.gui.model_source_tabs.set_active_tab(ModelSource.CUSTOM)
+            self.gui.experiment_selector.set_by_task_id(task_id)
+
+            best_ckpt = experiment_info.best_checkpoint
+            if best_ckpt:
+                row = self.gui.experiment_selector.get_by_task_id(task_id)
+                if row is not None:
+                    row.set_selected_checkpoint_by_name(best_ckpt)
+        except Exception as e:
+            logger.warning(f"Failed to set checkpoint from experiment info: {repr(e)}")
+
+    def _reset_gui_state(self):
+        if not isinstance(self.gui, GUI.ServingGUITemplate) or self.gui.experiment_selector is None:
+            return
+        self.gui.model_source_tabs.set_active_tab(ModelSource.PRETRAINED)
 
 def _exclude_duplicated_predictions(
     api: Api,