| """Construction du corpus synthetique : templates + PII generees + offsets gold. |
| |
| Usage : |
| # jeu d'evaluation (templates du pool EVAL, jamais vus en train) |
| python -m bench.synth.build --split eval --n 1500 --out data/bench_v1.jsonl |
| # corpus d'entrainement (hors git, regenerable a l'identique par seed) |
| python -m bench.synth.build --split train --n 100000 \ |
| --out data/corpus_train_100k.jsonl |
| |
| Chaque segment est un objet JSONL au format du harness (voir harness/score.py). |
| ~30 % des segments recoivent un bruitage OCR a longueur constante (offsets |
| inchanges, flag "noise": true), ~8 % sont des negatifs purs sans PII, et les |
| valeurs longues (IBAN, NIR...) peuvent etre coupees par un saut de ligne |
| (piege OCR/PDF, longueur conservee). |
| |
| Limite assumee : synthetique pur. L'eval reelle annotee main (Judilibre, |
| BODACC, documents fictifs relus) reste indispensable avant toute conclusion — |
| analyse §4.3 : "jamais du synthetique seul". |
| """ |
|
|
| import argparse |
| import json |
| import random |
| import re |
| from pathlib import Path |
|
|
| from bench.pii.generators import Person, PiiFactory |
| from bench.synth.noise import apply_noise |
| from bench.synth.templates import NEGATIVES, all_templates |
|
|
| _SLOT_RE = re.compile(r"\{([a-z_]+?)(\d+)(_v)?\}") |
|
|
| |
| _SLOT_TYPES = { |
| "person": "PERSON", "company": "COMPANY", "address": "ADDRESS", |
| "city": "CITY", "email": "EMAIL", "phone": "PHONE", "date": "DATE", |
| "date_birth": "DATE_BIRTH", "iban": "IBAN", "nir": "NIR", |
| "siren": "SIREN", "siret": "SIRET", "tva": "TVA", "card": "CARD", |
| "plate": "PLATE", "rg": "RG", "cadastre": "CADASTRE", "ip": "IP", |
| "amount": "AMOUNT", "ref": None, |
| } |
|
|
|
|
| def _maybe_linebreak(surface: str, rng: random.Random) -> str: |
| """Piege PDF/OCR : coupe une valeur longue par un saut de ligne (meme |
| longueur, un espace interieur remplace par \\n).""" |
| if len(surface) < 14 or " " not in surface[2:-2] or rng.random() > 0.04: |
| return surface |
| spaces = [i for i, c in enumerate(surface) if c == " " and 1 < i < len(surface) - 2] |
| i = rng.choice(spaces) |
| return surface[:i] + "\n" + surface[i + 1:] |
|
|
|
|
| def fill_template(template: str, factory: PiiFactory, rng: random.Random, |
| ref_label: str | None = None) -> dict: |
| values: dict[tuple[str, str], object] = {} |
| text_parts: list[str] = [] |
| entities: list[dict] = [] |
| pos = 0 |
| cursor = 0 |
|
|
| for m in _SLOT_RE.finditer(template): |
| name, idx, variant = m.group(1), m.group(2), m.group(3) |
| if name not in _SLOT_TYPES: |
| raise ValueError(f"slot inconnu : {m.group(0)}") |
|
|
| text_parts.append(template[cursor:m.start()]) |
| pos += m.start() - cursor |
| cursor = m.end() |
|
|
| key = (name, idx) |
| if key not in values: |
| values[key] = getattr(factory, name)() |
| val = values[key] |
|
|
| if isinstance(val, Person): |
| surface = rng.choice(val.variants()[1:]) if variant else val.full |
| else: |
| surface = _maybe_linebreak(str(val), rng) |
|
|
| etype = _SLOT_TYPES[name] |
| if name == "ref" and ref_label: |
| etype = ref_label |
| if etype is not None: |
| entities.append( |
| {"start": pos, "end": pos + len(surface), "type": etype, "value": surface} |
| ) |
| text_parts.append(surface) |
| pos += len(surface) |
|
|
| text_parts.append(template[cursor:]) |
| return {"text": "".join(text_parts), "entities": entities} |
|
|
|
|
| def build_corpus(n: int, seed: int, noise_share: float, |
| split: str = "all", negative_share: float = 0.08, |
| values: str = "faker", ref_label: str | None = None) -> list[dict]: |
| rng = random.Random(seed) |
| if values == "real": |
| from bench.pii.real_factory import RealValuesFactory |
|
|
| factory = RealValuesFactory(seed=seed) |
| else: |
| factory = PiiFactory(seed=seed) |
| templates = all_templates(split) |
| domains = list(templates) |
| segments = [] |
| for i in range(n): |
| if rng.random() < negative_share: |
| domain = "negatif" |
| seg = fill_template(rng.choice(NEGATIVES), factory, rng, ref_label=ref_label) |
| else: |
| domain = domains[i % len(domains)] |
| seg = fill_template(rng.choice(templates[domain]), factory, rng, ref_label=ref_label) |
| noised = rng.random() < noise_share |
| if noised: |
| seg["text"] = apply_noise(seg["text"], rng) |
| for e in seg["entities"]: |
| e["value"] = seg["text"][e["start"]:e["end"]] |
| seg = {"id": f"{split}-{domain}-{i:06d}", "domain": domain, |
| "noise": noised, **seg} |
| segments.append(seg) |
| return segments |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description="Genere le corpus benchmark synthetique") |
| ap.add_argument("--n", type=int, default=600) |
| ap.add_argument("--seed", type=int, default=42) |
| ap.add_argument("--noise-share", type=float, default=0.3) |
| ap.add_argument("--negative-share", type=float, default=0.08) |
| ap.add_argument("--split", choices=["train", "eval", "all"], default="all") |
| ap.add_argument("--values", choices=["faker", "real"], default="faker", |
| help="real = pools BODACC (anti-contamination fine-tune)") |
| ap.add_argument("--label-refs", action="store_true", |
| help="etiquette les {ref} en REF (convention 2026-07-29)") |
| ap.add_argument("--out", default="data/bench_v0.jsonl") |
| args = ap.parse_args() |
|
|
| segments = build_corpus(args.n, args.seed, args.noise_share, |
| args.split, args.negative_share, args.values, |
| "REF" if args.label_refs else None) |
| out = Path(args.out) |
| out.parent.mkdir(parents=True, exist_ok=True) |
| with out.open("w", encoding="utf-8") as f: |
| for seg in segments: |
| f.write(json.dumps(seg, ensure_ascii=False) + "\n") |
|
|
| n_ent = sum(len(s["entities"]) for s in segments) |
| n_noise = sum(1 for s in segments if s["noise"]) |
| print(f"{len(segments)} segments ({n_noise} bruites), {n_ent} entites -> {out}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
