View source for Introduction aux règles de transfert

[[A long introduction to transfer rules|In English]]

Écrire des règles de transfert semble délicat. Les gens comprennent généralement les concepts de base, mais se battent avec le formalisme. Nous pensons que le formalisme n'est pas si mauvais. Et comparé à plusieurs autres formalismes,<ref>ex: Matxin, OpenLogos, ...</ref> il est assez direct. Peut-être qu'une des raisons qui fait lutter les gens est que nous mélangeons la programmation déclarative et procédurale. Peut-être. 

== Quelques formalités ==

Avant de commencer, il est important de donner quelques idées sur ce qu'on ''ne peut pas'' faire, avant d'expliquer ce que l'on peut. Si vous vous mettez à apprendre des règles en vous attendant à autre chose, alors ce sera probablement confus.

* Il n'y a pas de règle récursive. Les règles rencontrent des modèles de longueur fixe. Il n'y a pas d'optionalité au niveau des mots. Il n'y a pas de manière de dire «un ou plusieurs», c'est juste «un».
* Les règles d'Apertium sont très liées au [[format du flux Apertium]]. Si vous ne comprenez pas le format du flux, il sera encore plus difficile de comprendre les règles. 
* Les règles contiennent à la fois des parties ''déclaratives'' et ''procédurales''. Vous ne pouvez pas vous attendre juste à dire ''ce que'' vous voulez ou ''comment'' vous voulez le faire. Vous avez besoin de faire les deux -- mais à différent endroits (mais c'est assez intuitif). 
* Les modèles sont mis en concordance seulement du côté de la langue-source. Pas du côté de la cible.
* Le transfert de structure n'a pas accès aux informations du générateur morphologique de la langue cible. Cela signifie que si le transfert a besoin d'informations sur les formes disponibles d'un mot particulier, ex. : s'il n'existe qu'au singulier, ou seulement au pluriel, alors cette information doit aller dans le [[dictionnaire bilingue]].

== Transfert lexical et transfert de structure ==

Voir aussi : [[Dictionnaire bilingue]]

À ce point il vaut mieux ne pas confondre les rôles du [[lexical transfer|transfert lexical]] et du transfert de structure. Il y a une zone commune entre les deux, mais il y a aussi de grosses parties qui ne se recouvrent pas.

* Le '''transfert lexical''' (le fichier <code>lang1-lang2.dix</code>) : 
** Ne donne —presque toujours— que des traductions entre mots, pas entre balises.
** Peut ajouter ou changer des balises, sur la base de chaque lemme.
** Ne réordonne pas les mots.
** Peut être utilisé pour donner un tuyau au transfert de structure pour porter attention aux caractéristiques manquantes, ou aux caractéristiques qui ne peuvent pas être décidées hors d'un contexte. Par exemple :
*** les balises {{tag|ND}} et {{tag|GD}} qui signifient "Hé, quand je traduis ce mot je ne sais pas quel devrait être le genre ou le nombre -- transfert de structure ! j'ai besoin de ton aide pour trouver", ou
*** la balise {{tag|sint}}<ref>Cette balise est utilisée pour ''synthétique'', par opposition à ''analytique''. En anglais, les adjectifs ''synthétiques'' s'infléchissent pour les comparaisons avec ''-er'' et ''-est'', lorsque les adjectifs ''analytiques'' ont des formes comparatives et superlatives avec ''more'' et ''most''.</ref> qui dit "Oh ! si vous écrivez une règle de transfert pour les adjectifs, et qu'elle rencontre cet adjectif alors vous avez besoin de penser à la manière dont vous allez supporter les formes comparatives et superlatives".

* Le '''transfert de structure''' (le fichier <code>lang1-lang2.t*x</code>) : 
** Donne rarement des traductions entre mots simples.
** Souvent ajoute ou modifier les balises sur la base de (groupes de lemmes) par-catégorie.
** Peut changer l'ordre des mots.

Une règle générale est que si la règle s'applique à tous les mots d'une catégorie, elle devra probablement être traitée lors le transfert de structure, et que si elle s'applique à juste une partie de ces mots, alors peut-être qu'elle aura besoin d'être traitée lors le transfert lexical.

La sortie du transfert lexical ressemble à ceci :

<pre>

 ^slword<sometag>/tlword<sometag>$  ^slword1<sometag><blah>/tlword3<sometag><foo>$ ^slword3<sometag><blah>/tlword2<sometag><GD>$ 

</pre>

Alors que la sortie du transfert de structure ressemblerait à ceci :

<pre>

 ^tlword<sometag>$ ^tlword3<sometag><foo>$ ^tlword2<sometag><GD>$ 

</pre>

Ceci dit, quand vous êtes dans la première étape du transfert de structure vous avez accès à la fois aux côtés source et cible de la traduction. Après la première étape du transfert de structure, vous avez seulement accès au côté cible.

=== Comment le transfert lexical est traité ===

Soit l'unité lexicale suivante en entrée : <code>^slword<tag1><tag2><tag3>$</code>

Si le dictionnaire bilingue contient le code suivant :

<pre>
    <e><p><l>slword<s n="tag1"/><s n="tag2"/></l><r>tlword<s n="tag1"/></r></p></e>
</pre>

Alors on obtiendra sortie suivante du module de transfert lexical :

<pre>
  ^slword<tag1><tag2><tag3>/tlword<tag1><tag3>$
</pre>

Notez que la forme lexicale de la langue cible est produite en remplaçant un préfixe du côté source (ex : <code><s n="tag1"/><s n="tag2"/></code>) par un préfixe du côté cible (ex : <code><s n="tag1"/></code>). Ces préfixes viennent du dictionnaire bilingue. Chacune des balises de la langue source non "rencontrée" par le préfixe dans le dictionnaire bilingue est copiée sur la sortie du côté de la langue cible.

== Quelques préliminaires ==

* Pattern:

* Action:

== Aperçu d'un fichier de transfert ==

Il est difficile de donner un aperçu étape-par-étape sur ce à quoi ressemble un fichier de transfert parce-qu'il y a beaucoup de parties obligatoires qui ont besoin d'être même dans le fichier le plus basique. Mais, il est important d'avoir une vue générale avant d'entrer dans les détails. Voici un exemple dans lequel je ne vais délibérément utiliser des noms linguistiques pour les différentes parties, pour essayer d'éviter les suppositions.

''Note du traducteur : J'ai rajouté des lignes blanches pour mieux voir les différentes sections.''

<pre>
<?xml version="1.0" encoding="utf-8"?>
<transfer>
  <section-def-cats>
    <def-cat n="quelques_catégories_de_mots">
      <cat-item tags="mytag.*"/>
    </def-cat>
  </section-def-cats>
  
  <section-def-attrs>
    <def-attr n="quelques_caractéristiques_d_un_mot">
      <attr-item tags="macaractéristique"/>
      <attr-item tags="mon_autre_caractéristique"/>
    </def-attr>
  </section-def-attrs>
  
  <section-def-vars>
    <def-var n="blank"/>
  </section-def-vars>  
  
  <section-rules>
    <rule>
      <pattern>
        <pattern-item n="quelques_catégories_de_mots"/>
      </pattern>
      <action>
        <let><clip pos="1" side="tl" part="quelques_caractéristiques_d_un_mot"/><lit-tag v="mon_autre_caractéristique"/></let>
        <out>
          <lu><clip pos="1" side="tl" part="whole"/></lu>
        </out>
      </action>
    </rule>
  </section-rules>
</transfer>
</pre>

Je vais essayer de donner une relation balise par balise... les balises {{tag|transfer}} et {{tag|/transfer}} ne font rien. Elles encapsulent juste le reste des sections.

=== Comment les règles sont appliquées ===

== Exemples pratiques ==

=== Niveau 1 transfert de structure : bases ===

<center>
{|class=wikitable
|-
| '''Entrée:''' || ''Otišla si'' ||  ''tiho'' || ''i'' || ''bez'' || ''pozdrava''
|-
| '''Sortie:''' || ''You left''  || ''quietly'' || ''and'' || ''without'' || ''a word''
|-
|}
</center>

==== Transfert lexical ====

Pour le propos de cet exemple, on va utiliser des sorties de transfert lexical "pré-préparées". Dans un vrai système, ce serait la sortie de l'exécution de <code>lt-proc -b</code> sur le dictionnaire bilingue du système. Donc, nous passons la phrase à travers notre étape de transfert lexical "imaginaire", et nous arrivons avec la sortie qui suit :

<pre>
^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$ 
^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$ 
^tiho<adv>/quietly<adv>$ 
^i<cnjcoo>/and<cnjcoo>$ 
^bez<pr>/without<pr>$ 
^pozdrav<n><mi><sg><gen>/word<n><sg><gen>$
</pre>

Mettez la sortie dans un fichier appelé <code>example1.txt</code> on en aura besoin plus tard.

À ce point si vous ne l'avez pas déjà fait, ça vaut la peine d'essayer un ''modèle zéro'', c'est à dire sans règle de transfert, essayez de passer la sortie à travers le fichier de transfert qu'on a fait auparavant (voir [[Introduction aux règles de transfert#Aperçu d'un fichier de transfert|ici]] -- sauvez le dans un fichier appelé <code>rules.t1x</code>).

D'abord, on a besoin de le compiler :

<pre>
$ apertium-preprocess-transfer rules.t1x rules.bin
</pre>

Ensuite on peut passer par le transfert :

<pre>
$ cat /tmp/example1.txt | apertium-transfer -b rules.t1x rules.bin
^leave<vblex><lp><f><sg>$
^be<vbser><clt><pres><p2><sg>$ 
^quietly<adv>$ 
^and<cnjcoo>$ 
^without<pr>$ 
^word<n><sg><gen>$
</pre>

Alors essayez de la passer au générateur d'anglais (qui peut être compilé depuis n'importe quel fichier <code>en.dix</code>) : <ref>Vous pouvez utiliser n'importe quel générateur apertium pour l'anglais, on en trouve un dans <code>apertium/incubator/apertium-sh-en/</code>, et il peut être compilé en donnant la commande <code>sh compile.sh</code> dans le catalogue (??) <code>apertium-sh-en</code>. Pour plus d'information, voir [[Créer une nouvelle paire de langues]].</ref>

<pre>
$ cat /tmp/example1.txt | apertium-transfer -b rules.t1x rules.bin | lt-proc -g sh-en.autogen.bin
#leave 
#be 
quietly 
and 
without 
#word
</pre>

C'est évidemment inadéquat, mais ne vous en faites pas, on va utiliser le module de transfert de structure pour le rendre adéquat !

==== Réflexion ====

Réfléchissons sur les changements nécessaires afin de convertir ceci dans une forme adéquate pour la génération de la langue cible. NB: Si on veut changer l'information, c'est une procédure, si on veut envoyer en sortie ou non, c'est une déclaration.

;Procédures:

# Si la balise de langue source est {{tag|lp}} (signification ?), changer la balise de langue cible en {{tag|past}} (passé)

;Déclarations:

# Envoyer en sortie un pronom sujet qui prend l'information sur sa personne et son nombre du verbe principal.
# Envoyer en sortie le verbe principal avec les informations sur la catégorie et le temps (mais pas le genre et le nombre, la langue cible étant l'anglais).
# Ne pas envoyer en sortie le verbe auxiliaire (''biti'', "be").
# Envoyer en sortie les noms avec la catégorie et le nombre (mais pas le cas).
# Les mots devraient être envoyés en sortie encapsulés entre <code>^</code> et <code>$</code>
# Les balises devraient être envoyés en sortie encapsulés entre <code>&lt;</code> et <code>&gt;</code>

;Ordre de travail

Donc, dans quel ordre faisons-nous ça ? Hé bien, ça n'a pas grande importance -- un développeur expérimenté le fera probablement en deux étapes, mais dans un but pédagogique, on va découper ça en cinq étapes :

* D'abord, on va écrire une règle qui fait concorder la construction lp et auxiliaire, et envoie en sortie seulement le verbe principal (déclarations: 2, 3, 5)
** Définir les catégories de "lp" et "auxiliary"
* Deuxièmement, on va éditer cette règle pour changer la balise de langue source tag de {{tag|lp}} à {{tag|past}} (procédure: 1)
** Définir l'attribut de "tense" (temps)
* Troisièmement, on va éditer la même règle pour ne pas envoyer en sortie le genre et le nombre (déclaration: 2)
** Définir l'attribut de "verb_type"
* Quatrièmement, on va éditer la même règle pour envoyer en sortie un sujet pronom avant le verbe (déclarations: 1, 5, 6)
** Définir les attributs de "person" et "number" (personne et nombre)
* Cinquièmement, on va écrire une nouvelle règle qui rencontre la construction du nom et envoie en sortie seulement "category" et "number" (déclarations: 4, 5)
** Définir la catégorie de "noun"
** Définir l'attribut de "noun_type"

;Antisèche

Voici à quoi les entrées et sorties de chacun des changements ci-dessus ressembleront. 

<center>
{|class=wikitable
|-
! Change !! Input                   !!  Output
|-
|   1   || <code>^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$<br/>^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$</code>  || <code>^leave<vblex><lp><f><sg>$</code> 
|-
|   2   || <code>^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$<br/>^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$</code>   || <code>^leave<vblex><past><f><sg>$</code> 
|-
|   3   || <code>^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$<br/>^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$</code>  || <code>^leave<vblex><past>$</code> 
|-
|   4   || <code>^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$<br/>^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$</code>  || <code>^prpers<prn><subj><p2><mf><sg>$<br/>^leave<vblex><past>$</code> 
|-
|   5   ||<code> ^pozdrav<n><mi><sg><gen>/word<n><sg><gen>$</code>    || <code>^word<n><sg>$</code>  
|-
|}
</center>

==== Implémentation ====

===== Étape 1 =====

On travaille sur la sortie (c'est à dire sur les deux premières lignes de ''example1.txt''):

<pre>
^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$
^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$ 
</pre>

1. Fabriquer nos catégories dans ''rules.t1x''. Remplacer le pseudo def-cat avec :

<pre>
  <section-def-cats>
    <def-cat n="lp">
      <cat-item tags="vblex.*.*.lp.*"/>
    </def-cat>
    <def-cat n="biti-clt">
      <cat-item tags="vbser.clt.pres.*"/>
    </def-cat>
  </section-def-cats>
</pre>

Pourquoi avons-nous besoin de <code>.*.*</code> ? -- À cause de la manière dont le système de mise en concordance dans les catégories travaille. Au milieu des séquences de balises, une <code>*</code> est comptée comme une simple balise. À la fin, elle est comptée comme n'importe quelle séquence de balises. Donc, on a {{tag|vblex}} suivi par n'importe quelle balise, suivi par n'importe quelle balise, suivi par {{tag|lp}} suivi par n'importe quelle séquence de balises. Les personnes familières avec les expressions régulières devraient noter tout spécialement que <code>.*</code> ne signifie pas "n'importe quoi", et que "*" ne correspond pas à "n'importe quel nombre de fois" (sauf à la fin d'un modèle). <code>*</code> est plus comme un wildcard (??). 

2. Éditer la règle d'exemple et remplacer le "pattern".

<pre>
      <pattern>
          <pattern-item n="lp"/>
          <pattern-item n="biti-clt"/>
      </pattern>
</pre>

3. Sauver et compiler le fichier des règles.

<pre>
$ apertium-preprocess-transfer rules.t1x rules.bin
</pre>

Maintenant testez le :

<pre>

$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin

^leave<vblex><lp><f><sg>$ 
^quietly<adv>$ 
^and<cnjcoo>$ 
^without<pr>$ 
^word<n><sg><gen>$

</pre>

Super !

===== Étape 2 =====

1. Ajoutez un {{tag|def-attr}} donnant les valeurs possibles de la caractéristique <code>tense</code> (temps).

Donc, maintenant on s'est débarrassé du verbe "to be" (être), on veut changer la balise pour le temps de {{tag|lp}} à {{tag|past}}. Ça impliquera d'utiliser une déclaration, disant explicitement au transfert ce qu'on veut changer. Mais avant ça, on a besoin de définir les valeurs possibles que notre caractéristique peut prendre. On le fait avec un {{tag|def-attr}}. Appelons-le <code>tense</code>. Ajoutez ce qui suit à la {{tag|section-def-attrs}}.

<pre>
    <def-attr n="tense">
        <attr-item tags="lp"/>
        <attr-item tags="past"/>
    </def-attr>
</pre>

Cela dit que les mots peuvent avoir un attribut <code>tense</code>, qui peut être une des deux valeurs, soit {{tag|lp}} soit {{tag|past}}. Comme exercice pour le lecteur, vous pouvez essayer d'ajouter d'autres valeurs possibles.

2. Écrire une déclaration qui change le temps de la langue cible (<code>side="tl"</code>) 

Cette déclaration devrait aller immédiatement après la balise {{tag|action}} et avant la balise {{tag|out}} .

<pre>
      <action>
        <let><clip pos="1" side="tl" part="tense"/><lit-tag v="past"/></let>
        <out>
</pre>

(Note: Ça va ''toujours'' changer la balise de la langue cible en {{tag|past}}, même si l'entrée n'est pas {{tag|lp}}. C'est assez bon pour notre exemple actuel, mais pour une description sur la façon dont les déclarations conditionnelles fonctionnent, restez à l'écoute !)

Maintenant testez le :

<pre>
$ apertium-preprocess-transfer rules.t1x rules.bin

$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin
^leave<vblex><past><f><sg>$ 
^quietly<adv>$ 
^and<cnjcoo>$ 
^without<pr>$ 
^word<n><sg><gen>$
</pre>

===== Étape 3 =====

Ainsi on a envoyé en sortie la totalité de l'unité lexicale de la langue cible. Le lecteur se rappellera que la forme lexicale de la langue cible est produite en passant la sortie du tagueur de partie-de-discours de la langue source à travers le module de transfert lexical, et en remplaçant un préfixe du code source avec un préfixe du coté cible. Chaque balise de langue source non identifiée par son préfixe dans le dictionnaire bilingue est copiée telle quelle sur la sortie du coté de la langue cible.

C'est pourquoi nous avons :

<pre>
^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$ 
</pre>

Notre entrée de la langue source est <code>otići<vblex><perf><iv><lp><f><sg></code>, notre dictionnaire bilingue mentionne <code>otići<vblex><perf><iv> → leave<vblex></code> donc il nous reste les balises {{tag|f><sg}} du coté de la langue cible. Ces balises ne sont pas nécessaires pour la génération de l'anglais, donc on a besoin de déclarer qu'elles ne devraient pas être envoyées en sortie.

1. Définir les caractéristiques que l'on veut envoyer en sortie.

Nous avons déjà défini la caractéristique (<code>def-attr</code>) <code>tense</code>, la seule balise restante qu'on a besoin d'envoyer en sortie est le type de verbe. Donc, faites un nouveau <code>def-attr</code> pour le type de verbe. Dans Apertium habituellement, ils sont préfixés avec <code>a_</code> qui signifie "attribut", donc il n'y a pas de confusion avec les autres utilisations de "verb".

<pre>
    <def-attr n="a_verb">
      <attr-item tags="vblex"/>
      <attr-item tags="vbser"/>
    </def-attr>
</pre>

Note: La raison pour laquelle on a deux balises ici, est que dans beaucoup de paires de langues, le verbe "to be" (dans ce cas, ''biti'', mais aussi ''ser'', ''être'' etc...) est balisé différemment des autres verbes à cause de son comportement morphologique et syntaxique.

2. Déclarer quelles caractéristiques on veut envoyer en sortie.

Donc, maintenant on a obtenu nos deux caractéristiques définies, changeons notre déclaration {{tag|out}} :

Là où on avait auparavant :

<pre>
      <lu><clip pos="1" side="tl" part="whole"/></lu>
</pre>

Le remplacer par :

<pre>
      <lu>
            <clip pos="1" side="tl" part="lem"/>
            <clip pos="1" side="tl" part="a_verb"/>
            <clip pos="1" side="tl" part="tense"/>
      </lu>
</pre>

On connaît les deux secondes caractéristiques, comme on les a juste rajoutées. La caractéristique "lem" est une caractéristique pré-définie qui correspond au "lemme". Il y en a d'autres, si vous vous rappelez que "whole" correspond à toutes les unités lexicales, et "tags" correspond à toutes les balises. 

Maintenant testez le :

<pre>
$ apertium-preprocess-transfer rules.t1x rules.bin

$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin
^leave<vblex><past>$ 
^quietly<adv>$ 
^and<cnjcoo>$ 
^without<pr>$ 
^word<n><sg><gen>$

</pre>

Waou ! Ce qui vient de se passer est que nous avons par magie détruit les deux balises non voulues {{tag|f}} et {{tag|sg}} en ''ne spécifiant pas qu'on les voulait''. La suppression de balises n'est ainsi pas implémentée comme telle <code>tag → 0</code>, mais en ne déclarant pas ces balises.

Maintenant on devrait avoir une forme lexicale pour "leave" qu'on peut générer... let's give it a go (???) :

<pre>
$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin | lt-proc -g sh-en.autogen.bin
left 
quietly 
and 
without 
#word
</pre>

On en est arrivé là, maintenant allons à l'étape suivante...

===== Étape 4 =====

Pour récapituler, notre entrée est :

<pre>
^otići<vblex><perf><iv><lp><f><sg>/leave<vblex><lp><f><sg>$
^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$
</pre>

Et notre sortie actuelle est :

<pre>
^leave<vblex><past>$
</pre>

Ce dont nous avons besoin est de prendre l'information du verbe (maintenant non affiché) ''biti'' "to be = être" et de l'utiliser pour envoyer en sortie un pronom personnel avant le verbe. Rappelez-vous, que lorsqu'on n'envoie pas en sortie quelque-chose, on ne le ''supprime'' pas, il est toujours là dans l'entrée, on choisit juste de ne pas l'envoyer sur la sortie. 

La chaîne qu'on veut en sortie ressemble à ceci :

<pre>
^prpers<prn><subj><p2><mf><sg>$
</pre>

1. Envoyer en sortie un squelette de pronom.

Donc, on a besoin de prendre les informations personne et nombre du verbe "to be" (être), et le reste nécessaire pour le déclarer juste en sortie. Commençons par envoyer en sortie la chaîne <code>^prpers<prn><subj>$</code> avant le verbe.

<pre>
      <lu>
            <lit v="prpers"/>
            <lit-tag v="prn.subj"/>
      </lu>
      <b/>
</pre>

La sortie {{tag|lu}} un <code>^</code> et le {{tag|/lu}} envoient en sortie un <code>$</code>. La balise {{tag|lit}} envoie en sortie un chaîne littéral, et le {{tag|lit-tag}} envoie en sortie une séquence de balises qui commence par un <code>&lt;</code>, se termine par <code>&gt;</code> et où chaque <code>.</code> est remplacé par <code>&gt;&lt;</code>. Le {{tag|b/}} envoie en sortie un simple caractère d'espace ' ' . 

2. Définition des caractéristiques pour la personne et le nombre.

La prochaine étape est de déclarer ces caractéristiques depuis le verbe à envoyer en sortie. Pour faire ça, on a besoin de nouveau de définir quelques caractéristiques et leur valeurs possibles.

<pre>
    <def-attr n="person">
        <attr-item tags="p1"/>
        <attr-item tags="p2"/>
        <attr-item tags="p3"/>
    </def-attr>
    <def-attr n="number">
        <attr-item tags="sg"/>
        <attr-item tags="pl"/>
    </def-attr>
</pre>

On revient à notre squelette de pronom et on ajoute les caractéristiques manquantes :

<pre>
      <lu>
            <lit v="prpers"/>
            <lit-tag v="prn.subj"/>
            <clip pos="2" side="sl" part="person"/>
            <lit-tag v="mf"/>
            <clip pos="2" side="sl" part="number"/>
      </lu>
      <b/>
</pre>

Il y a deux choses importantes qu'il est utile de noter ici, la première est que nous "découpons" (copier une partie de chaîne qui concorde avec un modèle) depuis la position 2, qui est le verbe "to be" (être).

Pour être plus clair, l'expression <code><clip pos="2" side="sl" part="person"/></code> fait une copie de la partie de l'unité lexicale en position 2, du coté de la langue source, qui concorde avec un des modèles défini dans le {{tag|def-attr}} pour "person" (qui peut être aussi bien {{tag|p1}}, {{tag|p2}} ou {{tag|p3}}). Si nous regardons la sortie du transfert lexical pour la position "2" ça deviendra plus clair :

<pre>
^biti<vbser><clt><pres><p2><sg>/be<vbser><clt><pres><p2><sg>$
 |                     |__|   | |                           |
 |                   personne | |                           |
 |____________________________| |___________________________|
          coté="source"                  coté="cible"
</pre>

Si on essayait de découper depuis la position 1, on n'obtiendrait pas de résultat pour l'attribut "person" parce que le verbe en position 1 ne contient aucune balise qui concorde avec les balises de <code>def-attr</code> pour <code>person</code>. Le deuxième est qu'on a envoyé en sortie le genre comme balise littérale. C'est parce que bien que notre premier verbe nous donne le genre, il nous donne juste {{tag|f}}, et l'anglais n'exprime pas de genre dans le pronom à la 2ème personne.

Maintenant testez le :

<pre>
$ apertium-preprocess-transfer rules.t1x rules.bin

$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin 
^prpers<prn><subj><p2><mf><sg>$ ^leave<vblex><past>$ 
^quietly<adv>$ 
^and<cnjcoo>$ 
^without<pr>$ 
^word<n><sg><gen>$
</pre>

Et maintenant avec le générateur :

<pre>
$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin | lt-proc -g  sh-en.autogen.bin 
you left 
quietly 
and 
without 
#word
</pre>

===== Étape 5 =====

Donc, la dernière chose restant à faire est de ne pas envoyer en sortie la balise génitif du nom. On va avoir à écrire entièrement une nouvelle règle pour faire concorder les noms. 

1. Définir une catégorie pour les noms

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

2. Faire une nouvelle règle qui fait concorder les noms comme défini dans les catégories précédentes.

Pour commencer on va juste envoyer en sortie la <code>totalité</code> de l'unité lexicale.

<pre>
<rule>
  <pattern>
    <pattern-item n="noun"/>
  </pattern>
  <action>
    <out>
      <lu><clip pos="1" side="tl" part="whole"/></lu>
    </out>
  </action>
</rule>
</pre>

3. Définir une nouvelle catégorie pour les types de noms

<pre>
    <def-attr n="a_noun">
      <attr-item tags="n"/>
      <attr-item tags="np"/>
    </def-attr>
</pre>

4. Ajuster la règle pour envoyer en sortie seulement la nom, le type et le nombre

Rappelez vous que nous avons auparavant défini le {{tag|def-attr}} pour "number".

<pre>

    <out>
      <lu>
        <clip pos="1" side="tl" part="lem"/>
        <clip pos="1" side="tl" part="a_noun"/>
        <clip pos="1" side="tl" part="number"/>
      </lu>
    </out>

</pre>

Maintenant recompilez, et testez :

<pre>
$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin 
^prpers<prn><subj><p2><mf><sg>$ ^leave<vblex><past>$ 
^quietly<adv>$ 
^and<cnjcoo>$ 
^without<pr>$ 
^word<n><sg>$

$ cat example1.txt | apertium-transfer -b rules.t1x rules.bin  | lt-proc -g sh-en.autogen.bin
you left
quietly
and
without
word
</pre>

Succès !

===== Étape 6 =====

L'étape 6 est laissée comme exercice pour le lecteur. Changez la règle des noms (noun) pour envoyer en sortie un article indéfini avant le nom. Vous pouvez le faire en suivant les instructions pour ajouter le pronom. La chaîne que vous avez besoin d'envoyer en sortie est <code>^a<det><ind><sg>$</code>. 

Ne vous en faites pas si vous obtenez un <code>~a</code> sur la sortie, c'est attendu, le <code>~</code> est utilisé pour la [[postgeneration]].

=== Niveau 1 transfert de structure : expressions conditionnelles ===

=== Niveau 3 transfert de structure ===

''Resorni ministar je navlačio ljude, kaže sejte biljku zelenu i čudo će da bude''

''The minister of agriculture tricks the people, he says plant the green herb and there will be a miracle''

==== Transfert lexical ====

<pre>
^Resorni ministar<n><ma><sg><nom>/Minister# of agrculture<n><sg><nom>$ 
^biti<vbser><clt><pres><p3><sg>/be<vbser><pres><p3><sg>$ 
^*navlačio/trick$ 
^čovjek<n><ma><pl><acc>/person<n><pl><acc>$
^,<cm>/,<cm>$ 
^kazati<vblex><perf><tv><pres><p3><sg>/say<vblex><pres><p3><sg>$ 
^*sejte/plant$ 
^biljka<n><f><sg><acc>/herb<n><sg><acc>$ 
^zelen<adj><pst><ma><sg><dat><ind>/green<adj><sint><pst><ma><sg><dat><ind>$ 
^i<cnjcoo>/and<cnjcoo>$ 
^čudo<n><nt><sg><nom>/miracle<n><sg><nom>$ 
^htjeti<vbmod><clt><futI><p3><sg>/will<vaux><futI><p3><sg>$ 
^da<cnjsub>/$ 
^biti<vbser><futII><pres><p3><sg>/be<vbser><futII><pres><p3><sg>$
</pre>

== Notes ==

<references/>

== Voir aussi ==

* http://wiki.apertium.eu/index.php/Session_5:_Structural_transfer_basics (en anglais)

[[Category:Documentation]]
[[Category:Documentation en français]]