supervisely 6.73.326__py3-none-any.whl → 6.73.327__py3-none-any.whl

supervisely/annotation/annotation.py

@@ -3088,7 +3088,7 @@ class Annotation:
     def to_yolo(
         self,
         class_names: List[str],
-        task_type: Literal["detection", "segmentation", "pose"] = "detection",
+        task_type: Literal["detect", "segment", "pose"] = "detect",
     ) -> List[str]:
         """
         Convert Supervisely annotation to YOLO annotation format.

supervisely/app/widgets/pretrained_models_selector/pretrained_models_selector.py

@@ -4,7 +4,7 @@ from supervisely.api.api import Api
 from supervisely.app.content import DataJson, StateJson
 from supervisely.app.widgets import Widget
 from supervisely.io.fs import get_file_ext
-from supervisely.nn.utils import ModelSource
+from supervisely.nn.utils import ModelSource, _get_model_name
 
 
 class PretrainedModelsSelector(Widget):
@@ -147,9 +147,11 @@ class PretrainedModelsSelector(Widget):
         if train_version == "v1":
             model_name = selected_model.get(model_name_column)
             if model_name is None:
-                raise ValueError(
-                    "Could not find model name. Make sure you have column 'Model' in your models list."
-                )
+                model_name = _get_model_name(selected_model)
+                if model_name is None:
+                    raise ValueError(
+                        "Could not find model name. Make sure you have column 'Model' in your models list."
+                    )
 
             model_meta = selected_model.get("meta")
             if model_meta is None:
@@ -230,24 +232,25 @@ class PretrainedModelsSelector(Widget):
         for task_type in self._table_data:
             for arch_type in self._table_data[task_type]:
                 for idx, model in enumerate(self._table_data[task_type][arch_type]):
-                    model_meta = model.get("meta", {})
-                    if model_meta.get("model_name") == model_name:
-                        self.set_active_task_type(task_type)
-                        self.set_active_arch_type(arch_type)
-                        self.set_active_row(idx)
-                        return
+                    name_from_info = _get_model_name(model)
+                    if name_from_info is not None:
+                        if name_from_info.lower() == model_name.lower():
+                            self.set_active_task_type(task_type)
+                            self.set_active_arch_type(arch_type)
+                            self.set_active_row(idx)
+                            return
 
     def get_by_model_name(self, model_name: str) -> Union[Dict, None]:
         for task_type in self._table_data:
             for arch_type in self._table_data[task_type]:
                 for idx, model in enumerate(self._table_data[task_type][arch_type]):
-                    model_meta = model.get("meta", {})
-                    if model_meta.get("model_name") == model_name:
-                        return model
+                    name_from_info = _get_model_name(model)
+                    if name_from_info is not None:
+                        if name_from_info.lower() == model_name.lower():
+                            return model
 
     def _filter_and_sort_models(self, models: List[Dict], sort_models: bool = True) -> Dict:
         filtered_models = {}
-
         for model in models:
             for key in model:
                 if isinstance(model[key], (int, float)):

supervisely/app/widgets/pretrained_models_selector/template.html

@@ -62,7 +62,8 @@
         <tr>
             <template v-for="(col, colKey) in data.{{{widget.widget_id}}}.tableData[state.{{{widget.widget_id}}}.selectedTaskType][state.{{{widget.widget_id}}}.selectedArchType][0]">
             <th v-if="colKey != 'meta'" :key="colKey">
-                <div>{{ colKey }}</div>
+                <div v-if="colKey==='model_name'">Model</div>
+                <div v-else>{{ colKey }}</div>
             </th>
         </template>
         </tr> 

supervisely/convert/image/yolo/yolo_helper.py

@@ -17,7 +17,8 @@ from supervisely.geometry.polygon import Polygon
 from supervisely.geometry.polyline import Polyline
 from supervisely.geometry.rectangle import Rectangle
 from supervisely.imaging.color import generate_rgb
-from supervisely.io.fs import get_file_name_with_ext, touch
+from supervisely.io.fs import get_file_name, get_file_name_with_ext, touch
+from supervisely.nn.task_type import TaskType
 from supervisely.project.project import Dataset, OpenMode, Project
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.sly_logger import logger
@@ -27,6 +28,20 @@ YOLO_DETECTION_COORDS_NUM = 4
 YOLO_SEGM_MIN_COORDS_NUM = 6
 YOLO_KEYPOINTS_MIN_COORDS_NUM = 6
 
+
+class YOLOTaskType:
+    DETECT = "detect"
+    SEGMENT = "segment"
+    POSE = "pose"
+
+
+SLY_YOLO_TASK_TYPE_MAP = {
+    TaskType.OBJECT_DETECTION: YOLOTaskType.DETECT,
+    TaskType.INSTANCE_SEGMENTATION: YOLOTaskType.SEGMENT,
+    TaskType.POSE_ESTIMATION: YOLOTaskType.POSE,
+}
+
+
 coco_classes = [
     "person",
     "bicycle",
@@ -398,22 +413,22 @@ def keypoints_to_yolo_line(
 
 def convert_label_geometry_if_needed(
     label: Label,
-    task_type: Literal["detection", "segmentation", "pose"],
+    task_type: Literal["detect", "segment", "pose"],
     verbose: bool = False,
 ) -> List[Label]:
-    if task_type == "detection":
+    if task_type == YOLOTaskType.DETECT:
         available_geometry_type = Rectangle
         convertable_geometry_types = [Polygon, GraphNodes, Bitmap, Polyline, AlphaMask, AnyGeometry]
-    elif task_type == "segmentation":
+    elif task_type == YOLOTaskType.SEGMENT:
         available_geometry_type = Polygon
         convertable_geometry_types = [Bitmap, AlphaMask, AnyGeometry]
-    elif task_type == "pose":
+    elif task_type == YOLOTaskType.POSE:
         available_geometry_type = GraphNodes
         convertable_geometry_types = []
     else:
         raise ValueError(
             f"Unsupported task type: {task_type}. "
-            "Supported types: 'detection', 'segmentation', 'pose'"
+            f"Supported types: '{YOLOTaskType.DETECT}', '{YOLOTaskType.SEGMENT}', '{YOLOTaskType.POSE}'"
         )
 
     if label.obj_class.geometry_type == available_geometry_type:
@@ -438,7 +453,7 @@ def label_to_yolo_lines(
     img_height: int,
     img_width: int,
     class_names: List[str],
-    task_type: Literal["detection", "segmentation", "pose"],
+    task_type: Literal["detect", "segment", "pose"],
 ) -> List[str]:
     """
     Convert the Supervisely Label to a line in the YOLO format.
@@ -449,21 +464,21 @@ def label_to_yolo_lines(
 
     lines = []
     for label in labels:
-        if task_type == "detection":
+        if task_type == YOLOTaskType.DETECT:
             yolo_line = rectangle_to_yolo_line(
                 class_idx=class_idx,
                 geometry=label.geometry,
                 img_height=img_height,
                 img_width=img_width,
             )
-        elif task_type == "segmentation":
+        elif task_type == YOLOTaskType.SEGMENT:
             yolo_line = polygon_to_yolo_line(
                 class_idx=class_idx,
                 geometry=label.geometry,
                 img_height=img_height,
                 img_width=img_width,
             )
-        elif task_type == "pose":
+        elif task_type == YOLOTaskType.POSE:
             nodes_field = label.obj_class.geometry_type.items_json_field
             max_kpts_count = len(label.obj_class.geometry_config[nodes_field])
             yolo_line = keypoints_to_yolo_line(
@@ -474,7 +489,10 @@ def label_to_yolo_lines(
                 max_kpts_count=max_kpts_count,
             )
         else:
-            raise ValueError(f"Unsupported task type: {task_type}")
+            raise ValueError(
+                f"Unsupported task type: {task_type}. "
+                f"Supported types: '{YOLOTaskType.DETECT}', '{YOLOTaskType.SEGMENT}', '{YOLOTaskType.POSE}'"
+            )
 
         if yolo_line is not None:
             lines.append(yolo_line)
@@ -485,12 +503,11 @@ def label_to_yolo_lines(
 def sly_ann_to_yolo(
     ann: Annotation,
     class_names: List[str],
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
 ) -> List[str]:
     """
     Convert the Supervisely annotation to the YOLO format.
     """
-
     h, w = ann.img_size
     yolo_lines = []
     for label in ann.labels:
@@ -509,11 +526,12 @@ def sly_ds_to_yolo(
     dataset: Dataset,
     meta: ProjectMeta,
     dest_dir: Optional[str] = None,
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
     log_progress: bool = False,
     progress_cb: Optional[Union[tqdm, Callable]] = None,
+    is_val: Optional[bool] = None,
 ) -> str:
-
+    task_type = validate_task_type(task_type)
     if progress_cb is not None:
         log_progress = False
 
@@ -543,15 +561,19 @@ def sly_ds_to_yolo(
         ann_path = dataset.get_ann_path(name)
         ann = Annotation.load_json_file(ann_path, meta)
 
-        images_dir = val_images_dir if ann.img_tags.get("val") else train_images_dir
-        labels_dir = val_labels_dir if ann.img_tags.get("val") else train_labels_dir
+        if is_val is not None:
+            images_dir = val_images_dir if is_val else train_images_dir
+            labels_dir = val_labels_dir if is_val else train_labels_dir
+        else:
+            images_dir = val_images_dir if ann.img_tags.get("val") else train_images_dir
+            labels_dir = val_labels_dir if ann.img_tags.get("val") else train_labels_dir
 
         img_path = Path(dataset.get_img_path(name))
         img_name = f"{dataset.short_name}_{get_file_name_with_ext(img_path)}"
         img_name = generate_free_name(used_names, img_name, with_ext=True, extend_used_names=True)
         shutil.copy2(img_path, images_dir / img_name)
 
-        label_path = str(labels_dir / f"{img_name}.txt")
+        label_path = str(labels_dir / f"{get_file_name(img_name)}.txt")
         yolo_lines = ann.to_yolo(class_names, task_type)
         if len(yolo_lines) > 0:
             with open(label_path, "w") as f:
@@ -565,7 +587,8 @@ def sly_ds_to_yolo(
     # * save data config file if it does not exist
     config_path = dest_dir / "data_config.yaml"
     if not config_path.exists():
-        save_yolo_config(meta, dest_dir, with_keypoint=task_type == "pose")
+        with_keypoint = task_type is YOLOTaskType.POSE
+        save_yolo_config(meta, dest_dir, with_keypoint=with_keypoint)
 
     return str(dest_dir)
 
@@ -578,6 +601,8 @@ def save_yolo_config(meta: ProjectMeta, dest_dir: str, with_keypoint: bool = Fal
     data_yaml = {
         "train": f"../{str(dest_dir.name)}/images/train",
         "val": f"../{str(dest_dir.name)}/images/val",
+        "train_labels": f"../{str(dest_dir.name)}/labels/train",
+        "val_labels": f"../{str(dest_dir.name)}/labels/val",
         "nc": len(class_names),
         "names": class_names,
         "colors": class_colors,
@@ -590,6 +615,7 @@ def save_yolo_config(meta: ProjectMeta, dest_dir: str, with_keypoint: bool = Fal
                 field_name = obj_class.geometry_type.items_json_field
                 max_kpts_count = max(max_kpts_count, len(obj_class.geometry_config[field_name]))
         data_yaml["kpt_shape"] = [max_kpts_count, 3]
+        data_yaml["flip_idx"] = [i for i in range(max_kpts_count)]
     with open(save_path, "w") as f:
         yaml.dump(data_yaml, f, default_flow_style=None)
 
@@ -599,21 +625,31 @@ def save_yolo_config(meta: ProjectMeta, dest_dir: str, with_keypoint: bool = Fal
 def sly_project_to_yolo(
     project: Union[Project, str],
     dest_dir: Optional[str] = None,
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
     log_progress: bool = False,
     progress_cb: Optional[Callable] = None,
+    val_datasets: Optional[List[str]] = None,
 ):
     """
     Convert Supervisely project to YOLO format.
 
+    :param project: Supervisely project or path to the directory with the project.
+    :type project: :class:`supervisely.project.project.Project` or :class:`str`
     :param dest_dir: Destination directory.
     :type dest_dir: :class:`str`, optional
+    :param task_type: Task type.
+    :type task_type: :class:`str`, optional
     :param log_progress: Show uploading progress bar.
     :type log_progress: :class:`bool`
     :param progress_cb: Function for tracking conversion progress (for all items in the project).
     :type progress_cb: callable, optional
-    :return: None
-    :rtype: NoneType
+    :param val_datasets:    List of dataset names for validation.
+                            Full dataset names are required (e.g., 'ds0/nested_ds1/ds3').
+                            If specified, datasets from the list will be marked as val, others as train.
+                            If not specified, the function will determine the validation datasets automatically.
+    :type val_datasets: :class:`list`, optional
+    :return: Path to the destination directory.
+    :rtype: :class:`str`
 
     :Usage example:
 
@@ -627,6 +663,7 @@ def sly_project_to_yolo(
         # Convert Project to YOLO format
         sly.Project(project_directory).to_yolo(log_progress=True)
     """
+    task_type = validate_task_type(task_type)
     if isinstance(project, str):
         project = Project(project, mode=OpenMode.READ)
 
@@ -644,9 +681,15 @@ def sly_project_to_yolo(
             desc="Converting Supervisely project to YOLO format", total=project.total_items
         ).update
 
-    save_yolo_config(project.meta, dest_dir, with_keypoint=task_type == "pose")
+    with_keypoint = task_type is YOLOTaskType.POSE
+    save_yolo_config(project.meta, dest_dir, with_keypoint=with_keypoint)
 
     for dataset in project.datasets:
+        if val_datasets is not None:
+            is_val = dataset.name in val_datasets
+        else:
+            is_val = None
+
         dataset: Dataset
         dataset.to_yolo(
             meta=project.meta,
@@ -654,18 +697,23 @@ def sly_project_to_yolo(
             task_type=task_type,
             log_progress=log_progress,
             progress_cb=progress_cb,
+            is_val=is_val,
         )
         logger.info(f"Dataset '{dataset.short_name}' has been converted to YOLO format.")
     logger.info(f"Project '{project.name}' has been converted to YOLO format.")
 
+    return str(dest_dir)
+
 
 def to_yolo(
     input_data: Union[Project, Dataset, str],
     dest_dir: Optional[str] = None,
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
     meta: Optional[ProjectMeta] = None,
     log_progress: bool = True,
     progress_cb: Optional[Callable] = None,
+    val_datasets: Optional[List[str]] = None,
+    is_val: Optional[bool] = None,
 ) -> Union[None, str]:
     """
     Universal function to convert Supervisely project or dataset  to YOLO format.
@@ -691,6 +739,13 @@ def to_yolo(
     :type log_progress: :class:`bool`
     :param progress_cb: Function for tracking conversion progress (for all items in the project).
     :type progress_cb: callable, optional
+    :param val_datasets:    List of dataset names for validation.
+                            Full dataset names are required (e.g., 'ds0/nested_ds1/ds3').
+                            If specified, datasets from the list will be marked as val, others as train.
+                            If not specified, the function will determine the validation datasets automatically.
+    :type val_datasets: :class:`list`, optional
+    :param is_val: Whether the dataset is for validation.
+    :type is_val: :class:`bool`, optional
     :return: None, list of YOLO lines, or path to the destination directory.
     :rtype: NoneType, list, str
 
@@ -711,7 +766,7 @@ def to_yolo(
 
         # Convert Dataset to YOLO format
         dataset: sly.Dataset = project_fs.datasets.get("dataset_name")
-        sly.convert.to_yolo(dataset, dest_dir="./yolo", meta=project_fs.meta)
+        sly.convert.to_yolo(dataset, dest_dir="./yolo", meta=project_fs.meta, is_val=True)
     """
     if isinstance(input_data, str):
         try:
@@ -728,6 +783,7 @@ def to_yolo(
             task_type=task_type,
             log_progress=log_progress,
             progress_cb=progress_cb,
+            val_datasets=val_datasets,
         )
     elif isinstance(input_data, Dataset):
         return sly_ds_to_yolo(
@@ -737,6 +793,20 @@ def to_yolo(
             task_type=task_type,
             log_progress=log_progress,
             progress_cb=progress_cb,
+            is_val=is_val,
         )
     else:
         raise ValueError("Unsupported input type. Only Project or Dataset are supported.")
+
+
+def validate_task_type(task_type: Literal["detect", "segment", "pose"]) -> str:
+    if task_type not in [YOLOTaskType.DETECT, YOLOTaskType.SEGMENT, YOLOTaskType.POSE]:
+        task_type = SLY_YOLO_TASK_TYPE_MAP.get(task_type)
+        if task_type is None:
+            raise ValueError(
+                f"Unsupported task type: {task_type}. "
+                f"Supported types: '{YOLOTaskType.DETECT}', '{SLY_YOLO_TASK_TYPE_MAP[TaskType.OBJECT_DETECTION]}', "
+                f"'{YOLOTaskType.SEGMENT}', '{SLY_YOLO_TASK_TYPE_MAP[TaskType.INSTANCE_SEGMENTATION]}', "
+                f"'{YOLOTaskType.POSE}', '{SLY_YOLO_TASK_TYPE_MAP[TaskType.POSE_ESTIMATION]}'"
+            )
+    return task_type

supervisely/nn/inference/gui/serving_gui_template.py

@@ -23,7 +23,7 @@ from supervisely.app.widgets.pretrained_models_selector.pretrained_models_select
 )
 from supervisely.nn.experiments import get_experiment_infos
 from supervisely.nn.inference.gui.serving_gui import ServingGUI
-from supervisely.nn.utils import ModelSource, RuntimeType
+from supervisely.nn.utils import ModelSource, RuntimeType, _get_model_name
 
 
 class ServingGUITemplate(ServingGUI):
@@ -149,8 +149,7 @@ class ServingGUITemplate(ServingGUI):
     @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")
+            return _get_model_name(self.model_info)
         else:
             return self.model_info.get("model_name")
 

supervisely/nn/inference/inference.py

@@ -75,6 +75,7 @@ from supervisely.nn.utils import (
     ModelPrecision,
     ModelSource,
     RuntimeType,
+    _get_model_name,
 )
 from supervisely.project import ProjectType
 from supervisely.project.download import download_to_cache, read_from_cached_project
@@ -173,9 +174,7 @@ class Inference:
             self._use_gui = False
             deploy_params, need_download = self._get_deploy_params_from_args()
             if need_download:
-                local_model_files = self._download_model_files(
-                    deploy_params["model_source"], deploy_params["model_files"], False
-                )
+                local_model_files = self._download_model_files(deploy_params, False)
                 deploy_params["model_files"] = local_model_files
             self._load_model_headless(**deploy_params)
 
@@ -210,14 +209,12 @@ class Inference:
                     self.initialize_gui()
 
             def on_serve_callback(
-                gui: Union[GUI.InferenceGUI, GUI.ServingGUI, GUI.ServingGUITemplate]
+                gui: Union[GUI.InferenceGUI, GUI.ServingGUI, GUI.ServingGUITemplate],
             ):
                 Progress("Deploying model ...", 1)
                 if isinstance(self.gui, GUI.ServingGUITemplate):
                     deploy_params = self.get_params_from_gui()
-                    model_files = self._download_model_files(
-                        deploy_params["model_source"], deploy_params["model_files"]
-                    )
+                    model_files = self._download_model_files(deploy_params)
                     deploy_params["model_files"] = model_files
                     self._load_model_headless(**deploy_params)
                 elif isinstance(self.gui, GUI.ServingGUI):
@@ -230,7 +227,7 @@ class Inference:
                     gui.show_deployed_model_info(self)
 
             def on_change_model_callback(
-                gui: Union[GUI.InferenceGUI, GUI.ServingGUI, GUI.ServingGUITemplate]
+                gui: Union[GUI.InferenceGUI, GUI.ServingGUI, GUI.ServingGUITemplate],
             ):
                 self.shutdown_model()
                 if isinstance(self.gui, (GUI.ServingGUI, GUI.ServingGUITemplate)):
@@ -567,13 +564,23 @@ class Inference:
     def _checkpoints_cache_dir(self):
         return os.path.join(os.path.expanduser("~"), ".cache", "supervisely", "checkpoints")
 
-    def _download_model_files(
-        self, model_source: str, model_files: List[str], log_progress: bool = True
-    ) -> dict:
-        if model_source == ModelSource.PRETRAINED:
-            return self._download_pretrained_model(model_files, log_progress)
-        elif model_source == ModelSource.CUSTOM:
-            return self._download_custom_model(model_files, log_progress)
+    def _download_model_files(self, deploy_params: dict, log_progress: bool = True) -> dict:
+        if deploy_params["runtime"] != RuntimeType.PYTORCH:
+            export = deploy_params["model_info"].get("export", {})
+            export_model = export.get(deploy_params["runtime"], None)
+            if export_model is not None:
+                if sly_fs.get_file_name(export_model) == sly_fs.get_file_name(
+                    deploy_params["model_files"]["checkpoint"]
+                ):
+                    deploy_params["model_files"]["checkpoint"] = (
+                        deploy_params["model_info"]["artifacts_dir"] + export_model
+                    )
+                    logger.info(f"Found model checkpoint for '{deploy_params['runtime']}'")
+
+        if deploy_params["model_source"] == ModelSource.PRETRAINED:
+            return self._download_pretrained_model(deploy_params["model_files"], log_progress)
+        elif deploy_params["model_source"] == ModelSource.CUSTOM:
+            return self._download_custom_model(deploy_params["model_files"], log_progress)
 
     def _download_pretrained_model(self, model_files: dict, log_progress: bool = True):
         """
@@ -2929,9 +2936,7 @@ class Inference:
                 state = request.state.state
                 deploy_params = state["deploy_params"]
                 if isinstance(self.gui, GUI.ServingGUITemplate):
-                    model_files = self._download_model_files(
-                        deploy_params["model_source"], deploy_params["model_files"]
-                    )
+                    model_files = self._download_model_files(deploy_params)
                     deploy_params["model_files"] = model_files
                     self._load_model_headless(**deploy_params)
                 elif isinstance(self.gui, GUI.ServingGUI):
@@ -3061,7 +3066,7 @@ class Inference:
                 raise ValueError("No pretrained models found.")
 
             model = self.pretrained_models[0]
-            model_name = model.get("meta", {}).get("model_name", None)
+            model_name = _get_model_name(model)
             if model_name is None:
                 raise ValueError("No model name found in the first pretrained model.")
 
@@ -3126,7 +3131,7 @@ class Inference:
             meta = m.get("meta", None)
             if meta is None:
                 continue
-            model_name = meta.get("model_name", None)
+            model_name = _get_model_name(m)
             if model_name is None:
                 continue
             m_files = meta.get("model_files", None)
@@ -3135,7 +3140,7 @@ class Inference:
             checkpoint = m_files.get("checkpoint", None)
             if checkpoint is None:
                 continue
-            if model == m["meta"]["model_name"]:
+            if model.lower() == model_name.lower():
                 model_info = m
                 model_source = ModelSource.PRETRAINED
                 model_files = {"checkpoint": checkpoint}
@@ -3153,8 +3158,6 @@ class Inference:
             model_meta_path = os.path.join(artifacts_dir, "model_meta.json")
             model_info["model_meta"] = self._load_json_file(model_meta_path)
             original_model_files = model_info.get("model_files")
-            if not original_model_files:
-                raise ValueError("Invalid 'experiment_info.json'. Missing 'model_files' key.")
             return model_info, original_model_files
 
         def _prepare_local_model_files(artifacts_dir, checkpoint_path, original_model_files):
@@ -3201,6 +3204,7 @@ class Inference:
             model_files = _prepare_local_model_files(
                 artifacts_dir, checkpoint_path, original_model_files
             )
+
         else:
             local_artifacts_dir = os.path.join(
                 self.model_dir, "local_deploy", os.path.basename(artifacts_dir)
@@ -3298,7 +3302,11 @@ class Inference:
             if draw:
                 raise ValueError("Draw visualization is not supported for project inference")
 
-            state = {"projectId": project_id, "dataset_ids": dataset_ids, "settings": settings}
+            state = {
+                "projectId": project_id,
+                "dataset_ids": dataset_ids,
+                "settings": settings,
+            }
             if upload:
                 source_project = api.project.get_info_by_id(project_id)
                 workspace_id = source_project.workspace_id
@@ -3472,7 +3480,7 @@ class Inference:
     def _add_workflow_input(self, model_source: str, model_files: dict, model_info: dict):
         if model_source == ModelSource.PRETRAINED:
             checkpoint_url = model_info["meta"]["model_files"]["checkpoint"]
-            checkpoint_name = model_info["meta"]["model_name"]
+            checkpoint_name = _get_model_name(model_info)
         else:
             checkpoint_name = sly_fs.get_file_name_with_ext(model_files["checkpoint"])
             checkpoint_url = os.path.join(

supervisely/nn/training/gui/classes_selector.py

@@ -4,21 +4,28 @@ from supervisely.app.widgets import Button, Card, ClassesTable, Container, Text
 
 class ClassesSelector:
     title = "Classes Selector"
-    description = (
-        "Select classes that will be used for training. "
-        "Supported shapes are Bitmap, Polygon, Rectangle."
-    )
+    description = "Select classes that will be used for training"
     lock_message = "Select training and validation splits to unlock"
 
     def __init__(self, project_id: int, classes: list, app_options: dict = {}):
+        # Init widgets
+        self.qa_stats_text = None
+        self.classes_table = None
+        self.validator_text = None
+        self.button = None
+        self.container = None
+        self.card = None
+        # -------------------------------- #
+
         self.display_widgets = []
+        self.app_options = app_options
 
         # GUI Components
         if is_development() or is_debug_with_sly_net():
             qa_stats_link = abs_url(f"projects/{project_id}/stats/datasets")
         else:
             qa_stats_link = f"/projects/{project_id}/stats/datasets"
-        qa_stats_text = Text(
+        self.qa_stats_text = Text(
             text=f"<i class='zmdi zmdi-chart-donut' style='color: #7f858e'></i> <a href='{qa_stats_link}' target='_blank'> <b> QA & Stats </b></a>"
         )
 
@@ -32,7 +39,7 @@ class ClassesSelector:
         self.validator_text.hide()
         self.button = Button("Select")
         self.display_widgets.extend(
-            [qa_stats_text, self.classes_table, self.validator_text, self.button]
+            [self.qa_stats_text, self.classes_table, self.validator_text, self.button]
         )
         # -------------------------------- #
 
@@ -42,7 +49,7 @@ class ClassesSelector:
             description=self.description,
             content=self.container,
             lock_message=self.lock_message,
-            collapsable=app_options.get("collapsable", False),
+            collapsable=self.app_options.get("collapsable", False),
         )
         self.card.lock()
 
@@ -62,14 +69,14 @@ class ClassesSelector:
     def validate_step(self) -> bool:
         self.validator_text.hide()
 
-        if len(self.classes_table.project_meta.obj_classes) == 0:
+        project_classes = self.classes_table.project_meta.obj_classes
+        if len(project_classes) == 0:
             self.validator_text.set(text="Project has no classes", status="error")
             self.validator_text.show()
             return False
 
         selected_classes = self.classes_table.get_selected_classes()
         table_data = self.classes_table._table_data
-
         empty_classes = [
             row[0]["data"]
             for row in table_data
@@ -78,23 +85,21 @@ class ClassesSelector:
 
         n_classes = len(selected_classes)
         if n_classes == 0:
-            self.validator_text.set(text="Please select at least one class", status="error")
+            message = "Please select at least one class"
+            status = "error"
         else:
-            warning_text = ""
+            class_text = "class" if n_classes == 1 else "classes"
+            message = f"Selected {n_classes} {class_text}"
             status = "success"
             if empty_classes:
                 intersections = set(selected_classes).intersection(empty_classes)
                 if intersections:
-                    warning_text = (
-                        f". Selected class has no annotations: {', '.join(intersections)}"
-                        if len(intersections) == 1
-                        else f". Selected classes have no annotations: {', '.join(intersections)}"
+                    class_text = "class" if len(intersections) == 1 else "classes"
+                    message += (
+                        f". Selected {class_text} have no annotations: {', '.join(intersections)}"
                     )
                     status = "warning"
 
-            class_text = "class" if n_classes == 1 else "classes"
-            self.validator_text.set(
-                text=f"Selected {n_classes} {class_text}{warning_text}", status=status
-            )
+        self.validator_text.set(text=message, status=status)
         self.validator_text.show()
         return n_classes > 0