Difference between revisions of "Exemples de règles de transfert"
(→Transférer deux mots en les accordant: correction formulation) |
(→Écriture de la règle de transfert: intro) |
||
Line 247: | Line 247: | ||
==== Écriture de la règle de transfert ==== |
==== Écriture de la règle de transfert ==== |
||
Pour cette première règle, nous partons d'un fichier de suffixe <code>.t1x</code> "vide" ayant la structure décrite [[Exemples de règles de transfert#Structure d'un fichier .t1x|ici]]. |
|||
La section '''def-macros''' étant facultative, comme elle n'est pas utilisée pour les premières règles de transfert décrites dans cette page, nous ne la mettrons pas pour l'instant. |
|||
La section '''def-vars''' est obligatoire. Bien qu'elle ne sera jamais utilisée dans les exemples de cette page, nous nous contenterons d'y mettre un contenu minimal pour que le fichier <code>.t1x</code> puisse être compilé : |
|||
<pre> |
|||
<section-def-vars> |
|||
<def-var n="aucune_variable"/> |
|||
</section-def-vars> |
|||
</pre> |
|||
Les autres sections pourront contenir des informations utiles à notre première règle de transfert. |
|||
===== Section def-cats ===== |
===== Section def-cats ===== |
Revision as of 12:42, 21 February 2013
Cette page est destinée à compléter la page Introduction aux règles de transfert. Les exemples utilisés concernent la paire apertium-eo-fr. Il s'agit d'une paire le langues validée pour le sens de traduction français → espéranto. Par contre, le sens de traduction espéranto → français n'a pas été implémenté par le développeur initial. C'est un autre développeur, totalement débutant pour l'écriture des règles de transfert qui a choisi de le faire. Les exemples fournis concernent les toutes premières règles écrites pour traduire un groupe d'un, deux ou trois mots espéranto en un groupe de deux ou trois mots français.
Cette page ne concerne que l'écriture du fichier de règles destiné à être utilisé par l'outil apertium-transfer dont le suffixe est .t1x
. L'écriture de balises destinée à la fragmentation dans le cadre d'un transfert en 3 étapes n'y est pas abordé.
Contents
- 1 Les différentes étapes d'une traduction avec apertium
- 2 Comment trouver ce qu'on doit faire
- 3 Structure d'un fichier .t1x
- 4 Exemples de règles de transfert
Les différentes étapes d'une traduction avec apertium
Commençons par lister les différentes opérations qui sont exécutées pour une traduction.
Opération | Rôle | Langues concernées |
---|---|---|
Déformatage | Permet de marquer des zones du texte source à ne pas traduire. Par exemple, on ne traduit pas dans une autre langue les balises HTML, mais seulement le texte de la page web. | Les mêmes logiciels sont utilisés pour toutes les paires de langues. C'est le format des données à traduire qui emmènera à utiliser tel ou tel déformateur. |
Analyse | Chaque mot du texte source est décomposé en un lemme suivi du type de mot et de ses attributs (genre, nombre, personne et temps pour un verbe ...). Pour certains mots, plusieurs analyses sont possibles. Dans ce cas, elles sont toutes envoyées en sortie. | Valable pour toutes les langues, elle fait appel au dictionnaire morphologique de la langue source. |
Désambiguïsation | Lorsqu'un mot dispose de plusieurs analyses, cette étape permet de n'en conserver qu'une seule. | Valable pour toutes les langues, elle fait appel à un fichier de suffixe .prob Pour les langues non ambiguës comme l'espéranto, cette étape reste nécessaire pour supprimer la forme de surface de chaque mot analysé (pré-formatage pour l'étape de transfert). |
Pré-transfert | Traitement des multi-mots avant l'étape de transfert. | Toutes langues. Ne nécessite pas de fichier de données particulier. |
Transfert | Transforme les analyses issues de la langue source en leur version traduite dans la langue cible. | Valable pour toutes les paires de langues, il fait appel au dictionnaire bilingue et au fichier de transfert de suffixe .t1x
|
Traitement inter-fragments | Permet des traitements sur un groupe de mots (le sujet, un complément ...) Comme indiqué plus haut, on ne s'occupera pas de cette étape (ni de la suivante). |
Utilisé à priori pour simplifier l'étape de transfert, il nécessite de rajouter quelques balises à l'étape de transfert. Il fait appel à un fichier de suffixe .t2x et éventuellement à d'autres fichiers si on exécute plusieurs passes de ce type.
|
Post-fragmentation | Fin du ou des traitement(s) inter-fragments | Nécessaire si un ou plusieurs traitements inter-fragments ont été exécutés. Elle fait appel à un fichier de suffixe .t3x
|
Génération | Génère la forme de surface des mots de la langue cible à partir de la décomposition en lemme + attributs obtenue suite aux étapes précédentes. | Valable pour toutes les paires de langues, elle fait appel au dictionnaire morphologique de la langue cible. |
Post-génération | Permet des corrections orthographiques entre mots voisins lorsqu'il y a des cas particuliers non traités par la génération. | Utilisé pour beaucoup de langues cibles (dont le français), peut être pas pour toutes. |
Reformatage | Remet les données traduites au format du document source. | Les mêmes logiciels sont utilisés pour toutes les paires de langues. Il existe un reformateur pour chaque déformateur disponible bien que tous les reformateurs fassent un traitement similaire. |
La page Préparation pour utiliser les outils de transfert donne un exemple de la manière dont une phrase espagnole est transformée à chaque étape du traitement pour aboutir finalement à une traduction en anglais.
Comment trouver ce qu'on doit faire
Fondamentalement, l'étape de transfert part d'une analyse désambiguïsée du texte en langue source pour fournir un équivalent dans la langue cible. L'étape de génération effectue alors le traitement inverse de l'analyse. Ça a une conséquence : il faut que les données fournies au générateur correspondent exactement à ce que donnerait une nouvelle analyse du texte traduit dans la langue cible. Sinon, la génération ne sera que partielle avec des # apparaissant au début de certains mots qui seront alors présentés sous la forme de lemmes.
Exemple :
On veut traduire en français les 3 mots espéranto :
la aŭtomata traduko
Après analyse et désambiguïsation, on obtient :
^la<det><def><sp>$ ^aŭtomata<adj><sg><nom>$ ^traduko<n><sg><nom>$
Une étape de transfert lexical (utilisant seulement le dictionnaire bilingue) donnera :
^le<det><def><sp>$ ^automatique<adj><sg><nom>$ ^traduction<n><f><sg><nom>$
Le morceau de phrase que l'on veut obtenir en français est :
la traduction automatique
En analysant ce morceau de phrase, on obtient :
^le<det><def><f><sg>$ ^traduction<n><f><sg>$ ^automatique<adj><mf><sg>$
qui est le texte qu'on devra fournir au générateur pour obtenir la traduction souhaitée.
Il faudra donc dans l'étape de transfert de structure réaliser la transformation suivante :
Origine :
^le<det><def><sp>$ ^automatique<adj><sg><nom>$ ^traduction<n><f><sg><nom>$
Résultat :
^le<det><def><f><sg>$ ^traduction<n><f><sg>$ ^automatique<adj><mf><sg>$
C'est pour cela, qu'on écrit des règles de transferts. Leur but est d'ajouter ou de supprimer certaines balises dans les descriptions de mots, et éventuellement de changer l'ordre de certains mots.
Structure d'un fichier .t1x
Le fichier contenant les règles de transfert a comme suffixe .t1x
. Ce fichier est composé de plusieurs sections obligatoires et peut contenir d'autres sections facultatives. Chacune des sections devra contenir au moins un élément.
<?xml version="1.0" encoding="UTF-8"?> <transfer> <section-def-cats> .......... </section-def-cats> <section-def-attrs> .......... </section-def-attrs> <section-def-vars> .......... </section-def-vars> <section-def-macros> .......... </section-def-macros> <section-rules> .......... </section-rules> </transfer>
Section def-cats
La section def-cats est obligatoire. Elle permet de déclarer des catégories de mots que l'on va rechercher pour appliquer une règle de transfert particulière. Il peut s'agir de mots simples (un article (déterminant), un nom, un adjectif, un verbe, ...) ou de choses un peu plus compliquées comme un nom possédant dans sa description la balise <nom> (nominatif) signifiant qu'il fait partie du sujet de la phrase.
Cette section contient un ou plusieurs éléments qui ont la structure suivante :
<def-cat n="nom_de_ce_qu'on_veut_décrire"> <cat-item tags="sa_description"/> .... (il peut y avoir une ou plusieurs balises <cat-item .../>) </def-cat>
Section def-attrs
La section def-attrs est obligatoire. Elle permet de regrouper par fonctionnalités des noms d'attributs de mots définis dans la section sdefs d'un dictionnaire morphologique. Par exemple, on regroupera dans cette section toutes les balises correspondant au :
- genre d'un mot
- nombre d'un mot (singulier, pluriel, ...)
- personne d'un verbe
- temps d'un verbe
- ...
Cette section contient un ou plusieurs éléments qui ont la structure suivante :
<def-attr n="nom_d'une_liste_d'attributs_jouant_un_rôle_commun"> <attr-item tags="un_attribut_de_la_section_sdef_d'un_dictionnaire"/> .... (on a plusieurs balises <attr-item .../> autant que de valeurs possibles pour l'attribut) </def-attr>
Section def-vars
La section def-vars est obligatoire et doit comporter au moins un élément respectant la syntaxe <def-var n="..."/>
. Il s'agit de lister les variables globales utilisées dans les règles de transferts. Toutefois, pour les règles décrites dans cette page, nous n'aurons besoin d'aucune de ces variables.
Section def-macros
La section def-macros est facultative. Néanmoins, elle sera très utile pour écrire des fichiers de transfert moins longs en évitant de dupliquer à l'identique (ou presque) un même traitement dans plusieurs règles de transfert.
Cette section contient un ou plusieurs éléments qui ont la structure suivante :
<def-macro n="nom_de_la_macro" npar="nombre_de_paramètres"> .... (le code de la macro) </def-macro>
Section rules
Enfin, La section rules est obligatoire. C'est la plus longue du fichier de transfert et celle qui justifie son existence. Elle permet en effet de définir les traitements à effectuer pour traduire des groupes de mots (ou quelquefois des mots isolés, comme on le verra).
Cette section contient un ou plusieurs éléments qui ont la structure suivante :
<rule> <pattern> <pattern-item n="nom_défini_comme_def-cat_correspondant_au_premier_mot_à_traiter"/> .... (autant de balises <pattern-item ..../> que de mots qu'on veut traiter ensemble) </pattern> <action> .... (description de la règle de transfert) </action> </rule>
Exemples de règles de transfert
Transférer deux mots en les accordant
On va commencer par traduire en français l'article espéranto "la" suivi d'un nom commun.
Recherche des modifications à apporter
En espéranto, l'article défini "la" est invariant, alors qu'en français, il possède 3 formes : "le", "la", "les" selon le genre et le nombre du nom auquel il s'accorde.
Pour le nom commun, il a deux formes en espéranto selon qu'il fasse partie du sujet ou du complément d'objet dans la phrase. En français, il s'écrit pareil dans les deux cas.
Exemples :
Espéranto | Analyse espéranto | Français | Analyse français |
---|---|---|---|
la tago la tagon |
^la<det><def><sp>$ ^tago<n><sg><nom>$ ^la<det><def><sp>$ ^tago<n><sg><acc>$ |
le jour | ^le<det><def><m><sg>$ ^jour<n><m><sg>$ |
la nokto la nokton |
^la<det><def><sp>$ ^nokto<n><sg><nom>$ ^la<det><def><sp>$ ^nokto<n><sg><acc>$ |
la nuit | ^le<det><def><f><sg>$ ^nuit<n><f><sg>$ |
la tagoj la tagojn |
^la<det><def><sp>$ ^tago<n><pl><nom>$ ^la<det><def><sp>$ ^tago<n><pl><acc>$ |
les jours | ^le<det><def><mf><pl>$ ^jour<n><m><pl>$ |
la noktoj la noktojn |
^la<det><def><sp>$ ^nokto<n><pl><nom>$ ^la<det><def><sp>$ ^nokto<n><pl><acc>$ |
les nuits | ^le<det><def><mf><pl>$ ^nuit<n><f><pl>$ |
Examinons ce que donne la traduction lexicale de l'analyse espéranto et comparons-la à l'analyse en français que l'on veut soumettre au générateur :
Analyse espéranto | Analyse espéranto traduite en français | L'analyse en français que l'on veut obtenir |
---|---|---|
^la<det><def><sp>$ ^tago<n><sg><nom>$ ^la<det><def><sp>$ ^tago<n><sg><acc>$ |
^le<det><def><sp>$ ^jour<n><m><sg><nom>$ ^le<det><def><sp>$ ^jour<n><m><sg><acc>$ |
^le<det><def><m><sg>$ ^jour<n><m><sg>$ |
^la<det><def><sp>$ ^nokto<n><sg><nom>$ ^la<det><def><sp>$ ^nokto<n><sg><acc>$ |
^le<det><def><sp>$ ^nuit<n><f><sg><nom>$ ^le<det><def><sp>$ ^nuit<n><f><sg><acc>$ |
^le<det><def><f><sg>$ ^nuit<n><f><sg>$ |
^la<det><def><sp>$ ^tago<n><pl><nom>$ ^la<det><def><sp>$ ^tago<n><pl><acc>$ |
^le<det><def><sp>$ ^jour<n><m><pl><nom>$ ^le<det><def><sp>$ ^jour<n><m><pl><acc>$ |
^le<det><def><m><pl>$ ^jour<n><m><pl>$ |
^la<det><def><sp>$ ^nokto<n><pl><nom>$ ^la<det><def><sp>$ ^nokto<n><pl><acc>$ |
^le<det><def><sp>$ ^nuit<n><f><sg><nom>$ ^le<det><def><sp>$ ^nuit<n><f><pl><acc>$ |
^le<det><def><f><pl>$ ^nuit<n><f><pl>$ |
On constate que :
- pour l'article, la traduction lexicale donne systématiquement ^le<det><def><sp>$ . Il faudra remplacer la dernière balise <sp> (singulier ou pluriel) par les balises du nom commun indiquant son genre et son nombre.
- pour le nom commun, la traduction lexicale a trouvé (dans le dictionnaire bilingue) le genre du nom traduit en français. Pour savoir si ce nom est au singulier ou au pluriel, elle a conservé l'attribut nombre de la langue d'origine. Par contre, on a aussi conservé les attributs <nom> ou <acc> dont on n'a pas besoin en français et qui empêcheraient la génération du mot. Il faudra donc les supprimer dans la règle de transfert.
Écriture de la règle de transfert
Pour cette première règle, nous partons d'un fichier de suffixe .t1x
"vide" ayant la structure décrite ici.
La section def-macros étant facultative, comme elle n'est pas utilisée pour les premières règles de transfert décrites dans cette page, nous ne la mettrons pas pour l'instant.
La section def-vars est obligatoire. Bien qu'elle ne sera jamais utilisée dans les exemples de cette page, nous nous contenterons d'y mettre un contenu minimal pour que le fichier .t1x
puisse être compilé :
<section-def-vars> <def-var n="aucune_variable"/> </section-def-vars>
Les autres sections pourront contenir des informations utiles à notre première règle de transfert.
Section def-cats
Dans cette section, on va définir 2 catégories de mots :
- les déterminants qu'on appellera det et qu'on identifiera dans les analyses par la balise <det> suivie de n'importe quoi.
- les noms communs qu'on appellera nom_commun et qu'on identifiera dans les analyses par la balise <n> suivie de n'importe quoi.
La section def-cats s'écrira comme ceci :
<section-def-cats> <def-cat n="det"> <cat-item tags="det.*"/> </def-cat> <def-cat n="nom_commun"> <cat-item tags="n.*"/> </def-cat> </section-def-cats>
- les noms des catégories de mots sont dans l'attribut n des balises <def-cat n="...">
- les description de ce qu'on doit trouver dans l'analyse pour reconnaître la catégorie de mot sont dans l'attribut tags des balises <cat-item tags="..."/>
Section def-attrs
On va à présent définir les attributs possibles pour les différentes balises des mots
<section-def-attrs> <def-attr n="type_mot"> <attr-item tags="n"/> <attr-item tags="det"/> </def-attr> <def-attr n="genre"> <attr-item tags="m"/> <attr-item tags="f"/> <attr-item tags="mf"/> </def-attr> <def-attr n="nombre"> <attr-item tags="sg"/> <attr-item tags="pl"/> <attr-item tags="sp"/> </def-attr> </section-def-attrs>
- dans l'attribut n des balises <def-attr n="...">, on donne un nom aux différentes caractéristiques des mots que l'on veut traiter
- pour chacune de ces caractéristiques, les balises <attr-item tags="..."/> indiquent les différentes valeurs possibles de cette caractéristique.
Dans le cas de la règle que l'on veut écrire, on a défini 3 caractéristiques :
- type_mot (peut être pas obligatoire, mais il n'y a pas de solution alternative documentée). Pour l'instant, les types disponibles sont :
- n (nom commun)
- det (déterminant)
- genre avec comme valeurs possibles
- m (masculin)
- f (féminin)
- mf (masculin ou féminin)
- nombre avec comme valeurs possibles
- sg (singulier)
- pl (pluriel)
- sp (singulier ou pluriel)
Section rules
Une section rules contenant uniquement la règle qu'on veut écrire contiendrait :
<section-rules> <rule> <pattern> <pattern-item n="det"/> <pattern-item n="nom_commun"/> </pattern> <action> <out> <lu> <clip pos="1" side="tl" part="lem"/> <clip pos="1" side="tl" part="type_mot"/> <lit-tag v="def"/> <clip pos="2" side="tl" part="genre"/> <clip pos="2" side="tl" part="nombre"/> </lu> <b /> <lu> <clip pos="2" side="tl" part="lem"/> <clip pos="2" side="tl" part="type_mot"/> <clip pos="2" side="tl" part="genre"/> <clip pos="2" side="tl" part="nombre"/> </lu> </out> </action> </rule> </section-rules>
La règle est composée de 2 sections :
<pattern> <pattern-item n="det"/> <pattern-item n="nom_commun"/> </pattern>
Dans ce morceau, on précise quelles sont les catégories de mots successives que l'on doit trouver dans l'analyse du texte source pour que la règle puisse s'appliquer. Dans le cas présent, il faudra trouver un déterminant, suivi d'un nom commun. Les attributs des balises <pattern-item n="..."/> doivent tous avoir été définis dans la section def-cats, sinon la règle ne pourra jamais être appliquée.
La partie la plus intéressante de la règle est à partir de la balise <action>. Elle a la structure suivante :
<action> <out> <lu> ... (génération de l'unité lexicale pour le premier mot) </lu> <b /> <lu> ... (génération de l'unité lexicale pour le deuxième mot) </lu> </out> </action>
Dans cette règle, on ne fait que générer des données que l'on envoie en sortie. Le contenu de la balise <action> se limite donc à de la génération de texte qui est indiquée par la balise <out>.
On devra générer l'analyse de 2 mots dans la langue cible. Chaque analyse de mot constitue une unité lexicale (balise <lu>) qui en sortie sera symbolisée par les caractères ^...$ où la description de l'unité lexicale remplacera les pointillés.
Entre les deux unités lexicales, on laissera un espace (balise ) sinon, les deux mots générés se toucheraient.
Examinons l'écriture de chacune des unités lexicales :
La première balise <clip pos="1" side="tl" part="lem"/> possède élément par élément la signification suivante :
Morceau | Signification |
---|---|
clip | C'est un mot-clé qui peut être traduit par "récupère" |
pos="1" | C'est le numéro du pattern-item dans la liste <pattern>...</pattern> de la règle. Ici, pos="1" correspond à l'analyse du déterminant |
side="tl" | On récupère l'information dans la langue cible. Pour accéder à la langue source, on mettrait side="sl" |
part="lem" | C'est un mot clé réservé correspondant au lemme. |
La troisième balise <lit-tag v="def"/> possède élément par élément la signification suivante :
Morceau | Signification |
---|---|
lit-tag | C'est un mot-clé qui peut être traduit par "génère une balise" |
v="def" | On précise ici le contenu de la balise. Dans le cas présent, on générera <def>. |
L'ensemble des 5 instructions nécessaires pour générer l'analyse du déterminant possède la signification suivante :
Instruction | Signification |
---|---|
<clip pos="1" side="tl" part="lem"/> | Récupérer le lemme du premier mot du pattern dans la langue cible. Ce sera toujours l'article français "le". |
<clip pos="1" side="tl" part="type_mot"/> | Récupérer le type du premier mot du pattern dans la langue cible. Ce sera det. |
<lit-tag v="def"/> | Générer une balise def, c'est à dire le texte <def> qui permet de préciser que l'article est défini. |
<clip pos="2" side="tl" part="genre"/> | Récupérer le genre du deuxième mot du pattern de la langue cible, c'est à dire le genre du nom commun. |
<clip pos="2" side="tl" part="nombre"/> | Récupérer le nombre du deuxième mot du pattern de la langue cible, c'est à dire le nombre du nom commun. |
L'ensemble de ces 5 éléments récupérés constitue l'unité lexicale <lu>...</lu> qui sera envoyée en sortie grâce à la balise <out>...</out>
Pour la deuxième unité lexicale correspondant à la traduction du nom commun, on peut remarquer qu'on a dans chaque ligne : pos="2" side="tl" ce qui signifie qu'on recopiera simplement certaines balises du nom commun (2ème mot de la règle).
Explication détaillée des 4 instructions :
Instruction | Signification |
---|---|
<clip pos="2" side="tl" part="lem"/> | Récupérer le lemme du deuxième mot du pattern dans la langue cible (le nom commun en français). |
<clip pos="2" side="tl" part="type_mot"/> | Récupérer le type du deuxième mot. Ce sera n. |
<clip pos="2" side="tl" part="genre"/> | Récupérer le genre du nom commun. |
<clip pos="2" side="tl" part="nombre"/> | Récupérer le nombre du nom commun. |
Remarque
Si on génère le résultat obtenu en sortie du transfert, on n'obtient pas tout à fait ce qu'il faudrait :
Analyse Français | Résultat génération | Ce qu'il faudrait |
---|---|---|
^le<det><def><m><sg>$ ^jour<n><m><sg>$ | ~le jour | le jour |
^le<det><def><f><sg>$ ^nuit<n><f><sg>$ | ~la nuit | la nuit |
^le<det><def><mf><pl>$ ^jour<n><m><pl>$ | ~les jours | les jours |
^le<det><def><mf><pl>$ ^nuit<n><f><pl>$ | ~les nuits | les nuits |
^le<det><def><m><sg>$ ^arbre<n><m><sg>$ | ~le arbre | l'arbre |
^le<det><def><f><sg>$ ^histoire<n><f><sg>$ | ~la histoire | l'histoire |
^le<det><def><m><pl>$ ^arbre<n><m><pl>$ | ~les arbres | les arbres |
^le<det><def><f><pl>$ ^histoire<n><f><pl>$ | ~les histoires | les histoires |
Le remplacement de l'article le/la par l' en fonction de la première lettre du mot suivant n'est pas fait au moment de la génération mais juste après dans l'étape de post-génération qui s'occupe des mots marqués par une ~ . En dehors de cette remarque, la post-génération ne sera pas traitée dans cette page.
Rajouter un mot dans la langue cible
L'espéranto ne possède pas d'article indéfini. Pour exprimer un, une, des, on se contente de ne pas mettre l'article défini la devant la nom commun. Un nom commun isolé écrit en espéranto devra donc être précédé de l'article indéfini un, une ou des adéquat, si on le traduit en français.
Notre deuxième règle va faire cette transformation.
Examinons de que donne le transfert lexical d'un mot en espéranto et comparons-le à ce qu'on voudrait obtenir en français.
Examinons ce que donne la traduction lexicale de l'analyse espéranto et comparons-la à l'analyse en français que l'on veut soumettre au générateur :
Analyse espéranto | Analyse espéranto traduite en français | L'analyse en français que l'on veut obtenir |
---|---|---|
^tago<n><sg><nom>$ ^tago<n><sg><acc>$ |
^jour<n><m><sg><nom>$ ^jour<n><m><sg><acc>$ |
^un<det><ind><m><sg>$ ^jour<n><m><sg>$ |
^nokto<n><sg><nom>$ ^nokto<n><sg><acc>$ |
^nuit<n><f><sg><nom>$ ^nuit<n><f><sg><acc>$ |
^un<det><ind><f><sg>$ ^nuit<n><f><sg>$ |
^tago<n><pl><nom>$ ^tago<n><pl><acc>$ |
^jour<n><m><pl><nom>$ ^jour<n><m><pl><acc>$ |
^un<det><ind><m><pl>$ ^jour<n><m><pl>$ |
^nokto<n><pl><nom>$ ^nokto<n><pl><acc>$ |
^nuit<n><f><sg><nom>$ ^nuit<n><f><pl><acc>$ |
^un<det><ind><f><pl>$ ^nuit<n><f><pl>$ |
Par rapport à la règle précédente, au lieu de générer ^le<det><def><genre><nombre>$ on va générer ^un<det><ind><genre><nombre>$. Tout le reste est sans changement.
Pour écrire la nouvelle règle, on dispose déjà de tout ce qu'il faut dans les sections def-cats et def-attrs. Il suffira donc de rajouter la nouvelle règle dans la section rules qui va devenir :
<section-rules> <rule> <pattern> <pattern-item n="det"/> <pattern-item n="nom_commun"/> </pattern> <action> ... (voir le contenu au paragraphe précédent) </action> </rule> <rule> <pattern> <pattern-item n="nom_commun"/> </pattern> <action> <out> <lu> <lit v="un"/> <lit-tag v="det.ind"/> <clip pos="1" side="tl" part="genre"/> <clip pos="1" side="tl" part="nombre"/> </lu> <b /> <lu> <clip pos="1" side="tl" part="lem"/> <clip pos="1" side="tl" part="type_mot"/> <clip pos="1" side="tl" part="genre"/> <clip pos="1" side="tl" part="nombre"/> </lu> </out> </action> </rule>
Dans cette nouvelle règle, on trouve pour la première fois l'instruction lit qui va générer une chaîne de caractères, par opposition à lit-tag qui englobe la chaîne générée de < > pour qu'elle devienne une balise.
Comme dans le texte de la langue source à transférer, il n'y a qu'un mot (le nom commun mentionné dans le pattern), on accède à ses attributs par pos="1" alors que c'était pos="2" dans la première règle.
Les 4 instructions nécessaires pour générer l'analyse de l'article indéfini possèdent la signification suivante :
Instruction | Signification |
---|---|
<lit v="un"> | Générer le lemme "un". |
<lit-tag v="det.ind"/> | Générer une balise det suivie d'une balise ind, c'est à dire le texte <det><ind> qui permet de préciser qu'on génère un article indéfini. |
<clip pos="1" side="tl" part="genre"/> | Récupérer le genre du nom commun. |
<clip pos="1" side="tl" part="nombre"/> | Récupérer le nombre du nom commun. |
Les instructions pour générer la traduction en français du nom commun sont les mêmes que pour la règle précédent, à part que maintenant pos="1".
Intervertir deux mots
Nous allons voir à présent une règle pour changer l'ordre de deux mots lors d'une traduction. En espéranto, il est d'usage de mettre l'adjectif avant le nom (même si ce n'est pas une règle stricte, le traducteur espagnol -> espéranto conserve d'ailleurs l'ordre des mots. En français, la plupart des adjectifs (mais pas tous !) se placent avant le nom qu'ils qualifient.
Même si la solution complète serait plus compliquée, nous allons voir une règle qui a partir d'une forme "la" + adjectif + nom en espéranto, fournit une traduction du type "le/la/les" + nom + adjectif en français.
@@@@@@@ (Sera complété plus tard). @@@@@@@
Changer des attributs en fonction de conditions
A présent, nous allons examiner une règle permettant de traduire un pronom personnel suivi d'un verbe en appliquant les règles de conjugaison.
Recherche des modifications à apporter
- En espéranto, le verbe est invariant par rapport au pronom personnel qui le précède
- En français, le verbe s'accorde avec la personne et le nombre du pronom personnel (mais pas son genre)
De plus, certains pronoms personnel du français n'ont pas d'équivalent spécifique en espéranto qui sur ce point est comme l'anglais :
- tu (2ème personne du singulier) et vous (2ème personne du pluriel) en français sont tous deux traduits par vi en espéranto.
- ils et elles (les formes masculines et féminines de la 3ème personne du pluriel) sont traduites par ili en espéranto.
pour passer de l'espéranto au français, on fera donc des choix :
- vi → vous 2ème personne du pluriel ou forme de politesse pour s'adresser à une seule personne
- ili → ils on choisit le masculin pour la 3ème personne du pluriel en français.
De même, l'espéranto ne dispose que d'un temps pour le passé là où le français en a trois et dans une analyse, les dictionnaires espéranto et français n'utilisent pas la même abréviation pour le présent de l'indicatif. Il faudra donc changer tout ça lors de la traduction.
Nous allons voir ce que tout celà donne pour le verbe kanti → chanter conjugué au présent de l'indicatif.
Espéranto | Analyse espéranto | Analyse espéranto traduite | L'analyse qu'on voudrait | Français |
---|---|---|---|---|
mi kantas | ^prpers<prn><subj><p1><mf><sg>$ ^kanti<vbtr_ntr><pres>$ |
^prpers<prn><p1><mf><sg>$ ^chanter<vblex><pres>$ |
^prpers<prn><p1><mf><sg>$ ^chanter<vblex><pri><p1><sg>$ |
je chante |
vi kantas | ^prpers<prn><subj><p2><mf><sp>$ ^kanti<vbtr_ntr><pres>$ |
^prpers<prn><p2><mf><sp>$ ^chanter<vblex><pres>$ |
^prpers<prn><p2><mf><pl>$ ^chanter<vblex><pri><p2><pl>$ |
tu chantes → vous chantez |
li kantas | ^prpers<prn><subj><p3><m><sg>$ ^kanti<vbtr_ntr><pres>$ |
^prpers<prn><p3><m><sg>$ ^chanter<vblex><pres>$ |
^prpers<prn><p3><m><sg>$ ^chanter<vblex><pri><p3><sg>$ |
il chante |
ŝi kantas | ^prpers<prn><subj><p3><f><sg>$ ^kanti<vbtr_ntr><pres>$ |
^prpers<prn><p3><f><sg>$ ^chanter<vblex><pres>$ |
^prpers<prn><p3><f><sg>$ ^chanter<vblex><pri><p3><sg>$ |
elle chante |
ni kantas | ^prpers<prn><subj><p1><mf><pl>$ ^kanti<vbtr_ntr><pres>$ |
^prpers<prn><p1><mf><pl>$ ^chanter<vblex><pres>$ |
^prpers<prn><p1><mf><pl>$ ^chanter<vblex><pri><p1><pl>$ |
nous chantons |
vi kantas | ^prpers<prn><subj><p2><mf><sp>$ ^kanti<vbtr_ntr><pres>$ |
^prpers<prn><p2><mf><sp>$ ^chanter<vblex><pres>$ |
^prpers<prn><p2><mf><pl>$ ^chanter<vblex><pri><p2><pl>$ |
vous chantez |
ili kantas | ^prpers<prn><subj><p3><mf><pl>$ ^kanti<vbtr_ntr><pres>$ |
^prpers<prn><p3><mf><pl>$ ^chanter<vblex><pres>$ |
^prpers<prn><p3><m><pl>$ ^chanter<vblex><pri><p3><pl>$ |
ils chantent (elles chantent) |
Écriture de la règle de transfert
Rajouts dans la section def-cats
Dans cette section, nous allons rajouter une catégorie pour les pronoms et une catégorie pour les verbes :
<def-cat n="prn"> <cat-item tags="prn.*"/> </def-cat> <def-cat n="verbe"> <cat-item tags="vbser.*"/> <cat-item tags="vblex.*"/> <cat-item tags="vbtr.*"/> <cat-item tags="vbntr.*"/> <cat-item tags="vbtr_ntr.*"/> </def-cat>
Rajouts dans la section def-attrs
En ce qui concerne les verbes, différents mots clés sont utilisés en espéranto, alors qu'en français, presque tous les verbes sont classés vblex.
Dans les types de mots, on rajoute les verbes (plusieurs possibilités) et les pronoms :
<def-attr n="type_mot"> .......... (ce qu'il y avait avant) <attr-item tags="prn"/> <attr-item tags="vblex"/> <attr-item tags="vbmod"/> <attr-item tags="vbser"/> <attr-item tags="vbhaver"/> </def-attr>
On rajoute aussi que 2 catégories personne et temps pour la conjugaison des verbes:
<def-attr n="personne"> <attr-item tags="p1"/> <attr-item tags="p2"/> <attr-item tags="p3"/> </def-attr> <def-attr n="temps"> <attr-item tags="pres"/> <attr-item tags="past"/> <attr-item tags="pri"/> <attr-item tags="pii"/> <attr-item tags="fti"/> </def-attr>
Avant d'écrire la section rules, il y a des transformations nécessaires sur les temps des verbes et sur le genre et le nombre des pronoms.
Transformation du temps
Pour cet exemple, on se limitera aux temps de l'indicatif.
En espéranto, il y a 3 temps de l'indicatif :
- le passé : past
- le présent : pres
- le futur : fti
En français, il y a 6 temps courants de l'indicatif :
- l'imparfait :pii
- le passé simple : ifi
- le passé composé qu'il faudrait fabriquer avec le verbe avoir + le participe passé.
- le plus que parfait (idem)
- le présent : pri
- le futur : fti
Pour les verbes au futur, l'attribut fti peut être conservé sans changement
Pour les verbes au présent, il faudra remplacer l'attribut pres de l'espéranto par pri.
Pour les verbes au passé, le passé composé serait pas mal pout une traduction, mais moins facile à générer. On va pour cet exemple remplacer l'attribut past de l'espéranto par pii.
Sous forme algorithmique, cela donne les conditions suivantes :
SI temps = "pres" ALORS temps <- "pri" SINON SI temps = "past" ALORS temps <- "pii" FIN SI
Transformation des attributs du pronom
Pour le pronom, on fera les changements suivants :
SI personne = "p2" ALORS nombre <- "pl" SINON SI (personne = "p3" ET nombre = "pl" ALORS genre <- "m" FIN SI
Section rules
La nouvelle règle a le contenu suivant :
<rule> <pattern> <pattern-item n="prn"/> <pattern-item n="verbe"/> </pattern> <action> <choose> <when> <test> <equal> <clip pos="2" side="sl" part="temps"/> <lit-tag v="pres"/> </equal> </test> <let> <clip pos="2" side="tl" part="temps"/> <lit-tag v="pri"/> </let> </when> <when> <test> <equal> <clip pos="2" side="sl" part="temps"/> <lit-tag v="past"/> </equal> </test> <let> <clip pos="2" side="tl" part="temps"/> <lit-tag v="pii"/> </let> </when> </choose> <choose> <!-- cas particuliers de transferts des pronoms --> <when> <!-- 2ème personne toujours au pluriel : vi -> vous --> <test> <equal> <clip pos="1" side="sl" part="personne"/> <lit-tag v="p2"/> </equal> </test> <let> <clip pos="1" side="tl" part="nombre"/> <lit-tag v="pl"/> </let> </when> <when> <!-- 3ème personne du pluriel toujours au masculin : ili -> ils --> <test> <and> <equal> <clip pos="1" side="sl" part="personne"/> <lit-tag v="p3"/> </equal> <equal> <clip pos="1" side="sl" part="nombre"/> <lit-tag v="pl"/> </equal> </and> </test> <let> <clip pos="1" side="tl" part="genre"/> <lit-tag v="m"/> </let> </when> </choose> <out> <lu> <clip pos="1" side="tl" part="lem"/> <clip pos="1" side="tl" part="type_mot"/> <clip pos="1" side="tl" part="personne"/> <clip pos="1" side="tl" part="genre"/> <clip pos="1" side="tl" part="nombre"/> </lu> <b /> <lu> <clip pos="2" side="tl" part="lem"/> <clip pos="2" side="tl" part="type_mot"/> <clip pos="2" side="tl" part="temps"/> <clip pos="1" side="tl" part="personne"/> <clip pos="1" side="tl" part="nombre"/> </lu> </out> </action> </rule>