Aligneur-Syllabeur

Lectura Aligneur-Syllabeur

Aligneur grapheme-phoneme et syllabeur phonologique du francais

PyPI GitHub pip install lectura-aligneur

Presentation

Pivot central du pipeline Lectura. Module autonome, zero dependance Python. Realise l’alignement lettre-par-lettre entre orthographe et phonetique, construit les groupes de lecture en gerant les phenomenes de chaine parlee, et decompose chaque syllabe en ses constituants phonologiques.

C’est grace a cet aligneur que les corpus d’entrainement des modeles G2P et P2G ont ete prepares. Sans lui, rien n’aurait ete possible.

Ce que fait ce module

#	Fonction	Description
1	Groupes de lecture	Regroupe les mots lies par elision, liaison ou enchainement
2	Alignement grapheme-phoneme	Correspondance lettre-par-lettre entre orthographe et IPA
3	Lettres muettes et fusionnees	Detecte les lettres silencieuses et les graphemes multi-phonemes (x→ks)
4	Syllabation ortho + phone	Decoupe chaque groupe en syllabes au niveau phonetique ET orthographique
5	Attaque / Noyau / Coda	Decompose chaque syllabe en ses constituants avec phonemes distribues
6	Spans	Positions caractere de chaque syllabe, groupe et composant dans le texte source

Tester en ligne

Le test en ligne utilise l’API Lectura (G2P + Aligneur) — aucun telechargement necessaire.

Cliquez sur le bouton pour lancer la demo.

Exemples de code

Analyse d’un mot (API simple)

from lectura_aligneur import LecturaSyllabeur

syllabeur = LecturaSyllabeur()    # mode API par defaut
result = syllabeur.analyze("chocolat")

print(result.format_detail())
# chocolat -> /ʃɔkɔla/
#   σ1: /ʃɔ/ <<cho>> [0:3] att=ʃ noy=ɔ cod=-
#   σ2: /kɔ/ <<co>>  [3:5] att=k noy=ɔ cod=-
#   σ3: /la/ <<lat>>  [5:8] att=l noy=a cod=-

# Chaque syllabe expose son alignement grapheme-phoneme :
for s in result.syllabes:
    att = " ".join(f"{p.ipa}→{p.grapheme}" for p in s.attaque.phonemes)
    noy = " ".join(f"{p.ipa}→{p.grapheme}" for p in s.noyau.phonemes)
    print(f"  {s.ortho:6s} /{s.phone}/  att=[{att}] noy=[{noy}]  span={s.span}")

Analyse complete avec groupes de lecture

from lectura_aligneur import LecturaSyllabeur, MotAnalyse

syllabeur = LecturaSyllabeur()

# Mots annotes par le G2P (phone + liaison)
mots = [
    MotAnalyse(phone="lez", liaison="Lz"),    # les (liaison en z)
    MotAnalyse(phone="ɑ̃fɑ̃", liaison="none"),   # enfants
    MotAnalyse(phone="ʒu",  liaison="none"),    # jouent
]

result = syllabeur.analyser_complet(mots)

print(f"{result.nb_groupes} groupes, {result.nb_syllabes} syllabes")
print(f"Groupes : {result.format_ligne1()}")
print(f"Syllabes : {result.format_ligne2()}")
# 2 groupes, 4 syllabes
# Groupes : les enfants | jouent
# Syllabes : le.zɑ̃.fɑ̃ | ʒu

Avec Lectura G2P comme phonemiseur

from lectura_aligneur import LecturaSyllabeur
from lectura_nlp import creer_engine

g2p = creer_engine()    # mode API par defaut

class G2PPhonemizer:
    def predict(self, word):
        return g2p.analyser([word])['g2p'][0]

syllabeur = LecturaSyllabeur(phonemizer=G2PPhonemizer())

Architecture E1 / E2

Le module fonctionne en deux etapes, utilisables separement ou ensemble :

E1 — Groupes de lecture (construire_groupes)

Parcourt les mots annotes et les regroupe selon les phenomenes de chaine parlee :

Elision : l’enfant → 1 groupe
Liaison : les‿enfants → 1 groupe (consonne de liaison z, t, n, r, p)
Enchainement : avec‿elle → 1 groupe (consonne finale resyllabee)

E2 — Syllabation (syllabifier_groupes)

Pour chaque groupe :

Syllabation IPA par modele de sonorite (5 classes : obstruantes, nasales, liquides, semi-voyelles, voyelles)
Alignement DFS grapheme-phoneme avec detection des lettres muettes et fusionnees
Construction des syllabes avec decomposition attaque/noyau/coda et correspondance grapheme

Structures de donnees

Classe	Champs principaux	Role
`Syllabe`	`phone`, `ortho`, `span`, `attaque`, `noyau`, `coda`	Syllabe decomposee avec alignement
`GroupePhonologique`	`phonemes[]` → `.phone`, `.grapheme`	Attaque, noyau ou coda d’une syllabe
`Phoneme`	`ipa`, `grapheme`	Phoneme individuel avec correspondance grapheme
`ResultatAnalyse`	`mot`, `phone`, `syllabes[]`	Analyse d’un mot
`MotAnalyse`	`token`, `phone`, `liaison`, `pos`	Mot annote par le G2P
`GroupeLecture`	`mots[]`, `phone_groupe`, `jonctions[]`, `span`	Groupe de lecture
`ResultatGroupe`	`groupe`, `syllabes[]`	Groupe syllabe
`ResultatSyllabation`	`groupes[]`, `nb_syllabes`, `nb_groupes`	Resultat complet

Role dans le pipeline Lectura

L’Aligneur-Syllabeur est le pivot central de Lectura :

Preparation des corpus — l’alignement grapheme-phoneme a permis de constituer les donnees d’entrainement des modeles G2P et P2G
Lecture assistee — les groupes de lecture avec syllabes colorees sont la base de l’interface de lecture augmentee
Synthese vocale — l’alignement et les spans permettent la synchronisation texte-audio

Installation

pip install lectura-aligneur       # mode API par defaut (zero dependance)

Phonemiseur pluggable : utilisable avec votre propre phonemiseur, eSpeak-NG, ou le module Lectura G2P. N’importe quel objet avec une methode phonemize(word) ou predict(word) est accepte.

Caracteristiques techniques

Zero dependance Python
Bi-modal : mode API (zero config) ou mode local avec donnees embarquees
Alignement DFS grapheme-phoneme avec gestion des lettres muettes et fusionnees
Modele de sonorite pour la syllabation (5 classes phonologiques)
Architecture E1/E2 : construction des groupes puis syllabation, utilisables separement
Phonemiseur pluggable : eSpeak-NG, Lectura G2P, ou tout objet compatible
Python 3.10+ avec type hints complets (PEP-561)
Double licence : AGPL-3.0 (libre) / Licence commerciale