| 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
|
| - sample_weight: per-sample weights for binary/multiclass; replaces counts with weighted sums
|
| """
|
|
|
| _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).
|
| 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 or 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 _is_integer_like(arr, atol=1e-12):
|
| """Return True if all values are finite and very close to integers."""
|
| arr = np.asarray(arr, dtype=float)
|
| if not np.all(np.isfinite(arr)):
|
| return False
|
| return np.all(np.abs(arr - np.round(arr)) <= atol)
|
|
|
|
|
| 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())
|
| 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,
|
| sample_weight: list[float] | None = None,
|
| ):
|
| y_true_all = np.asarray(references).astype(int)
|
| y_pred_all = np.asarray(predictions)
|
|
|
|
|
| if ignore_index is not None:
|
| mask = y_true_all != ignore_index
|
| else:
|
| mask = np.ones_like(y_true_all, dtype=bool)
|
|
|
| y_true = y_true_all[mask]
|
| y_pred_in = y_pred_all[mask]
|
|
|
| if y_true.size == 0:
|
| return {"balanced_accuracy": float("nan"), "reason": "empty_after_ignore_index"}
|
|
|
|
|
| w = None
|
| if sample_weight is not None:
|
| w_in = np.asarray(sample_weight, dtype=float)
|
| if w_in.shape[0] != y_true_all.shape[0]:
|
| raise ValueError("`sample_weight` length must match number of samples.")
|
| w = w_in[mask]
|
|
|
| _check_1d_same_len(y_true, y_pred_in)
|
|
|
|
|
| if task == "binary":
|
| uniq_pred = np.unique(y_pred_in)
|
|
|
| if np.isin(uniq_pred, [0.0, 1.0]).all():
|
| y_pred = y_pred_in.astype(int)
|
|
|
| elif _is_integer_like(y_pred_in):
|
| raise ValueError("For binary with label predictions, values must be 0/1.")
|
| else:
|
| 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:
|
| 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)
|
|
|
|
|
| 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)}
|
|
|
|
|
| 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 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 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"), "reason": "empty_class_mask_after_filtering"}
|
|
|
| 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))
|
| 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"] = supports
|
| return out
|
|
|
