Apertium et les contraintes grammaticales (vislcg3)

In English

Cette page décrit l'utilisation des contraintes grammaticales (CG) sur la plateforme de traduction Apertium. Bien qu'Apertium ait déjà un désambiguïsateur rapide, avec des statistiques de haute précision (POS tagger), l'utilisation du désambiguïsateur CG pourra probablement dans beaucoup de cas être utilisé pour améliorer les résultats. Par exemple,le désambiguïsateur CG pourra être utilisé comme pré-désambiguïsateur pour le tagueur d'Apertium, permettant l'imposition de contraintes plus fines que ce qui serait possible sinon.

Logiciels requis

• lttoolbox (français) (>= 3.0.5)
• Apertium (>= 3.0.0)
• ICU (>= 3.8)
• Une paire de langues (les exemples utilisent apertium-es-ca)
• VISL CG3 (depuis SVN -- voir plus bas)

Debian / Ubuntu et dérivés

curl -sS http://apertium.projectjj.com/apt/install-nightly.sh | sudo bash
sudo apt-get install cg3

Installation de VISL CG3

Vous aurez besoin de cmake. Pour l'installer sur Debian, tapez simplepment apt-get install cmake.

Vous aurez besoin de libicu-dev. Pour l'installer sur Debian, tapez simplement apt-get install libicu-dev.

Vous aurez besoin de libboost-dev. Pour l'installer sur Debian, tapez simplement apt-get install libboost-dev.

Vous pourriez vouloir installer tmalloc. Pour l'installer sur Debian, tapez simplement apt-get install libgoogle-perftools-dev.

$ svn co http://beta.visl.sdu.dk/svn/visl/tools/vislcg3/trunk vislcg3
$ cd vislcg3
$ ./cmake.sh -DCMAKE_INSTALL_PREFIX=<prefix>
$ make -j3
$ make install

Vous devriez maintenant avoir quatre exécutables dans <prefix>/bin:

• vislcg3 — c'est le désambiguïsateur d'origine. Il possède toutes les caractéristiques disponibles (?) et utilise le format d'entrée/sortie de CG.
• cg-comp — est un programme pour compiler les grammaires dans un format binaire.
• cg-proc — est un programme pour exécuter les grammaires binaires sur une entrée de flux Apertium formaté.
• cg-conv — est un programme pour convertir entre formats de flux à la volée.

Note : le support d'Apertium dans VISL CG est encore en développement et donc des bugs peuvent être trouvés.

Exemple d'utilisation

Prenons un exemple d'Apertium, soit :

$ echo "vino a la playa" | lt-proc es-ca.automorf.bin 
^vino/vino<n><m><sg>/venir<vblex><ifi><p3><sg>$ ^a/a<pr>$ ^la/el<det><def><f><sg>/lo<prn><pro><p3><f><sg>$ ^playa/playa<n><f><sg>$

Deux cas d'ambiguïté se posent : le premier cas concerne la possibilité 'nom ou verbe', le second la possibilité 'déterminant ou pronom'. La séquence la plus appropriée serait verb prep det noun (verbe préposition déterminant nom). On peut écrire quelques règles dans CG pour forcer cela.

La première étape consiste à définir les catégories nécessaires ; ce peut être des balises, des formes de mots ou des lemmes. Ça peut aider de penser à elles comme "balises grossières", qui pourraient impliquer un ensemble de belles balises ou de lemmes. Pour ce faire, on crée un fichier grammaire.txt et on y ajoute le texte suivant :

DELIMITERS = "<$.>" ;

LIST NOUN = n;
LIST VERB = vblex;
LIST DET = det;
LIST PRN = prn;
LIST PREP = pr;

SECTION

Note : le mot-clé delimiters est utilisé pour définir les limites de fenêtre.

L'étape suivante consiste à écrire les deux règles, à savoir :

Règle #1

"Quand l'unité lexicale courante peut être un pronom ou un déterminant et qu'elle est suivie à droite par une unité lexicale qui pourrait être un nom, choisir le déterminant"

# 1
SELECT DET IF
        (0 DET)
        (0 PRN)
        (1 NOUN) ;

On ajoute la règle au fichier, puis on compile à l'aide de cg-comp.

$ ./cg-comp grammaire.txt grammaire.bin
Sections: 1, Rules: 1, Sets: 6, Tags: 7

À présent, on teste la règle dans le pipeline Apertium :

$ echo "vino a la playa" | lt-proc es-ca.automorf.bin |  cg-proc grammaire.bin
^vino/vino<n><m><sg>/venir<vblex><ifi><p3><sg>$ ^a/a<pr>$ ^la/el<det><def><f><sg>$ ^playa/playa<n><f><sg>$

Comme on peut le voir, le déterminant a été sélectionné à la place du pronom.

Règle #2

"Quand l'unité lexicale courante peut être un nom ou un verbe, si les deux unités qui suivent à droite sont une préposition et un déterminant, supprimer la "lecture" du nom."

# 2
REMOVE NOUN IF
        (0 NOUN)
        (0 VERB)
        (1 PREP)
        (2 DET) ;

On ajoute la règle, on recompile la grammaire et on teste :

$ echo "vino a la playa" | lt-proc es-ca.automorf.bin |  cg-proc grammaire.bin
^vino/venir<vblex><ifi><p3><sg>$ ^a/a<pr>$ ^la/el<det><def><f><sg>$ ^playa/playa<n><f><sg>$

Et voilà la phrase pleinement désambiguïsée ! Il est utile de noter que les mots-clés SELECT et REMOVE peuvent passer pour similaires aux contraintes forbid / enforce du format TSX utilisé par apertium-tagger, seulement beaucoup plus flexible.

Trouver les mots inconnus dans Apertium

lttoolbox ajoute une astérisque (*) aux mots inconnus. Vous pouvez par conséquent repérer les mots inconnus à l'aide d'une expression régulière simple qui recherchera les astérisques :

LIST unknown = ("\\*.*"r) ; 

Maintenant vous pouvez avoir une règle comme

SELECT proper-name IF (1 unknown);

Performance

Quand on applique les deux règles de grammaire plus haut à un texte d'entrée de 10.000 lignes (40.000 mots), le traitement requiert environ 12 secondes (~ 3.000 mots/sec). En comparaison, apertium-tagger fait cela en 1,5 secondes (~ 26.000 mots/sec). Dans le cas d'un essai avec une grammaire plus étendue (pour le féroïen — de 204 règles), la performance descend à ~ 2.000 mots/sec.

Traçage

vislcg3 supporte le traçage, en montrant quelles règles ont été appliquées, bien que la commande cg-proc ne le supporte pas. Quoi qu'il en soit, pour le développement, on peut utiliser le script python tagger-to-visl.py pour mettre le texte formaté Apertium au format vislcg3, et ensuite juste utiliser la commande vislcg3 :

$ echo "vino a la playa" | lt-proc es-ca.automorf.bin | python tagger-to-visl.py | vislcg3 --trace -g grammaire.txt

C'est vraiment pratique, puisque vous obtenez rapidement le numéro de ligne (et le nom de la règle, si vous en avez spécifié un) pour chaque modification faite dans le flux par vislcg3.

Dépannage

Si vous obtenez

/usr/local/bin/cg-proc: invalid option -- 'w'
/usr/local/bin/apertium: line 480:  9764 Avbrutt (SIGABRT)       $APERTIUM_PATH/apertium-re$FORMATADOR > $SALIDA

cela signifie que votre vislcg3 a besoin d'être mis à jour.

Après votre mise à jour de vislcg3, vous risquez probablement d'obtenir quelque-chose comme

Error: Grammar revision is 4879, but this loader requires 5465 or later!

Il vous faut recompiler vos grammaires CG chaque fois que vous mettez à jour vislcg3, ex :

cd apertium-nn-nb
touch *.rlx            # ruse pour faire penser que grammaires ont besoin d'être recompilées
make
sudo make install

Voir aussi

• Contraintes grammaticales
• Entraînement d'un tagueur

Liens externes

• Manuel sur les contraintes grammaticales