Upload balanced_topk_accuracy.py

balanced_topk_accuracy.py

@@ -0,0 +1,88 @@
+import numpy as np
+import evaluate
+import datasets
+
+_DESCRIPTION = """
+Balanced (macro) Top-K Accuracy for multiclass classification.
+For each class c, compute recall@k (fraction of samples of class c where c is in top-k predictions),
+then macro-average over classes. Accepts (N, K) score/prob arrays.
+"""
+
+_KWARGS_DESCRIPTION = """
+Args:
+    predictions: 2D array-like of shape (N, K) with class scores/probabilities.
+    references:  1D list/array of integer labels in [0, K-1].
+    k:           int, top-k (default 1). If None, use k_list instead.
+    k_list:      Optional[list[int]] to compute multiple ks at once (e.g., [1,5]).
+    zero_division: float, default 0.0. Used when a class has no positive samples.
+    return_per_class: bool, default False. If True, also return per-class recalls@k.
+Returns:
+    dict with {"balanced_topk_accuracy": float or dict[int,float]}.
+    If k_list provided, returns a dict mapping k -> score. Optionally adds "per_class_recall".
+"""
+
+_CITATION = ""
+
+
+class BalancedTopKAccuracy(evaluate.Metric):
+    def _info(self):
+        return evaluate.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Sequence(datasets.Value("float64")),
+                    "references": datasets.Value("int64"),
+                }
+            ),
+        )
+
+    def _compute(
+        self,
+        predictions,
+        references,
+        k: int | None = 1,
+        k_list: list[int] | None = None,
+        zero_division: float = 0.0,
+        return_per_class: bool = False,
+    ):
+        y_true = np.asarray(references, dtype=int)
+        scores = np.asarray(predictions, dtype=float)
+
+        if scores.ndim != 2 or y_true.ndim != 1:
+            raise ValueError("predictions must be (N, K) scores; references must be 1D labels.")
+        N, K = scores.shape
+        if y_true.shape[0] != N:
+            raise ValueError(f"Shape mismatch: references length {y_true.shape[0]} vs predictions {N}.")
+
+        ks = (k_list if k_list is not None else [k if k is not None else 1])
+        ks = sorted(set(int(x) for x in ks if x is not None and x >= 1))
+        if not ks:
+            raise ValueError("Provide a positive integer k or a non-empty k_list.")
+
+        top_indices = np.argpartition(-scores, kth=np.maximum(ks).min()-1 if len(ks)==1 else np.max(ks)-1, axis=1)
+        sorted_idx = np.argsort(-scores, axis=1)
+        results = {}
+        per_class = {}
+
+        for kk in ks:
+            topk = sorted_idx[:, :kk]
+            recalls = []
+            for c in range(K):
+                mask = (y_true == c)
+                denom = int(mask.sum())
+                if denom == 0:
+                    recalls.append(float(zero_division))
+                    continue
+                hits = int(np.any(topk[mask] == c, axis=1).sum())
+                recalls.append(hits / denom)
+            ba_k = float(np.mean(recalls))
+            results[kk] = ba_k
+            if return_per_class:
+                per_class[kk] = recalls
+
+        out = {"balanced_topk_accuracy": results[ks[0]] if len(ks)==1 else results}
+        if return_per_class:
+            out["per_class_recall"] = per_class if len(ks)>1 else per_class[ks[0]]
+        return out