Upload balanced_accuracy_multilabel.py

balanced_accuracy_multilabel.py

@@ -4,21 +4,29 @@ 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.
+Treat each label as a binary task and compute BA = (TPR + TNR)/2, then average over labels.
+
+Extras:
+- average={'macro','weighted','micro'} (default: macro)
+- threshold='auto' (per-label Youden's J) or float in (0,1)
+- class_mask=[...] (evaluate a subset of labels)
+- ignore_index to skip unlabeled samples (e.g., -100)
 """
 
 _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.
+    references:  list[list[int or float]] of shape (N, L). 0/1 labels; ignore_index is allowed.
     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.
+    threshold:   float in (0,1) or 'auto' (per-label). Default 0.5 if from_probas=True.
+    zero_division: float, default 0.0. Used when denominator is 0 (no positives/negatives).
+    average:     'macro'|'weighted'|'micro', default 'macro'.
+    class_mask:  Optional[list[int]] — only average over these label indices.
+    ignore_index: int | None, default None. If set, samples with reference==ignore_index are skipped.
+    return_per_label: bool, default False — also return per-label BA list (after masking).
 Returns:
-    dict: {"balanced_accuracy": float, optional "per_label_ba": list[float]}
+    dict: {"balanced_accuracy": float, optional "per_label_ba": list[float], optional "per_label_thresholds": list[float]}
 """
 
 _CITATION = ""
@@ -33,6 +41,35 @@ def _safe_div(num, den, zero_div=0.0):
     return out
 
 
+def _binary_ba(tp, fn, tn, fp, zero_div):
+    tpr = _safe_div(tp, tp + fn, zero_div)
+    tnr = _safe_div(tn, tn + fp, zero_div)
+    return 0.5 * (tpr + tnr)
+
+
+def _best_threshold_per_label(y_true_col, prob_col, zero_div):
+    """Return (t_opt, ba_opt) using Youden's J for a single label."""
+    p = np.asarray(prob_col, dtype=float)
+    uniq = np.unique(p)
+    if uniq.size == 1:
+        candidates = [float(uniq[0])]
+    else:
+        mids = (uniq[:-1] + uniq[1:]) / 2.0
+        candidates = [uniq[0] - 1e-12] + mids.tolist() + [uniq[-1] + 1e-12]
+    best_t, best_ba = None, -1.0
+    yt = (np.asarray(y_true_col) == 1).astype(int)
+    for t in candidates:
+        yp = (p >= t).astype(int)
+        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())
+        ba = _binary_ba(tp, fn, tn, fp, zero_div)
+        if ba > best_ba or (abs(ba - best_ba) < 1e-12 and abs(t - 0.5) < abs((best_t or 0.5) - 0.5)):
+            best_ba, best_t = ba, float(t)
+    return best_t, best_ba
+
+
 class BalancedAccuracyMultilabel(evaluate.Metric):
     def _info(self):
         return evaluate.MetricInfo(
@@ -42,7 +79,7 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
             features=datasets.Features(
                 {
                     "predictions": datasets.Sequence(datasets.Value("float64")),
-                    "references": datasets.Sequence(datasets.Value("int64")),
+                    "references":  datasets.Sequence(datasets.Value("float64")),
                 }
             ),
         )
@@ -52,34 +89,97 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
         predictions,
         references,
         from_probas: bool = False,
-        threshold: float = 0.5,
+        threshold: float | str = 0.5,
         zero_division: float = 0.0,
+        average: str = "macro",
+        class_mask: list[int] | None = None,
+        ignore_index: int | None = None,
         return_per_label: bool = False,
     ):
-        y_true = np.asarray(references, dtype=int)
+        y_true_in = np.asarray(references, dtype=float)
         y_pred_in = np.asarray(predictions, dtype=float)
 
-        if y_true.ndim != 2 or y_pred_in.ndim != 2:
+        if y_true_in.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}.")
+        if y_true_in.shape != y_pred_in.shape:
+            raise ValueError(f"Shape mismatch: references {y_true_in.shape} vs predictions {y_pred_in.shape}.")
+
+        if ignore_index is not None:
+            mask = (y_true_in != ignore_index)
+            valid = mask.astype(bool)
+        else:
+            valid = np.ones_like(y_true_in, dtype=bool)
 
-        y_pred = (y_pred_in >= threshold).astype(int) if from_probas else y_pred_in.astype(int)
+        y_true = (y_true_in == 1).astype(int)
+        probs = y_pred_in
 
         L = y_true.shape[1]
+        labels = list(range(L))
+        if class_mask:
+            labels = [j for j in class_mask if 0 <= j < L]
+            if not labels:
+                return {"balanced_accuracy": float("nan")}
+
         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}
+        per_label_thr = []
+
+        if from_probas and threshold == "auto":
+            for j in labels:
+                vmask = valid[:, j]
+                t_opt, ba_opt = _best_threshold_per_label(y_true[vmask, j], probs[vmask, j], zero_division)
+                per_label_ba.append(float(ba_opt))
+                per_label_thr.append(float(t_opt))
+        else:
+            if from_probas:
+                thr = 0.5 if threshold is None else float(threshold)
+                y_pred = (probs >= thr).astype(int)
+            else:
+                y_pred = probs.astype(int)
+
+            for j in labels:
+                vmask = valid[:, j]
+                yt, yp = y_true[vmask, j], y_pred[vmask, 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())
+                per_label_ba.append(float(_binary_ba(tp, fn, tn, fp, zero_division)))
+
+        per_label_ba = np.asarray(per_label_ba, dtype=float)
+
+        if average == "macro":
+            score = float(np.mean(per_label_ba)) if per_label_ba.size else float("nan")
+        elif average == "weighted":
+            weights = []
+            for j in labels:
+                vmask = valid[:, j]
+                weights.append(int(y_true[vmask, j].sum()))
+            weights = np.asarray(weights, dtype=float)
+            if weights.sum() == 0:
+                score = float(np.mean(per_label_ba))
+            else:
+                score = float(np.average(per_label_ba, weights=weights))
+        elif average == "micro":
+            TP = FP = TN = FN = 0.0
+            for j in labels:
+                vmask = valid[:, j]
+                yt = y_true[vmask, j]
+                if from_probas and threshold == "auto":
+                    t = per_label_thr[labels.index(j)]
+                    yp = (probs[vmask, j] >= t).astype(int)
+                else:
+                    yp = y_pred[vmask, j] if 'y_pred' in locals() else (probs[vmask, j] >= 0.5).astype(int)
+                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())
+            score = float(_binary_ba(TP, FN, TN, FP, zero_division))
+        else:
+            raise ValueError("average must be one of {'macro','weighted','micro'}.")
+
+        out = {"balanced_accuracy": score}
+        if from_probas and threshold == "auto":
+            out["per_label_thresholds"] = [float(x) for x in per_label_thr]
         if return_per_label:
-            out["per_label_ba"] = per_label_ba
+            out["per_label_ba"] = [float(x) for x in per_label_ba]
         return out