valor-lite 0.33.10__py3-none-any.whl → 0.33.12__py3-none-any.whl

valor_lite/classification/computation.py

@@ -182,9 +182,9 @@ def compute_metrics(
         out=precision,
     )
 
-    accuracy = np.zeros_like(recall)
+    accuracy = np.zeros(n_scores, dtype=np.float64)
     np.divide(
-        (counts[:, :, 0] + counts[:, :, 3]),
+        counts[:, :, 0].sum(axis=1),
         float(n_datums),
         out=accuracy,
     )

valor_lite/classification/manager.py

@@ -367,6 +367,14 @@ class Evaluator:
             )
         ]
 
+        metrics[MetricType.Accuracy] = [
+            Accuracy(
+                value=accuracy.astype(float).tolist(),
+                score_thresholds=score_thresholds,
+                hardmax=hardmax,
+            )
+        ]
+
         for label_idx, label in self.index_to_label.items():
 
             kwargs = {
@@ -401,12 +409,6 @@ class Evaluator:
                     **kwargs,
                 )
             )
-            metrics[MetricType.Accuracy].append(
-                Accuracy(
-                    value=accuracy[:, label_idx].astype(float).tolist(),
-                    **kwargs,
-                )
-            )
             metrics[MetricType.F1].append(
                 F1(
                     value=f1_score[:, label_idx].astype(float).tolist(),

valor_lite/classification/metric.py

@@ -158,24 +158,23 @@ class Recall(_ThresholdValue):
     pass
 
 
-class Accuracy(_ThresholdValue):
+class F1(_ThresholdValue):
     """
-    Accuracy metric for a specific class label.
+    F1 score for a specific class label.
 
-    This class calculates the accuracy at various score thresholds for a binary
-    classification task. Accuracy is defined as the ratio of the sum of true positives and
-    true negatives over all predictions.
+    This class calculates the F1 score at various score thresholds for a binary
+    classification task.
 
     Attributes
     ----------
     value : list[float]
-        Accuracy values computed at each score threshold.
+        F1 scores computed at each score threshold.
     score_thresholds : list[float]
-        Score thresholds at which the accuracy values are computed.
+        Score thresholds at which the F1 scores are computed.
     hardmax : bool
         Indicates whether hardmax thresholding was used.
     label : str
-        The class label for which the accuracy is computed.
+        The class label for which the F1 score is computed.
 
     Methods
     -------
@@ -188,23 +187,21 @@ class Accuracy(_ThresholdValue):
     pass
 
 
-class F1(_ThresholdValue):
+@dataclass
+class Accuracy:
     """
-    F1 score for a specific class label.
+    Multiclass accuracy metric.
 
-    This class calculates the F1 score at various score thresholds for a binary
-    classification task.
+    This class calculates the accuracy at various score thresholds.
 
     Attributes
     ----------
     value : list[float]
-        F1 scores computed at each score threshold.
+        Accuracy values computed at each score threshold.
     score_thresholds : list[float]
-        Score thresholds at which the F1 scores are computed.
+        Score thresholds at which the accuracy values are computed.
     hardmax : bool
         Indicates whether hardmax thresholding was used.
-    label : str
-        The class label for which the F1 score is computed.
 
     Methods
     -------
@@ -214,7 +211,22 @@ class F1(_ThresholdValue):
         Converts the instance to a dictionary representation.
     """
 
-    pass
+    value: list[float]
+    score_thresholds: list[float]
+    hardmax: bool
+
+    def to_metric(self) -> Metric:
+        return Metric(
+            type=type(self).__name__,
+            value=self.value,
+            parameters={
+                "score_thresholds": self.score_thresholds,
+                "hardmax": self.hardmax,
+            },
+        )
+
+    def to_dict(self) -> dict:
+        return self.to_metric().to_dict()
 
 
 @dataclass

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,7 +333,7 @@ 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)
+    pd_labels = data[:, 5].astype(np.int32)
     scores = data[:, 6]
     unique_pd_labels, unique_pd_indices = np.unique(
         pd_labels, return_index=True
@@ -383,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],
@@ -476,7 +478,7 @@ 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))
@@ -582,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,
     )
@@ -593,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],
@@ -666,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
@@ -688,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
@@ -707,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
@@ -736,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-0.33.10.dist-info → valor_lite-0.33.12.dist-info}/METADATA

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

{valor_lite-0.33.10.dist-info → valor_lite-0.33.12.dist-info}/RECORD

@@ -3,12 +3,12 @@ valor_lite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 valor_lite/schemas.py,sha256=r4cC10w1xYsA785KmGE4ePeOX3wzEs846vT7QAiVg_I,293
 valor_lite/classification/__init__.py,sha256=2wmmziIzUATm7MbmAcPNLXrEX5l4oeD7XBwPd9bWM3Q,506
 valor_lite/classification/annotation.py,sha256=0aUOvcwBAZgiNOJuyh-pXyNTG7vP7r8CUfnU3OmpUwQ,1113
-valor_lite/classification/computation.py,sha256=qd9K7CcSGmMm_7shfX47_ZIuB-uE2LLiLMZSS_3NJTk,12093
-valor_lite/classification/manager.py,sha256=7NKk4syQHH5hBEUDWTD0zIFkJSNdOMzJn8a8GzfBnDc,23205
-valor_lite/classification/metric.py,sha256=m9_zD82YGl0QhuMql943YNKg67NZ6bsrR8ggs6_JZms,11728
+valor_lite/classification/computation.py,sha256=pMePRFKCikYiGDgR-ZB8TmrzAts5ZIz4EywCT-XL42g,12100
+valor_lite/classification/manager.py,sha256=fwb5z84SzgJ-ud1kTY3oYbUJLbA7R0cdWqqcaAIUcWs,23222
+valor_lite/classification/metric.py,sha256=JjY9x6Sq1Hr_2agGnyT9EhVI5wXKQcMmEwxIK32yhGw,11903
 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=Z9jhiimYm7j3tYAqYN4yZd6Hm5eQYrHmXBsemAltS5M,27530
+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
@@ -17,8 +17,8 @@ valor_lite/semantic_segmentation/computation.py,sha256=iJkEmTNmw9HwQCxSnpJkQsAdV
 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.10.dist-info/LICENSE,sha256=M0L53VuwfEEqezhHb7NPeYcO_glw7-k4DMLZQ3eRN64,1068
-valor_lite-0.33.10.dist-info/METADATA,sha256=U_O0KL08ks1p4k7yZnX5Z7ItdcCnDxZZ5xgnu7Skhpw,5632
-valor_lite-0.33.10.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-valor_lite-0.33.10.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
-valor_lite-0.33.10.dist-info/RECORD,,
+valor_lite-0.33.12.dist-info/LICENSE,sha256=M0L53VuwfEEqezhHb7NPeYcO_glw7-k4DMLZQ3eRN64,1068
+valor_lite-0.33.12.dist-info/METADATA,sha256=Sak_wCIniTYTNYjNrF8sy-ITbFdG_j_zFUq-jz1PYLk,5632
+valor_lite-0.33.12.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+valor_lite-0.33.12.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
+valor_lite-0.33.12.dist-info/RECORD,,