supervisely 6.73.452__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/nn/inference/inference.py

@@ -5,12 +5,14 @@ import asyncio
 import inspect
 import json
 import os
+import queue
 import re
 import shutil
 import subprocess
 import tempfile
 import threading
 import time
+import uuid
 from collections import OrderedDict, defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import asdict, dataclass
@@ -52,6 +54,7 @@ from supervisely.annotation.tag_meta import TagMeta, TagValueType
 from supervisely.api.api import Api, ApiField
 from supervisely.api.app_api import WorkflowMeta, WorkflowSettings
 from supervisely.api.image_api import ImageInfo
+from supervisely.api.video.video_api import VideoInfo
 from supervisely.app.content import get_data_dir
 from supervisely.app.fastapi.subapp import (
     Application,
@@ -67,6 +70,7 @@ from supervisely.decorators.inference import (
     process_images_batch_sliding_window,
 )
 from supervisely.geometry.any_geometry import AnyGeometry
+from supervisely.geometry.geometry import Geometry
 from supervisely.imaging.color import get_predefined_colors
 from supervisely.io.fs import list_files
 from supervisely.nn.experiments import ExperimentInfo
@@ -75,7 +79,7 @@ from supervisely.nn.inference.inference_request import (
     InferenceRequest,
     InferenceRequestsManager,
 )
-from supervisely.nn.inference.uploader import Uploader
+from supervisely.nn.inference.uploader import Downloader, Uploader
 from supervisely.nn.model.model_api import ModelAPI, Prediction
 from supervisely.nn.prediction_dto import Prediction as PredictionDTO
 from supervisely.nn.utils import (
@@ -94,6 +98,17 @@ from supervisely.project.project_meta import ProjectMeta
 from supervisely.sly_logger import logger
 from supervisely.task.progress import Progress
 from supervisely.video.video import ALLOWED_VIDEO_EXTENSIONS, VideoFrameReader
+from supervisely.video_annotation.frame import Frame
+from supervisely.video_annotation.frame_collection import FrameCollection
+from supervisely.video_annotation.key_id_map import KeyIdMap
+from supervisely.video_annotation.video_annotation import VideoAnnotation
+from supervisely.video_annotation.video_figure import VideoFigure
+from supervisely.video_annotation.video_object import VideoObject
+from supervisely.video_annotation.video_object_collection import (
+    VideoObject,
+    VideoObjectCollection,
+)
+from supervisely.video_annotation.video_tag_collection import VideoTagCollection
 
 try:
     from typing import Literal
@@ -140,6 +155,7 @@ class Inference:
     """Default batch size for inference"""
     INFERENCE_SETTINGS: str = None
     """Path to file with custom inference settings"""
+    DEFAULT_IOU_MERGE_THRESHOLD: float = 0.9
 
     def __init__(
         self,
@@ -193,7 +209,6 @@ class Inference:
         self._task_id = None
         self._sliding_window_mode = sliding_window_mode
         self._autostart_delay_time = 5 * 60  # 5 min
-        self._tracker = None
         self._hardware: str = None
         if custom_inference_settings is None:
             if self.INFERENCE_SETTINGS is not None:
@@ -427,7 +442,7 @@ class Inference:
 
                 device = "cuda" if torch.cuda.is_available() else "cpu"
             except Exception as e:
-                logger.warn(
+                logger.warning(
                     f"Device auto detection failed, set to default 'cpu', reason: {repr(e)}"
                 )
                 device = "cpu"
@@ -734,15 +749,15 @@ class Inference:
         for model in self.pretrained_models:
             model_meta = model.get("meta")
             if model_meta is not None:
-                model_name = model_meta.get("model_name")
-                if model_name is not None:
-                    if model_name.lower() == model_name.lower():
+                this_model_name = model_meta.get("model_name")
+                if this_model_name is not None:
+                    if this_model_name.lower() == model_name.lower():
                         selected_model = model
                         break
                 else:
-                    model_name = model.get("model_name")
-                    if model_name is not None:
-                        if model_name.lower() == model_name.lower():
+                    this_model_name = model.get("model_name")
+                    if this_model_name is not None:
+                        if this_model_name.lower() == model_name.lower():
                             selected_model = model
                             break
 
@@ -1359,6 +1374,7 @@ class Inference:
 
         if tracker == "botsort":
             from supervisely.nn.tracker import BotSortTracker
+
             device = tracker_settings.get("device", self.device)
             logger.debug(f"Initializing BotSort tracker with device: {device}")
             return BotSortTracker(settings=tracker_settings, device=device)
@@ -1375,15 +1391,15 @@ class Inference:
             if classes is not None:
                 num_classes = len(classes)
         except NotImplementedError:
-            logger.warn(f"get_classes() function not implemented for {type(self)} object.")
+            logger.warning(f"get_classes() function not implemented for {type(self)} object.")
         except AttributeError:
-            logger.warn("Probably, get_classes() function not working without model deploy.")
+            logger.warning("Probably, get_classes() function not working without model deploy.")
         except Exception as exc:
-            logger.warn("Unknown exception. Please, contact support")
+            logger.warning("Unknown exception. Please, contact support")
             logger.exception(exc)
 
         if num_classes is None:
-            logger.warn(f"get_classes() function return {classes}; skip classes processing.")
+            logger.warning(f"get_classes() function return {classes}; skip classes processing.")
 
         return {
             "app_name": get_name_from_env(default="Neural Network Serving"),
@@ -1401,6 +1417,42 @@ class Inference:
 
     # pylint: enable=method-hidden
 
+    def get_tracking_settings(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get default parameters for all available tracking algorithms.
+
+        Returns:
+            {"botsort": {"track_high_thresh": 0.6, ...}}
+            Empty dict if tracking not supported.
+        """
+        info = self.get_info()
+        trackers_params = {}
+
+        tracking_support = info.get("tracking_on_videos_support")
+        if not tracking_support:
+            return trackers_params
+
+        tracking_algorithms = info.get("tracking_algorithms", [])
+
+        for tracker_name in tracking_algorithms:
+            try:
+                if tracker_name == "botsort":
+                    from supervisely.nn.tracker import BotSortTracker
+
+                    trackers_params[tracker_name] = BotSortTracker.get_default_params()
+                # Add other trackers here as elif blocks
+                else:
+                    logger.debug(f"Tracker '{tracker_name}' not implemented")
+            except Exception as e:
+                logger.warning(f"Failed to get params for '{tracker_name}': {e}")
+
+        INTERNAL_FIELDS = {"device", "fps"}
+        for tracker_name, params in trackers_params.items():
+            trackers_params[tracker_name] = {
+                k: v for k, v in params.items() if k not in INTERNAL_FIELDS
+            }
+        return trackers_params
+
     def get_human_readable_info(self, replace_none_with: Optional[str] = None):
         hr_info = {}
         info = self.get_info()
@@ -1952,7 +2004,7 @@ class Inference:
         else:
             n_frames = frames_reader.frames_count()
 
-        self._tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
+        inference_request.tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
 
         progress_total = (n_frames + step - 1) // step
         inference_request.set_stage(InferenceRequest.Stage.INFERENCE, 0, progress_total)
@@ -1978,8 +2030,8 @@ class Inference:
                 settings=inference_settings,
             )
 
-            if self._tracker is not None:
-                anns = self._apply_tracker_to_anns(frames, anns)
+            if inference_request.tracker is not None:
+                anns = self._apply_tracker_to_anns(frames, anns, inference_request.tracker)
 
             predictions = [
                 Prediction(ann, model_meta=self.model_meta, frame_index=frame_index)
@@ -1994,10 +2046,9 @@ class Inference:
             inference_request.done(len(batch_results))
             logger.debug(f"Frames {batch[0]}-{batch[-1]} done.")
         video_ann_json = None
-        if self._tracker is not None:
+        if inference_request.tracker is not None:
             inference_request.set_stage("Postprocess...", 0, 1)
-
-            video_ann_json = self._tracker.video_annotation.to_json()
+            video_ann_json = inference_request.tracker.video_annotation.to_json()
             inference_request.done()
         result = {"ann": results, "video_ann": video_ann_json}
         inference_request.final_result = result.copy()
@@ -2029,7 +2080,7 @@ class Inference:
         upload_mode = state.get("upload_mode", None)
         iou_merge_threshold = inference_settings.get("existing_objects_iou_thresh", None)
         if upload_mode == "iou_merge" and iou_merge_threshold is None:
-            iou_merge_threshold = 0.7
+            iou_merge_threshold = self.DEFAULT_IOU_MERGE_THRESHOLD  # TODO: change to 0.9
 
         images_infos = api.image.get_info_by_id_batch(image_ids)
         images_infos_dict = {im_info.id: im_info for im_info in images_infos}
@@ -2071,14 +2122,9 @@ class Inference:
                 output_dataset_id
             ] = output_dataset_info
 
-        # start download to cache in background
-        dataset_image_infos: Dict[int, List[ImageInfo]] = defaultdict(list)
-        for image_info in images_infos:
-            dataset_image_infos[image_info.dataset_id].append(image_info)
-        for dataset_id, ds_image_infos in dataset_image_infos.items():
-            self.cache.run_cache_task_manually(
-                api, [info.id for info in ds_image_infos], dataset_id=dataset_id
-            )
+        def download_f(item: int):
+            self.cache.download_image(api, item)
+            return item
 
         _upload_predictions = partial(
             self.upload_predictions,
@@ -2094,7 +2140,9 @@ class Inference:
         )
 
         _add_results_to_request = partial(
-            self.add_results_to_request, inference_request=inference_request
+            self.add_results_to_request,
+            inference_request=inference_request,
+            progress_cb=inference_request.done,
         )
 
         if upload_mode is None:
@@ -2103,40 +2151,60 @@ class Inference:
             upload_f = _upload_predictions
 
         inference_request.set_stage(InferenceRequest.Stage.INFERENCE, 0, len(image_ids))
+        download_workers = max(8, min(batch_size, 64))
         with Uploader(upload_f, logger=logger) as uploader:
-            for image_ids_batch in batched(image_ids, batch_size=batch_size):
-                if uploader.has_exception():
-                    exception = uploader.exception
-                    raise exception
-                if inference_request.is_stopped():
-                    logger.debug(
-                        f"Cancelling inference project...",
-                        extra={"inference_request_uuid": inference_request.uuid},
-                    )
-                    break
-
-                images_nps = [self.cache.download_image(api, img_id) for img_id in image_ids_batch]
-                anns, slides_data = self._inference_auto(
-                    source=images_nps,
-                    settings=inference_settings,
-                )
+            with Downloader(download_f, max_workers=download_workers, logger=logger) as downloader:
+                for image_id in image_ids:
+                    downloader.put(image_id)
+                downloader.next(100)
+                for image_ids_batch in batched(image_ids, batch_size=batch_size):
+                    if uploader.has_exception():
+                        exception = uploader.exception
+                        raise exception
+                    if inference_request.is_stopped():
+                        logger.debug(
+                            f"Cancelling inference...",
+                            extra={"inference_request_uuid": inference_request.uuid},
+                        )
+                        break
+                    if inference_request.is_paused():
+                        logger.info("Inference request is paused. Waiting...")
+                        while inference_request.is_paused():
+                            if (
+                                inference_request.paused_for()
+                                > inference_request.PAUSE_SLEEP_MAX_WAIT
+                            ):
+                                logger.info(
+                                    "Inference request has been paused for too long. Cancelling..."
+                                )
+                                raise RuntimeError("Inference request cancelled due to long pause.")
+                            time.sleep(inference_request.PAUSE_SLEEP_INTERVAL)
 
-                batch_predictions = []
-                for image_id, ann, this_slides_data in zip(image_ids_batch, anns, slides_data):
-                    image_info: ImageInfo = images_infos_dict[image_id]
-                    dataset_info = dataset_infos_dict[image_info.dataset_id]
-                    prediction = Prediction(
-                        ann,
-                        model_meta=self.model_meta,
-                        name=image_info.name,
-                        image_id=image_info.id,
-                        dataset_id=image_info.dataset_id,
-                        project_id=dataset_info.project_id,
+                    images_nps = [
+                        self.cache.download_image(api, img_id) for img_id in image_ids_batch
+                    ]
+                    downloader.next(len(image_ids_batch))
+                    anns, slides_data = self._inference_auto(
+                        source=images_nps,
+                        settings=inference_settings,
                     )
-                    prediction.extra_data["slides_data"] = this_slides_data
-                    batch_predictions.append(prediction)
 
-                uploader.put(batch_predictions)
+                    batch_predictions = []
+                    for image_id, ann, this_slides_data in zip(image_ids_batch, anns, slides_data):
+                        image_info: ImageInfo = images_infos_dict[image_id]
+                        dataset_info = dataset_infos_dict[image_info.dataset_id]
+                        prediction = Prediction(
+                            ann,
+                            model_meta=self.model_meta,
+                            name=image_info.name,
+                            image_id=image_info.id,
+                            dataset_id=image_info.dataset_id,
+                            project_id=dataset_info.project_id,
+                        )
+                        prediction.extra_data["slides_data"] = this_slides_data
+                        batch_predictions.append(prediction)
+
+                    uploader.put(batch_predictions)
 
     def _inference_video_id(
         self,
@@ -2181,7 +2249,7 @@ class Inference:
         else:
             n_frames = video_info.frames_count
 
-        self._tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
+        inference_request.tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
 
         logger.debug(
             f"Video info:",
@@ -2218,8 +2286,8 @@ class Inference:
                 settings=inference_settings,
             )
 
-            if self._tracker is not None:
-                anns = self._apply_tracker_to_anns(frames, anns)
+            if inference_request.tracker is not None:
+                anns = self._apply_tracker_to_anns(frames, anns, inference_request.tracker)
 
             predictions = [
                 Prediction(
@@ -2228,8 +2296,8 @@ class Inference:
                     frame_index=frame_index,
                     video_id=video_info.id,
                     dataset_id=video_info.dataset_id,
-                        project_id=video_info.project_id,
-                    )
+                    project_id=video_info.project_id,
+                )
                 for ann, frame_index in zip(anns, batch)
             ]
             for pred, this_slides_data in zip(predictions, slides_data):
@@ -2240,9 +2308,169 @@ class Inference:
             inference_request.done(len(batch_results))
             logger.debug(f"Frames {batch[0]}-{batch[-1]} done.")
         video_ann_json = None
-        if self._tracker is not None:
+        if inference_request.tracker is not None:
+            inference_request.set_stage("Postprocess...", 0, progress_total)
+
+            video_ann_json = inference_request.tracker.create_video_annotation(
+                video_info.frames_count,
+                start_frame_index,
+                step=step,
+                progress_cb=inference_request.done,
+            ).to_json()
+        inference_request.final_result = {"video_ann": video_ann_json}
+        return video_ann_json
+
+    def _tracking_by_detection(self, api: Api, state: dict, inference_request: InferenceRequest):
+        logger.debug("Inferring video_id...", extra={"state": state})
+        inference_settings = self._get_inference_settings(state)
+        logger.debug(f"Inference settings:", extra=inference_settings)
+        batch_size = self._get_batch_size_from_state(state)
+        video_id = get_value_for_keys(state, ["videoId", "video_id"], ignore_none=True)
+        if video_id is None:
+            raise ValueError("Video id is not provided")
+        video_info = api.video.get_info_by_id(video_id)
+        start_frame_index = get_value_for_keys(
+            state, ["startFrameIndex", "start_frame_index", "start_frame"], ignore_none=True
+        )
+        if start_frame_index is None:
+            start_frame_index = 0
+        step = get_value_for_keys(state, ["stride", "step"], ignore_none=True)
+        if step is None:
+            step = 1
+        end_frame_index = get_value_for_keys(
+            state, ["endFrameIndex", "end_frame_index", "end_frame"], ignore_none=True
+        )
+        duration = state.get("duration", None)
+        frames_count = get_value_for_keys(
+            state, ["framesCount", "frames_count", "num_frames"], ignore_none=True
+        )
+        tracking = state.get("tracker", None)
+        direction = state.get("direction", "forward")
+        direction = 1 if direction == "forward" else -1
+        track_id = get_value_for_keys(state, ["trackId", "track_id"], ignore_none=True)
+
+        if frames_count is not None:
+            n_frames = frames_count
+        elif end_frame_index is not None:
+            n_frames = end_frame_index - start_frame_index
+        elif duration is not None:
+            fps = video_info.frames_count / video_info.duration
+            n_frames = int(duration * fps)
+        else:
+            n_frames = video_info.frames_count
+
+        inference_request.tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
+
+        logger.debug(
+            f"Video info:",
+            extra=dict(
+                w=video_info.frame_width,
+                h=video_info.frame_height,
+                start_frame_index=start_frame_index,
+                n_frames=n_frames,
+            ),
+        )
+
+        # start downloading video in background
+        self.cache.run_cache_task_manually(api, None, video_id=video_id)
+
+        progress_total = (n_frames + step - 1) // step
+        inference_request.set_stage(InferenceRequest.Stage.INFERENCE, 0, progress_total)
+
+        _upload_f = partial(
+            self.upload_predictions_to_video,
+            api=api,
+            video_info=video_info,
+            track_id=track_id,
+            context=inference_request.context,
+            progress_cb=inference_request.done,
+            inference_request=inference_request,
+        )
+
+        _range = (start_frame_index, start_frame_index + direction * n_frames)
+        if _range[0] > _range[1]:
+            _range = (_range[1], _range[0])
+
+        def _notify_f(predictions: List[Prediction]):
+            logger.debug(
+                "Notifying tracking progress...",
+                extra={
+                    "track_id": track_id,
+                    "range": _range,
+                    "current": inference_request.progress.current,
+                    "total": inference_request.progress.total,
+                },
+            )
+            stopped = self.api.video.notify_progress(
+                track_id=track_id,
+                video_id=video_info.id,
+                frame_start=_range[0],
+                frame_end=_range[1],
+                current=inference_request.progress.current,
+                total=inference_request.progress.total,
+            )
+            if stopped:
+                inference_request.stop()
+                logger.info("Tracking has been stopped by user", extra={"track_id": track_id})
+
+        def _exception_handler(e: Exception):
+            self.api.video.notify_tracking_error(
+                track_id=track_id,
+                error=str(type(e)),
+                message=str(e),
+            )
+            raise e
+
+        with Uploader(
+            upload_f=_upload_f,
+            notify_f=_notify_f,
+            exception_handler=_exception_handler,
+            logger=logger,
+        ) as uploader:
+            for batch in batched(
+                range(
+                    start_frame_index, start_frame_index + direction * n_frames, direction * step
+                ),
+                batch_size,
+            ):
+                if inference_request.is_stopped():
+                    logger.debug(
+                        f"Cancelling inference video...",
+                        extra={"inference_request_uuid": inference_request.uuid},
+                    )
+                    break
+                logger.debug(
+                    f"Inferring frames {batch[0]}-{batch[-1]}:",
+                )
+                frames = self.cache.download_frames(
+                    api, video_info.id, batch, redownload_video=True
+                )
+                anns, slides_data = self._inference_auto(
+                    source=frames,
+                    settings=inference_settings,
+                )
+
+                if inference_request.tracker is not None:
+                    anns = self._apply_tracker_to_anns(frames, anns, inference_request.tracker)
+
+                predictions = [
+                    Prediction(
+                        ann,
+                        model_meta=self.model_meta,
+                        frame_index=frame_index,
+                        video_id=video_info.id,
+                        dataset_id=video_info.dataset_id,
+                        project_id=video_info.project_id,
+                    )
+                    for ann, frame_index in zip(anns, batch)
+                ]
+                for pred, this_slides_data in zip(predictions, slides_data):
+                    pred.extra_data["slides_data"] = this_slides_data
+                uploader.put(predictions)
+        video_ann_json = None
+        if inference_request.tracker is not None:
             inference_request.set_stage("Postprocess...", 0, 1)
-            video_ann_json = self._tracker.video_annotation.to_json()
+            video_ann_json = inference_request.tracker.video_annotation.to_json()
             inference_request.done()
         inference_request.final_result = {"video_ann": video_ann_json}
         return video_ann_json
@@ -2268,10 +2496,9 @@ class Inference:
         upload_mode = state.get("upload_mode", None)
         iou_merge_threshold = inference_settings.get("existing_objects_iou_thresh", None)
         if upload_mode == "iou_merge" and iou_merge_threshold is None:
-            iou_merge_threshold = 0.7
+            iou_merge_threshold = self.DEFAULT_IOU_MERGE_THRESHOLD
         cache_project_on_model = state.get("cache_project_on_model", False)
 
-        project_info = api.project.get_info_by_id(project_id)
         inference_request.context.setdefault("project_info", {})[project_id] = project_info
         dataset_ids = state.get("dataset_ids", None)
         if dataset_ids is None:
@@ -2306,7 +2533,11 @@ class Inference:
 
         if cache_project_on_model:
             download_to_cache(
-                api, project_info.id, datasets_infos, progress_cb=inference_request.done
+                api,
+                project_info.id,
+                datasets_infos,
+                progress_cb=inference_request.done,
+                skip_create_readme=True,
             )
 
         images_infos_dict = {}
@@ -2315,20 +2546,9 @@ class Inference:
             if not cache_project_on_model:
                 inference_request.done(dataset_info.items_count)
 
-        def _download_images(datasets_infos: List[DatasetInfo]):
-            for dataset_info in datasets_infos:
-                image_ids = [image_info.id for image_info in images_infos_dict[dataset_info.id]]
-                with ThreadPoolExecutor(max(8, min(batch_size, 64))) as executor:
-                    for image_id in image_ids:
-                        executor.submit(
-                            self.cache.download_image,
-                            api,
-                            image_id,
-                        )
-
-        if not cache_project_on_model:
-            # start downloading in parallel
-            threading.Thread(target=_download_images, args=[datasets_infos], daemon=True).start()
+        def download_f(item: int):
+            self.cache.download_image(api, item)
+            return item
 
         _upload_predictions = partial(
             self.upload_predictions,
@@ -2343,7 +2563,9 @@ class Inference:
         )
 
         _add_results_to_request = partial(
-            self.add_results_to_request, inference_request=inference_request
+            self.add_results_to_request,
+            inference_request=inference_request,
+            progress_cb=inference_request.done,
         )
 
         if upload_mode is None:
@@ -2351,57 +2573,78 @@ class Inference:
         else:
             upload_f = _upload_predictions
 
+        download_workers = max(8, min(batch_size, 64))
         inference_request.set_stage(InferenceRequest.Stage.INFERENCE, 0, inference_progress_total)
         with Uploader(upload_f, logger=logger) as uploader:
-            for dataset_info in datasets_infos:
-                for images_infos_batch in batched(
-                    images_infos_dict[dataset_info.id], batch_size=batch_size
-                ):
-                    if inference_request.is_stopped():
-                        logger.debug(
-                            f"Cancelling inference project...",
-                            extra={"inference_request_uuid": inference_request.uuid},
-                        )
-                        return
-                    if uploader.has_exception():
-                        exception = uploader.exception
-                        raise exception
-                    if cache_project_on_model:
-                        images_paths, _ = zip(
-                            *read_from_cached_project(
-                                project_info.id,
-                                dataset_info.name,
-                                [ii.name for ii in images_infos_batch],
+            with Downloader(download_f, max_workers=download_workers, logger=logger) as downloader:
+                for images in images_infos_dict.values():
+                    for image in images:
+                        downloader.put(image.id)
+                downloader.next(100)
+                for dataset_info in datasets_infos:
+                    for images_infos_batch in batched(
+                        images_infos_dict[dataset_info.id], batch_size=batch_size
+                    ):
+                        if uploader.has_exception():
+                            exception = uploader.exception
+                            raise exception
+                        if inference_request.is_stopped():
+                            logger.debug(
+                                f"Cancelling inference project...",
+                                extra={"inference_request_uuid": inference_request.uuid},
                             )
+                            return
+                        if inference_request.is_paused():
+                            logger.info("Inference request is paused. Waiting...")
+                            while inference_request.is_paused():
+                                if (
+                                    inference_request.paused_for()
+                                    > inference_request.PAUSE_SLEEP_MAX_WAIT
+                                ):
+                                    logger.info(
+                                        "Inference request has been paused for too long. Cancelling..."
+                                    )
+                                    raise RuntimeError(
+                                        "Inference request cancelled due to long pause."
+                                    )
+                                time.sleep(inference_request.PAUSE_SLEEP_INTERVAL)
+                        if cache_project_on_model:
+                            images_paths, _ = zip(
+                                *read_from_cached_project(
+                                    project_info.id,
+                                    dataset_info.name,
+                                    [ii.name for ii in images_infos_batch],
+                                )
+                            )
+                            images_nps = [sly_image.read(img_path) for img_path in images_paths]
+                        else:
+                            images_nps = self.cache.download_images(
+                                api,
+                                dataset_info.id,
+                                [info.id for info in images_infos_batch],
+                                return_images=True,
+                            )
+                            downloader.next(len(images_infos_batch))
+                        anns, slides_data = self._inference_auto(
+                            source=images_nps,
+                            settings=inference_settings,
                         )
-                        images_nps = [sly_image.read(img_path) for img_path in images_paths]
-                    else:
-                        images_nps = self.cache.download_images(
-                            api,
-                            dataset_info.id,
-                            [info.id for info in images_infos_batch],
-                            return_images=True,
-                        )
-                    anns, slides_data = self._inference_auto(
-                        source=images_nps,
-                        settings=inference_settings,
-                    )
-                    predictions = [
-                        Prediction(
-                            ann,
-                            model_meta=self.model_meta,
-                            image_id=image_info.id,
-                            name=image_info.name,
-                            dataset_id=dataset_info.id,
-                            project_id=dataset_info.project_id,
-                            image_name=image_info.name,
-                        )
-                        for ann, image_info in zip(anns, images_infos_batch)
-                    ]
-                    for pred, this_slides_data in zip(predictions, slides_data):
-                        pred.extra_data["slides_data"] = this_slides_data
+                        predictions = [
+                            Prediction(
+                                ann,
+                                model_meta=self.model_meta,
+                                image_id=image_info.id,
+                                name=image_info.name,
+                                dataset_id=dataset_info.id,
+                                project_id=dataset_info.project_id,
+                                image_name=image_info.name,
+                            )
+                            for ann, image_info in zip(anns, images_infos_batch)
+                        ]
+                        for pred, this_slides_data in zip(predictions, slides_data):
+                            pred.extra_data["slides_data"] = this_slides_data
 
-                    uploader.put(predictions)
+                        uploader.put(predictions)
 
     def _run_speedtest(
         self,
@@ -2444,7 +2687,13 @@ class Inference:
             inference_request.done()
 
         if cache_project_on_model:
-            download_to_cache(api, project_id, datasets_infos, progress_cb=inference_request.done)
+            download_to_cache(
+                api,
+                project_id,
+                datasets_infos,
+                progress_cb=inference_request.done,
+                skip_create_readme=True,
+            )
 
         inference_request.set_stage("warmup", 0, num_warmup)
 
@@ -2565,6 +2814,11 @@ class Inference:
     def _freeze_model(self):
         if self._model_frozen or not self._model_served:
             return
+
+        if not self._deploy_params:
+            logger.warning("Deploy params are not set, cannot freeze the model.")
+            return
+
         logger.debug("Freezing model...")
         runtime = self._deploy_params.get("runtime")
         if runtime and runtime.lower() != RuntimeType.PYTORCH.lower():
@@ -2907,11 +3161,89 @@ class Inference:
             inference_request.add_results(results)
 
     def add_results_to_request(
-        self, predictions: List[Prediction], inference_request: InferenceRequest
+        self, predictions: List[Prediction], inference_request: InferenceRequest, progress_cb=None
     ):
         results = self._format_output(predictions)
         inference_request.add_results(results)
-        inference_request.done(len(results))
+        if progress_cb:
+            progress_cb(len(results))
+
+    def upload_predictions_to_video(
+        self,
+        predictions: List[Prediction],
+        api: Api,
+        video_info: VideoInfo,
+        track_id: str,
+        context: Dict,
+        progress_cb=None,
+        inference_request: InferenceRequest = None,
+    ):
+        key_id_map = KeyIdMap()
+        project_meta = context.get("project_meta", None)
+        if project_meta is None:
+            project_meta = ProjectMeta.from_json(api.project.get_meta(video_info.project_id))
+            context["project_meta"] = project_meta
+        meta_changed = False
+        for prediction in predictions:
+            project_meta, ann, meta_changed_ = update_meta_and_ann(
+                project_meta, prediction.annotation, None
+            )
+            prediction.annotation = ann
+            meta_changed = meta_changed or meta_changed_
+        if meta_changed:
+            project_meta = api.project.update_meta(video_info.project_id, project_meta)
+            context["project_meta"] = project_meta
+
+        figure_data_by_object_id = defaultdict(list)
+
+        tracks_to_object_ids = context.setdefault("tracks_to_object_ids", {})
+        new_tracks: Dict[int, VideoObject] = {}
+        for prediction in predictions:
+            annotation = prediction.annotation
+            tracks = annotation.custom_data
+            for track, label in zip(tracks, annotation.labels):
+                if track not in tracks_to_object_ids and track not in new_tracks:
+                    video_object = VideoObject(obj_class=label.obj_class)
+                    new_tracks[track] = video_object
+        if new_tracks:
+            tracks, video_objects = zip(*new_tracks.items())
+            added_object_ids = api.video.object.append_bulk(
+                video_info.id, VideoObjectCollection(video_objects), key_id_map=key_id_map
+            )
+            for track, object_id in zip(tracks, added_object_ids):
+                tracks_to_object_ids[track] = object_id
+        for prediction in predictions:
+            annotation = prediction.annotation
+            tracks = annotation.custom_data
+            for track, label in zip(tracks, annotation.labels):
+                object_id = tracks_to_object_ids[track]
+                figure_data_by_object_id[object_id].append(
+                    {
+                        ApiField.OBJECT_ID: object_id,
+                        ApiField.GEOMETRY_TYPE: label.geometry.geometry_name(),
+                        ApiField.GEOMETRY: label.geometry.to_json(),
+                        ApiField.META: {ApiField.FRAME: prediction.frame_index},
+                        ApiField.TRACK_ID: track_id,
+                    }
+                )
+
+        for object_id, figures_data in figure_data_by_object_id.items():
+            figures_keys = [uuid.uuid4() for _ in figures_data]
+            api.video.figure._append_bulk(
+                entity_id=video_info.id,
+                figures_json=figures_data,
+                figures_keys=figures_keys,
+                key_id_map=key_id_map,
+            )
+            logger.debug(f"Added {len(figures_data)} geometries to object #{object_id}")
+        if progress_cb:
+            progress_cb(len(predictions))
+        if inference_request is not None:
+            results = self._format_output(predictions)
+            for result in results:
+                result["annotation"] = None
+                result["data"] = None
+            inference_request.add_results(results)
 
     def serve(self):
         if not self._use_gui and not self._is_cli_deploy:
@@ -2995,7 +3327,7 @@ class Inference:
 
         if not self._use_gui:
             Progress("Model deployed", 1).iter_done_report()
-        else:
+        elif self.api is not None:
             autostart_func()
 
         @server.exception_handler(HTTPException)
@@ -3022,6 +3354,11 @@ class Inference:
         def get_session_info(response: Response):
             return self.get_info()
 
+        @server.post("/get_tracking_settings")
+        @self._check_serve_before_call
+        def get_tracking_settings(response: Response):
+            return self.get_tracking_settings()
+
         @server.post("/get_custom_inference_settings")
         def get_custom_inference_settings():
             return {"settings": self.custom_inference_settings}
@@ -3305,6 +3642,22 @@ class Inference:
                 "inference_request_uuid": inference_request.uuid,
             }
 
+        @server.post("/tracking_by_detection")
+        def tracking_by_detection(response: Response, request: Request):
+            state = request.state.state
+            context = request.state.context
+            state.update(context)
+            if state.get("tracker") is None:
+                state["tracker"] = "botsort"
+
+            logger.debug("Received a request to 'tracking_by_detection'", extra={"state": state})
+            self.validate_inference_state(state)
+            api = self.api_from_request(request)
+            inference_request, future = self.inference_requests_manager.schedule_task(
+                self._tracking_by_detection, api, state
+            )
+            return {"message": "Track task started."}
+
         @server.post("/inference_project_id_async")
         def inference_project_id_async(response: Response, request: Request):
             state = request.state.state
@@ -3368,10 +3721,7 @@ class Inference:
             data = {**inference_request.to_json(), **log_extra}
             if inference_request.stage != InferenceRequest.Stage.INFERENCE:
                 data["progress"] = {"current": 0, "total": 1}
-            logger.debug(
-                f"Sending inference progress with uuid:",
-                extra=data,
-            )
+            logger.debug(f"Sending inference progress with uuid:", extra=data)
             return data
 
         @server.post(f"/pop_inference_results")
@@ -4228,10 +4578,10 @@ class Inference:
                 self._args.draw,
             )
 
-    def _apply_tracker_to_anns(self, frames: List[np.ndarray], anns: List[Annotation]):
+    def _apply_tracker_to_anns(self, frames: List[np.ndarray], anns: List[Annotation], tracker):
         updated_anns = []
         for frame, ann in zip(frames, anns):
-            matches = self._tracker.update(frame, ann)
+            matches = tracker.update(frame, ann)
             track_ids = [match["track_id"] for match in matches]
             tracked_labels = [match["label"] for match in matches]
 
@@ -4297,61 +4647,72 @@ class Inference:
     def export_tensorrt(self, deploy_params: dict):
         raise NotImplementedError("Have to be implemented in child class after inheritance")
 
-def _exclude_duplicated_predictions(
-    api: Api,
-    pred_anns: List[Annotation],
-    dataset_id: int,
-    gt_image_ids: List[int],
-    iou: float = None,
-    meta: Optional[ProjectMeta] = None,
+
+def _filter_duplicated_predictions_from_ann_cpu(
+    gt_ann: Annotation, pred_ann: Annotation, iou_threshold: float
 ):
     """
-    Filter out predictions that significantly overlap with ground truth (GT) objects.
+    Filter out predicted labels whose bboxes have IoU > iou_threshold with any GT label.
+    Uses Shapely for geometric operations.
 
-    This is a wrapper around the `_filter_duplicated_predictions_from_ann` method that does the following:
-    - Checks inference settings for the IoU threshold (`existing_objects_iou_thresh`)
-    - Gets ProjectMeta object if not provided
-    - Downloads GT annotations for the specified image IDs
-    - Filters out predictions that have an IoU greater than or equal to the specified threshold with any GT object
+    Args:
+        pred_ann: Predicted annotation object
+        gt_ann: Ground truth annotation object
+        iou_threshold: IoU threshold for filtering
 
-    :param api: Supervisely API object
-    :type api: Api
-    :param pred_anns: List of Annotation objects containing predictions
-    :type pred_anns: List[Annotation]
-    :param dataset_id: ID of the dataset containing the images
-    :type dataset_id: int
-    :param gt_image_ids: List of image IDs to filter predictions. All images should belong to the same dataset
-    :type gt_image_ids: List[int]
-    :param iou: IoU threshold (0.0-1.0). Predictions with IoU >= threshold with any
-                    ground truth box of the same class will be removed. None if no filtering is needed
-    :type iou: Optional[float]
-    :param meta: ProjectMeta object
-    :type meta: Optional[ProjectMeta]
-    :return: List of Annotation objects containing filtered predictions
-    :rtype: List[Annotation]
-
-    Notes:
-    ------
-    - Requires PyTorch and torchvision for IoU calculations
-    - This method is useful for identifying new objects that aren't already annotated in the ground truth
+    Returns:
+        New annotation with filtered labels
     """
-    if isinstance(iou, float) and 0 < iou <= 1:
-        if meta is None:
-            ds = api.dataset.get_info_by_id(dataset_id)
-            meta = ProjectMeta.from_json(api.project.get_meta(ds.project_id))
-        gt_anns = api.annotation.download_json_batch(dataset_id, gt_image_ids)
-        gt_anns = [Annotation.from_json(ann, meta) for ann in gt_anns]
-        for i in range(0, len(pred_anns)):
-            before = len(pred_anns[i].labels)
-            with Timer() as timer:
-                pred_anns[i] = _filter_duplicated_predictions_from_ann(
-                    gt_anns[i], pred_anns[i], iou
-                )
-            after = len(pred_anns[i].labels)
-            logger.debug(
-                f"{[i]}: applied NMS with IoU={iou}. Before: {before}, After: {after}. Time: {timer.get_time():.3f}ms"
-            )
-    return pred_anns
+    if not iou_threshold:
+        return pred_ann
+
+    from shapely.geometry import box
+
+    def calculate_iou(geom1: Geometry, geom2: Geometry):
+        """Calculate IoU between two geometries using Shapely."""
+        bbox1 = geom1.to_bbox()
+        bbox2 = geom2.to_bbox()
+
+        box1 = box(bbox1.left, bbox1.top, bbox1.right, bbox1.bottom)
+        box2 = box(bbox2.left, bbox2.top, bbox2.right, bbox2.bottom)
+
+        intersection = box1.intersection(box2).area
+        union = box1.union(box2).area
+
+        return intersection / union if union > 0 else 0.0
+
+    new_labels = []
+    pred_cls_bboxes = defaultdict(list)
+    for label in pred_ann.labels:
+        name_shape = (label.obj_class.name, label.geometry.name())
+        pred_cls_bboxes[name_shape].append(label)
+
+    gt_cls_bboxes = defaultdict(list)
+    for label in gt_ann.labels:
+        name_shape = (label.obj_class.name, label.geometry.name())
+        if name_shape not in pred_cls_bboxes:
+            continue
+        gt_cls_bboxes[name_shape].append(label)
+
+    for name_shape, pred in pred_cls_bboxes.items():
+        gt = gt_cls_bboxes[name_shape]
+        if len(gt) == 0:
+            new_labels.extend(pred)
+            continue
+
+        for pred_label in pred:
+            # Check if this prediction has IoU < threshold with ALL GT boxes
+            keep = True
+            for gt_label in gt:
+                iou = calculate_iou(pred_label.geometry, gt_label.geometry)
+                if iou >= iou_threshold:
+                    keep = False
+                    break
+
+            if keep:
+                new_labels.append(pred_label)
+
+    return pred_ann.clone(labels=new_labels)
 
 
 def _filter_duplicated_predictions_from_ann(
@@ -4382,13 +4743,15 @@ def _filter_duplicated_predictions_from_ann(
     - Predictions with classes not present in ground truth will be kept
     - Requires PyTorch and torchvision for IoU calculations
     """
+    if not iou_threshold:
+        return pred_ann
 
     try:
         import torch
         from torchvision.ops import box_iou
 
     except ImportError:
-        raise ImportError("Please install PyTorch and torchvision to use this feature.")
+        return _filter_duplicated_predictions_from_ann_cpu(gt_ann, pred_ann, iou_threshold)
 
     def _to_tensor(geom):
         return torch.tensor([geom.left, geom.top, geom.right, geom.bottom]).float()
@@ -4396,16 +4759,18 @@ def _filter_duplicated_predictions_from_ann(
     new_labels = []
     pred_cls_bboxes = defaultdict(list)
     for label in pred_ann.labels:
-        pred_cls_bboxes[label.obj_class.name].append(label)
+        name_shape = (label.obj_class.name, label.geometry.name())
+        pred_cls_bboxes[name_shape].append(label)
 
     gt_cls_bboxes = defaultdict(list)
     for label in gt_ann.labels:
-        if label.obj_class.name not in pred_cls_bboxes:
+        name_shape = (label.obj_class.name, label.geometry.name())
+        if name_shape not in pred_cls_bboxes:
             continue
-        gt_cls_bboxes[label.obj_class.name].append(label)
+        gt_cls_bboxes[name_shape].append(label)
 
-    for name, pred in pred_cls_bboxes.items():
-        gt = gt_cls_bboxes[name]
+    for name_shape, pred in pred_cls_bboxes.items():
+        gt = gt_cls_bboxes[name_shape]
         if len(gt) == 0:
             new_labels.extend(pred)
             continue
@@ -4419,6 +4784,63 @@ def _filter_duplicated_predictions_from_ann(
     return pred_ann.clone(labels=new_labels)
 
 
+def _exclude_duplicated_predictions(
+    api: Api,
+    pred_anns: List[Annotation],
+    dataset_id: int,
+    gt_image_ids: List[int],
+    iou: float = None,
+    meta: Optional[ProjectMeta] = None,
+):
+    """
+    Filter out predictions that significantly overlap with ground truth (GT) objects.
+
+    This is a wrapper around the `_filter_duplicated_predictions_from_ann` method that does the following:
+    - Checks inference settings for the IoU threshold (`existing_objects_iou_thresh`)
+    - Gets ProjectMeta object if not provided
+    - Downloads GT annotations for the specified image IDs
+    - Filters out predictions that have an IoU greater than or equal to the specified threshold with any GT object
+
+    :param api: Supervisely API object
+    :type api: Api
+    :param pred_anns: List of Annotation objects containing predictions
+    :type pred_anns: List[Annotation]
+    :param dataset_id: ID of the dataset containing the images
+    :type dataset_id: int
+    :param gt_image_ids: List of image IDs to filter predictions. All images should belong to the same dataset
+    :type gt_image_ids: List[int]
+    :param iou: IoU threshold (0.0-1.0). Predictions with IoU >= threshold with any
+                    ground truth box of the same class will be removed. None if no filtering is needed
+    :type iou: Optional[float]
+    :param meta: ProjectMeta object
+    :type meta: Optional[ProjectMeta]
+    :return: List of Annotation objects containing filtered predictions
+    :rtype: List[Annotation]
+
+    Notes:
+    ------
+    - Requires PyTorch and torchvision for IoU calculations
+    - This method is useful for identifying new objects that aren't already annotated in the ground truth
+    """
+    if isinstance(iou, float) and 0 < iou <= 1:
+        if meta is None:
+            ds = api.dataset.get_info_by_id(dataset_id)
+            meta = ProjectMeta.from_json(api.project.get_meta(ds.project_id))
+        gt_anns = api.annotation.download_json_batch(dataset_id, gt_image_ids)
+        gt_anns = [Annotation.from_json(ann, meta) for ann in gt_anns]
+        for i in range(0, len(pred_anns)):
+            before = len(pred_anns[i].labels)
+            with Timer() as timer:
+                pred_anns[i] = _filter_duplicated_predictions_from_ann(
+                    gt_anns[i], pred_anns[i], iou
+                )
+            after = len(pred_anns[i].labels)
+            logger.debug(
+                f"{[i]}: applied NMS with IoU={iou}. Before: {before}, After: {after}. Time: {timer.get_time():.3f}ms"
+            )
+    return pred_anns
+
+
 def _get_log_extra_for_inference_request(
     inference_request_uuid, inference_request: Union[InferenceRequest, dict]
 ):
@@ -4526,7 +4948,7 @@ def get_gpu_count():
         gpu_count = len(re.findall(r"GPU \d+:", nvidia_smi_output))
         return gpu_count
     except (subprocess.CalledProcessError, FileNotFoundError) as exc:
-        logger.warn("Calling nvidia-smi caused a error: {exc}. Assume there is no any GPU.")
+        logger.warning("Calling nvidia-smi caused a error: {exc}. Assume there is no any GPU.")
         return 0
 
 
@@ -4706,7 +5128,180 @@ def update_meta_and_ann(meta: ProjectMeta, ann: Annotation, model_prediction_suf
                 img_tags = None
             if not any_label_updated:
                 labels = None
-            ann = ann.clone(img_tags=TagCollection(img_tags))
+            ann = ann.clone(img_tags=img_tags)
+    return meta, ann, meta_changed
+
+
+def update_meta_and_ann_for_video_annotation(
+    meta: ProjectMeta, ann: VideoAnnotation, model_prediction_suffix: str = None
+):
+    """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.
+    """
+    obj_classes_suffixes = ["_nn"]
+    tag_meta_suffixes = ["_nn"]
+    if model_prediction_suffix is not None:
+        obj_classes_suffixes = [model_prediction_suffix]
+        tag_meta_suffixes = [model_prediction_suffix]
+        logger.debug(
+            f"Using custom suffixes for obj classes and tag metas: {obj_classes_suffixes}, {tag_meta_suffixes}"
+        )
+    logger.debug("source meta", extra={"meta": meta.to_json()})
+    meta_changed = False
+
+    # meta, ann, replaced_classes_in_meta, replaced_classes_in_ann = _fix_classes_names(meta, ann)
+    # if replaced_classes_in_meta:
+    #     meta_changed = True
+    #     logger.warning(
+    #         "Some classes names were fixed in project meta",
+    #         extra={"replaced_classes": {old: new for old, new in replaced_classes_in_meta}},
+    #     )
+
+    new_objects: List[VideoObject] = []
+    new_figures: List[VideoFigure] = []
+    any_object_updated = False
+    for video_object in ann.objects:
+        this_object_figures = [
+            figure for figure in ann.figures if figure.video_object.key() == video_object.key()
+        ]
+        this_object_changed = False
+        original_obj_class_name = video_object.obj_class.name
+        suffix_found = False
+        for suffix in ["", *obj_classes_suffixes]:
+            obj_class = video_object.obj_class
+            obj_class_name = obj_class.name + suffix
+            if suffix:
+                obj_class = obj_class.clone(name=obj_class_name)
+                video_object = video_object.clone(obj_class=obj_class)
+                any_object_updated = True
+                this_object_changed = True
+            meta_obj_class = meta.get_obj_class(obj_class_name)
+            if meta_obj_class is None:
+                # obj class is not in meta, add it with suffix
+                meta = meta.add_obj_class(obj_class)
+                new_objects.append(video_object)
+                meta_changed = True
+                suffix_found = True
+                break
+            elif (
+                meta_obj_class.geometry_type.geometry_name()
+                == video_object.obj_class.geometry_type.geometry_name()
+            ):
+                # if object geometry is the same as in meta, use meta obj class
+                video_object = video_object.clone(obj_class=meta_obj_class)
+                new_objects.append(video_object)
+                suffix_found = True
+                any_object_updated = True
+                this_object_changed = True
+                break
+            elif meta_obj_class.geometry_type.geometry_name() == AnyGeometry.geometry_name():
+                # if meta obj class is AnyGeometry, use it in object
+                video_object = video_object.clone(obj_class=meta_obj_class)
+                new_objects.append(video_object)
+                suffix_found = True
+                any_object_updated = True
+                this_object_changed = True
+                break
+        if not suffix_found:
+            # if no suffix found, raise error
+            raise ValueError(
+                f"Can't add obj class {original_obj_class_name} to project meta. "
+                "Tried with suffixes: " + ", ".join(obj_classes_suffixes) + ". "
+                "Please check if model geometry type is compatible with existing obj classes."
+            )
+        elif this_object_changed:
+            this_object_figures = [
+                figure.clone(video_object=video_object) for figure in this_object_figures
+            ]
+        new_figures.extend(this_object_figures)
+    if any_object_updated:
+        frames_figures = {}
+        for figure in new_figures:
+            frames_figures.setdefault(figure.frame_index, []).append(figure)
+        new_frames = FrameCollection(
+            [
+                Frame(index=frame_index, figures=figures)
+                for frame_index, figures in frames_figures.items()
+            ]
+        )
+        ann = ann.clone(objects=new_objects, frames=new_frames)
+
+    # check if tag metas are in project meta
+    # if not, add them with suffix
+    ann_tag_metas: Dict[str, TagMeta] = {}
+    for video_object in ann.objects:
+        for tag in video_object.tags:
+            tag_name = tag.meta.name
+            if tag_name not in ann_tag_metas:
+                ann_tag_metas[tag_name] = tag.meta
+    for tag in ann.tags:
+        tag_name = tag.meta.name
+        if tag_name not in ann_tag_metas:
+            ann_tag_metas[tag_name] = tag.meta
+
+    changed_tag_metas = {}
+    for ann_tag_meta in ann_tag_metas.values():
+        meta_tag_meta = meta.get_tag_meta(ann_tag_meta.name)
+        if meta_tag_meta is None:
+            meta = meta.add_tag_meta(ann_tag_meta)
+            meta_changed = True
+        elif not meta_tag_meta.is_compatible(ann_tag_meta):
+            suffix_found = False
+            for suffix in tag_meta_suffixes:
+                new_tag_meta_name = ann_tag_meta.name + suffix
+                meta_tag_meta = meta.get_tag_meta(new_tag_meta_name)
+                if meta_tag_meta is None:
+                    new_tag_meta = ann_tag_meta.clone(name=new_tag_meta_name)
+                    meta = meta.add_tag_meta(new_tag_meta)
+                    changed_tag_metas[ann_tag_meta.name] = new_tag_meta
+                    meta_changed = True
+                    suffix_found = True
+                    break
+                if meta_tag_meta.is_compatible(ann_tag_meta):
+                    changed_tag_metas[ann_tag_meta.name] = meta_tag_meta
+                    suffix_found = True
+                    break
+            if not suffix_found:
+                raise ValueError(f"Can't add tag meta {ann_tag_meta.name} to project meta")
+
+    if changed_tag_metas:
+        objects = []
+        any_object_updated = False
+        for video_object in ann.objects:
+            any_tag_updated = False
+            object_tags = []
+            for tag in video_object.tags:
+                if tag.meta.name in changed_tag_metas:
+                    object_tags.append(tag.clone(meta=changed_tag_metas[tag.meta.name]))
+                    any_tag_updated = True
+                else:
+                    object_tags.append(tag)
+            if any_tag_updated:
+                video_object = video_object.clone(tags=TagCollection(object_tags))
+                any_object_updated = True
+            objects.append(video_object)
+
+        video_tags = []
+        any_tag_updated = False
+        for tag in ann.tags:
+            if tag.meta.name in changed_tag_metas:
+                video_tags.append(tag.clone(meta=changed_tag_metas[tag.meta.name]))
+                any_tag_updated = True
+            else:
+                video_tags.append(tag)
+        if any_tag_updated or any_object_updated:
+            if any_tag_updated:
+                video_tags = VideoTagCollection(video_tags)
+            else:
+                video_tags = None
+            if any_object_updated:
+                objects = VideoObjectCollection(objects)
+            else:
+                objects = None
+            ann = ann.clone(tags=video_tags, objects=objects)
+
     return meta, ann, meta_changed
 
 
@@ -4820,7 +5415,8 @@ def get_value_for_keys(data: dict, keys: List, ignore_none: bool = False):
             return data[key]
     return None
 
-def torch_load_safe(checkpoint_path: str, device:str = "cpu"):
+
+def torch_load_safe(checkpoint_path: str, device: str = "cpu"):
     import torch  # pylint: disable=import-error
 
     # TODO: handle torch.load(weights_only=True) - change in torch 2.6.0