Initial benchmark dataset upload

EVAL.md

@@ -0,0 +1,172 @@
+# Evaluating on HandleAtlas-benchmark
+
+A self-contained eval harness for the
+[`LumeData/HandleAtlas-benchmark`](https://huggingface.co/datasets/LumeData/HandleAtlas-benchmark)
+dataset. The whole protocol — splits, labels, thresholds, scoring — lives in
+[`eval.yaml`](./eval.yaml); the runner in [`run_eval.py`](./run_eval.py) reads
+that file, loads the dataset from the Hub, and reports the same numbers used
+on the model cards.
+
+---
+
+## What gets measured
+
+| metric | definition |
+|---|---|
+| **span-only F1** *(primary)* | label-agnostic; a prediction matches a gold span when their character-offset IoU ≥ 0.5 |
+| **span+label F1** | exact match on `(start, end, label)` — only fair when models share this taxonomy |
+| **latency** | wall-clock ms per record, batch=1, CPU |
+
+Per-label P/R/F1 is also printed for diagnostic use.
+
+---
+
+## Setup
+
+You only need the deps for the adapter you plan to use.
+
+```bash
+# core (always needed)
+pip install datasets pyyaml
+
+# adapter: gliner  (GLiNER models, including HandleAtlas)
+pip install gliner "transformers<5" torch
+#   + ONNX (only if you pass --onnx):
+pip install onnx onnxruntime optimum "accelerate>=0.26"
+
+# adapter: hf-pipeline  (BERT/DeBERTa token-classification models)
+pip install "transformers<5" torch
+#   Some PII models (e.g. openai/privacy-filter) require a newer transformers:
+pip install "git+https://github.com/huggingface/transformers.git"
+```
+
+Recommended: use `uv` so each run gets an isolated env.
+
+```bash
+uv run --with gliner --with 'transformers<5' --with torch \
+       --with datasets --with pyyaml \
+       python run_eval.py --adapter gliner --model LumeData/HandleAtlas-166m
+```
+
+---
+
+## Quickstart
+
+### Evaluate HandleAtlas (PyTorch float)
+
+```bash
+python run_eval.py --adapter gliner --model LumeData/HandleAtlas-166m
+```
+
+### Evaluate the CPU (INT8 ONNX) variant
+
+```bash
+python run_eval.py \
+  --adapter gliner \
+  --model LumeData/HandleAtlas-166m-CPU \
+  --onnx
+```
+
+### Evaluate base GLiNER zero-shot
+
+```bash
+python run_eval.py --adapter gliner --model urchade/gliner_small-v2.1
+```
+
+### Evaluate a different-taxonomy PII model (label-agnostic only)
+
+The span-only F1 is fair across taxonomies; the span+label F1 will read low —
+that's expected.
+
+```bash
+python run_eval.py \
+  --adapter hf-pipeline \
+  --model openai/privacy-filter
+```
+
+If you want span+label to be meaningful, pass `--label-map` to translate the
+model's classes into the HandleAtlas label set:
+
+```bash
+python run_eval.py \
+  --adapter hf-pipeline \
+  --model some/pii-model \
+  --label-map "USERNAME=generic_username,SOCIAL=instagram_username"
+```
+
+---
+
+## CLI flags
+
+| flag | what it does |
+|---|---|
+| `--adapter` | `gliner` or `hf-pipeline` (required) |
+| `--model` | HF Hub id or local path; passed straight to the adapter (required) |
+| `--spec` | path to `eval.yaml` (defaults to the one next to `run_eval.py`) |
+| `--threshold` | override the decoding threshold from the spec |
+| `--label-map` | `model_label=target_label,...` for `hf-pipeline` |
+| `--onnx`, `--onnx-file` | load the ONNX file instead of the PyTorch weights (GLiNER) |
+| `--threads` | CPU threads (default 8) |
+| `--device` | hf-pipeline: `-1`=CPU, `0`=first GPU |
+| `--limit N` | only score the first N records (smoke test) |
+| `--save-predictions PATH` | write per-record predictions to JSONL |
+| `--json` | also dump the metrics JSON at the end |
+
+---
+
+## Adding your own model
+
+If neither built-in adapter fits, subclass `Adapter` in `run_eval.py` and
+register it. The contract is one method:
+
+```python
+class MyAdapter(Adapter):
+    name = "mymodel"
+
+    def __init__(self, model, labels, threshold, per_label_thresholds, **_):
+        super().__init__(model, labels, threshold, per_label_thresholds)
+        # load once
+        self.m = my_lib.load(model)
+
+    def predict(self, text: str) -> list[dict]:
+        # MUST return [{"start": int, "end": int, "label": str}, ...]
+        # `start`/`end` are Python character offsets, end exclusive.
+        return [{"start": s, "end": e, "label": l}
+                for s, e, l in self.m.extract(text, self.labels)]
+
+ADAPTERS["mymodel"] = MyAdapter
+```
+
+Then:
+
+```bash
+python run_eval.py --adapter mymodel --model path/or/id
+```
+
+That's it — scoring and reporting are reused.
+
+---
+
+## Reproducing the published numbers
+
+The values printed by this harness on `--model LumeData/HandleAtlas-166m`
+should match the baselines table in `eval.yaml`. If they don't, check:
+
+1. **Threshold** — the spec sets `0.5` with a `0.65` override on
+   `generic_username`. Don't override unless you mean to.
+2. **Split** — the harness only uses the `test` split; the published numbers
+   are on this same split with `seed=123`.
+3. **Hardware** — latency was measured on a MacBook Pro M5 Pro at 8 threads.
+   Different hardware will give different ms numbers; F1 should not move.
+
+---
+
+## Files
+
+| file | purpose |
+|---|---|
+| `eval.yaml` | declarative protocol — dataset, labels, thresholds, metrics, baselines |
+| `run_eval.py` | runner — loads dataset, calls the adapter, scores, reports |
+| `EVAL.md` | this file |
+| `test.jsonl` | the actual eval data, also mirrored on the Hub |
+| `README.md` | dataset card |

eval.yaml

@@ -0,0 +1,119 @@
+## HandleAtlas Benchmark — evaluation spec
+##
+## Self-contained recipe for reproducing the numbers on the dataset card.
+## Spans are character offsets into `text` (Python code points, end exclusive).
+## Scoring is label-agnostic span F1 at IoU >= 0.5, plus exact span+label F1.
+
+name: handleatlas-benchmark
+version: 1
+dataset:
+  repo_id: LumeData/HandleAtlas-benchmark
+  config: default
+  split: test
+  loader: |
+    from datasets import load_dataset
+    ds = load_dataset("LumeData/HandleAtlas-benchmark", split="test")
+
+task:
+  type: token-classification
+  subtype: span-extraction
+  input_field: text
+  target_field: entities          # list[{start, end, label}]
+  offsets: python-char            # not UTF-16, not BPE tokens
+  end_exclusive: true
+  multi_label_spans: true         # identical (start,end) with different labels are allowed
+
+labels:
+  - instagram_username
+  - snapchat_username
+  - youtube_username
+  - twitch_username
+  - tiktok_username
+  - discord_username
+  - x_username
+  - cashapp_username
+  - onlyfans_username
+  - tumblr_username
+  - github_username
+  - kofi_username
+  - patreon_username
+  - roblox_username
+  - generic_username
+
+metrics:
+  - id: span_only_f1
+    description: Label-agnostic span detection. A prediction matches a gold span
+      when their character-offset IoU >= iou_threshold. Each gold span is matched
+      at most once (greedy by best IoU).
+    iou_threshold: 0.5
+    primary: true
+    aggregate: micro
+    reports: [precision, recall, f1, tp, fp, fn]
+
+  - id: span_label_f1
+    description: Exact match on (start, end, label). Stricter than span_only_f1
+      and only fair to compare across models that share this label taxonomy.
+    aggregate: micro
+    reports: [precision, recall, f1, tp, fp, fn]
+
+  - id: latency_ms
+    description: Wall-clock ms per record, single batch=1 inference. CPU only.
+    reports: [mean, p50, p95]
+    hardware: MacBook Pro M5 Pro
+    threads: 8
+
+reference_implementation:
+  language: python
+  file: data/benchmark.py
+  scoring_fns:
+    - score_span_only
+    - score_span_label
+
+inference_protocol:
+  threshold: 0.5
+  per_label_threshold_overrides:
+    generic_username: 0.65
+  drop_predictions_with_label:
+    - discord_invite           # excluded from this taxonomy
+  decoding: greedy
+  batch_size: 1
+
+baselines:
+  - model: LumeData/HandleAtlas-166m
+    span_only_f1: 0.955
+    span_label_f1: 0.887
+    precision: 0.914
+    recall: 1.000
+    latency_ms_mean: 37.1
+    latency_ms_p95: 52.2
+    runtime: pytorch-float
+  - model: LumeData/HandleAtlas-166m-CPU
+    span_only_f1: 0.955
+    span_label_f1: 0.887
+    latency_ms_mean: 13.3
+    latency_ms_p95: 22.3
+    runtime: onnx-int8
+  - model: urchade/gliner_small-v2.1
+    span_only_f1: 0.061
+    span_label_f1: 0.031
+    precision: 1.000
+    recall: 0.031
+    latency_ms_mean: 35.0
+    latency_ms_p95: 49.9
+    runtime: pytorch-float
+    note: zero-shot, same label list at threshold 0.5
+  - model: openai/privacy-filter
+    span_only_f1: 0.402
+    precision: 0.305
+    recall: 0.591
+    latency_ms_mean: 113.6
+    latency_ms_p95: 288.1
+    runtime: pytorch-float
+    note: different label taxonomy — span+label F1 not comparable
+
+splits:
+  test:
+    n_records: 100
+    n_spans: 127
+    seed: 123
+    notes: shuffle(annotations) -> take first 100; reproducible with SEED=123

run_eval.py

@@ -0,0 +1,348 @@
+#!/usr/bin/env python3
+"""HandleAtlas benchmark eval harness.
+
+Strap any NER model into one of the adapters below and run:
+
+    python run_eval.py --adapter gliner --model LumeData/HandleAtlas-166m
+
+Reads ``eval.yaml`` (sitting next to this file) for the dataset id, label list,
+thresholds and scoring protocol, then loads the dataset from the Hugging Face
+Hub and reports span-only F1, span+label F1, and CPU latency.
+
+Add your own model by writing a new ``Adapter`` subclass and registering it
+in ``ADAPTERS`` at the bottom of the file. Adapters MUST return a list of
+``{"start": int, "end": int, "label": str}`` dicts where ``start``/``end`` are
+Python character offsets into the input ``text`` (end exclusive).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import statistics
+import time
+from collections import defaultdict
+from pathlib import Path
+from typing import Callable, Iterable
+
+import yaml
+from datasets import load_dataset
+
+HERE = Path(__file__).resolve().parent
+
+
+# ---------------------------------------------------------------------------
+# Scoring  (identical to the reference impl in data/benchmark.py)
+# ---------------------------------------------------------------------------
+def iou(a: dict, b: dict) -> float:
+    inter = max(0, min(a["end"], b["end"]) - max(a["start"], b["start"]))
+    if inter == 0:
+        return 0.0
+    union = max(a["end"], b["end"]) - min(a["start"], b["start"])
+    return inter / union if union else 0.0
+
+
+def score_span_only(pred_per_rec, gold_per_rec, iou_thresh: float = 0.5) -> dict:
+    tp = fp = fn = 0
+    for preds, gold in zip(pred_per_rec, gold_per_rec):
+        matched = set()
+        for p in preds:
+            best_i, best_v = -1, 0.0
+            for gi, g in enumerate(gold):
+                if gi in matched:
+                    continue
+                v = iou(p, g)
+                if v > best_v:
+                    best_v, best_i = v, gi
+            if best_v >= iou_thresh and best_i != -1:
+                tp += 1
+                matched.add(best_i)
+            else:
+                fp += 1
+        fn += len(gold) - len(matched)
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f = 2 * p * r / (p + r) if (p + r) else 0.0
+    return {"tp": tp, "fp": fp, "fn": fn, "precision": p, "recall": r, "f1": f}
+
+
+def score_span_label(pred_per_rec, gold_per_rec) -> dict:
+    tp = fp = fn = 0
+    per_tp: dict[str, int] = defaultdict(int)
+    per_fp: dict[str, int] = defaultdict(int)
+    per_fn: dict[str, int] = defaultdict(int)
+    for preds, gold in zip(pred_per_rec, gold_per_rec):
+        gs = {(g["start"], g["end"], g["label"]) for g in gold}
+        ps = {(p["start"], p["end"], p["label"]) for p in preds}
+        for t in gs & ps:
+            tp += 1; per_tp[t[2]] += 1
+        for t in ps - gs:
+            fp += 1; per_fp[t[2]] += 1
+        for t in gs - ps:
+            fn += 1; per_fn[t[2]] += 1
+    p = tp / (tp + fp) if (tp + fp) else 0.0
+    r = tp / (tp + fn) if (tp + fn) else 0.0
+    f = 2 * p * r / (p + r) if (p + r) else 0.0
+    return {
+        "tp": tp, "fp": fp, "fn": fn, "precision": p, "recall": r, "f1": f,
+        "per_label_tp": dict(per_tp),
+        "per_label_fp": dict(per_fp),
+        "per_label_fn": dict(per_fn),
+    }
+
+
+def fmt_latency(times: list[float]) -> dict:
+    if not times:
+        return {}
+    s = sorted(times)
+    return {
+        "mean": statistics.mean(s),
+        "p50": s[len(s) // 2],
+        "p95": s[int(len(s) * 0.95)],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Adapter protocol
+# ---------------------------------------------------------------------------
+class Adapter:
+    """Subclass + register to plug a new NER model into the harness.
+
+    The harness will instantiate exactly one Adapter per run, then call
+    ``predict(text)`` once per record. Do all your model loading in
+    ``__init__`` so the per-call path is hot.
+    """
+    name: str = ""
+
+    def __init__(self, model: str, labels: list[str], threshold: float,
+                 per_label_thresholds: dict[str, float], **kwargs):
+        self.model_id = model
+        self.labels = labels
+        self.threshold = threshold
+        self.per_label_thresholds = per_label_thresholds
+
+    def predict(self, text: str) -> list[dict]:
+        raise NotImplementedError
+
+    def _apply_thresholds(self, ents: Iterable[dict]) -> list[dict]:
+        out = []
+        for e in ents:
+            t = self.per_label_thresholds.get(e["label"], self.threshold)
+            if e.get("score", 1.0) >= t:
+                out.append({"start": int(e["start"]),
+                            "end":   int(e["end"]),
+                            "label": e["label"]})
+        return out
+
+
+class GLiNERAdapter(Adapter):
+    """Works for any GLiNER-format model (Hub id or local path)."""
+    name = "gliner"
+
+    def __init__(self, model, labels, threshold, per_label_thresholds,
+                 onnx: bool = False, onnx_file: str = "model_quantized.onnx",
+                 threads: int = 8, **_):
+        super().__init__(model, labels, threshold, per_label_thresholds)
+        import os
+        os.environ.setdefault("OMP_NUM_THREADS", str(threads))
+        import torch
+        torch.set_num_threads(threads)
+        from gliner import GLiNER
+        kw = {}
+        if onnx:
+            kw.update(load_onnx_model=True, onnx_model_file=onnx_file)
+        if Path(model).exists():
+            kw["local_files_only"] = True
+        self.m = GLiNER.from_pretrained(model, **kw)
+        self.m.eval()
+        self._floor = min(threshold, *per_label_thresholds.values()) \
+            if per_label_thresholds else threshold
+
+    def predict(self, text):
+        ents = self.m.predict_entities(text, self.labels, threshold=self._floor)
+        return self._apply_thresholds(ents)
+
+
+class HFPipelineAdapter(Adapter):
+    """Token-classification pipeline (BERT/DeBERTa-style PII / NER models).
+
+    Maps the model's entity_group strings to your label list via
+    ``--label-map key1=value1,key2=value2``.
+    """
+    name = "hf-pipeline"
+
+    def __init__(self, model, labels, threshold, per_label_thresholds,
+                 label_map: dict[str, str] | None = None, device: int = -1, **_):
+        super().__init__(model, labels, threshold, per_label_thresholds)
+        from transformers import pipeline
+        self.pipe = pipeline("token-classification", model=model,
+                             aggregation_strategy="simple", device=device)
+        self.label_map = label_map or {}
+        self.label_set = set(labels)
+
+    def predict(self, text):
+        out = []
+        for ent in self.pipe(text):
+            raw = (ent.get("entity_group") or ent.get("entity") or "").lower()
+            mapped = self.label_map.get(raw, raw)
+            if mapped not in self.label_set:
+                continue
+            out.append({"start": int(ent["start"]),
+                        "end":   int(ent["end"]),
+                        "label": mapped,
+                        "score": float(ent.get("score", 1.0))})
+        return self._apply_thresholds(out)
+
+
+ADAPTERS: dict[str, type[Adapter]] = {
+    GLiNERAdapter.name:    GLiNERAdapter,
+    HFPipelineAdapter.name: HFPipelineAdapter,
+}
+
+
+# ---------------------------------------------------------------------------
+# Harness
+# ---------------------------------------------------------------------------
+def parse_kv(s: str) -> dict[str, str]:
+    if not s:
+        return {}
+    out = {}
+    for pair in s.split(","):
+        if "=" not in pair:
+            continue
+        k, v = pair.split("=", 1)
+        out[k.strip()] = v.strip()
+    return out
+
+
+def run(adapter: Adapter, ds, primary_iou: float) -> dict:
+    preds_all = []
+    gold_all = []
+    times = []
+    for rec in ds:
+        text = rec["text"]
+        gold_all.append(rec["entities"])
+        t0 = time.perf_counter()
+        preds = adapter.predict(text)
+        times.append((time.perf_counter() - t0) * 1000)
+        preds_all.append(preds)
+
+    span_only = score_span_only(preds_all, gold_all, iou_thresh=primary_iou)
+    span_label = score_span_label(preds_all, gold_all)
+    return {
+        "span_only_f1": span_only,
+        "span_label_f1": span_label,
+        "latency_ms": fmt_latency(times),
+        "n_records": len(gold_all),
+        "n_gold_spans": sum(len(g) for g in gold_all),
+        "predictions": preds_all,
+    }
+
+
+def report(name: str, results: dict) -> None:
+    so = results["span_only_f1"]
+    sl = results["span_label_f1"]
+    lat = results["latency_ms"]
+    print(f"\n=== {name} ===")
+    print(f"  records: {results['n_records']}   "
+          f"gold spans: {results['n_gold_spans']}")
+    print(f"  span-only F1   P={so['precision']:.3f}  R={so['recall']:.3f}  "
+          f"F1={so['f1']:.3f}   (TP={so['tp']} FP={so['fp']} FN={so['fn']})")
+    print(f"  span+label F1  P={sl['precision']:.3f}  R={sl['recall']:.3f}  "
+          f"F1={sl['f1']:.3f}   (TP={sl['tp']} FP={sl['fp']} FN={sl['fn']})")
+    if lat:
+        print(f"  latency        mean={lat['mean']:6.1f} ms   "
+              f"p50={lat['p50']:6.1f} ms   p95={lat['p95']:6.1f} ms")
+
+    labels_seen = (set(sl["per_label_tp"]) | set(sl["per_label_fp"])
+                   | set(sl["per_label_fn"]))
+    if labels_seen:
+        print("\n  per-label (span+label):")
+        for l in sorted(labels_seen):
+            tp = sl["per_label_tp"].get(l, 0)
+            fp = sl["per_label_fp"].get(l, 0)
+            fn = sl["per_label_fn"].get(l, 0)
+            p = tp / (tp + fp) if (tp + fp) else 0.0
+            r = tp / (tp + fn) if (tp + fn) else 0.0
+            f = 2*p*r/(p+r) if (p+r) else 0.0
+            print(f"    {l:<22} P={p:.2f} R={r:.2f} F1={f:.2f}   "
+                  f"TP={tp} FP={fp} FN={fn}")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--adapter", required=True, choices=sorted(ADAPTERS),
+                    help="Which built-in adapter to use.")
+    ap.add_argument("--model", required=True,
+                    help="HF Hub id or local path passed verbatim to the adapter.")
+    ap.add_argument("--spec", default=str(HERE / "eval.yaml"),
+                    help="Path to eval.yaml (default: next to this file).")
+    ap.add_argument("--threshold", type=float, default=None,
+                    help="Override default decoding threshold from the spec.")
+    ap.add_argument("--label-map", default="",
+                    help="model_label=target_label,... (hf-pipeline only).")
+    ap.add_argument("--onnx", action="store_true",
+                    help="GLiNER: load the ONNX file instead of PyTorch.")
+    ap.add_argument("--onnx-file", default="model_quantized.onnx")
+    ap.add_argument("--threads", type=int, default=8)
+    ap.add_argument("--device", type=int, default=-1,
+                    help="hf-pipeline: -1 = CPU, 0 = first GPU.")
+    ap.add_argument("--limit", type=int, default=None,
+                    help="Only score the first N records (smoke test).")
+    ap.add_argument("--save-predictions", default=None,
+                    help="Write per-record predictions as JSONL to this path.")
+    ap.add_argument("--json", action="store_true",
+                    help="Also dump the final metrics JSON to stdout.")
+    args = ap.parse_args()
+
+    spec = yaml.safe_load(open(args.spec))
+
+    repo = spec["dataset"]["repo_id"]
+    split = spec["dataset"]["split"]
+    print(f"Loading {repo}:{split} ...")
+    ds = load_dataset(repo, split=split)
+    if args.limit:
+        ds = ds.select(range(min(args.limit, len(ds))))
+
+    labels = spec["labels"]
+    proto = spec["inference_protocol"]
+    threshold = args.threshold if args.threshold is not None else proto["threshold"]
+    overrides = dict(proto.get("per_label_threshold_overrides") or {})
+
+    primary_metric = next(m for m in spec["metrics"] if m.get("primary"))
+    primary_iou = primary_metric.get("iou_threshold", 0.5)
+
+    print(f"Building adapter '{args.adapter}' over {args.model} ...")
+    cls = ADAPTERS[args.adapter]
+    adapter = cls(
+        model=args.model,
+        labels=labels,
+        threshold=threshold,
+        per_label_thresholds=overrides,
+        label_map=parse_kv(args.label_map),
+        onnx=args.onnx,
+        onnx_file=args.onnx_file,
+        threads=args.threads,
+        device=args.device,
+    )
+
+    print(f"Running over {len(ds)} records ...")
+    results = run(adapter, ds, primary_iou=primary_iou)
+
+    if args.save_predictions:
+        with open(args.save_predictions, "w") as f:
+            for rec, preds in zip(ds, results["predictions"]):
+                f.write(json.dumps({"id": rec.get("id"),
+                                    "text": rec["text"],
+                                    "predictions": preds}) + "\n")
+        print(f"Wrote per-record predictions -> {args.save_predictions}")
+
+    report(args.model, results)
+
+    if args.json:
+        slim = {k: v for k, v in results.items() if k != "predictions"}
+        print("\n" + json.dumps(slim, indent=2))
+
+
+if __name__ == "__main__":
+    main()