valor-lite 0.33.9__py3-none-any.whl → 0.33.11__py3-none-any.whl

valor_lite/object_detection/computation.py

@@ -184,7 +184,7 @@ def _compute_ranked_pairs_for_datum(
 
     # find best fits for prediction
     mask_label_match = data[:, 4] == data[:, 5]
-    matched_predicitons = np.unique(data[mask_label_match, 2].astype(int))
+    matched_predicitons = np.unique(data[mask_label_match, 2].astype(np.int32))
     mask_unmatched_predictions = ~np.isin(data[:, 2], matched_predicitons)
     data = data[mask_label_match | mask_unmatched_predictions]
 
@@ -333,8 +333,11 @@ def compute_metrics(
     average_recall = np.zeros((n_scores, n_labels))
     counts = np.zeros((n_ious, n_scores, n_labels, 7))
 
-    pd_labels = data[:, 5].astype(int)
-    unique_pd_labels = np.unique(pd_labels)
+    pd_labels = data[:, 5].astype(np.int32)
+    scores = data[:, 6]
+    unique_pd_labels, unique_pd_indices = np.unique(
+        pd_labels, return_index=True
+    )
     gt_count = label_metadata[:, 0]
     running_total_count = np.zeros(
         (n_ious, n_rows),
@@ -342,7 +345,6 @@ def compute_metrics(
     )
     running_tp_count = np.zeros_like(running_total_count)
     running_gt_count = np.zeros_like(running_total_count)
-    pr_curve = np.zeros((n_ious, n_labels, 101))
 
     mask_score_nonzero = data[:, 6] > 1e-9
     mask_gt_exists = data[:, 1] >= 0.0
@@ -381,17 +383,19 @@ def compute_metrics(
             true_positives_mask[mask_tp_inner] = mask_gt_unique
 
             # calculate intermediates
-            pd_count = np.bincount(pd_labels, minlength=n_labels).astype(float)
+            pd_count = np.bincount(pd_labels, minlength=n_labels).astype(
+                np.float64
+            )
             tp_count = np.bincount(
                 pd_labels,
                 weights=true_positives_mask,
                 minlength=n_labels,
-            ).astype(float)
+            ).astype(np.float64)
 
             fp_count = np.bincount(
                 pd_labels[mask_fp_inner],
                 minlength=n_labels,
-            ).astype(float)
+            ).astype(np.float64)
 
             fn_count = np.bincount(
                 pd_labels[mask_fn_inner],
@@ -474,21 +478,43 @@ def compute_metrics(
         where=running_gt_count > 1e-9,
         out=recall,
     )
-    recall_index = np.floor(recall * 100.0).astype(int)
+    recall_index = np.floor(recall * 100.0).astype(np.int32)
+
+    # bin precision-recall curve
+    pr_curve = np.zeros((n_ious, n_labels, 101, 2))
     for iou_idx in range(n_ious):
         p = precision[iou_idx]
         r = recall_index[iou_idx]
-        pr_curve[iou_idx, pd_labels, r] = np.maximum(
-            pr_curve[iou_idx, pd_labels, r], p
+        pr_curve[iou_idx, pd_labels, r, 0] = np.maximum(
+            pr_curve[iou_idx, pd_labels, r, 0],
+            p,
+        )
+        pr_curve[iou_idx, pd_labels, r, 1] = np.maximum(
+            pr_curve[iou_idx, pd_labels, r, 1],
+            scores,
         )
 
     # calculate average precision
-    running_max = np.zeros((n_ious, n_labels))
+    running_max_precision = np.zeros((n_ious, n_labels))
+    running_max_score = np.zeros((n_labels))
     for recall in range(100, -1, -1):
-        precision = pr_curve[:, :, recall]
-        running_max = np.maximum(precision, running_max)
-        average_precision += running_max
-        pr_curve[:, :, recall] = running_max
+
+        # running max precision
+        running_max_precision = np.maximum(
+            pr_curve[:, :, recall, 0],
+            running_max_precision,
+        )
+        pr_curve[:, :, recall, 0] = running_max_precision
+
+        # running max score
+        running_max_score = np.maximum(
+            pr_curve[:, :, recall, 1],
+            running_max_score,
+        )
+        pr_curve[:, :, recall, 1] = running_max_score
+
+        average_precision += running_max_precision
+
     average_precision = average_precision / 101.0
 
     # calculate average recall
@@ -558,7 +584,7 @@ def _count_with_examples(
         Counts for each unique label index.
     """
     unique_rows, indices = np.unique(
-        data.astype(int)[:, unique_idx],
+        data.astype(np.int32)[:, unique_idx],
         return_index=True,
         axis=0,
     )
@@ -569,6 +595,35 @@ def _count_with_examples(
     return examples, labels, counts
 
 
+def _isin(
+    data: NDArray[np.int32],
+    subset: NDArray[np.int32],
+) -> NDArray[np.bool_]:
+    """
+    Creates a mask of rows that exist within the subset.
+
+    Parameters
+    ----------
+    data : NDArray[np.int32]
+        An array with shape (N, 2).
+    subset : NDArray[np.int32]
+        An array with shape (M, 2) where N >= M.
+
+    Returns
+    -------
+    NDArray[np.bool_]
+        Returns a bool mask with shape (N,).
+    """
+    combined_data = (data[:, 0].astype(np.int64) << 32) | data[:, 1].astype(
+        np.uint32
+    )
+    combined_subset = (subset[:, 0].astype(np.int64) << 32) | subset[
+        :, 1
+    ].astype(np.uint32)
+    mask = np.isin(combined_data, combined_subset, assume_unique=False)
+    return mask
+
+
 def compute_confusion_matrix(
     data: NDArray[np.float64],
     label_metadata: NDArray[np.int32],
@@ -642,20 +697,16 @@ def compute_confusion_matrix(
     mask_gt_pd_match = mask_gt_pd_exists & mask_label_match
     mask_gt_pd_mismatch = mask_gt_pd_exists & ~mask_label_match
 
-    groundtruths = data[:, [0, 1]].astype(int)
-    predictions = data[:, [0, 2]].astype(int)
+    groundtruths = data[:, [0, 1]].astype(np.int32)
+    predictions = data[:, [0, 2]].astype(np.int32)
     for iou_idx in range(n_ious):
         mask_iou_threshold = data[:, 3] >= iou_thresholds[iou_idx]
         mask_iou = mask_iou_nonzero & mask_iou_threshold
 
         groundtruths_passing_ious = np.unique(groundtruths[mask_iou], axis=0)
-        mask_groundtruths_with_passing_ious = (
-            (
-                groundtruths.reshape(-1, 1, 2)
-                == groundtruths_passing_ious.reshape(1, -1, 2)
-            )
-            .all(axis=2)
-            .any(axis=1)
+        mask_groundtruths_with_passing_ious = _isin(
+            data=groundtruths,
+            subset=groundtruths_passing_ious,
         )
         mask_groundtruths_without_passing_ious = (
             ~mask_groundtruths_with_passing_ious & mask_gt_exists
@@ -664,13 +715,9 @@ def compute_confusion_matrix(
         predictions_with_passing_ious = np.unique(
             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)
-            .any(axis=1)
+        mask_predictions_with_passing_ious = _isin(
+            data=predictions,
+            subset=predictions_with_passing_ious,
         )
         mask_predictions_without_passing_ious = (
             ~mask_predictions_with_passing_ious & mask_pd_exists
@@ -683,13 +730,9 @@ def compute_confusion_matrix(
             groundtruths_with_passing_score = np.unique(
                 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)
-                .any(axis=1)
+            mask_groundtruths_with_passing_score = _isin(
+                data=groundtruths,
+                subset=groundtruths_with_passing_score,
             )
             mask_groundtruths_without_passing_score = (
                 ~mask_groundtruths_with_passing_score & mask_gt_exists
@@ -712,21 +755,13 @@ def compute_confusion_matrix(
             )
 
             # filter out true-positives from misclf and misprd
-            mask_gts_with_tp_override = (
-                (
-                    data[mask_misclf][:, [0, 1]].reshape(-1, 1, 2)
-                    == data[mask_tp][:, [0, 1]].reshape(1, -1, 2)
-                )
-                .all(axis=2)
-                .any(axis=1)
+            mask_gts_with_tp_override = _isin(
+                data=groundtruths[mask_misclf],
+                subset=groundtruths[mask_tp],
             )
-            mask_pds_with_tp_override = (
-                (
-                    data[mask_misclf][:, [0, 2]].reshape(-1, 1, 2)
-                    == data[mask_tp][:, [0, 2]].reshape(1, -1, 2)
-                )
-                .all(axis=2)
-                .any(axis=1)
+            mask_pds_with_tp_override = _isin(
+                data=predictions[mask_misclf],
+                subset=predictions[mask_tp],
             )
             mask_misprd[mask_misclf] |= (
                 ~mask_gts_with_tp_override & mask_pds_with_tp_override

valor_lite/object_detection/manager.py

@@ -595,7 +595,12 @@ class Evaluator:
 
         metrics[MetricType.PrecisionRecallCurve] = [
             PrecisionRecallCurve(
-                precision=pr_curves[iou_idx][label_idx].astype(float).tolist(),
+                precisions=pr_curves[iou_idx, label_idx, :, 0]
+                .astype(float)
+                .tolist(),
+                scores=pr_curves[iou_idx, label_idx, :, 1]
+                .astype(float)
+                .tolist(),
                 iou_threshold=iou_threshold,
                 label=label,
             )

valor_lite/object_detection/metric.py

@@ -591,8 +591,10 @@ class PrecisionRecallCurve:
 
     Attributes
     ----------
-    precision : list[float]
+    precisions : list[float]
         Interpolated precision values corresponding to recalls at 0.0, 0.01, ..., 1.0.
+    scores : list[float]
+        Maximum prediction score for each point on the interpolated curve.
     iou_threshold : float
         The Intersection over Union (IoU) threshold used to determine true positives.
     label : str
@@ -606,14 +608,18 @@ class PrecisionRecallCurve:
         Converts the instance to a dictionary representation.
     """
 
-    precision: list[float]
+    precisions: list[float]
+    scores: list[float]
     iou_threshold: float
     label: str
 
     def to_metric(self) -> Metric:
         return Metric(
             type=type(self).__name__,
-            value=self.precision,
+            value={
+                "precisions": self.precisions,
+                "scores": self.scores,
+            },
             parameters={
                 "iou_threshold": self.iou_threshold,
                 "label": self.label,

{valor_lite-0.33.9.dist-info → valor_lite-0.33.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: valor-lite
-Version: 0.33.9
+Version: 0.33.11
 Summary: Compute valor metrics locally.
 License: MIT License
         

{valor_lite-0.33.9.dist-info → valor_lite-0.33.11.dist-info}/RECORD

@@ -8,17 +8,17 @@ valor_lite/classification/manager.py,sha256=7NKk4syQHH5hBEUDWTD0zIFkJSNdOMzJn8a8
 valor_lite/classification/metric.py,sha256=m9_zD82YGl0QhuMql943YNKg67NZ6bsrR8ggs6_JZms,11728
 valor_lite/object_detection/__init__.py,sha256=PiKfemo8FkZRzBhPSjhil8ahGURLy0Vk_iV25CB4UBU,1139
 valor_lite/object_detection/annotation.py,sha256=o6VfiRobiB0ljqsNBLAYMXgi32RSIR7uTA-dgxq6zBI,8248
-valor_lite/object_detection/computation.py,sha256=7rOfVlYDadXcJ1_S0FJRF3IPigcsR7guk_0rXeIdAOE,26919
-valor_lite/object_detection/manager.py,sha256=k8VRqmlfWGKj1IuijbG49jXkMelE8v59pTQTCwkSMKk,38833
-valor_lite/object_detection/metric.py,sha256=nWSqIQSBQrpl3Stz_xe2-AYoo2nrATeMuFVFmREjSNA,23833
+valor_lite/object_detection/computation.py,sha256=ZW83XT-aemRg-5ZdISmrj0bRD9wWmYCU3gkSlfXlNZc,27747
+valor_lite/object_detection/manager.py,sha256=vb4JpynNF0JcnFwNmReFjls9UGAquigN2hpEbG89J04,38991
+valor_lite/object_detection/metric.py,sha256=tHRVnpBqw_w1VwnNkTCmu1yv7Max9FRlf5uh0wYew4s,24046
 valor_lite/semantic_segmentation/__init__.py,sha256=IdarTHKUuUMDvMBmInQu12Mm_NMCbql6Hf0nL5b56Ak,424
 valor_lite/semantic_segmentation/annotation.py,sha256=CujYFdHS3fgr4Y7mEDs_u1XBmbPJzNU2CdqvjCT_d_A,2938
 valor_lite/semantic_segmentation/computation.py,sha256=iJkEmTNmw9HwQCxSnpJkQsAdVcFriGhhu_WMks6D7tU,5122
 valor_lite/semantic_segmentation/manager.py,sha256=aJk6edWZWKqrzl6hVmEUSZVYhHLuyihxWgAIXsCXkZ0,17361
 valor_lite/semantic_segmentation/metric.py,sha256=Y8M3z92SaABEe9TwBUN37TFsh9DR5WoIxO-TfXVwz8I,6289
 valor_lite/text_generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valor_lite-0.33.9.dist-info/LICENSE,sha256=M0L53VuwfEEqezhHb7NPeYcO_glw7-k4DMLZQ3eRN64,1068
-valor_lite-0.33.9.dist-info/METADATA,sha256=dXS7Nt_WHKBaIARWZ3Ek27i26-pWyatewb3eFEnYor8,5631
-valor_lite-0.33.9.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-valor_lite-0.33.9.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
-valor_lite-0.33.9.dist-info/RECORD,,
+valor_lite-0.33.11.dist-info/LICENSE,sha256=M0L53VuwfEEqezhHb7NPeYcO_glw7-k4DMLZQ3eRN64,1068
+valor_lite-0.33.11.dist-info/METADATA,sha256=QniFV86iMnaqPtJElufV4tkF3-kI1sS6EXKRzupWavc,5632
+valor_lite-0.33.11.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+valor_lite-0.33.11.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
+valor_lite-0.33.11.dist-info/RECORD,,