Upload 2 files

balanced_accuracy.py

@@ -0,0 +1,178 @@
+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
+- support_per_class: when return_per_class=True (multiclass), also return true sample counts per class
+"""
+
+_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.
+    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. If set, samples with reference == ignore_index are skipped.
+    return_per_class: bool, default False — also return per-class recalls list (multiclass).
+    class_mask: Optional[list[int]] — only average over these classes (multiclass).
+Returns:
+    {"balanced_accuracy": float}
+    + (binary, threshold="auto"): {"optimal_threshold": float}
+    + (multiclass, return_per_class=True):
+        {"per_class_recall": list[float], "support_per_class": list[int]}
+"""
+
+_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)
+    if uniq.size == 1:
+        candidates = [float(uniq[0])]
+    else:
+        mids = (uniq[:-1] + uniq[1:]) / 2.0
+        candidates = [float(uniq[0] - 1e-12), *mids.tolist(), float(uniq[-1] + 1e-12)]
+
+    best_t, best_ba = None, -1.0
+    yt = (np.asarray(y_true) == 1).astype(int)
+    for t in candidates:
+        yp = (p >= t).astype(int)
+        ba = _binary_ba_from_labels(yt, yp, zero_div)
+        if (ba > best_ba) or (abs(ba - best_ba) < 1e-12 and (best_t is None or abs(t - 0.5) < abs(best_t - 0.5))):
+            best_ba, best_t = float(ba), float(t)
+    return best_t, 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",
+        num_classes: int | None = None,
+        adjusted: bool = False,
+        zero_division: float = 0.0,
+        threshold: float | str | None = 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 or y_pred_in.ndim != 1:
+            raise ValueError("`references`/`predictions` must be 1D.")
+
+        # ---- 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)
+                    if not (0.0 < t < 1.0):
+                        raise ValueError("`threshold` must be in (0,1) or 'auto'.")
+                    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
+        if (y_pred < 0).any() or (y_pred >= num_classes).any():
+            raise ValueError(f"`predictions` must be in [0,{num_classes-1}] for multiclass.")
+
+        classes = list(range(num_classes))
+        if class_mask:
+            classes = [c for c in class_mask if 0 <= c < num_classes]
+            if not classes:
+                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()
+            out["support_per_class"] = [int((y_true == c).sum()) for c in classes]
+        return out

balanced_accuracy_multilabel.py

@@ -11,6 +11,7 @@ Extras:
 - 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)
+- support_per_label: when return_per_label=True, also return true positive counts per label (after masking)
 """
 
 _KWARGS_DESCRIPTION = """
@@ -20,13 +21,15 @@ Args:
     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) 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).
+    zero_division: float, default 0.0.
     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.
+    ignore_index: int | None, default None.
     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], optional "per_label_thresholds": list[float]}
+    {"balanced_accuracy": float}
+    + (from_probas & threshold='auto'): {"per_label_thresholds": list[float]}
+    + (return_per_label): {"per_label_ba": list[float], "support_per_label": list[int]}
 """
 
 _CITATION = ""
@@ -55,7 +58,7 @@ def _best_threshold_per_label(y_true_col, prob_col, zero_div):
         candidates = [float(uniq[0])]
     else:
         mids = (uniq[:-1] + uniq[1:]) / 2.0
-        candidates = [uniq[0] - 1e-12] + mids.tolist() + [uniq[-1] + 1e-12]
+        candidates = [float(uniq[0] - 1e-12), *mids.tolist(), float(uniq[-1] + 1e-12)]
     best_t, best_ba = None, -1.0
     yt = (np.asarray(y_true_col) == 1).astype(int)
     for t in candidates:
@@ -65,8 +68,8 @@ def _best_threshold_per_label(y_true_col, prob_col, zero_div):
         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)
+        if (ba > best_ba) or (abs(ba - best_ba) < 1e-12 and (best_t is None or abs(t - 0.5) < abs(best_t - 0.5))):
+            best_ba, best_t = float(ba), float(t)
     return best_t, best_ba
 
 
@@ -105,8 +108,7 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
             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)
+            valid = (y_true_in != ignore_index)
         else:
             valid = np.ones_like(y_true_in, dtype=bool)
 
@@ -122,7 +124,7 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
 
         per_label_ba = []
         per_label_thr = []
-
+        # ---- compute per-label BA ----
         if from_probas and threshold == "auto":
             for j in labels:
                 vmask = valid[:, j]
@@ -147,16 +149,19 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
 
         per_label_ba = np.asarray(per_label_ba, dtype=float)
 
+        # 新增：每标签支持度（正样本数；考虑 ignore_index，有 class_mask 时按其顺序）
+        support_per_label = []
+        for j in labels:
+            vmask = valid[:, j]
+            support_per_label.append(int(y_true[vmask, j].sum()))
+
+        # ---- aggregate ----
         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)
+            weights = np.asarray(support_per_label, dtype=float)
             if weights.sum() == 0:
-                score = float(np.mean(per_label_ba))
+                score = float(np.mean(per_label_ba)) if per_label_ba.size else float("nan")
             else:
                 score = float(np.average(per_label_ba, weights=weights))
         elif average == "micro":
@@ -182,4 +187,5 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
             out["per_label_thresholds"] = [float(x) for x in per_label_thr]
         if return_per_label:
             out["per_label_ba"] = [float(x) for x in per_label_ba]
+            out["support_per_label"] = support_per_label
         return out