Scaffold: protocol README, official harness, validator, example submission

README.md

@@ -0,0 +1,109 @@
+---
+license: cc-by-nc-sa-4.0
+pretty_name: "READ-Bench — Leaderboard Submissions"
+tags:
+  - leaderboard
+  - time-series
+  - retrieval
+  - anomaly-detection
+  - benchmark
+---
+
+# READ-Bench — Leaderboard Submissions
+
+This repository collects **community submissions** to the
+[READ-Bench](https://huggingface.co/datasets/c3aiia3c/read-bench) leaderboard for
+historical-instance retrieval in time-series diagnosis
+([arXiv:2609.32123](https://arxiv.org/abs/2609.32123)).
+
+- **Data** lives in [`c3aiia3c/read-bench`](https://huggingface.co/datasets/c3aiia3c/read-bench).
+- **Submissions** (code + results) live here, one folder per method.
+- **The live board** is the
+  [READ-Bench Leaderboard Space](https://huggingface.co/spaces/c3aiia3c/read-bench-leaderboard),
+  which renders every accepted submission.
+
+Submissions are **reproducible by design**: you include runnable code, and the
+official harness (`eval_submission.py`, in this repo) runs *your* method against
+the *hidden* relevance labels to produce the score — so numbers can't be faked
+and anyone can rerun them.
+
+## What a submission contains
+
+Add one folder, `submissions/<your-slug>/`, with:
+
+| file | required | what |
+|---|---|---|
+| `method.py` | ✅ | exposes `rank(query, corpus) -> list[int]` (see contract below) |
+| `metadata.yaml` | ✅ | method name, family, supervision, authors, links |
+| `requirements.txt` | ✅ | any deps your `method.py` imports |
+| `results.json` | ✅ | produced by the harness (do not hand-edit) |
+
+Copy [`example_submission/`](example_submission) as your starting point — it's a
+working Euclidean-distance baseline.
+
+## The method contract
+
+```python
+def rank(query: dict, corpus: list[dict]) -> list[int]:
+    """Return corpus INDICES ordered most- to least-relevant to `query`.
+
+    Each entry has: ts_values ([T][C] floats), channels, label, class_label,
+    rca_target, rca_affected, dataset, entry_id, native_split, extras.
+
+    Rules:
+      * NEVER read query["class_label"] — it is the hidden target (and is
+        masked out before your function is called).
+      * You may read corpus class_labels ONLY if you declare your method
+        `supervision: supervised` or `neighbour-labels` in metadata.yaml.
+    """
+```
+
+## How to submit (all on Hugging Face — no GitHub needed)
+
+```bash
+# 1. clone this repo (git-backed, like GitHub)
+git clone https://huggingface.co/datasets/c3aiia3c/read-bench-results
+cd read-bench-results
+
+# 2. create your submission from the template
+cp -r example_submission submissions/my-method
+# ... edit submissions/my-method/method.py + metadata.yaml + requirements.txt
+
+# 3. validate structure, then score with the official harness
+pip install -r submissions/my-method/requirements.txt
+python validate_submission.py --submission submissions/my-method --run
+#   -> writes submissions/my-method/results.json
+
+# 4. open a Pull Request on this repo (Community tab) with your folder.
+```
+
+To open the PR: push your branch, or use the **"Community" → "New pull request"**
+button on this repo's page and upload your `submissions/<slug>/` folder. A
+maintainer re-runs the harness to confirm your `results.json`, then merges — and
+the [Leaderboard Space](https://huggingface.co/spaces/c3aiia3c/read-bench-leaderboard)
+picks it up automatically.
+
+## Scoring
+
+- **Primary metric:** NDCG@10, macro-averaged over the 12 datasets, at pollution
+  levels ρ = 0 / 10 / 20% (fraction of the corpus that is Normal).
+- Also reported: P@{1,3,5,10,20}, HR@{...}, NDCG@{1,3,5,20}, macro-F1.
+- Relevance is binary & multi-target: a corpus item is relevant to a query iff
+  they share the same non-normal `class_label`.
+- The split is reconstructed deterministically (seed 42): corpus = train-split
+  anomalies + Normals to the pollution fraction; queries = test-split anomalies.
+
+See [`eval_submission.py`](eval_submission.py) for the exact, self-contained
+implementation (only `datasets` + `numpy`).
+
+## Citation
+
+```bibtex
+@article{readbench2026,
+  title  = {READ-Bench: Benchmarking Historical Instance Retrieval for Time-Series Diagnosis},
+  author = {Pastrana, Gerardo and Li, Haojun and Mehta, Dhruv and Vyas, Anoushka and
+            Khoshfetrat Pakazad, Sina and Ohlsson, Henrik and Paparrizos, John},
+  journal = {arXiv preprint arXiv:2609.32123},
+  year    = {2026}
+}
+```

eval_submission.py

@@ -0,0 +1,245 @@
+"""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: <submission>/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()

example_submission/metadata.yaml

@@ -0,0 +1,14 @@
+name: "ED (channel-independent Euclidean)"
+# Short slug used for the submission folder + leaderboard row.
+slug: "ed-baseline"
+family: "Raw-window distance"       # one of: Raw-window distance | Symbolic | FM embedder | Fusion | Reranker | Supervised
+supervision: "label-free"           # one of: label-free | neighbour-labels | supervised
+authors: "READ-Bench maintainers"
+affiliation: "C3 AI"
+paper: ""                            # URL to a paper/preprint, optional
+code: ""                             # URL to a public code release, optional
+description: >
+  Baseline reference: z-normalize each channel, linearly resample every window
+  to a common length, and rank corpus items by Euclidean distance. Label-free.
+# Filled in automatically by the harness; leave blank in your PR.
+results_file: "results.json"

example_submission/method.py

@@ -0,0 +1,56 @@
+"""Example READ-Bench submission: a channel-independent Euclidean (ED) retriever.
+
+Copy this folder, rename it, and replace `rank` with your method. The only
+contract is the `rank(query, corpus)` signature below. This baseline needs just
+numpy — real submissions may import torch, an embedder, etc. (declare them in
+`requirements.txt`).
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+import numpy as np
+
+
+def _flat(entry: Dict) -> np.ndarray:
+    """Flatten a window to a 1-D vector; z-normalize per channel for scale.
+
+    `ts_values` is a nested `[T][C]` list (variable T, C across datasets). We
+    z-score each channel then flatten, so Euclidean distance is comparable.
+    """
+    x = np.asarray(entry["ts_values"], dtype=np.float32)   # (T, C)
+    if x.ndim == 1:
+        x = x[:, None]
+    mu = x.mean(axis=0, keepdims=True)
+    sd = x.std(axis=0, keepdims=True)
+    sd = np.where(sd == 0, 1.0, sd)
+    return ((x - mu) / sd).ravel()
+
+
+def rank(query: Dict, corpus: List[Dict]) -> List[int]:
+    """Return corpus indices ordered most- to least-relevant to `query`.
+
+    Label-free: ignores class_label entirely (never reads the query's, which is
+    masked anyway). Distance = Euclidean on resampled, z-normalized windows.
+    Windows of different length are compared on a common resampled grid.
+    """
+    GRID = 128
+    q = _resample(_flat(query), GRID)
+    dists = []
+    for item in corpus:
+        c = _resample(_flat(item), GRID)
+        dists.append(float(np.linalg.norm(q - c)))
+    # smaller distance = more relevant
+    return list(np.argsort(dists, kind="stable"))
+
+
+def _resample(vec: np.ndarray, n: int) -> np.ndarray:
+    """Linear-resample a 1-D vector to length `n` so variable-shape windows align."""
+    if len(vec) == n:
+        return vec
+    if len(vec) == 0:
+        return np.zeros(n, dtype=np.float32)
+    xp = np.linspace(0.0, 1.0, num=len(vec))
+    x = np.linspace(0.0, 1.0, num=n)
+    return np.interp(x, xp, vec).astype(np.float32)

example_submission/requirements.txt

@@ -0,0 +1,4 @@
+# Example submission depends only on numpy. Declare any extra deps your
+# method.py imports (torch, transformers, a specific embedder SDK, ...).
+numpy>=1.24
+datasets>=2.19

validate_submission.py

@@ -0,0 +1,101 @@
+"""Validate a READ-Bench submission before opening a PR.
+
+Checks the submission folder is well-formed and (optionally) re-runs the
+official harness to verify the reported numbers. Run::
+
+    python validate_submission.py --submission submissions/my-method          # structure only
+    python validate_submission.py --submission submissions/my-method --run    # + recompute scores
+
+Exits non-zero on any failure, so it doubles as a CI gate.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+REQUIRED_FILES = ["method.py", "metadata.yaml", "requirements.txt"]
+REQUIRED_META = ["name", "slug", "family", "supervision"]
+FAMILIES = {"Raw-window distance", "Symbolic", "FM embedder", "Fusion",
+            "Reranker", "Supervised", "Other"}
+SUPERVISION = {"label-free", "neighbour-labels", "supervised"}
+
+
+def _fail(msg: str) -> None:
+    print(f"  ✗ {msg}")
+
+
+def _ok(msg: str) -> None:
+    print(f"  ✓ {msg}")
+
+
+def validate(submission: Path, run: bool, token: str = None) -> bool:
+    import yaml
+
+    print(f"Validating {submission}")
+    ok = True
+
+    for f in REQUIRED_FILES:
+        if (submission / f).exists():
+            _ok(f"{f} present")
+        else:
+            _fail(f"missing {f}")
+            ok = False
+
+    meta = {}
+    if (submission / "metadata.yaml").exists():
+        meta = yaml.safe_load((submission / "metadata.yaml").read_text()) or {}
+        for key in REQUIRED_META:
+            if meta.get(key):
+                _ok(f"metadata.{key} = {meta[key]!r}")
+            else:
+                _fail(f"metadata.{key} missing/empty")
+                ok = False
+        if meta.get("family") and meta["family"] not in FAMILIES:
+            _fail(f"family must be one of {sorted(FAMILIES)}")
+            ok = False
+        if meta.get("supervision") and meta["supervision"] not in SUPERVISION:
+            _fail(f"supervision must be one of {sorted(SUPERVISION)}")
+            ok = False
+
+    # method.py must import and expose rank(query, corpus).
+    try:
+        from eval_submission import load_method
+        load_method(submission)
+        _ok("method.py exposes rank(query, corpus)")
+    except Exception as exc:  # noqa: BLE001
+        _fail(f"method.py not loadable: {type(exc).__name__}: {exc}")
+        ok = False
+
+    if run and ok:
+        print("Running official harness (this downloads the dataset)…")
+        try:
+            from eval_submission import evaluate
+            results = evaluate(submission, token=token)
+            out = submission / "results.json"
+            out.write_text(json.dumps(results, indent=2))
+            h = results["headline"]
+            _ok(f"scored NDCG@10 rho0/10/20 = "
+                f"{h['rho0']:.4f}/{h['rho10']:.4f}/{h['rho20']:.4f} -> {out.name}")
+        except Exception as exc:  # noqa: BLE001
+            _fail(f"harness failed: {type(exc).__name__}: {exc}")
+            ok = False
+
+    print("PASS ✅" if ok else "FAIL ❌")
+    return ok
+
+
+def main(argv=None) -> None:
+    p = argparse.ArgumentParser(description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--submission", required=True, type=Path)
+    p.add_argument("--run", action="store_true", help="also recompute scores via the harness")
+    p.add_argument("--token", default=None)
+    args = p.parse_args(argv)
+    sys.exit(0 if validate(args.submission, args.run, args.token) else 1)
+
+
+if __name__ == "__main__":
+    main()