Delete balanced-accuracy.py

balanced-accuracy.py

@@ -1,77 +0,0 @@
-# Balanced Accuracy metric (binary / multiclass / multilabel) for 🤗 Evaluate
-import numpy as np
-from evaluate import Metric
-
-
-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, fill_value=float(zero_div))
-    mask = den != 0
-    out[mask] = num[mask] / den[mask]
-    return out
-
-
-class BalancedAccuracy(Metric):
-    def _info(self):
-        return self._metric_info_from_module(
-            description=(
-                "Balanced Accuracy for imbalanced classification.\n"
-                "Binary: (TPR + TNR) / 2.\n"
-                "Multiclass: macro-average of per-class recall.\n"
-                "Multilabel: macro-average of per-label BA."
-            )
-        )
-
-    def _compute(
-        self,
-        predictions,
-        references,
-        task: str = "binary",         # "binary" | "multiclass" | "multilabel"
-        num_classes: int | None = None,
-        adjusted: bool = False,      
-        zero_division: float = 0.0,  
-    ):
-        y_true = np.asarray(references)
-        y_pred = np.asarray(predictions)
-
-        if task == "binary":
-            # 约定标签 {0,1}
-            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)
-            if adjusted:
-                ba = 2 * ba - 1  # (BA - 0.5)/0.5
-            return {"balanced_accuracy": float(ba)}
-
-        if task == "multiclass":
-            if num_classes is None:
-                num_classes = int(max(y_true.max(), y_pred.max())) + 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)  # per-class recall
-            ba = float(recall_c.mean())
-            if adjusted:
-                chance = 1.0 / float(num_classes)
-                ba = float((ba - chance) / (1.0 - chance))
-            return {"balanced_accuracy": ba}
-
-        # multilabel: y_true/y_pred shape: (N, L) with {0,1}
-        if y_true.ndim != 2:
-            raise ValueError("For task='multilabel', y_true/y_pred must be 2D arrays of shape (N, L).")
-        L = y_true.shape[1]
-        per_label = []
-        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.append(0.5 * (tpr + tnr))
-        return {"balanced_accuracy": float(np.mean(per_label))}