| """Seconde passe en majuscules ciblees : reveiller ce que le modele sait deja. |
| |
| Mesure du 31/07/2026. En presentant au modele le MEME texte mis en |
| capitales, la fuite sur les societes tombait de 15,8 % a 7,2 %. Autrement |
| dit, une societe sur trois que le modele « rate » lui est en fait |
| familiere : il ne la reconnait pas ecrite « Pennylane » alors qu'il la |
| reconnait ecrite « PENNYLANE ». Cause : les pools BODACC et SIRENE qui ont |
| servi a fabriquer le corpus stockent les raisons sociales en capitales, |
| d'ou un corpus a 65 % de majuscules contre 17 % dans la vraie |
| correspondance. |
| |
| Mettre tout le texte en capitales n'est pas exploitable : le modele voit |
| alors des societes partout et le sur-masquage monte a 57 %. On ne |
| majuscule donc que les mots capitalises qu'aucune de nos trois listes ne |
| connait (lexique francais, patronymes SIRENE, prenoms INSEE) : un mot |
| capitalise absent des trois est un candidat marque. Le sur-masquage reste a |
| 14 % et la fuite societes tombe a 10,3 %. |
| |
| Cout : une inference de plus par document. Le module est donc optionnel, |
| active par le detecteur qui en veut. |
| |
| La transformation preserve la LONGUEUR du texte, donc les offsets trouves |
| sur la variante sont valables sur l'original. Les rares caracteres dont la |
| majuscule occupe plusieurs codets (« ß ») sont laisses tels quels. |
| """ |
|
|
| import gzip |
| import re |
| import unicodedata |
| from functools import lru_cache |
| from pathlib import Path |
|
|
| FORMES = Path(__file__).resolve().parents[2] / "data" / "formes_connues.txt.gz" |
|
|
| |
| |
| _MOT = re.compile(r"\b[A-ZÀ-Þ][a-zà-ÿ][\wÀ-ÿ.-]{1,}\b") |
|
|
|
|
| def _norm(s: str) -> str: |
| s = unicodedata.normalize("NFD", s.upper()) |
| return "".join(c for c in s if unicodedata.category(c) != "Mn") |
|
|
|
|
| @lru_cache(maxsize=1) |
| def _connues() -> frozenset: |
| if not FORMES.exists(): |
| return frozenset() |
| with gzip.open(FORMES, "rt", encoding="utf-8") as f: |
| return frozenset(l.strip() for l in f if l.strip()) |
|
|
|
|
| def variante(text: str) -> str: |
| """Le texte avec les mots capitalises inconnus passes en capitales.""" |
| connues = _connues() |
| if not connues: |
| return text |
| out = list(text) |
| for m in _MOT.finditer(text): |
| mot = m.group(0) |
| if _norm(mot) in connues: |
| continue |
| for i, c in enumerate(mot.upper()): |
| if len(c) == 1: |
| out[m.start() + i] = c |
| return "".join(out) |
|
|
|
|
| def seconde_passe(text: str, spans: list[dict], detecteur, |
| types=("COMPANY",)) -> list[dict]: |
| """Spans supplementaires trouves sur la variante en capitales. |
| |
| `detecteur` est la fonction de detection a rejouer. On ne retient que |
| les types demandes, et jamais un span qui empiete sur un span deja |
| trouve : la premiere passe, faite sur le texte authentique, fait foi. |
| """ |
| var = variante(text) |
| if var == text or len(var) != len(text): |
| return [] |
|
|
| occupe = set() |
| for s in spans: |
| occupe.update(range(s["start"], s["end"])) |
|
|
| extra = [] |
| for s in detecteur(var): |
| if s["type"] not in types: |
| continue |
| r = set(range(s["start"], s["end"])) |
| if r & occupe: |
| continue |
| occupe |= r |
| extra.append({**s, "value": text[s["start"]:s["end"]]}) |
| return extra |
|
|
