Upload 3 files

balanced_accuracy.py

@@ -16,6 +16,7 @@ Extras
 - 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
+- sample_weight: per-sample weights for binary/multiclass; replaces counts with weighted sums
 """
 
 _KWARGS_DESCRIPTION = """
@@ -35,11 +36,12 @@ Args:
     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).
+    sample_weight: Optional[list[float]] — per-sample weights.
 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]}
+        {"per_class_recall": list[float], "support_per_class": list[int or float]}
 """
 
 _CITATION = ""
@@ -110,16 +112,27 @@ class BalancedAccuracy(evaluate.Metric):
         ignore_index: int | None = None,
         return_per_class: bool = False,
         class_mask: list[int] | None = None,
+        sample_weight: list[float] | 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")}
+        else:
+            mask = np.ones_like(y_true, dtype=bool)
+
+        y_true = y_true[mask]
+        y_pred_in = y_pred_in[mask]
+        if y_true.size == 0:
+            return {"balanced_accuracy": float("nan")}
+
+        w = None
+        if sample_weight is not None:
+            w_in = np.asarray(sample_weight, dtype=float)
+            if w_in.shape[0] != mask.shape[0]:
+                raise ValueError("sample_weight length must match number of samples.")
+            w = w_in[mask]
 
         if y_true.ndim != 1 or y_pred_in.ndim != 1:
             raise ValueError("`references`/`predictions` must be 1D.")
@@ -141,7 +154,20 @@ class BalancedAccuracy(evaluate.Metric):
             else:
                 y_pred = y_pred_in.astype(int)
 
-            ba = _binary_ba_from_labels(y_true, y_pred, zero_division)
+            if w is None:
+                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())
+            else:
+                tp = float(w[((y_true == 1) & (y_pred == 1))].sum())
+                fn = float(w[((y_true == 1) & (y_pred == 0))].sum())
+                tn = float(w[((y_true == 0) & (y_pred == 0))].sum())
+                fp = float(w[((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
             return {"balanced_accuracy": float(ba)}
@@ -163,9 +189,20 @@ class BalancedAccuracy(evaluate.Metric):
             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)
+        recalls, supports = [], []
+        for c in classes:
+            mask_c = (y_true == c)
+            if w is None:
+                denom = float(mask_c.sum())
+                num = float((mask_c & (y_pred == c)).sum())
+                supports.append(int(denom))
+            else:
+                denom = float((w[mask_c]).sum())
+                num = float((w[mask_c & (y_pred == c)]).sum())
+                supports.append(float(denom))
+            recalls.append(float(_safe_div(num, denom, zero_division)))
+
+        recall_c = np.asarray(recalls, dtype=float)
         ba = float(recall_c.mean())
         if adjusted:
             chance = 1.0 / float(len(classes))
@@ -174,5 +211,5 @@ class BalancedAccuracy(evaluate.Metric):
         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]
+            out["support_per_class"] = supports
         return out

balanced_accuracy_multilabel.py

@@ -12,6 +12,7 @@ Extras:
 - 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)
+- sample_weight: per-sample weights; confusion counts become weighted sums for each label
 """
 
 _KWARGS_DESCRIPTION = """
@@ -26,6 +27,7 @@ Args:
     class_mask:  Optional[list[int]] — only average over these label indices.
     ignore_index: int | None, default None.
     return_per_label: bool, default False — also return per-label BA list (after masking).
+    sample_weight: Optional[list[float]] — per-sample weights.
 Returns:
     {"balanced_accuracy": float}
     + (from_probas & threshold='auto'): {"per_label_thresholds": list[float]}
@@ -98,6 +100,7 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
         class_mask: list[int] | None = None,
         ignore_index: int | None = None,
         return_per_label: bool = False,
+        sample_weight: list[float] | None = None,
     ):
         y_true_in = np.asarray(references, dtype=float)
         y_pred_in = np.asarray(predictions, dtype=float)
@@ -115,7 +118,14 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
         y_true = (y_true_in == 1).astype(int)
         probs = y_pred_in
 
-        L = y_true.shape[1]
+        N, L = y_true.shape
+        if sample_weight is not None:
+            w_in = np.asarray(sample_weight, dtype=float)
+            if w_in.shape[0] != N:
+                raise ValueError("sample_weight length must match number of samples.")
+        else:
+            w_in = None
+
         labels = list(range(L))
         if class_mask:
             labels = [j for j in class_mask if 0 <= j < L]
@@ -124,7 +134,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]
@@ -141,29 +151,33 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
             for j in labels:
                 vmask = valid[:, j]
                 yt, yp = y_true[vmask, j], y_pred[vmask, 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())
+                if w_in is None:
+                    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())
+                else:
+                    wv = w_in[vmask]
+                    tp = float(wv[((yt == 1) & (yp == 1))].sum())
+                    fn = float(wv[((yt == 1) & (yp == 0))].sum())
+                    tn = float(wv[((yt == 0) & (yp == 0))].sum())
+                    fp = float(wv[((yt == 0) & (yp == 1))].sum())
                 per_label_ba.append(float(_binary_ba(tp, fn, tn, fp, zero_division)))
 
         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 = np.asarray(support_per_label, dtype=float)
-            if weights.sum() == 0:
-                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))
+            score = float(np.average(per_label_ba, weights=weights)) if weights.sum() > 0 else (
+                float(np.mean(per_label_ba)) if per_label_ba.size else float("nan")
+            )
         elif average == "micro":
             TP = FP = TN = FN = 0.0
             for j in labels:
@@ -174,10 +188,17 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
                     yp = (probs[vmask, j] >= t).astype(int)
                 else:
                     yp = y_pred[vmask, j] if 'y_pred' in locals() else (probs[vmask, j] >= 0.5).astype(int)
-                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())
+                if w_in is None:
+                    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())
+                else:
+                    wv = w_in[vmask]
+                    TP += float(wv[((yt == 1) & (yp == 1))].sum())
+                    FN += float(wv[((yt == 1) & (yp == 0))].sum())
+                    TN += float(wv[((yt == 0) & (yp == 0))].sum())
+                    FP += float(wv[((yt == 0) & (yp == 1))].sum())
             score = float(_binary_ba(TP, FN, TN, FP, zero_division))
         else:
             raise ValueError("average must be one of {'macro','weighted','micro'}.")

balanced_topk_accuracy.py

@@ -6,6 +6,8 @@ _DESCRIPTION = """
 Balanced (macro) Top-K Accuracy for multiclass classification.
 For each class c, compute recall@k (fraction of samples of class c whose top-k predictions contain c),
 then macro-average over classes. Accepts (N, K) score/prob arrays.
+
+Supports sample_weight to compute weighted recalls per class.
 """
 
 _KWARGS_DESCRIPTION = """
@@ -15,6 +17,7 @@ Args:
     k:           int, top-k (default 1). If None, use k_list instead.
     k_list:      Optional[list[int]] to compute multiple ks at once (e.g., [1,5]).
     class_mask:  Optional[list[int]] — only average over these classes (e.g., tail classes).
+    sample_weight: Optional[list[float]] — per-sample weights.
     zero_division: float, default 0.0. Used when a class has no positive samples.
     return_per_class: bool, default False. If True, also return per-class recalls@k.
 Returns:
@@ -25,6 +28,10 @@ Returns:
 _CITATION = ""
 
 
+def _div(a, b, zero_div=0.0):
+    return (a / b) if b != 0 else float(zero_div)
+
+
 class BalancedTopKAccuracy(evaluate.Metric):
     def _info(self):
         return evaluate.MetricInfo(
@@ -32,10 +39,8 @@ class BalancedTopKAccuracy(evaluate.Metric):
             citation=_CITATION,
             inputs_description=_KWARGS_DESCRIPTION,
             features=datasets.Features(
-                {
-                    "predictions": datasets.Sequence(datasets.Value("float64")),
-                    "references": datasets.Value("int64"),
-                }
+                {"predictions": datasets.Sequence(datasets.Value("float64")),
+                 "references":  datasets.Value("int64")}
             ),
         )
 
@@ -46,6 +51,7 @@ class BalancedTopKAccuracy(evaluate.Metric):
         k: int | None = 1,
         k_list: list[int] | None = None,
         class_mask: list[int] | None = None,
+        sample_weight: list[float] | None = None,
         zero_division: float = 0.0,
         return_per_class: bool = False,
     ):
@@ -60,6 +66,12 @@ class BalancedTopKAccuracy(evaluate.Metric):
         if (y_true < 0).any() or (y_true >= K).any():
             raise ValueError(f"references must be within [0, {K-1}] for given predictions shape (N, {K}).")
 
+        w = None
+        if sample_weight is not None:
+            w = np.asarray(sample_weight, dtype=float)
+            if w.shape[0] != N:
+                raise ValueError("sample_weight length must match number of samples.")
+
         ks_in = k_list if k_list is not None else [k if k is not None else 1]
         ks = sorted(set(int(x) for x in ks_in if x is not None and int(x) >= 1))
         if not ks:
@@ -82,13 +94,14 @@ class BalancedTopKAccuracy(evaluate.Metric):
             topk = sorted_idx[:, :kk]
             recalls = []
             for c in classes:
-                mask = (y_true == c)
-                denom = int(mask.sum())
+                mask_c = (y_true == c)
+                denom = float(w[mask_c].sum()) if w is not None else float(mask_c.sum())
                 if denom == 0:
                     recalls.append(float(zero_division))
                     continue
-                hits = int(np.any(topk[mask] == c, axis=1).sum())
-                recalls.append(hits / denom)
+                hit_mask = np.any(topk[mask_c] == c, axis=1)
+                hits = float(w[mask_c][hit_mask].sum()) if w is not None else float(hit_mask.sum())
+                recalls.append(_div(hits, denom, zero_division))
 
             ba_k = float(np.mean(recalls))
             results[kk] = ba_k