Apertium
Apertium est un logiciel libre de traduction automatique initialement créé pour traduire entre elles les différents dialectes parlés dans chacune des régions d'Espagne. Par exemple, pour faire des traductions entre la catalan et le valencien. Si on se limitait à traduire l'espagnol en espagnol (fut-il d'une autre région), ça ne nous servirait pas à grand chose ici. Mais en réalité, Apertium a été conçu pour traduire toutes les langues proches entre elles. On pourra donc l'utiliser pour faire des traductions entre :
- le français et le suisse
- le français et le belge (une fois)
- l'essonnien de la cité des Tarterets avec le neuf-troisien de Clichy-sous-bois ou le Villiers-le-Belien (appelé aussi beauvillésien en langage snob).
Par contre, à l'origine, on n'aurait pas pu faire des traductions entre le français et le québécois à cause des plus de 5000 km de distance. Toutefois, depuis sa première version, Apertium a été perfectionné pour traduire entre elles des langues plus éloignées.
En plus, ce sont les mêmes programmes qui servent à traduire toutes les langues. Donc, pour pouvoir faire des traductions entre 2 langues non encore supportées, il n'y a pas besoin de savoir programmer. Il faut juste écrire quelques fichiers de données. Aussi, la dÉencyclopédie va t'apprendre à développer ta propre paire de langues pour faire de la traduction automatique.
Les dictionnaires
Avant de traduire du texte, il te faudra écrire des dictionnaires pour que ton outil de traduction puisse reconnaître les mots avec toutes leurs variantes orthographiques. Apertium utilise deux types de dictionnaires.
Les dictionnaires morphologiques
Pour commencer, nous allons écrire un dictionnaire morphologique appelé aussi monodix (en gaulois). Ce type de dictionnaire permet de retrouver toutes les variantes orthographiques des différents mots avec une description.
Commençons par les noms. Prenons un nom masculin au hasard : le mot bit (une donnée binaire en [[informatique])). On peut l'écrire de deux manières :
- bit:bit<n><m><sg> (bit, c'est le mot bit (on s'en doutait !) qui est un nom au masculin singulier)
- bits:bit<n><m><pl> (bits, c'est encore le mot bit qui est un nom au masculin pluriel)
En réalité, dans le dictionnaire, on ne l'écrira pas comme ça. Le dictionnaire doit être au format XML. On écrira donc :
<e><p><l>bit</l> <r>bit<s n="n"/><s n="m"/><s n="sg"/></r></p></e> <e><p><l>bits</l> <r>bit<s n="n"/><s n="m"/><s n="pl"/></r></p></e>
Et pour tous les mots du dictionnaire, on pourra faire pareil.
Cependant, beaucoup de noms au masculin s'écrivent comme ils s'écrivent, c'est à dire en ne rajoutant rien à la façon de les écrire lorsqu'ils sont au masculin singulier, alors qu'il faut rajouter un s pour les mettre au pluriel. Et pour exprimer tout ce qui a été écrit dans la phrase précédente, on va écrire un paradigme.
Nous allons faire un paradigme pour le mot bit Ça tombe bien, le mot est court !
On va mettre entre <l> et </l> ce qu'on rajoute et entre <r> et </r> la description du mot.
Le paradigme s'écrira ainsi :
<pardef n="bit__n" <e> <p><l></l> <r><s n="n"/><s n="m"/><s n="sg"/></r></p></e> <e> <p><l>s</l> <r><s n="n"/><s n="m"/><s n="pl"/></r></p></e> </pardef>
Donc pour résumer :
- bit__n est le nom qu'on donne à ce paradigme
- ne rien rajouter au mot => nom au masculin singulier
- rajouter un s au mot => nom au masculin pluriel
Ensuite, il y a plein de noms masculins dans la langue française qui fonctionneront comme bit. On va pouvoir utiliser notre paradigme pour les mettre dans le dictionnaire :
<e lm="bit"> <i>bit</i> <par n="bit__n"/></e> <e lm="octet"> <i>octet</i> <par n="bit__n"/></e> <e lm="ordinateur"> <i>ordinateur</i> <par n="bit__n"/></e> <e lm="programme"> <i>programme</i> <par n="bit__n"/></e>
De la même manière, il y a des noms au féminin auxquels on rajoute s pour passer au pluriel. On va donc créer un paradigme pour ces noms et ensuite, utiliser le paradigme.
Prenons donc un nom féminin au hasard qui respecte cette règle. Par exemple le mot bite. Une bite, c'est plus ou moins long, ça dépend, mais pour en faire un paradigme, ça n'a pas d'importance.
Le paradigme est semblable au précédent, on remplacera juste les m par des f qui veut dire féminin :
<pardef n="bite__n" <e> <p><l></l> <r><s n="n"/><s n="f"/><s n="sg"/></r></p></e> <e> <p><l>s</l> <r><s n="n"/><s n="f"/><s n="pl"/></r></p></e> </pardef>
Et ensuite, on va pouvoir définir plein de mots au féminin qui passent au pluriel comme le mot bite :
<e lm="bite"> <i>bite</i> <par n="bite__n"/></e> <e lm="éjaculation"> <i>éjaculation</i> <par n="bite__n"/></e> <e lm="vessie"> <i>vessie</i> <par n="bite__n"/></e> <e lm="fuite"> <i>fuite</i> <par n="bite__n"/></e> <e lm="urine"> <i>urine</i> <par n="bite__n"/></e> <e lm="flaque"> <i>flaque</i> <par n="bite__n"/></e> <e lm="inondation"> <i>inondation</i> <par n="bite__n"/></e>
Certains mots ont déjà un s au singulier et n'en ont pas deux qui se suivent au pluriel. Il s'écrivent pareil dans les deux cas. On va faire un paradigme un peu différent en utilisant sp dans la description pour "singulier ou pluriel" :
<pardef n="pénis__n" <e> <p><l></l> <r><s n="n"/><s n="m"/><s n="sp"/></r></p></e> </pardef>
Et ensuite :
<e lm="pénis"> <i>pénis</i> <par n="pénis__n"/></e> <e lm="clitoris"> <i>clitoris</i> <par n="pénis__n"/></e> <e lm="frottis"> <i>frottis</i> <par n="pénis__n"/></e>
Il y a aussi des mots qu'on peut trouver au masculin et au féminin. Par exemple mec (masculin) qui s'écrit meuf au féminin. En effet, tout le monde sait qu'une meuf, ce n'est rien d'autre qu'un mec avec des nichons et un clitoris à la place du pénis.
On va donc écrire un paradigme pour les quatre combinaisons possibles :
<pardef n="me/c__n" <e> <p><l>c</l> <r><s n="n"/><s n="m"/><s n="sg"/></r></p></e> <e> <p><l>cs</l> <r><s n="n"/><s n="m"/><s n="pl"/></r></p></e> <e> <p><l>uf</l> <r><s n="n"/><s n="f"/><s n="sg"/></r></p></e> <e> <p><l>ufs</l> <r><s n="n"/><s n="f"/><s n="pl"/></r></p></e> </pardef>
Ici, deux particularités :
- Tout d'abord, le nom du paradigme : On l'a écrit me/c__n au lieu de mec__n. En effet, la partie du mot qu'on retrouve dans les 4 cas est me
- ensuite, il faut déjà rajouter un c pour obtenir le lemme mec qui correspond au mot au masculin singulier. On voit ce rajout dans : <l>c</l>
La définition du mot dans le dictionnaire tient compte de cette particularité :
<e lm="mec"> <i>me</i> <par n="me/c__n"/></e>
où la partie invariante du mot est entre <i> et </i>
On pourrait faire de même avec des adjectifs ("adj") mais intéressons nous plutôt aux verbes.
Encore une fois, on va commencer par choisir un verbe au hasard, par exemple éjaculer, qui, conjugué aux différents temps et aux différentes personnes peut donner toutes les orthographes suivantes :
éjacula éjaculai éjaculaient éjaculais éjaculait éjaculant éjaculas éjaculasse éjaculassent éjaculasses éjaculassiez éjaculassions éjacule éjaculent éjaculer éjaculera éjaculerai éjaculeraient éjaculerais éjaculerait éjaculeras éjaculerez éjaculeriez éjaculerions éjaculerons éjaculeront éjacules éjaculez éjaculiez éjaculions éjaculons éjaculâmes éjaculât éjaculâtes éjaculèrent éjaculé éjaculée éjaculées éjaculés
Pour chacune des ces orthographes, il faudra bien sûr une description (voire plusieurs si une orthographe apparaît dans plusieurs cas). On commencera donc par écrire un paradigme.
Ensuite, on pourra définir plein de verbes terminés à l'infinitif par er qui se conjuguent comme éjaculer :
<e lm="commencer"> <i>commenc</i> <par n="éjacul/er__vblex"/></e> <e lm="masturber"> <i>masturb</i> <par n="éjacul/er__vblex"/></e> <e lm="frotter"> <i>frott</i> <par n="éjacul/er__vblex"/></e> <e lm="sucer"> <i>suc</i> <par n="éjacul/er__vblex"/></e> <e lm="secouer"> <i>secou</i> <par n="éjacul/er__vblex"/></e> <e lm="éjaculer"> <i>éjacul</i> <par n="éjacul/er__vblex"/></e> <e lm="continuer"> <i>continu</i> <par n="éjacul/er__vblex"/></e> <e lm="branler"> <i>branl</i> <par n="éjacul/er__vblex"/></e> <e lm="gicler"> <i>gicl</i> <par n="éjacul/er__vblex"/></e> <e lm="asperger"> <i>asperg</i> <par n="éjacul/er__vblex"/></e> <e lm="manger"> <i>mang</i> <par n="éjacul/er__vblex"/></e> <e lm="recommencer"> <i>recommenc</i> <par n="éjacul/er__vblex"/></e>
En réalité, si nous regardons ce que donne la première personne du pluriel au présent, on obtiendrait commencons, sucons, mangons, aspergons, etc... en conjuguant ces verbes comme éjaculer. Pour résoudre ce problème, il faudra 2 autres paradigmes pour supporter les variantes orthographiques.
Les dictionnaires bilingues
Pour traduire des texte, il faudra écrire aussi un dictionnaire bilingue appelé bidix (en gaulois). En gros, un dictionnaire bilingue, ça permet d'établir la correspondance entre les mots des deux langues. Mais plutôt que de se contenter d'une liste de deux colonnes de mots parfaitement lisibles, il faut englober ça dans des balises XML afin que l'intelligence artificielle du traducteur puisse arriver à comprendre.
En plus des mots dans les deux langues, ce dictionnaire indique la catégorie du mot (nom, verbe, adjectif etc...) et quelquefois d'autres informations comme le genre s'il change d'une langue à l'autre.
Par exemple un dictionnaire français-anglais pourra contenir les lignes suivantes :
<e><p><l>moi<s n="prn"/></l> <r>me<s n="prn"/></r></p></e> <e><p><l>je<s n="prn"/></l> <r>I<s n="prn"/></r></p></e> <e><p><l>avoir<s n="vbhaver"/></l> <r>have<s n="vbhaver"/></r></p></e> <e><p><l>un<s n="det"/><s n="ind"/></l> <r>a<s n="det"/><s n="ind"/></r></p></e> <e><p><l>gros<s n="adj"/></l> <r>big<s n="adj"/></r></p></e> <e><p><l>bite<s n="n"/><s n="f"/></l> <r>penis<s n="n"/></r></p></e>
Plusieurs mots qui ont des significations voisines pourront être traduits de la même façon. Mais il faudra que la traduction soit unique dans l'autre sens. Par exemple si on traduit du français en anglais :
- bite -> penis
- pénis -> penis
Reste à pouvoir traduire le mot anglaispenis en français. Il faudra choisir l'un des deux mots ci-dessus. Pour cela, on le précise en écrivant :
- <e r="LR"> lorsqu'on peut traduire de la langue de gauche à la langue de droite
- <e r="RL"> lorsqu'on peut traduire de la langue de droite à la langue de gauche
Par exemple si penis (anglais) doit être traduit par pénis :
<e r="LR"><p><l>bite<s n="n"/><s n="f"/></l> <r>penis<s n="n"/></r></p></e> <e><p><l>pénis<s n="n"/><s n="m"/></l> <r>penis<s n="n"/></r></p></e>
Par contre, Apertium n'a pas prévu la possibilité d'indiquer les mots qui ne peuvent se traduire ni de la langue de gauche à celle de droite, ni de la langue de droite à celle de gauche. Mais comme le rajout de tels groupes de mot risquerait de ne pas servir souvent dans une traduction, nous te proposons de ne pas en mettre.
L'utilisation des attributs <e r="LR"> et <e r="RL"> peut aussi permettre d'accepter des variantes orthographiques fréquentes, mais pas très correctes :
<e><p><l>écrire<s n="vblex"/></l> <r>write<s n="vblex"/></r></p></e> <e r="LR"><p><l>ekrire<s n="vblex"/></l> <r>write<s n="vblex"/></r></p></e>
Cependant, il peut être intéressant de prévoir 2 versions alternatives dans une langue. Pour cela, on peut utiliser l'attribut alt comme ci-dessous pour pouvoir demander la traduction d'un texte anglais, soit en français, soit en kévinien :
<e alt="fr"><p><l>écrire<s n="vblex"/></l> <r>write<s n="vblex"/></r></p></e> <e alt="kevin"><p><l>ekrire<s n="vblex"/></l> <r>write<s n="vblex"/></r></p></e>
Voila, tu connais la syntaxe XML pour écrire les dictionnaires. Pour les monodix, il y en a déjà dans les langues les plus courantes, comme le français, l'anglais...
Ton premier travail pour développer une nouvelle paire de langues sera donc certainement d'écrire un gros bidix
Je reprends. Ton premier travail pour développer une nouvelle paire de langues sera donc certainement d'écrire un dictionnaire bilingue de grande taille, environ 30000 mots pour que le traducteur dispose d'un vocabulaire suffisant pour faire des traductions complètes.
L'analyse
Maintenant que tu disposes des dictionnaires, les différents programmes d'Apertium peuvent les utiliser pour faire une traduction. Le premier programme est l'analyseur qui va transformer les différents mots de ton texte en une série de lemmes et attributs. Les analyseurs fonctionnent selon le principe des transducteurs à états finis.
Comme ce serait compliqué à expliquer, voici un dessin d'un transducteur à états finis servant d'analyseur de bière anglaise :
Examinons maintenant le fonctionnement d'un autre analyseur de bière :
Comme vous pouvez le constater, cet analyseur est légèrement bugué. Néanmoins, le programmeur a implémenté une boucle pour relancer le test si le premier essai n'est pas concluant. En pareil cas, il reste le risque que le programme parte dans une boucle infinie (car, comme vous le voyez, la source de bière a du mal à se tarir). Toutefois, après un certain nombre d'essais, un traitement d'exception se déclenche pour interrompre définitivement le test.
La désambiguïsation
Une fois que le texte est sorti de l'analyseur, il est fréquent que pour les différents mots du texte analysé, l'analyseur ait trouvé plusieurs possibilités de mots qui auraient la même orthographe dans le texte d'origine.
Par exemple, si on veut analyser la phrase :
Le chat joue, la chatte le regarde
l'analyseur va donner ceci :
^Le/Le<det><def><m><sg>/Lème<adj><mf><sp>/Le<prn><pro><p3><m><sg>/Le<prn><pro><p3><nt><sg>$ ^chat/chat<n><m><sg>$ ^joue/joue<n><f><sg>/jouer<vblex><pri><p3><sg>/jouer<vblex><pri><p1><sg>/jouer<vblex><prs><p3><sg>/jouer<vblex><prs><p1><sg>/jouer<vblex><imp><p2><sg>$^,/,<cm>$ ^la/le<det><def><f><sg>/le<prn><pro><p3><f><sg>$ ^chatte/chat<n><f><sg>$ ^le/le<det><def><m><sg>/le<prn><pro><p3><m><sg>/le<prn><pro><p3><nt><sg>$ ^regarde/regarder<vblex><pri><p3><sg>/regarder<vblex><pri><p1><sg>/regarder<vblex><prs><p3><sg>/regarder<vblex><prs><p1><sg>/regarder<vblex><imp><p2><sg>$
Chacun des mots pouvant être analysé de plusieurs façon, essayons de voir pour chaque mot ce que donne une des solutions données par l'analyseur.
| mot | analyse choisie |
|---|---|
| Le | Comme le L est majuscule, il s'agit d'un chiffre romain correspondant à 50. Et comme il y a un e juste après ce qui fait 50e (cinquantième en toutes lettres). |
| chat | est forcément un nom. Ce mot est un anglicisme qui signifie discussion sur internet. |
| joue | C'est également un nom qui correspond à la partie du visage sur laquelle tu recevras des gifles si tu n'es pas sage. |
| la | Tout le monde sait que le la est une note de musique. Mon prof de musique aimait à chanter le la3 qui parait-il sert à accorder les instruments ou les voix des élèves. Laaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ! |
| chatte | C'est un nom qui est synonyme de clitoris. |
| le | Ça peut être un article. |
| regarde | C'est le verbe regarder qui s'écrit comme ça à l'impératif présent : regarde ! |
Maintenant qu'on a choisi pour chacun des mots, une signification, on va pouvoir les traduire en utilisant le bidix et des règles de transfert qu'on va voir juste après.
On va donc obtenir dans la 2ème langue de la paire quelque-chose qui signifie :
Cinquantième discussion sur internet réceptacle à gifle, laaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa clitoris le regarde ça !
Bon, choisir une interprétation au hasard pour chacun des mots, n'est finalement pas l'idéal. C'est pour ça qu'on utilise un tagger qui permet de choisir entre plusieurs analyses.
Mais le tagger ne sait pas choisir tout seul. Il faut l'entraîner en lui donnant des milliers de phrases à traiter. L'une des manière d'entraîner le tagger s'appelle l'entraînement supervisé.
Au lieu de fournir au tagger juste des phrases, on rajoute à chacun des mots la catégorie à laquelle il appartient. Par exemple :
Le<det> chat<n> joue<verb>, la<det> chatte<n> le<prn> regarde<verb>
Mais le problème, c'est que l'entraînement d'un tagger, avec des milliers de phrases, ça prend du temps, beaucoup de temps ! Mais avec un peu de patience, vous devriez pouvoir profiter du résultat.
Et une fois le tagger bien entrainé, il devrait être capable de sélectionner les bonnes analyses pour chaque mot. On pourra passer à l'étape suivante : le transfert.
Les fichiers de transfert
Bon, ça y est. Tu as entraîné ton tagger et il est capable de choisir pour chacun des mots une analyse. A partir de là, il est possible de trouver dans le dictionnaire bilingue le mot traduit correspondant. Mais le travail de traduction n'est pas fini pour autant. Les noms peuvent être neutres dans une langue, masculins ou féminins dans une autre. Les adjectifs peuvent être invariants ou s'accorder. La conjugaison des verbes varie aussi d'une langue à l'autre.
Tout cela entraîne une conséquence : les attributs qu'on a trouvé pour chacun des mots dans le monodix de la langue d'origine, ne devront pas forcément être conservés à l'identique dans l'autre langue. Et pour faire les transformations nécessaires, il va te falloir écrire un fichier des règles de transfert. Bien entendu, ce fichier sera en XML.
La structure d'une règle de transfert est simple :
<rule>
<pattern>
<!-- la liste des catégories de mots qui se suivent -->
</pattern>
<action>
<!-- les instructions pour générer les mots et leurs attributs dans la nouvelle langue -->
</action>
</rule>
On va prendre un exemple simple pour traduire depuis l'espéranto l'article défini la suivi d'un nom :
- la viro -> l'homme (de la catégorie homo-sapiens, pas homo-sexuel)
- la virino -> la femme
- la viroj -> les hommes
- la virinoj -> les femmes
Dans la première partie de la règle, on va juste énumérer les catégories des mots qui se suivent, l'article s'écrivant det comme déterminant :
<rule>
<pattern>
<pattern-item n="det"/>
<pattern-item n="nom"/>
</pattern>
Et c'est entre les balises <action> ... </action> qu'on va décrire tout ce qu'il faut faire.
Comme vous pouvez le constater, dans la langue d'origine, l'article la s'écrit toujours pareil, alors qu'une fois traduit en français, on devra avoir le, la ou les selon le genre et le nombre du nom. Sous une forme algorithmique, ce qu'on doit générer s'écrirait comme ça :
DEBUT
SI genre du nom = m et nombre du nom = sg ALORS
générer le<det<ind><m><sg>
SINON SI genre du nom = f et nombre du nom = sg ALORS
générer le<det<ind><f><sg>
SINON SI genre du nom = m et nombre du nom = pl ALORS
générer le<det<ind><m><pl>
SINON SI genre du nom = f et nombre du nom = pl ALORS
générer le<det<ind><f><pl>
générer un espace
générer le nom avec tous ses attributs
FIN
Pour écrire tout ça en XML, on utilise l'instruction clip qui ne sert pas à faire de la vidéo mais à accéder aux différents attributs dans la liste des pattern-item.
<clip pos="numéro" side="tl ou sl" part="nom_attribut"/> * numéro identifie la position du pattern-item dans la liste, * sl veut dire dans la langue d'origine, tl dans la langue traduite * nom_attribut aura été défini auparavant avec les valeurs qu'il peut prendre
Dans une règle, on peut mettre des conditions plus ou moins complexes et donc des traitements conditionnels. La construction d'une règle consiste à empiler des balises XML. On t'avais dit que tu pourrais écrire ton système de traduction automatique sans savoir programmer et c'est vrai. L'écriture de règle de transfert s'apparente à un jeu de construction.
Par exemple, pour traduire en XML l'algorithme ci-dessus on écrira :
Bon, en réalité, dans cet exemple, il n'était pas nécessaire d'utiliser les instructions conditionnelles. Il suffisait d'utiliser les attributs du 2ème mot (pos="2"), c'est à dire du nom, pour générer certains attributs de l'article.
La règle pouvait donc s'écrire plus simplement :
<rule>
<pattern>
<pattern-item n="det"/>
<pattern-item n="nom"/>
</pattern>
<action>
<out>
<lu>
<clip pos="1" side="tl" part="lem"/>
<clip pos="1" side="tl" part="type_mot"/>
<clip pos="1" side="tl" part="type_det"/>
<clip pos="2" side="tl" part="genre"/>
<clip pos="2" side="sl" 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="sl" part="nombre"/>
</lu>
</out>
</action>
</rule>
La génération et la post-génération
Si tu as bien écrit le fichier des règles de transfert et qu'il est compatible avec le dictionnaire morphologique (monodix) de la langue de destination, le travail est presque fini. Après l'étape de transfert, le générateur est capable de remplacer les descriptions lemme + attributs que tu as généré par les mots correspondants.
Voici un exemple de texte en français que tu pourras obtenir à partir d'une langue étrangère, sans rien faire d'autre :
C'est ~la histoire ~de ~le chat et ~de une souris géante~.
Un jour, ~le chat ~de ~les voisins gambadait dans ~le champ~. Tout ~à coup, un animal lui tira sur ~la queue~. ~Le chat se retourna et vit ~la souris qui était plus grosse ~que lui~. ~La souris cria "Bouh !" ~à ~le chat~. ~Le chat prit peur et grimpa dans ~le arbre~. Il continua jusqu'~à ~la extrémité ~de ~la branche qui cassa~. ~De ~le coup, ~le chat tomba dans ~la eau ~de ~le lac~. ~La souris géante sortit alors ~son camescope pour filmer ~le chat en train ~de nager~. ~Sa vidéo eut ~de ~le succès sur Youtube car ~de habitude, ~les chats ont peur de ~la eau~.
C'est presque bon. On comprend le texte. Toutefois, dans de nombreuses langues, certains mots doivent quelquefois être modifiés en fonction du mot voisin. Ils sont marqués par une ~ lors de la génération du texte et on a recours à une étape de post-génération pour en corriger l'orthographe.
Pour l'étape de post-génération, il faudra disposer d'un dernier fichier au format XML. Dans le cas des langues de destination courantes comme le français, ce fichier existe déjà dans d'autres paires de langues et il suffira de le récupérer. Sinon, il faudra te démerder tout seul vu que j'ai la flemme de rajouter des explications sur un format de fichier qui n'est même pas documenté dans le wiki officiel du projet comme à ce stade, tu seras devenu un spécialiste du fonctionnement d'Apertium et du format XML, tu pourras t'inspirer d'autres fichiers de post-génération pour en comprendre le format et écrire celui adapté à ta langue.
Essayons Apertium
Supposons, que tu aies développé ta paire de langues. Il y a une méthode simple pour traduire des textes en ligne de commandes. Il suffit de taper quelque-chose comme :
echo "Ici, tu mets le texte dont tu veux la traduction" | apertium xx-yy
avec :
- xx qui est le code de la langue d'origine (fr = français, en = anglais, de = allemand, ...)
- yy qui est le code de la langue de destination
Pour voir si tus as compris, tu n'a qu'à faire un essai pour traduire en allemand la phrase française qui te viens à l'esprit.
echo "Suce moi la bitte !" | apertium fr-de Saugen Sie mich der *bitte !
Bon, tu as compris la syntaxe. Par contre, malgré tous les paradigmes qui utilisaient ce mot, tu n'as pas été capable d'orthographier le mot bite correctement. Lors de l'analyse de la phrase en français, le mot bitte n'a pas été trouvé dans le premier monodix. Il n'a donc pas pu être traduit et Apertium l'a simplement ré-écrit précédé d'une étoile.
Tu aurais eu le mot en français précédé d'une @ s'il avait pu être analysé mais n'avait pas de traduction dans le bidix. Enfin, si le problème venait de l'étape de transfert ou du monodix de la langue de destination, tu aurais eu le mot traduit sous la forme d'un lemme précédé d'un #.
Essaie à présent de retraduire en français la phrase que tu as obtenue. Tu pourras supprimer l'étoile.
echo "Saugen Sie mich der bitte !" | apertium de-fr Suce moi la s'il te plait !
Hé oui, le mot bitte existait en allemand. Apertium t'en a donc donné la traduction !
Bonne utilisation d'Apertium.
S'il vous a enthousiasmé, votez pour lui sur sa page de vote ! Ou pas.