Delete balanced-accuracy.py

balanced-accuracy.py

@@ -1,175 +0,0 @@
-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