Créer une nouvelle paire de langues

From Apertium
Jump to: navigation, search

In English

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 grammaire.

Contents

[edit] Introduction

Apertium est une plate-forme de traduction automatique. Le moteur 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.

[edit] Qu'est-ce qu'une paire de langues ?

Apertium utilise un type de transfert dit superficiel. Cela signifie que le moteur utilise des dictionnaires et des règles de transfert superficielles. Ce type de transfert 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 de la langue xx : il contient les règles d'inflexion des mots dans la langue xx. Dans l'exemple que nous utiliserons, le fichier sera nommé apertium-sh-en.sh.dix[1]
  2. Le dictionnaire morphologique de la langue yy : il contient les règles d'inflexion des mots dans la langue yy. Dans l'exemple que nous utiliserons, le fichier sera nommé apertium-sh-en.en.dix
  3. Le dictionnaire bilingue: il contient la correspondance entre les mots et les symboles dans les deux langues. Dans l'exemple que nous utiliserons, le fichier sera nommé apertium-sh-en.sh-en.dix

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

Deux autres fichiers contiennent les règles de transfert. 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. Ces fichiers sont :

  • Règles de transfert de la langue xx vers la langue yy : ce fichier contient les règles de transformation de la langue xx vers la langue yy. Dans notre exemple, le fichier sera nommé : apertium-sh-en.sh-en.t1x
  • Règles de transfert de la langue xx vers la langue yy : ce fichier contient les règles de transformation de la langue xx vers la langue yy. Dans notre exemple, le fichier sera nommé : apertium-sh-en.en-sh.t1x

Pour certaines paires de langues, il existe des fichiers supplémentaires mais nous n'abordons pas ces fichiers dans ce tutoriel. Les fichiers mentionnés plus haut sont ceux qui sont nécessaires au bon fonctionnement du système.

[edit] Paire de langues

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

[edit] 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 la forme standard d'un mot qui peut être fléchi (conjugué, décliné, etc.). Par exemple, le lemme de la forme "sachions" est "savoir". En anglais, comme la flexion des mots est très limitée, 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 conjugué "was". En français, pour les noms et les adjectifs, le lemme sera la première personne du singulier, pour les verbes ce sera l'infinitif.

Le deuxième est : symbole. Dans le contexte du système Apertium, un symbole (ou "tag") fait référence à une étiquette grammaticale. Comme le logiciel a été initialement développé en pays catalan, 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 du moteur Apertium. Attention : l'écriture <pl> sera utilisée en "mode texte", alors qu'en "mode XML" le même tag sera noté <s n="pl"/>.

Le troisième est : paradigme. (En grec, "paradeigma" signifie "exemple".) Dans le contexte du système Apertium, un paradigme fait référence au comportement d'un certain groupe de mots lors de la flexion. Dans le dictionnaire morphologique, les lemmes sont liés à des paradigmes, ce qui permet de connaître la flexion de certains lemmes sans avoir à énumérer toutes les terminaisons possibles. Les paradigmes sont définis dans les éléments <pardef> et appelés par les éléments <par>.

[edit] Les dictionnaires monolingues

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

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

</dictionary>

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

Pour être utile, nous devons ajouter quelques entrées dans notre dictionnaire. On commencera d'abord par spécifier l'ensemble des caractères susceptibles d'être utilisés dans le dictionnaire entre les balises 'alphabet'. 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 les balises <dictionary> et </dictionary>.

Nous devons aussi 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 identifiants de symbole peuvent être d'une longueur quelconque. Cependant, il est préférable de définir des symboles abrégés car vous allez les taper très souvent.

Malheureusement, les noms ne sont pas si simples en serbo-croate. Les inflexions 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 nominatif.

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 existe 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'.

Par conséquent :

<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/>' (équivalente à <l></l>) signifie qu'il n'y a rien à ajouter dans la section "sg" pour le mot 'gramofon'.

Vous vous demandez sans doute à quoi servent les diverses balises de l'exemple ci-dessus.

  • e est utilisé pour 'entrée'.
  • p est utilisé pour 'pair'.
  • l est utilisé pour 'left'(gauche).
  • r est utilisé pour 'right'(droite).

L'explication de la présence 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)

À présent que nous avons défini un paradigme, nous devons le lier au lemme 'gramofon'. Nous ajoutons ce lien dans la section précédemment définie.

L'entrée dans </dictionary> </pre>

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>

Comme un dictionnaire compte d'ordinaire de très nombreuses entrées, il est préférable d'utiliser une ligne par entrée pour la facilité de 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 dictionnaire anglais -> serbo-croate.

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

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

$ lt-comp lr apertium-sh-en.en.dix en-sh.automorf.bin
$ lt-comp rl apertium-sh-en.sh.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).

[edit] Règles de transfert

Maintenant, nous avons deux dictionnaires morphologiques et un dictionnaire bilingue. Tout ce que nous avons à faire est une règle de transfert pour les noms. Les fichiers de règles de transfert 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'inflexion 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).

La balise "clip" permet à l'utilisateur de sélectionner 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.sh-en.t1x sh-en.t1x.bin

Ce qui générera un fichier sh-en.t1x.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 transfert :

$ 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.sh-en.t1x sh-en.t1x.bin sh-en.autobil.bin


[edit] Génération

[edit] Notes de bas de page

  1. Ce fichier peux avoir éventuellement l'extension metadix

[edit] Voir aussi

Personal tools