superiorvision 0.30.0.dev1__tar.gz → 0.30.0.dev2__tar.gz

{superiorvision-0.30.0.dev1/src/superiorvision.egg-info → superiorvision-0.30.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superiorvision
-Version: 0.30.0.dev1
+Version: 0.30.0.dev2
 Summary: A tensor-native, inference-focused fork of Supervision
 Author-email: "Roboflow et al." <develop@roboflow.com>
 Maintainer-email: Piotr Skalski <piotr@roboflow.com>
@@ -114,7 +114,7 @@ Install the SuperiorVision distribution in a
 is currently a development release, so pin it explicitly:
 
 ```bash
-pip install superiorvision==0.30.0.dev1
+pip install superiorvision==0.30.0.dev2
 ```
 
 For an editable checkout:

{superiorvision-0.30.0.dev1 → superiorvision-0.30.0.dev2}/README.md

@@ -63,7 +63,7 @@ Install the SuperiorVision distribution in a
 is currently a development release, so pin it explicitly:
 
 ```bash
-pip install superiorvision==0.30.0.dev1
+pip install superiorvision==0.30.0.dev2
 ```
 
 For an editable checkout:

{superiorvision-0.30.0.dev1 → superiorvision-0.30.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "setuptools>=61" ]
 
 [project]
 name = "superiorvision"
-version = "0.30.0.dev1"
+version = "0.30.0.dev2"
 description = "A tensor-native, inference-focused fork of Supervision"
 readme = "README.md"
 keywords = [

{superiorvision-0.30.0.dev1 → superiorvision-0.30.0.dev2/src/superiorvision.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superiorvision
-Version: 0.30.0.dev1
+Version: 0.30.0.dev2
 Summary: A tensor-native, inference-focused fork of Supervision
 Author-email: "Roboflow et al." <develop@roboflow.com>
 Maintainer-email: Piotr Skalski <piotr@roboflow.com>
@@ -114,7 +114,7 @@ Install the SuperiorVision distribution in a
 is currently a development release, so pin it explicitly:
 
 ```bash
-pip install superiorvision==0.30.0.dev1
+pip install superiorvision==0.30.0.dev2
 ```
 
 For an editable checkout:

{superiorvision-0.30.0.dev1 → superiorvision-0.30.0.dev2}/src/supervision/detection/core.py

@@ -63,9 +63,6 @@ from supervision.detection.utils.iou_and_nms import (
 from supervision.detection.utils.iou_and_nms import (
     box_non_max_merge as numpy_box_non_max_merge,
 )
-from supervision.detection.utils.iou_and_nms import (
-    box_non_max_suppression as numpy_box_non_max_suppression,
-)
 from supervision.detection.utils.iou_and_nms import (
     mask_non_max_merge as numpy_mask_non_max_merge,
 )
@@ -784,7 +781,7 @@ class Detections:
     @classmethod
     def from_transformers(
         cls,
-        transformers_results: dict[str, Any],
+        transformers_results: Any,
         id2label: dict[int, str] | None = None,
     ) -> Detections:
         """
@@ -2961,7 +2958,10 @@ class Detections:
         ):
             index = [int(index)]
         tensor_index = _index_for_device(index, self.xyxy.device)
-        host_index = _index_for_host(index)
+        needs_host_index = isinstance(self.mask, CompactMask) or any(
+            not isinstance(value, torch.Tensor) for value in self.data.values()
+        )
+        host_index = _index_for_host(index) if needs_host_index else index
         data: _DetectionDataType = {}
         for key, value in self.data.items():
             if isinstance(value, torch.Tensor):
@@ -3329,10 +3329,7 @@ class Detections:
             )
 
         if self.mask is not None:
-            if (
-                isinstance(self.mask, torch.Tensor)
-                and overlap_metric == OverlapMetric.IOU
-            ):
+            if isinstance(self.mask, torch.Tensor):
                 indices = tensor_mask_non_max_suppression(
                     predictions=predictions,
                     masks=self.mask,
@@ -3359,18 +3356,12 @@ class Detections:
                 iou_threshold=threshold,
                 overlap_metric=overlap_metric,
             )
-        elif overlap_metric == OverlapMetric.IOU:
+        else:
             indices = tensor_box_non_max_suppression(
                 predictions=predictions,
                 iou_threshold=threshold,
                 overlap_metric=overlap_metric,
             )
-        else:
-            indices = numpy_box_non_max_suppression(
-                predictions=to_numpy(predictions),
-                iou_threshold=threshold,
-                overlap_metric=overlap_metric,
-            )
 
         return self.select(indices)
 

{superiorvision-0.30.0.dev1 → superiorvision-0.30.0.dev2}/src/supervision/detection/overlap_filter.py

@@ -10,6 +10,40 @@ import torch
 from supervision.detection.utils import box_iou_batch, mask_iou_batch
 
 
+def _uses_intersection_over_smaller(overlap_metric: object | None) -> bool:
+    """Return whether an overlap metric requests intersection over smaller area."""
+    value = getattr(overlap_metric, "value", overlap_metric)
+    return isinstance(value, str) and value.lower() == "ios"
+
+
+def _tensor_mask_overlap_batch(
+    masks: torch.Tensor, overlap_metric: object | None
+) -> torch.Tensor:
+    """Compute pairwise tensor mask overlap without leaving the source device."""
+    flat_masks = masks.bool().flatten(1)
+    intersection = (flat_masks[:, None] & flat_masks[None, :]).sum(dim=2)
+    areas = flat_masks.sum(dim=1)
+    if _uses_intersection_over_smaller(overlap_metric):
+        denominator = torch.minimum(areas[:, None], areas[None, :])
+    else:
+        denominator = areas[:, None] + areas[None, :] - intersection
+    return intersection / denominator.clamp(min=1)
+
+
+def _tensor_box_overlap_batch(
+    boxes: torch.Tensor, overlap_metric: object | None
+) -> torch.Tensor:
+    """Compute pairwise tensor box overlap without leaving the source device."""
+    if not _uses_intersection_over_smaller(overlap_metric):
+        return box_iou_batch(boxes, boxes)
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    top_left = torch.maximum(boxes[:, None, :2], boxes[:, :2])
+    bottom_right = torch.minimum(boxes[:, None, 2:], boxes[:, 2:])
+    intersection = (bottom_right - top_left).clamp(min=0).prod(dim=2)
+    denominator = torch.minimum(areas[:, None], areas[None, :])
+    return torch.nan_to_num(intersection / denominator)
+
+
 def resize_masks(masks: np.ndarray, max_dimension: int = 640) -> np.ndarray:
     """
     Resize all masks in the array to have a maximum dimension of max_dimension,
@@ -86,16 +120,15 @@ def mask_non_max_suppression(
         # Pairwise mask IoU without leaving the source device. This is intentionally
         # exact; callers wanting a reduced-resolution approximation can downsample
         # the masks before constructing Detections.
-        flat_masks = sorted_masks.bool().flatten(1)
-        intersection = (flat_masks[:, None] & flat_masks[None, :]).sum(dim=2)
-        areas = flat_masks.sum(dim=1)
-        ious = intersection / (areas[:, None] + areas[None, :] - intersection).clamp(min=1)
+        ious = _tensor_mask_overlap_batch(sorted_masks, overlap_metric)
         categories = sorted_predictions[:, 5]
         keep = torch.ones(rows, dtype=torch.bool, device=predictions.device)
         for index in range(rows):
-            if not keep[index]:
-                continue
-            suppress = (ious[index] > iou_threshold) & (categories == categories[index])
+            suppress = (
+                (ious[index] > iou_threshold)
+                & (categories == categories[index])
+                & keep[index]
+            )
             suppress[index] = False
             keep &= ~suppress
         output = torch.zeros(rows, dtype=torch.bool, device=predictions.device)
@@ -159,12 +192,14 @@ def box_non_max_suppression(
         sort_index = torch.argsort(predictions[:, 4], descending=True)
         sorted_predictions = predictions[sort_index]
         boxes, categories = sorted_predictions[:, :4], sorted_predictions[:, 5]
-        ious = box_iou_batch(boxes, boxes)
+        ious = _tensor_box_overlap_batch(boxes, overlap_metric)
         keep = torch.ones(rows, dtype=torch.bool, device=predictions.device)
         for index in range(rows):
-            if not keep[index]:
-                continue
-            suppress = (ious[index] > iou_threshold) & (categories == categories[index])
+            suppress = (
+                (ious[index] > iou_threshold)
+                & (categories == categories[index])
+                & keep[index]
+            )
             suppress[index] = False
             keep &= ~suppress
         output = torch.zeros(rows, dtype=torch.bool, device=predictions.device)

{superiorvision-0.30.0.dev1 → superiorvision-0.30.0.dev2}/src/supervision/detection/tools/transformers.py

@@ -8,7 +8,43 @@ import numpy.typing as npt
 from PIL import Image
 
 from supervision.config import CLASS_NAME_DATA_FIELD
-from supervision.detection.utils.converters import mask_to_xyxy
+from supervision.detection.tensor_utils import mask_to_xyxy
+
+
+def _detach_numeric(value: Any) -> Any:
+    """Detach real tensors in place while retaining legacy array-like inputs."""
+    import torch
+
+    if isinstance(value, torch.Tensor):
+        return value.detach()
+    if isinstance(value, np.ndarray):
+        return value
+    return value.detach().numpy()
+
+
+def _as_boolean(value: Any) -> Any:
+    """Cast a numeric mask to boolean without changing its device or container."""
+    import torch
+
+    if isinstance(value, torch.Tensor):
+        return value.to(dtype=torch.bool)
+    return value.astype(bool)
+
+
+def _as_integer(value: Any) -> Any:
+    """Cast class identifiers to integers without changing their device."""
+    import torch
+
+    if isinstance(value, torch.Tensor):
+        return value.to(dtype=torch.long)
+    return value.astype(int)
+
+
+def _is_tensor(value: Any) -> bool:
+    """Return whether a value is a Torch tensor without importing Torch eagerly."""
+    import torch
+
+    return isinstance(value, torch.Tensor)
 
 
 def process_transformers_detection_result(
@@ -29,12 +65,12 @@ def process_transformers_detection_result(
         Processed detection result including bounding boxes, confidence scores,
             class IDs, and data.
     """
-    class_ids = detection_result["labels"].cpu().detach().numpy().astype(int)
+    class_ids = _as_integer(_detach_numeric(detection_result["labels"]))
     data = append_class_names_to_data(class_ids, id2label, {})
 
     return dict(
-        xyxy=detection_result["boxes"].cpu().detach().numpy(),
-        confidence=detection_result["scores"].cpu().detach().numpy(),
+        xyxy=_detach_numeric(detection_result["boxes"]),
+        confidence=_detach_numeric(detection_result["scores"]),
         class_id=class_ids,
         data=data,
     )
@@ -66,14 +102,14 @@ def process_transformers_v4_segmentation_result(
     else:
         boxes = None
         if "boxes" in segmentation_result:
-            boxes = segmentation_result["boxes"].cpu().detach().numpy()
-        masks = segmentation_result["masks"].cpu().detach().numpy().astype(bool)
-        class_ids = segmentation_result["labels"].cpu().detach().numpy().astype(int)
+            boxes = _detach_numeric(segmentation_result["boxes"])
+        masks = _as_boolean(_detach_numeric(segmentation_result["masks"]))
+        class_ids = _as_integer(_detach_numeric(segmentation_result["labels"]))
 
         return dict(
             xyxy=boxes if boxes is not None else mask_to_xyxy(masks),
-            mask=np.squeeze(masks, axis=1) if boxes is not None else masks,
-            confidence=segmentation_result["scores"].cpu().detach().numpy(),
+            mask=masks.squeeze(1) if boxes is not None else masks,
+            confidence=_detach_numeric(segmentation_result["scores"]),
             class_id=class_ids,
             data=append_class_names_to_data(class_ids, id2label, {}),
         )
@@ -99,8 +135,13 @@ def process_transformers_v5_segmentation_result(
         Processed segmentation result including bounding boxes, masks, confidence
             scores, class IDs, and data.
     """
+    if _is_tensor(segmentation_result):
+        segmentation_array = segmentation_result.detach()
+        return process_transformers_v5_panoptic_segmentation_result(
+            segmentation_array, id2label
+        )
     if segmentation_result.__class__.__name__ == "Tensor":
-        segmentation_array = segmentation_result.cpu().detach().numpy()
+        segmentation_array = segmentation_result.detach().numpy()
         return process_transformers_v5_panoptic_segmentation_result(
             segmentation_array, id2label
         )
@@ -128,15 +169,38 @@ def process_transformers_v5_semantic_or_instance_segmentation_result(
             scores, class IDs, and data.
     """
     segments_info = segmentation_result["segments_info"]
-    segmentation_array = segmentation_result["segmentation"].cpu().detach().numpy()
-    scores = np.array([segment["score"] for segment in segments_info], dtype=float)
-    class_ids = np.array([segment["label_id"] for segment in segments_info], dtype=int)
-    if len(segments_info) == 0:
-        masks = np.empty((0, *segmentation_array.shape), dtype=bool)
+    segmentation_array = _detach_numeric(segmentation_result["segmentation"])
+    if _is_tensor(segmentation_array):
+        import torch
+
+        device = segmentation_array.device
+        scores = torch.tensor(
+            [segment["score"] for segment in segments_info],
+            dtype=torch.float32,
+            device=device,
+        )
+        class_ids = torch.tensor(
+            [segment["label_id"] for segment in segments_info],
+            dtype=torch.long,
+            device=device,
+        )
+        segment_ids = torch.tensor(
+            [segment["id"] for segment in segments_info],
+            dtype=segmentation_array.dtype,
+            device=device,
+        )
+        masks = segmentation_array.unsqueeze(0) == segment_ids[:, None, None]
     else:
-        masks = np.array(
-            [segmentation_array == segment["id"] for segment in segments_info]
-        ).astype(bool)
+        scores = np.array([segment["score"] for segment in segments_info], dtype=float)
+        class_ids = np.array(
+            [segment["label_id"] for segment in segments_info], dtype=int
+        )
+        if len(segments_info) == 0:
+            masks = np.empty((0, *segmentation_array.shape), dtype=bool)
+        else:
+            masks = np.array(
+                [segmentation_array == segment["id"] for segment in segments_info]
+            ).astype(bool)
     data = append_class_names_to_data(class_ids, id2label, {})
 
     return dict(
@@ -183,7 +247,7 @@ def process_transformers_v4_panoptic_segmentation_result(
 
 
 def process_transformers_v5_panoptic_segmentation_result(
-    segmentation_array: npt.NDArray[Any], id2label: dict[int, str] | None
+    segmentation_array: Any, id2label: dict[int, str] | None
 ) -> dict[str, Any]:
     """
     Process a v5 Transformers semantic segmentation tensor.
@@ -198,13 +262,19 @@ def process_transformers_v5_panoptic_segmentation_result(
         Processed segmentation result including bounding boxes, masks,
             class IDs, and data.
     """
-    class_ids = np.unique(segmentation_array).astype(int)
-    if len(class_ids) == 0:
-        masks = np.empty((0, *segmentation_array.shape), dtype=bool)
+    if _is_tensor(segmentation_array):
+        import torch
+
+        class_ids = torch.unique(segmentation_array).to(dtype=torch.long)
+        masks = segmentation_array.unsqueeze(0) == class_ids[:, None, None]
     else:
-        masks = np.stack(
-            [segmentation_array == class_id for class_id in class_ids], axis=0
-        ).astype(bool)
+        class_ids = np.unique(segmentation_array).astype(int)
+        if len(class_ids) == 0:
+            masks = np.empty((0, *segmentation_array.shape), dtype=bool)
+        else:
+            masks = np.stack(
+                [segmentation_array == class_id for class_id in class_ids], axis=0
+            ).astype(bool)
     data = append_class_names_to_data(class_ids, id2label, {})
     return dict(xyxy=mask_to_xyxy(masks), mask=masks, class_id=class_ids, data=data)
 
@@ -237,7 +307,7 @@ def png_string_to_segmentation_array(png_string: bytes) -> npt.NDArray[Any]:
 
 
 def append_class_names_to_data(
-    class_ids: npt.NDArray[Any],
+    class_ids: Any,
     id2label: dict[int, str] | None,
     data: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
@@ -259,7 +329,11 @@ def append_class_names_to_data(
         data = {}
 
     if id2label is not None:
-        class_names = np.array([id2label[class_id] for class_id in class_ids])
+        if _is_tensor(class_ids):
+            host_class_ids = class_ids.detach().cpu().tolist()
+        else:
+            host_class_ids = class_ids.tolist()
+        class_names = np.array([id2label[class_id] for class_id in host_class_ids])
         data[CLASS_NAME_DATA_FIELD] = class_names
 
     return data

{superiorvision-0.30.0.dev1 → superiorvision-0.30.0.dev2}/src/supervision/key_points/core.py

@@ -11,6 +11,7 @@ import torch
 
 from supervision.config import CLASS_NAME_DATA_FIELD
 from supervision.detection.core import Detections
+from supervision.detection.overlap_filter import box_non_max_suppression
 from supervision.detection.utils._typing import (
     _DetectionDataType,
     _DetectionDataValueType,
@@ -20,10 +21,7 @@ from supervision.detection.utils.internal import (
     is_data_equal,
     merge_data,
 )
-from supervision.detection.utils.iou_and_nms import (
-    OverlapMetric,
-    box_non_max_suppression,
-)
+from supervision.detection.utils.iou_and_nms import OverlapMetric
 from supervision.utils.internal import warn_deprecated
 from supervision.utils.tensor import as_tensor, tensor_data
 from supervision.validators import _validate_keypoints_fields
@@ -56,11 +54,6 @@ def _select_data(
 ) -> _DetectionDataType:
     """Select mixed tensor/host metadata without moving numeric tensors off device."""
     selected: dict[str, Any] = {}
-    host_index: int | slice | npt.NDArray[np.generic]
-    if isinstance(index, torch.Tensor):
-        host_index = index.detach().cpu().numpy()
-    else:
-        host_index = index
     for key, value in data.items():
         if isinstance(value, torch.Tensor):
             tensor_index = (
@@ -70,6 +63,11 @@ def _select_data(
             )
             selected[key] = value[tensor_index]
         else:
+            host_index = (
+                index.detach().cpu().numpy()
+                if isinstance(index, torch.Tensor)
+                else index
+            )
             selected.update(get_data_item({key: value}, cast(Any, host_index)))
     return cast(_DetectionDataType, selected)