Apertium et les contraintes grammaticales (vislcg3)

From Apertium
Revision as of 16:20, 1 May 2012 by Bech (talk | contribs) (Création page)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search

Cette page décrit l'utilisation des contraintes grammaticales (CG) sur la plateforme de traduction Apertium. Bien que 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 tagger d'Apertium, permettant l'imposition de contraintes plus fines que ce qui serait possible sinon.

Logiciels requis

Installation de VISL CG3

Vous aurez besoin d'installer cmake. Pour l'installer sur Debian tapez juste apt-get install cmake.

Vous aurez besoin d'installer libicu-dev. Pour l'installer sur Debian tapez juste apt-get install libicu-dev.

Vous aurez besoin d'installer libboost-dev. Pour l'installer sur Debian tapez juste apt-get install libboost-dev.

Vous pourriez vouloir installer tmalloc. Pour l'installer sur Debian tapez juste 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, on a :

$ 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>$

Ici on a deux ambiguïtés, la première est entre un nom et un verbe, la seconde est entre un détermineur et un 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.

D'abord on définit nos catégories, ce peut être des balises, des formes de mots ou lemmes. Ça peut aider de penser à elles comme "balises grossières", qui pourraient impliquer un ensemble de belles balises ou de lemmes. Donc, créer un fichier grammaire.txt, et ajouter 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.

La prochaine chose qu'on veut faire est d'écrire les deux règles, donc :

Règle #1
"Quand l'unité lexicale courante peut être un pronom ou un détermineur, et qu'elle est suivie à droite par une unité lexicale qui pourrait être un nom, choisir le détermineur"
# 1
SELECT DET IF
        (0 DET)
        (0 PRN)
        (1 NOUN) ;

Ajouter cette règle au fichier, et compiler en utilisant cg-comp

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

Maintenant essayez de le tester 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 voir, le détermineur 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étermineur, supprimer la "lecture" du nom."
# 2
REMOVE NOUN IF
        (0 NOUN)
        (0 VERB)
        (1 PREP)
        (2 DET) ;

Ajouter cette règle, recompiler la grammaire et tester :

$ 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>$

Voilà ! Une 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 étoile star aux mots inconnus, donc vous pouvez trouver les mots inconnus en utilisant une expression régulière simple qui trouve cette étoile :

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

Maintenant vous pouvez avoir une règle comme

SELECT proper-name IF (1 unknown);

Performance

Pour appliquer les 2 règles de grammaire ci-dessus à un texte d'entrée de 10 000 lignes (40 000 mots), ça prend approximativement 12 secondes (~ 3 000 mots/seconde). En comparaison, apertium-tagger fait ça en 1,5 secondes (~ 26 000 mots/seconde). Testé avec une grammaire plus étendue, pour féroïen — de 204 règles, la performance tombe à (~ 2 000 mots/seconde).

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

Liens externes