Upload balanced-accuracy.py

balanced-accuracy.py

@@ -1 +1,175 @@
-from balanced_accuracy import *  # re-export for remote one-liner
+import numpy as np
+import evaluate
+import datasets
+
+_DESCRIPTION = """
+Balanced Accuracy for imbalanced classification.
+
+Definitions
+- Binary: (TPR + TNR) / 2
+- Multiclass: macro-average of per-class recall
+
+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.
+        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, 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.
+    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 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 = ""
+
+
+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
+
+
+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 _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):
+    def _info(self):
+        return evaluate.MetricInfo(
+            description=_DESCRIPTION,
+            citation=_CITATION,
+            inputs_description=_KWARGS_DESCRIPTION,
+            features=datasets.Features(
+                {
+                    "predictions": datasets.Value("float64"),
+                    "references": datasets.Value("float64"),
+                }
+            ),
+            reference_urls=[
+                "https://scikit-learn.org/stable/modules/generated/sklearn.metrics.balanced_accuracy_score.html"
+            ],
+        )
+
+    def _compute(
+        self,
+        predictions,
+        references,
+        task: str = "binary",         # "binary" | "multiclass"
+        num_classes: int | None = None,
+        adjusted: bool = False,
+        zero_division: float = 0.0,
+        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).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_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":
+            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
+            return {"balanced_accuracy": float(ba)}
+
+        # ---- Multiclass ----
+        if task != "multiclass":
+            raise ValueError("`task` must be 'binary' or 'multiclass'.")
+
+        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
+
+        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))
+
+        out = {"balanced_accuracy": ba}
+        if return_per_class:
+            out["per_class_recall"] = recall_c.tolist()
+        return out