Upload balanced_accuracy.py

balanced_accuracy.py

@@ -9,28 +9,34 @@ Definitions
 - Binary: (TPR + TNR) / 2
 - Multiclass: macro-average of per-class recall
 
-Quality-of-life
-- from_probas=True: accept probabilities/logits directly (binary threshold or multiclass argmax)
+Extras
+- threshold="auto": pick the best threshold for binary probabilities (Youden's J)
 - ignore_index: skip unlabeled samples (e.g., -100)
 - adjusted=True: sklearn-style chance correction
+- return_per_class=True: also return per-class recalls (multiclass)
+- class_mask=[...] (multiclass): average over a subset of classes
 """
 
 _KWARGS_DESCRIPTION = """
 Args:
-    predictions: 1D list/array. Integer labels by default; if from_probas=True, pass probabilities/logits.
-                 - binary: list[0/1] or list[float] (prob for positive class)
-                 - multiclass: list[int class_id] or 2D array-like of shape (N, K) with class scores/probs
+    predictions: 1D list/array.
+        Binary: integer labels {0,1}, or probabilities in [0,1] (if threshold given)
+        Multiclass: integer labels {0..K-1}
     references:  1D list/array of integer labels.
-    task:        "binary" | "multiclass". (Default: "binary")
-    num_classes: int, required for multiclass if labels are not 0..K-1 (optional if from_probas=True and scores provided).
+    task:        "binary" | "multiclass" (Default: "binary")
+    num_classes: int, for multiclass; inferred if labels are 0..K-1.
     adjusted:    bool, default False. (binary: 2*BA-1; multiclass: (BA-1/K)/(1-1/K))
-    zero_division: float, default 0.0. Value used when a denominator is 0 (e.g., no positives for a class).
-    from_probas: bool, default False. If True, `predictions` will be interpreted as probabilities/logits.
-    threshold:   float, default 0.5. Binary threshold when from_probas=True and predictions are 1D.
-    proba_pos_index: int, default 1. If binary and predictions are 2D scores with shape (N, 2), which column is positive.
-    ignore_index: int | None, default None. If set, samples whose reference == ignore_index will be skipped.
+    zero_division: float, default 0.0. Value used when a denominator is 0.
+    threshold:   float in (0,1) or "auto" (binary only).
+                 - float: binarize probs via (prob >= threshold)
+                 - "auto": choose threshold maximizing BA on given data (Youden's J)
+                 - if None: treat `predictions` as 0/1 labels (no binarization)
+    ignore_index: int | None, default None. If set, samples with reference == ignore_index are skipped.
+    return_per_class: bool, default False (multiclass) — also return per-class recalls list.
+    class_mask: Optional[list[int]] — only average over these classes (multiclass).
 Returns:
-    dict: {"balanced_accuracy": float}
+    dict with at least {"balanced_accuracy": float}. If threshold="auto" (binary) adds {"optimal_threshold": float}.
+    If return_per_class=True (multiclass) adds {"per_class_recall": list[float]}.
 """
 
 _CITATION = ""
@@ -45,26 +51,33 @@ def _safe_div(num, den, zero_div=0.0):
     return out
 
 
-def _to_int_labels_binary(y_pred, from_probas: bool, threshold: float, proba_pos_index: int):
-    y_pred = np.asarray(y_pred)
-    if from_probas:
-        if y_pred.ndim == 1:
-            return (y_pred >= threshold).astype(int)
-        if y_pred.ndim == 2:
-            if y_pred.shape[1] == 2:
-                return (y_pred[:, proba_pos_index] >= threshold).astype(int)
-            return np.argmax(y_pred, axis=1).astype(int)
-        raise ValueError("Binary from_probas expects 1D (prob) or 2D (scores) predictions.")
-    return y_pred.astype(int)
+def _binary_ba_from_labels(y_true_i, y_pred_i, zero_div):
+    tp = float(((y_true_i == 1) & (y_pred_i == 1)).sum())
+    fn = float(((y_true_i == 1) & (y_pred_i == 0)).sum())
+    tn = float(((y_true_i == 0) & (y_pred_i == 0)).sum())
+    fp = float(((y_true_i == 0) & (y_pred_i == 1)).sum())
+    tpr = _safe_div(tp, tp + fn, zero_div)
+    tnr = _safe_div(tn, tn + fp, zero_div)
+    return 0.5 * (tpr + tnr)
 
 
-def _to_int_labels_multiclass(y_pred, from_probas: bool):
-    y_pred = np.asarray(y_pred)
-    if from_probas:
-        if y_pred.ndim != 2:
-            raise ValueError("Multiclass with from_probas=True expects 2D scores/probs of shape (N, K).")
-        return np.argmax(y_pred, axis=1).astype(int)
-    return y_pred.astype(int)
+def _binary_find_best_threshold(y_true, probs, zero_div):
+    p = np.asarray(probs, dtype=float)
+    uniq = np.unique(p)
+    candidates = []
+    if uniq.size == 1:
+        candidates = [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
+    for t in candidates:
+        y_pred = (p >= t).astype(int)
+        ba = _binary_ba_from_labels(y_true, y_pred, zero_div)
+        if ba > best_ba or (abs(ba - best_ba) < 1e-12 and abs(t - 0.5) < abs(best_t - 0.5)):
+            best_ba, best_t = ba, t
+    return float(best_t), float(best_ba)
 
 
 class BalancedAccuracy(evaluate.Metric):
@@ -92,56 +105,71 @@ class BalancedAccuracy(evaluate.Metric):
         num_classes: int | None = None,
         adjusted: bool = False,
         zero_division: float = 0.0,
-        from_probas: bool = False,
-        threshold: float = 0.5,
-        proba_pos_index: int = 1,
+        threshold: float | str | None = None,  # binary only: float or "auto" or None
         ignore_index: int | None = None,
+        return_per_class: bool = False,
+        class_mask: list[int] | None = None,
     ):
-        y_true = np.asarray(references)
-        y_pred_raw = np.asarray(predictions)
+        y_true = np.asarray(references).astype(int)
+        y_pred_in = np.asarray(predictions)
 
         if ignore_index is not None:
             mask = y_true != ignore_index
             y_true = y_true[mask]
-            y_pred_raw = y_pred_raw[mask]
+            y_pred_in = y_pred_in[mask]
             if y_true.size == 0:
                 return {"balanced_accuracy": float("nan")}
 
         if y_true.ndim != 1:
             raise ValueError("`references` must be 1D integer labels, e.g., [0,1,1,0].")
+        if y_pred_in.ndim != 1:
+            raise ValueError("`predictions` must be 1D labels or probabilities (for binary).")
 
+        # ---- Binary ----
         if task == "binary":
-            y_pred = _to_int_labels_binary(y_pred_raw, from_probas, threshold, proba_pos_index)
-            y_true = y_true.astype(int)
-
-            tp = float(((y_true == 1) & (y_pred == 1)).sum())
-            fn = float(((y_true == 1) & (y_pred == 0)).sum())
-            tn = float(((y_true == 0) & (y_pred == 0)).sum())
-            fp = float(((y_true == 0) & (y_pred == 1)).sum())
-            tpr = _safe_div(tp, tp + fn, zero_division)
-            tnr = _safe_div(tn, tn + fp, zero_division)
-            ba = 0.5 * (tpr + tnr)
+            is_prob_like = not np.isin(np.unique(y_pred_in), [0.0, 1.0]).all()
+
+            if is_prob_like:
+                if threshold == "auto":
+                    t_opt, ba = _binary_find_best_threshold(y_true, y_pred_in, zero_division)
+                    if adjusted:
+                        ba = 2 * ba - 1
+                    return {"balanced_accuracy": float(ba), "optimal_threshold": float(t_opt)}
+                else:
+                    t = 0.5 if (threshold is None) else float(threshold)
+                    y_pred = (y_pred_in >= t).astype(int)
+            else:
+                y_pred = y_pred_in.astype(int)
+
+            ba = _binary_ba_from_labels(y_true, y_pred, zero_division)
             if adjusted:
-                ba = 2 * ba - 1  # (BA - 0.5)/0.5
+                ba = 2 * ba - 1
             return {"balanced_accuracy": float(ba)}
 
-        if task == "multiclass":
-            y_pred = _to_int_labels_multiclass(y_pred_raw, from_probas)
-            y_true = y_true.astype(int)
+        # ---- Multiclass ----
+        if task != "multiclass":
+            raise ValueError("`task` must be 'binary' or 'multiclass'.")
 
-            if num_classes is None:
-                if from_probas and y_pred_raw.ndim == 2:
-                    num_classes = y_pred_raw.shape[1]
-                else:
-                    num_classes = int(max(y_true.max(), y_pred.max())) + 1
+        y_pred = y_pred_in.astype(int)
+        if num_classes is None:
+            num_classes = int(max(y_true.max() if y_true.size else 0, y_pred.max() if y_pred.size else 0)) + 1
 
-            tp = np.array([(y_pred[y_true == c] == c).sum() for c in range(num_classes)], dtype=float)
-            fn = np.array([(y_pred[y_true == c] != c).sum() for c in range(num_classes)], dtype=float)
-            recall_c = _safe_div(tp, tp + fn, zero_division)
-            ba = float(recall_c.mean())
-            if adjusted:
-                chance = 1.0 / float(num_classes)
-                ba = float((ba - chance) / (1.0 - chance))
-            return {"balanced_accuracy": ba}
+        classes = list(range(num_classes))
+        if class_mask is not None and len(class_mask) > 0:
+            classes = [c for c in class_mask if 0 <= c < num_classes]
+            if len(classes) == 0:
+                return {"balanced_accuracy": float("nan")}
+
+        tp = np.array([(y_pred[y_true == c] == c).sum() for c in classes], dtype=float)
+        fn = np.array([(y_pred[y_true == c] != c).sum() for c in classes], dtype=float)
+        recall_c = _safe_div(tp, tp + fn, zero_division)
+        ba = float(recall_c.mean())
+
+        if adjusted:
+            chance = 1.0 / float(len(classes))
+            ba = float((ba - chance) / (1.0 - chance))
 
-        raise ValueError("`task` must be 'binary' or 'multiclass'.")
+        out = {"balanced_accuracy": ba}
+        if return_per_class:
+            out["per_class_recall"] = recall_c.tolist()
+        return out