valor-lite 0.36.6__py3-none-any.whl → 0.37.5__py3-none-any.whl

valor_lite/object_detection/utilities.py

@@ -1,42 +1,24 @@
 from collections import defaultdict
 
 import numpy as np
+import pyarrow as pa
 from numpy.typing import NDArray
 
-from valor_lite.object_detection.computation import PairClassification
 from valor_lite.object_detection.metric import Metric, MetricType
 
 
 def unpack_precision_recall_into_metric_lists(
-    results: tuple[
-        tuple[
-            NDArray[np.float64],
-            NDArray[np.float64],
-        ],
-        tuple[
-            NDArray[np.float64],
-            NDArray[np.float64],
-        ],
-        NDArray[np.float64],
-        NDArray[np.float64],
-    ],
+    counts: NDArray[np.uint64],
+    precision_recall_f1: NDArray[np.float64],
+    average_precision: NDArray[np.float64],
+    mean_average_precision: NDArray[np.float64],
+    average_recall: NDArray[np.float64],
+    mean_average_recall: NDArray[np.float64],
+    pr_curve: NDArray[np.float64],
     iou_thresholds: list[float],
     score_thresholds: list[float],
-    index_to_label: list[str],
+    index_to_label: dict[int, str],
 ):
-    (
-        (
-            average_precision,
-            mean_average_precision,
-        ),
-        (
-            average_recall,
-            mean_average_recall,
-        ),
-        precision_recall,
-        pr_curves,
-    ) = results
-
     metrics = defaultdict(list)
 
     metrics[MetricType.AP] = [
@@ -46,7 +28,7 @@ def unpack_precision_recall_into_metric_lists(
             label=label,
         )
         for iou_idx, iou_threshold in enumerate(iou_thresholds)
-        for label_idx, label in enumerate(index_to_label)
+        for label_idx, label in index_to_label.items()
     ]
 
     metrics[MetricType.mAP] = [
@@ -64,7 +46,7 @@ def unpack_precision_recall_into_metric_lists(
             iou_thresholds=iou_thresholds,
             label=label,
         )
-        for label_idx, label in enumerate(index_to_label)
+        for label_idx, label in index_to_label.items()
     ]
 
     # TODO - (c.zaloom) will be removed in the future
@@ -83,7 +65,7 @@ def unpack_precision_recall_into_metric_lists(
             label=label,
         )
         for score_idx, score_threshold in enumerate(score_thresholds)
-        for label_idx, label in enumerate(index_to_label)
+        for label_idx, label in index_to_label.items()
     ]
 
     metrics[MetricType.mAR] = [
@@ -103,7 +85,7 @@ def unpack_precision_recall_into_metric_lists(
             iou_thresholds=iou_thresholds,
             label=label,
         )
-        for label_idx, label in enumerate(index_to_label)
+        for label_idx, label in index_to_label.items()
     ]
 
     # TODO - (c.zaloom) will be removed in the future
@@ -117,20 +99,20 @@ def unpack_precision_recall_into_metric_lists(
 
     metrics[MetricType.PrecisionRecallCurve] = [
         Metric.precision_recall_curve(
-            precisions=pr_curves[iou_idx, label_idx, :, 0].tolist(),  # type: ignore[reportArgumentType]
-            scores=pr_curves[iou_idx, label_idx, :, 1].tolist(),  # type: ignore[reportArgumentType]
+            precisions=pr_curve[iou_idx, label_idx, :, 0].tolist(),
+            scores=pr_curve[iou_idx, label_idx, :, 1].tolist(),
             iou_threshold=iou_threshold,
             label=label,
         )
         for iou_idx, iou_threshold in enumerate(iou_thresholds)
-        for label_idx, label in enumerate(index_to_label)
+        for label_idx, label in index_to_label.items()
     ]
 
-    for label_idx, label in enumerate(index_to_label):
+    for label_idx, label in index_to_label.items():
         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, :]
+                row = counts[iou_idx, score_idx, :, label_idx]
                 kwargs = {
                     "label": label,
                     "iou_threshold": iou_threshold,
@@ -145,21 +127,22 @@ def unpack_precision_recall_into_metric_lists(
                     )
                 )
 
+                row = precision_recall_f1[iou_idx, score_idx, :, label_idx]
                 metrics[MetricType.Precision].append(
                     Metric.precision(
-                        value=float(row[3]),
+                        value=float(row[0]),
                         **kwargs,
                     )
                 )
                 metrics[MetricType.Recall].append(
                     Metric.recall(
-                        value=float(row[4]),
+                        value=float(row[1]),
                         **kwargs,
                     )
                 )
                 metrics[MetricType.F1].append(
                     Metric.f1_score(
-                        value=float(row[5]),
+                        value=float(row[2]),
                         **kwargs,
                     )
                 )
@@ -167,40 +150,153 @@ def unpack_precision_recall_into_metric_lists(
     return metrics
 
 
-def _create_empty_confusion_matrix(index_to_labels: list[str]):
-    unmatched_ground_truths = dict()
+def unpack_confusion_matrix(
+    confusion_matrices: NDArray[np.uint64],
+    unmatched_groundtruths: NDArray[np.uint64],
+    unmatched_predictions: NDArray[np.uint64],
+    index_to_label: dict[int, str],
+    iou_thresholds: list[float],
+    score_thresholds: list[float],
+) -> list[Metric]:
+    metrics = []
+    for iou_idx, iou_thresh in enumerate(iou_thresholds):
+        for score_idx, score_thresh in enumerate(score_thresholds):
+            cm_dict = {}
+            ugt_dict = {}
+            upd_dict = {}
+            for idx, label in index_to_label.items():
+                ugt_dict[label] = int(
+                    unmatched_groundtruths[iou_idx, score_idx, idx]
+                )
+                upd_dict[label] = int(
+                    unmatched_predictions[iou_idx, score_idx, idx]
+                )
+                for pidx, plabel in index_to_label.items():
+                    if label not in cm_dict:
+                        cm_dict[label] = {}
+                    cm_dict[label][plabel] = int(
+                        confusion_matrices[iou_idx, score_idx, idx, pidx]
+                    )
+            metrics.append(
+                Metric.confusion_matrix(
+                    confusion_matrix=cm_dict,
+                    unmatched_ground_truths=ugt_dict,
+                    unmatched_predictions=upd_dict,
+                    iou_threshold=iou_thresh,
+                    score_threshold=score_thresh,
+                )
+            )
+    return metrics
+
+
+def create_mapping(
+    tbl: pa.Table,
+    pairs: NDArray[np.float64],
+    index: int,
+    id_col: str,
+    uid_col: str,
+) -> dict[int, str]:
+    col = pairs[:, index].astype(np.int64)
+    values, indices = np.unique(col, return_index=True)
+    indices = indices[values >= 0]
+    return {
+        tbl[id_col][idx].as_py(): tbl[uid_col][idx].as_py() for idx in indices
+    }
+
+
+def unpack_examples(
+    detailed_pairs: NDArray[np.float64],
+    mask_tp: NDArray[np.bool_],
+    mask_fn: NDArray[np.bool_],
+    mask_fp: NDArray[np.bool_],
+    iou_thresholds: list[float],
+    score_thresholds: list[float],
+    index_to_datum_id: dict[int, str],
+    index_to_groundtruth_id: dict[int, str],
+    index_to_prediction_id: dict[int, str],
+) -> list[Metric]:
+    metrics = []
+    ids = detailed_pairs[:, :5].astype(np.int64)
+    unique_datums = np.unique(detailed_pairs[:, 0].astype(np.int64))
+    for datum_index in unique_datums:
+        mask_datum = detailed_pairs[:, 0] == datum_index
+        mask_datum_tp = mask_tp & mask_datum
+        mask_datum_fp = mask_fp & mask_datum
+        mask_datum_fn = mask_fn & mask_datum
+
+        datum_id = index_to_datum_id[datum_index]
+        for iou_idx, iou_thresh in enumerate(iou_thresholds):
+            for score_idx, score_thresh in enumerate(score_thresholds):
+
+                unique_tp = np.unique(
+                    ids[np.ix_(mask_datum_tp[iou_idx, score_idx], (0, 1, 2, 3, 4))], axis=0  # type: ignore - numpy ix_ typing
+                )
+                unique_fp = np.unique(
+                    ids[np.ix_(mask_datum_fp[iou_idx, score_idx], (0, 2, 4))], axis=0  # type: ignore - numpy ix_ typing
+                )
+                unique_fn = np.unique(
+                    ids[np.ix_(mask_datum_fn[iou_idx, score_idx], (0, 1, 3))], axis=0  # type: ignore - numpy ix_ typing
+                )
+
+                tp = [
+                    (
+                        index_to_groundtruth_id[row[1]],
+                        index_to_prediction_id[row[2]],
+                    )
+                    for row in unique_tp
+                ]
+                fp = [index_to_prediction_id[row[1]] for row in unique_fp]
+                fn = [index_to_groundtruth_id[row[1]] for row in unique_fn]
+                metrics.append(
+                    Metric.examples(
+                        datum_id=datum_id,
+                        true_positives=tp,
+                        false_negatives=fn,
+                        false_positives=fp,
+                        iou_threshold=iou_thresh,
+                        score_threshold=score_thresh,
+                    )
+                )
+    return metrics
+
+
+def create_empty_confusion_matrix_with_examples(
+    iou_threhsold: float,
+    score_threshold: float,
+    index_to_label: dict[int, str],
+) -> Metric:
+    unmatched_groundtruths = dict()
     unmatched_predictions = dict()
     confusion_matrix = dict()
-    for label in index_to_labels:
-        unmatched_ground_truths[label] = {"count": 0, "examples": []}
+    for label in index_to_label.values():
+        unmatched_groundtruths[label] = {"count": 0, "examples": []}
         unmatched_predictions[label] = {"count": 0, "examples": []}
         confusion_matrix[label] = {}
-        for plabel in index_to_labels:
+        for plabel in index_to_label.values():
             confusion_matrix[label][plabel] = {"count": 0, "examples": []}
-    return (
-        confusion_matrix,
-        unmatched_predictions,
-        unmatched_ground_truths,
+
+    return Metric.confusion_matrix_with_examples(
+        confusion_matrix=confusion_matrix,
+        unmatched_ground_truths=unmatched_groundtruths,
+        unmatched_predictions=unmatched_predictions,
+        iou_threshold=iou_threhsold,
+        score_threshold=score_threshold,
     )
 
 
-def _unpack_confusion_matrix(
+def _unpack_confusion_matrix_with_examples(
+    metric: Metric,
     ids: NDArray[np.int32],
     mask_matched: NDArray[np.bool_],
     mask_fp_unmatched: NDArray[np.bool_],
     mask_fn_unmatched: NDArray[np.bool_],
-    index_to_datum_id: list[str],
-    index_to_groundtruth_id: list[str],
-    index_to_prediction_id: list[str],
-    index_to_label: list[str],
-    iou_threhsold: float,
-    score_threshold: float,
+    index_to_datum_id: dict[int, str],
+    index_to_groundtruth_id: dict[int, str],
+    index_to_prediction_id: dict[int, str],
+    index_to_label: dict[int, str],
 ):
-    (
-        confusion_matrix,
-        unmatched_predictions,
-        unmatched_ground_truths,
-    ) = _create_empty_confusion_matrix(index_to_label)
+    if not isinstance(metric.value, dict):
+        raise TypeError("expected metric to contain a dictionary value")
 
     unique_matches = np.unique(
         ids[np.ix_(mask_matched, (0, 1, 2, 3, 4))], axis=0  # type: ignore - numpy ix_ typing
@@ -220,8 +316,8 @@ def _unpack_confusion_matrix(
     for idx in range(n_max):
         if idx < n_unmatched_groundtruths:
             label = index_to_label[unique_unmatched_groundtruths[idx, 2]]
-            unmatched_ground_truths[label]["count"] += 1
-            unmatched_ground_truths[label]["examples"].append(
+            metric.value["unmatched_ground_truths"][label]["count"] += 1
+            metric.value["unmatched_ground_truths"][label]["examples"].append(
                 {
                     "datum_id": index_to_datum_id[
                         unique_unmatched_groundtruths[idx, 0]
@@ -232,9 +328,10 @@ def _unpack_confusion_matrix(
                 }
             )
         if idx < n_unmatched_predictions:
-            label = index_to_label[unique_unmatched_predictions[idx, 2]]
-            unmatched_predictions[label]["count"] += 1
-            unmatched_predictions[label]["examples"].append(
+            label_id = unique_unmatched_predictions[idx, 2]
+            label = index_to_label[label_id]
+            metric.value["unmatched_predictions"][label]["count"] += 1
+            metric.value["unmatched_predictions"][label]["examples"].append(
                 {
                     "datum_id": index_to_datum_id[
                         unique_unmatched_predictions[idx, 0]
@@ -247,8 +344,10 @@ def _unpack_confusion_matrix(
         if idx < n_matched:
             glabel = index_to_label[unique_matches[idx, 3]]
             plabel = index_to_label[unique_matches[idx, 4]]
-            confusion_matrix[glabel][plabel]["count"] += 1
-            confusion_matrix[glabel][plabel]["examples"].append(
+            metric.value["confusion_matrix"][glabel][plabel]["count"] += 1
+            metric.value["confusion_matrix"][glabel][plabel][
+                "examples"
+            ].append(
                 {
                     "datum_id": index_to_datum_id[unique_matches[idx, 0]],
                     "ground_truth_id": index_to_groundtruth_id[
@@ -260,43 +359,29 @@ def _unpack_confusion_matrix(
                 }
             )
 
-    return Metric.confusion_matrix(
-        confusion_matrix=confusion_matrix,
-        unmatched_ground_truths=unmatched_ground_truths,
-        unmatched_predictions=unmatched_predictions,
-        iou_threshold=iou_threhsold,
-        score_threshold=score_threshold,
-    )
+    return metric
 
 
-def unpack_confusion_matrix_into_metric_list(
-    results: NDArray[np.uint8],
+def unpack_confusion_matrix_with_examples(
+    metrics: dict[int, dict[int, Metric]],
     detailed_pairs: NDArray[np.float64],
-    iou_thresholds: list[float],
-    score_thresholds: list[float],
-    index_to_datum_id: list[str],
-    index_to_groundtruth_id: list[str],
-    index_to_prediction_id: list[str],
-    index_to_label: list[str],
+    mask_tp: NDArray[np.bool_],
+    mask_fp_fn_misclf: NDArray[np.bool_],
+    mask_fp_unmatched: NDArray[np.bool_],
+    mask_fn_unmatched: NDArray[np.bool_],
+    index_to_datum_id: dict[int, str],
+    index_to_groundtruth_id: dict[int, str],
+    index_to_prediction_id: dict[int, str],
+    index_to_label: dict[int, str],
 ) -> list[Metric]:
 
     ids = detailed_pairs[:, :5].astype(np.int32)
 
-    mask_matched = (
-        np.bitwise_and(
-            results, PairClassification.TP | PairClassification.FP_FN_MISCLF
-        )
-        > 0
-    )
-    mask_fp_unmatched = (
-        np.bitwise_and(results, PairClassification.FP_UNMATCHED) > 0
-    )
-    mask_fn_unmatched = (
-        np.bitwise_and(results, PairClassification.FN_UNMATCHED) > 0
-    )
+    mask_matched = mask_tp | mask_fp_fn_misclf
 
     return [
-        _unpack_confusion_matrix(
+        _unpack_confusion_matrix_with_examples(
+            metric=metric,
             ids=ids,
             mask_matched=mask_matched[iou_idx, score_idx],
             mask_fp_unmatched=mask_fp_unmatched[iou_idx, score_idx],
@@ -305,10 +390,7 @@ def unpack_confusion_matrix_into_metric_list(
             index_to_groundtruth_id=index_to_groundtruth_id,
             index_to_prediction_id=index_to_prediction_id,
             index_to_label=index_to_label,
-            iou_threhsold=iou_threshold,
-            score_threshold=score_threshold,
         )
-        for iou_idx, iou_threshold in enumerate(iou_thresholds)
-        for score_idx, score_threshold in enumerate(score_thresholds)
-        if (results[iou_idx, score_idx] != -1).any()
+        for iou_idx, inner in metrics.items()
+        for score_idx, metric in inner.items()
     ]

valor_lite/semantic_segmentation/__init__.py

@@ -1,14 +1,15 @@
 from .annotation import Bitmask, Segmentation
-from .manager import DataLoader, Evaluator, Filter, Metadata
+from .evaluator import Builder, Evaluator, EvaluatorInfo
+from .loader import Loader
 from .metric import Metric, MetricType
 
 __all__ = [
-    "DataLoader",
+    "Builder",
+    "Loader",
     "Evaluator",
     "Segmentation",
     "Bitmask",
     "Metric",
     "MetricType",
-    "Filter",
-    "Metadata",
+    "EvaluatorInfo",
 ]

valor_lite/semantic_segmentation/annotation.py

@@ -1,5 +1,6 @@
 import warnings
 from dataclasses import dataclass, field
+from typing import Any
 
 import numpy as np
 from numpy.typing import NDArray
@@ -16,6 +17,8 @@ class Bitmask:
         A NumPy array of boolean values representing the mask.
     label : str
         The semantic label associated with the mask.
+    metadata : dict[str, Any], optional
+        A dictionary containing any metadata to be used within filtering operations.
 
     Examples
     --------
@@ -26,6 +29,7 @@ class Bitmask:
 
     mask: NDArray[np.bool_]
     label: str
+    metadata: dict[str, Any] | None = None
 
     def __post_init__(self):
         if self.mask.dtype != np.bool_:
@@ -51,6 +55,8 @@ class Segmentation:
         The shape of the segmentation masks. This is set automatically after initialization.
     size : int, optional
         The total number of pixels in the masks. This is set automatically after initialization.
+    metadata : dict[str, Any], optional
+        A dictionary containing any metadata to be used within filtering operations.
 
     Examples
     --------
@@ -71,6 +77,7 @@ class Segmentation:
     predictions: list[Bitmask]
     shape: tuple[int, ...]
     size: int = field(default=0)
+    metadata: dict[str, Any] | None = None
 
     def __post_init__(self):
 

valor_lite/semantic_segmentation/computation.py

@@ -2,93 +2,13 @@ import numpy as np
 from numpy.typing import NDArray
 
 
-def compute_label_metadata(
-    confusion_matrices: NDArray[np.int64],
-    n_labels: int,
-) -> NDArray[np.int64]:
-    """
-    Computes label metadata returning a count of annotations per label.
-
-    Parameters
-    ----------
-    confusion_matrices : NDArray[np.int64]
-        Confusion matrices per datum with shape (n_datums, n_labels + 1, n_labels + 1).
-    n_labels : int
-        The total number of unique labels.
-
-    Returns
-    -------
-    NDArray[np.int64]
-        The label metadata array with shape (n_labels, 2).
-            Index 0 - Ground truth label count
-            Index 1 - Prediction label count
-    """
-    label_metadata = np.zeros((n_labels, 2), dtype=np.int64)
-    label_metadata[:, 0] = confusion_matrices[:, 1:, :].sum(axis=(0, 2))
-    label_metadata[:, 1] = confusion_matrices[:, :, 1:].sum(axis=(0, 1))
-    return label_metadata
-
-
-def filter_cache(
-    confusion_matrices: NDArray[np.int64],
-    datum_mask: NDArray[np.bool_],
-    label_mask: NDArray[np.bool_],
-    number_of_labels: int,
-) -> tuple[NDArray[np.int64], NDArray[np.int64]]:
-    """
-    Performs the filter operation over the internal cache.
-
-    Parameters
-    ----------
-    confusion_matrices : NDArray[int64]
-        The internal evaluator cache.
-    datum_mask : NDArray[bool]
-        A mask that filters out datums.
-    datum_mask : NDArray[bool]
-        A mask that filters out labels.
-
-    Returns
-    -------
-    NDArray[int64]
-        Filtered confusion matrices.
-    NDArray[int64]
-        Filtered label metadata.
-    """
-    if label_mask.any():
-        # add filtered labels to background
-        null_predictions = confusion_matrices[:, label_mask, :].sum(
-            axis=(1, 2)
-        )
-        null_groundtruths = confusion_matrices[:, :, label_mask].sum(
-            axis=(1, 2)
-        )
-        null_intersection = (
-            confusion_matrices[:, label_mask, label_mask]
-            .reshape(confusion_matrices.shape[0], -1)
-            .sum(axis=1)
-        )
-        confusion_matrices[:, 0, 0] += (
-            null_groundtruths + null_predictions - null_intersection
-        )
-        confusion_matrices[:, label_mask, :] = 0
-        confusion_matrices[:, :, label_mask] = 0
-
-    confusion_matrices = confusion_matrices[datum_mask]
-
-    label_metadata = compute_label_metadata(
-        confusion_matrices=confusion_matrices,
-        n_labels=number_of_labels,
-    )
-    return confusion_matrices, label_metadata
-
-
-def compute_intermediate_confusion_matrices(
+def compute_intermediates(
     groundtruths: NDArray[np.bool_],
     predictions: NDArray[np.bool_],
     groundtruth_labels: NDArray[np.int64],
     prediction_labels: NDArray[np.int64],
     n_labels: int,
-) -> NDArray[np.int64]:
+) -> NDArray[np.uint64]:
     """
     Computes an intermediate confusion matrix containing label counts.
 
@@ -99,15 +19,15 @@ def compute_intermediate_confusion_matrices(
     predictions : NDArray[np.bool_]
         A 2-D array containing flattened bitmasks for each label.
     groundtruth_labels : NDArray[np.int64]
-        A 1-D array containing label indices.
-    groundtruth_labels : NDArray[np.int64]
-        A 1-D array containing label indices.
+        A 1-D array containing ground truth label indices.
+    prediction_labels : NDArray[np.int64]
+        A 1-D array containing prediction label indices.
     n_labels : int
         The number of unique labels.
 
     Returns
     -------
-    NDArray[np.int64]
+    NDArray[np.uint64]
         A 2-D confusion matrix with shape (n_labels + 1, n_labels + 1).
     """
 
@@ -125,7 +45,7 @@ def compute_intermediate_confusion_matrices(
     intersected_groundtruth_counts = intersection_counts.sum(axis=1)
     intersected_prediction_counts = intersection_counts.sum(axis=0)
 
-    confusion_matrix = np.zeros((n_labels + 1, n_labels + 1), dtype=np.int64)
+    confusion_matrix = np.zeros((n_labels + 1, n_labels + 1), dtype=np.uint64)
     confusion_matrix[0, 0] = background_counts
     confusion_matrix[
         np.ix_(groundtruth_labels + 1, prediction_labels + 1)
@@ -136,14 +56,11 @@ def compute_intermediate_confusion_matrices(
     confusion_matrix[groundtruth_labels + 1, 0] = (
         groundtruth_counts - intersected_groundtruth_counts
     )
-
     return confusion_matrix
 
 
 def compute_metrics(
-    confusion_matrices: NDArray[np.int64],
-    label_metadata: NDArray[np.int64],
-    n_pixels: int,
+    confusion_matrix: NDArray[np.uint64],
 ) -> tuple[
     NDArray[np.float64],
     NDArray[np.float64],
@@ -156,16 +73,10 @@ def compute_metrics(
     """
     Computes semantic segmentation metrics.
 
-    Takes data with shape (3, N).
-
     Parameters
     ----------
-    confusion_matrices : NDArray[np.int64]
-        A 3-D array containing confusion matrices for each datum with shape (n_datums, n_labels + 1, n_labels + 1).
-    label_metadata : NDArray[np.int64]
-        A 2-D array containing label metadata with shape (n_labels, 2).
-            Index 0: Ground Truth Label Count
-            Index 1: Prediction Label Count
+    counts : NDArray[np.uint64]
+        A 2-D confusion matrix with shape (n_labels + 1, n_labels + 1).
 
     Returns
     -------
@@ -184,14 +95,13 @@ def compute_metrics(
     NDArray[np.float64]
         Unmatched ground truth ratios.
     """
-    n_labels = label_metadata.shape[0]
-    gt_counts = label_metadata[:, 0]
-    pd_counts = label_metadata[:, 1]
-
-    counts = confusion_matrices.sum(axis=0)
+    n_labels = confusion_matrix.shape[0] - 1
+    n_pixels = confusion_matrix.sum()
+    gt_counts = confusion_matrix[1:, :].sum(axis=1)
+    pd_counts = confusion_matrix[:, 1:].sum(axis=0)
 
     # compute iou, unmatched_ground_truth and unmatched predictions
-    intersection_ = counts[1:, 1:]
+    intersection_ = confusion_matrix[1:, 1:]
     union_ = (
         gt_counts[:, np.newaxis] + pd_counts[np.newaxis, :] - intersection_
     )
@@ -206,7 +116,7 @@ def compute_metrics(
 
     unmatched_prediction_ratio = np.zeros((n_labels), dtype=np.float64)
     np.divide(
-        counts[0, 1:],
+        confusion_matrix[0, 1:],
         pd_counts,
         where=pd_counts > 1e-9,
         out=unmatched_prediction_ratio,
@@ -214,14 +124,14 @@ def compute_metrics(
 
     unmatched_ground_truth_ratio = np.zeros((n_labels), dtype=np.float64)
     np.divide(
-        counts[1:, 0],
+        confusion_matrix[1:, 0],
         gt_counts,
         where=gt_counts > 1e-9,
         out=unmatched_ground_truth_ratio,
     )
 
     # compute precision, recall, f1
-    tp_counts = counts.diagonal()[1:]
+    tp_counts = confusion_matrix.diagonal()[1:]
 
     precision = np.zeros(n_labels, dtype=np.float64)
     np.divide(tp_counts, pd_counts, where=pd_counts > 1e-9, out=precision)
@@ -238,8 +148,8 @@ def compute_metrics(
     )
 
     # compute accuracy
-    tp_count = counts[1:, 1:].diagonal().sum()
-    background_count = counts[0, 0]
+    tp_count = confusion_matrix[1:, 1:].diagonal().sum()
+    background_count = confusion_matrix[0, 0]
     accuracy = (
         (tp_count + background_count) / n_pixels if n_pixels > 0 else 0.0
     )