supervisely 6.73.260__tar.gz → 6.73.262__tar.gz

{supervisely-6.73.260/supervisely.egg-info → supervisely-6.73.262}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.260
+Version: 6.73.262
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.260 → supervisely-6.73.262}/supervisely/app/widgets/experiment_selector/experiment_selector.py

@@ -19,6 +19,8 @@ from supervisely.app.widgets import (
 )
 from supervisely.io.fs import get_file_name_with_ext
 from supervisely.nn.experiments import ExperimentInfo
+from supervisely.nn.utils import ModelSource
+
 
 WEIGHTS_DIR = "weights"
 
@@ -473,6 +475,17 @@ class ExperimentSelector(Widget):
         full_model_files["checkpoint"] = self.get_selected_checkpoint_path()
         return full_model_files
 
+    def get_deploy_params(self) -> Dict[str, Any]:
+        """
+        Returns a dictionary with deploy parameters except runtime and device keys.
+        """
+        deploy_params = {
+            "model_source": ModelSource.CUSTOM,
+            "model_files": self.get_model_files(),
+            "model_info": self.get_selected_experiment_info(),
+        }
+        return deploy_params
+
     def set_active_row(self, row_index: int) -> None:
         if row_index < 0 or row_index > len(self._rows) - 1:
             raise ValueError(f'Row with index "{row_index}" does not exist')

{supervisely-6.73.260 → supervisely-6.73.262}/supervisely/app/widgets/pretrained_models_selector/pretrained_models_selector.py

@@ -1,9 +1,10 @@
-from typing import Dict, List, Union
+from typing import Dict, List, Literal, Union
 
 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
 
 
 class PretrainedModelsSelector(Widget):
@@ -134,39 +135,71 @@ class PretrainedModelsSelector(Widget):
             selected_row_index = int(widget_actual_state["selectedRow"])
             return models[selected_row_index]
 
-    def get_selected_model_params(self, model_name_column: str = "Model") -> Union[Dict, None]:
+    def get_selected_model_params(
+        self,
+        model_name_column: str = "Model",
+        train_version: Literal["v1", "v2"] = "v1",
+    ) -> Union[Dict, None]:
         selected_model = self.get_selected_row()
         if selected_model is None:
             return {}
 
-        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."
-            )
-        checkpoint_url = selected_model.get("meta", {}).get("weights_url")
-        if checkpoint_url is None:
-            pass
-
-        checkpoint_ext = get_file_ext(checkpoint_url)
-        checkpoint_name = f"{model_name.lower()}{checkpoint_ext}"
-
-        task_type = self.get_selected_task_type()
-        model_params = {
-            "model_source": "Pretrained models",
-            "task_type": task_type,
-            "checkpoint_name": checkpoint_name,
-            "checkpoint_url": checkpoint_url,
-        }
-
-        if len(self._arch_types) > 1:
-            arch_type = self.get_selected_arch_type()
-            model_params["arch_type"] = arch_type
-
-        config_url = selected_model.get("meta", {}).get("config_url")
-        if config_url is not None:
-            model_params["config_url"] = config_url
+        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_meta = selected_model.get("meta")
+            if model_meta is None:
+                raise ValueError(
+                    "Could not find model meta. Make sure you have key 'meta' in your models configuration list."
+                )
+            checkpoint_url = model_meta.get("weights_url")
+            if checkpoint_url is None:
+                model_files = model_meta.get("model_files")
+                if model_files is None:
+                    raise ValueError(
+                        "Could not find model files. Make sure you have key 'model_files' or 'weights_url' in 'meta' in your models configuration list."
+                    )
+                checkpoint_url = model_files.get("checkpoint")
+                if checkpoint_url is None:
+                    raise ValueError(
+                        "Could not find checkpoint url. Make sure you have key 'checkpoint' in 'model_files' in 'meta' in your models configuration list."
+                    )
+
+            checkpoint_ext = get_file_ext(checkpoint_url)
+            checkpoint_name = f"{model_name.lower()}{checkpoint_ext}"
+
+            task_type = self.get_selected_task_type()
+            model_params = {
+                "model_source": "Pretrained models",
+                "task_type": task_type,
+                "checkpoint_name": checkpoint_name,
+                "checkpoint_url": checkpoint_url,
+            }
 
+            if len(self._arch_types) > 1:
+                arch_type = self.get_selected_arch_type()
+                model_params["arch_type"] = arch_type
+
+            config_url = selected_model.get("meta", {}).get("config_url")
+            if config_url is not None:
+                model_params["config_url"] = config_url
+        elif train_version == "v2":
+            model_info = self.get_selected_row()
+            meta = model_info.get("meta")
+            if meta is None:
+                raise ValueError("key 'meta' not found in model configuration")
+            model_files = meta.get("model_files")
+            if model_files is None:
+                raise ValueError("key 'model_files' not found in key 'meta' in model configuration")
+            model_params = {
+                "model_source": ModelSource.PRETRAINED,
+                "model_info": model_info,
+                "model_files": model_files,
+            }
         return model_params
 
     def get_selected_row_index(self, state=StateJson()) -> Union[int, None]:

{supervisely-6.73.260 → supervisely-6.73.262}/supervisely/nn/artifacts/artifacts.py

@@ -536,58 +536,62 @@ class BaseTrainArtifacts:
             api: Api, train_info: TrainInfo
         ) -> ExperimentInfo:
 
-            checkpoints = []
-            for chk in train_info.checkpoints:
-                if self.weights_folder:
-                    checkpoints.append(join(self.weights_folder, chk.name))
-                else:
-                    checkpoints.append(chk.name)
-
-            best_checkpoint = next(
-                (chk.name for chk in train_info.checkpoints if "best" in chk.name), None
-            )
-            if not best_checkpoint and checkpoints:
-                best_checkpoint = get_file_name_with_ext(checkpoints[-1])
-
-            task_info = api.task.get_info_by_id(train_info.task_id)
-            workspace_id = task_info["workspaceId"]
-
-            project = api.project.get_info_by_name(workspace_id, train_info.project_name)
-            project_id = project.id if project else None
-
-            model_files = {}
-            if train_info.config_path:
-                model_files["config"] = self.get_config_path(train_info.artifacts_folder).replace(
-                    train_info.artifacts_folder, ""
+            try:
+                checkpoints = []
+                for chk in train_info.checkpoints:
+                    if self.weights_folder:
+                        checkpoints.append(join(self.weights_folder, chk.name))
+                    else:
+                        checkpoints.append(chk.name)
+
+                best_checkpoint = next(
+                    (chk.name for chk in train_info.checkpoints if "best" in chk.name), None
                 )
-
-            input_datetime = task_info["startedAt"]
-            parsed_datetime = datetime.strptime(input_datetime, "%Y-%m-%dT%H:%M:%S.%fZ")
-            date_time = parsed_datetime.strftime("%Y-%m-%d %H:%M:%S")
-
-            experiment_info_data = {
-                "experiment_name": f"Unknown {self.framework_name} experiment",
-                "framework_name": self.framework_name,
-                "model_name": f"Unknown {self.framework_name} model",
-                "task_type": train_info.task_type,
-                "project_id": project_id,
-                "task_id": train_info.task_id,
-                "model_files": model_files,
-                "checkpoints": checkpoints,
-                "best_checkpoint": best_checkpoint,
-                "artifacts_dir": train_info.artifacts_folder,
-                "datetime": date_time,
-            }
-
-            experiment_info_fields = {
-                field.name
-                for field in ExperimentInfo.__dataclass_fields__.values()  # pylint: disable=no-member
-            }
-            for field in experiment_info_fields:
-                if field not in experiment_info_data:
-                    experiment_info_data[field] = None
-
-            return ExperimentInfo(**experiment_info_data)
+                if not best_checkpoint and checkpoints:
+                    best_checkpoint = get_file_name_with_ext(checkpoints[-1])
+
+                task_info = api.task.get_info_by_id(train_info.task_id)
+                workspace_id = task_info["workspaceId"]
+
+                project = api.project.get_info_by_name(workspace_id, train_info.project_name)
+                project_id = project.id if project else None
+
+                model_files = {}
+                if train_info.config_path:
+                    model_files["config"] = self.get_config_path(
+                        train_info.artifacts_folder
+                    ).replace(train_info.artifacts_folder, "")
+
+                input_datetime = task_info["startedAt"]
+                parsed_datetime = datetime.strptime(input_datetime, "%Y-%m-%dT%H:%M:%S.%fZ")
+                date_time = parsed_datetime.strftime("%Y-%m-%d %H:%M:%S")
+
+                experiment_info_data = {
+                    "experiment_name": f"Unknown {self.framework_name} experiment",
+                    "framework_name": self.framework_name,
+                    "model_name": f"Unknown {self.framework_name} model",
+                    "task_type": train_info.task_type,
+                    "project_id": project_id,
+                    "task_id": train_info.task_id,
+                    "model_files": model_files,
+                    "checkpoints": checkpoints,
+                    "best_checkpoint": best_checkpoint,
+                    "artifacts_dir": train_info.artifacts_folder,
+                    "datetime": date_time,
+                }
+
+                experiment_info_fields = {
+                    field.name
+                    for field in ExperimentInfo.__dataclass_fields__.values()  # pylint: disable=no-member
+                }
+                for field in experiment_info_fields:
+                    if field not in experiment_info_data:
+                        experiment_info_data[field] = None
+
+                return ExperimentInfo(**experiment_info_data)
+            except Exception as e:
+                logger.warning(f"Failed to build experiment info: {e}")
+                return None
 
         train_infos = self.get_list(sort)
 

{supervisely-6.73.260 → supervisely-6.73.262}/supervisely/nn/inference/cache.py

@@ -1,11 +1,11 @@
 import json
 import shutil
+import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from enum import Enum
 from logging import Logger
 from pathlib import Path
 from threading import Lock, Thread
-from time import sleep
 from typing import Any, Callable, Generator, List, Optional, Tuple, Union
 
 import cv2
@@ -140,7 +140,7 @@ class PersistentImageTTLCache(TTLCache):
         self[video_id] = video_path
         if src_video_path != str(video_path):
             shutil.move(src_video_path, str(video_path))
-        sly.logger.debug(f"Saved video to {video_path}")
+        sly.logger.debug(f"Video #{video_id} saved to {video_path}", extra={"video_id": video_id})
 
     def get_video_path(self, video_id: int) -> Path:
         return self[video_id]
@@ -197,12 +197,14 @@ class InferenceImageCache:
         ttl: int,
         is_persistent: bool = True,
         base_folder: str = sly.env.smart_cache_container_dir(),
+        log_progress: bool = False,
     ) -> None:
         self.is_persistent = is_persistent
         self._maxsize = maxsize
         self._ttl = ttl
         self._lock = Lock()
-        self._load_queue = CacheOut(10 * 60)
+        self._load_queue = CacheOut(ttl=10 * 60)
+        self.log_progress = log_progress
 
         if is_persistent:
             self._data_dir = Path(base_folder)
@@ -342,11 +344,13 @@ class InferenceImageCache:
                 Thread(
                     target=self.download_video,
                     args=(api, video_id),
-                    kwargs={"return_images": False},
+                    kwargs={**kwargs, "return_images": False},
                 ).start()
         elif redownload_video:
             Thread(
-                target=self.download_video, args=(api, video_id), kwargs={"return_images": False}
+                target=self.download_video,
+                args=(api, video_id),
+                kwargs={**kwargs, "return_images": False},
             ).start()
 
         def name_constuctor(frame_index: int):
@@ -371,6 +375,7 @@ class InferenceImageCache:
             with self._lock:
                 self._cache.save_video(video_id, str(video_path))
                 self._load_queue.delete(video_id)
+            sly.logger.debug(f"Video #{video_id} added to cache", extra={"video_id": video_id})
         else:
             cap = cv2.VideoCapture(str(video_path))
             frame_index = 0
@@ -396,17 +401,57 @@ class InferenceImageCache:
         """
         return_images = kwargs.get("return_images", True)
         progress_cb = kwargs.get("progress_cb", None)
+        video_info = kwargs.get("video_info", api.video.get_info_by_id(video_id))
 
-        video_info = api.video.get_info_by_id(video_id)
         self._wait_if_in_queue(video_id, api.logger)
         if not video_id in self._cache:
+            download_time = time.monotonic()
             self._load_queue.set(video_id, video_id)
-            sly.logger.debug("Downloading video #%s", video_id)
-            temp_video_path = Path("/tmp/smart_cache").joinpath(
-                f"_{sly.rand_str(6)}_" + video_info.name
-            )
-            api.video.download_path(video_id, temp_video_path, progress_cb=progress_cb)
-            self.add_video_to_cache(video_id, temp_video_path)
+            try:
+                sly.logger.debug("Downloading video #%s", video_id)
+                if progress_cb is None and self.log_progress:
+                    size = video_info.file_meta.get("size", None)
+                    if size is None:
+                        size = "unknown"
+                    else:
+                        size = int(size)
+
+                    prog_n = 0
+                    prog_t = time.monotonic()
+
+                    def _progress_cb(n):
+                        nonlocal prog_n
+                        nonlocal prog_t
+                        prog_n += n
+                        cur_t = time.monotonic()
+                        if cur_t - prog_t > 3 or (isinstance(size, int) and prog_n >= size):
+                            prog_t = cur_t
+                            percent_str = ""
+                            if isinstance(size, int):
+                                percent_str = f" ({(prog_n*100) // size}%)"
+                            prog_str = (
+                                f"{(prog_n / 1000000):.2f}/{(size / 1000000):.2f} MB{percent_str}"
+                            )
+                            sly.logger.debug(
+                                "Downloading video #%s: %s",
+                                video_id,
+                                prog_str,
+                            )
+
+                    progress_cb = _progress_cb
+                temp_video_path = Path("/tmp/smart_cache").joinpath(
+                    f"_{sly.rand_str(6)}_" + video_info.name
+                )
+                api.video.download_path(video_id, temp_video_path, progress_cb=progress_cb)
+                self.add_video_to_cache(video_id, temp_video_path)
+                download_time = time.monotonic() - download_time
+                api.logger.debug(
+                    f"Video #{video_id} downloaded to cache in {download_time:.2f} sec",
+                    extra={"video_id": video_id, "download_time": download_time},
+                )
+            except Exception as e:
+                self._load_queue.delete(video_id)
+                raise e
         if return_images:
             return self.get_frames_from_cache(video_id, list(range(video_info.frames_count)))
 
@@ -664,6 +709,7 @@ class InferenceImageCache:
                 for pos, image in executor.map(get_one_image, items):
                     all_frames[pos] = image
 
+        download_time = time.monotonic()
         if len(indexes_to_load) > 0:
             for id_or_hash, image in load_generator(indexes_to_load):
                 name = name_cunstructor(id_or_hash)
@@ -672,9 +718,13 @@ class InferenceImageCache:
                 if return_images:
                     pos = pos_by_name[name]
                     all_frames[pos] = image
+        download_time = time.monotonic() - download_time
 
         # logger.debug(f"All stored files: {sorted(os.listdir(self.tmp_path))}")
-        logger.debug(f"Images/Frames added to cache: {indexes_to_load}")
+        logger.debug(
+            f"Images/Frames added to cache: {indexes_to_load} in {download_time:.2f} sec",
+            extra={"indexes": indexes_to_load, "download_time": download_time},
+        )
         logger.debug(f"Images/Frames found in cache: {set(indexes).difference(indexes_to_load)}")
 
         if return_images:
@@ -686,8 +736,8 @@ class InferenceImageCache:
             logger.debug(f"Waiting for other task to load {name}")
 
         while name in self._load_queue:
-            # TODO: sleep if slowdown
-            sleep(0.1)
+            # TODO: time.sleep if slowdown
+            time.sleep(0.1)
             continue
 
     def download_frames_to_paths(self, api, video_id, frame_indexes, paths, progress_cb=None):

{supervisely-6.73.260 → supervisely-6.73.262}/supervisely/nn/inference/inference.py

@@ -228,6 +228,7 @@ class Inference:
             ttl=env.smart_cache_ttl(),
             is_persistent=True,
             base_folder=env.smart_cache_container_dir(),
+            log_progress=True,
         )
 
     def get_batch_size(self):
@@ -571,7 +572,9 @@ class Inference:
                     ) as download_pbar:
                         self.gui.download_progress.show()
                         sly_fs.download(
-                            url=file_url, save_path=file_path, progress=download_pbar.update
+                            url=file_url,
+                            save_path=file_path,
+                            progress=download_pbar.update,
                         )
                     local_model_files[file] = file_path
             else:
@@ -590,6 +593,10 @@ class Inference:
         for file in model_files:
             file_url = model_files[file]
             file_info = self.api.file.get_info_by_path(team_id, file_url)
+            if file_info is None:
+                raise FileNotFoundError(
+                    f"File '{file_url}' not found in Team Files. Make sure the file exists."
+                )
             file_size = file_info.sizeb
             file_name = os.path.basename(file_url)
             file_path = os.path.join(self.model_dir, file_name)
@@ -1374,7 +1381,11 @@ class Inference:
         return result
 
     def _inference_images_ids(
-        self, api: Api, state: dict, images_ids: List[int], async_inference_request_uuid: str = None
+        self,
+        api: Api,
+        state: dict,
+        images_ids: List[int],
+        async_inference_request_uuid: str = None,
     ):
         """Inference images by ids.
         If "output_project_id" in state, upload images and annotations to the output project.
@@ -1799,7 +1810,8 @@ class Inference:
             dataset_id = _get_or_create_new_dataset(output_project_id, src_dataset_id)
             image_names = [result["image_name"] for result in results]
             image_infos = api.image.get_list(
-                dataset_id, filters=[{"field": "name", "operator": "in", "value": image_names}]
+                dataset_id,
+                filters=[{"field": "name", "operator": "in", "value": image_names}],
             )
             meta_changed = False
             anns = []
@@ -2104,7 +2116,10 @@ class Inference:
                 # Read images
                 if cache_project_on_model:
                     images_nps = []
-                    for dataset_id, images_infos in images_infos_batch_by_dataset.items():
+                    for (
+                        dataset_id,
+                        images_infos,
+                    ) in images_infos_batch_by_dataset.items():
                         dataset_info = datasets_infos_dict[dataset_id]
                         images_paths, _ = zip(
                             *read_from_cached_project(
@@ -2116,7 +2131,10 @@ class Inference:
                         images_nps.extend([sly_image.read(path) for path in images_paths])
                 else:
                     images_nps = []
-                    for dataset_id, images_infos in images_infos_batch_by_dataset.items():
+                    for (
+                        dataset_id,
+                        images_infos,
+                    ) in images_infos_batch_by_dataset.items():
                         images_nps.extend(
                             self.cache.download_images(
                                 api,
@@ -2845,7 +2863,8 @@ def update_meta_and_ann(meta: ProjectMeta, ann: Annotation):
     """Update project meta and annotation to match each other
     If obj class or tag meta from annotation conflicts with project meta
     add suffix to obj class or tag meta.
-    Return tuple of updated project meta, annotation and boolean flag if meta was changed."""
+    Return tuple of updated project meta, annotation and boolean flag if meta was changed.
+    """
     obj_classes_suffixes = ["_nn"]
     tag_meta_suffixes = ["_nn"]
     ann_obj_classes = {}

{supervisely-6.73.260 → supervisely-6.73.262}/supervisely/nn/inference/tracking/bbox_tracking.py

@@ -1,6 +1,7 @@
 import functools
 import json
 import time
+import uuid
 from pathlib import Path
 from queue import Queue
 from threading import Event, Thread
@@ -154,7 +155,8 @@ class BBoxTracking(Inference):
             raise
         stop_upload_event.set()
 
-    def _track_api(self, api: sly.Api, context: dict):
+    def _track_api(self, api: sly.Api, context: dict, request_uuid: str = None):
+        track_t = time.monotonic()
         # unused fields:
         context["trackId"] = "auto"
         context["objectIds"] = []
@@ -193,15 +195,27 @@ class BBoxTracking(Inference):
                 video_id=video_interface.video_id,
             )
 
-        api.logger.info("Start tracking.")
-
         predictions = []
-        for input_geom in input_bboxes:
+        frames_n = video_interface.frames_count
+        box_n = len(input_bboxes)
+        geom_t = time.monotonic()
+        api.logger.info(
+            "Start tracking.",
+            extra={
+                "video_id": video_interface.video_id,
+                "frame_range": range_of_frames,
+                "geometries_count": box_n,
+                "frames_count": frames_n,
+                "request_uuid": request_uuid,
+            },
+        )
+        for box_i, input_geom in enumerate(input_bboxes, 1):
             input_bbox = input_geom["data"]
             bbox = sly.Rectangle.from_json(input_bbox)
             predictions_for_object = []
             init = False
-            for _ in video_interface.frames_loader_generator():
+            frame_t = time.monotonic()
+            for frame_i, _ in enumerate(video_interface.frames_loader_generator(), 1):
                 imgs = video_interface.frames
                 target = PredictionBBox(
                     "",  # TODO: can this be useful?
@@ -224,10 +238,40 @@ class BBoxTracking(Inference):
                 predictions_for_object.append(
                     {"type": sly_geometry.geometry_name(), "data": sly_geometry.to_json()}
                 )
+                api.logger.debug(
+                    "Frame processed. Geometry: [%d / %d]. Frame: [%d / %d]",
+                    box_i,
+                    box_n,
+                    frame_i,
+                    frames_n,
+                    extra={
+                        "geometry_index": box_i,
+                        "frame_index": frame_i,
+                        "processing_time": time.monotonic() - frame_t,
+                        "request_uuid": request_uuid,
+                    },
+                )
+                frame_t = time.monotonic()
+
             predictions.append(predictions_for_object)
+            api.logger.info(
+                "Geometry processed. Progress: [%d / %d]",
+                box_i,
+                box_n,
+                extra={
+                    "geometry_index": box_i,
+                    "processing_time": time.monotonic() - geom_t,
+                    "request_uuid": request_uuid,
+                },
+            )
+            geom_t = time.monotonic()
 
         # predictions must be NxK bboxes: N=number of frames, K=number of objects
         predictions = list(map(list, zip(*predictions)))
+        api.logger.info(
+            "Tracking finished.",
+            extra={"tracking_time": time.monotonic() - track_t, "request_uuid": request_uuid},
+        )
         return predictions
 
     def _inference(self, frames: List[np.ndarray], geometries: List[Geometry], settings: dict):
@@ -322,8 +366,19 @@ class BBoxTracking(Inference):
 
         @server.post("/track-api")
         def track_api(request: Request):
-            sly.logger.info("Start tracking.")
-            return self._track_api(request.state.api, request.state.context)
+            inference_request_uuid = uuid.uuid5(
+                namespace=uuid.NAMESPACE_URL, name=f"{time.time()}"
+            ).hex
+            sly.logger.info(
+                "Received track-api request.", extra={"request_uuid": inference_request_uuid}
+            )
+            result = self._track_api(
+                request.state.api, request.state.context, request_uuid=inference_request_uuid
+            )
+            sly.logger.info(
+                "Track-api request processed.", extra={"request_uuid": inference_request_uuid}
+            )
+            return result
 
         @server.post("/track-api-files")
         def track_api_files(

{supervisely-6.73.260 → supervisely-6.73.262}/supervisely/nn/inference/tracking/tracker_interface.py

@@ -73,7 +73,7 @@ class TrackerInterface:
 
         self.geometries[start_fig] = geometries[-1]
 
-    def frames_loader_generator(self, batch_size=16) -> Generator[None, None, None]:
+    def frames_loader_generator(self, batch_size=4) -> Generator[None, None, None]:
         if self.load_all_frames:
             self._cur_frames_indexes = self.frames_indexes
             yield

{supervisely-6.73.260 → supervisely-6.73.262/supervisely.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.260
+Version: 6.73.262
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely