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

valor_lite/{detection → object_detection}/manager.py

@@ -1,17 +1,18 @@
 from collections import defaultdict
 from dataclasses import dataclass
+from typing import Type
 
 import numpy as np
+import valor_lite.object_detection.annotation as annotation
 from numpy.typing import NDArray
-from shapely.geometry import Polygon as ShapelyPolygon
 from tqdm import tqdm
-from valor_lite.detection.annotation import (
+from valor_lite.object_detection.annotation import (
     Bitmask,
     BoundingBox,
     Detection,
     Polygon,
 )
-from valor_lite.detection.computation import (
+from valor_lite.object_detection.computation import (
     compute_bbox_iou,
     compute_bitmask_iou,
     compute_confusion_matrix,
@@ -19,7 +20,7 @@ from valor_lite.detection.computation import (
     compute_polygon_iou,
     compute_ranked_pairs,
 )
-from valor_lite.detection.metric import (
+from valor_lite.object_detection.metric import (
     AP,
     AR,
     F1,
@@ -59,103 +60,6 @@ filtered_metrics = evaluator.evaluate(iou_thresholds=[0.5], filter_mask=filter_m
 """
 
 
-def _get_valor_dict_annotation_key(
-    annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask],
-) -> str:
-    """Get the correct JSON key to extract a given annotation type."""
-
-    if issubclass(annotation_type, BoundingBox):
-        return "bounding_box"
-    if issubclass(annotation_type, Polygon):
-        return "polygon"
-    else:
-        return "raster"
-
-
-def _get_annotation_representation(
-    annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask],
-) -> str:
-    """Get the correct representation of an annotation object."""
-
-    representation = (
-        "extrema"
-        if issubclass(annotation_type, BoundingBox)
-        else ("mask" if issubclass(annotation_type, Bitmask) else "shape")
-    )
-
-    return representation
-
-
-def _get_annotation_representation_from_valor_dict(
-    data: list,
-    annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask],
-) -> tuple[float, float, float, float] | ShapelyPolygon | NDArray[np.bool_]:
-    """Get the correct representation of an annotation object from a valor dictionary."""
-
-    if issubclass(annotation_type, BoundingBox):
-        x = [point[0] for shape in data for point in shape]
-        y = [point[1] for shape in data for point in shape]
-        return (min(x), max(x), min(y), max(y))
-    if issubclass(annotation_type, Polygon):
-        return ShapelyPolygon(data)
-    else:
-        return np.array(data)
-
-
-def _get_annotation_data(
-    keyed_groundtruths: dict,
-    keyed_predictions: dict,
-    annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask] | None,
-    key=int,
-) -> np.ndarray:
-    """Create an array of annotation pairs for use when calculating IOU. Needed because we unpack bounding box representations, but not bitmask or polygon representations."""
-    if annotation_type == BoundingBox:
-        return np.array(
-            [
-                np.array([*gextrema, *pextrema])
-                for _, _, _, pextrema in keyed_predictions[key]
-                for _, _, gextrema in keyed_groundtruths[key]
-            ]
-        )
-    else:
-        return np.array(
-            [
-                np.array([groundtruth_obj, prediction_obj])
-                for _, _, _, prediction_obj in keyed_predictions[key]
-                for _, _, groundtruth_obj in keyed_groundtruths[key]
-            ]
-        )
-
-
-def compute_iou(
-    data: NDArray[np.floating],
-    annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask],
-) -> NDArray[np.floating]:
-    """
-    Computes intersection-over-union (IoU) calculations for various annotation types.
-
-    Parameters
-    ----------
-    data : NDArray[np.floating]
-        A sorted array of bounding box, bitmask, or polygon pairs.
-    annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask]
-        The type of annotation contained in the data.
-
-
-    Returns
-    -------
-    NDArray[np.floating]
-        Computed IoU's.
-    """
-
-    if annotation_type == BoundingBox:
-        return compute_bbox_iou(data=data)
-    elif annotation_type == Bitmask:
-        return compute_bitmask_iou(data=data)
-    else:
-        return compute_polygon_iou(data=data)
-
-
 @dataclass
 class Filter:
     ranked_indices: NDArray[np.int32]
@@ -185,22 +89,17 @@ class Evaluator:
         self.prediction_examples: dict[int, NDArray[np.float16]] = dict()
 
         # label reference
-        self.label_to_index: dict[tuple[str, str], int] = dict()
-        self.index_to_label: dict[int, tuple[str, str]] = dict()
-
-        # label key reference
-        self.index_to_label_key: dict[int, str] = dict()
-        self.label_key_to_index: dict[str, int] = dict()
-        self.label_index_to_label_key_index: dict[int, int] = dict()
+        self.label_to_index: dict[str, int] = dict()
+        self.index_to_label: dict[int, str] = dict()
 
         # computation caches
-        self._detailed_pairs: NDArray[np.floating] = np.array([])
-        self._ranked_pairs: NDArray[np.floating] = np.array([])
+        self._detailed_pairs: NDArray[np.float64] = np.array([])
+        self._ranked_pairs: NDArray[np.float64] = np.array([])
         self._label_metadata: NDArray[np.int32] = np.array([])
         self._label_metadata_per_datum: NDArray[np.int32] = np.array([])
 
     @property
-    def ignored_prediction_labels(self) -> list[tuple[str, str]]:
+    def ignored_prediction_labels(self) -> list[str]:
         """
         Prediction labels that are not present in the ground truth set.
         """
@@ -211,7 +110,7 @@ class Evaluator:
         ]
 
     @property
-    def missing_prediction_labels(self) -> list[tuple[str, str]]:
+    def missing_prediction_labels(self) -> list[str]:
         """
         Ground truth labels that are not present in the prediction set.
         """
@@ -238,8 +137,7 @@ class Evaluator:
     def create_filter(
         self,
         datum_uids: list[str] | NDArray[np.int32] | None = None,
-        labels: list[tuple[str, str]] | NDArray[np.int32] | None = None,
-        label_keys: list[str] | NDArray[np.int32] | None = None,
+        labels: list[str] | NDArray[np.int32] | None = None,
     ) -> Filter:
         """
         Creates a filter that can be passed to an evaluation.
@@ -248,10 +146,8 @@ class Evaluator:
         ----------
         datum_uids : list[str] | NDArray[np.int32], optional
             An optional list of string uids or a numpy array of uid indices.
-        labels : list[tuple[str, str]] | NDArray[np.int32], optional
+        labels : list[str] | NDArray[np.int32], optional
             An optional list of labels or a numpy array of label indices.
-        label_keys : list[str] | NDArray[np.int32], optional
-            An optional list of label keys or a numpy array of label key indices.
 
         Returns
         -------
@@ -296,24 +192,6 @@ class Evaluator:
             ] = False
             mask_labels[~np.isin(np.arange(n_labels), labels)] = False
 
-        if label_keys is not None:
-            if isinstance(label_keys, list):
-                label_keys = np.array(
-                    [self.label_key_to_index[key] for key in label_keys]
-                )
-            label_indices = (
-                np.where(np.isclose(self._label_metadata[:, 2], label_keys))[0]
-                if label_keys.size > 0
-                else np.array([])
-            )
-            mask_ranked[
-                ~np.isin(self._ranked_pairs[:, 4].astype(int), label_indices)
-            ] = False
-            mask_detailed[
-                ~np.isin(self._detailed_pairs[:, 4].astype(int), label_indices)
-            ] = False
-            mask_labels[~np.isin(np.arange(n_labels), label_indices)] = False
-
         mask_label_metadata = (
             mask_datums[:, np.newaxis] & mask_labels[np.newaxis, :]
         )
@@ -321,13 +199,12 @@ class Evaluator:
         label_metadata_per_datum[:, ~mask_label_metadata] = 0
 
         label_metadata = np.zeros_like(self._label_metadata, dtype=np.int32)
-        label_metadata[:, :2] = np.transpose(
+        label_metadata = np.transpose(
             np.sum(
                 label_metadata_per_datum,
                 axis=1,
             )
         )
-        label_metadata[:, 2] = self._label_metadata[:, 2]
 
         return Filter(
             ranked_indices=np.where(mask_ranked)[0],
@@ -335,245 +212,22 @@ class Evaluator:
             label_metadata=label_metadata,
         )
 
-    def evaluate(
-        self,
-        metrics_to_return: list[MetricType] = MetricType.base_metrics(),
-        iou_thresholds: list[float] = [0.5, 0.75, 0.9],
-        score_thresholds: list[float] = [0.5],
-        number_of_examples: int = 0,
-        filter_: Filter | None = None,
-        as_dict: bool = False,
-    ) -> dict[MetricType, list]:
+    def _convert_example_to_dict(
+        self, box: NDArray[np.float16]
+    ) -> dict[str, float]:
         """
-        Performs an evaluation and returns metrics.
-
-        Parameters
-        ----------
-        metrics_to_return : list[MetricType]
-            A list of metrics to return in the results.
-        iou_thresholds : list[float]
-            A list of IoU thresholds to compute metrics over.
-        score_thresholds : list[float]
-            A list of score thresholds to compute metrics over.
-        number_of_examples : int, default=0
-            Maximum number of annotation examples to return in ConfusionMatrix.
-        filter_ : Filter, optional
-            An optional filter object.
-        as_dict : bool, default=False
-            An option to return metrics as dictionaries.
-
-        Returns
-        -------
-        dict[MetricType, list]
-            A dictionary mapping MetricType enumerations to lists of computed metrics.
+        Converts a cached bounding box example to dictionary format.
         """
-
-        ranked_pairs = self._ranked_pairs
-        detailed_pairs = self._detailed_pairs
-        label_metadata = self._label_metadata
-        if filter_ is not None:
-            ranked_pairs = ranked_pairs[filter_.ranked_indices]
-            detailed_pairs = detailed_pairs[filter_.detailed_indices]
-            label_metadata = filter_.label_metadata
-
-        (
-            (
-                average_precision,
-                mean_average_precision,
-                average_precision_average_over_ious,
-                mean_average_precision_average_over_ious,
-            ),
-            (
-                average_recall,
-                mean_average_recall,
-                average_recall_averaged_over_scores,
-                mean_average_recall_averaged_over_scores,
-            ),
-            precision_recall,
-            pr_curves,
-        ) = compute_metrics(
-            data=ranked_pairs,
-            label_metadata=label_metadata,
-            iou_thresholds=np.array(iou_thresholds),
-            score_thresholds=np.array(score_thresholds),
-        )
-
-        metrics = defaultdict(list)
-
-        metrics[MetricType.AP] = [
-            AP(
-                value=average_precision[iou_idx][label_idx],
-                iou_threshold=iou_thresholds[iou_idx],
-                label=self.index_to_label[label_idx],
-            )
-            for iou_idx in range(average_precision.shape[0])
-            for label_idx in range(average_precision.shape[1])
-            if int(label_metadata[label_idx, 0]) > 0
-        ]
-
-        metrics[MetricType.mAP] = [
-            mAP(
-                value=mean_average_precision[iou_idx][label_key_idx],
-                iou_threshold=iou_thresholds[iou_idx],
-                label_key=self.index_to_label_key[label_key_idx],
-            )
-            for iou_idx in range(mean_average_precision.shape[0])
-            for label_key_idx in range(mean_average_precision.shape[1])
-        ]
-
-        metrics[MetricType.APAveragedOverIOUs] = [
-            APAveragedOverIOUs(
-                value=average_precision_average_over_ious[label_idx],
-                iou_thresholds=iou_thresholds,
-                label=self.index_to_label[label_idx],
-            )
-            for label_idx in range(self.n_labels)
-            if int(label_metadata[label_idx, 0]) > 0
-        ]
-
-        metrics[MetricType.mAPAveragedOverIOUs] = [
-            mAPAveragedOverIOUs(
-                value=mean_average_precision_average_over_ious[label_key_idx],
-                iou_thresholds=iou_thresholds,
-                label_key=self.index_to_label_key[label_key_idx],
-            )
-            for label_key_idx in range(
-                mean_average_precision_average_over_ious.shape[0]
-            )
-        ]
-
-        metrics[MetricType.AR] = [
-            AR(
-                value=average_recall[score_idx][label_idx],
-                iou_thresholds=iou_thresholds,
-                score_threshold=score_thresholds[score_idx],
-                label=self.index_to_label[label_idx],
-            )
-            for score_idx in range(average_recall.shape[0])
-            for label_idx in range(average_recall.shape[1])
-            if int(label_metadata[label_idx, 0]) > 0
-        ]
-
-        metrics[MetricType.mAR] = [
-            mAR(
-                value=mean_average_recall[score_idx][label_key_idx],
-                iou_thresholds=iou_thresholds,
-                score_threshold=score_thresholds[score_idx],
-                label_key=self.index_to_label_key[label_key_idx],
-            )
-            for score_idx in range(mean_average_recall.shape[0])
-            for label_key_idx in range(mean_average_recall.shape[1])
-        ]
-
-        metrics[MetricType.ARAveragedOverScores] = [
-            ARAveragedOverScores(
-                value=average_recall_averaged_over_scores[label_idx],
-                score_thresholds=score_thresholds,
-                iou_thresholds=iou_thresholds,
-                label=self.index_to_label[label_idx],
-            )
-            for label_idx in range(self.n_labels)
-            if int(label_metadata[label_idx, 0]) > 0
-        ]
-
-        metrics[MetricType.mARAveragedOverScores] = [
-            mARAveragedOverScores(
-                value=mean_average_recall_averaged_over_scores[label_key_idx],
-                score_thresholds=score_thresholds,
-                iou_thresholds=iou_thresholds,
-                label_key=self.index_to_label_key[label_key_idx],
-            )
-            for label_key_idx in range(
-                mean_average_recall_averaged_over_scores.shape[0]
-            )
-        ]
-
-        metrics[MetricType.PrecisionRecallCurve] = [
-            PrecisionRecallCurve(
-                precision=list(pr_curves[iou_idx][label_idx]),
-                iou_threshold=iou_threshold,
-                label=label,
-            )
-            for iou_idx, iou_threshold in enumerate(iou_thresholds)
-            for label_idx, label in self.index_to_label.items()
-            if int(label_metadata[label_idx, 0]) > 0
-        ]
-
-        for label_idx, label in self.index_to_label.items():
-
-            if label_metadata[label_idx, 0] == 0:
-                continue
-
-            for score_idx, score_threshold in enumerate(score_thresholds):
-                for iou_idx, iou_threshold in enumerate(iou_thresholds):
-
-                    row = precision_recall[iou_idx][score_idx][label_idx]
-                    kwargs = {
-                        "label": label,
-                        "iou_threshold": iou_threshold,
-                        "score_threshold": score_threshold,
-                    }
-                    metrics[MetricType.Counts].append(
-                        Counts(
-                            tp=int(row[0]),
-                            fp=int(row[1]),
-                            fn=int(row[2]),
-                            **kwargs,
-                        )
-                    )
-
-                    metrics[MetricType.Precision].append(
-                        Precision(
-                            value=row[3],
-                            **kwargs,
-                        )
-                    )
-                    metrics[MetricType.Recall].append(
-                        Recall(
-                            value=row[4],
-                            **kwargs,
-                        )
-                    )
-                    metrics[MetricType.F1].append(
-                        F1(
-                            value=row[5],
-                            **kwargs,
-                        )
-                    )
-                    metrics[MetricType.Accuracy].append(
-                        Accuracy(
-                            value=row[6],
-                            **kwargs,
-                        )
-                    )
-
-        if MetricType.ConfusionMatrix in metrics_to_return:
-            metrics[
-                MetricType.ConfusionMatrix
-            ] = self._compute_confusion_matrix(
-                data=detailed_pairs,
-                label_metadata=label_metadata,
-                iou_thresholds=iou_thresholds,
-                score_thresholds=score_thresholds,
-                number_of_examples=number_of_examples,
-            )
-
-        for metric in set(metrics.keys()):
-            if metric not in metrics_to_return:
-                del metrics[metric]
-
-        if as_dict:
-            return {
-                mtype: [metric.to_dict() for metric in mvalues]
-                for mtype, mvalues in metrics.items()
-            }
-
-        return metrics
+        return {
+            "xmin": float(box[0]),
+            "xmax": float(box[1]),
+            "ymin": float(box[2]),
+            "ymax": float(box[3]),
+        }
 
     def _unpack_confusion_matrix(
         self,
-        confusion_matrix: NDArray[np.floating],
-        label_key_idx: int,
+        confusion_matrix: NDArray[np.float64],
         number_of_labels: int,
         number_of_examples: int,
     ) -> dict[
@@ -586,7 +240,7 @@ class Evaluator:
                 | list[
                     dict[
                         str,
-                        str | float | tuple[float, float, float, float],
+                        str | dict[str, float] | float,
                     ]
                 ],
             ],
@@ -629,8 +283,8 @@ class Evaluator:
         )
 
         return {
-            self.index_to_label[gt_label_idx][1]: {
-                self.index_to_label[pd_label_idx][1]: {
+            self.index_to_label[gt_label_idx]: {
+                self.index_to_label[pd_label_idx]: {
                     "count": max(
                         int(confusion_matrix[gt_label_idx, pd_label_idx, 0]),
                         0,
@@ -642,7 +296,7 @@ class Evaluator:
                                     gt_label_idx, pd_label_idx, example_idx
                                 )
                             ],
-                            "groundtruth": tuple(
+                            "groundtruth": self._convert_example_to_dict(
                                 self.groundtruth_examples[
                                     datum_idx(
                                         gt_label_idx,
@@ -655,9 +309,9 @@ class Evaluator:
                                         pd_label_idx,
                                         example_idx,
                                     )
-                                ].tolist()
+                                ]
                             ),
-                            "prediction": tuple(
+                            "prediction": self._convert_example_to_dict(
                                 self.prediction_examples[
                                     datum_idx(
                                         gt_label_idx,
@@ -670,7 +324,7 @@ class Evaluator:
                                         pd_label_idx,
                                         example_idx,
                                     )
-                                ].tolist()
+                                ]
                             ),
                             "score": score_idx(
                                 gt_label_idx, pd_label_idx, example_idx
@@ -682,30 +336,20 @@ class Evaluator:
                     ],
                 }
                 for pd_label_idx in range(number_of_labels)
-                if (
-                    self.label_index_to_label_key_index[pd_label_idx]
-                    == label_key_idx
-                )
             }
             for gt_label_idx in range(number_of_labels)
-            if (
-                self.label_index_to_label_key_index[gt_label_idx]
-                == label_key_idx
-            )
         }
 
     def _unpack_hallucinations(
         self,
-        hallucinations: NDArray[np.floating],
-        label_key_idx: int,
+        hallucinations: NDArray[np.float64],
         number_of_labels: int,
         number_of_examples: int,
     ) -> dict[
         str,
         dict[
             str,
-            int
-            | list[dict[str, str | float | tuple[float, float, float, float]]],
+            int | list[dict[str, str | float | dict[str, float]]],
         ],
     ]:
         """
@@ -740,7 +384,7 @@ class Evaluator:
         )
 
         return {
-            self.index_to_label[pd_label_idx][1]: {
+            self.index_to_label[pd_label_idx]: {
                 "count": max(
                     int(hallucinations[pd_label_idx, 0]),
                     0,
@@ -750,12 +394,10 @@ class Evaluator:
                         "datum": self.index_to_uid[
                             datum_idx(pd_label_idx, example_idx)
                         ],
-                        "prediction": tuple(
+                        "prediction": self._convert_example_to_dict(
                             self.prediction_examples[
                                 datum_idx(pd_label_idx, example_idx)
-                            ][
-                                prediction_idx(pd_label_idx, example_idx)
-                            ].tolist()
+                            ][prediction_idx(pd_label_idx, example_idx)]
                         ),
                         "score": score_idx(pd_label_idx, example_idx),
                     }
@@ -764,25 +406,14 @@ class Evaluator:
                 ],
             }
             for pd_label_idx in range(number_of_labels)
-            if (
-                self.label_index_to_label_key_index[pd_label_idx]
-                == label_key_idx
-            )
         }
 
     def _unpack_missing_predictions(
         self,
         missing_predictions: NDArray[np.int32],
-        label_key_idx: int,
         number_of_labels: int,
         number_of_examples: int,
-    ) -> dict[
-        str,
-        dict[
-            str,
-            int | list[dict[str, str | tuple[float, float, float, float]]],
-        ],
-    ]:
+    ) -> dict[str, dict[str, int | list[dict[str, str | dict[str, float]]]]]:
         """
         Unpacks a numpy array of missing prediction counts and examples.
         """
@@ -806,7 +437,7 @@ class Evaluator:
         )
 
         return {
-            self.index_to_label[gt_label_idx][1]: {
+            self.index_to_label[gt_label_idx]: {
                 "count": max(
                     int(missing_predictions[gt_label_idx, 0]),
                     0,
@@ -816,12 +447,10 @@ class Evaluator:
                         "datum": self.index_to_uid[
                             datum_idx(gt_label_idx, example_idx)
                         ],
-                        "groundtruth": tuple(
+                        "groundtruth": self._convert_example_to_dict(
                             self.groundtruth_examples[
                                 datum_idx(gt_label_idx, example_idx)
-                            ][
-                                groundtruth_idx(gt_label_idx, example_idx)
-                            ].tolist()
+                            ][groundtruth_idx(gt_label_idx, example_idx)]
                         ),
                     }
                     for example_idx in range(number_of_examples)
@@ -829,51 +458,253 @@ class Evaluator:
                 ],
             }
             for gt_label_idx in range(number_of_labels)
-            if (
-                self.label_index_to_label_key_index[gt_label_idx]
-                == label_key_idx
-            )
         }
 
-    def _compute_confusion_matrix(
+    def compute_precision_recall(
         self,
-        data: NDArray[np.floating],
-        label_metadata: NDArray[np.int32],
-        iou_thresholds: list[float],
-        score_thresholds: list[float],
-        number_of_examples: int,
-    ) -> list[ConfusionMatrix]:
+        iou_thresholds: list[float] = [0.5, 0.75, 0.9],
+        score_thresholds: list[float] = [0.5],
+        filter_: Filter | None = None,
+        as_dict: bool = False,
+    ) -> dict[MetricType, list]:
         """
-        Computes detailed counting metrics.
+        Computes all metrics except for ConfusionMatrix
 
         Parameters
         ----------
-        data : NDArray[np.floating]
-            An array containing detailed pairs of detections.
-        label_metadata : NDArray[np.int32]
-            An array containing label metadata.
         iou_thresholds : list[float]
-            List of IoU thresholds to compute metrics for.
+            A list of IoU thresholds to compute metrics over.
         score_thresholds : list[float]
-            List of confidence thresholds to compute metrics for.
-        number_of_examples : int
-            Maximum number of annotation examples to return per metric.
+            A list of score thresholds to compute metrics over.
+        filter_ : Filter, optional
+            An optional filter object.
+        as_dict : bool, default=False
+            An option to return metrics as dictionaries.
 
         Returns
         -------
-        list[list[ConfusionMatrix]]
-            Outer list is indexed by label, inner list is by IoU.
+        dict[MetricType, list]
+            A dictionary mapping MetricType enumerations to lists of computed metrics.
         """
 
-        if data.size == 0:
-            return list()
+        ranked_pairs = self._ranked_pairs
+        label_metadata = self._label_metadata
+        if filter_ is not None:
+            ranked_pairs = ranked_pairs[filter_.ranked_indices]
+            label_metadata = filter_.label_metadata
 
         (
-            confusion_matrix,
-            hallucinations,
-            missing_predictions,
-        ) = compute_confusion_matrix(
-            data=data,
+            (
+                average_precision,
+                mean_average_precision,
+                average_precision_average_over_ious,
+                mean_average_precision_average_over_ious,
+            ),
+            (
+                average_recall,
+                mean_average_recall,
+                average_recall_averaged_over_scores,
+                mean_average_recall_averaged_over_scores,
+            ),
+            precision_recall,
+            pr_curves,
+        ) = compute_metrics(
+            data=ranked_pairs,
+            label_metadata=label_metadata,
+            iou_thresholds=np.array(iou_thresholds),
+            score_thresholds=np.array(score_thresholds),
+        )
+
+        metrics = defaultdict(list)
+
+        metrics[MetricType.AP] = [
+            AP(
+                value=float(average_precision[iou_idx][label_idx]),
+                iou_threshold=iou_thresholds[iou_idx],
+                label=self.index_to_label[label_idx],
+            )
+            for iou_idx in range(average_precision.shape[0])
+            for label_idx in range(average_precision.shape[1])
+            if int(label_metadata[label_idx, 0]) > 0
+        ]
+
+        metrics[MetricType.mAP] = [
+            mAP(
+                value=float(mean_average_precision[iou_idx]),
+                iou_threshold=iou_thresholds[iou_idx],
+            )
+            for iou_idx in range(mean_average_precision.shape[0])
+        ]
+
+        metrics[MetricType.APAveragedOverIOUs] = [
+            APAveragedOverIOUs(
+                value=float(average_precision_average_over_ious[label_idx]),
+                iou_thresholds=iou_thresholds,
+                label=self.index_to_label[label_idx],
+            )
+            for label_idx in range(self.n_labels)
+            if int(label_metadata[label_idx, 0]) > 0
+        ]
+
+        metrics[MetricType.mAPAveragedOverIOUs] = [
+            mAPAveragedOverIOUs(
+                value=float(mean_average_precision_average_over_ious),
+                iou_thresholds=iou_thresholds,
+            )
+        ]
+
+        metrics[MetricType.AR] = [
+            AR(
+                value=float(average_recall[score_idx][label_idx]),
+                iou_thresholds=iou_thresholds,
+                score_threshold=score_thresholds[score_idx],
+                label=self.index_to_label[label_idx],
+            )
+            for score_idx in range(average_recall.shape[0])
+            for label_idx in range(average_recall.shape[1])
+            if int(label_metadata[label_idx, 0]) > 0
+        ]
+
+        metrics[MetricType.mAR] = [
+            mAR(
+                value=float(mean_average_recall[score_idx]),
+                iou_thresholds=iou_thresholds,
+                score_threshold=score_thresholds[score_idx],
+            )
+            for score_idx in range(mean_average_recall.shape[0])
+        ]
+
+        metrics[MetricType.ARAveragedOverScores] = [
+            ARAveragedOverScores(
+                value=float(average_recall_averaged_over_scores[label_idx]),
+                score_thresholds=score_thresholds,
+                iou_thresholds=iou_thresholds,
+                label=self.index_to_label[label_idx],
+            )
+            for label_idx in range(self.n_labels)
+            if int(label_metadata[label_idx, 0]) > 0
+        ]
+
+        metrics[MetricType.mARAveragedOverScores] = [
+            mARAveragedOverScores(
+                value=float(mean_average_recall_averaged_over_scores),
+                score_thresholds=score_thresholds,
+                iou_thresholds=iou_thresholds,
+            )
+        ]
+
+        metrics[MetricType.PrecisionRecallCurve] = [
+            PrecisionRecallCurve(
+                precision=pr_curves[iou_idx][label_idx].astype(float).tolist(),
+                iou_threshold=iou_threshold,
+                label=label,
+            )
+            for iou_idx, iou_threshold in enumerate(iou_thresholds)
+            for label_idx, label in self.index_to_label.items()
+            if int(label_metadata[label_idx, 0]) > 0
+        ]
+
+        for label_idx, label in self.index_to_label.items():
+
+            if label_metadata[label_idx, 0] == 0:
+                continue
+
+            for score_idx, score_threshold in enumerate(score_thresholds):
+                for iou_idx, iou_threshold in enumerate(iou_thresholds):
+
+                    row = precision_recall[iou_idx][score_idx][label_idx]
+                    kwargs = {
+                        "label": label,
+                        "iou_threshold": iou_threshold,
+                        "score_threshold": score_threshold,
+                    }
+                    metrics[MetricType.Counts].append(
+                        Counts(
+                            tp=int(row[0]),
+                            fp=int(row[1]),
+                            fn=int(row[2]),
+                            **kwargs,
+                        )
+                    )
+
+                    metrics[MetricType.Precision].append(
+                        Precision(
+                            value=float(row[3]),
+                            **kwargs,
+                        )
+                    )
+                    metrics[MetricType.Recall].append(
+                        Recall(
+                            value=float(row[4]),
+                            **kwargs,
+                        )
+                    )
+                    metrics[MetricType.F1].append(
+                        F1(
+                            value=float(row[5]),
+                            **kwargs,
+                        )
+                    )
+                    metrics[MetricType.Accuracy].append(
+                        Accuracy(
+                            value=float(row[6]),
+                            **kwargs,
+                        )
+                    )
+
+        if as_dict:
+            return {
+                mtype: [metric.to_dict() for metric in mvalues]
+                for mtype, mvalues in metrics.items()
+            }
+
+        return metrics
+
+    def compute_confusion_matrix(
+        self,
+        iou_thresholds: list[float] = [0.5, 0.75, 0.9],
+        score_thresholds: list[float] = [0.5],
+        number_of_examples: int = 0,
+        filter_: Filter | None = None,
+        as_dict: bool = False,
+    ) -> list:
+        """
+        Computes confusion matrices at various thresholds.
+
+        Parameters
+        ----------
+        iou_thresholds : list[float]
+            A list of IoU thresholds to compute metrics over.
+        score_thresholds : list[float]
+            A list of score thresholds to compute metrics over.
+        number_of_examples : int, default=0
+            Maximum number of annotation examples to return in ConfusionMatrix.
+        filter_ : Filter, optional
+            An optional filter object.
+        as_dict : bool, default=False
+            An option to return metrics as dictionaries.
+
+        Returns
+        -------
+        list[ConfusionMatrix] | list[dict]
+            List of confusion matrices per threshold pair.
+        """
+
+        detailed_pairs = self._detailed_pairs
+        label_metadata = self._label_metadata
+        if filter_ is not None:
+            detailed_pairs = detailed_pairs[filter_.detailed_indices]
+            label_metadata = filter_.label_metadata
+
+        if detailed_pairs.size == 0:
+            return list()
+
+        (
+            confusion_matrix,
+            hallucinations,
+            missing_predictions,
+        ) = compute_confusion_matrix(
+            data=detailed_pairs,
             label_metadata=label_metadata,
             iou_thresholds=np.array(iou_thresholds),
             score_thresholds=np.array(score_thresholds),
@@ -881,23 +712,20 @@ class Evaluator:
         )
 
         n_ious, n_scores, n_labels, _, _ = confusion_matrix.shape
-        return [
+        matrices = [
             ConfusionMatrix(
                 iou_threshold=iou_thresholds[iou_idx],
                 score_threshold=score_thresholds[score_idx],
-                label_key=label_key,
                 number_of_examples=number_of_examples,
                 confusion_matrix=self._unpack_confusion_matrix(
                     confusion_matrix=confusion_matrix[
                         iou_idx, score_idx, :, :, :
                     ],
-                    label_key_idx=label_key_idx,
                     number_of_labels=n_labels,
                     number_of_examples=number_of_examples,
                 ),
                 hallucinations=self._unpack_hallucinations(
                     hallucinations=hallucinations[iou_idx, score_idx, :, :],
-                    label_key_idx=label_key_idx,
                     number_of_labels=n_labels,
                     number_of_examples=number_of_examples,
                 ),
@@ -905,16 +733,62 @@ class Evaluator:
                     missing_predictions=missing_predictions[
                         iou_idx, score_idx, :, :
                     ],
-                    label_key_idx=label_key_idx,
                     number_of_labels=n_labels,
                     number_of_examples=number_of_examples,
                 ),
             )
-            for label_key_idx, label_key in self.index_to_label_key.items()
             for iou_idx in range(n_ious)
             for score_idx in range(n_scores)
         ]
 
+        if as_dict:
+            return [m.to_dict() for m in matrices]
+        return matrices
+
+    def evaluate(
+        self,
+        iou_thresholds: list[float] = [0.5, 0.75, 0.9],
+        score_thresholds: list[float] = [0.5],
+        number_of_examples: int = 0,
+        filter_: Filter | None = None,
+        as_dict: bool = False,
+    ) -> dict[MetricType, list]:
+        """
+        Computes all avaiable metrics.
+
+        Parameters
+        ----------
+        iou_thresholds : list[float]
+            A list of IoU thresholds to compute metrics over.
+        score_thresholds : list[float]
+            A list of score thresholds to compute metrics over.
+        number_of_examples : int, default=0
+            Maximum number of annotation examples to return in ConfusionMatrix.
+        filter_ : Filter, optional
+            An optional filter object.
+        as_dict : bool, default=False
+            An option to return metrics as dictionaries.
+
+        Returns
+        -------
+        dict[MetricType, list]
+            A dictionary mapping metric type to a list of metrics.
+        """
+        results = self.compute_precision_recall(
+            iou_thresholds=iou_thresholds,
+            score_thresholds=score_thresholds,
+            filter_=filter_,
+            as_dict=as_dict,
+        )
+        results[MetricType.ConfusionMatrix] = self.compute_confusion_matrix(
+            iou_thresholds=iou_thresholds,
+            score_thresholds=score_thresholds,
+            number_of_examples=number_of_examples,
+            filter_=filter_,
+            as_dict=as_dict,
+        )
+        return results
+
 
 class DataLoader:
     """
@@ -923,7 +797,7 @@ class DataLoader:
 
     def __init__(self):
         self._evaluator = Evaluator()
-        self.pairs: list[NDArray[np.floating]] = list()
+        self.pairs: list[NDArray[np.float64]] = list()
         self.groundtruth_count = defaultdict(lambda: defaultdict(int))
         self.prediction_count = defaultdict(lambda: defaultdict(int))
 
@@ -947,51 +821,36 @@ class DataLoader:
             self._evaluator.index_to_uid[index] = uid
         return self._evaluator.uid_to_index[uid]
 
-    def _add_label(self, label: tuple[str, str]) -> tuple[int, int]:
+    def _add_label(self, label: str) -> int:
         """
         Helper function for adding a label to the cache.
 
         Parameters
         ----------
-        label : tuple[str, str]
-            The label as a tuple in format (key, value).
+        label : str
+            The label associated with the annotation.
 
         Returns
         -------
         int
             Label index.
-        int
-            Label key index.
         """
 
         label_id = len(self._evaluator.index_to_label)
-        label_key_id = len(self._evaluator.index_to_label_key)
         if label not in self._evaluator.label_to_index:
             self._evaluator.label_to_index[label] = label_id
             self._evaluator.index_to_label[label_id] = label
 
-            # update label key index
-            if label[0] not in self._evaluator.label_key_to_index:
-                self._evaluator.label_key_to_index[label[0]] = label_key_id
-                self._evaluator.index_to_label_key[label_key_id] = label[0]
-                label_key_id += 1
-
-            self._evaluator.label_index_to_label_key_index[
-                label_id
-            ] = self._evaluator.label_key_to_index[label[0]]
             label_id += 1
 
-        return (
-            self._evaluator.label_to_index[label],
-            self._evaluator.label_key_to_index[label[0]],
-        )
+        return self._evaluator.label_to_index[label]
 
     def _compute_ious_and_cache_pairs(
         self,
         uid_index: int,
-        keyed_groundtruths: dict,
-        keyed_predictions: dict,
-        annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask],
+        groundtruths: list,
+        predictions: list,
+        annotation_type: Type[BoundingBox] | Type[Polygon] | Type[Bitmask],
     ) -> None:
         """
         Compute IOUs between groundtruths and preditions before storing as pairs.
@@ -1000,122 +859,92 @@ class DataLoader:
         ----------
         uid_index: int
             The index of the detection.
-        keyed_groundtruths: dict
-            A dictionary of groundtruths.
-        keyed_predictions: dict
-            A dictionary of predictions.
+        groundtruths: list
+            A list of groundtruths.
+        predictions: list
+            A list of predictions.
         annotation_type: type[BoundingBox] | type[Polygon] | type[Bitmask]
             The type of annotation to compute IOUs for.
         """
-        gt_keys = set(keyed_groundtruths.keys())
-        pd_keys = set(keyed_predictions.keys())
-        joint_keys = gt_keys.intersection(pd_keys)
-        gt_unique_keys = gt_keys - pd_keys
-        pd_unique_keys = pd_keys - gt_keys
 
         pairs = list()
-        for key in joint_keys:
-            n_predictions = len(keyed_predictions[key])
-            n_groundtruths = len(keyed_groundtruths[key])
-            data = _get_annotation_data(
-                keyed_groundtruths=keyed_groundtruths,
-                keyed_predictions=keyed_predictions,
-                key=key,
-                annotation_type=annotation_type,
-            )
-            ious = compute_iou(data=data, annotation_type=annotation_type)
-            mask_nonzero_iou = (ious > 1e-9).reshape(
-                (n_predictions, n_groundtruths)
-            )
-            mask_ious_halluc = ~(mask_nonzero_iou.any(axis=1))
-            mask_ious_misprd = ~(mask_nonzero_iou.any(axis=0))
+        n_predictions = len(predictions)
+        n_groundtruths = len(groundtruths)
 
-            pairs.extend(
-                [
-                    np.array(
-                        [
-                            float(uid_index),
-                            float(gidx),
-                            float(pidx),
-                            ious[pidx * len(keyed_groundtruths[key]) + gidx],
-                            float(glabel),
-                            float(plabel),
-                            float(score),
-                        ]
-                    )
-                    for pidx, plabel, score, _ in keyed_predictions[key]
-                    for gidx, glabel, _ in keyed_groundtruths[key]
-                    if ious[pidx * len(keyed_groundtruths[key]) + gidx] > 1e-9
-                ]
-            )
-            pairs.extend(
-                [
-                    np.array(
-                        [
-                            float(uid_index),
-                            -1.0,
-                            float(pidx),
-                            0.0,
-                            -1.0,
-                            float(plabel),
-                            float(score),
-                        ]
-                    )
-                    for pidx, plabel, score, _ in keyed_predictions[key]
-                    if mask_ious_halluc[pidx]
-                ]
-            )
-            pairs.extend(
-                [
-                    np.array(
-                        [
-                            float(uid_index),
-                            float(gidx),
-                            -1.0,
-                            0.0,
-                            float(glabel),
-                            -1.0,
-                            -1.0,
-                        ]
-                    )
-                    for gidx, glabel, _ in keyed_groundtruths[key]
-                    if mask_ious_misprd[gidx]
-                ]
-            )
-        for key in gt_unique_keys:
-            pairs.extend(
-                [
-                    np.array(
-                        [
-                            float(uid_index),
-                            float(gidx),
-                            -1.0,
-                            0.0,
-                            float(glabel),
-                            -1.0,
-                            -1.0,
-                        ]
-                    )
-                    for gidx, glabel, _ in keyed_groundtruths[key]
-                ]
-            )
-        for key in pd_unique_keys:
-            pairs.extend(
-                [
-                    np.array(
-                        [
-                            float(uid_index),
-                            -1.0,
-                            float(pidx),
-                            0.0,
-                            -1.0,
-                            float(plabel),
-                            float(score),
-                        ]
-                    )
-                    for pidx, plabel, score, _ in keyed_predictions[key]
-                ]
-            )
+        all_pairs = np.array(
+            [
+                np.array([gann, pann])
+                for _, _, _, pann in predictions
+                for _, _, gann in groundtruths
+            ]
+        )
+
+        match annotation_type:
+            case annotation.BoundingBox:
+                ious = compute_bbox_iou(all_pairs)
+            case annotation.Polygon:
+                ious = compute_polygon_iou(all_pairs)
+            case annotation.Bitmask:
+                ious = compute_bitmask_iou(all_pairs)
+            case _:
+                raise ValueError(
+                    f"Invalid annotation type `{annotation_type}`."
+                )
+
+        ious = ious.reshape(n_predictions, n_groundtruths)
+        predictions_with_iou_of_zero = np.where((ious < 1e-9).all(axis=1))[0]
+        groundtruths_with_iou_of_zero = np.where((ious < 1e-9).all(axis=0))[0]
+
+        pairs.extend(
+            [
+                np.array(
+                    [
+                        float(uid_index),
+                        float(gidx),
+                        float(pidx),
+                        ious[pidx, gidx],
+                        float(glabel),
+                        float(plabel),
+                        float(score),
+                    ]
+                )
+                for pidx, plabel, score, _ in predictions
+                for gidx, glabel, _ in groundtruths
+                if ious[pidx, gidx] >= 1e-9
+            ]
+        )
+        pairs.extend(
+            [
+                np.array(
+                    [
+                        float(uid_index),
+                        -1.0,
+                        float(predictions[index][0]),
+                        0.0,
+                        -1.0,
+                        float(predictions[index][1]),
+                        float(predictions[index][2]),
+                    ]
+                )
+                for index in predictions_with_iou_of_zero
+            ]
+        )
+        pairs.extend(
+            [
+                np.array(
+                    [
+                        float(uid_index),
+                        float(groundtruths[index][0]),
+                        -1.0,
+                        0.0,
+                        float(groundtruths[index][1]),
+                        -1.0,
+                        -1.0,
+                    ]
+                )
+                for index in groundtruths_with_iou_of_zero
+            ]
+        )
 
         self.pairs.append(np.array(pairs))
 
@@ -1157,12 +986,8 @@ class DataLoader:
             )
 
             # cache labels and annotations
-            keyed_groundtruths = defaultdict(list)
-            keyed_predictions = defaultdict(list)
-
-            representation_property = _get_annotation_representation(
-                annotation_type=annotation_type
-            )
+            groundtruths = list()
+            predictions = list()
 
             for gidx, gann in enumerate(detection.groundtruths):
                 if not isinstance(gann, annotation_type):
@@ -1170,26 +995,17 @@ class DataLoader:
                         f"Expected {annotation_type}, but annotation is of type {type(gann)}."
                     )
 
-                if isinstance(gann, BoundingBox):
-                    self._evaluator.groundtruth_examples[uid_index][
-                        gidx
-                    ] = getattr(gann, representation_property)
-                else:
-                    converted_box = gann.to_box()
-                    self._evaluator.groundtruth_examples[uid_index][gidx] = (
-                        getattr(converted_box, "extrema")
-                        if converted_box is not None
-                        else None
-                    )
+                self._evaluator.groundtruth_examples[uid_index][
+                    gidx
+                ] = gann.extrema
                 for glabel in gann.labels:
-                    label_idx, label_key_idx = self._add_label(glabel)
+                    label_idx = self._add_label(glabel)
                     self.groundtruth_count[label_idx][uid_index] += 1
-                    representation = getattr(gann, representation_property)
-                    keyed_groundtruths[label_key_idx].append(
+                    groundtruths.append(
                         (
                             gidx,
                             label_idx,
-                            representation,
+                            gann.annotation,
                         )
                     )
 
@@ -1199,36 +1015,25 @@ class DataLoader:
                         f"Expected {annotation_type}, but annotation is of type {type(pann)}."
                     )
 
-                if isinstance(pann, BoundingBox):
-                    self._evaluator.prediction_examples[uid_index][
-                        pidx
-                    ] = getattr(pann, representation_property)
-                else:
-                    converted_box = pann.to_box()
-                    self._evaluator.prediction_examples[uid_index][pidx] = (
-                        getattr(converted_box, "extrema")
-                        if converted_box is not None
-                        else None
-                    )
+                self._evaluator.prediction_examples[uid_index][
+                    pidx
+                ] = pann.extrema
                 for plabel, pscore in zip(pann.labels, pann.scores):
-                    label_idx, label_key_idx = self._add_label(plabel)
+                    label_idx = self._add_label(plabel)
                     self.prediction_count[label_idx][uid_index] += 1
-                    representation = representation = getattr(
-                        pann, representation_property
-                    )
-                    keyed_predictions[label_key_idx].append(
+                    predictions.append(
                         (
                             pidx,
                             label_idx,
                             pscore,
-                            representation,
+                            pann.annotation,
                         )
                     )
 
             self._compute_ious_and_cache_pairs(
                 uid_index=uid_index,
-                keyed_groundtruths=keyed_groundtruths,
-                keyed_predictions=keyed_predictions,
+                groundtruths=groundtruths,
+                predictions=predictions,
                 annotation_type=annotation_type,
             )
 
@@ -1295,150 +1100,6 @@ class DataLoader:
             annotation_type=Bitmask,
         )
 
-    def _add_data_from_valor_dict(
-        self,
-        detections: list[tuple[dict, dict]],
-        annotation_type: type[Bitmask] | type[BoundingBox] | type[Polygon],
-        show_progress: bool = False,
-    ):
-        """
-        Adds Valor-format detections to the cache.
-
-        Parameters
-        ----------
-        detections : list[tuple[dict, dict]]
-            A list of groundtruth, prediction pairs in Valor-format dictionaries.
-        annotation_type : type[Bitmask] | type[BoundingBox] | type[Polygon]
-            The annotation type to process.
-        show_progress : bool, default=False
-            Toggle for tqdm progress bar.
-        """
-
-        disable_tqdm = not show_progress
-        for groundtruth, prediction in tqdm(detections, disable=disable_tqdm):
-            # update metadata
-            self._evaluator.n_datums += 1
-            self._evaluator.n_groundtruths += len(groundtruth["annotations"])
-            self._evaluator.n_predictions += len(prediction["annotations"])
-
-            # update datum uid index
-            uid_index = self._add_datum(uid=groundtruth["datum"]["uid"])
-
-            # initialize bounding box examples
-            self._evaluator.groundtruth_examples[uid_index] = np.zeros(
-                (len(groundtruth["annotations"]), 4), dtype=np.float16
-            )
-            self._evaluator.prediction_examples[uid_index] = np.zeros(
-                (len(prediction["annotations"]), 4), dtype=np.float16
-            )
-
-            # cache labels and annotations
-            keyed_groundtruths = defaultdict(list)
-            keyed_predictions = defaultdict(list)
-
-            annotation_key = _get_valor_dict_annotation_key(
-                annotation_type=annotation_type
-            )
-            invalid_keys = list(
-                filter(
-                    lambda x: x != annotation_key,
-                    ["bounding_box", "raster", "polygon"],
-                )
-            )
-
-            for gidx, gann in enumerate(groundtruth["annotations"]):
-                if (gann[annotation_key] is None) or any(
-                    [gann[k] is not None for k in invalid_keys]
-                ):
-                    raise ValueError(
-                        f"Input JSON doesn't contain {annotation_type} data, or contains data for multiple annotation types."
-                    )
-                if annotation_type == BoundingBox:
-                    self._evaluator.groundtruth_examples[uid_index][
-                        gidx
-                    ] = np.array(
-                        _get_annotation_representation_from_valor_dict(
-                            gann[annotation_key],
-                            annotation_type=annotation_type,
-                        ),
-                    )
-
-                for valor_label in gann["labels"]:
-                    glabel = (valor_label["key"], valor_label["value"])
-                    label_idx, label_key_idx = self._add_label(glabel)
-                    self.groundtruth_count[label_idx][uid_index] += 1
-                    keyed_groundtruths[label_key_idx].append(
-                        (
-                            gidx,
-                            label_idx,
-                            _get_annotation_representation_from_valor_dict(
-                                gann[annotation_key],
-                                annotation_type=annotation_type,
-                            ),
-                        )
-                    )
-            for pidx, pann in enumerate(prediction["annotations"]):
-                if (pann[annotation_key] is None) or any(
-                    [pann[k] is not None for k in invalid_keys]
-                ):
-                    raise ValueError(
-                        f"Input JSON doesn't contain {annotation_type} data, or contains data for multiple annotation types."
-                    )
-
-                if annotation_type == BoundingBox:
-                    self._evaluator.prediction_examples[uid_index][
-                        pidx
-                    ] = np.array(
-                        _get_annotation_representation_from_valor_dict(
-                            pann[annotation_key],
-                            annotation_type=annotation_type,
-                        )
-                    )
-                for valor_label in pann["labels"]:
-                    plabel = (valor_label["key"], valor_label["value"])
-                    pscore = valor_label["score"]
-                    label_idx, label_key_idx = self._add_label(plabel)
-                    self.prediction_count[label_idx][uid_index] += 1
-                    keyed_predictions[label_key_idx].append(
-                        (
-                            pidx,
-                            label_idx,
-                            pscore,
-                            _get_annotation_representation_from_valor_dict(
-                                pann[annotation_key],
-                                annotation_type=annotation_type,
-                            ),
-                        )
-                    )
-
-            self._compute_ious_and_cache_pairs(
-                uid_index=uid_index,
-                keyed_groundtruths=keyed_groundtruths,
-                keyed_predictions=keyed_predictions,
-                annotation_type=annotation_type,
-            )
-
-    def add_bounding_boxes_from_valor_dict(
-        self,
-        detections: list[tuple[dict, dict]],
-        show_progress: bool = False,
-    ):
-        """
-        Adds Valor-format bounding box detections to the cache.
-
-        Parameters
-        ----------
-        detections : list[tuple[dict, dict]]
-            A list of groundtruth, prediction pairs in Valor-format dictionaries.
-        show_progress : bool, default=False
-            Toggle for tqdm progress bar.
-        """
-        return self._add_data_from_valor_dict(
-            detections=detections,
-            show_progress=show_progress,
-            annotation_type=BoundingBox,
-        )
-
     def finalize(self) -> Evaluator:
         """
         Performs data finalization and some preprocessing steps.
@@ -1494,11 +1155,6 @@ class DataLoader:
                             ]
                         )
                     ),
-                    float(
-                        self._evaluator.label_index_to_label_key_index[
-                            label_idx
-                        ]
-                    ),
                 ]
                 for label_idx in range(n_labels)
             ]