valor-lite 0.33.2__py3-none-any.whl → 0.33.4__py3-none-any.whl

valor_lite/detection/__init__.py

@@ -1,11 +1,10 @@
-from .annotation import Bitmask, BoundingBox, Detection
+from .annotation import Bitmask, BoundingBox, Detection, Polygon
 from .computation import (
     compute_detailed_counts,
-    compute_iou,
     compute_metrics,
     compute_ranked_pairs,
 )
-from .manager import DataLoader, Evaluator
+from .manager import DataLoader, Evaluator, compute_iou
 from .metric import (
     AP,
     AR,
@@ -29,6 +28,7 @@ __all__ = [
     "Bitmask",
     "BoundingBox",
     "Detection",
+    "Polygon",
     "MetricType",
     "Counts",
     "Precision",

valor_lite/detection/annotation.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass, field
 
 import numpy as np
 from numpy.typing import NDArray
+from shapely.geometry import Polygon as ShapelyPolygon
 
 
 @dataclass
@@ -24,6 +25,37 @@ class BoundingBox:
         return (self.xmin, self.xmax, self.ymin, self.ymax)
 
 
+@dataclass
+class Polygon:
+    shape: ShapelyPolygon
+    labels: list[tuple[str, str]]
+    scores: list[float] = field(default_factory=list)
+
+    def __post_init__(self):
+        if not isinstance(self.shape, ShapelyPolygon):
+            raise TypeError("shape must be of type shapely.geometry.Polygon.")
+        if len(self.scores) > 0 and len(self.labels) != len(self.scores):
+            raise ValueError(
+                "If scores are defined, there must be a 1:1 pairing with labels."
+            )
+
+    def to_box(self) -> BoundingBox | None:
+
+        if self.shape.is_empty:
+            return None
+
+        xmin, ymin, xmax, ymax = self.shape.bounds
+
+        return BoundingBox(
+            xmin=xmin,
+            xmax=xmax,
+            ymin=ymin,
+            ymax=ymax,
+            labels=self.labels,
+            scores=self.scores,
+        )
+
+
 @dataclass
 class Bitmask:
     mask: NDArray[np.bool_]
@@ -36,15 +68,27 @@ class Bitmask:
                 "If scores are defined, there must be a 1:1 pairing with labels."
             )
 
-    def to_box(self) -> BoundingBox:
-        raise NotImplementedError
+    def to_box(self) -> BoundingBox | None:
+
+        if not self.mask.any():
+            return None
+
+        rows, cols = np.nonzero(self.mask)
+        return BoundingBox(
+            xmin=cols.min(),
+            xmax=cols.max(),
+            ymin=rows.min(),
+            ymax=rows.max(),
+            labels=self.labels,
+            scores=self.scores,
+        )
 
 
 @dataclass
 class Detection:
     uid: str
-    groundtruths: list[BoundingBox]
-    predictions: list[BoundingBox]
+    groundtruths: list[BoundingBox] | list[Bitmask] | list[Polygon]
+    predictions: list[BoundingBox] | list[Bitmask] | list[Polygon]
 
     def __post_init__(self):
         for prediction in self.predictions:

valor_lite/detection/computation.py

@@ -2,7 +2,7 @@ import numpy as np
 from numpy.typing import NDArray
 
 
-def compute_iou(data: NDArray[np.floating]) -> NDArray[np.floating]:
+def compute_bbox_iou(data: NDArray[np.floating]) -> NDArray[np.floating]:
     """
     Computes intersection-over-union (IoU) for axis-aligned bounding boxes.
 
@@ -24,14 +24,12 @@ def compute_iou(data: NDArray[np.floating]) -> NDArray[np.floating]:
     Parameters
     ----------
     data : NDArray[np.floating]
-        A sorted array of classification pairs.
-    label_metadata : NDArray[np.int32]
-        An array containing metadata related to labels.
+        A sorted array of bounding box pairs.
 
     Returns
     -------
     NDArray[np.floating]
-        Compute IoU's.
+        Computed IoU's.
     """
 
     xmin1, xmax1, ymin1, ymax1 = (
@@ -69,10 +67,77 @@ def compute_iou(data: NDArray[np.floating]) -> NDArray[np.floating]:
     return iou
 
 
+def compute_bitmask_iou(data: NDArray[np.floating]) -> NDArray[np.floating]:
+    """
+    Computes intersection-over-union (IoU) for bitmasks.
+
+    Takes data with shape (N, 2):
+
+    Index 0 - first bitmask
+    Index 1 - second bitmask
+
+    Returns data with shape (N, 1):
+
+    Index 0 - IoU
+
+    Parameters
+    ----------
+    data : NDArray[np.floating]
+        A sorted array of bitmask pairs.
+
+    Returns
+    -------
+    NDArray[np.floating]
+        Computed IoU's.
+    """
+    intersection_ = np.array([np.logical_and(x, y).sum() for x, y in data])
+    union_ = np.array([np.logical_or(x, y).sum() for x, y in data])
+
+    return intersection_ / union_
+
+
+def compute_polygon_iou(
+    data: NDArray[np.floating],
+) -> NDArray[np.floating]:
+    """
+    Computes intersection-over-union (IoU) for shapely polygons.
+
+    Takes data with shape (N, 2):
+
+    Index 0 - first polygon
+    Index 1 - second polygon
+
+    Returns data with shape (N, 1):
+
+    Index 0 - IoU
+
+    Parameters
+    ----------
+    data : NDArray[np.floating]
+        A sorted array of polygon pairs.
+
+    Returns
+    -------
+    NDArray[np.floating]
+        Computed IoU's.
+    """
+    intersection_ = np.array(
+        [poly1.intersection(poly2).area for poly1, poly2 in data]
+    )
+    union_ = np.array(
+        [
+            poly1.area + poly2.area - intersection_[i]
+            for i, (poly1, poly2) in enumerate(data)
+        ]
+    )
+
+    return intersection_ / union_
+
+
 def _compute_ranked_pairs_for_datum(
-    data: np.ndarray,
-    label_metadata: np.ndarray,
-) -> np.ndarray:
+    data: NDArray[np.floating],
+    label_metadata: NDArray[np.int32],
+) -> NDArray[np.floating]:
     """
     Computes ranked pairs for a datum.
     """
@@ -113,7 +178,7 @@ def _compute_ranked_pairs_for_datum(
 
 def compute_ranked_pairs(
     data: list[NDArray[np.floating]],
-    label_metadata: NDArray[np.integer],
+    label_metadata: NDArray[np.int32],
 ) -> NDArray[np.floating]:
     """
     Performs pair ranking on input data.
@@ -133,7 +198,7 @@ def compute_ranked_pairs(
     Parameters
     ----------
     data : NDArray[np.floating]
-        A sorted array of classification pairs.
+        A sorted array summarizing the IOU calculations of one or more pairs.
     label_metadata : NDArray[np.int32]
         An array containing metadata related to labels.
 
@@ -142,30 +207,29 @@ def compute_ranked_pairs(
     NDArray[np.floating]
         A filtered array containing only ranked pairs.
     """
-    pairs = np.concatenate(
-        [
-            _compute_ranked_pairs_for_datum(
-                datum,
-                label_metadata=label_metadata,
-            )
-            for datum in data
-        ],
-        axis=0,
-    )
+
+    ranked_pairs_by_datum = [
+        _compute_ranked_pairs_for_datum(
+            data=datum,
+            label_metadata=label_metadata,
+        )
+        for datum in data
+    ]
+    ranked_pairs = np.concatenate(ranked_pairs_by_datum, axis=0)
     indices = np.lexsort(
         (
-            -pairs[:, 3],  # iou
-            -pairs[:, 6],  # score
+            -ranked_pairs[:, 3],  # iou
+            -ranked_pairs[:, 6],  # score
         )
     )
-    return pairs[indices]
+    return ranked_pairs[indices]
 
 
 def compute_metrics(
-    data: np.ndarray,
-    label_metadata: np.ndarray,
-    iou_thresholds: np.ndarray,
-    score_thresholds: np.ndarray,
+    data: NDArray[np.floating],
+    label_metadata: NDArray[np.int32],
+    iou_thresholds: NDArray[np.floating],
+    score_thresholds: NDArray[np.floating],
 ) -> tuple[
     tuple[
         NDArray[np.floating],
@@ -198,7 +262,7 @@ def compute_metrics(
     Parameters
     ----------
     data : NDArray[np.floating]
-        A sorted array of classification pairs.
+        A sorted array summarizing the IOU calculations of one or more pairs.
     label_metadata : NDArray[np.int32]
         An array containing metadata related to labels.
     iou_thresholds : NDArray[np.floating]
@@ -429,12 +493,12 @@ def compute_metrics(
 
 
 def compute_detailed_counts(
-    data: np.ndarray,
-    label_metadata: np.ndarray,
-    iou_thresholds: np.ndarray,
-    score_thresholds: np.ndarray,
+    data: NDArray[np.floating],
+    label_metadata: NDArray[np.int32],
+    iou_thresholds: NDArray[np.floating],
+    score_thresholds: NDArray[np.floating],
     n_samples: int,
-) -> np.ndarray:
+) -> NDArray[np.int32]:
     """
     Compute detailed counts.
 
@@ -452,19 +516,19 @@ def compute_detailed_counts(
 
     Index 0 - True Positive Count
     ... Datum ID Examples
-    Index n_samples + 1 - False Positive Misclassification Count
+    Index 2 * n_samples + 1 - False Positive Misclassification Count
     ... Datum ID Examples
-    Index 2 * n_samples + 2 - False Positive Hallucination Count
+    Index 4 * n_samples + 2 - False Positive Hallucination Count
     ... Datum ID Examples
-    Index 3 * n_samples + 3 - False Negative Misclassification Count
+    Index 6 * n_samples + 3 - False Negative Misclassification Count
     ... Datum ID Examples
-    Index 4 * n_samples + 4 - False Negative Missing Prediction Count
+    Index 8 * n_samples + 4 - False Negative Missing Prediction Count
     ... Datum ID Examples
 
     Parameters
     ----------
     data : NDArray[np.floating]
-        A sorted array of classification pairs.
+        A sorted array summarizing the IOU calculations of one or more pairs.
     label_metadata : NDArray[np.int32]
         An array containing metadata related to labels.
     iou_thresholds : NDArray[np.floating]
@@ -476,22 +540,24 @@ def compute_detailed_counts(
 
     Returns
     -------
-    NDArray[np.floating]
+    NDArray[np.int32]
         The detailed counts with optional examples.
     """
 
     n_labels = label_metadata.shape[0]
     n_ious = iou_thresholds.shape[0]
     n_scores = score_thresholds.shape[0]
-    n_metrics = 5 * (n_samples + 1)
+    n_metrics = 5 * (2 * n_samples + 1)
 
     tp_idx = 0
-    fp_misclf_idx = tp_idx + n_samples + 1
-    fp_halluc_idx = fp_misclf_idx + n_samples + 1
-    fn_misclf_idx = fp_halluc_idx + n_samples + 1
-    fn_misprd_idx = fn_misclf_idx + n_samples + 1
+    fp_misclf_idx = 2 * n_samples + 1
+    fp_halluc_idx = 4 * n_samples + 2
+    fn_misclf_idx = 6 * n_samples + 3
+    fn_misprd_idx = 8 * n_samples + 4
 
-    detailed_pr_curve = np.ones((n_ious, n_scores, n_labels, n_metrics)) * -1.0
+    detailed_pr_curve = -1 * np.ones(
+        (n_ious, n_scores, n_labels, n_metrics), dtype=np.int32
+    )
 
     mask_gt_exists = data[:, 1] > -0.5
     mask_pd_exists = data[:, 2] > -0.5
@@ -509,13 +575,14 @@ def compute_detailed_counts(
         mask_iou_threshold = data[:, 3] >= iou_thresholds[iou_idx]
         mask_iou = mask_iou_nonzero & mask_iou_threshold
 
-        groundtruths_with_pairs = np.unique(groundtruths[mask_iou], axis=0)
+        groundtruths_passing_ious = np.unique(groundtruths[mask_iou], axis=0)
         mask_groundtruths_with_passing_ious = (
-            groundtruths.reshape(-1, 1, 2)
-            == groundtruths_with_pairs.reshape(1, -1, 2)
-        ).all(axis=2)
-        mask_groundtruths_with_passing_ious = (
-            mask_groundtruths_with_passing_ious.any(axis=1)
+            (
+                groundtruths.reshape(-1, 1, 2)
+                == groundtruths_passing_ious.reshape(1, -1, 2)
+            )
+            .all(axis=2)
+            .any(axis=1)
         )
         mask_groundtruths_without_passing_ious = (
             ~mask_groundtruths_with_passing_ious & mask_gt_exists
@@ -525,11 +592,12 @@ def compute_detailed_counts(
             predictions[mask_iou], axis=0
         )
         mask_predictions_with_passing_ious = (
-            predictions.reshape(-1, 1, 2)
-            == predictions_with_passing_ious.reshape(1, -1, 2)
-        ).all(axis=2)
-        mask_predictions_with_passing_ious = (
-            mask_predictions_with_passing_ious.any(axis=1)
+            (
+                predictions.reshape(-1, 1, 2)
+                == predictions_with_passing_ious.reshape(1, -1, 2)
+            )
+            .all(axis=2)
+            .any(axis=1)
         )
         mask_predictions_without_passing_ious = (
             ~mask_predictions_with_passing_ious & mask_pd_exists
@@ -543,11 +611,12 @@ def compute_detailed_counts(
                 groundtruths[mask_iou & mask_score], axis=0
             )
             mask_groundtruths_with_passing_score = (
-                groundtruths.reshape(-1, 1, 2)
-                == groundtruths_with_passing_score.reshape(1, -1, 2)
-            ).all(axis=2)
-            mask_groundtruths_with_passing_score = (
-                mask_groundtruths_with_passing_score.any(axis=1)
+                (
+                    groundtruths.reshape(-1, 1, 2)
+                    == groundtruths_with_passing_score.reshape(1, -1, 2)
+                )
+                .all(axis=2)
+                .any(axis=1)
             )
             mask_groundtruths_without_passing_score = (
                 ~mask_groundtruths_with_passing_score & mask_gt_exists
@@ -623,21 +692,41 @@ def compute_detailed_counts(
 
             if n_samples > 0:
                 for label_idx in range(n_labels):
-                    tp_examples = tp[tp[:, 2].astype(int) == label_idx][
-                        :n_samples, 0
-                    ]
-                    fp_misclf_examples = fp_misclf[
-                        fp_misclf[:, 2].astype(int) == label_idx
-                    ][:n_samples, 0]
-                    fp_halluc_examples = fp_halluc[
-                        fp_halluc[:, 2].astype(int) == label_idx
-                    ][:n_samples, 0]
-                    fn_misclf_examples = fn_misclf[
-                        fn_misclf[:, 2].astype(int) == label_idx
-                    ][:n_samples, 0]
-                    fn_misprd_examples = fn_misprd[
-                        fn_misprd[:, 2].astype(int) == label_idx
-                    ][:n_samples, 0]
+                    tp_examples = (
+                        tp[tp[:, 2].astype(int) == label_idx][
+                            :n_samples, [0, 1]
+                        ]
+                        .astype(int)
+                        .flatten()
+                    )
+                    fp_misclf_examples = (
+                        fp_misclf[fp_misclf[:, 2].astype(int) == label_idx][
+                            :n_samples, [0, 1]
+                        ]
+                        .astype(int)
+                        .flatten()
+                    )
+                    fp_halluc_examples = (
+                        fp_halluc[fp_halluc[:, 2].astype(int) == label_idx][
+                            :n_samples, [0, 1]
+                        ]
+                        .astype(int)
+                        .flatten()
+                    )
+                    fn_misclf_examples = (
+                        fn_misclf[fn_misclf[:, 2].astype(int) == label_idx][
+                            :n_samples, [0, 1]
+                        ]
+                        .astype(int)
+                        .flatten()
+                    )
+                    fn_misprd_examples = (
+                        fn_misprd[fn_misprd[:, 2].astype(int) == label_idx][
+                            :n_samples, [0, 1]
+                        ]
+                        .astype(int)
+                        .flatten()
+                    )
 
                     detailed_pr_curve[
                         iou_idx,