detect/ner_onnx.py

"""Couche B candidate : Anonym-IA/V2-camembert-ner-pii, NOTRE export ONNX int8.

Meme interface que la couche regex : detect(text) -> spans harness.

⚠️ Constat 2026-07-28 : les exports ONNX publies par Anonym-IA (fp32 ET int8)
sont casses/obsoletes — ils ratent l'adresse, l'email et la ville de l'exemple
de leur propre carte modele, la ou le safetensors original les trouve a 99 %.
On exporte donc nous-memes depuis le modele source (MIT) :

    optimum-cli export onnx --model Anonym-IA/V2-camembert-ner-pii-french \
        --task token-classification models/camembert-pii/
    python -c "from onnxruntime.quantization import quantize_dynamic, QuantType; \
        quantize_dynamic('models/camembert-pii/model.onnx', \
        'models/camembert-pii/model_int8.onnx', weight_type=QuantType.QUInt8, \
        per_channel=True, op_types_to_quantize=['MatMul'])"

⚠️ Recette de quantization : la config naive (QInt8 par tenseur, tous ops)
detruit le rappel du modele (ne trouve plus que les entites les plus fortes).
QUInt8 + per_channel + MatMul uniquement = sortie identique au fp32 sur les
tests, 191 Mo, ~30 ms/segment CPU. `models/` est hors git.

Fenetrage : 512 tokens max (camembert), fenetres avec chevauchement, coupe
au milieu de la zone de recouvrement. Decodage BIO tolerant (I- apres O =
debut d'entite). Les spans adjacents de meme type (PRENOM + NOM -> PERSON)
sont fusionnes s'ils ne sont separes que par espaces/ponctuation legere.
"""

import json
import os
import re
from functools import lru_cache
from pathlib import Path

import numpy as np

MODELS = Path(__file__).resolve().parents[2] / "models"
MODEL_DIR = MODELS / "camembert-pii"
MODEL_FILE = os.environ.get("NER_ONNX_FILE", "model_int8.onnx")

# labels du camembert-ner generique (Jean-Baptiste), exporte pareil
LABEL_MAP_GENERIC = {"PER": "PERSON", "ORG": "COMPANY", "LOC": "CITY"}

# labels modele -> types benchmark ; None = garde le label brut (la metrique
# de couverture compte tous les spans, quel que soit le type)
LABEL_MAP = {
    "NOM_PERSONNE": "PERSON", "PRENOM_PERSONNE": "PERSON",
    "NOM_SOCIETE": "COMPANY",
    "NOM_VOIE": "ADDRESS", "NUMERO_VOIE": "ADDRESS",
    "SECONDARYADDRESS": "ADDRESS", "CODE_POSTAL": "ADDRESS",
    "VILLE": "CITY",
    "EMAIL": "EMAIL", "TELEPHONE": "PHONE",
    "DATE": "DATE", "DOB": "DATE_BIRTH",
    "IBAN": "IBAN", "CREDITCARD": "CARD",
    "NUM_SECURITE_SOCIALE": "NIR",
    "REF_CADASTRALE": "CADASTRE", "NUM_DOSSIER": "RG",
    "VEHICLEVRM": "PLATE", "IP": "IP",
    "AMOUNT": "AMOUNT", "CURRENCY": "AMOUNT",
}

_MAX_TOKENS = 510  # 512 - <s> - </s>
_OVERLAP = 64
# nos fine-tunes sont entraines en sequences de 192 tokens : au-dela, les
# positions n'ont jamais ete vues et le rappel s'effondre (bug 'signatures
# en fin de mail long', audit 2026-07-29). Fenetrage par modele.
_MODEL_MAX = {"pii-noirci": 190, "pii-noirci-v2": 190, "pii-noirci-v6": 380, "pii-noirci-v7": 380, "pii-noirci-v8": 380}
_JOIN_CHARS = set("  .,-'’/")


@lru_cache(maxsize=4)
def _load(model_dir: Path = MODEL_DIR):
    import onnxruntime as ort
    from tokenizers import Tokenizer

    if not model_dir.exists():
        raise FileNotFoundError(
            f"{model_dir} absent : exporter le modele (voir docstring du module)"
        )
    tokenizer = Tokenizer.from_file(str(model_dir / "tokenizer.json"))
    # le tokenizer.json sauve apres un entrainement peut embarquer une
    # troncature (192 tokens) appliquee silencieusement -> les fins de
    # documents longs n'etaient PAS tokenisees (bug signatures, 2026-07-29)
    tokenizer.no_truncation()
    tokenizer.no_padding()
    cfg = json.load(open(model_dir / "config.json"))
    id2label = {int(k): v for k, v in cfg["id2label"].items()}
    session = ort.InferenceSession(
        str(model_dir / MODEL_FILE), providers=["CPUExecutionProvider"]
    )
    bos = tokenizer.token_to_id("<s>")
    eos = tokenizer.token_to_id("</s>")
    return tokenizer, session, id2label, bos, eos


def _windows(n_tokens: int, max_tokens: int = _MAX_TOKENS):
    """[(debut, fin, garde_debut, garde_fin)] : la zone gardee coupe le
    chevauchement en son milieu."""
    if n_tokens <= max_tokens:
        return [(0, n_tokens, 0, n_tokens)]
    step = max_tokens - _OVERLAP
    wins = []
    start = 0
    while start < n_tokens:
        end = min(start + max_tokens, n_tokens)
        keep_from = start if start == 0 else start + _OVERLAP // 2
        keep_to = end if end == n_tokens else end - _OVERLAP // 2
        wins.append((start, end, keep_from, keep_to))
        if end == n_tokens:
            break
        start += step
    return wins


def _token_labels(text: str, model_dir: Path = MODEL_DIR):
    tokenizer, session, id2label, bos, eos = _load(model_dir)
    enc = tokenizer.encode(text, add_special_tokens=False)
    ids, offsets = enc.ids, enc.offsets
    labels = [None] * len(ids)

    max_tokens = _MODEL_MAX.get(model_dir.name, _MAX_TOKENS)
    for start, end, keep_from, keep_to in _windows(len(ids), max_tokens):
        chunk = [bos] + ids[start:end] + [eos]
        input_ids = np.array([chunk], dtype=np.int64)
        attention = np.ones_like(input_ids)
        (logits,) = session.run(
            None, {"input_ids": input_ids, "attention_mask": attention}
        )
        pred = logits[0].argmax(axis=-1)  # (len(chunk),)
        for i in range(keep_from, keep_to):
            labels[i] = id2label[int(pred[i - start + 1])]
    return offsets, labels


def detect_raw(text: str, model_dir: Path = MODEL_DIR,
               label_map: dict | None = None) -> list[dict]:
    """Spans BIO decodes, labels modele mappes vers les types benchmark."""
    label_map = LABEL_MAP if label_map is None else label_map
    offsets, labels = _token_labels(text, model_dir)
    spans = []
    cur = None  # [start, end, type]
    for (tok_s, tok_e), label in zip(offsets, labels):
        if label is None or label == "O" or tok_s == tok_e:
            cur = None
            continue
        prefix, _, etype = label.partition("-")
        etype = label_map.get(etype, etype)
        if cur is not None and etype == cur[2] and prefix == "I":
            cur[1] = tok_e
        else:
            cur = [tok_s, tok_e, etype]
            spans.append(cur)

    # recalage sur les frontieres de mots : le modele coupe parfois en plein
    # sous-token ("Arthur Sam|son") et un nom a moitie masque est une fuite
    for s in spans:
        while s[0] > 0 and text[s[0]].isalnum() and text[s[0] - 1].isalnum():
            s[0] -= 1
        while s[1] < len(text) and text[s[1] - 1].isalnum() and text[s[1]].isalnum():
            s[1] += 1

    # fusion des spans adjacents de meme type (Prenom + Nom, montant + devise)
    merged: list[list] = []
    for s in spans:
        if (merged and merged[-1][2] == s[2]
                and merged[-1][1] >= s[0] - len(text[merged[-1][1]:s[0]])
                and set(text[merged[-1][1]:s[0]]) <= _JOIN_CHARS):
            merged[-1][1] = max(merged[-1][1], s[1])
        else:
            merged.append(s)

    return [
        {"start": s, "end": e, "type": t, "value": text[s:e]}
        for s, e, t in merged
    ]


_MIXED_CASE = re.compile(r"\b[^\W\d_]+\b")


def repair_case(text: str) -> str:
    """Normalise les tokens a casse suspecte ("ArtHur", "FerRand", "MARÉChAL"
    -> "Arthur", "Ferrand", "Maréchal"), longueur conservee. Les formes
    legitimes (minuscules, MAJUSCULES, Capitalise) ne sont pas touchees."""
    out = list(text)
    for m in _MIXED_CASE.finditer(text):
        tok = m.group(0)
        if len(tok) < 3 or tok.islower() or tok.isupper() or tok.istitle():
            continue
        out[m.start():m.end()] = tok[0].upper() + tok[1:].lower()
    return "".join(out)


def detect(text: str, model_dir: Path = MODEL_DIR,
           label_map: dict | None = None) -> list[dict]:
    """detect_raw + seconde passe sur le texte a casse reparee (bruit OCR).

    La reparation conserve la longueur : les offsets sont communs. Les spans
    de la seconde passe ne sont ajoutes que s'ils ne chevauchent rien, avec
    la surface du texte d'origine.
    """
    spans = detect_raw(text, model_dir, label_map)
    repaired = repair_case(text)
    if repaired != text:
        occupied = set()
        for s in spans:
            occupied.update(range(s["start"], s["end"]))
        for s in detect_raw(repaired, model_dir, label_map):
            rng = set(range(s["start"], s["end"]))
            if rng & occupied:
                continue
            occupied |= rng
            s["value"] = text[s["start"]:s["end"]]
            spans.append(s)
        spans.sort(key=lambda s: s["start"])
    return spans


def detect_generic(text: str) -> list[dict]:
    """camembert-ner generique (Jean-Baptiste), notre export ONNX int8.

    Mesure bench_v0 : PERSON 0,5 % de fuite (vs 20 % pour Anonym-IA V2),
    CITY 0,25 %, robuste OCR. C'est le meilleur moteur PERSON/CITY connu.
    """
    return detect(text, MODELS / "camembert-ner", LABEL_MAP_GENERIC)


# types conserves du fine-tune metier : ceux ou il apporte quelque chose.
# Les types a format sont le territoire de la regex (~0 % de fuite) ; le
# modele y produit des faux positifs de biais de distribution ("3 000
# mètres" -> AMOUNT, "1975" -> DATE_BIRTH : dans son corpus, tous les
# nombres etaient des PII). MAIS il rattrape des formats bruites OCR que la
# regex rate : on garde donc ses spans de format AVEC une confirmation
# faible (un indice minimal du format, tolerant au bruit).
NOIRCI_TYPES = {"COMPANY", "ADDRESS", "PERSON", "CITY", "CADASTRE"}
NOIRCI_CONFIRM = {
    "AMOUNT": re.compile(r"€|eur", re.IGNORECASE),
    "DATE": re.compile(r"\d[/.]\d|janv|f[ée]vr|mars|avril|mai|juin|juil|ao[uû]|sept|oct|nov|d[ée]c", re.IGNORECASE),
    "DATE_BIRTH": re.compile(r"\d[/.]\d|janv|f[ée]vr|mars|avril|mai|juin|juil|ao[uû]|sept|oct|nov|d[ée]c", re.IGNORECASE),
    "PLATE": re.compile(r"[A-Za-z]{2}.?\d{3}.?[A-Za-z]{2}|\d{3} ?[A-Za-z]{3}"),
    "TVA": re.compile(r"^[\sF]*[FR]", re.IGNORECASE),
    "PHONE": re.compile(r"^\D*(?:\+33|0[0-9lO])"),
    "IBAN": re.compile(r"[A-Za-z]{2}\d{2}"),
}


def detect_noirci(text: str) -> list[dict]:
    """NOTRE fine-tune (DistilCamemBERT, corpus 100k v3, labels = nos types).

    Mesure 2026-07-29 : COMPANY 7,7 % de fuite sur bench_realvals (44,6 %
    pour le pipeline sans lui), 0 % sur bench_real_v0. Faible hors documents
    metier (wikiner) : il joue le role de moteur COMPANY + filet metier,
    JAMAIS seul — camembert-ner garde PERSON/CITY, la regex garde les
    formats (voir NOIRCI_TYPES).
    """
    spans = detect(text, MODELS / "onnx-pii-v14-base", label_map={})
    kept = []
    for s in spans:
        if s["type"] in NOIRCI_TYPES:
            kept.append(s)
        elif s["type"] in NOIRCI_CONFIRM and NOIRCI_CONFIRM[s["type"]].search(s["value"]):
            kept.append(s)
    return kept