README.md

# Balanced Accuracy Metrics for 🤗 Evaluate

A minimal, production-ready set of **balanced accuracy** metrics for imbalanced vision/NLP tasks, implemented as plain Python scripts that you can load with `evaluate` from a **dataset-type** repo on the Hugging Face Hub.

> **What this is**
>
> Three drop‑in metrics that focus on fair evaluation under class imbalance:
>
> - `balanced_accuracy.py` — **binary & multiclass** balanced accuracy with options for `sample_weight`, `threshold="auto"` (Youden’s J), `ignore_index`, `adjusted`, `class_mask`, `return_per_class`, and `support_per_class`.
> - `balanced_accuracy_multilabel.py` — **multilabel** balanced accuracy with `average={"macro","weighted","micro"}`, `threshold="auto"` (per label), `sample_weight`, `class_mask`, `ignore_index`, and `support_per_label`.
> - `balanced_topk_accuracy.py` — **balanced top‑k accuracy** (macro top‑k recall across classes) with `sample_weight`, multiple `k` values, and class masking.
>
> **Why it’s useful**
>
> - Works without packaging: just download the script and load via `evaluate`.
> - Designed for long‑tail / imbalanced setups; supports masking, weighting, and chance‑adjustment.
> - Clear error messages and `reason` fields for edge cases.

---

## Requirements & Installation

Install the minimal dependencies (Python ≥3.9 recommended):

```bash
pip install --upgrade pip
pip install evaluate datasets huggingface_hub numpy
```

> **Windows note**: You may see a symlink warning from `huggingface_hub`. It only affects caching and can be ignored. To silence it, set `HF_HUB_DISABLE_SYMLINKS_WARNING=1` or enable Windows Developer Mode.

---

## Repository Layout

This project is intentionally lightweight—each metric is a single Python file living in a dataset‑type Hub repo:

```
balanced_accuracy.py
balanced_accuracy_multilabel.py
balanced_topk_accuracy.py
README.md
```

All three metrics are loadable from the Hub via `hf_hub_download(...)` + `evaluate.load(local_path, module_type="metric")` — no installation step required.

---

## Quickstart

### 0) Common helper

```python
from huggingface_hub import hf_hub_download
import evaluate

REPO = "OliverOnHF/balanced-accuracy"   # dataset-type repo
REV  = "main"                           # or a specific commit hash for reproducibility

def load_metric_from_hf(filename):
    path = hf_hub_download(REPO, filename, repo_type="dataset", revision=REV)
    return evaluate.load(path, module_type="metric")
```

### 1) Binary & Multiclass — `balanced_accuracy.py`

```python
m = load_metric_from_hf("balanced_accuracy.py")

# Binary (labels)
print(m.compute(references=[0,1,1,0], predictions=[0,1,0,0], task="binary"))
# → {'balanced_accuracy': 0.75}

# Binary (probabilities) + automatic threshold search (Youden’s J)
print(m.compute(references=[0,1,1,0],
                predictions=[0.2, 0.9, 0.1, 0.3],
                task="binary", threshold="auto"))
# → {'balanced_accuracy': 0.75, 'optimal_threshold': 0.6}

# Multiclass (macro BA) with per-class recall & sample_weight
print(m.compute(references=[0,1,2,1],
                predictions=[0,2,2,1],
                task="multiclass", num_classes=3,
                return_per_class=True,
                sample_weight=[1, 0.5, 1, 1]))
# → {'balanced_accuracy': 0.888888..., 'per_class_recall': [1.0, 0.6666..., 1.0], 'support_per_class': [1.0, 1.5, 1.0]}

# Class masking (e.g., tail classes only)
print(m.compute(references=[0,1,2,1], predictions=[0,2,2,1],
                task="multiclass", num_classes=3,
                class_mask=[1,2], return_per_class=True))
```

**Key arguments**

- `task`: `"binary"` or `"multiclass"` (default `"binary"`)
- `threshold`: float in (0,1) or `"auto"` (binary probabilities only). If predictions are 0/1 labels, threshold is ignored.
- `num_classes`: for multiclass; inferred if not set (when labels are 0..K‑1).
- `sample_weight`: per‑sample weights; confusion **counts become weighted sums**.
- `ignore_index`: skip samples where `reference == ignore_index`.
- `adjusted`: chance‑corrected BA (`2*BA-1` for binary; `(BA-1/K)/(1-1/K)` for multiclass).
- `class_mask`: compute macro‑BA over a subset of classes.
- `return_per_class`: also return per‑class recalls; `support_per_class` is **count or weighted sum** (if `sample_weight` is provided).

---

### 2) Multilabel — `balanced_accuracy_multilabel.py`

```python
m = load_metric_from_hf("balanced_accuracy_multilabel.py")

y_true = [[1,0,1],
          [0,1,0]]
y_pred = [[1,0,0],
          [0,1,1]]

# Labels (0/1)
print(m.compute(references=y_true, predictions=y_pred, return_per_label=True))
# → {'balanced_accuracy': 0.6666..., 'per_label_ba': [1.0, 1.0, 0.0], 'support_per_label': [1, 1, 1]}

# Probabilities + per-label automatic threshold
probs = [[0.9,0.2,0.1],
         [0.1,0.8,0.7]]
print(m.compute(references=y_true, predictions=probs,
                from_probas=True, threshold="auto"))
# → {'balanced_accuracy': 0.8333..., 'per_label_thresholds': [0.5, 0.5, ~0.7]}

# Weighted / micro / class_mask
print(m.compute(references=y_true, predictions=y_pred,
                average="micro",
                sample_weight=[1.0, 0.5],
                class_mask=[0,2]))
```

**Key arguments**

- `from_probas`: if `True`, `predictions` are probabilities in `[0,1]`; else must be 0/1 labels.
- `threshold`: float in (0,1) or `"auto"` (when `from_probas=True`; `"auto"` selects a threshold per label).
- `average`: `"macro" | "weighted" | "micro"`  
  - *macro*: average BA across labels;  
  - *weighted*: weighted by each label’s **positive support**;  
  - *micro*: pool TP/TN/FP/FN across all labels then compute BA.
- `class_mask`: evaluate only the specified label indices.
- `return_per_label`: additionally return `per_label_ba` and `support_per_label`.

---

### 3) Balanced Top‑K Accuracy — `balanced_topk_accuracy.py`

```python
import numpy as np
m = load_metric_from_hf("balanced_topk_accuracy.py")

scores = np.array([[0.7,  0.2, 0.1],
                   [0.1,  0.3, 0.6],
                   [0.05, 0.05,0.9],
                   [0.05, 0.9, 0.05]])
y_true = [0,1,2,1]

# top-1 (macro recall across classes)
print(m.compute(references=y_true, predictions=scores, k=1, return_per_class=True))
# → {'balanced_topk_accuracy': 0.8333..., 'per_class_recall': [1.0, 0.5, 1.0]}

# multiple k at once
print(m.compute(references=y_true, predictions=scores, k_list=[1,2], return_per_class=True))
# → {'balanced_topk_accuracy': {1: 0.8333..., 2: 1.0}, 'per_class_recall': {1: [...], 2: [...]}}

# with sample_weight and class_mask
print(m.compute(references=y_true, predictions=scores, k=1,
                sample_weight=[1,0.5,1,1], class_mask=[0,1,2]))
```

**Intuition**: For each class `c`, compute recall@k among samples of class `c`, then macro‑average across classes (optionally over a masked subset).

---

## Expected Outputs (Sanity Check)

These should match what you get locally:

```
# Binary BA
{'balanced_accuracy': 0.75}

# Binary BA with auto threshold (probs: [0.2, 0.9, 0.1, 0.3])
{'balanced_accuracy': 0.75, 'optimal_threshold': 0.6}

# Multiclass BA with weights
{'balanced_accuracy': 0.888888..., 'per_class_recall': [1.0, 0.6666..., 1.0], 'support_per_class': [1.0, 1.5, 1.0]}

# Multilabel BA (labels)
{'balanced_accuracy': 0.6666..., 'per_label_ba': [1.0, 1.0, 0.0], 'support_per_label': [1, 1, 1]}

# Multilabel BA (probs + auto thresholds)
{'balanced_accuracy': 0.8333..., 'per_label_thresholds': [0.5, 0.5, ~0.7]}

# Balanced top-1 and top-2
{'balanced_topk_accuracy': 0.8333..., 'per_class_recall': [1.0, 0.5, 1.0]}
{'balanced_topk_accuracy': {1: 0.8333..., 2: 1.0}, 'per_class_recall': {1: [...], 2: [...]}}
```

---

## API Reference (TL;DR)

### `balanced_accuracy.py` (binary/multiclass)

- **Args**:  
  `predictions`, `references`, `task={"binary","multiclass"}`, `num_classes=None`,  
  `adjusted=False`, `zero_division=0.0`, `threshold=None|"auto" (binary prob)`,  
  `ignore_index=None`, `return_per_class=False`, `class_mask=None`, `sample_weight=None`  
- **Returns**:  
  `{"balanced_accuracy": float}` + optional `{"optimal_threshold": float}` (binary, auto) +  
  optional `{"per_class_recall": list[float], "support_per_class": list[int|float]}` (multiclass).

### `balanced_accuracy_multilabel.py`

- **Args**:  
  `predictions`, `references`, `from_probas=False`, `threshold=0.5|"auto"`,  
  `zero_division=0.0`, `average="macro"|"weighted"|"micro"`, `class_mask=None`,  
  `ignore_index=None`, `return_per_label=False`, `sample_weight=None`  
- **Returns**:  
  `{"balanced_accuracy": float}` + optional `{"per_label_thresholds": list[float]}` (auto) +  
  optional `{"per_label_ba": list[float], "support_per_label": list[int]}`.

### `balanced_topk_accuracy.py`

- **Args**:  
  `predictions (N,K)`, `references (N)`, `k=1` or `k_list=[...]`, `class_mask=None`,  
  `sample_weight=None`, `zero_division=0.0`, `return_per_class=False`  
- **Returns**:  
  `{"balanced_topk_accuracy": float | dict[int,float]}` + optional `{"per_class_recall": ...}`.

---

## Error Messages & Special Reasons

Friendly messages you may encounter by design:

- **Length/shape**: “Mismatch in the number of predictions …” / “Multilabel expects 2D arrays …”  
- **NaN/Inf**: “`predictions` contains NaN/Inf.”  
- **Binary**:  
  - labels not in {0,1} → “For binary with label predictions, values must be 0/1.”  
  - probs not in [0,1] → “For binary with probabilities, `predictions` must be in [0,1].”  
- **Multiclass**: label out of range → “`predictions`/`references` must be in [0,K‑1] …”  
- **Multilabel**: average invalid / prob or label value invalid / shape mismatch  
- **Top‑k**: invalid `k` / label out of range  
- **Reasoned NaN**:
  - `{"reason": "empty_after_ignore_index"}` — all samples were ignored  
  - `{"reason": "empty_class_mask_after_filtering"}` — class/label mask removed everything

---

## Reproducible Smoke Test

Copy into `test_all.py` and run:

```python
from huggingface_hub import hf_hub_download
import evaluate, numpy as np

REPO, REV = "OliverOnHF/balanced-accuracy", "main"
def load(fname): return evaluate.load(hf_hub_download(REPO, fname, repo_type="dataset", revision=REV), module_type="metric")

# 1) binary & multiclass
mba = load("balanced_accuracy.py")
print(mba.compute(references=[0,1,1,0], predictions=[0,1,0,0], task="binary"))
print(mba.compute(references=[0,1,1,0], predictions=[0.2,0.9,0.1,0.3], task="binary", threshold="auto"))
print(mba.compute(references=[0,1,2,1], predictions=[0,2,2,1], task="multiclass", num_classes=3, return_per_class=True, sample_weight=[1,0.5,1,1]))

# 2) multilabel
mml = load("balanced_accuracy_multilabel.py")
y_true = [[1,0,1],[0,1,0]]; y_pred = [[1,0,0],[0,1,1]]; probs = [[0.9,0.2,0.1],[0.1,0.8,0.7]]
print(mml.compute(references=y_true, predictions=y_pred, return_per_label=True))
print(mml.compute(references=y_true, predictions=probs, from_probas=True, threshold="auto"))

# 3) top-k
mtk = load("balanced_topk_accuracy.py")
scores = np.array([[0.7,0.2,0.1],[0.1,0.3,0.6],[0.05,0.05,0.9],[0.05,0.9,0.05]]); y_true = [0,1,2,1]
print(mtk.compute(references=y_true, predictions=scores, k=1, return_per_class=True))
print(mtk.compute(references=y_true, predictions=scores, k_list=[1,2], return_per_class=True))
```

---

## Tips

- Pin `revision` to a commit hash for exact reproducibility.  
- `support_per_class` / `support_per_label` are **counts** when unweighted; if `sample_weight` is provided they become **effective weight sums** (floats).  
- For extreme long‑tail distributions, combine `class_mask` with per‑class analysis for stable reporting.

---

## License

MIT (suggested). If you need a specific license, add a root `LICENSE` file.