| """Harness de scoring — metrique reine : leak rate par type d'entite. |
| |
| Format d'echange (JSONL, un segment par ligne) : |
| {"id": "...", "text": "...", "domain": "juridique", "noise": false, |
| "entities": [{"start": 10, "end": 21, "type": "PERSON", "value": "Jean Dupont"}]} |
| |
| Les predictions suivent le meme format (memes ids, offsets sur le meme texte). |
| |
| Definitions (voir doc/memory/analyse.md §5.1) : |
| - Une entite gold est COUVERTE si l'union des spans predits (tous types |
| confondus) couvre 100 % de ses caracteres significatifs (espaces/ponctuation |
| de bord exclus). Un IBAN masque aux 3/4 est une FUITE, pas un succes partiel. |
| - leak rate = 1 - (couvertes / total), par type et global. |
| - partial rate = entites touchees mais pas entierement couvertes (fuites |
| quand meme, comptees a part car symptome different : frontieres de spans). |
| - over-masking = part des caracteres predits qui ne recouvrent aucune entite |
| gold (bruit impose au LLM). |
| - F1 span exact avec normalisation des frontieres (strip ponctuation, espaces |
| et titres M./Mme/Me/Dr) + match du type. |
| """ |
|
|
| import json |
| from collections import defaultdict |
| from dataclasses import dataclass |
|
|
| _TITLES = ("M. ", "Mme ", "Me ", "Dr ", "Monsieur ", "Madame ", "Maître ") |
| _STRIP_CHARS = " \t\n.,;:()[]«»\"'" |
|
|
|
|
| @dataclass(frozen=True) |
| class Span: |
| start: int |
| end: int |
| type: str |
|
|
| def normalized(self, text: str) -> "Span": |
| s, e = self.start, self.end |
| while s < e and text[s] in _STRIP_CHARS: |
| s += 1 |
| while e > s and text[e - 1] in _STRIP_CHARS: |
| e -= 1 |
| for t in _TITLES: |
| if text[s:e].startswith(t): |
| s += len(t) |
| break |
| return Span(s, e, self.type) |
|
|
|
|
| def _significant_chars(text: str, span: Span) -> set[int]: |
| n = span.normalized(text) |
| return {i for i in range(n.start, n.end) if text[i] not in _STRIP_CHARS} |
|
|
|
|
| def load_jsonl(path) -> dict[str, dict]: |
| docs = {} |
| with open(path, encoding="utf-8") as f: |
| for line in f: |
| line = line.strip() |
| if line: |
| d = json.loads(line) |
| docs[d["id"]] = d |
| return docs |
|
|
|
|
| def _spans(doc: dict) -> list[Span]: |
| return [Span(e["start"], e["end"], e["type"]) for e in doc.get("entities", [])] |
|
|
|
|
| def score(gold_docs: dict[str, dict], pred_docs: dict[str, dict]) -> dict: |
| per_type = defaultdict(lambda: {"total": 0, "covered": 0, "partial": 0, "missed": 0}) |
| exact = defaultdict(lambda: {"tp": 0, "fp": 0, "fn": 0}) |
| overmask_chars = 0 |
| pred_chars = 0 |
|
|
| for doc_id, gold in gold_docs.items(): |
| text = gold["text"] |
| pred = pred_docs.get(doc_id, {"entities": []}) |
| gspans, pspans = _spans(gold), _spans(pred) |
|
|
| pred_cover = set() |
| for p in pspans: |
| pred_cover |= set(range(p.start, p.end)) |
|
|
| gold_cover = set() |
| for g in gspans: |
| gold_cover |= set(range(g.start, g.end)) |
|
|
| |
| for g in gspans: |
| sig = _significant_chars(text, g) |
| if not sig: |
| continue |
| hit = len(sig & pred_cover) |
| st = per_type[g.type] |
| st["total"] += 1 |
| if hit == len(sig): |
| st["covered"] += 1 |
| elif hit > 0: |
| st["partial"] += 1 |
| else: |
| st["missed"] += 1 |
|
|
| |
| sig_pred = {i for i in pred_cover if i < len(text) and text[i] not in _STRIP_CHARS} |
| pred_chars += len(sig_pred) |
| overmask_chars += len(sig_pred - gold_cover) |
|
|
| |
| gset = {(s.normalized(text)) for s in gspans} |
| pset = {(s.normalized(text)) for s in pspans} |
| for s in gset & pset: |
| exact[s.type]["tp"] += 1 |
| for s in gset - pset: |
| exact[s.type]["fn"] += 1 |
| for s in pset - gset: |
| exact[s.type]["fp"] += 1 |
|
|
| report = {"per_type": {}, "global": {}} |
| tot = {"total": 0, "covered": 0, "partial": 0, "missed": 0} |
| for etype in sorted(per_type): |
| st = per_type[etype] |
| ex = exact[etype] |
| prec = ex["tp"] / (ex["tp"] + ex["fp"]) if ex["tp"] + ex["fp"] else 0.0 |
| rec = ex["tp"] / (ex["tp"] + ex["fn"]) if ex["tp"] + ex["fn"] else 0.0 |
| f1 = 2 * prec * rec / (prec + rec) if prec + rec else 0.0 |
| report["per_type"][etype] = { |
| **st, |
| "leak_rate": 1 - st["covered"] / st["total"] if st["total"] else 0.0, |
| "exact_precision": round(prec, 4), |
| "exact_recall": round(rec, 4), |
| "exact_f1": round(f1, 4), |
| } |
| for k in tot: |
| tot[k] += st[k] |
|
|
| report["global"] = { |
| **tot, |
| "leak_rate": 1 - tot["covered"] / tot["total"] if tot["total"] else 0.0, |
| "overmask_rate": overmask_chars / pred_chars if pred_chars else 0.0, |
| } |
| return report |
|
|
|
|
| def format_report(report: dict) -> str: |
| lines = [ |
| f"{'type':<12} {'total':>6} {'covered':>8} {'partial':>8} {'missed':>7} " |
| f"{'LEAK':>7} {'P':>6} {'R':>6} {'F1':>6}" |
| ] |
| for etype, st in report["per_type"].items(): |
| lines.append( |
| f"{etype:<12} {st['total']:>6} {st['covered']:>8} {st['partial']:>8} " |
| f"{st['missed']:>7} {st['leak_rate']:>7.2%} {st['exact_precision']:>6.2f} " |
| f"{st['exact_recall']:>6.2f} {st['exact_f1']:>6.2f}" |
| ) |
| g = report["global"] |
| lines.append("-" * len(lines[0])) |
| lines.append( |
| f"{'GLOBAL':<12} {g['total']:>6} {g['covered']:>8} {g['partial']:>8} " |
| f"{g['missed']:>7} {g['leak_rate']:>7.2%} over-masking {g['overmask_rate']:.2%}" |
| ) |
| return "\n".join(lines) |
|
|
|
|
| def main(): |
| import argparse |
|
|
| ap = argparse.ArgumentParser(description="Score des predictions PII vs gold") |
| ap.add_argument("gold") |
| ap.add_argument("pred") |
| ap.add_argument("--json", action="store_true", help="sortie JSON complete") |
| args = ap.parse_args() |
|
|
| report = score(load_jsonl(args.gold), load_jsonl(args.pred)) |
| if args.json: |
| print(json.dumps(report, ensure_ascii=False, indent=2)) |
| else: |
| print(format_report(report)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
