@piecemaker-legal/piecemaker 1.0.6 → 1.0.7

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/AUDIT_PERF_QUALITE.md

@@ -1,246 +0,0 @@
-# PieceMaker — plan v3 (archive historique)
-
-> **Statut — archive, non-feuille de route active.** Ce plan est conservé comme trace de l'analyse
-> publiée dans le commit `fb4bca1` du **6 août 2026**. Il fige les mesures, hypothèses et travaux
-> « à faire » tels qu'ils étaient alors envisagés ; il ne décrit pas l'état courant du code et ne
-> constitue pas un compte rendu d'exécution ultérieure. Ne pas interpréter ses chiffres ou ses
-> étapes comme des résultats actuels sans consulter les documents de vérification ci-dessous.
->
-> État et résultats disponibles depuis ce plan :
-> - [`eval/CRITERES_QUALITE.md`](eval/CRITERES_QUALITE.md) vérifie les étapes 1 à 3 et documente
->   la correction de la fuite liée aux tirets Unicode ;
-> - [`eval/BACKENDS_MESURES.md`](eval/BACKENDS_MESURES.md) rassemble les mesures comparatives des
->   backends ;
-> - les scripts [`eval/verify_substitution.cjs`](eval/verify_substitution.cjs),
->   [`eval/verify_whitespace.py`](eval/verify_whitespace.py), [`eval/evaluate.py`](eval/evaluate.py)
->   et [`eval/bench_backend.py`](eval/bench_backend.py) indiquent les vérifications
->   effectivement rejouables. Leurs JSON de sortie sont régénérables localement et ne sont
->   volontairement pas conservés dans le dépôt.
->
-> Les sections historiques ci-dessous sont volontairement laissées inchangées : leurs mentions
-> « à faire », estimations et résultats partiels ne donnent pas le statut courant et ne prouvent
-> pas des travaux réalisés aujourd'hui.
-
-> Remplace la v2. Contient **deux corrections de mes propres conclusions** et un renversement de
-> l'objectif qualité, provoqué par la lecture du code de substitution que je n'avais pas encore lu.
-
----
-
-## 0. État du run et chiffres, tous mesurés
-
-Le run end-to-end a été **interrompu à 592/972 chunks (61 %)**, encore en phase d'extraction — il n'a
-jamais atteint la phase de classification. Ce qu'il a donné avant de s'arrêter :
-
-| | valeur | base de mesure |
-|---|---|---|
-| Démarrage (modèle + 2 analyseurs spaCy) | **64 s** | mesuré |
-| Extraction | **1,22 s/chunk** | **n = 592 chunks**, 61 % du document |
-| → extraction document complet | **19,7 min** | 1,22 × 972 |
-| RSS du worker | 869 Mo | mesuré |
-| `classify_text` sur contextes réels | **2 890 ms/appel** | n = 25, tirés au sort dans les **1 689 occurrences réelles** |
-| → phase classification | **81,3 min** | 2,89 × 1 689 |
-| spaCy (pipeline complet, jeté) | ~1,5 min | mesuré |
-| **Total attendu** | **≈ 102 min** | |
-
-Ce n'est toujours pas un chrono end-to-end complet. Les deux phases sont maintenant mesurées sur des
-échantillons larges et réels, mais la somme reste une somme. **Dis-moi si tu veux que je relance le
-run complet** — il sature ton M1 pendant ~1 h 40, je ne le relance pas sans ton feu vert.
-
----
-
-## 1. ⚠️ Correction n° 1 — j'avais tort sur `classify_text`
-
-En v2 j'ai écrit : « 12 runs, 0 type `ORGANIZATION_*` produit → l'étape ne produit rien ».
-Le fait était exact, **l'inférence était fausse**. Mesuré sur 25 contextes réels avec le schéma à
-221 labels verbatim de `scanner_worker.py` : `classify_text` renvoie une forme ≠ `other`
-**25 fois sur 25**. L'absence de `ORGANIZATION_*` dans les 12 sorties vient donc de ces runs-là
-(fichier à 30 labels / version antérieure), pas d'un échec de la fonction.
-
-**Mais ce que la mesure montre est pire.** Voici ce que la fonction produit sur un URD biotech
-franco-américain :
-
-```
-SA 11/25  ·  AG 2  ·  AS 2  ·  No Liability 1  ·  Osakeyhtiö 1  ·  Ltd 1
-EIRELI 1  ·  Srl 1  ·  Aktiengesellschaft 1  ·  GP 1  ·  ANS 1  ·  Inc 1  ·  CC 1
-```
-
-`Osakeyhtiö` (finlandais), `EIRELI` (brésilien), `No Liability` (australien), `ANS` (norvégien),
-`CC` (Close Corporation sud-africaine) — pour des sociétés comme AlphaBio, Novartis, Investis.
-44 % de « SA » par défaut. Ce ne sont pas des abstentions, ce sont des **réponses fausses et
-confiantes, à 2,9 s pièce**.
-
-L'argument de suppression est donc plus fort qu'en v2, mais pour une autre raison : l'étape ne coûte
-pas 81 min pour rien, elle coûte 81 min pour **injecter des codes faux** (`SOCIETE_OSAKEYHTIÖ_04`)
-dans le document anonymisé.
-
----
-
-## 2. 🔴 Correction n° 2 — j'avais tort sur l'objectif qualité
-
-En v2 j'ai proposé « maximiser le rappel sous plancher de précision, car un faux positif n'est qu'un
-mot caviardé pour rien ». **C'est faux**, et je l'ai écrit avant d'avoir lu le code de substitution.
-
-`websocket-server/lib/anonymization-server.cjs:394` :
-
-```js
-const regex = new RegExp(escapeRegex(original), 'gi');
-result = result.replace(regex, code);
-```
-
-Substitution **globale**, **insensible à la casse**, et **sans limite de mot**. Trois conséquences,
-toutes vérifiées sur le document réel :
-
-### 2.1 Ta seconde intuition est juste — et déjà implémentée
-
-Détecter une entité **une seule fois suffit** : le `replace` global remplace ensuite toutes ses
-occurrences. J'ai mesuré que 74,6 % des occurrences d'entités déjà connues ne sont jamais re-détectées
-par GLiNER — j'ai failli te l'annoncer comme une fuite. **Ce n'en est pas une**, précisément à cause
-de ce `replace` global. Vérifié avant de te l'écrire.
-
-### 2.2 En revanche chaque faux positif est amplifié à l'échelle du document
-
-Blast radius mesuré, entité par entité, sur le ALPHABIO :
-
-| entité détectée | substitutions déclenchées | dont **à l'intérieur d'un autre mot** |
-|---|---|---|
-| `CA` | **4 725** | 4 724 — `capital`, `case`, `cash`, `indicators`, `carbon` |
-| `us` / `US` | 2 099 ×2 | 1 918 — `business`, `used`, `adjustments` |
-| `AU` | 1 030 | 1 028 — `Faubourg`, `authority`, `Audit`, `auditors` |
-| `EU` | 726 | 644 — `European` |
-| `RU` | 702 | 701 — `rue`, `structure`, `rules`, `instruments` |
-| `ZA` | 477 | 476 — `organization`, `commercialization`, `authorization` |
-| `IND` | 454 | 432 — `indicators`, `indirect`, `kind` |
-| `RP` | 441 | 343 — `Corporation`, `purpose`, `corporate` |
-| `Company` | 895 | — (vrai mot, mais générique) |
-
-**Total : 600 entités → 28 956 substitutions sur un document de 194 391 mots.**
-Soit environ **un mot sur sept réécrit**. Le document anonymisé n'est pas « sur-caviardé », il est
-**détruit** — et de façon irréversible, puisque `reverse_mapping` ne peut pas reconstituer `capital`
-à partir de `ADRESSE_07pital`.
-
-### 2.3 Donc l'objectif s'inverse
-
-Ce n'est pas « rappel maximal sous plancher de précision ». Avec cette substitution, **la précision
-est le terme dominant** : une entité fausse coûte toutes ses occurrences, et une entité fausse et
-courte corrompt le texte. Le rappel *par occurrence*, lui, est presque gratuit grâce au `replace`
-global — il suffit d'un seul repérage.
-
-**Objectif corrigé** : *maximiser le rappel sur les entités **distinctes**, sous contrainte de
-précision élevée, avec une pénalité spécifique aux entités courtes et fréquentes.*
-Et surtout : **corriger la substitution avant de toucher au modèle** — c'est là que se joue le ratio.
-
----
-
-## 3. Tes deux propositions
-
-### ✅ « Les `\n` doivent être supprimés des .md (ou ne pas être produits) » — oui, et c'est plus grave que je ne l'avais dit
-
-Je peux maintenant le prouver par le code. La substitution utilise `escapeRegex(original)` : une
-entité contenant `\n`, un double espace ou un NBSP produit une regex qui n'accepte **que cette
-séquence exacte de blancs**. Ces entités-là ne sont donc **jamais substituées nulle part** :
-
-```
-ORGANIZATION : 217 entités contiennent un \n   ·  18 un NBSP
-PERSON       :  41                              ·  21
-LOCATION     :  19                              ·   6
-```
-
-**277 entités = fuite de PII réelle**, pas théorique. C'est le seul vrai cas de fuite que j'aie trouvé.
-
-Sur le **où** corriger : à la conversion, comme tu le dis — c'est le seul endroit où les offsets du
-`sensitive_map` restent cohérents avec le fichier que tout le monde lit ensuite. Mais pas un
-`replace(/\n/g,' ')` brutal : il faut **préserver les sauts de paragraphe (`\n\n`), les listes et les
-tableaux**, et ne réduire que les retours à la ligne *intra-paragraphe* (retours de justification PDF),
-les espaces multiples et les NBSP. Règle à appliquer dans `smart_converter.py` en post-traitement de
-markitdown, avant écriture du `.md`.
-
-### ⚠️ « Quand une entité est repérée, supprimer les occurrences suivantes pour éviter à GLiNER de recommencer » — juste sur la bonne phase, sans effet sur l'autre
-
-- **Phase d'extraction : aucun gain.** Le coût est **par chunk**, pas par entité — 1,22 s que le chunk
-  contienne 0 ou 20 entités. GLiNER fait une passe d'encodeur sur le chunk entier quoi qu'il arrive ;
-  on ne peut pas lui dire « ignore Dupont ». Et supprimer le texte décalerait tous les offsets, en plus
-  d'exiger de savoir que c'est de la PII *avant* de l'avoir cherchée.
-- **Phase de classification : exactement ça, et c'est le gros morceau.** Celle-là est bien
-  *par occurrence* : **1 689 appels pour 576 noms distincts**. Mémoïser par nom normalisé, c'est
-  **−66 %** sur les 81 min. Ton intuition tombe juste sur la seule phase où elle s'applique.
-- **Et un troisième usage, meilleur** : une fois l'ensemble des noms distincts connu, une passe
-  « gazetteer » (recherche de chaîne de chaque nom connu sur tout le document) rattrape gratuitement
-  ce que GLiNER a manqué. C'est précisément ce que fait déjà le `replace` global — d'où le §2.1.
-
----
-
-## 4. Plan révisé, par ordre de priorité
-
-### Étape 1 — Réparer la substitution 🔴 *avant tout le reste*
-`anonymization-server.cjs:377-404`. Rien ne sert de régler le modèle tant qu'une détection correcte
-produit un document détruit.
-1. **Limites de mot** : `new RegExp("(?<!\\w)"+escapeRegex(original)+"(?!\\w)", "g")`.
-   → supprime à elle seule ~11 000 des 28 956 substitutions, toutes fausses.
-2. **Supprimer le flag `i`** (ou ne le garder que pour la première lettre). `us` ≠ `US`.
-3. **Longueur minimale** : refuser toute entité < 4 caractères hors liste blanche explicite.
-   → neutralise `CA`, `us`, `AU`, `EU`, `RU`, `ZA`, `HK`, `MX`, `JP`, `KR`, `CN`.
-4. **Ordonner les substitutions par longueur décroissante** et remplacer par jeton non re-substituable,
-   pour que `French` ne mange pas `French Monetary and Financial Code`.
-- **Critère d'acceptation** : sur le ALPHABIO, 0 substitution à l'intérieur d'un mot. Vérifiable exactement.
-
-### Étape 2 — Normalisation des blancs à la conversion 🔴
-Règle décrite en §3. Cible : **0 entité contenant `\n` ou double espace** dans le `sensitive_map`,
-et les 1 273 « distincts » qui retombent à 971 (−24 % de faux distincts, cf. v2).
-
-### Étape 3 — Arbitrage de spans 🔴
-Supprimer tout span chevauchant ou inclus **quel que soit le type** (presidio ne le fait qu'à type
-égal). → corrige les 81 double-typages et 179 chevauchements. Départage : longueur, puis score,
-puis priorité PERSON > ORG > LOC — à valider sur corpus.
-
-### Étape 4 — Corpus de référence annoté ⭐
-Inchangé depuis la v2, et toujours le prérequis de toute décision « qualité » :
-3 documents du Dossier AVION + un extrait ALPHABIO, outil d'annotation HTML local, ~1 h de ton temps.
-Métrique révisée par le §2.3 : **rappel sur entités distinctes / précision, avec pénalité sur les
-entités courtes et fréquentes**.
-
-### Étape 5 — Faux positifs des pattern recognizers
-`IpRecognizer` : 31/31 FP (numéros de section `3.7.2.2`). `UrlRecognizer` : `2023.Th`, `occur.Th`.
-Vérifiable exactement, sans annotation.
-
-### Étape 6 — Calibration du seuil, par type
-Rappel : le seuil actuel de **0.3 ne filtre rien** (score minimum observé 0.401). Balayage
-0.30→0.90 sur le corpus. Tester aussi `0.1` : s'il apparaît des entités sous 0.4, il y a du rappel
-gratuit ; sinon c'est un plancher interne du modèle. Mesure, pas hypothèse.
-
-### Étape 7 — Supprimer `classify_text`
-Regex de forme juridique sur le nom normalisé ; absence de forme → `ORGANIZATION`.
-Gain : **81 min**, et surtout suppression des `Osakeyhtiö`/`EIRELI` du §1.
-Couverture mesurée **sur ce document** : 11 % des noms portent une forme littérale (63/576).
-**À re-mesurer sur le Dossier AVION** (Kbis « URGOT SA », « CAITLYN SA ») où elle sera bien plus haute.
-
-### Étape 8 — Choix du checkpoint (A/B sur corpus)
-`gliner2-privacy-filter-PII-multi` — même backbone, donc **même vitesse**, spécialisé PII.
-Décision sur les chiffres du corpus uniquement.
-
-### Étape 9 — Vitesse, chaque levier conditionné à un score corpus inchangé ou meilleur
-| levier | gain mesuré | risque qualité |
-|---|---|---|
-| spaCy en tokenizer seul | −1,5 min, −1 Go RSS | nul (le NER spaCy est déjà jeté) |
-| `torch.set_num_threads(6)` | −18 % sur l'extraction | nul |
-| mémoïsation classification par nom distinct | −66 % *(sans objet si étape 7 faite)* | nul |
-| recouvrement 50 → ~15 mots | −15 à −20 % de chunks | à mesurer sur corpus |
-| taille de chunk | — | ⚠️ ne pas augmenter : p90 = 485 tokens / 512, 1 % des chunks débordent déjà |
-| MPS · int8 | ⛔ écartés, mesurés | MPS 29,6 vs 23,0 min ; int8 indisponible (`NoQEngine`) |
-
-### Étape 10 — Fuite PII dans les logs
-`scanner_worker.py:495` — chaque entité en clair sur stderr, capturé par Electron.
-Flag `PIECEMAKER_DEBUG_ENTITIES`, off par défaut.
-
----
-
-## 5. Bilan
-
-**Qualité** — l'essentiel du ratio ne se joue pas dans GLiNER : il se joue dans la substitution
-(28 956 remplacements dont ~11 000 à l'intérieur de mots), la normalisation des blancs (277 entités
-jamais substituées = la seule vraie fuite trouvée), et l'arbitrage de spans. Ces trois corrections
-coûtent **zéro milliseconde d'inférence**.
-
-**Vitesse** — ~102 min → ~20 min, dont 81 min gagnées en supprimant une étape qui produit des
-réponses fausses.
-
-**Ce qui reste inconnu** — précision et rappel réels. Étape 4.

package/server/piecemaker/vendor/websocket-server/scripts/presidio-gliner/MODELE_COREML.md

@@ -1,62 +0,0 @@
-# Encodeur CoreML — génération et déploiement
-
-`coreml_runtime.py` fait tourner l'encodeur mdeberta sur le GPU du Mac : **2,1× sur le document
-complet, sortie identique** (mesures et méthode dans `eval/BACKENDS_MESURES.md`). Si le modèle
-compilé est absent, le worker retombe sur torch sans erreur — cette étape est donc **optionnelle**,
-elle n'achète que la vitesse.
-
-## Générer le modèle (~4 min, une fois)
-
-```bash
-cd eval
-PIECEMAKER_COREML_SEQ=832 python3 coreml_encoder.py convert     # ~2 min -> .mlpackage
-python3 - <<'PY'
-import shutil, coremltools as ct
-m = ct.models.MLModel('artifacts/encoder_b1_832.mlpackage',
-                      compute_units=ct.ComputeUnit.CPU_AND_GPU)   # ~2 min de compilation
-shutil.copytree(m.get_compiled_model_path(), 'artifacts/encoder_b1_832.mlmodelc')
-PY
-mkdir -p ../models && cp -R artifacts/encoder_b1_832.mlmodelc ../models/
-```
-
-Prérequis : `pip install coremltools` (n'a rétrogradé aucune dépendance sur cette machine).
-
-## Pourquoi un `.mlmodelc` et pas le `.mlpackage`
-
-Charger le `.mlpackage` **recompile à chaque démarrage** : 97 s, mesuré deux fois de suite, parce
-que chaque chargement compile dans un répertoire temporaire que le cache système ne reconnaît pas.
-Un `.mlmodelc` persisté touche ce cache : **97 s au tout premier chargement, puis ~6 s**. C'est la
-différence entre inutilisable et livrable.
-
-## Pourquoi 832 tokens
-
-Le padding se fait sur la séquence la plus longue du lot. Longueurs réelles mesurées :
-
-| document | longueurs des lots |
-|---|---|
-| `Assignation_URGOT_vs_CAITLYN` | 741 · 781 · 811 |
-| `Conclusions_Assignation_URGOT` | 770 · 811 |
-
-À 772 (première tentative), 2 lots sur 3 de l'Assignation retombaient sur torch et le gain tombait
-à 1,13×. À 832 : **0 repli en français**, 11 lots sur 122 sur le ALPHABIO anglais.
-
-## Pourquoi le GPU et pas le Neural Engine
-
-`CPU_AND_NE` a été mesuré **3,3× plus lent que le CPU** sur ce modèle (3,60 s contre 1,10 s).
-L'attention désenchevêtrée de deberta-v3 est le motif que l'ANE traite le plus mal. `CPU_AND_GPU`
-est un choix mesuré.
-
-## Désactiver
-
-```bash
-PIECEMAKER_COREML=0            # repli torch explicite
-PIECEMAKER_COREML_MODEL=/chemin/vers/encoder_b1_<seq>.mlmodelc
-```
-
-La longueur de séquence est lue dans le nom du fichier (`encoder_b1_832.mlmodelc` → 832).
-
-## Déploiement
-
-Le `.mlmodelc` fait 620 Mo et n'est **pas** versionné (`.gitignore`). Deux options :
-soit l'empaqueter avec l'app, soit le générer à la première exécution. Tant qu'il est absent, le
-worker tourne en torch — correct, seulement plus lent.

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

@@ -1,118 +0,0 @@
-#!/usr/bin/env python3
-"""Génère une fois l'encodeur CoreML, pour que les scans GLiNER tournent sur le GPU.
-
-Le runtime (`coreml_runtime.py`) accélère l'encodeur mdeberta sur le GPU du Mac
-et libère surtout les cœurs CPU pour que la machine reste utilisable pendant un
-scan. Les mesures historiques sont documentées dans `eval/BACKENDS_MESURES.md` ;
-GLiNER2.5 reçoit son propre artefact compilé à partir de ses poids exacts.
-
-Ce script est **best-effort et idempotent** :
-  - il ne refait rien si le `.mlmodelc` est déjà là ;
-  - il sort 0 quoi qu'il arrive (dépendance manquante, conversion refusée…), car
-    le runtime retombe seul sur torch — un scan ne doit jamais échouer à cause
-    d'une optimisation.
-
-Il réutilise `Wrap` et `_patch_deberta_scale` de `eval/coreml_encoder.py` pour ne
-pas dupliquer les correctifs de traçage deberta, mais synthétise ses propres
-entrées (la conversion ne dépend que de leur forme, pas de leurs valeurs).
-
-    python3 build_coreml.py            # génère l'encodeur GLiNER2.5 dans models/
-    PIECEMAKER_COREML_SEQ=832          # longueur de séquence (défaut 832)
-"""
-import os
-import shutil
-import sys
-import tempfile
-
-HERE = os.path.dirname(os.path.abspath(__file__))
-SEQ = int(os.environ.get("PIECEMAKER_COREML_SEQ", "832"))
-MODELS_DIR = os.path.join(HERE, "models")
-
-from model_config import PREFERRED_GLINER_MODEL  # noqa: E402
-from coreml_runtime import default_model_path  # noqa: E402
-
-GLINER_MODEL = PREFERRED_GLINER_MODEL
-TARGET = default_model_path(GLINER_MODEL, SEQ)
-
-
-def _log(msg):
-    print(msg, flush=True)
-
-
-def main():
-    if os.path.exists(TARGET):
-        _log(f"Encodeur CoreML déjà présent : {TARGET}")
-        return 0
-
-    try:
-        import numpy as np
-        import torch
-        import coremltools as ct
-        from gliner2 import AutoExtractor
-    except Exception as exc:  # noqa: BLE001
-        _log(f"CoreML non généré (dépendance manquante : {type(exc).__name__}: {exc}) — les scans resteront sur CPU torch")
-        return 0
-
-    # Correctifs de traçage deberta partagés avec l'outil d'évaluation.
-    sys.path.insert(0, os.path.join(HERE, "eval"))
-    try:
-        from coreml_encoder import Wrap, _patch_deberta_scale
-    except Exception as exc:  # noqa: BLE001
-        _log(f"CoreML non généré (helpers de conversion introuvables : {exc}) — CPU torch")
-        return 0
-
-    try:
-        torch.set_grad_enabled(False)
-        _patch_deberta_scale()
-
-        # Entrées factices de la bonne forme : seule la forme (1 x SEQ) est gravée
-        # dans le modèle converti, pas les valeurs.
-        ids = torch.zeros((1, SEQ), dtype=torch.long)
-        mask = torch.ones((1, SEQ), dtype=torch.long)
-
-        _log(f"Chargement de {GLINER_MODEL}...")
-        model = AutoExtractor.from_pretrained(
-            GLINER_MODEL,
-            local_files_only=True,
-        ).eval()
-        wrap = Wrap(model.encoder).eval()
-        del model
-
-        _log("Traçage du modèle...")
-        traced = torch.jit.trace(wrap, (ids, mask), strict=False)
-
-        _log("Conversion en MLProgram (fp16)...")
-        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,
-        )
-
-        with tempfile.TemporaryDirectory() as tmp:
-            pkg = os.path.join(tmp, f"encoder_b1_{SEQ}.mlpackage")
-            mlmodel.save(pkg)
-
-            # Le .mlmodelc persisté touche le cache système : ~6 s au chargement
-            # ensuite, contre ~97 s si l'on rechargeait le .mlpackage à chaque fois
-            # (cf. MODELE_COREML.md). On garde une référence vivante le temps de la
-            # copie, sinon le répertoire compilé temporaire peut disparaître.
-            _log("Compilation en .mlmodelc (peut prendre ~2 min)...")
-            compiled_model = ct.models.MLModel(pkg, compute_units=ct.ComputeUnit.CPU_AND_GPU)
-            os.makedirs(MODELS_DIR, exist_ok=True)
-            if os.path.exists(TARGET):
-                shutil.rmtree(TARGET, ignore_errors=True)
-            shutil.copytree(compiled_model.get_compiled_model_path(), TARGET)
-
-        _log(f"Encodeur GPU CoreML prêt : {TARGET}")
-        return 0
-    except Exception as exc:  # noqa: BLE001
-        _log(f"Génération CoreML échouée ({type(exc).__name__}: {exc}) — les scans resteront sur CPU torch, sans conséquence sur la qualité")
-        return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,164 +0,0 @@
-#!/usr/bin/env python3
-"""Run mdeberta's encoder on the Mac GPU through CoreML instead of the CPU.
-
-The encoder dominates a scan's wall clock. Historical GLiNER2 measurements showed that a
-CoreML/GPU MLProgram ran it about twice as fast as torch on this hardware (see
-eval/BACKENDS_MESURES.md §6):
-
-    ALPHABIO_URD_2023  972 chunks   18,76 min -> 8,96 min    2,09x
-    Assignation URGOT   18 chunks   0,932 -> 0,403 s/chunk    2,31x
-    Conclusions         13 chunks   0,999 -> 0,441 s/chunk    2,27x
-
-Those quality and speed measurements concern the historical checkpoint. GLiNER2.5 gets a
-separate compiled artifact so old weights can never be injected into the new model.
-
-NOT the Neural Engine: `CPU_AND_NE` measured **3,3x slower** than the CPU on this model.
-deberta-v3's disentangled attention is the pattern the ANE handles worst. `CPU_AND_GPU` is
-a measured choice, not a default.
-
-Everything degrades to plain torch: coremltools missing, model file missing, a load failure,
-a prediction failure, or a sequence longer than the converted shape — each falls back
-correctly. A scan must never fail because of an optimisation.
-
-Environment:
-    PIECEMAKER_COREML=0          disable entirely (default: enabled)
-    PIECEMAKER_COREML_MODEL=...  path to the .mlmodelc (default: model-specific
-                               file in models/ next to this file)
-"""
-import os
-import sys
-
-_HERE = os.path.dirname(os.path.abspath(__file__))
-DEFAULT_SEQ = 832
-LEGACY_MODEL_ID = "fastino/gliner2-multi-v1"
-
-
-def default_model_path(model_id=None, seq_len=DEFAULT_SEQ):
-    """Return a CoreML artifact tied to the exact checkpoint weights.
-
-    Reusing the historical GLiNER2 encoder with GLiNER2.5 would silently
-    produce invalid detections. Keep the old filename only for the old model;
-    every newer checkpoint gets its own explicit artifact.
-    """
-    if not model_id or model_id == LEGACY_MODEL_ID:
-        filename = f"encoder_b1_{seq_len}.mlmodelc"
-    else:
-        slug = str(model_id).rsplit("/", 1)[-1].replace("/", "-")
-        filename = f"{slug}-encoder_b1_{seq_len}.mlmodelc"
-    return os.path.join(_HERE, "models", filename)
-
-
-DEFAULT_MODEL = default_model_path()
-
-
-def _log(msg):
-    print(msg, file=sys.stderr, flush=True)
-
-
-class _Out:
-    """Duck-types the HF model output — gliner2 only reads `.last_hidden_state`."""
-
-    __slots__ = ("last_hidden_state",)
-
-    def __init__(self, h):
-        self.last_hidden_state = h
-
-
-class CoreMLEncoder:
-    """Callable replacement for `model.encoder.forward`.
-
-    The converted model has a fixed shape (1 x seq_len), so each sequence is padded to
-    seq_len and predicted on its own. Sequences longer than seq_len — 11 batches of 122 on
-    ALPHABIO, none on the French corpus — go to torch, which is why the original forward is
-    kept rather than replaced.
-    """
-
-    def __init__(self, mlmodel, torch_forward, seq_len):
-        import numpy as np
-        import torch
-
-        self._np = np
-        self._torch = torch
-        self.m = mlmodel
-        self.torch_forward = torch_forward
-        self.seq_len = seq_len
-        self.calls = 0
-        self.fallbacks = 0
-
-    def __call__(self, input_ids=None, attention_mask=None, **kw):
-        torch, np = self._torch, self._np
-        self.calls += 1
-
-        if input_ids is None or attention_mask is None:
-            return self.torch_forward(input_ids=input_ids, attention_mask=attention_mask, **kw)
-
-        _, s = input_ids.shape
-        if s > self.seq_len:
-            self.fallbacks += 1
-            return self.torch_forward(input_ids=input_ids, attention_mask=attention_mask, **kw)
-
-        pad = self.seq_len - s
-        ids = torch.nn.functional.pad(input_ids, (0, pad)).numpy().astype(np.int32)
-        msk = torch.nn.functional.pad(attention_mask, (0, pad)).numpy().astype(np.int32)
-
-        try:
-            rows = [self.m.predict({"input_ids": ids[i:i + 1], "attention_mask": msk[i:i + 1]})
-                    ["last_hidden_state"] for i in range(ids.shape[0])]
-        except Exception as exc:  # noqa: BLE001
-            self.fallbacks += 1
-            _log(f"CoreML predict failed ({type(exc).__name__}: {exc}) — falling back to torch")
-            return self.torch_forward(input_ids=input_ids, attention_mask=attention_mask, **kw)
-
-        h = np.concatenate(rows, axis=0)[:, :s, :].astype(np.float32)
-        return _Out(torch.from_numpy(h))
-
-
-# The worker builds one GLiNER2Recognizer per language and pre-loads a shared model, so
-# maybe_accelerate is reached three times per process. Loading the .mlmodelc three times
-# took startup from 63 s to 208 s (measured); the model is immutable, so cache it.
-_MLMODEL_CACHE = {}
-
-
-def _seq_len_from_path(path: str) -> int:
-    """The sequence length is encoded in the filename (encoder_b1_832.mlmodelc).
-
-    Guessing wrong in the safe direction matters: too small only costs speed (more torch
-    fallbacks), while too large would feed the model a shape it was not converted for.
-    """
-    base = os.path.basename(path)
-    tail = base.rsplit("_", 1)[-1].split(".")[0] if "_" in base else ""
-    return int(tail) if tail.isdigit() else DEFAULT_SEQ
-
-
-def maybe_accelerate(model, model_id=None) -> bool:
-    """Point `model.encoder.forward` at CoreML when it is available and wanted.
-
-    Returns True if the encoder was swapped. Never raises.
-    """
-    if os.environ.get("PIECEMAKER_COREML", "1").lower() in ("0", "false", "no"):
-        _log("CoreML disabled (PIECEMAKER_COREML=0) — torch CPU")
-        return False
-
-    path = os.environ.get("PIECEMAKER_COREML_MODEL", default_model_path(model_id))
-    if not os.path.exists(path):
-        _log(f"CoreML model absent ({path}) — torch CPU")
-        return False
-
-    if path in _MLMODEL_CACHE:
-        mlmodel = _MLMODEL_CACHE[path]
-        if mlmodel is None:  # a previous attempt already failed; don't retry per recognizer
-            return False
-    else:
-        try:
-            import coremltools as ct
-
-            mlmodel = ct.models.CompiledMLModel(path, compute_units=ct.ComputeUnit.CPU_AND_GPU)
-        except Exception as exc:  # noqa: BLE001
-            _MLMODEL_CACHE[path] = None
-            _log(f"CoreML unavailable ({type(exc).__name__}: {exc}) — torch CPU")
-            return False
-        _MLMODEL_CACHE[path] = mlmodel
-        _log(f"CoreML GPU encoder active (seq {_seq_len_from_path(path)}) — ~2x faster than torch CPU")
-
-    model.encoder.forward = CoreMLEncoder(mlmodel, model.encoder.forward, _seq_len_from_path(path))
-    return True