Graphemiseur (P2G)

Lectura Graphemiseur

Modele unifie P2G + POS + Morphologie pour le francais (IPA → orthographe)

PyPI GitHub pip install lectura-graphemiseur

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 V6 avec word feedback et phone_lex_features (2.56M parametres, ONNX INT8 = 2.6 Mo).

Tache	Description	Performance
P2G	IPA vers orthographe (modele core)	~88% word accuracy
P2G	Pipeline complet (+ formules + noms propres)	90.95% word accuracy
POS	Etiquetage morpho-syntaxique (19 tags)	98.3% accuracy
Morphologie	Genre, nombre, temps, mode, personne	94.7-99.7%

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) :

Couche	Package	Contenu
Couche 1	`lectura-graphemiseur`	Modele P2G core + lex_select + coherence morpho + accents
Couche 2	`lectura-p2g`	Pipeline complet = graphemiseur + formules (nombres, maths) + noms propres + entites

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.

i (i) e (é) ɛ (ai) a (a) ɑ (a) ɔ (o) o (ô) u (ou) y (u) ø (oeu) œ (eu) ə (e) ɑ̃ (an) ɛ̃ (in) ɔ̃ (on) œ̃ (un) j (y) w (w) ɥ (u) p b t d k ɡ (gu) f v s z ʃ (ch) ʒ (j) m n ɲ (gn) ŋ (ng) l ʁ (r)

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 (V6)

Le P2G utilise un mecanisme de word feedback : les representations de mots issues des tetes POS/Morpho sont diffusees aux positions caractere correspondantes avant la prediction P2G finale.

Modele core : raw (82.32%) → lex_select (87.33%) → coherence morpho + accents (~88%). Pipeline complet (lectura-p2g) : + formules + composés + noms propres + entités (90.95%).

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

Phone_lex_features (28d) : le modele V6 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 choisit 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

2.56M parametres, modele ONNX INT8 = 2.6 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 : contact@lec-tu-ra.com