| """Scoring for typed extraction. |
| |
| A prediction for one field is ``{"value": ..., "confidence": c, "p_null": p}``: |
| ``value`` None (an empty list for lists) means "not in the state", ``confidence`` |
| is the predictor's probability that the answer it returned -- value or null -- |
| is correct, and ``p_null`` its probability that the field is absent. |
| |
| Every field gets an exact score in {0, 1} (lists: exact set match) plus a |
| partial score (text: token F1; lists: multiset F1). Three things are reported |
| separately because a single blended number hides them: |
| |
| * **hallucination rate** -- on fields whose gold is null, the share answered |
| with a value anyway. This is the safety number for an extractor. |
| * **miss rate** -- on fields with a value, the share answered null. |
| * **accuracy at 90% coverage** -- answer only the 90% most confident fields; |
| extraction products tell users to route on confidence, so it has to mean |
| something. |
| |
| numpy only, so the scorer is testable without a model. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import datetime as dt |
| import math |
| import re |
| import string |
| from collections import Counter, defaultdict |
| from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple |
|
|
| import numpy as np |
|
|
| from .schema import (DATE, DATETIME, DURATION, LIST, NUMBER, TEXT, TIME, Case, |
| Field, Gold) |
|
|
| REL_TOL = 1e-3 |
|
|
|
|
| |
|
|
| _ARTICLES = re.compile(r"\b(a|an|the)\b", re.UNICODE) |
| _PUNCT = set(string.punctuation) |
|
|
|
|
| def norm_text(s: str) -> str: |
| """SQuAD's answer normalisation: lower, no punctuation/articles, one space.""" |
| s = "".join(ch for ch in s.lower() if ch not in _PUNCT) |
| return " ".join(_ARTICLES.sub(" ", s).split()) |
|
|
|
|
| def token_f1(pred: str, gold: str) -> float: |
| p, g = norm_text(pred).split(), norm_text(gold).split() |
| if not p or not g: |
| return float(p == g) |
| common = sum((Counter(p) & Counter(g)).values()) |
| if common == 0: |
| return 0.0 |
| prec, rec = common / len(p), common / len(g) |
| return 2 * prec * rec / (prec + rec) |
|
|
|
|
| def _num(v: Any) -> Optional[float]: |
| if isinstance(v, bool): |
| return None |
| if isinstance(v, (int, float)): |
| return float(v) |
| return None |
|
|
|
|
| def same_number(p: Any, g: Any, decimals: Optional[int] = None) -> bool: |
| a, b = _num(p), _num(g) |
| if a is None or b is None: |
| return False |
| if decimals is not None: |
| return round(a, decimals) == round(b, decimals) |
| return math.isclose(a, b, rel_tol=REL_TOL, abs_tol=1e-9) |
|
|
|
|
| def same_temporal(t: str, p: Any, g: Any) -> bool: |
| if not isinstance(p, str) or not isinstance(g, str): |
| return False |
| try: |
| if t == DATE: |
| return dt.date.fromisoformat(p) == dt.date.fromisoformat(g) |
| if t == TIME: |
| return dt.time.fromisoformat(p) == dt.time.fromisoformat(g) |
| return dt.datetime.fromisoformat(p) == dt.datetime.fromisoformat(g) |
| except ValueError: |
| return False |
|
|
|
|
| def same_scalar(t: str, p: Any, g: Any, options: Mapping[str, Any]) -> bool: |
| if t == TEXT: |
| return isinstance(p, str) and norm_text(p) == norm_text(g) |
| if t in (NUMBER, DURATION): |
| return same_number(p, g, options.get("decimals")) |
| if t in (DATE, TIME, DATETIME): |
| return same_temporal(t, p, g) |
| return False |
|
|
|
|
| def _is_null(v: Any) -> bool: |
| return v is None or v == [] |
|
|
|
|
| |
|
|
| def score_field(f: Field, gold: Gold, value: Any) -> Tuple[float, float]: |
| """(exact, partial) for one predicted value against the gold.""" |
| if gold.null or _is_null(value): |
| s = float(gold.null and _is_null(value)) |
| return s, s |
| if f.type == LIST: |
| if not isinstance(value, list): |
| return 0.0, 0.0 |
| best = max((_list_f1(f, value, g) for g in gold.accepted() if g), default=0.0) |
| return float(best >= 1.0 - 1e-9), best |
| exact = any(same_scalar(f.type, value, g, f.options) for g in gold.accepted()) |
| partial = float(exact) |
| if f.type == TEXT and isinstance(value, str): |
| partial = max(token_f1(value, g) for g in gold.accepted()) |
| return float(exact), partial |
|
|
|
|
| |
| |
| |
| LIST_TEXT_JACCARD = 0.5 |
|
|
|
|
| def _jaccard(a: str, b: str) -> float: |
| x, y = set(norm_text(a).split()), set(norm_text(b).split()) |
| return len(x & y) / len(x | y) if x | y else 1.0 |
|
|
|
|
| def _item_match(t: str, p: Any, g: Any, options: Mapping[str, Any]) -> bool: |
| if t == TEXT and isinstance(p, str) and isinstance(g, str): |
| return norm_text(p) == norm_text(g) or _jaccard(p, g) >= LIST_TEXT_JACCARD |
| return same_scalar(t, p, g, options) |
|
|
|
|
| def _list_f1(f: Field, pred: Sequence[Any], gold: Sequence[Any]) -> float: |
| t = f.item_type |
| unmatched = list(gold) |
| hit = 0 |
| for p in pred: |
| for i, g in enumerate(unmatched): |
| if _item_match(t, p, g, f.options): |
| hit += 1 |
| unmatched.pop(i) |
| break |
| if hit == 0: |
| return 0.0 |
| prec, rec = hit / len(pred), hit / len(gold) |
| return 2 * prec * rec / (prec + rec) |
|
|
|
|
| |
|
|
| def score_cases(cases: Sequence[Case], preds: Sequence[Mapping[str, Mapping[str, Any]]] |
| ) -> Dict[str, Any]: |
| rows: List[Dict[str, Any]] = [] |
| for case, pred in zip(cases, preds): |
| for name, f in case.fields.items(): |
| g = case.gold[name] |
| p = pred.get(name) or {} |
| value = p.get("value") |
| exact, partial = score_field(f, g, value) |
| rows.append({ |
| "case": case.id, "family": case.family, "type": f.type, |
| "gold_null": g.null, "pred_null": _is_null(value), "source": g.source, |
| "exact": exact, "partial": partial, |
| "confidence": p.get("confidence"), "p_null": p.get("p_null")}) |
| return summarise(rows) |
|
|
|
|
| def summarise(rows: Sequence[Mapping[str, Any]]) -> Dict[str, Any]: |
| if not rows: |
| return {"fields": 0} |
| exact = np.array([r["exact"] for r in rows]) |
| out: Dict[str, Any] = {"fields": len(rows), "cases": len({r["case"] for r in rows}), |
| "exact": float(exact.mean()), |
| "partial": float(np.mean([r["partial"] for r in rows]))} |
| by_type: Dict[str, List[float]] = defaultdict(list) |
| for r in rows: |
| by_type[r["type"]].append(r["exact"]) |
| out["by_type"] = {t: {"n": len(v), "exact": float(np.mean(v))} for t, v in sorted(by_type.items())} |
| out["macro_exact"] = float(np.mean([v["exact"] for v in out["by_type"].values()])) |
|
|
| by_family: Dict[str, List[Mapping[str, Any]]] = defaultdict(list) |
| for r in rows: |
| by_family[r["family"]].append(r) |
| out["by_family"] = {k: _family(v) for k, v in sorted(by_family.items())} |
| |
| |
| out["macro_family_exact"] = float(np.mean([v["exact"] for v in out["by_family"].values()])) |
| present = [v["exact_present"] for v in out["by_family"].values() if v.get("exact_present") is not None] |
| out["macro_family_exact_present"] = float(np.mean(present)) if present else None |
|
|
| by_source: Dict[str, List[float]] = defaultdict(list) |
| for r in rows: |
| if not r["gold_null"]: |
| by_source[r["source"]].append(r["exact"]) |
| out["by_source"] = {k: {"n": len(v), "exact": float(np.mean(v))} for k, v in sorted(by_source.items())} |
|
|
| out.update(_null_metrics(rows)) |
| out.update(_confidence_metrics(rows)) |
| return out |
|
|
|
|
| def _family(rows: Sequence[Mapping[str, Any]]) -> Dict[str, Any]: |
| d = {"n": len(rows), "exact": float(np.mean([r["exact"] for r in rows])), |
| "partial": float(np.mean([r["partial"] for r in rows]))} |
| d.update(_null_metrics(rows)) |
| return d |
|
|
|
|
| def _null_metrics(rows: Sequence[Mapping[str, Any]]) -> Dict[str, Any]: |
| null = [r for r in rows if r["gold_null"]] |
| full = [r for r in rows if not r["gold_null"]] |
| out: Dict[str, Any] = { |
| "null_share": len(null) / len(rows), |
| "hallucination": (float(np.mean([not r["pred_null"] for r in null])) if null else None), |
| "miss": (float(np.mean([r["pred_null"] for r in full])) if full else None), |
| "exact_present": (float(np.mean([r["exact"] for r in full])) if full else None), |
| } |
| scored = [r for r in rows if r.get("p_null") is not None] |
| if null and full and len(scored) == len(rows): |
| out["p_null_auroc"] = auroc([r["p_null"] for r in rows], [r["gold_null"] for r in rows]) |
| return out |
|
|
|
|
| def _confidence_metrics(rows: Sequence[Mapping[str, Any]]) -> Dict[str, Any]: |
| conf = [r["confidence"] for r in rows] |
| if any(c is None for c in conf): |
| return {} |
| c = np.clip(np.array(conf, dtype=float), 0.0, 1.0) |
| y = np.array([r["exact"] for r in rows], dtype=float) |
| order = np.argsort(-c, kind="stable") |
| k = max(1, int(round(0.9 * len(rows)))) |
| return {"ece": ece(c, y), "brier": float(np.mean((c - y) ** 2)), |
| "exact_at_90_coverage": float(y[order[:k]].mean()), |
| "aurc": aurc(c, y)} |
|
|
|
|
| def ece(conf: np.ndarray, correct: np.ndarray, bins: int = 10) -> float: |
| edges = np.linspace(0.0, 1.0, bins + 1) |
| idx = np.clip(np.digitize(conf, edges[1:-1]), 0, bins - 1) |
| total = 0.0 |
| for b in range(bins): |
| m = idx == b |
| if m.any(): |
| total += m.mean() * abs(conf[m].mean() - correct[m].mean()) |
| return float(total) |
|
|
|
|
| def aurc(conf: np.ndarray, correct: np.ndarray) -> float: |
| """Area under the risk-coverage curve (lower is better).""" |
| order = np.argsort(-conf, kind="stable") |
| risk = np.cumsum(1.0 - correct[order]) / np.arange(1, len(order) + 1) |
| return float(risk.mean()) |
|
|
|
|
| def auroc(scores: Sequence[float], labels: Sequence[bool]) -> Optional[float]: |
| s = np.asarray(scores, dtype=float) |
| y = np.asarray(labels, dtype=bool) |
| pos, neg = s[y], s[~y] |
| if len(pos) == 0 or len(neg) == 0: |
| return None |
| ranks = _rankdata(np.concatenate([pos, neg])) |
| return float((ranks[:len(pos)].sum() - len(pos) * (len(pos) + 1) / 2) / (len(pos) * len(neg))) |
|
|
|
|
| def _rankdata(a: np.ndarray) -> np.ndarray: |
| order = np.argsort(a, kind="mergesort") |
| ranks = np.empty(len(a), dtype=float) |
| sa = a[order] |
| i = 0 |
| while i < len(a): |
| j = i |
| while j + 1 < len(a) and sa[j + 1] == sa[i]: |
| j += 1 |
| ranks[order[i:j + 1]] = (i + j) / 2 + 1 |
| i = j + 1 |
| return ranks |
|
|
