supervisely 6.73.456__py3-none-any.whl → 6.73.458__py3-none-any.whl

supervisely/nn/inference/inference.py

@@ -67,6 +67,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
@@ -94,6 +95,13 @@ 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.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 VideoObjectCollection
+from supervisely.video_annotation.video_tag_collection import VideoTagCollection
 
 try:
     from typing import Literal
@@ -140,6 +148,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 +202,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:
@@ -1401,6 +1409,41 @@ 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 +1995,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 +2021,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 +2037,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 +2071,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}
@@ -2181,7 +2223,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 +2260,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(
@@ -2240,9 +2282,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()
         inference_request.final_result = {"video_ann": video_ann_json}
         return video_ann_json
@@ -2268,7 +2310,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
         cache_project_on_model = state.get("cache_project_on_model", False)
 
         project_info = api.project.get_info_by_id(project_id)
@@ -3022,6 +3064,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}
@@ -4228,10 +4275,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,62 +4344,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(
     gt_ann: Annotation, pred_ann: Annotation, iou_threshold: float
@@ -4382,13 +4439,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 +4455,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 +4480,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]
 ):
@@ -4706,7 +4824,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
 
 

supervisely/nn/inference/inference_request.py

@@ -59,6 +59,8 @@ class InferenceRequest:
         self._created_at = time.monotonic()
         self._updated_at = self._created_at
         self._finished = False
+        
+        self.tracker = None
 
         self.global_progress = None
         self.global_progress_total = 1
@@ -250,8 +252,7 @@ class InferenceRequest:
             status_data.pop(key, None)
         status_data.update(self.get_usage())
         return status_data
-
-
+    
 class GlobalProgress:
     def __init__(self):
         self.progress = Progress(message="Ready", total_cnt=1)