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

supervisely/nn/inference/tracking/bbox_tracking.py

@@ -13,6 +13,7 @@ from supervisely.api.api import Api
 from supervisely.api.module_api import ApiField
 from supervisely.api.video.video_figure_api import FigureInfo
 from supervisely.geometry.helpers import deserialize_geometry
+from supervisely.geometry.oriented_bbox import OrientedBBox
 from supervisely.geometry.rectangle import Rectangle
 from supervisely.imaging import image as sly_image
 from supervisely.nn.inference.inference import Uploader
@@ -76,7 +77,7 @@ class BBoxTracking(BaseTracking):
                 min(frame_index for (_, _, frame_index) in items),
                 max(frame_index for (_, _, frame_index) in items),
             ]
-            pos_inc = inference_request.progress.current - video_interface.global_pos
+            pos_inc = len(items)
 
             video_interface._notify(
                 pos_increment=pos_inc,
@@ -109,7 +110,7 @@ class BBoxTracking(BaseTracking):
                 init = False
                 for _ in video_interface.frames_loader_generator():
                     geom = video_interface.geometries[fig_id]
-                    if not isinstance(geom, Rectangle):
+                    if not isinstance(geom, (Rectangle, OrientedBBox)):
                         raise TypeError(f"Tracking does not work with {geom.geometry_name()}.")
 
                     imgs = video_interface.frames
@@ -117,18 +118,27 @@ class BBoxTracking(BaseTracking):
                         "",  # TODO: can this be useful?
                         [geom.top, geom.left, geom.bottom, geom.right],
                         None,
+                        geom.angle if isinstance(geom, OrientedBBox) else None,
                     )
 
                     if not init:
                         self.initialize(imgs[0], target)
                         init = True
 
-                    geometry = self.predict(
-                        rgb_image=imgs[-1],
-                        prev_rgb_image=imgs[0],
-                        target_bbox=target,
-                        settings=self.custom_inference_settings_dict,
-                    )
+                    if isinstance(geom, OrientedBBox):
+                        geometry = self.predict_oriented(
+                            rgb_image=imgs[-1],
+                            prev_rgb_image=imgs[0],
+                            target_bbox=target,
+                            settings=self.custom_inference_settings_dict,
+                        )
+                    else:
+                        geometry = self.predict(
+                            rgb_image=imgs[-1],
+                            prev_rgb_image=imgs[0],
+                            target_bbox=target,
+                            settings=self.custom_inference_settings_dict,
+                        )
                     sly_geometry = self._to_sly_geometry(geometry)
 
                     uploader.put([(sly_geometry, obj_id, video_interface._cur_frames_indexes[-1])])
@@ -159,7 +169,7 @@ class BBoxTracking(BaseTracking):
             api.logger.info(
                 "Finished tracking.", extra={"inference_request_uuid": inference_request.uuid}
             )
-            video_interface._notify(True, task="Finished tracking")
+        video_interface._notify(True, task="Finished tracking")
 
     def _track_api(self, api: Api, context: dict, inference_request: InferenceRequest):
         track_t = time.monotonic()
@@ -218,8 +228,7 @@ class BBoxTracking(BaseTracking):
             },
         )
         for box_i, input_geom in enumerate(input_bboxes, 1):
-            input_bbox = input_geom["data"]
-            bbox = Rectangle.from_json(input_bbox)
+            bbox = self._deserialize_geometry(input_geom)
             predictions_for_object = []
             init = False
             frame_t = time.monotonic()
@@ -229,18 +238,27 @@ class BBoxTracking(BaseTracking):
                     "",  # TODO: can this be useful?
                     [bbox.top, bbox.left, bbox.bottom, bbox.right],
                     None,
+                    bbox.angle if isinstance(bbox, OrientedBBox) else None,
                 )
 
                 if not init:
                     self.initialize(imgs[0], target)
                     init = True
 
-                geometry = self.predict(
-                    rgb_image=imgs[-1],
-                    prev_rgb_image=imgs[0],
-                    target_bbox=target,
-                    settings=self.custom_inference_settings_dict,
-                )
+                if isinstance(bbox, OrientedBBox):
+                    geometry = self.predict_oriented(
+                        rgb_image=imgs[-1],
+                        prev_rgb_image=imgs[0],
+                        target_bbox=target,
+                        settings=self.custom_inference_settings_dict,
+                    )
+                else:
+                    geometry = self.predict(
+                        rgb_image=imgs[-1],
+                        prev_rgb_image=imgs[0],
+                        target_bbox=target,
+                        settings=self.custom_inference_settings_dict,
+                    )
                 sly_geometry = self._to_sly_geometry(geometry)
 
                 predictions_for_object.append(
@@ -293,24 +311,33 @@ class BBoxTracking(BaseTracking):
         }
         results = [[] for _ in range(len(frames) - 1)]
         for geometry in geometries:
-            if not isinstance(geometry, Rectangle):
+            if not isinstance(geometry, (Rectangle, OrientedBBox)):
                 raise TypeError(f"Tracking does not work with {geometry.geometry_name()}.")
             target = PredictionBBox(
                 "",
                 [geometry.top, geometry.left, geometry.bottom, geometry.right],
                 None,
+                angle=geometry.angle if isinstance(geometry, OrientedBBox) else None,
             )
             self.initialize(frames[0], target)
             for i in range(len(frames) - 1):
-                pred_geometry = self.predict(
-                    rgb_image=frames[i + 1],
-                    prev_rgb_image=frames[i],
-                    target_bbox=target,
-                    settings=updated_settings,
-                )
+                if isinstance(geometry, OrientedBBox):
+                    pred_geometry = self.predict_oriented(
+                        rgb_image=frames[i + 1],
+                        prev_rgb_image=frames[i],
+                        target_bbox=target,
+                        settings=updated_settings,
+                    )
+                else:
+                    pred_geometry = self.predict(
+                        rgb_image=frames[i + 1],
+                        prev_rgb_image=frames[i],
+                        target_bbox=target,
+                        settings=updated_settings,
+                    )
                 sly_pred_geometry = self._to_sly_geometry(pred_geometry)
                 results[i].append(
-                    {"type": Rectangle.geometry_name(), "data": sly_pred_geometry.to_json()}
+                    {"type": sly_pred_geometry.geometry_name(), "data": sly_pred_geometry.to_json()}
                 )
         return results
 
@@ -359,7 +386,7 @@ class BBoxTracking(BaseTracking):
             uploader.raise_from_notify
             for fig_i, figure in enumerate(figures, 1):
                 figure = api.video.figure._convert_json_info(figure)
-                if not figure.geometry_type == Rectangle.geometry_name():
+                if not figure.geometry_type in (Rectangle.geometry_name(), OrientedBBox.geometry_name()):
                     raise TypeError(f"Tracking does not work with {figure.geometry_type}.")
                 api.logger.info("figure:", extra={"figure": figure._asdict()})
                 sly_geometry: Rectangle = deserialize_geometry(
@@ -378,6 +405,7 @@ class BBoxTracking(BaseTracking):
                             sly_geometry.right,
                         ],
                         None,
+                        sly_geometry.angle if isinstance(sly_geometry, OrientedBBox) else None,
                     )
 
                     if not init:
@@ -386,12 +414,20 @@ class BBoxTracking(BaseTracking):
 
                     logger.debug("Start prediction")
                     t = time.time()
-                    geometry = self.predict(
-                        rgb_image=next_frame.image,
-                        prev_rgb_image=frame.image,
-                        target_bbox=target,
-                        settings=self.custom_inference_settings_dict,
-                    )
+                    if target.angle is not None:
+                        geometry = self.predict_oriented(
+                            rgb_image=next_frame.image,
+                            prev_rgb_image=frame.image,
+                            target_bbox=target,
+                            settings=self.custom_inference_settings_dict,
+                        )
+                    else:
+                        geometry = self.predict(
+                            rgb_image=next_frame.image,
+                            prev_rgb_image=frame.image,
+                            target_bbox=target,
+                            settings=self.custom_inference_settings_dict,
+                        )
                     logger.debug("Prediction done. Time: %f sec", time.time() - t)
                     sly_geometry = self._to_sly_geometry(geometry)
 
@@ -536,6 +572,46 @@ class BBoxTracking(BaseTracking):
         :rtype: PredictionBBox
         """
         raise NotImplementedError
+    
+
+    def _get_circumscribed_box(self, tlbr, angle):
+        top, left, bottom, right = tlbr
+        cx = (left + right) / 2
+        cy = (top + bottom) / 2
+        half_w = (right - left) / 2
+        half_h = (bottom - top) / 2
+        cos_a = np.cos(angle)
+        sin_a = np.sin(angle)
+        dx = abs(half_w * cos_a) + abs(half_h * sin_a)
+        dy = abs(half_w * sin_a) + abs(half_h * cos_a)
+        
+        return [cy - dy, cx - dx, cy + dy, cx + dx]
+    
+    def _inscribe_oriented_box(self, tracked_box, angle):
+        top, left, bottom, right = tracked_box
+        cx = (left + right) / 2
+        cy = (top + bottom) / 2
+        dx = (right - left) / 2
+        dy = (bottom - top) / 2
+        cos_a = abs(np.cos(angle))
+        sin_a = abs(np.sin(angle))
+        det = cos_a * cos_a - sin_a * sin_a  # = cos(2*angle)
+        if abs(det) < 1e-10:  # angle ≈ 45° or 135°
+            half_w = half_h = min(dx, dy) / (cos_a + sin_a)
+        else:
+            half_w = abs(dx * cos_a - dy * sin_a) / abs(det)
+            half_h = abs(dy * cos_a - dx * sin_a) / abs(det)
+        
+        return [cy - half_h, cx - half_w, cy + half_h, cx + half_w]
+    
+    def predict_oriented(self, rgb_image: np.ndarray, settings: Dict[str, Any], prev_rgb_image: np.ndarray, target_bbox: PredictionBBox) -> PredictionBBox:
+        if not target_bbox.angle:
+            predicted = self.predict(rgb_image, settings, prev_rgb_image, target_bbox)
+            return PredictionBBox(predicted.class_name, predicted.bbox_tlbr, predicted.score, 0)
+        circumscribed_bbox = self._get_circumscribed_box(target_bbox.bbox_tlbr, target_bbox.angle)
+        circumscribed_target = self.predict(rgb_image, settings, prev_rgb_image, PredictionBBox(target_bbox.class_name, circumscribed_bbox, target_bbox.score))
+        inscribed_bbox = self._inscribe_oriented_box(circumscribed_target.bbox_tlbr, target_bbox.angle)
+        return PredictionBBox(target_bbox.class_name, inscribed_bbox, circumscribed_target.score, target_bbox.angle)
 
     def visualize(
         self,
@@ -560,12 +636,15 @@ class BBoxTracking(BaseTracking):
 
     def _to_sly_geometry(self, dto: PredictionBBox) -> Rectangle:
         top, left, bottom, right = dto.bbox_tlbr
-        geometry = Rectangle(top=top, left=left, bottom=bottom, right=right)
+        if dto.angle is not None:
+            geometry = OrientedBBox(top=top, left=left, bottom=bottom, right=right, angle=dto.angle)
+        else:
+            geometry = Rectangle(top=top, left=left, bottom=bottom, right=right)
         return geometry
 
     def _create_label(self, dto: PredictionBBox) -> Rectangle:
         geometry = self._to_sly_geometry(dto)
-        return Label(geometry, ObjClass("", Rectangle))
+        return Label(geometry, ObjClass("", type(geometry)))
 
     def _get_obj_class_shape(self):
         return Rectangle

supervisely/nn/inference/tracking/tracker_interface.py

@@ -10,11 +10,13 @@ from typing import OrderedDict as OrderedDictType
 import numpy as np
 
 from supervisely._utils import find_value_by_keys
+from supervisely.annotation.label import LabelingStatus
 from supervisely.api.api import Api
 from supervisely.api.module_api import ApiField
 from supervisely.geometry.geometry import Geometry
 from supervisely.geometry.graph import GraphNodes
 from supervisely.geometry.helpers import deserialize_geometry
+from supervisely.geometry.oriented_bbox import OrientedBBox
 from supervisely.geometry.point import Point
 from supervisely.geometry.polygon import Polygon
 from supervisely.geometry.polyline import Polyline
@@ -22,7 +24,6 @@ from supervisely.geometry.rectangle import Rectangle
 from supervisely.nn.inference.cache import InferenceImageCache
 from supervisely.sly_logger import logger
 from supervisely.video_annotation.key_id_map import KeyIdMap
-from supervisely.annotation.label import LabelingStatus
 
 
 class TrackerInterface:
@@ -83,7 +84,7 @@ class TrackerInterface:
     @property
     def video_info(self):
         if self._video_info is None:
-            self._video_info = self.api.video.get_info_by_id(self.video_id)
+            self._video_info = self.api.video.get_info_by_id(self.video_id, raise_error=True)
         return self._video_info
 
     def add_object_geometries(self, geometries: List[Geometry], object_id: int, start_fig: int):
@@ -132,6 +133,10 @@ class TrackerInterface:
             h = self.video_info.frame_height
             w = self.video_info.frame_width
         rect = Rectangle.from_size((h, w))
+        if isinstance(geometry, OrientedBBox):
+            if rect.contains_point_location(geometry.center):
+                return geometry
+            return None
         cropped = geometry.crop(rect)
         if len(cropped) == 0:
             return None

supervisely/nn/inference/uploader.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
+import queue
 import threading
+from concurrent.futures import Future, ThreadPoolExecutor, wait
 from logging import Logger
-from queue import Empty, Queue
-from types import TracebackType
-from typing import Callable, Optional, Type
+from typing import Callable, List
 
-from supervisely.sly_logger import logger
+from supervisely.sly_logger import logger as sly_logger
 
 
 class Uploader:
@@ -25,7 +25,7 @@ class Uploader:
         self._logger = logger
         self.exception = None
         self._lock = threading.Lock()
-        self._q = Queue()
+        self._q = queue.Queue()
         self._stop_event = threading.Event()
         self._exception_event = threading.Event()
         self._upload_thread = threading.Thread(
@@ -34,7 +34,7 @@ class Uploader:
         )
         self.raise_from_notify = False
         self._notify_thread = None
-        self._notify_q = Queue()
+        self._notify_q = queue.Queue()
         if self._notify_f is not None:
             self._notify_thread = threading.Thread(target=self._notify_loop, daemon=True)
             self._notify_thread.start()
@@ -55,14 +55,14 @@ class Uploader:
                     while True:
                         try:
                             items.append(self._notify_q.get_nowait())
-                        except Empty:
+                        except queue.Empty:
                             break
                     if items:
                         self._notify_f(items)
 
                     for _ in range(len(items)):
                         self._notify_q.task_done()
-                except Empty:
+                except queue.Empty:
                     continue
         except StopIteration:
             self.stop()
@@ -91,7 +91,7 @@ class Uploader:
                     while True:
                         try:
                             items.append(self._q.get_nowait())
-                        except Empty:
+                        except queue.Empty:
                             break
                     if items:
                         self._upload_f(items)
@@ -99,7 +99,7 @@ class Uploader:
 
                     for _ in range(len(items)):
                         self._q.task_done()
-                except Empty:
+                except queue.Empty:
                     continue
         except StopIteration:
             self.stop()
@@ -143,7 +143,7 @@ class Uploader:
         self,
         exception: Exception,
     ):
-        raise exception
+        return False  # propagate
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.stop()
@@ -152,7 +152,7 @@ class Uploader:
             if self._upload_thread.is_alive():
                 raise TimeoutError("Uploader thread didn't finish in time")
         except TimeoutError:
-            _logger = logger
+            _logger = sly_logger
             if self._logger is not None:
                 _logger = self._logger
             _logger.warning("Uploader thread didn't finish in time")
@@ -166,3 +166,130 @@ class Uploader:
             except Exception as exc:
                 return self._exception_handler(exc)
         return False
+
+
+class Downloader:
+
+    def __init__(
+        self,
+        download_f: Callable,
+        max_workers: int = 8,
+        buffer_size: int = 100,
+        exception_handler: Callable = None,
+        logger: Logger = None,
+    ):
+        self._download_f = download_f
+        self._max_workers = max_workers
+        self._logger = logger
+        self._exception_handler = exception_handler
+        if self._exception_handler is None:
+            self._exception_handler = self._default_exception_handler
+        self._input_q = queue.Queue()
+        self._buffer_q = queue.Queue(buffer_size)
+        self._output_q = queue.Queue()
+        self._executor: ThreadPoolExecutor = None
+        self._download_futures: List[Future] = None
+        self._stop_event = threading.Event()
+
+    def _download_loop(self):
+        while not self._stop_event.is_set():
+            try:
+                item = self._buffer_q.get(timeout=0.2)
+                try:
+                    output = self._download_f(item)
+                    self._output_q.put(output)
+                finally:
+                    self._buffer_q.task_done()
+            except queue.Empty:
+                continue
+            except Exception as e:
+                logger = self._logger or sly_logger
+                logger.debug("Error in downloader thread", exc_info=True)
+
+    def start(self):
+        if self.is_alive():
+            raise RuntimeError("Downloader already started")
+        self._executor = ThreadPoolExecutor(max_workers=self._max_workers)
+        self._download_futures = []
+        for _ in range(self._max_workers):
+            self._download_futures.append(self._executor.submit(self._download_loop))
+
+    def put(self, item):
+        self._input_q.put(item)
+
+    def get(self, wait=True, timeout: float = None):
+        return self._output_q.get(block=wait, timeout=timeout)
+
+    def _move_input_to_buffer(self):
+        try:
+            item = self._input_q.get_nowait()
+        except queue.Empty:
+            return
+        for _ in range(10):
+            try:
+                self._buffer_q.put_nowait(item)
+                return
+            except queue.Full:
+                pass
+            try:
+                self._buffer_q.get_nowait()
+            except queue.Empty:
+                pass
+        try:
+            self._buffer_q.put_nowait(item)
+            return
+        except:
+            raise RuntimeError("Unable to move item from input to buffer")
+
+    def next(self, n: int = 1, raise_on_error=False):
+        for _ in range(n):
+            try:
+                self._move_input_to_buffer()
+            except Exception:
+                if raise_on_error:
+                    raise
+                logger = sly_logger
+                if self._logger is not None:
+                    logger = self._logger
+                logger.debug("Error moving buffer", exc_info=True)
+                continue
+
+    def is_alive(self):
+        return self._executor is not None and any(not f.done() for f in self._download_futures)
+
+    def stop(self):
+        self._stop_event.set()
+        for future in self._download_futures:
+            future.cancel()
+        self._executor.shutdown(wait=False)
+
+    def join(self, timeout=None):
+        _, not_done = wait(self._download_futures, timeout=timeout)
+        if not_done:
+            raise TimeoutError("Timeout waiting for downloads to complete")
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def _default_exception_handler(
+        self,
+        exception: Exception,
+    ):
+        return False  # propagate
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+        try:
+            self.join(timeout=30)
+            if self.is_alive():
+                raise TimeoutError("Downloader threads didn't finish in time")
+        except TimeoutError:
+            _logger = sly_logger
+            if self._logger is not None:
+                _logger = self._logger
+            _logger.warning("Downloader threads didn't finish in time")
+        if exc_type is not None:
+            exc = exc_val.with_traceback(exc_tb)
+            return self._exception_handler(exc)
+        return False

supervisely/nn/live_training/__init__.py

@@ -0,0 +1,7 @@
+from .loss_plateau_detector import LossPlateauDetector
+from .request_queue import RequestQueue, RequestType
+from .artifacts_utils import upload_artifacts
+from .live_training import LiveTraining
+from .incremental_dataset import IncrementalDataset
+from .dynamic_sampler import DynamicSampler
+from .checkpoint_utils import resolve_checkpoint

supervisely/nn/live_training/api_server.py

@@ -0,0 +1,111 @@
+from fastapi import FastAPI, HTTPException, Request, Response
+import uvicorn
+import threading
+import asyncio
+
+from .request_queue import RequestQueue, RequestType
+import supervisely as sly
+from supervisely import logger
+
+
+def start_api_server(
+    app: sly.Application,
+    request_queue: RequestQueue,
+    host: str = "0.0.0.0",
+    port: int = 8000
+) -> threading.Thread:
+    """Start FastAPI server in a daemon thread."""
+    server = app.get_server()
+    create_api(server, request_queue)
+
+    config = uvicorn.Config(app, host=host, port=port, log_level="info")
+    server = uvicorn.Server(config)
+    
+    thread = threading.Thread(target=server.run, daemon=True, name="APIServer")
+    thread.start()
+    
+    logger.debug(f"Live Training API server started: http://{host}:{port}")
+
+    return thread
+
+
+def create_api(app: FastAPI, request_queue: RequestQueue) -> FastAPI:
+    
+    @app.post("/start")
+    async def start(response: Response):
+        """Start the live training process."""
+        future = request_queue.put(RequestType.START)
+        result = await _wait_for_result(future, response, timeout=None)
+        return result
+        
+    @app.post("/predict")
+    async def predict(request: Request, response: Response):
+        """Run inference on an image."""
+        sly_api = _api_from_request(request)
+        state = request.state.state
+        img_np = sly_api.image.download_np(state['image_id'])
+        future = request_queue.put(
+            RequestType.PREDICT,
+            {'image': img_np, 'image_id': state['image_id']}
+        )
+        result = await _wait_for_result(future, response)
+        return result
+    
+    @app.post("/add-sample")
+    async def add_sample(request: Request, response: Response):
+        """Add a new training sample."""
+        sly_api = _api_from_request(request)
+        state = request.state.state
+        img_np = sly_api.image.download_np(state['image_id'])
+        ann_json = sly_api.annotation.download_json(state['image_id'])
+        img_info = sly_api.image.get_info_by_id(state['image_id'])
+        future = request_queue.put(
+            RequestType.ADD_SAMPLE,
+            {
+                'image': img_np,
+                'annotation': ann_json,
+                'image_id': state['image_id'],
+                'image_name': img_info.name
+            }
+        )
+        result = await _wait_for_result(future, response)
+        return result
+
+    @app.post("/status")
+    async def status(response: Response):
+        """Check the status of the training process."""
+        future = request_queue.put(RequestType.STATUS)
+        result = await _wait_for_result(future, response)
+        return result
+
+    return app
+
+
+async def _wait_for_result(future: asyncio.Future, response: Response, timeout: float = 600.0):
+    """Wait for the future to complete with a timeout."""
+    try:
+        result = await asyncio.wait_for(future, timeout=timeout)
+    except asyncio.TimeoutError:
+        # raise HTTPException(503, detail={"error": "Request timeout - training may be busy"})
+        response.status_code = 503
+        result = _error_response_message("Request timeout - training may be busy")
+    except Exception as e:
+        # raise HTTPException(500, detail={"error": str(e)})
+        response.status_code = 500
+        result = _error_response_message(str(e))
+    return result
+
+
+def _api_from_request(request: Request) -> sly.Api:
+    api = None
+    try:
+        api = request.state.api
+    finally:
+        if not isinstance(api, sly.Api):
+            logger.warning("sly.Api instance not found in request.state.api. Creating API from app's credentials.")
+            api = sly.Api()
+    return api
+
+
+def _error_response_message(message: str):
+    return {"error": {"details": {"message": message}}}