Créer une nouvelle paire de langues

Tutoriel de création d'une nouvelle paire de langues pour Apertium

Ce document est un tutoriel décrivant les étapes nécessaires à la création d'une nouvelle paire de langues pour le logiciel de traduction automatique Apertium.

Des connaissances de la linguistique ou du système de traduction ne sont pas nécessaires, mais il est tout de même important d'avoir certaines notions de grammaires.

Introduction

Apertium est une platte-forme de traduction automatique. L'engin et les outils sont présents dans le but de faciliter la création d'un système de traduction. Les seules autres choses nécessaires au bon fonctionnement d'Apertium sont les données. Les données sont divisées en trois parties principales, les dictionnaires, et en quelques règles.

Pour obtenir plus d'information à propos du projet apertium, veuillez visiter la page suivante : http://apertium.sourceforge.net.

Pour qu'Apertium puisse fonctionner, vous aurez besoin de :

• lttoolbox (>= 3.0.0)
• libxml utils (xmllint etc.)
• apertium (>= 3.0.0)
• Un éditeur de texte

Ce document ne décrit pas les étapes de l'installation. Pour plus d'informations, veuillez consulter la documentation sur le site du projet Apertium.

Qu'est-ce qu'une paire de langues?

Apertium utilise un type de transfère dit superficiel. Cela signifie que l'engin utilise des dictionnaires et des règles de transfère superficielles. Ce type de transfère est différent de celui dit profond parce qu'il ne fait pas une analyse syntaxique complète. Les règles sont des opérations sur un groupe d'unités lexicales au lieu d'une analyse en arbre. À la base, il y a trois dictionnaires principaux :

1. Le dictionnaire morphologique du langage xx: Contient les règles d'inflection des mots dans le langage xx. Dans l'exemple que nous utiliserons, le fichier sera nommé apertium-sh-en.sh.dix
2. Le dictionnaire morphologique du langage yy: Contient les règles d'inflection des mots dans le langage yy. Dans l'exemple que nous utiliserons, le fichier sera nommé apertium-sh-en.en.dix
3. Le dictionnaire bilingue: Contient la correspondance entre les mots et les symboles dans les deux langages. Dans l'exemple que nous utiliserons, le fichier sera nommé apertium-sh-en.sh-en.dix

Dans une paire de traduction, les deux langages peuvent prendre le rôle de source ou de destination. Ce sont des termes relatifs.

Il y a aussi deux fichiers contenant les règles de transfère. Ces règles sont les lignes directrices de l'ordre des mots dans la phrase. Par exemple : chat noir -> cat black -> black cat. Les règles gouvernent aussi le genre et le nombre. Les règles peuvent aussi êtes utilisées dans le but d'insérer des éléments lexicaux, tel que décrit plus loin. Ce fichiers sont :

• Règles de transfère du langage xx vers le langage yy : Ce fichier contient les règles de transformation du langage xx vers le langage yy. Dans notre exemple, le fichier sera nommé : apertium-sh-en.trules-sh-en.xml
• Règles de transfère du langage xx vers le langage yy : Ce fichier contient les règles de transformation du langage xx vers le langage yy. Dans notre exemple, le fichier sera nommé : apertium-sh-en.trules-en-sh.xml

Certaines paires de langages ont d'autres fichiers, mais nous ne traiterons pas de ces fichiers dans ce tutoriel. Les fichiers mentionnés ci-haut sont ceux qui sont nécessaires au bon fonctionnement du système.

Paire de langages

Comme il est mentionné plus haut, ce tutoriel utilise le Serbo-Croate et l'anglais comme langages pour expliquer la création du système de base. Cette pair n'est pas idéale compte tenu du fait que la relation entre ces deux langages et tout de même faible. Néanmoins, cela ne devrait pas poser de problèmes pour les exemples qui suivent.

Une courte note sur les termes

Il y a un certain nombre de termes qui doivent être compris avant de continuer.

Le premier est : lemme. Un lemme est un mot nullement affecté par les informations grammaticales. Par exemple, le lemme du mot chats est chat. En anglais, le lemme d'un mot est très souvent sa forme singulière masculine. Pour les verbes, le lemme est l'infinitif duquel on retire le "to". Par exemple, le verbe "be" est l'infinitif et le lemme de la forme conjugé "was".

Le deuxième est : symbole. Dans le contexte du système Apertium, un symbole fait référence à une étiquette grammaticale. Comme le logiciel a été initialement développé en Espagne, les abréviations proviennent souvent du catalan. Le mot chats est un mot au pluriel. Deux étiquettes lui seront associées, <n>; pour nom et <pl> pour pluriel. Les symboles sont définis entre balises pour le bon fonctionnement de l'engin Apertium.

Le troisième est : paradigme. Dans le contexte du système Apertium, un paradigme fait référence au comportement d'un certain groupe de mots lors de l'inflection. Dans le dictionnaire morphologique, les lemmes sont liés à des paradigmes, ce qui permet connaître l'inflection de certains lemmes sans avoir à énumérer tous les terminaisons possibles. Les paradigmes sont définis entre les balises <pardef> et utilisé entre balises <par>.

Les dictionnaires monolingues

Commençons par définir notre premier dictionnaire. Le dictionnaire est un fichier XML. Ouvrez votre éditeur de texte favoris et copiez-y les lignes suivantes.

<?xml version="1.0" encoding="UTF-8"?>
<dictionary>

</dictionary>

Sauvez le sous le nom : apertium-sh-en.sh.dix

Pour être utile, notre dictionnaire nécessite quelques entrées. Il est utile de commencer par définir un alphabet dans lequel il y a l'ensemble des caractères qui peuvent être utilisées dans notre dictionnaire. Pour le Serbo-Croate, l'alphabet ressemblera à ce qui suit.

<alphabet>ABCČĆDDžĐEFGHIJKLLjMNNjOPRSŠTUVZŽabcčćddžđefghijklljmnnjoprsštuvzž</alphabet>

Il convient ensuite de remplir l'espace entre <dictionary> et </dictionary>

Nous devons définir certains symboles. Commençons par des symboles simples tels que : nom (n) singulier (sg) et pluriel (pl).

<sdefs>
   <sdef n="n"/>
   <sdef n="sg"/>
   <sdef n="pl"/>
</sdefs>

Les symboles n'ont pas à être si courts. Ils peuvent être écrit au long, mais comme vous allez les taper très souvent, il est optimal de les abbrévier.

Malheureusement, les noms ne sont pas si simples en Serbo-Croate. Les inflections se font plus qu'en nombre, mais en genre et en cas. Mais à des fins pédagogiques, nous allons utiliser les noms masculins dans le cas nomintatif.

La prochaine étape est de définir une section pour les paradigmes

<pardefs>

</pardefs>

et une section pour la partie principale du dictionnaire.

<section id="main" type="standard">

</section>

Il y a deux types de section dans un dictionnaire de données. La première est la section standard, qui contient des mots, des clitiques, etc. La deuxième section est dite inconditionnelle et contient des éléments grammaticaux tels que la ponctuation. Nous n'utiliserons pas de section inconditionnelle dans notre exemple.

Notre fichier devrait maintenant ressembler à ce qui suit :

<?xml version="1.0" encoding="UTF-8"?>
<dictionary>
   <sdefs>
     <sdef n="n"/>
     <sdef n="sg"/>
     <sdef n="pl"/>
   </sdefs>
   <pardefs>

   </pardefs>
   <section id="main" type="standard">

   </section>
</dictionary>

Maintenant que notre squelette est en place, nous pouvons y ajouter un nom. Le nom en question sera 'gramofon' (qui signifie gramophone, un lecteur de musique)

La première chose à faire, compte tenu du fait que nous n'avons pas de paradigmes, est de définir un paradigme.

Souvenez vous que nous utilisons le masculin dans le cas nominatif pour l'exemple. La forme singulière du mot est 'gramofon' et la forme plurielle est 'gramofoni'.

Alors :

<pardef n="gramofon__n">
   <e>
     <p>
       <l/>
       <r><s n="n"/><s n="sg"/></r>
     </p>
   </e>
   <e>
     <p>
       <l>i</l>
       <r><s n="n"/><s n="pl"/></r>
     </p>
   </e>
</pardef>

Note: La balise '<l/>' (equivalente à <l></l>) signifie qu'il n'y a rien à ajouter dans la section "sg" pour le mot 'gramofon'.

À ce moment, vous vous demandez possiblement à quoi servent les nombreuses balises.

   * e, est pour entrée.
   * p, est pour pair.
   * l, est pour "left"(gauche).
   * r, est pour "right"(droite). 

La raison des balises <l> et <r> est simple, les dictionnaires morphologiques seront compilés en machines à état fini. La compilation Gauche/Droite produit des analyses à partir de mots, tandis que la compilation Droite/Gauche produit des mots à partir d'analyses.

Par exemple :

• gramofoni (gauche à droite) gramofon<n><pl> (analyse)
• gramofon<n><pl> (droite à gauche) gramofoni (génération d'un mot)

Maintenant qu'un paradigme est défini, nous devons le lier au lemme 'gramofon'. Nous ajoutons ce lien dans la section précédemment définie.

L'entrée dans </dictionary>

En compilant de gauche à droite, nous obtenons un analyseur. Maintenant, créons un générateur.

$ lt-comp rl apertium-sh-en.sh.dix sh-en.autogen.bin

À ce stage, la sortie devrait être la même que plus haut.

Testons l'analyseur avec lt-proc.

$ lt-proc sh-en.automorf.bin

Maintenant, essayons le avec 'gramofoni'

La sortie devrait être la suivante :

^gramofoni/gramofon<n><pl>$

Maintenant, nous devons appliquer le même processus dans le dictionnaire Anglais, en prenant soin de substituer le mot 'gramofon' par gramophone et changer l'inflection au pluriel.

Il devrait maintenant y avoir deux fichiers dans le dossier :

   * apertium-sh-en.sh.dix qui contient un dictionnaire morphologique très basique du Serbo-Croate
   * apertium-sh-en.en.dix qui contient un dictionnaire morphologique très basique de l'Anglais

Les dictionnaires bilingues

Donc, jusqu'à maintenant, nous avons créé deux dictionnaires morphologiques unilingues. La prochaine étape est de créer un dictionnaire bilingue, dictionnaire qui décrit les liens entre les mots des deux dictionnaires. Tous les dictionnaires utilisent le même format (Spécifié dans le DTD, dix.dtd).

Créer un nouveau fichier, apertium-sh-en.sh-en.dix et ajoutez-y le squelette de base :

<?xml version="1.0" encoding="UTF-8"?>
<dictionary>
   <alphabet/>
   <sdefs>
     <sdef n="n"/>
     <sdef n="sg"/>
     <sdef n="pl"/>
   </sdefs>

   <section id="main" type="standard">

   </section>
</dictionary>

Nous devons maintenant ajouter une entrée pour la traduction entre les deux mots :

<e><p><l>gramofon<s n="n"/></l><r>gramophone<s n="n"/></r></p></e>

Parce qu'il y a habituellement beaucoup d'entrées dans un dictionnaire, il vaut mieux utiliser une ligne par entrée, facilitant ainsi la lisibilité du fichier. En compilant le dictionnaire de gauche à droite, nous obtenons un dictionnaire Serbo-Croate -> Anglais et en le compilant de droite à gauche, nous obtenons un dicitonnaire Anglais -> Serbo-Croate.

Une fois que l'entrée est ajoutée, tapez les commandes suivantes :

$ lt-comp lr apertium-sh-en.sh.dix sh-en.automorf.bin
$ lt-comp rl apertium-sh-en.sh.dix sh-en.autogen.bin

$ lt-comp lr apertium-sh-en.en.dix en-sh.automorf.bin
$ lt-comp rl apertium-sh-en.en.dix en-sh.autogen.bin

$ lt-comp lr apertium-sh-en.sh-en.dix sh-en.autobil.bin
$ lt-comp rl apertium-sh-en.sh-en.dix en-sh.autobil.bin

Cela génère un analyseur morphologique (automorf), un générateur morphologique (autogen) et un chercheur de mots (autobil) (bil pour bilingue).

Règles de transfère

Maintenant, nous avons deux dictionnaires morphologiques et un dictionnaire bilingue. Tout ce que nous avons à faire est une règle de transfère pour les noms. Les fichiers de règles de transfère sont dans des fichiers DTD (transfer.dtd) qui sont dans l'ensemble Apertium. Si vous voulez implémenter une règle, il est optimal de regarder dans d'autres fichier de règles et de s'en inspirer, question de recycler ce qui a déjà été fait. Par exemple, celle qui suit sera utile pour toutes langues ne nécessitant pas un sujet.

Copiez le squelette comme dans les autres fichiers :

<?xml version="1.0" encoding="UTF-8"?>
<transfer>

</transfer>

À ce moment, parce que nous ignorons les cas, nous devons seulement faire une règle qui prend les symboles grammaticaux entrés et les transforme en sortie.

Nous devons d'abord définir des catégories et des attributs. Ceux-ci nous permettent de grouper les symboles grammaticaux. Les catégories servent aussi à grouper les symboles dans un but d'appariement (Par exemple 'n.*' représente tous les noms). Les attributs servent à grouper un ensemble de symboles dans lequel il est facile de faire une sélection (Par exemple 'sg' et 'pl' peuvent être groupées avec un attribut 'nombre')

Ajoutons maintenant les sections nécessaires :

<section-def-cats>

</section-def-cats>
<section-def-attrs>

</section-def-attrs>

Puisque nous faisons seulement l'inflection des noms singuliers et pluriels, nous devons ajouter une catégorie pour les noms avec un attribut nombre. Cela suffira :

Dans la section : section-def-cats

<def-cat n="nom">
   <cat-item tags="n.*"/>
</def-cat>

Cela réfère à tous les noms (les lemmes suivi de <n> et de n'importe quoi) Dans la section section-def-attrs, ajoutez:

<def-attr n="nbr">
   <attr-item tags="sg"/>
   <attr-item tags="pl"/>
</def-attr>

et ensuite

<def-attr n="a_nom">
   <attr-item tags="n"/>
</def-attr>

La première définit l'attribut nbr (number), qui peut être singulier(sg) ou pluriel (pl) La deuxième définit l'attribut a_nom (l'attribut du nom)

Ensuite, nous devons ajouter une section pour les variables globales :

<section-def-vars>

</section-def-vars>

Ces variables sont utilisés pour conserver ou transférer les attributs entre les règles. Nous avons besoin d'une seule variable à cette étape-ci.

<def-var n="number"/>

Finalement, nous devons ajouter une règle, qui prendra le nom et qui créera une sortie dans le bon format. Une section de règles est nécessaire.

<section-rules>

</section-rules>

Voici un exemple de règle :

<rule>
   <pattern>
     <pattern-item n="nom"/>
   </pattern>
   <action>
     <out>
       <lu>
         <clip pos="1" side="tl" part="lem"/>
         <clip pos="1" side="tl" part="a_nom"/>
         <clip pos="1" side="tl" part="nbr"/>
       </lu>
     </out>
   </action>
</rule>

La première balise définit une règle. La deuxième balise signifie au programme d'appliquer la règle si ce le patron(motif) est trouvé. Dans cet exemple, le motif est un nom singulier. Notez que les motifs ont une correspondance avec les plus longs résultats. Si vous avez trois règles et que la première concorde avec "<prn><vblex><n>", la deuxième avec "<prn><vblex>" et la troisième avec "<n>", le motif qui sera choisit sera le premier.

Pour chacun des motifs, il y a une action associée, qui produit une certaine sortie. La sortie est une unité lexicale (lu).

Le balise "clip" permet à l'utilisateur de selectionner et de manipuler des attributs et des items lexicaux du langage source (side="sl") et du langage cible (side="tl").

Compilons et testons.

$ apertium-preprocess-transfer apertium-sh-en.trules-sh-en.xml trules-sh-en.bin

Ce qui générera une fichier trules-sh-en.bin.

Nous sommes maintenant prêts à tester notre système de traduction.

Pour commencer, voyons voir le résultat avec le mot 'gramofoni' :

$ echo "gramofoni" | lt-proc sh-en.automorf.bin 

La sortie devrait être la suivante :

^gramofon/gramofon<n><pl>$

Maintenant,

$ echo "gramofoni" | lt-proc sh-en.automorf.bin | \
  gawk 'BEGIN{RS="$"; FS="/";}{nf=split($1,COMPONENTS,"^"); for(i = 1; i<nf; i++) printf COMPONENTS[i]; if($2 != "") printf("^%s$",$2);}' | \
^gramofon<n><pl>$

Essayons maintenant la règle de transfère :

$ echo "gramofoni" | lt-proc sh-en.automorf.bin | \
  gawk 'BEGIN{RS="$"; FS="/";}{nf=split($1,COMPONENTS,"^"); for(i = 1; i<nf; i++) printf COMPONENTS[i]; if($2 != "") printf("^%s$",$2);}' | \
  apertium-transfer apertium-sh-en.trules-sh-en.xml trules-sh-en.bin sh-en.autobil.bin

Liens externes

• http://apertium.sourceforge.net/ Le site officiel d'Apertium
• http://ilazki.thinkgeek.co.uk/apertium/graph.svg
• http://xixona.dlsi.ua.es/wiki/index.php/Main_Page

Sources

• http://apertium.sourceforge.net/index_fr.html
• http://apertium.sourceforge.net/#documentation
• http://ilazki.thinkgeek.co.uk/apertium/index.php