| |
| """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 |
|
|
|
|
| |
| |
| |
| 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)], |
| } |
|
|
|
|
| |
| |
| |
| 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, |
| } |
|
|
|
|
| |
| |
| |
| 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() |
|
|
