Upload balanced_accuracy_multilabel.py

balanced_accuracy_multilabel.py

@@ -0,0 +1,85 @@
+import numpy as np
+import evaluate
+import datasets
+
+_DESCRIPTION = """
+Multilabel Balanced Accuracy:
+For each label treat it as a binary task and compute BA = (TPR + TNR)/2, then macro-average over labels.
+Supports probability inputs (from_probas=True) with thresholding, and returns per-label BA if requested.
+"""
+
+_KWARGS_DESCRIPTION = """
+Args:
+    predictions: list[list[int or float]] of shape (N, L).
+                 If from_probas=True, values are probabilities in [0,1]; otherwise 0/1 labels.
+    references:  list[list[int]] of shape (N, L), 0/1 labels.
+    from_probas: bool, default False. If True, binarize predictions with `threshold`.
+    threshold:   float in (0,1), default 0.5.
+    zero_division: float, default 0.0. Used when denominator is 0 (no positives/negatives for a label).
+    return_per_label: bool, default False. If True, also return per-label BA list.
+Returns:
+    dict: {"balanced_accuracy": float, optional "per_label_ba": list[float]}
+"""
+
+_CITATION = ""
+
+
+def _safe_div(num, den, zero_div=0.0):
+    num = np.asarray(num, dtype=float)
+    den = np.asarray(den, dtype=float)
+    out = np.full_like(num, float(zero_div))
+    mask = den != 0
+    out[mask] = num[mask] / den[mask]
+    return out
+
+
+class BalancedAccuracyMultilabel(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.Sequence(datasets.Value("int64")),
+                }
+            ),
+        )
+
+    def _compute(
+        self,
+        predictions,
+        references,
+        from_probas: bool = False,
+        threshold: float = 0.5,
+        zero_division: float = 0.0,
+        return_per_label: bool = False,
+    ):
+        y_true = np.asarray(references, dtype=int)
+        y_pred_in = np.asarray(predictions, dtype=float)
+
+        if y_true.ndim != 2 or y_pred_in.ndim != 2:
+            raise ValueError("Multilabel expects 2D arrays of shape (N, L).")
+        if y_true.shape != y_pred_in.shape:
+            raise ValueError(f"Shape mismatch: references {y_true.shape} vs predictions {y_pred_in.shape}.")
+
+        y_pred = (y_pred_in >= threshold).astype(int) if from_probas else y_pred_in.astype(int)
+
+        L = y_true.shape[1]
+        per_label_ba = []
+        for j in range(L):
+            yt, yp = y_true[:, j], y_pred[:, j]
+            tp = float(((yt == 1) & (yp == 1)).sum())
+            fn = float(((yt == 1) & (yp == 0)).sum())
+            tn = float(((yt == 0) & (yp == 0)).sum())
+            fp = float(((yt == 0) & (yp == 1)).sum())
+            tpr = _safe_div(tp, tp + fn, zero_division)
+            tnr = _safe_div(tn, tn + fp, zero_division)
+            per_label_ba.append(0.5 * (tpr + tnr))
+
+        ba = float(np.mean(per_label_ba)) if L > 0 else float("nan")
+        out = {"balanced_accuracy": ba}
+        if return_per_label:
+            out["per_label_ba"] = per_label_ba
+        return out