Bases sur les dictionnaires unilingues

On a dit que le format des dictionnaires d'Apertium n'est pas intuitif, ce qui est assez vrai si vous n'êtes pas habitué à penser aux dictionnaires d'une manière particulière. Cette page espère être une introduction de base sur la façon dont ils fonctionnent et comment vous pouvez commencer à les lire et les écrire !

Cette page suppose que vous êtes à l'aise avec HTML et XML, que vous pouvez distinguer un élément d'un attribut et savez ce que sont les données caractères. Si vous voulez un résumé rapide, ceci devrait vous aider :

<element attribute="value">character data</element>

Si cela n'a aucune signification pour vous, vous devriez probablement lire un peu plus sur le XML.

Introduction

Donc, au niveau global, le dictionnaire le plus basique a besoin de 3 sections. Nous allons, pas à pas, définir un dictionnaire qui va analyser et générer le mot anglais "beer" et sa forme plurielle, "beers".

La première section définit l'alphabet qui est utilisé par le dictionnaire. C'est assez explicite et ça ressemblera à quelque-chose comme :

  <alphabet>ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz</alphabet>

La seconde section définit les symboles grammaticaux de la langue sur laquelle vous travaillez. C'est normalement là où les gens disent, attendez... que sont les symboles grammaticaux ? Hé bien, il y a plusieurs façons de décrire les mots, et les différentes formes que les mots peuvent prendre, donc je suppose que vous savez ce qu'est une partie de discours. Par exemple: les noms (maison, bière, bateau, chat, ...), que vous pouvez distinguer des adjectifs (rouge, bon, transparent, ...) et des verbes (manger, multiplier, écrire, ...). La manière de les spécifier est la suivante :

  <sdefs>
    <sdef n="nom"/>
    <sdef n="verbe"/>
    <sdef n="adjectif"/>
  </sdefs>

ou en utilisant des termes anglais :

  <sdefs>
    <sdef n="noun"/>
    <sdef n="verb"/>
    <sdef n="adjective"/>
  </sdefs>

Les gens se plaignent souvent de la brièveté de ces symboles, et typiquement même les valeurs sont abrégées, ainsi le nom devient "n", le verbe devient "vb" et l'adjectif devient "adj" etc... (voir Liste de symboles pour quelques abréviations courantes). La brièveté présente toutefois un intérêt, quand vous écrivez, ou copiez vous voulez que les symboles restent aussi petits que possible. Par exemple, <sdef> veut dire "définition de symbole", et <sdefs> est simplement la même chose au pluriel.

Après avoir spécifié l'alphabet et les symboles, on a besoin de spécifier les mots, c'est la partie la plus importante du dictionnaire ! Pour supporter les mots on utilise une section. Il peut y avoir plus d'une section dans un dictionnaire, et il y a plus d'un type de section. On ne rentrera pas dans les détails ici, mais traditionnellement la plus grande section est appelée "main" et est de type "standard".

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

  </section>

La prochaine étape est de rajouter une entrée. C'est un peu plus compliqué, donc s'il vous plaît, continuez de lire...

Entrées

Les dictionnaires unilingues dans Apertium sont des dictionnaires morphologiques, cela signifie qu'ils ne supportent pas seulement les mots, mais qu'ils supportent aussi comment ils s'infléchissent, et ce que leur infléchissement signifie. Dans Apertium on utilise les dictionnaires morphologiques pour deux traitements :

1. Analyse — récupération de toutes les unités lexicales possibles à partir de la forme de surface d'un mot.
2. Génération — production de la forme de surface d'un mot à partir d'une unité lexicale.

Bon, maintenant pour expliquer unité lexicale et forme de surface. Rappelez-vous l'exemple de "beer" et "beers". Nous savons que "beer" est un nom, nous savons aussi qu'il est au singulier, nous savons aussi que la seule différence entre "beer" et "beers" est que "beers" est au pluriel. Donc, pour résumer les connaissances ci-dessous, on trouve les 2 faits suivants :

1. beer — est un nom au singulier,
2. beers — est la forme au pluriel du nom "beer".

Ce qu'on entend par unité lexicale est la combinaison du lemme, par exemple "beer" et des symboles grammaticaux. La forme de surface d'un mot est le mot tel que vous le lisez. Dans le style Apertium ils devraient être représentés par quelque-chose comme ce qui suit :

Forme de surface	Unité lexicale
beer	beer<nom><singulier>
beers	beer<nom><pluriel>

Afin de pouvoir faire la conversion entre ces deux formes, on a besoin de les définir comme paire. Les paires de forme de surface et d'unités lexicales dans Apertium sont indiquées par l'élément <p> . C'est plutôt intuitif, à partir du moment où vous connaissez l'abréviation ! Ces éléments paires peuvent contenir un "coté gauche" (<l> abréviation de l'anglais left) et un "coté droit" (<r> abréviation de l'anglais right). Le coté gauche contient presque toujours la forme de surface du mot, alors que le coté droit contient l'unité lexicale. Donc, notre première entrée (<e>) devrait ressembler à quelque-chose comme :

    <e>
      <p>
        <l>beer</l>
        <r>beer<s n="nom"/><s n="singulier"/></r>
      </p>
    </e>

Maintenant, en gros, vous avez besoin d'autant de ces entrées qu'il y a de formes de surface dans la langue, toutefois les astucieux parmi vous se seront rendus compte que la création d'entrées pour tous les mots d'une langue est une tâche impossible. La prochaine section vous montrera comment cela peut être évité, mais pour l'instant nous avons à présent suffisamment d'informations pour compiler notre premier dictionnaire :

<dictionary>
  <alphabet>abcdefghijklmnopqrstuvwxyz</alphabet>
  <sdefs>
    <sdef n="nom"/>
    <sdef n="singulier"/>
    <sdef n="pluriel"/>
  </sdefs>

  <section id="main" type="standard">
    <e>
      <p>
        <l>beer</l>
        <r>beer<s n="nom"/><s n="singulier"/></r>
      </p>
    </e>
    <e>
      <p>
        <l>beers</l>
        <r>beer<s n="nom"/><s n="pluriel"/></r>
      </p>
    </e>
  </section>
</dictionary>

Les entrées ci-dessus nous permettrons de retrouver les unités lexicales pour "beer" et "beers", and générer les deux formes de surface de ces mêmes unités lexicales.

Le dictionnaire est fonctionnel, mais est destiné à des fins pédagogiques, les vrais fichiers dictionnaires ont un aspect quelque peu différent, parce que définir chaque mot complètement séparément des autres mots qui suivent les mêmes règles est plutôt inefficace.

Compilation

Voir aussi : Lttoolbox (français)

Save this into a file called dictionary.dix, then we'll compile the dictionary into a binary form using the tool lt-comp. The command takes three arguments, the first is "direction", then input file and output file. The "direction" option is important.

If we specify the direction as "lr" (left → right), we get an analyser (that is, a dictionary that takes surface forms and outputs lexical units. If we specify the reverse ("rl", right → left), we get a generator, which takes lexical units and outputs surface forms. We might as well generate both:

$ lt-comp lr dictionary.dix analyser.bin
main@standard 7 6

$ lt-comp rl dictionary.dix generator.bin
main@standard 7 6

We can now use the dictionary to analyse the noun "beers":

$ echo "beers" | lt-proc analyser.bin
^beers/beer<noun><plural>$

The analysis gives us the surface form, followed by the lexical unit. Say we want to generate the surface form from the lexical unit, we just do:

$ echo "^beer<noun><plural>$" | lt-proc -g generator.bin
beers

Paradigms

So, great, we have a dictionary and we can analyse and generate the two forms of the words "beer". But what happens when we want to add more words, say "school", or "computer". Well, one thing we could do is just add four more entries in the main section (one for each of "school", "schools", "computer" and "computers"). On the other hand, this would be pretty inefficient. Instead, we can generalise a rule, which in this case is "add -s to make the plural", using a paradigm, which is literally, "an example serving as a model or pattern".

In order to define paradigms, we typically take a word that can serve as an example for how other words inflect. In this case, we can say, "the words school and computer inflect like beer".

Paradigms go in a section called <pardefs> (paradigm definitions), below the <sdefs> and above the main section. They are defined in <pardef> (paradigm definition) elements. Each paradigm definition must have an attribute "id", which contains a unique name. This id can be anything, but conventionally takes the form of:

<lemma>__<part of speech>, (e.g. beer__n)

In order to make the lexical units for beer, beers, computer, computers, etc... we need to distinguish between the part of the surface form that doesn't change (the identical part), and the part that does change. In the example already given, it is quite straightforward that the identical part is always the singular form. However, this might not always be the case (e.g. "wolf, wolves" or "tooth, teeth").

You probably guessed already what the paradigm definition is going to look like, so here it is:

    <pardef n="beer__n">
      <e>
        <p>
          <l/>
          <r><s n="noun"/><s n="singular"/></r>
        </p>
      </e>
      <e>
        <p>
          <l>s</l>
          <r><s n="noun"/><s n="plural"/></r>
        </p>
      </e>
    </pardef>

The only thing that has changed between these two entries, and the first ones we made is that the identical part has been removed from both sides of the pair.

The paradigm definition goes into its own part of the dictionary, enclosed in <pardefs> tags, for example:

  <pardefs>

    ...  

  </pardefs>

We can see where this fits in with the rest of the dictionary below:

<dictionary>
  <alphabet>abcdefghijklmnopqrstuvwxyz</alphabet>
  <sdefs>

   ...

  </sdefs>
  <pardefs>

    ...  

  </pardefs>
  <section id="main" type="standard">
    <e lm="beer"><i>beer</i><par n="beer__n"/></e>
    <e lm="school"><i>school</i><par n="beer__n"/></e>
    <e lm="computer"><i>computer</i><par n="beer__n"/></e>
    <e lm="house"><i>house</i><par n="beer__n"/></e>
  </section>
</dictionary>