@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/eval/coreml_encoder.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Direct coremltools conversion of the mdeberta encoder — the fair test of the ANE.
+
+onnxruntime's CoreML execution provider is not a verdict on the Neural Engine: it only
+claimed 592 of 1825 nodes and split the graph into 25 partitions, so every forward pass
+would pay 25 CPU<->CoreML round trips. coremltools converts the whole traced graph into
+one MLProgram instead, which is the only way to know whether mdeberta can run on the ANE
+at all.
+
+Batch 1 (not 8): conversion peaks at several GB and this machine has 8. The comparison is
+therefore against torch at batch 1 too — same tensor, same process, same threads.
+
+    python3 coreml_encoder.py convert
+    python3 coreml_encoder.py bench {torch,all,ane,cpugpu}
+"""
+import json
+import os
+import sys
+import time
+
+import numpy as np
+import torch
+
+S = os.path.dirname(os.path.abspath(__file__))
+ART = os.path.join(S, "artifacts")
+INPUTS = os.path.join(ART, "encoder_inputs.pt")
+
+torch.set_num_threads(6)
+torch.set_grad_enabled(False)
+
+
+class Wrap(torch.nn.Module):
+    def __init__(self, enc):
+        super().__init__()
+        self.enc = enc
+
+    def forward(self, input_ids, attention_mask):
+        return self.enc(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state
+
+
+# Sequence length of the converted model. 772 was simply the length of the captured batch;
+# it turned out to be too short for French: real batches reach 811 tokens (padding is to the
+# longest sequence in the batch), so 2 of 3 batches of the Assignation fell back to torch and
+# most of the speed-up was lost. 832 covers every length measured on the Dossier AVION.
+SEQ = int(os.environ.get("PIECEMAKER_COREML_SEQ", "832"))
+MLPKG = os.path.join(ART, f"encoder_b1_{SEQ}.mlpackage")
+REF1 = os.path.join(ART, f"encoder_ref_b1_{SEQ}.npy")
+RESULTS = os.path.join(ART, "coreml_bench.json")
+
+
+def _b1():
+    inp = torch.load(INPUTS)
+    ids, mask = inp["input_ids"][:1], inp["attention_mask"][:1]
+    n = ids.shape[1]
+    if n < SEQ:
+        ids = torch.nn.functional.pad(ids, (0, SEQ - n))
+        mask = torch.nn.functional.pad(mask, (0, SEQ - n))
+    return ids[:, :SEQ], mask[:, :SEQ]
+
+
+def _save(name, entry):
+    all_res = json.load(open(RESULTS, encoding="utf-8")) if os.path.exists(RESULTS) else {}
+    all_res[name] = entry
+    json.dump(all_res, open(RESULTS, "w"), indent=1)
+    print(f"[{name}] {entry}", flush=True)
+
+
+def _patch_deberta_scale():
+    """deberta computes its attention scale as sqrt(tensor(query.size(-1)) * factor).
+
+    Under torch.jit.trace, size(-1) becomes a traced int32 tensor and the dtype argument is
+    lost, so coremltools receives sqrt(int32) and refuses it ("expects fp16/fp32, got
+    int32"). The shape is fixed in this conversion anyway, so folding the scale into a
+    python float makes it a constant — mathematically identical, and traceable.
+    """
+    from transformers.models.deberta_v2 import modeling_deberta_v2 as m
+
+    def scaled_size_sqrt(query_layer, scale_factor):
+        return torch.tensor(float(query_layer.size(-1)) * scale_factor).sqrt()
+
+    # The methods resolve the name from module globals at call time, so rebinding the
+    # module attribute is enough.
+    m.scaled_size_sqrt = scaled_size_sqrt
+
+    # build_rpos carries @torch.jit.script, so its `if` survives tracing as a prim::If
+    # whose two branches return different ranks ([1,772,772] vs [1,1,772,772]) — MIL
+    # rejects a cond whose branches disagree on type. In self-attention query and key are
+    # the same length, so the condition is statically false; evaluating it in python folds
+    # the branch away.
+    def build_rpos(query_layer, key_layer, relative_pos, position_buckets: int,
+                   max_relative_positions: int):
+        if key_layer.size(-2) != query_layer.size(-2):
+            return m.build_relative_position(key_layer, key_layer, bucket_size=position_buckets,
+                                             max_position=max_relative_positions)
+        return relative_pos
+
+    m.build_rpos = build_rpos
+
+    # deberta masks with torch.finfo(fp32).min = -3.4e38. That constant is baked into the
+    # trace, and it is NOT representable in fp16: CoreML turns it into -inf, a fully masked
+    # softmax row becomes 0/0, and the whole output is NaN (measured: max_delta = nan on
+    # the GPU). -1e4 is the standard fp16-safe mask value and is just as saturating after
+    # softmax.
+    _masked_fill = torch.Tensor.masked_fill
+
+    def masked_fill(self, mask, value):
+        if isinstance(value, (int, float)) and value < -1e4:
+            value = -1e4
+        return _masked_fill(self, mask, value)
+
+    torch.Tensor.masked_fill = masked_fill
+
+
+def convert():
+    import coremltools as ct
+    from gliner2 import GLiNER2
+
+    _patch_deberta_scale()
+    ids, mask = _b1()
+    model = GLiNER2.from_pretrained("fastino/gliner2-multi-v1").eval()
+    wrap = Wrap(model.encoder).eval()
+
+    ref = wrap(ids, mask)
+    np.save(REF1, ref.numpy())
+    del model
+
+    print("tracing...", flush=True)
+    traced = torch.jit.trace(wrap, (ids, mask), strict=False)
+
+    print("converting to MLProgram (fp16)...", flush=True)
+    mlmodel = ct.convert(
+        traced,
+        inputs=[ct.TensorType(name="input_ids", shape=ids.shape, dtype=np.int32),
+                ct.TensorType(name="attention_mask", shape=mask.shape, dtype=np.int32)],
+        outputs=[ct.TensorType(name="last_hidden_state")],
+        convert_to="mlprogram",
+        compute_precision=ct.precision.FLOAT16,
+        minimum_deployment_target=ct.target.macOS14,
+    )
+    mlmodel.save(MLPKG)
+    print(f"saved {MLPKG}", flush=True)
+
+
+def bench():
+    which = sys.argv[2]
+    ids, mask = _b1()
+
+    if which == "torch":
+        from gliner2 import GLiNER2
+        enc = GLiNER2.from_pretrained("fastino/gliner2-multi-v1").eval().encoder
+        fn = lambda: enc(input_ids=ids, attention_mask=mask)  # noqa: E731
+        fn()
+        ts = [(_t := time.perf_counter(), fn(), time.perf_counter() - _t)[2] for _ in range(3)]
+        _save("torch-fp32-b1", {"best_s": min(ts), "avg_s": sum(ts) / len(ts), "max_delta": 0.0})
+        return
+
+    import coremltools as ct
+    units = {"all": ct.ComputeUnit.ALL,
+             "ane": ct.ComputeUnit.CPU_AND_NE,
+             "cpugpu": ct.ComputeUnit.CPU_AND_GPU}[which]
+    t0 = time.perf_counter()
+    m = ct.models.MLModel(MLPKG, compute_units=units)
+    load_s = time.perf_counter() - t0
+    print(f"chargement/compilation: {load_s:.1f}s", flush=True)
+
+    feed = {"input_ids": ids.numpy().astype(np.int32),
+            "attention_mask": mask.numpy().astype(np.int32)}
+    out = m.predict(feed)["last_hidden_state"]
+    ref = np.load(REF1)
+    d = float(np.abs(out - ref).max())
+
+    ts = []
+    for _ in range(3):
+        t = time.perf_counter()
+        m.predict(feed)
+        ts.append(time.perf_counter() - t)
+    _save(f"coreml-{which}", {"best_s": min(ts), "avg_s": sum(ts) / len(ts),
+                              "max_delta": d, "load_s": round(load_s, 1)})
+
+
+if __name__ == "__main__":
+    {"convert": convert, "bench": bench}[sys.argv[1]]()

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/eval/encoder_backends.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Isolate the mdeberta encoder (92 % of the wall clock) and time it under every backend
+available on this machine, on the real tensors the pipeline feeds it.
+
+Backends compared, all on the same captured batch:
+  torch-fp32   what ships today (Accelerate/AMX GEMM on the M1's performance cores)
+  ort-cpu      onnxruntime, CPU execution provider
+  ort-coreml   onnxruntime, CoreML execution provider (GPU + Neural Engine)
+  ort-int8     onnxruntime dynamic int8 quantisation, CPU
+
+Also reports max |Δ| on last_hidden_state against torch-fp32: a backend that is fast but
+drifts is caught here, before spending an hour on the corpus.
+
+    python3 encoder_backends.py capture   # dump real input tensors
+    python3 encoder_backends.py export    # torch -> onnx
+    python3 encoder_backends.py bench
+"""
+import json
+import os
+import sys
+import time
+
+import numpy as np
+import torch
+
+S = os.path.dirname(os.path.abspath(__file__))
+ART = os.path.join(S, "artifacts")
+os.makedirs(ART, exist_ok=True)
+INPUTS = os.path.join(ART, "encoder_inputs.pt")
+ONNX_FP32 = os.path.join(ART, "encoder_fp32.onnx")
+ONNX_INT8 = os.path.join(ART, "encoder_int8.onnx")
+# CoreML refuses unbounded dimensions ("has unbounded dimension which is not supported"),
+# so the dynamic export gets partitioned into 97 fragments and falls back. A static-shape
+# export is the only one CoreML can actually compile.
+ONNX_STATIC = os.path.join(ART, "encoder_static.onnx")
+RESULTS = os.path.join(ART, "encoder_bench.json")
+
+torch.set_num_threads(6)
+torch.set_grad_enabled(False)
+
+
+def load_model():
+    from gliner2 import GLiNER2
+    m = GLiNER2.from_pretrained("fastino/gliner2-multi-v1")
+    m.eval()
+    return m
+
+
+# ---------------------------------------------------------------------------
+def capture():
+    """Run one real batch through the pipeline and keep the encoder's inputs."""
+    from bench_backend import BATCH, DESCS, FLOOR, chunk
+    text = open(os.path.join(S, "slice_C.md"), encoding="utf-8").read()
+    chunks = chunk(text)[:BATCH]
+
+    model = load_model()
+    grabbed = {}
+    real = model.encoder.forward
+
+    def grab(input_ids=None, attention_mask=None, **kw):
+        if "input_ids" not in grabbed:
+            grabbed["input_ids"] = input_ids.detach().clone()
+            grabbed["attention_mask"] = attention_mask.detach().clone()
+        return real(input_ids=input_ids, attention_mask=attention_mask, **kw)
+
+    model.encoder.forward = grab
+    model.batch_extract_entities(chunks, DESCS, batch_size=BATCH, threshold=FLOOR,
+                                 include_confidence=True, include_spans=True)
+    torch.save(grabbed, INPUTS)
+    print(f"capture: input_ids {tuple(grabbed['input_ids'].shape)} -> {INPUTS}")
+
+
+# ---------------------------------------------------------------------------
+def export():
+    inp = torch.load(INPUTS)
+    model = load_model()
+    encoder = model.encoder
+
+    class Wrap(torch.nn.Module):
+        """last_hidden_state only — the heads stay in torch, they are 8 % of the time."""
+
+        def __init__(self, enc):
+            super().__init__()
+            self.enc = enc
+
+        def forward(self, input_ids, attention_mask):
+            return self.enc(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state
+
+    wrap = Wrap(encoder).eval()
+    print("exporting to ONNX (opset 17)...", flush=True)
+    torch.onnx.export(
+        wrap, (inp["input_ids"], inp["attention_mask"]), ONNX_FP32,
+        input_names=["input_ids", "attention_mask"], output_names=["last_hidden_state"],
+        dynamic_axes={"input_ids": {0: "b", 1: "s"}, "attention_mask": {0: "b", 1: "s"},
+                      "last_hidden_state": {0: "b", 1: "s"}},
+        opset_version=17, do_constant_folding=True, dynamo=False,
+    )
+    print(f"export: {ONNX_FP32} ({os.path.getsize(ONNX_FP32) / 1e6:.0f} Mo)")
+
+    from onnxruntime.quantization import QuantType, quantize_dynamic
+    print("quantizing int8 (dynamic, per-channel)...", flush=True)
+    quantize_dynamic(ONNX_FP32, ONNX_INT8, weight_type=QuantType.QInt8, per_channel=True)
+    print(f"export: {ONNX_INT8} ({os.path.getsize(ONNX_INT8) / 1e6:.0f} Mo)")
+
+    print("exporting static-shape ONNX for CoreML...", flush=True)
+    torch.onnx.export(
+        wrap, (inp["input_ids"], inp["attention_mask"]), ONNX_STATIC,
+        input_names=["input_ids", "attention_mask"], output_names=["last_hidden_state"],
+        opset_version=17, do_constant_folding=True, dynamo=False,
+    )
+    print(f"export: {ONNX_STATIC} ({os.path.getsize(ONNX_STATIC) / 1e6:.0f} Mo)")
+
+
+# ---------------------------------------------------------------------------
+def _time(fn, n=3):
+    fn()  # warm-up
+    ts = []
+    for _ in range(n):
+        t = time.perf_counter()
+        fn()
+        ts.append(time.perf_counter() - t)
+    return min(ts), sum(ts) / len(ts)
+
+
+REF_NPY = os.path.join(ART, "encoder_ref.npy")
+
+COREML = {"ModelFormat": "MLProgram", "MLComputeUnits": "ALL"}
+ORT_BACKENDS = {
+    "ort-cpu":           (ONNX_FP32,   ["CPUExecutionProvider"]),
+    "ort-int8":          (ONNX_INT8,   ["CPUExecutionProvider"]),
+    "ort-coreml-dyn":    (ONNX_FP32,   [("CoreMLExecutionProvider", COREML), "CPUExecutionProvider"]),
+    "ort-coreml-static": (ONNX_STATIC, [("CoreMLExecutionProvider", COREML), "CPUExecutionProvider"]),
+    "ort-coreml-ane":    (ONNX_STATIC, [("CoreMLExecutionProvider", dict(COREML, MLComputeUnits="CPUAndNeuralEngine")),
+                                        "CPUExecutionProvider"]),
+}
+
+
+def _save(name, entry):
+    all_res = json.load(open(RESULTS, encoding="utf-8")) if os.path.exists(RESULTS) else {}
+    all_res[name] = entry
+    json.dump(all_res, open(RESULTS, "w"), indent=1)
+    print(f"\n[{name}] {entry}")
+
+
+def bench():
+    """One backend per process — a torch model plus three 1 GB ORT sessions in the same
+    process is killed by the OOM killer on this 8 GB machine (exit 137)."""
+    name = sys.argv[2]
+    inp = torch.load(INPUTS)
+    ids, mask = inp["input_ids"], inp["attention_mask"]
+
+    if name == "torch-fp32":
+        enc = load_model().encoder
+        ref = enc(input_ids=ids, attention_mask=mask).last_hidden_state
+        np.save(REF_NPY, ref.numpy())
+        best, avg = _time(lambda: enc(input_ids=ids, attention_mask=mask))
+        _save(name, {"best_s": best, "avg_s": avg, "max_delta": 0.0,
+                     "shape": list(ids.shape)})
+        return
+
+    import onnxruntime as ort
+    path, providers = ORT_BACKENDS[name]
+    ref = np.load(REF_NPY)
+    feed = {"input_ids": ids.numpy(), "attention_mask": mask.numpy()}
+    try:
+        so = ort.SessionOptions()
+        so.intra_op_num_threads = 6
+        sess = ort.InferenceSession(path, so, providers=providers)
+        out = sess.run(None, feed)[0]
+        d = float(np.abs(out - ref).max())
+        best, avg = _time(lambda: sess.run(None, feed))
+        _save(name, {"best_s": best, "avg_s": avg, "max_delta": d,
+                     "providers": sess.get_providers()})
+    except Exception as exc:
+        _save(name, {"error": f"{type(exc).__name__}: {exc}"})
+
+
+if __name__ == "__main__":
+    {"capture": capture, "export": export, "bench": bench}[sys.argv[1]]()

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/eval/evaluate.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Score every configuration against the reference annotation, sweeping the threshold
+offline (the sweep stored all predictions down to 0.05).
+
+Metric rationale — anonymisation substitutes entity strings globally, so:
+  * RECALL is over DISTINCT gold entities: finding an entity once redacts every mention.
+    A miss is PII left in a document handed to a third party.
+  * PRECISION matters more than usual: a false positive is not one redacted word, it is
+    every occurrence of that string rewritten across the whole document.
+"""
+import json, os, sys, unicodedata, re
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from gold import GOLD, PERSON_KEY
+
+S = os.path.dirname(os.path.abspath(__file__))
+# Defaults to the configuration sweep; pass bench_results.json explicitly to score
+# inference backends with this exact scoring.
+RESULTS_FILE = sys.argv[1] if len(sys.argv) > 1 else "sweep_results.json"
+OUT_FILE = sys.argv[2] if len(sys.argv) > 2 else "eval_results.json"
+RES = json.load(open(os.path.join(S, RESULTS_FILE), encoding="utf-8"))
+SLICE_TEXT = {n: open(os.path.join(S, f"{n}.md"), encoding="utf-8").read()
+              for n in ("slice_A", "slice_B", "slice_C")}
+
+norm = lambda s: re.sub(r"\s+", " ", unicodedata.normalize("NFKC", s)).strip().lower()
+
+
+def matches(pred_text, pred_type, gold_text, gold_type):
+    if pred_type != gold_type:
+        return False
+    p, g = norm(pred_text), norm(gold_text)
+    if gold_type == "PERSON":
+        return PERSON_KEY.get(gold_text, g) in p
+    return p == g or p in g or g in p
+
+
+def is_fragment(pred_text, pred_type, gold):
+    """A prediction that is a strict part of a gold entity of the same type.
+
+    "Elsy" alongside the correctly detected "Elsy Boglioli" is not a hallucination:
+    it is a shorter span nested inside a real entity, and resolve_overlapping_spans
+    deletes it before anything reaches the mapping. Counting it as a false positive
+    would charge the model for something the pipeline already removes, so fragments
+    are reported separately and excluded from precision.
+    """
+    p = norm(pred_text)
+    for gtype, gitems in gold.items():
+        if gtype != pred_type:
+            continue
+        for g in gitems:
+            ng = norm(g)
+            if p != ng and p in ng:
+                return True
+    return False
+
+
+def score(preds, slice_name, threshold):
+    gold = GOLD[slice_name]
+    kept = [p for p in preds if p["score"] >= threshold]
+
+    found, missed = 0, []
+    for gtype, gitems in gold.items():
+        for g in gitems:
+            if any(matches(p["text"], p["type"], g, gtype) for p in kept):
+                found += 1
+            else:
+                missed.append(f"{gtype}:{g}")
+    total_gold = sum(len(v) for v in gold.values())
+
+    tp, fp, frag = 0, [], []
+    for p in kept:
+        if any(matches(p["text"], p["type"], g, gtype)
+               for gtype, gitems in gold.items() for g in gitems):
+            tp += 1
+        elif is_fragment(p["text"], p["type"], gold):
+            frag.append(f"{p['type']}:{p['text']}")
+        else:
+            fp.append(f"{p['type']}:{p['text']}")
+    scored = tp + len(fp)  # fragments are removed by span arbitration, not charged
+    return {
+        "recall": found / total_gold if total_gold else 1.0,
+        "precision": tp / scored if scored else 1.0,
+        "n_pred": len(kept), "gold": total_gold,
+        "missed": missed, "fp": fp, "fragments": frag,
+    }
+
+
+def blast(fp_labels, slice_name):
+    """How many words of the document a config's false positives would rewrite."""
+    text = SLICE_TEXT[slice_name]
+    total = 0
+    for lab in fp_labels:
+        ent = lab.split(":", 1)[1]
+        if len(ent) < 2:
+            continue
+        total += len(re.findall(r"(?<!\w)" + re.escape(ent) + r"(?!\w)", text, re.I))
+    return total
+
+
+THRESHOLDS = [0.05, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90]
+
+print(f"{'config':<16}{'thr':>5}{'rappel':>9}{'precis.':>9}{'F1':>7}{'F2':>7}"
+      f"{'pred':>6}{'FP mots':>9}")
+print("-" * 68)
+best = []
+for cfg, data in RES.items():
+    for thr in THRESHOLDS:
+        R = P = 0.0
+        npred = fpw = 0
+        allmissed, allfp, allfrag = [], [], []
+        for sname in SLICE_TEXT:
+            s = score(data["slices"][sname], sname, thr)
+            R += s["recall"] / 3
+            P += s["precision"] / 3
+            npred += s["n_pred"]
+            allmissed += s["missed"]
+            allfp += s["fp"]
+            allfrag += s.get("fragments", [])
+            fpw += blast(s["fp"], sname)
+        f1 = 2 * P * R / (P + R) if P + R else 0
+        f2 = 5 * P * R / (4 * P + R) if P + R else 0
+        print(f"{cfg:<16}{thr:>5.2f}{R:>9.3f}{P:>9.3f}{f1:>7.3f}{f2:>7.3f}{npred:>6}{fpw:>9}")
+        best.append((cfg, thr, R, P, f1, f2, npred, fpw, allmissed, allfp, allfrag))
+    print("-" * 68)
+
+json.dump([{"config": b[0], "threshold": b[1], "recall": b[2], "precision": b[3],
+            "f1": b[4], "f2": b[5], "n_pred": b[6], "fp_words": b[7],
+            "missed": b[8], "fp": b[9], "fragments": b[10]} for b in best],
+          open(os.path.join(S, OUT_FILE), "w", encoding="utf-8"),
+          ensure_ascii=False, indent=1)
+print(f"\nWROTE {OUT_FILE}")

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/eval/gold.py

@@ -0,0 +1,59 @@
+"""Reference annotation for three fixed slices of GENSIGHT_URD_2023.
+
+ANNOTATED BY CLAUDE, NOT BY THE USER. It encodes one explicit editorial rule that a
+lawyer may want to overrule, so it must be reviewed before any of it is treated as
+ground truth:
+
+  * A *named, identifiable* body is an ORGANIZATION (FDA, EMA, Sofinnova Partners SAS).
+  * A *generic institutional role* is not (Institutional Review Board, IBC, DSMB,
+    "advisory committee", "Board of Directors").
+  * Job titles are never PERSON ("Chief Executive Officer", "Chairman").
+  * Products, clinical trials, genes, laws and standards are not entities
+    (LUMEVOQ®, REVERSE, ND4, PDUFA, GMP).
+  * Journals and publications are not organisations (Ophthalmology Therapy).
+
+Recall is scored over DISTINCT entities, not occurrences: anonymisation substitutes by
+string globally, so detecting an entity once is enough to redact every mention.
+"""
+
+GOLD = {
+    "slice_A": {
+        "PERSON": [],
+        "ORGANIZATION": [
+            "GenSight Biologics", "GenSight", "EMA", "FDA", "MHRA",
+            "CAT", "Santhera",
+        ],
+        "LOCATION": ["Europe", "United States", "European Union", "France",
+                     "United Kingdom", "UK"],
+    },
+    "slice_B": {
+        "PERSON": [],
+        "ORGANIZATION": [
+            "FDA", "NIH", "NIH Office of Biotechnology Activities", "OBA", "RAC",
+            "GenSight Biologics", "National Institute of Health",
+        ],
+        "LOCATION": ["U.S."],
+    },
+    "slice_C": {
+        "PERSON": [
+            "Bernard Gilly", "Philippe Motté", "Michael Wyzga", "Laurence Rodriguez",
+            "Peter Goodfellow", "Simone Seiter", "Maritza McIntyre", "Elsy Boglioli",
+            "Françoise de Craecker", "Natalie Mount", "Cédric Moreau",
+        ],
+        "ORGANIZATION": [
+            "GenSight Biologics", "GenSight Biologics France SAS",
+            "Sofinnova Partners SAS", "AMF",
+        ],
+        "LOCATION": [],
+    },
+}
+
+# Distinctive token used for relaxed matching of a person: a prediction counts as
+# finding the person if it carries the surname ("Mr. Gilly", "Gilly", "Bernard Gilly").
+PERSON_KEY = {
+    "Bernard Gilly": "gilly", "Philippe Motté": "motté", "Michael Wyzga": "wyzga",
+    "Laurence Rodriguez": "rodriguez", "Peter Goodfellow": "goodfellow",
+    "Simone Seiter": "seiter", "Maritza McIntyre": "mcintyre",
+    "Elsy Boglioli": "boglioli", "Françoise de Craecker": "craecker",
+    "Natalie Mount": "mount", "Cédric Moreau": "moreau",
+}

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/eval/profile_split.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Where does the 1.29 s/chunk actually go?
+
+CoreML / ONNX can only accelerate the transformer encoder. If the encoder is 60 % of the
+wall clock, Amdahl caps a 5x encoder speed-up at 2.2x overall — worth knowing before
+converting anything. Times the encoder forward, the tokenisation/preprocessing and the
+python-side head work separately, on real chunks.
+"""
+import os
+import re
+import sys
+import time
+
+import torch
+from gliner2 import GLiNER2
+
+S = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, "/Users/tsardet/Documents/GitHub/PieceMaker_Claude_CLI/websocket-server/scripts")
+
+from bench_backend import BATCH, DESCS, FLOOR, chunk  # noqa: E402
+
+torch.set_num_threads(6)
+torch.set_grad_enabled(False)
+
+text = open(os.path.join(S, "slice_C.md"), encoding="utf-8").read()
+chunks = chunk(text)
+
+model = GLiNER2.from_pretrained("fastino/gliner2-multi-v1")
+model.eval()
+
+stats = {"encoder_s": 0.0, "calls": 0, "tokens": []}
+real_forward = model.encoder.forward
+
+
+def timed_forward(input_ids=None, attention_mask=None, **kw):
+    t = time.perf_counter()
+    out = real_forward(input_ids=input_ids, attention_mask=attention_mask, **kw)
+    stats["encoder_s"] += time.perf_counter() - t
+    stats["calls"] += 1
+    stats["tokens"].append(tuple(input_ids.shape))
+    return out
+
+
+model.encoder.forward = timed_forward
+
+# Warm-up
+model.batch_extract_entities([chunks[0]], DESCS, batch_size=1, threshold=FLOOR,
+                             include_confidence=True, include_spans=True)
+stats["encoder_s"], stats["calls"], stats["tokens"] = 0.0, 0, []
+
+t0 = time.perf_counter()
+for i in range(0, len(chunks), BATCH):
+    model.batch_extract_entities(chunks[i:i + BATCH], DESCS, batch_size=BATCH,
+                                 threshold=FLOOR, include_confidence=True, include_spans=True)
+total = time.perf_counter() - t0
+
+enc = stats["encoder_s"]
+print(f"chunks           : {len(chunks)}")
+print(f"encoder calls    : {stats['calls']}  shapes {sorted(set(stats['tokens']))}")
+print(f"total            : {total:.2f}s   ({total / len(chunks):.3f} s/chunk)")
+print(f"encoder          : {enc:.2f}s   {100 * enc / total:.1f} %")
+print(f"tout le reste    : {total - enc:.2f}s   {100 * (total - enc) / total:.1f} %")
+for speedup in (2, 3, 5, 100):
+    new = enc / speedup + (total - enc)
+    print(f"  si encodeur {speedup}x plus rapide -> {new:.2f}s  = {total / new:.2f}x global")