"""READ-Bench leaderboard — official evaluation harness (self-contained). This file is the single source of truth for how a submission is scored. It has **no dependency on any private package** — only ``datasets`` + ``numpy`` — so a submitter can clone the public results repo and reproduce their number exactly. A submission provides a ``method.py`` exposing: def rank(query: dict, corpus: list[dict]) -> list[int]: '''Return corpus INDICES ordered most- to least-relevant to `query`. You may read ts_values / channels / entry metadata, but NEVER query["class_label"] (the hidden target). Corpus class_labels may be read only if your method is declared supervised / label-aware.''' The harness loads the public dataset, rebuilds the official corpus/query split for each dataset and pollution level, calls ``rank`` per query, and computes NDCG@10 (plus P/HR/NDCG@{1,5,20} and macro-F1) with the paper's metric, then macro-averages across datasets. Run:: python eval_submission.py --submission submissions/my-method --out results.json """ from __future__ import annotations import argparse import importlib.util import json import random import sys from pathlib import Path from typing import Callable, Dict, List, Tuple import numpy as np REPO = "c3aiia3c/read-bench" DATASETS = [ "ctsr", "damadics", "exathlon", "hai", "mit_bih", "petrobras_3w", "rats40k", "rcaeval", "road", "telecom_ts", "tennessee_eastman", "voraus", ] # Official pollution levels: fraction of the corpus that is Normal. POLLUTION = {"rho0": 0.0, "rho10": 0.10, "rho20": 0.20} TOPK = (1, 3, 5, 10, 20) PRIMARY_METRIC = "NDCG@10" SEED = 42 LABEL_NORMAL = "Normal" # -------------------------------------------------------------------------- # Metric — vendored verbatim from the paper's implementation so submissions # score identically to the published numbers. # -------------------------------------------------------------------------- def score_retrieval(score_matrix: np.ndarray, corpus_labels: np.ndarray, query_labels: np.ndarray, topk: Tuple[int, ...] = TOPK) -> dict: """Score a (Q, N) score matrix (higher = better). P/HR/NDCG@K + macro-F1.""" order = np.argsort(-score_matrix, axis=1, kind="stable") ranked = corpus_labels[order] n_rel = (corpus_labels == query_labels[:, None]).sum(axis=1) return _metrics_from_ranked(ranked, query_labels, n_rel, topk) def score_from_ranked(ranked: np.ndarray, corpus_labels: np.ndarray, query_labels: np.ndarray, topk: Tuple[int, ...] = TOPK) -> dict: """Score from a (Q, N) matrix of corpus indices already ranked per query.""" ranked_labels = corpus_labels[ranked] n_rel = (corpus_labels == query_labels[:, None]).sum(axis=1) return _metrics_from_ranked(ranked_labels, query_labels, n_rel, topk) def _metrics_from_ranked(ranked, query_labels, n_rel, topk) -> dict: rel = (ranked == query_labels[:, None]) n_rel = np.maximum(n_rel, 1) metrics: Dict[str, float] = {} for k in topk: rel_k = rel[:, :k] metrics[f"P@{k}"] = float(rel_k.mean()) metrics[f"HR@{k}"] = float(rel_k.any(axis=1).mean()) discounts = 1.0 / np.log2(np.arange(2, k + 2)) dcg = (rel_k * discounts).sum(axis=1) ideal = np.array([discounts[:min(int(nr), k)].sum() for nr in n_rel]) metrics[f"NDCG@{k}"] = float(np.where(ideal > 0, dcg / ideal, 0.0).mean()) def _majority(top5): counts: dict = {} order: list = [] for lbl in top5: if lbl not in counts: counts[lbl] = 0 order.append(lbl) counts[lbl] += 1 return max(order, key=lambda l: counts[l]) top5 = [_majority(ranked[q, :5].tolist()) for q in range(len(query_labels))] classes = np.unique(query_labels) f1s = [] for cls in classes: tp = sum(p == cls and t == cls for p, t in zip(top5, query_labels)) fp = sum(p == cls and t != cls for p, t in zip(top5, query_labels)) fn = sum(p != cls and t == cls for p, t in zip(top5, query_labels)) pr = tp / (tp + fp) if tp + fp else 0.0 rc = tp / (tp + fn) if tp + fn else 0.0 f1s.append(2 * pr * rc / (pr + rc) if pr + rc else 0.0) metrics["macro_F1"] = float(np.mean(f1s)) if f1s else 0.0 return metrics # -------------------------------------------------------------------------- # Official split reconstruction (self-contained; mirrors the paper protocol). # Corpus = train-split anomalies (+ Normals to the pollution fraction), # query = test-split anomalies. Deterministic given SEED. # -------------------------------------------------------------------------- def _is_anom(e: dict) -> bool: return e.get("label") != LABEL_NORMAL def _subsample_normals(normals: List[dict], n: int, rng: random.Random) -> List[dict]: if n >= len(normals): return list(normals) return rng.sample(normals, n) def build_eval_split(rows: List[dict], pollution: float, seed: int = SEED, ) -> Tuple[List[dict], List[dict]]: """Return ``(corpus, query)`` for one dataset at one pollution level. Corpus = train anomalies + enough train Normals to make ``pollution`` of the corpus Normal; query = test anomalies. All deterministic given ``seed``. """ rng = random.Random(seed) train = [r for r in rows if r["native_split"] == "train"] test = [r for r in rows if r["native_split"] == "test"] corpus_anom = [r for r in train if _is_anom(r)] query = [r for r in test if _is_anom(r)] if not query: # degenerate datasets: fall back to all test rows query = list(test) corpus = list(corpus_anom) if pollution > 0 and corpus_anom: # n_normal / (n_anom + n_normal) = pollution -> solve for n_normal n_norm = round(pollution / (1 - pollution) * len(corpus_anom)) train_normals = [r for r in train if not _is_anom(r)] corpus += _subsample_normals(train_normals, n_norm, rng) rng.shuffle(corpus) return corpus, query # -------------------------------------------------------------------------- # Submission loading + running. # -------------------------------------------------------------------------- def load_method(submission_dir: Path) -> Callable[[dict, List[dict]], List[int]]: """Import ``method.py`` from a submission dir and return its ``rank``.""" method_path = submission_dir / "method.py" if not method_path.exists(): raise FileNotFoundError(f"no method.py in {submission_dir}") spec = importlib.util.spec_from_file_location("submission_method", method_path) mod = importlib.util.module_from_spec(spec) sys.modules["submission_method"] = mod spec.loader.exec_module(mod) if not hasattr(mod, "rank"): raise AttributeError("method.py must define rank(query, corpus) -> list[int]") return mod.rank def _label_array(entries: List[dict]) -> np.ndarray: return np.array([e["class_label"] for e in entries], dtype=object) def eval_dataset(rank_fn, rows: List[dict], pollution: float) -> dict: """Run the method over one dataset at one pollution level -> metrics dict.""" corpus, query = build_eval_split(rows, pollution) corpus_labels = _label_array(corpus) query_labels = _label_array(query) # Hide the query's class_label from the method (anti-cheat on the target). masked_queries = [{k: v for k, v in q.items() if k != "class_label"} for q in query] ranked = np.zeros((len(query), len(corpus)), dtype=np.int64) for i, q in enumerate(masked_queries): order = rank_fn(q, corpus) order = list(dict.fromkeys(int(j) for j in order)) # dedupe, keep order missing = [j for j in range(len(corpus)) if j not in set(order)] full = (order + missing)[:len(corpus)] ranked[i] = full return score_from_ranked(ranked, corpus_labels, query_labels) def evaluate(submission_dir: Path, datasets: List[str] = None, repo: str = REPO, token: str = None) -> dict: """Full evaluation of a submission -> results dict (also written as results.json).""" from datasets import load_dataset datasets = datasets or DATASETS rank_fn = load_method(submission_dir) per_dataset: Dict[str, Dict[str, dict]] = {} for name in datasets: ds = load_dataset(repo, name, token=token) rows = list(ds["train"]) + list(ds["test"]) per_dataset[name] = {} for level, rho in POLLUTION.items(): per_dataset[name][level] = eval_dataset(rank_fn, rows, rho) # Macro-average across datasets, per pollution level. summary: Dict[str, Dict[str, float]] = {} all_metrics = next(iter(next(iter(per_dataset.values())).values())).keys() for level in POLLUTION: summary[level] = {} for metric in all_metrics: vals = [per_dataset[d][level][metric] for d in datasets] summary[level][metric] = float(np.mean(vals)) return { "primary_metric": PRIMARY_METRIC, "headline": {level: summary[level][PRIMARY_METRIC] for level in POLLUTION}, "summary_macro_avg": summary, "per_dataset": per_dataset, "datasets": datasets, } def main(argv=None) -> None: p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) p.add_argument("--submission", required=True, type=Path, help="submission dir containing method.py + metadata.yaml") p.add_argument("--out", type=Path, default=None, help="write results JSON here (default: /results.json)") p.add_argument("--datasets", nargs="*", default=None, help="subset (default: all 12)") p.add_argument("--repo", default=REPO) p.add_argument("--token", default=None, help="HF token (only needed if repo is private)") args = p.parse_args(argv) results = evaluate(args.submission, args.datasets, args.repo, args.token) out = args.out or (args.submission / "results.json") out.write_text(json.dumps(results, indent=2)) h = results["headline"] print(f"NDCG@10 rho0={h['rho0']:.4f} rho10={h['rho10']:.4f} rho20={h['rho20']:.4f}") print(f"wrote {out}") if __name__ == "__main__": main()