Upload 3 files

balanced_accuracy.py

@@ -30,9 +30,6 @@ Args:
     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).
@@ -56,6 +53,15 @@ def _safe_div(num, den, zero_div=0.0):
     return out
 
 
+def _check_1d_same_len(y_true, y_pred, name_true="references", name_pred="predictions"):
+    if y_true.ndim != 1 or y_pred.ndim != 1:
+        raise ValueError(f"`{name_true}` and `{name_pred}` must be 1D.")
+    if y_true.shape[0] != y_pred.shape[0]:
+        raise ValueError(f"Length mismatch: `{name_true}`={y_true.shape[0]} vs `{name_pred}`={y_pred.shape[0]}.")
+    if not np.all(np.isfinite(y_pred)):
+        raise ValueError("`predictions` contains NaN/Inf.")
+
+
 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())
@@ -114,33 +120,39 @@ class BalancedAccuracy(evaluate.Metric):
         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)
+        y_true_all = np.asarray(references).astype(int)
+        y_pred_all = np.asarray(predictions)
 
+        # ignore_index mask
         if ignore_index is not None:
-            mask = y_true != ignore_index
+            mask = y_true_all != ignore_index
         else:
-            mask = np.ones_like(y_true, dtype=bool)
+            mask = np.ones_like(y_true_all, dtype=bool)
+
+        y_true = y_true_all[mask]
+        y_pred_in = y_pred_all[mask]
 
-        y_true = y_true[mask]
-        y_pred_in = y_pred_in[mask]
         if y_true.size == 0:
-            return {"balanced_accuracy": float("nan")}
+            return {"balanced_accuracy": float("nan"), "reason": "empty_after_ignore_index"}
 
+        # weights
         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.")
+            if w_in.shape[0] != y_true_all.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.")
+        _check_1d_same_len(y_true, y_pred_in)
 
         # ---- Binary ----
         if task == "binary":
-            is_prob_like = not np.isin(np.unique(y_pred_in), [0.0, 1.0]).all()
+            # if labels given, must be {0,1}
+            uniq_pred = np.unique(y_pred_in)
+            is_prob_like = not np.isin(uniq_pred, [0.0, 1.0]).all()
             if is_prob_like:
+                if np.any((y_pred_in < 0) | (y_pred_in > 1)):
+                    raise ValueError("For binary with probabilities, `predictions` must be in [0,1].")
                 if threshold == "auto":
                     t_opt, ba = _binary_find_best_threshold(y_true, y_pred_in, zero_division)
                     if adjusted:
@@ -152,8 +164,12 @@ class BalancedAccuracy(evaluate.Metric):
                         raise ValueError("`threshold` must be in (0,1) or 'auto'.")
                     y_pred = (y_pred_in >= t).astype(int)
             else:
+                # labels mode: enforce {0,1}
+                if not np.isin(uniq_pred, [0, 1]).all():
+                    raise ValueError("For binary with label predictions, values must be 0/1.")
                 y_pred = y_pred_in.astype(int)
 
+            # weighted confusion
             if w is None:
                 tp = float(((y_true == 1) & (y_pred == 1)).sum())
                 fn = float(((y_true == 1) & (y_pred == 0)).sum())
@@ -177,17 +193,22 @@ class BalancedAccuracy(evaluate.Metric):
             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 num_classes <= 0:
+            raise ValueError("`num_classes` must be positive.")
         if (y_pred < 0).any() or (y_pred >= num_classes).any():
             raise ValueError(f"`predictions` must be in [0,{num_classes-1}] for multiclass.")
+        if (y_true < 0).any() or (y_true >= num_classes).any():
+            raise ValueError(f"`references` must be in [0,{num_classes-1}] for multiclass.")
 
         classes = list(range(num_classes))
-        if class_mask:
+        if class_mask is not None and len(class_mask) > 0:
             classes = [c for c in class_mask if 0 <= c < num_classes]
-            if not classes:
-                return {"balanced_accuracy": float("nan")}
+            if len(classes) == 0:
+                return {"balanced_accuracy": float("nan"), "reason": "empty_class_mask_after_filtering"}
 
         recalls, supports = [], []
         for c in classes:

balanced_accuracy_multilabel.py

@@ -20,18 +20,14 @@ Args:
     predictions: list[list[int or float]] of shape (N, L).
                  If from_probas=True, values are probabilities in [0,1]; otherwise 0/1 labels.
     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`.
+    from_probas: bool, default False.
     threshold:   float in (0,1) or 'auto' (per-label). Default 0.5 if from_probas=True.
     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.
-    return_per_label: bool, default False — also return per-label BA list (after masking).
+    return_per_label: bool, default False.
     sample_weight: Optional[list[float]] — per-sample weights.
-Returns:
-    {"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 = ""
@@ -53,7 +49,6 @@ def _binary_ba(tp, fn, tn, fp, zero_div):
 
 
 def _best_threshold_per_label(y_true_col, prob_col, zero_div):
-    """Return (t_opt, ba_opt) using Youden's J for a single label."""
     p = np.asarray(prob_col, dtype=float)
     uniq = np.unique(p)
     if uniq.size == 1:
@@ -105,11 +100,17 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
         y_true_in = np.asarray(references, dtype=float)
         y_pred_in = np.asarray(predictions, dtype=float)
 
+        # basic checks
         if y_true_in.ndim != 2 or y_pred_in.ndim != 2:
             raise ValueError("Multilabel expects 2D arrays of shape (N, L).")
         if y_true_in.shape != y_pred_in.shape:
             raise ValueError(f"Shape mismatch: references {y_true_in.shape} vs predictions {y_pred_in.shape}.")
+        if not np.all(np.isfinite(y_pred_in)):
+            raise ValueError("`predictions` contains NaN/Inf.")
+        if average not in {"macro", "weighted", "micro"}:
+            raise ValueError("`average` must be one of {'macro','weighted','micro'}.")
 
+        # validity mask
         if ignore_index is not None:
             valid = (y_true_in != ignore_index)
         else:
@@ -119,10 +120,11 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
         probs = y_pred_in
 
         N, L = y_true.shape
+        # weights
         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.")
+                raise ValueError("`sample_weight` length must match number of samples.")
         else:
             w_in = None
 
@@ -130,10 +132,26 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
         if class_mask:
             labels = [j for j in class_mask if 0 <= j < L]
             if not labels:
-                return {"balanced_accuracy": float("nan")}
+                return {"balanced_accuracy": float("nan"), "reason": "empty_class_mask_after_filtering"}
 
-        per_label_ba = []
-        per_label_thr = []
+        # input value checks
+        if from_probas:
+            if threshold != "auto":
+                thr = 0.5 if threshold is None else float(threshold)
+                if not (0.0 < thr < 1.0):
+                    raise ValueError("`threshold` must be in (0,1) or 'auto' when from_probas=True.")
+            if np.any((probs < 0) | (probs > 1)):
+                raise ValueError("When from_probas=True, `predictions` must be in [0,1].")
+        else:
+            uniq = np.unique(probs[valid])
+            if not np.isin(uniq, [0.0, 1.0]).all():
+                raise ValueError("When from_probas=False, `predictions` must be 0/1 labels.")
+
+        # if everything invalid after ignore_index:
+        if not np.any(valid):
+            return {"balanced_accuracy": float("nan"), "reason": "empty_after_ignore_index"}
+
+        per_label_ba, per_label_thr = [], []
 
         if from_probas and threshold == "auto":
             for j in labels:
@@ -142,12 +160,7 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
                 per_label_ba.append(float(ba_opt))
                 per_label_thr.append(float(t_opt))
         else:
-            if from_probas:
-                thr = 0.5 if threshold is None else float(threshold)
-                y_pred = (probs >= thr).astype(int)
-            else:
-                y_pred = probs.astype(int)
-
+            y_pred = (probs >= thr).astype(int) if from_probas else probs.astype(int)
             for j in labels:
                 vmask = valid[:, j]
                 yt, yp = y_true[vmask, j], y_pred[vmask, j]
@@ -178,7 +191,7 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
             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":
+        else:  # micro
             TP = FP = TN = FN = 0.0
             for j in labels:
                 vmask = valid[:, j]
@@ -200,8 +213,6 @@ class BalancedAccuracyMultilabel(evaluate.Metric):
                     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'}.")
 
         out = {"balanced_accuracy": score}
         if from_probas and threshold == "auto":

balanced_topk_accuracy.py

@@ -18,11 +18,8 @@ Args:
     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.
+    zero_division: float, default 0.0.
     return_per_class: bool, default False. If True, also return per-class recalls@k.
-Returns:
-    dict with {"balanced_topk_accuracy": float or dict[int,float]}.
-    If k_list provided, returns a dict mapping k -> score. Optionally adds "per_class_recall".
 """
 
 _CITATION = ""
@@ -59,23 +56,25 @@ class BalancedTopKAccuracy(evaluate.Metric):
         scores = np.asarray(predictions, dtype=float)
 
         if scores.ndim != 2 or y_true.ndim != 1:
-            raise ValueError("predictions must be (N, K) scores; references must be 1D labels.")
+            raise ValueError("`predictions` must be (N, K) scores; `references` must be 1D labels.")
         N, K = scores.shape
         if y_true.shape[0] != N:
-            raise ValueError(f"Shape mismatch: references length {y_true.shape[0]} vs predictions {N}.")
+            raise ValueError(f"Length mismatch: references {y_true.shape[0]} vs predictions {N}.")
+        if not np.all(np.isfinite(scores)):
+            raise ValueError("`predictions` contains NaN/Inf.")
         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}).")
+            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.")
+                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:
-            raise ValueError("Provide a positive integer k or a non-empty k_list.")
+            raise ValueError("Provide a positive integer `k` or a non-empty `k_list`.")
         ks = [min(kk, K) for kk in ks]
 
         if class_mask is None or len(class_mask) == 0:
@@ -83,7 +82,7 @@ class BalancedTopKAccuracy(evaluate.Metric):
         else:
             classes = [c for c in class_mask if 0 <= c < K]
             if not classes:
-                return {"balanced_topk_accuracy": float("nan")}
+                return {"balanced_topk_accuracy": float("nan"), "reason": "empty_class_mask_after_filtering"}
 
         sorted_idx = np.argsort(-scores, axis=1)
 
@@ -103,7 +102,7 @@ class BalancedTopKAccuracy(evaluate.Metric):
                 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))
+            ba_k = float(np.mean(recalls)) if recalls else float("nan")
             results[kk] = ba_k
             if return_per_class:
                 per_class[kk] = [float(x) for x in recalls]