Graphemiseur (P2G)

Presentation

Le pendant inverse du G2P : a partir d’une transcription phonetique IPA, le P2G reconstruit l’orthographe francaise. Un seul modele BiLSTM char-level multi-tete V7 avec attention cross word-char et lex_select (3.2M parametres, ONNX INT8 = 4.4 Mo).

Quatre backends d’inference : API (zero config), ONNX Runtime, NumPy, ou pur Python (zero dependance).

Architecture en deux couches

En miroir de l’architecture G2P (lectura-phonemiseur + lectura-g2p) :

Le graphemiseur (couche 1) est zero dependance — pas d’import de lectura_formules. Le pipeline complet (couche 2) orchestre formules, fusion de composes, coherence morpho, noms propres et reconnaissance d’entites notables.

Tester en ligne

Le test en ligne utilise l’API Lectura — aucun telechargement de modele necessaire.

Cliquez sur le bouton pour lancer la demo.

Exemple de code

from lectura_graphemiseur import creer_engine

engine = creer_engine()   # mode API par defaut (zero config)

result = engine.analyser(["le", "ɑ̃fɑ̃", "sɔ̃", "aʁive", "a", "la", "mɛzɔ̃"])

print(result["ortho"])   # ['les', 'enfants', 'sont', 'arrives', 'a', 'la', 'maison']
print(result["pos"])     # ['ART:def', 'NOM', 'AUX', 'VER', 'PRE', 'ART:def', 'NOM']

Architecture du modele (V7)

Le P2G V7 ajoute un mecanisme d’attention cross word-char : les representations de mots issues des tetes POS/Morpho sont projetees vers les positions caractere par attention, ameliorant la resolution des ambiguites contextuelles. Le lex_select choisit parmi les candidats phonetiquement compatibles du lexique par une tete neuronale dediee.

Modele core : raw → lex_select → coherence morpho + accents (~95%). Pipeline complet (lectura-p2g) : + formules + composes + noms propres + entites (~96%).

Phrase IPA → Char Embedding (64d) → Shared BiLSTM (2x192h → 384d)
                                          |
                  +-----------------------+--------------------+
                  v                                             v
        Word representations              Word repr (384d) + Phone Lex Features (28d)
        (fwd[last] || bwd[first])                          |
                                                 Word BiLSTM (192h → 384d)
                                                       |
                                            +--------------+--------------+
                                           POS        Morpho (x6)    Attention Cross
                                                                    → P2G Head
                                                                    → Lex_Select Head

Phone_lex_features (28d) : le modele recoit un vecteur de 28 dimensions par mot, construit a partir du phone_lexicon.db (lexique phonetique SQLite) : 19d POS one-hot + 3d morpho (genre, nombre) + 6d features lexicales. Le lex_select selectionne la meilleure forme orthographique parmi les candidats phonetiquement compatibles du lexique. Sans phone_lexicon, le modele fonctionne en mode degrade (features = zeros).

Installation

# Modele core (zero dependance)
pip install lectura-graphemiseur             # mode API (zero config)
pip install lectura-graphemiseur[onnx]       # backend ONNX Runtime local (~2 ms/phrase)
pip install lectura-graphemiseur[numpy]      # backend NumPy local

# Pipeline complet (graphemiseur + formules + noms propres)
pip install lectura-p2g

Par defaut, le module utilise l’API Lectura (aucune configuration necessaire). Les backends locaux (ONNX, NumPy) necessitent les modeles pre-entraines, disponibles sous licence commerciale.

Caracteristiques techniques

• 3.2M parametres, modele ONNX INT8 = 4.4 Mo
• 4 backends : API (zero config), ONNX Runtime (~2 ms), NumPy (~50 ms), pur Python (~200 ms)
• Word feedback : les informations POS/morpho enrichissent la prediction P2G
• Phone_lex_features (28d) : features construites depuis phone_lexicon.db (lexique phonetique SQLite)
• Lex_select : selection lexicale parmi candidats phonetiques
• Pipeline lectura-p2g : formules (expressions mathematiques, nombres, sigles — mode chiffres par defaut), fusion de mots composes, noms propres, et reconnaissance de ~9000 entites notables via couche 2. Mode formule_tolerance="stt" pour la reconnaissance tolerante depuis un pipeline STT
• Zero dependance : le graphemiseur core n’importe pas lectura_formules
• Factory creer_engine() : detection automatique du meilleur backend
• Python 3.10+ avec type hints complets (PEP-561)
• Licence : AGPL-3.0 (non commerciale) — licence commerciale sur demande : admin@lectura.world