valor-lite 0.35.0__py3-none-any.whl → 0.36.1__py3-none-any.whl

valor_lite/classification/utilities.py

@@ -19,7 +19,7 @@ def unpack_precision_recall_rocauc_into_metric_lists(
     score_thresholds: list[float],
     hardmax: bool,
     label_metadata: NDArray[np.int32],
-    index_to_label: dict[int, str],
+    index_to_label: list[str],
 ) -> dict[MetricType, list[Metric]]:
     (
         counts,
@@ -38,7 +38,7 @@ def unpack_precision_recall_rocauc_into_metric_lists(
             value=float(rocauc[label_idx]),
             label=label,
         )
-        for label_idx, label in index_to_label.items()
+        for label_idx, label in enumerate(index_to_label)
         if label_metadata[label_idx, 0] > 0
     ]
 
@@ -57,7 +57,7 @@ def unpack_precision_recall_rocauc_into_metric_lists(
         for score_idx, score_threshold in enumerate(score_thresholds)
     ]
 
-    for label_idx, label in index_to_label.items():
+    for label_idx, label in enumerate(index_to_label):
         for score_idx, score_threshold in enumerate(score_thresholds):
 
             kwargs = {
@@ -105,8 +105,8 @@ def _unpack_confusion_matrix_value(
     confusion_matrix: NDArray[np.float64],
     number_of_labels: int,
     number_of_examples: int,
-    index_to_uid: dict[int, str],
-    index_to_label: dict[int, str],
+    index_to_datum_id: list[str],
+    index_to_label: list[str],
 ) -> dict[str, dict[str, dict[str, int | list[dict[str, str | float]]]]]:
     """
     Unpacks a numpy array of confusion matrix counts and examples.
@@ -137,7 +137,7 @@ def _unpack_confusion_matrix_value(
                 ),
                 "examples": [
                     {
-                        "datum": index_to_uid[
+                        "datum_id": index_to_datum_id[
                             datum_idx(gt_label_idx, pd_label_idx, example_idx)
                         ],
                         "score": score_idx(
@@ -158,8 +158,8 @@ def _unpack_unmatched_ground_truths_value(
     unmatched_ground_truths: NDArray[np.int32],
     number_of_labels: int,
     number_of_examples: int,
-    index_to_uid: dict[int, str],
-    index_to_label: dict[int, str],
+    index_to_datum_id: list[str],
+    index_to_label: list[str],
 ) -> dict[str, dict[str, int | list[dict[str, str]]]]:
     """
     Unpacks a numpy array of unmatched ground truth counts and examples.
@@ -181,7 +181,11 @@ def _unpack_unmatched_ground_truths_value(
                 0,
             ),
             "examples": [
-                {"datum": index_to_uid[datum_idx(gt_label_idx, example_idx)]}
+                {
+                    "datum_id": index_to_datum_id[
+                        datum_idx(gt_label_idx, example_idx)
+                    ]
+                }
                 for example_idx in range(number_of_examples)
                 if datum_idx(gt_label_idx, example_idx) >= 0
             ],
@@ -194,12 +198,12 @@ def unpack_confusion_matrix_into_metric_list(
     results: tuple[NDArray[np.float64], NDArray[np.int32]],
     score_thresholds: list[float],
     number_of_examples: int,
-    index_to_uid: dict[int, str],
-    index_to_label: dict[int, str],
+    index_to_datum_id: list[str],
+    index_to_label: list[str],
 ) -> list[Metric]:
 
     (confusion_matrix, unmatched_ground_truths) = results
-    n_scores, n_labels, _, _ = confusion_matrix.shape
+    _, n_labels, _, _ = confusion_matrix.shape
     return [
         Metric.confusion_matrix(
             score_threshold=score_threshold,
@@ -209,7 +213,7 @@ def unpack_confusion_matrix_into_metric_list(
                 number_of_labels=n_labels,
                 number_of_examples=number_of_examples,
                 index_to_label=index_to_label,
-                index_to_uid=index_to_uid,
+                index_to_datum_id=index_to_datum_id,
             ),
             unmatched_ground_truths=_unpack_unmatched_ground_truths_value(
                 unmatched_ground_truths=unmatched_ground_truths[
@@ -218,7 +222,7 @@ def unpack_confusion_matrix_into_metric_list(
                 number_of_labels=n_labels,
                 number_of_examples=number_of_examples,
                 index_to_label=index_to_label,
-                index_to_uid=index_to_uid,
+                index_to_datum_id=index_to_datum_id,
             ),
         )
         for score_idx, score_threshold in enumerate(score_thresholds)

valor_lite/exceptions.py

@@ -0,0 +1,15 @@
+class EmptyEvaluatorException(Exception):
+    def __init__(self):
+        super().__init__(
+            "evaluator cannot be finalized as it contains no data"
+        )
+
+
+class EmptyFilterException(Exception):
+    def __init__(self, message: str):
+        super().__init__(message)
+
+
+class InternalCacheException(Exception):
+    def __init__(self, message: str):
+        super().__init__(message)

valor_lite/object_detection/__init__.py

@@ -1,5 +1,5 @@
 from .annotation import Bitmask, BoundingBox, Detection, Polygon
-from .manager import DataLoader, Evaluator
+from .manager import DataLoader, Evaluator, Filter
 from .metric import Metric, MetricType
 
 __all__ = [
@@ -11,4 +11,5 @@ __all__ = [
     "MetricType",
     "DataLoader",
     "Evaluator",
+    "Filter",
 ]

valor_lite/object_detection/computation.py

@@ -1,4 +1,3 @@
-import warnings
 from enum import IntFlag, auto
 
 import numpy as np
@@ -221,6 +220,89 @@ def compute_label_metadata(
     return label_metadata
 
 
+def filter_cache(
+    detailed_pairs: NDArray[np.float64],
+    mask_datums: NDArray[np.bool_],
+    mask_predictions: NDArray[np.bool_],
+    mask_ground_truths: NDArray[np.bool_],
+    n_labels: int,
+) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.int32],]:
+    """
+    Performs filtering on a detailed cache.
+
+    Parameters
+    ----------
+    detailed_pairs : NDArray[float64]
+        A list of sorted detailed pairs with size (N, 7).
+    mask_datums : NDArray[bool]
+        A boolean mask with size (N,).
+    mask_ground_truths : NDArray[bool]
+        A boolean mask with size (N,).
+    mask_predictions : NDArray[bool]
+        A boolean mask with size (N,).
+    n_labels : int
+        The total number of unique labels.
+
+    Returns
+    -------
+    NDArray[float64]
+        Filtered detailed pairs.
+    NDArray[float64]
+        Filtered ranked pairs.
+    NDArray[int32]
+        Label metadata.
+    """
+    # filter datums
+    detailed_pairs = detailed_pairs[mask_datums].copy()
+
+    # filter ground truths
+    if mask_ground_truths.any():
+        invalid_groundtruth_indices = np.where(mask_ground_truths)[0]
+        detailed_pairs[
+            invalid_groundtruth_indices[:, None], (1, 3, 5)
+        ] = np.array([[-1, -1, 0]])
+
+    # filter predictions
+    if mask_predictions.any():
+        invalid_prediction_indices = np.where(mask_predictions)[0]
+        detailed_pairs[
+            invalid_prediction_indices[:, None], (2, 4, 5, 6)
+        ] = np.array([[-1, -1, 0, -1]])
+
+    # filter null pairs
+    mask_null_pairs = np.all(
+        np.isclose(
+            detailed_pairs[:, 1:5],
+            np.array([-1.0, -1.0, -1.0, -1.0]),
+        ),
+        axis=1,
+    )
+    detailed_pairs = detailed_pairs[~mask_null_pairs]
+
+    # sorts by score, iou with ground truth id as a tie-breaker
+    indices = np.lexsort(
+        (
+            detailed_pairs[:, 1],  # ground truth id
+            -detailed_pairs[:, 5],  # iou
+            -detailed_pairs[:, 6],  # score
+        )
+    )
+    detailed_pairs = detailed_pairs[indices]
+    label_metadata = compute_label_metadata(
+        ids=detailed_pairs[:, :5].astype(np.int32),
+        n_labels=n_labels,
+    )
+    ranked_pairs = rank_pairs(
+        detailed_pairs=detailed_pairs,
+        label_metadata=label_metadata,
+    )
+    return (
+        detailed_pairs,
+        ranked_pairs,
+        label_metadata,
+    )
+
+
 def rank_pairs(
     detailed_pairs: NDArray[np.float64],
     label_metadata: NDArray[np.int32],
@@ -350,15 +432,6 @@ def compute_precion_recall(
     counts = np.zeros((n_ious, n_scores, n_labels, 6), dtype=np.float64)
     pr_curve = np.zeros((n_ious, n_labels, 101, 2))
 
-    if ranked_pairs.size == 0:
-        warnings.warn("no valid ranked pairs")
-        return (
-            (average_precision, mAP),
-            (average_recall, mAR),
-            counts,
-            pr_curve,
-        )
-
     # start computation
     ids = ranked_pairs[:, :5].astype(np.int32)
     gt_ids = ids[:, 1]