Difference between revisions of "Mutation de la consonne initiale"

From Apertium
Jump to navigation Jump to search
(Création de la page (début de traduction))
 
(Lien page anglaise)
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
[[Initial consonant mutation|In English]]

Cette page donne un bref aperçu sur la manière dont les mutations de la consonne initiale sont actuellement analysées, désambiguïsées et générées dans Apertium. Elle utilise comme exemple la paire de langue <code>apertium-ga-gd</code> .
Cette page donne un bref aperçu sur la manière dont les mutations de la consonne initiale sont actuellement analysées, désambiguïsées et générées dans Apertium. Elle utilise comme exemple la paire de langue <code>apertium-ga-gd</code> .


=== Analyse ===
=== Analyse ===


L'analyse est prise en charge par la création de paradigmes avec le mot initial qui remplace simplement les formes non mutées avec les formes mutées. Par exemple pour la consonne initiale 'b', qui peut être lenited (?) comme 'bh' ou éclipsée comme 'mb', on obtient le paradigme de mutation initial suivant :
L'analyse est prise en charge par la création de paradigmes avec le mot initial qui remplace simplement les formes non mutées avec les formes mutées. Par exemple pour la consonne initiale 'b', qui peut être lénité comme 'bh' ou éclipsée comme 'mb', on obtient le paradigme de mutation initial suivant :


<pre>
<pre>
Line 40: Line 42:
LIST DetPos = (det pos); # déterminant possessif
LIST DetPos = (det pos); # déterminant possessif


LIST hPro = ("<h.*>"r "[aeiou].*"r); # h-prothesis (?)
LIST hPro = ("<h.*>"r "[aeiou].*"r); # h-prothèse
LIST Len = ("<ph.*>"r "p.*"r); # lenition (?)
LIST Len = ("<ph.*>"r "p.*"r); # lénition


SET DetPosF = DetPos | (f); # déterminant possessif féminin
SET DetPosF = DetPos | (f); # déterminant possessif féminin
Line 47: Line 49:
</pre>
</pre>


Ça devrait être pratiquement direct, puis on écrit les règles qui disent "Choisir le possessif féminin quand le nom qui suit est sujet à h-prothesis (?), et le possessif masculin quand le nom qui suit est sujet à lenition (?)",
Ça devrait être pratiquement direct, puis on écrit les règles qui disent "Choisir le possessif féminin quand le nom qui suit est sujet à h-prothesis (?), et le possessif masculin quand le nom qui suit est sujet à lénition",


<pre>
<pre>
Line 69: Line 71:
La génération des mutations initiales prend place dans deux fichiers, où <math>x</math> est le code de la langue qui est générée (<code>ga</code> pour l'irlandais, <code>gd</code> pour l'écossais gaélique).
La génération des mutations initiales prend place dans deux fichiers, où <math>x</math> est le code de la langue qui est générée (<code>ga</code> pour l'irlandais, <code>gd</code> pour l'écossais gaélique).


* <code>apertium-ga-gd.pre-<math>x</math>.t1x</code> &mdash; Transfer rules which add tags defining the mutation to the beginning of words which should be mutated.
* <code>apertium-ga-gd.pre-<math>x</math>.t1x</code> &mdash; Règles de transfert qui ajoute des balises définissant la mutation au début des mots qui devraient être mutés.
* <code>apertium-ga-gd.muta-<math>x</math>.dix</code> &mdash; A post-generation dictionary which takes the tag and the initial letter of the word and outputs the mutated form.
* <code>apertium-ga-gd.muta-<math>x</math>.dix</code> &mdash; Un dictionnaire post-génération qui prend la balise et la lettre initiale du mot et envoie en sortie la forme mutée.


For example, when translating the phrase "do theach" (your house) from Irish to Scottish Gaelic, the result will be do <u>th</u>aigh (where the initial mutation is marked by an underscore). The output of <code>apertium-transfer</code> will be:
Par exemple, lorsqu'on traduit la phrase "do theach" (votre maison) de l'irlandais à l'écossais gaélique, le résultat sera "do <u>th</u>aigh" ( la mutation initiale est marquée par un underscore). La sortie de <code>apertium-transfer</code> sera :


<pre>
<pre>
Line 78: Line 80:
</pre>
</pre>


This is then passed through <code>apertium-ga-gd.pre-gd</code>, which adds a tag, <code><l1></code> for lenition.
C'est alors passé à <code>apertium-ga-gd.pre-gd</code>, qui ajoute une balise, <code><l1></code> pour lénition.


<pre>
<pre>
Line 84: Line 86:
</pre>
</pre>


Le générateur morphologique sort alors les formes de surface des mots, et ajoute un signal "alarme" à la balise de mutation.
The morphological generator then outputs the surface forms of the words, and appends an "alarm" signal to the mutation tag.


<pre>
<pre>
Line 90: Line 92:
</pre>
</pre>


Finally, the mutation dictionary, <code>apertium-ga-gd.muta-gd.dix</code>, replaces the string <code>~<l1>t</code> with 'th', which is the lenited form of 't'.
Finalement, le dictionnaire de mutation, <code>apertium-ga-gd.muta-gd.dix</code>, remplace la chaîne <code>~<l1>t</code> avec 'th', qui est la forme lénitée de 't'.


<pre>
<pre>
Line 98: Line 100:
;apertium-ga-gd.pre-<math>x</math>.t1x
;apertium-ga-gd.pre-<math>x</math>.t1x


Comme mentionné plus haut, l'entrée de cette étape est :
As mentioned above, the input to this stage is:


<pre>
<pre>
Line 104: Line 106:
</pre>
</pre>


Une règle simplifiée (mais fonctionnant) dans ce fichier pourrait ressembler à quelque-chose comme :
A simplified (although functioning) rule in this file might look something like:


<pre>
<pre>
Line 112: Line 114:
</pattern>
</pattern>
<choose>
<choose>
<when> <!-- When the lemma of the determiner is "do",
<when> <!-- quabd le lemme du déterminant est "do",
apply lenition to the following noun -->
appliquer la lénition au nom qui suit -->
<test>
<test>
<equal>
<equal>
Line 131: Line 133:
</pre>
</pre>


And the output will be,
Et la sortie sera,


<pre>
<pre>
Line 139: Line 141:
;apertium-ga-gd.muta-<math>x</math>.dix
;apertium-ga-gd.muta-<math>x</math>.dix


L'entrée de cette étape est :
The input to this stage is:


<pre>
<pre>
Line 145: Line 147:
</pre>
</pre>


La "règle", ou plutôt l'"entrée" dans le dictionnaire de mutation ressemblera à :
The "rule", or rather "entry" in the mutation dictionary will look like:


<pre>
<pre>
Line 157: Line 159:
</pre>
</pre>


Ici, l'alphabet est défini comme un paradigme qui pour chaque lettre entrée donnée, envoie juste en sortie la lettre inchangée. Donc, ça signifie,
Here, the alphabet is defined as a paradigm which for any given input letter, just outputs the letter unchanged. So this basically says,


:"Quand on a le symbole alarme '~', suivi d'une balise indiquant la lénition suivie d'un 't' et ensuite n'importe quel caractère alphabétique, la sortie est 'th' suivi du prochain caractère".
:"When we have the alarm symbol '~', followed by a tag indicating lenition followed by a 't' and then any alphabetic character, output 'th' followed by the next character"


La sortie de cette étape est une phrase correctement mutée,
The output of this stage is a correctly mutated phrase,


<pre>
<pre>

Latest revision as of 07:18, 8 October 2014

In English

Cette page donne un bref aperçu sur la manière dont les mutations de la consonne initiale sont actuellement analysées, désambiguïsées et générées dans Apertium. Elle utilise comme exemple la paire de langue apertium-ga-gd .

Analyse[edit]

L'analyse est prise en charge par la création de paradigmes avec le mot initial qui remplace simplement les formes non mutées avec les formes mutées. Par exemple pour la consonne initiale 'b', qui peut être lénité comme 'bh' ou éclipsée comme 'mb', on obtient le paradigme de mutation initial suivant :

    <pardef n="initial-b">
      <e><p><l>b</l><r>b</r></p></e>
      <e><p><l>bh</l><r>b</r></p></e>
      <e><p><l>mb</l><r>b</r></p></e>
    </pardef>

Cela peut ensuite être appliqué à un mot, par exemple "bulc" (), comme :

    <e lm="bulc"><par n="initial-b"/><i>u</i><par n="bu/lc__n"/></e>

La mutation initiale est 'b', et le mot prend le paradigme bu/lc__n. Le problème avec cette méthode est que quelquefois ça peut causer une "sur analyse", mais on peut faire attention à cette désambiguïsation, voir plus loin.

Désambiguïsation[edit]

La désambiguïsation des mutations initiales peut se faire en utilisant l'outil de contraintes grammaticales (voir le fichier apertium-ga-gd.ga-gd.rlx). Le tagger apertium n'est pas utile pour ce propos car il ne peut pas regarder les formes de surface des mots, mais seulement les unités lexicales. Un exemple trivial illustratif de la façon dont la contrainte grammaticale peut être utilisée est présenté plus loin. Disons qu'on veut choisir entre un déterminant possessif féminin et un déterminant possessif masculin basé sur le type de mutation présentée par le nom suivant, par exemple dans les deux phrases qui suivent :[1]

  • a pheann, — his pen (son stylo (pour un homme))
  • a haois — her age (son age (pour une femme))

Ici le déterminant, "a", peut être aussi bien masculin que féminin (c'est à dire, "his" ou "her"). Donc, si on a l'entrée suivante pour l'outil constraint grammar :

  ^a/a<det><pos><p3><mf><pl>/a<det><pos><p3><m><sg>/a<det><pos><p3><f><sg>$ ^pheann/peann<n><m><sg><nom>/peann<n><m><pl><gen>$
  ^a/a<det><pos><p3><mf><pl>/a<det><pos><p3><m><sg>/a<det><pos><p3><f><sg>$ ^haois/aois<n><f><sg><nom>$ 

D'abord on définit avec quoi on veut travailler,

LIST DetPos = (det pos);             # déterminant possessif

LIST hPro = ("<h.*>"r "[aeiou].*"r); # h-prothèse
LIST Len = ("<ph.*>"r "p.*"r);       # lénition

SET DetPosF = DetPos | (f);          # déterminant possessif féminin
SET DetPosM = DetPos | (m);          # déterminant possessif masculin

Ça devrait être pratiquement direct, puis on écrit les règles qui disent "Choisir le possessif féminin quand le nom qui suit est sujet à h-prothesis (?), et le possessif masculin quand le nom qui suit est sujet à lénition",

SELECT DetPosF IF (1 hPro);
SELECT DetPosM IF (1 Len);

L'application de cette grammaire donne :

  ^a<det><pos><p3><m><sg>$ ^peann<n><m><sg><nom>$ 
  ^a<det><pos><p3><f><sg>$ ^oíche<n><f><sg><nom>$ 

Le résultat désiré.

Génération[edit]

Aperçu

La génération des mutations initiales prend place dans deux fichiers, où est le code de la langue qui est générée (ga pour l'irlandais, gd pour l'écossais gaélique).

  • apertium-ga-gd.pre-.t1x — Règles de transfert qui ajoute des balises définissant la mutation au début des mots qui devraient être mutés.
  • apertium-ga-gd.muta-.dix — Un dictionnaire post-génération qui prend la balise et la lettre initiale du mot et envoie en sortie la forme mutée.

Par exemple, lorsqu'on traduit la phrase "do theach" (votre maison) de l'irlandais à l'écossais gaélique, le résultat sera "do thaigh" (où la mutation initiale est marquée par un underscore). La sortie de apertium-transfer sera :

  ^do<det><pos><p2><mf><sg>$ ^taigh<n><m><sg><nom>$ 

C'est alors passé à apertium-ga-gd.pre-gd, qui ajoute une balise, <l1> pour lénition.

  ^do<det><pos><p2><mf><sg>$ ^<l1>$^taigh<n><m><sg><nom>$ 

Le générateur morphologique sort alors les formes de surface des mots, et ajoute un signal "alarme" à la balise de mutation.

  do ~<l1>taigh

Finalement, le dictionnaire de mutation, apertium-ga-gd.muta-gd.dix, remplace la chaîne ~<l1>t avec 'th', qui est la forme lénitée de 't'.

  do thaigh
apertium-ga-gd.pre-.t1x

Comme mentionné plus haut, l'entrée de cette étape est :

  ^do<det><pos><p2><mf><sg>$ ^taigh<n><m><sg><nom>$ 

Une règle simplifiée (mais fonctionnant) dans ce fichier pourrait ressembler à quelque-chose comme :

<pattern>
  <pattern-item n="det"/>
  <pattern-item n="nom"/>
</pattern>
<choose> 
  <when> <!-- quabd le lemme du déterminant est "do", 
              appliquer la lénition au nom qui suit -->
    <test>
      <equal>
        <clip pos="1" side="tl" part="lem"/>
        <lit v="do"/>
      </equal>
     </test>
     <out>
      <lu><clip pos="1" side="tl" part="whole"/></lu>
      <b/>
      <lu><lit-tag v="l1"/></lu>    <!-- Lenition -->
      <lu><clip pos="2" side="tl" part="whole"/></lu>
    </out>
  </when>
</choose>

Et la sortie sera,

  ^do<det><pos><p2><mf><sg>$ ^<l1>$^taigh<n><m><sg><nom>$ 
apertium-ga-gd.muta-.dix

L'entrée de cette étape est :

  do ~<l1>taigh

La "règle", ou plutôt l'"entrée" dans le dictionnaire de mutation ressemblera à :

    <e>
      <p>
        <l><a/><s n="l1"/>t</l>
        <r>th</r>
      </p>
      <par n="alphabet"/> 
    </e>

Ici, l'alphabet est défini comme un paradigme qui pour chaque lettre entrée donnée, envoie juste en sortie la lettre inchangée. Donc, ça signifie,

"Quand on a le symbole alarme '~', suivi d'une balise indiquant la lénition suivie d'un 't' et ensuite n'importe quel caractère alphabétique, la sortie est 'th' suivi du prochain caractère".

La sortie de cette étape est une phrase correctement mutée,

  do thaigh

Notes[edit]

  1. Notez que ce n'est pas vraiment pertinent pour passer de l'irlandais à l'écossais gaélique dans la mesure où les formes de surface de chaque langue sont les mêmes