close

Se connecter

Se connecter avec OpenID

Alignement automatique des corpus bilingue français et chinois

IntégréTéléchargement
UNIVERSITESORBONNE‐NOUVELLE,PARIS3ILPGA(INSTITUDELINGUSTIQUEET
PHONETIQUEGÉNÉRALESETAPPLIQUEES)
Alignement
automatiquedescorpus
bilinguefrançaiset
chinois
Alignement itératif paragraphe - phrase basé sur un dictionnaire
bilingue
JIN Kun 9/30/2013 Directeur de mémoire : Kim Gerdes
Mémoire présenté en vue de l’obtention
du Master R&D « Ingénierie Linguistique »
SorbonneNouvelle–Année2012‐2013
Remerciements
Ce mémoire n’aurait pas abouti sans une collaboration et un échange d’idées avec
toutes les personnes qui y ont participé, directement ou indirectement, et je tiens à les
en remercier.
Tout d’abord, mes remerciements s’adressent à Kim Gerdes, pendant cette période,
sa passion, son aide, sa confiance et son encadrement dans la conduite de ces travaux.
Mes remerciements s’adressent aussi à Mme Chantal Gatteau, Mr Antoine Deville
pour son aide en langue française.
Mes remerciements se portent aussi à l’université Paris 3 et plus particulièrement à
l’ILPGA, qui a mis à ma disposition les conditions de travail nécessaires pour
finaliser le présent mémoire.
Je tiens également à remercier Serge Fleury, directeur du Master Ingénierie
Linguistique, pour l’écoute attentive de ses étudiants.
Je remercie aussi Liangcai SHEN, un ami, ses conseils et encouragements. J’ai
apprécié sa disponibilité et le fait qu’il réponde toujours mes questions.
Un grand merci à tous les professeurs qui m’ont suivi durant ces années, je pense
notamment à ceux qui en particulier m’ont communiqué leur passion du TAL
(Traitement Automatique du Langage Naturel): André SALEM, Marcel Cori, Sylvain
Kahane, Kim Gerdes, Pierre Zweigenbaum et Serge Fleury.
De manière générale, je suis très heureux d’avoir choisi le Master «Ingénierie
Linguistique» et je remercie Kim Gerdes et Serge Fleury pour leur confiance : ils
savent accepter dans leur cursus des personnes au parcours atypique.
2
Contenu
Sorbonne Nouvelle – Année 2012-2013 ..............................Error! Bookmark not defined. Remerciements .................................................................................................................. 2 Introduction ....................................................................................................................... 5 1. 2. Alignement de bitexte ............................................................................................... 7 1.1 Bitexte .............................................................................................................. 7 1.2 Spécificités françaises, spécificités chinoises .................................................. 8 1.3 Alignement .................................................................................................... 10 1.4 Autres problèmes d’alignement ..................................................................... 14 1.5 Étendue de ce travail ...................................................................................... 15 Techniques d’alignement automatique ................................................................. 20 2.1 Définitions retenues de paragraphe, de phrase et de mot .............................. 20 2.2 Prétraitement des corpus bilingues ................................................................ 21 2.3 Normalisation des textes en pourcentage....................................................... 22 2.4 Notion de cognat, alignement par cognat, problème en zh-fr ........................ 23 2.5 Alignement des paragraphes dans la matrice................................................. 23 2.5.1 Algorithme de programmation dynamique .......................................... 26 2.5.2 Deux algorithmes baseline pour calculer la distance. .......................... 29 2.5.3 Trois algorithmes proposés pour calculer la distance. ......................... 35 2.6 3. Alignement de phrase dans la matrice ........................................................... 57 Procédé utilisé dans l'alignement .......................................................................... 61 3.1 Langage Python ............................................................................................. 61 3.2 Prétraitements ................................................................................................ 62 3.2.1 Extraction et combinaison de dictionnaires existants........................... 63 3.2.2 Lexique des formes fléchies du français (lefff) .................................... 70 3.2.3 Annotation par la fonction tag() ........................................................... 72 3.2.4 Lemmatisation du dictionnaire frzh.dict .............................................. 73 3
4. 3.3 Trouver des ancres d’alignement ................................................................... 75 3.4 Créer une matrice et calculer la distance de chaque paire de paragraphes. ... 77 3.5 Trouver le meilleur alignement...................................................................... 78 3.6 Moyen de programmer sur Python ................................................................ 79 3.7 Sortie de résultat ............................................................................................ 80 3.8 Mise en ligne.................................................................................................. 82 Conclusion ............................................................................................................... 84 Bibliographie ................................................................................................................... 85 Annexe .............................................................................................................................. 86 Le script Python de produire le dictionnaire bilingue .............................................. 86 Le script Python d’extraction des ancres ................................................................. 90 Le script Python d’alignement automatique ............................................................ 96 Le script Python de contrôle les saisis d’entrées ................................................... 102 4
Introduction
Le présent travail s'inscrit dans le cadre du Traitement Automatique du Langage
Naturel (TAL), un domaine de recherche actuellement en plein essor, situé à
l'intersection de plusieurs disciplines (informatique, linguistique, mathématiques,
psychologie) et mathématiques, psychologie) et dont l'objectif est la conception
d'outils informatiques permettant de traiter des données linguistiques écrites ou orales.
Une large collection (banque) de corpus bilingues alignés est utile dans des champs de
traduction manuelle et automatique. Mais le plus souvent, les chercheurs passent
énormément de temps sur un alignement étant donné qu'il manque des outils, ils sont
obliges de faire un alignement manuelle ou semi-automatique, et idem pour
l'alignement de corpus bilingue français/chinois.
Par conséquence, parmi cinq méthodes d'alignement automatique présentées dans ce
papier, et une méthode aligne le corpus bilingue en basant sur un dictionnaire bilingue,
il rend un résultat meilleur. Tous les mots dans le corpus sont cherchés par le
dictionnaire pour construire des paires de mots ou des ancres qui contiennent des mots
d’une langue et d’autre langue se traduisent mutuellement. Ces mots peuvent être le
mot simple ou le mot composé. En suite, la méthode prend en compte la fréquence de
mot et la longueur de paragraphe dans la formule de distance entre les segments (2ème
facteur: la longueur de toutes les ancres dans le paragraphe par rapport à la longueur de
paragraphe.). A la fin, en utilisant un algorithme de DTW, on obtient un résultat
d’alignement.
Pendant cet alignement, notre stratégie d’alignement est basée sur « de plus grand
jusqu’à plus petit », c’est-à-dire qu’on aligne d’abord ce qui est plus large en taille :
paragraphe, et puis le plus petit : phrase. A travers de l’évaluation de qualité, on a
obtenu que cette stratégie donne un résultat mieux.
Dans le 1er chapitre, on explique le concept de bitexte et la stratégie d’alignement
automatique. On explique également les notions générales, les méthodes générales et
les problèmes généraux rencontrés dans l’alignement automatique au niveau du
paragraphe, de la phrase et du mot. Ensuite, étant donné que ce projet consiste à
l’alignement automatique de corpus bilingue français/chinois, on présente ces deux
différents systèmes d'écriture.
5
Dans le 2ème chapitre, on définit dans ce projet les notions de paragraphe, de phrase et
de mot. Ensuite, on présente aussi une suite de prétraitements de corpus. Enfin, on
présente principalement cinq algorithmes d’alignement automatique : ils sont évalués
par une méthode statistique de précision, rappel et F-mesure.
Dans le 3ème chapitre, on présentera les détails de la programmation du meilleur
algorithme obtenu dans le 2ème chapitre. On présente les processus de production du
dictionnaire bilingue, le prétraitement de corpus bilingue et l’algorithme d’alignement
automatique.
6
1. Alignement de bitexte
1.1 Bitexte
Le terme bitext en anglais est proposé par Brian Harris (1988) pour désigner le corpus
qui comprend le texte de départ et le texte d'arrivée ou de traduction. En effet, il est
nommé autrement « corpus parallèle » : pendant une longue période, ce terme proposé
par Reinhard Hartmann (1980) se divise entre deux significations : d’abord les corpus
constitués de textes de départ et de leurs traductions (corpus de traduction) ; ensuite
ceux qui comprennent des textes en deux ou plusieurs langues qui, sans être des
traductions mutuelles, fonctionnent de façon semblable au plan de la situation de
communication (corpus comparables). C’est dans la linguistique informatique récente,
que le corpus parallèle se réfère spécialement à la collection des bitextes (Jörg
Tiedemann 2011). Le bitexte est généré non seulement par le texte original avec sa
traduction, mais aussi par la traduction d’une langue avec la traduction d’une autre
langue. (Figure 1-1).
Figure 1-1 Exemple d'un corpus parallèle contenant différents paires de corpus bilingues
Le bitexte est utilisé dans beaucoup de champs de recherche. Dans l’étude de
traduction, ils peuvent être utilisés pour étudier les moyens de traduction, et le
traducteur peut les consulter comme un dictionnaire. Dans la traduction automatique,
ils sont importants pour créer les ressources statistiques comme des modèles de
traduction.
7
Figure 1-2 Un bitexte aligné au niveau de paragraphe entre le chinois et le français
1.2 Spécificitésfrançaises,spécificitéschinoises
Cette section est basée principalement sur les travaux de Miao Jun 2012. La langue
française est une langue indo-européenne de la famille des langues romanes, et la
langue chinoise est une langue sino-tibétaine. Elles ont des systèmes d’écritures
différents, le français a une écriture alphabétique1 et le chinois possède une écriture
logographique 2 (ou apparentée). Le mot simple en français, unité porteuse de
signification, est un assemblage d’une ou plusieurs lettres. La lettre est l’unité de base
de l’écriture, mais en chinois, l’unité de base de l’écriture est le caractère, on l’appelle
« caractère carré ». Un caractère chinois peut constituer un seul mot qui véhicule une
unité de sens, mais il peut aussi s’associer en multiple caractères pour donner une
grande variété de sens.
1
Un alphabet est un ensemble de symboles destiné à représenter plus ou moins précisément
les phonèmes d’une langue.
2
Un logogramme est un unique graphème notant un lemme (mot) entier et non seulement
une partie de ses phonèmes. Dans la majorité des cas, rien n'indique, dans un logogramme, son
signifiant (comment il doit être prononcé – beaucoup de caractères chinois contiennent cette info :
les caractères de son similaires ont souvent une partie (souvent droite) qui est semblable). En
d'autres termes, c'est la plus petite unité significative du langage comme signe unique écrit qui
représente un mot complet, indépendamment de la langue.
8
Unité de base de l’écriture
a, b, c, d, …, z
中,文,土,豆……
Mot
土 (pinyin : /tu/. caractère, traduction : terre)
Pomme (5 lettres)
Terre (5 lettres)
Pomme de terre (14 lettre dont 2 espaces)
豆 (pinyin : /dou/. 1 caractère, traduction :
haricot)
土豆 (pinyin : /tudou/. 2 caractère, traduction :
pomme de terre)
Sauf la base de l’écriture est un caractère carré, un caractère chinois peut être
constitué de différents radicaux : base sémantique, base phonétiques ou mélange des
deux (un côté du caractère exprime le sens, l'autre la prononciation), par exemple :
Caractères 成 城(土+成) 诚(讠+成) Traduction française
Compléter Ville
Sincère Un caractère chinois (ou un mot) « 成 » se traduit par « compléter » en français, il est
aussi un radical phonétique, et associé avec un radical sémantique comme « 土 »
signifiant ‘terre’ pour construire un mot «城» qui se traduit par « ville », et associé
avec un radical sémantique comme « 讠» signifiant ‘parole’ pour construire un mot «
诚» qui se traduit par « sincère »,
D'un point de vue informatique, la composition en radicaux n'est pas encodée dans la
table Unicode, mais le caractère chinois entier, au même titre que la lettre en
caractères latins.
Le chinois traditionnel est aussi, comme le latin classique, une « scriptura continua »
qui est un style d'écriture sans espaces ou d'autres marques entre les mots ou les
phrases. En revanche, en français une phrase est une succession de mots non accolés
ou séparés par une ponctuation comme virgule, tiret etc.
Bonjour, je m’appelle Hélène
你好,我叫伊莲娜
Bienvenu en France
欢迎来到法国
Le chinois traditionnel n’a aucune ponctuation dans le texte, la segmentation des
phrases se fait grâce à l’expérience du lecteur. Depuis l’année 1919, la Chine a
commencé à utiliser le système de ponctuation moderne, similaire à la ponctuation
occidentale.
9
Appellation
points finaux
Symbole chinois
。? !
virgules
points de suspension
guillemets
, 、; : ·
……
“ ” ‘ ’ ﹄﹃ └ ┐《 》 〈 〉
parenthèses
( ) [] 〔〕{}【】
tirets
—— ~
-- ~~
.
noms propres
points de soulignement
Dans la traduction, un caractère chinois contient beaucoup plus d’information qu’un
caractère latin ; le chinois utilise moins d’article, préposition, conjonction que le
français. Le texte français est donc souvent plus long que le chinois en nombre de
caractères.
他哥吃完早饭上学去了。
son-frère-manger-finir-petit-déjeuner-aller-école-LE3
Son frère a pris le petit déjeuner, après il va à l’école.
Dans cet exemple, par rapport à la phrase chinoise, la phrase française utilise
quelques mots de plus : le, après, à. Et le mot « il » est utilisé pour référer « frère ».
1.3 Alignement
L’alignement est intimement connecté avec le bitexte, la tâche de l'alignement est de
générer le bitexte. L'alignement segmente les deux côtés d'un bitexte par un moyen tel
que le nème segment d’un côté correspond au nème segment de l'autre côté du bitexte
(Simard et Plamondon, 1996). Pendant la translation, un segment, par exemple dans la
figure 1-3, peut être supprimé(a), inséré, réordonné(b), divisé ou fusionné(c), par le
traducteur. Cela fait de l’alignement un travail difficile.
3
了 (LE) est principalement employé comme particule aspectuelle (suffixe verbal) ou comme
particule modale. La 1ère se situe immédiatement après le verbe : « verbe+ 了 », il s'agit d'un suffixe
verbal qui exprime l'action accomplie. La 2ème se place en fin de phrase : « verbe+objet + 了 », elle
permet d'exprimer un changement d'état ou une actualisation.
10
Figure 1-3 un segment supprimé dans la traduction(a), réordonnèrent de deux segments(b) et
regroupement de segments(c)
La stratégie commune à toutes les approches d'alignement automatique est d'exécuter
une procédure de plus en plus précise en commençant par l'alignement à un niveau de
la segmentation très grossier, et puis procéder à des alignements de segmentation plus
fins afin de finaliser un alignement définitif (Jörg Tiedemann 2011). Nous sommes
d’accord avec Tiedemann sur le fait que la raison principale de cette procédure est de
réduire l'espace de recherche pour les algorithmes d'alignement en les limitant à des
régions déjà alignées à un niveau plus élevé, afin de rendre le résultat plus précis. Si la
segmentation grossière est simple, l’alignement à ce niveau sera donc établi avec une
grande fiabilité.
En générale, les unités d'alignement de bitexte sont segmentées aux différents niveaux
par rapport à la longueur du segment. L'alignement peut se faire donc au niveau du
paragraphe, de la phrase et même du mot. Chacun de ces termes est difficile à définir
de manière précise. Les définitions retenues pour notre travail seront spécifiés en
section 2.1. Dans la suite de cette section, nous présenterons les bases de l’alignement
entre le français et le chinois, sans pour autant rentrer dans les détails techniques.
Le plus souvent, on appelle paragraphe, toute section non-vide de texte entre des
passages à la ligne. La segmentation des textes au niveau du paragraphe semble être le
seul point commun entre presque tous les textes modernes : le caractère de la nouvelle
ligne est donc le seul cognat « universel » (Gerdes 2011). Et puis, la suppression ou
l'insertion d'un paragraphe est un fait rare dans la traduction littéraire qui nous
11
intéressera ici. L'alignement par le caractère de la nouvelle ligne donne une méthode
d'alignement au niveau de paragraphe plus efficace.
Figure 1-4 Alignement au niveau de paragraphe
La phrase est souvent définie en fonction de la présence de certains symboles, par
exemple du point, du point d’interrogation, du point d'exclamation, … (« . », « ? », « !
»). Pour des symboles comme les deux points (« : »), les tirets longs (« – ») et les
points virgules (« ; »), il y a différentes conventions ; par conséquent, la segmentation
des textes au niveau de la phrase est plus compliquée que celle du paragraphe. Et pour
l’alignement au niveau de la phrase, il y a des moyens basés sur le nombre de
caractères de la phrase, car entre deux langues qui ont des systèmes d’écriture
similaires, des phrases plus longues dans une langue ont tendance à se traduire par des
phrases plus longues dans l'autre langue, et des phrases plus courtes ont tendance à se
traduire par des phrases plus courtes (Gale & Church, 1993). Dans les langues
éloignés (par exemple : chinois/français), les longueurs des phrases ne peuvent être
basées sur le nombre de caractères, mais sur leur fraction dans le texte entier (Voir
chapitre 2.3). Et puis, la suppression ou l'insertion, et même l'inversion des phrases
varient souvent dans une traduction selon la langue traduite. Par ailleurs, le point
d'arrêt indiquant la fin de phrase est représenté par un petit cercle « 。» dans des
langues asiatiques (chinois, japonais etc.), et il est différent dans les langues
européennes. Le cercle est aussi référencé avec la langue utilisée dans la table
Unicode, autrement dit, il s'agit d'un caractère différent dans la table Unicode (Gerdes,
2011). Tous les problèmes indiqués font que l’alignement au niveau des phrases est
plus difficile que celui de paragraphe.
12
Figure 1-5 Alignement au niveau de paragraphe
Le mot est le plus difficile à définir, comme on a indiqué dans la section 1.2. Malgré
cela, la segmentation des textes au niveau du mot est la tâche principale dans le
traitement automatique du langage naturel (TAL, en anglais : NLP, Natural Language
Processing). Pour les langues européennes, on peut se contenter de traiter chaque «
token », c'est-à-dire chaque suite de caractères entre des espaces ou de la ponctuation,
bien que cela pose plusieurs problèmes, parmi eux le fait que ces tokens ne
correspondent pas à des unités sémantiques (par exemple « pomme de terre », « parce
que », « Burkina Faso », …). Pour le chinois cette étape est plus cruciale. Elle est faite
à l'aide de dictionnaires et donne un résultat avec la précision allant vers 99%. Il
existe même des outils, comme ICTCLAS créé par M. Kevin ZHANG qui segmentent
le chinois avec une précision allant jusqu’à 99.7%. Bien que la segmentation au
niveau de mot ait une telle haute précision, au niveau bilingue, il n'y a pas
d’alignement des mots parfait. Car il y a des mots qui n'existent que dans une des
deux langues, comme par exemple « a » et « 了(LE) » dans la phrase suivante:
Pierre a dormi.
皮埃尔睡觉了。
Pierre-dormir-LE
En français, l’ensemble « a dormi » est un passé composé qui indique la fin d’un
processus, le mot « avoir » comme un auxiliaire se place avant une forme du participe
passé. En chinois, il n’existe pas d'auxiliaire, mais le mot 了 (LE) qui, est un
marqueur aspectuel indique que le processus a abouti. Bien qu’on aie ici deux mots
13
qui décrivent une fin de processus, ils ne constituent pas de traductions mutuelles4. Il
en suit que le meilleur alignement n’a pas de raffinement au-delà l’alignement « a
dormi » – « 睡觉了 »
Dans la traduction, certains mots même lexicaux sont ajoutés ou supprimés par le
traducteur ; par conséquent, il est impossible qu’ils soient alignés, comme par
exemple « 自 », un mot se traduit par « de » ou « origine » ou encore « soi-même » en
français qui est toujours avant un endroit pour représenter une action, dans la phrase
suivante :
Le grondement du fleuve monte derrière la maison.
江声浩荡,自屋后上升。
Fleuve-son-« vaste et puissant »-,-de-maison-derrière-monter
1.4 Autresproblèmesd’alignement
La note de bas de page apparait souvent dans le texte. Certes, elle est une forme
scientifique consistante en une ou plusieurs lignes ne figurant pas dans le texte. Sa
fonction consiste soit à citer une référence, une source, soit à disposer des arguments
ailleurs que dans le texte, soit à ajouter un commentaire. La dernière peut être aussi
dans une traduction pour compléter l’idée du traducteur. Du point de vue
«
typographique, la note de bas de page est composée d'un corps inférieur à celui du
texte et elle est signalée par un appel de note, sous forme d'astérisque, de chiffre ou de
lettre. Elle se place au bas de la page d'un livre, autrefois dans les marges aussi,
parfois en fin de chapitre ou en fin de volume. » (wikipédia) Dans un texte
électronique au format brut (TXT), la note de bas de page existe comme une partie du
texte normal. Pour l’alignement de celui-ci, il faut aussi la prendre en compte comme
un segment dans la traduction, la suppression, l’insertion, la division etc.
这小生命中间,有的是过剩的精力,欢乐,与骄傲!多么充沛的元气!他的身心老是在
跃动,飞舞回旋,教他喘不过气来。他象一条小壁虎日夜在火焰中跳舞。一股永远不倦
①的热情,对什么都会兴奋的热情。一场狂乱的梦,一道飞涌的泉水,一个无穷的希
望,一片笑声,一阕歌,一场永远不醒的沉醉。人生还没有拴住他;他随时躲过了:他
在无垠的宇宙中游泳。他多幸福!天生他是幸福的!他全心全意的相信幸福,拿出他所
有的热情去追求幸福!……
-------1 洲俗谚谓此种壁虎能在火中跳跃不受灼伤。
4
La raison est que l'aspect et le temps sont indépendants l'un de l'autre. On peut par exemple rencontrer
une action non-aboutie dans le passé.
14
1.5 Étenduedecetravail
Dans beaucoup de recherche de traduction, les chercheurs alignent des gros corpus
parallèles manuellement. Ces travaux qui délimitent des segments dans un texte en
utilisant des symboles spéciaux, figure 1-6, prend beaucoup de temps. Par conséquent,
nous désirons dans notre travail créer un outil d’alignement automatique de corpus
bilingue français / chinois.
Figure 1-6 un bitexte AUBE de Rolland Christophe aligné manuellement au niveau de paragraphe
par Miao Jun (2012)
D’abord, on alignement les textes français et chinois au niveau de paragraphe. Le but
est d'aligner le corpus bilingue par les modes « 1-1 », « 1-2 » et « 2-2 » (comme
l'indiquée dans la figure 1-4) : un ou plusieurs paragraphes de la langue source (ou
cible) lie un ou plusieurs paragraphes de la langue cible (ou source). Mais pour les
cas : une inversion de la structure de texte, par exemple les phrases « x, y » sont
inversé comme « y, x » dans la traduction ; une suppression ou une insertion, par
exemple la phrase z est supprimé (ou ajouté) dans la traduction, ils sont ignorés et on
les analyse comme un texte normal.
15
-
ensuite, c’est l’alignement au niveau de phrase, les mêmes conditions ci-dessus
sont appliquées dans cette étape.
Corpus
Le corpus bilingue peut être de tout genre. Dans le présent travail, nous nous
concentrons sur le genre de texte littéraire. Quant à ce type de texte, la traduction au
niveau de phrase est très proche du texte original, elle a rarement des suppressions ou
des inversions.
Le corpus dans ce travail vient de l'Internet, il est donc possible d’avoir des problèmes
typographiques ou ajouter des informations supplémentaires. D’ailleurs, on ne peut
pas vérifier la version de publication, on ne peut donc ni savoir d’où vient la
traduction, ni savoir la traduction est-t-il une traduction directe ou indirecte.
On utilise, comme corpus de teste, les deux premiers chapitres de l’Aube de « JeanChristophe » écrit par Romain Rolland et traduit par FU Lei. Il y a en total 282
paragraphes dans le texte français et 259 paragraphes dans le texte chinois. Afin
d’évaluer l’alignement automatique, on part d’un alignement manuel de ce corpus
comme illustré ci-dessous:
16
Figure 1-7 Capture d’écran d’Excel sur l'alignement manuel au niveau de paragraphe du volume «
L’aube » de « Jean-Christophe » par Romain Rolland
Chaque point rose a une coordonnée (x, y) qui réfère à une paire de paragraphes
alignée de deux langues, voir (a). S’il y a deux ou plusieurs points dans une ligne ou
une colonne, l’alignement ne sera pas paragraphe par paragraphe, c'est possible que
deux ou plusieurs paragraphes s'alignent en bloc, voir (b) et (c). Et (c) est un cas
réfère spécialement à l’alignement manuel dans le papier, voir section 2.5 pour la
précision.
(a)
(b)
(c)
Algorithmes
Les algorithmes d’alignement de segments (paragraphe ou phrase) sont basés sur un
calcul de la distance (ou similarité) de chaque paire de segments dans deux textes.
Nous allons utiliser cinq méthodes pour calculer la distance, qui sont :
1. par la position de symbole (symbole de paragraphe, point final) positionnée
après le segment.
2. par deux positions de symbole positionnées avant et après le segment.
3. par la fréquence d'ancre (ou paire de mot) trouvée dans des paires de segments.
4. par la fraction d'ancre dans le bitexte entier.
5. par la fraction d'ancre dans le bitexte entier et dans les paires de segments.
Dès que nous avons toutes les distances de segments, nous utilisons un algorithme de
programmation dynamique pour trouver les meilleurs paires de segments ; à l’aide de
ces paires, nous trouverons finalement un alignement automatique qui est en fait un
chemin qui ressemble à une diagonale dans la matrice (voir Figure 1-8). Il nous faudra
comparer l’alignement automatiquement avec l’alignement manuel (et correct) afin
d’évaluer la qualité de l’alignement automatique.
17
Figure 1-8 Chemin d'alignement de Jean-Christophe et sa traduction par FU Lei
Evaluation par la statistique
À propos de la qualité de ces méthodes, nous comparons leurs résultats avec
l’alignement manuel en utilisant les valeurs de précision, de rappel et de F-mesure. La
méthode le plus facile est de compter le nombre de points de l’alignement
automatique et l’alignement manuel qui coïncident.
Rappel est la fraction des points alignés corrects dans tous les points alignés manuel.
Précision est la fraction des points alignés corrects dans tous les points alignés
automatique.
F-Mesure qui combine la précision et le rappel est la moyenne harmonique de la
précision et de rappel.
18
Mise en ligne
A la fin de l'alignement de phrase, nous mettons à disposition des phrases alignées
dans un web site pouvant être consulté par d’autres personnes.
19
2. Techniques d’alignement automatique
Dans ce chapitre, on présente en théorie nos techniques d’alignement automatique sur
le corpus bilingue français/chinois. D’abord, on définit des notions de paragraphe, de
phrase et de mot (Section 2.1) qui servent de base théorique pour aligner le corpus
bilingue; ensuite, on définit le format de corpus bilingue (Section 2.2 et 2.3) qui
servent à former le corpus; puis, on présente des limites de la notion de cognat
(Section 2.4) dans le processus d’alignement de corpus bilingue français/chinois ;
enfin, on présente cinq algorithmes d’alignement automatique dont deux algorithmes
de baseline (2.5.2) et trois algorithmes par ancres (2.5.3).
2.1 Définitionsretenuesdeparagraphe,dephraseetdemot
Pour les définitions des notions de paragraphe, de phrase et de mot, il existe des
conventions variées. Dans ce travail, ces trois éléments de texte sont définis au niveau
de la typographie avec les moyens suivants :
 Paragraphe est une unité de discours constituée d’une suite de phrases et
défini typographiquement par une suite de phrases limitée par une nouvelle
ligne dans le texte. Au niveau d’informatique, un nouveau paragraphe est
commencé par une nouvelle ligne.
 Phrase est une unité de sens limitée par des signes typographiques que sont
les points finaux :
Point
Point d’interrogation
Point d’exclamation
Français
.
?
!
Chinois
。
?
!
 Mot est une unité sémantique du langage. En français, un mot qui est une
unité porteuse de signification est un assemblage d’une ou plusieurs lettres. En
chinois, un mot consiste soit d'un caractère chinois, soit de plusieurs caractères
chinois. Les mots utilisés dans ce travail ne dépendent que du dictionnaire
bilingue français/chinois utilisé. On ne procède donc pas à une segmentation
en mots préalable.
20
2.2 Prétraitementdescorpusbilingues
Les corpus bilingues concernés dans ce travail sont des textes de genre littéraire.
Avant de passer le processus d’alignement, les corpus bilingues doivent être
prétraités :
 Tous les formats de texte comme PDF, WORD, etc. doivent être convertis
dans le format cible du fichier qui est un texte brut avec le nom d’extension
« .txt »
Figure 2-1 Format de corpus
 Il faut ensuite nettoyer les éléments de contexte supplémentaires, comme les
commentaires du traducteur dans l'avant-propos et le post-propos, afin de faire
des corpus bilingues qui ont les mêmes débuts et fins.
Figure 2-2 Avant-propos et post-propos
 Pour les notes de bas de page, dans ce travail, on les efface aussi afin d’avoir
un environnement le plus simple. L’étude sur des corpus sans suppression de
note bas de page sera fait dans le travail future.
21
2.3 Normalisationdestextesenpourcentage
En général, la longueur du segment est très utile dans l’alignement entre deux langues
proches (ou de la même famille), comme le français, l’allemand etc., des segments
plus longs dans une langue ont tendance à se traduire par des segments plus longs
dans l’autre langue. Mais pour deux langues lointaines comme le chinois et le français
(voir Figure 2-3(a)), on a parlé précédemment des spécificités chinois et français, le
texte chinois est normalement constitué de moins de caractères que son texte parallèle
français.
Figure 2-3 Longueur et normalisation de texte
Pour l’alignement de ces deux langues, on est donc obligé de normaliser les textes en
pourcentage, voir Figure 2-3(b) : les paragraphes liés par des doubles flèches sont
alignés. La position de chaque caractère d’impression est une fraction du texte au lieu
de son index simple. Par exemple,
« Michelle va à l’école. » contient 22 caractères en français. Le mot «école.»
commence au 17ème caractère, mais on va le représenter comme 17/22=0.7727, donc
comme fraction sur le tout.
« 米歇尔去学校。 » contient 7 caractères en chinois, le mot « 学校 » qui est la
traduction du mot « école » commence au 5ème caractère, idem, on le représente comme
5/7=0.7143.
On estime donc que l'alignement par longueur se fera sur ces pourcentages et le même
segment du texte original correspondra à peu près à la même fraction du texte cible.
22
Par exemple le mot « école » à une position similaire que le mot « 学校 » : 0.7727
et 0.7143
2.4 Notiondecognat,alignementparcognat,problèmeenzh‐fr
Les cognats, ou « mots apparentés », sont des paires de tokens de langues différentes
qui ont en commun "d’évidentes" propriétés à la fois phonologiques ou
orthographiques et sémantiques, de sorte qu'elles sont susceptibles d'être utilisées
comme des traductions mutuelles. Les paires : generation / génération et error /
erreur constituent des exemples typiques pour l'anglais et le français, comme pour les
noms propres (Paris/Paris, China/Chine), les expressions numériques et la
ponctuation (points d'interrogation, parenthèses, etc.).
L’alignement par cognat permet de faciliter l’alignement des segments entre deux
langues proches par exemple deux langues qui sont dans une même famille. Mais,
plus les langues sont éloignées, plus il est difficile d'utiliser cette méthode, comme par
exemple pour le chinois et le français : cette notion convient moins car leurs systèmes
d’écriture étant complètement différents, on ne pourrait utiliser que des chiffres et
quelques transcriptions existantes dans les deux textes (exemple « 2013 ») ; par contre,
dans beaucoup de textes, surtout de genre littéraire, ces cognats ne sont pas présents,
et la méthode ne peut pas être utilisée.
2.5 Alignementdesparagraphesdanslamatrice
Tous les algorithmes d’alignement au niveau de paragraphe dans ce projet sont basés
sur un algorithme dynamique standard cherchant le plus court chemin dans la matrice
(Gerdes 2011) ; sur ce chemin, les paragraphes concernés dans le corpus bilingue sont
alignés.
Figure 2-4 Alignement dans la matrice
23
En convertissant la figure 2-3 (b) en matrice de la figure 2-4, la ligne rouge est la
ligne diagonale qui est le chemin naturellement le plus court allant du départ (0%)
jusqu’à la fin (100%) de la matrice ; cette ligne n’est pas le chemin que l’on cherche,
car l’alignement qui n’aligne que le début et la fin du texte n’est pas un alignement
des paragraphes. Ce que l’on cherche est représenté par la ligne noire : elle est le
chemin le plus court qui passe par un nombre maximum de points, ces points (0,0),
(30,25), (45,40), (60,61), (85,90) indiquant que les paires des symboles de paragraphe
sont alignés dans le corpus bilingue. Les symboles de paragraphe concernés par (0,0)
et (100,100) sont naïvement alignés étant donné qu’ils sont le début et la fin de corpus
bilingue (ce qui se doit d’être correcte comme on a enlevé dans notre prétraitement
d’éventuels avant-propos etc.). Si le « y = 25 », la ligne qui passe par le point (30,25)
est plus courte par rapport à celle qui passe le point (15,25) ; les symboles de
paragraphe de (30, 25) sont alignés ; il en est de même pour les points (60,61) et
(60,75). Tous les paragraphes concernés entre deux des points de la ligne sont alignés
dans le corpus bilingue.
En exécutant des algorithmes différents, on obtient des résultats différents, mais les
processus d’alignements se ressemblent : ils sont séparés en quatre étapes principales
(voir la figure 2-5):
0.15
0.30
0.45
0.60
0.85
1.00
0.25
0.10
0.05
0.20
0.35
0.60
0.75
0.40
0.25
0.10
0.05
0.20
0.45
0.60
0.61
0.46
0.31
0.16
0.01
0.24
0.39
0.75
0.60
0.45
0.30
0.15
0.10
0.25
0.90
0.75
0.60
0.45
0.30
0.5
0.10
1.00
0.85
0.70
0.55
0.40
0.15
0.0
Figure 2-5 Alignement dans la matrice
 1ère étape : initialiser la matrice.
La taille de matrice dépend du nombre de paragraphes dans le corpus bilingue.
Les nombres de paragraphes de corpus bilingue sont représentés par les nombres
de colonnes et de lignes, la ligne horizontale représentant une langue de corpus
bilingue et la ligne verticale représentant une autre langue ; chaque cellule de la
matrice a une coordonnée indépendante, comme (1, 1), (2, 1), (6, 5), …, (n, n), et
ces coordonnées se réfèrent aux paires de paragraphes correspondants, comme le
(1, 1) se réfère aux premiers paragraphes du corpus bilingue, et comme le (4, 3) se
24
réfère au 4ème paragraphe du texte d'une langue et le 3ème paragraphe du texte de
l’autre langue.
 2ème étape : calcul de toutes les distances des paires de paragraphes
concernés par les cellules dans la matrice, et les remplir dans la matrice.
La distance représente la similitude d’une paire de paragraphes, plus la distance
est petite, plus la paire de paragraphes est similaire, sa valeur dépend des
algorithmes utilisés ; on va préciser chaque algorithme dans les sections suivantes.
 3ème étape : alignement de corpus bilingue en cherchant le chemin ayant la
plus petite valeur en calculant les distances obtenues de la 2ème étape.
Les cellules du chemin qui ont la plus petite valeur montre que les paires de
paragraphes concernées sont alignées (ces cellules sont colorées en rouge). On
applique un algorithme de programmation dynamique (voir Section 2.5.1) pour
trouver ce chemin allant du début (1, 1) jusqu’à la fin (n, n) de la matrice.
 4ème étape : lier le corpus bilingue, sortir le résultat d’alignement.
Dès que le chemin d’alignement est trouvé, la suite est de générer le bitexte. Après
le résultat d’alignement, il est possible que deux ou plus de paragraphes d’une
langue soient reconstruits en un paragraphe, par exemple deux paragraphes d’une
langue colorée en vert concernés par (2, 2) et (2, 3) vont être combinés et puis
s’aligner avec le paragraphe d’une autre langue colorée en jaune.
Dans une traduction réelle, le texte source est traduit non seulement par paragraphe un
par un (« 1-1 »), mais aussi par paragraphe en bloc : « 1-2+ », « 2-2 ».
« 1-2+ » représente un paragraphe (deux ou plusieurs paragraphes) d’une langue
traduite(s) par deux ou plusieurs paragraphes (un paragraphe) d’une autre langue ;
l’ensemble des paragraphes de traduction (source) est donc aligné avec le paragraphe
source (traduction).
« 2-2 » est un cas comme la figure 2-6 (a) : deux paragraphes d’une langue sont
alignés en bloc avec deux paragraphes d’une autre langue ; la figure 2-6 (b) montre
que le chemin le plus court est celui de la ligne diagonale.
25
Figure 2-6 Alignement en bloc, le cas « 2-2 »
Dans ce projet, à cause des limites de l’algorithme de programmation dynamique
(voir Section 2.5.1), des alignements automatiques ne se réalisent que pour les cas «
1-1 » et « 1-2+ », mais pas « 2-2 », par exemple dans le table suivant, en calculant
toutes les distances possible, 0.8+0=0.8, 0.8+0.1+0=0.9, 0.8+0.9+0=1.7, le chemin le
plus court est « 0.8+0 » (en rouge), donc l’alignement sera le paragraphe « fr 0~0.9 »
aligne avec le paragraphe « zh 0~0.1 », le paragraphe « fr 0.9~1 » aligne avec le
paragraphe « zh 0.1~1 ».
0.1
0.9 0.8
1
0.9
1
0.1
0
2.5.1 Algorithmedeprogrammationdynamique
L’algorithme de programmation dynamique est un algorithme permettant de mesurer
la similitude entre deux suites de données qui peuvent être transformées en une
représentation linéaire, celle-ci correspondant à la nature de texte. Ensuite, la
normalisation en pourcentage du corpus bilingue français/chinois représente deux
suites de données linéaire et formée. Cet algorithme est donc utilisé pour l’alignement
de textes dans notre travail.
Ici, on utilise la matrice de la figure 2-5 comme exemple pour représenter cet
algorithme, la matrice est nommée Mdis. Le processus est séparé en 3 étapes :
Tout d’abord, on construit une matrice M dans laquelle le nombre de colonnes et de
lignes comporte une de plus que celles de la matrice Mdis.
26
La cellule (1,1) qui est pré-remplie par la valeur 0, les (1, 2), (1,3), …, (1, n) et les (2,
1), (3, 1),…, (n, 1) sont pré-remplies par une valeur allant vers l’infini. Les cellules
restantes sont remplies par des valeurs qui sont obtenues au moyen du calcul suivant :
La somme de la valeur minimum entre trois cellules (x, y), (x+1, y), (x, y+1) dans
la matrice M et la valeur de cellule (x, y) dans la matrice Mdis permet d’identifier
dans la matrice M (voir Figure 2-7) le chemin ayant les valeurs minimums.
1
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
0
0.15
0.45
0.9
1.5
2.35
0.25
0.1
0.15
0.65
1.26
2.01
2.91
0.35
0.2
0.2
0.81
0.51
0.36
0.21
1.41
0.96
0.66
0.36
0.31
2.16
1.56
1.11
0.66
0.81
0.41
3.91
3.01
2.26
1.66
1.06
0.81
0.41
3.35
0.35
0.7
1.3
2.05
0.4
0.85
1.45
0.45
0.84
0.56
Figure 2-7 Matrice M
Par exemple, pour calculer la valeur de la cellule (3,3), on compare trois valeurs de (2,
2), (2, 3) et (3, 2) dans la matrice ci-dessus : la valeur la plus petite est M(2,2), puis
ajouter à la valeur Mdis(2,2), on obtient la valeur :
M(3,3) = M(2,2) + Mdis(2,2)
Pendant le remplissage de la Matrice M, on crée une nouvelle matrice Mdir pour
enregistrer la « trace » de Mdis, le nombre de colonnes et de lignes étant le même que
celui de Mdis. On remplit la Mdis avec les conditions suivantes :
‐
‐
‐
Si la valeur minimum est M(x,y), Mdir(x,y) = 0
Si la valeur minimum est M(x+1, y), Mdir(x,y) = -1
Si la valeur minimum est M(x, y+1), Mdir(x,y) = 1
0
1
1
1
1
-1
0
1
1
1
-1
-1
0
0
1
-1
-1
-1
0
0
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
0
1
1
1
1
27
1
1
0
1
1
-1
1
1
-1
1
1
-1
0
1
-1
-1
0
-1
0
-1
-1
1
1
0
Figure 2-8 Matrice Mdir
A la fin, une autre matrice Malign pré-remplie par zéro est créée : elle représente
seulement le chemin d’alignement en analysant les données de Mdir par :
‐
‐
‐
La cellule Malign(n, m) qui est en bas à droit est remplie de 1 par défaut,
parce que les derniers paragraphes dans le bitexte sont alignés naïvement, et
on commence ici pour chercher le chemin demandé.
Le sens d’analyse des données est d’aller du bas à droit au haut à gauche.
La condition d’analyse :



1
0
0
0
0
0
0
Si Mdir (n, m) égale 0, alors, n = n – 1 et m = m – 1, Malign(n, m) = 1
Si Mdir(n, m) égale 1, alors, n = n – 1, Malign(n, m) = 1
Si Mdir(n, m) égale -1, alors m = m – 1, Malign(n, m) = 1
0
1
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
1
Figure 2-9 Matrice Malign
Les cellules contenant la valeur 1 qui construisent le chemin demandé sont colorées
en rouge, afin de faciliter la découverte de la relation de traduction, ou d’alignement.
La figure 2-10 est un résultat d’alignement automatique du corpus bilingue, le volume
« Aube » de « Jean-Christophe » par Romain Rolland et traduit par FU Lei. Les points
roses sont les cellules contenant la valeur 1 dans la matrice.
28
Figure 2-10 Un alignement automatique du corpus bilingue, le volume « Aube » de « JeanChristophe» écrit par Romain Rolland et traduit par FU Lei
2.5.2 Deuxalgorithmesbaselinepourcalculerladistance.
Différents algorithmes calculent différentes distances ; on propose ici deux
algorithmes baseline de calcul de la distance : ils sont réalisés par:
‐
la position de chaque paire des symboles des paragraphes en pourcentage dans le
corpus bilingue. (Section 2.5.2.1)
‐
deux positions de début et de fin de paragraphe. (Section 2.5.2.2)
2.5.2.1 Calcul de la distance par la position de symbole de paragraphe
Le premier algorithme consiste à calculer la distance par la position de chaque paire
de symboles des paragraphes en pourcentage dans le corpus bilingue. Pa se réfère à la
position d’un des symboles des paragraphes de la langue A et Pb se réfère à la
position d’un des symboles des paragraphes de la langue B, la distance entre Pa et Pb
est :
29
L’algorithmeestd’utilisercettedistancepouralignerlecorpusbilinguedansla
matrice;ondonnel’exemplesuivant:
Figure 2-11 Similaire de position relative de symbole de paragraphe
Un corpus bilingue français/chinois comme la figure 2-11, contient 5 symboles de
paragraphes dans le texte français et 4 symboles de paragraphes dans le texte chinois.
On le convertit en matrice en calculant la distance, qui est :
Pb1(25)
Pb2(55)
Pb3(95)
Pb4(100)
Pa1(15)
0.10
0.40
0.80
0.85
Pa2(30)
0.05
0.25
0.65
0.70
Pa3(50)
0.25
0.05
0.45
0.50
Pa4(75)
0.50
0.20
0.20
0.25
Pa5(100)
0.75
0.45
0.05
0
Figure 2-12 Matrice d'alignement des symboles des paragraphes
La matrice contient 4 colonnes et 5 lignes, chaque cellule de la matrice contient une
valeur qui est la distance de paire des symboles de paragraphes. Après le calcul par la
programmation dynamique, le chemin d’alignement trouvé est coloré en rouge, il
passe par les point (Pa1, Pb1), (Pa2, Pb1), (Pa3, Pb2), (Pa4, Pb3) et (Pa5, Pb4), et les
paragraphes entre deux flèches doubles sont alignés (voir figure 2-13), comme les 1er
et 2ème paragraphes dans le texte français et le 1er paragraphe dans le texte chinois.
30
Figure 2-13 Alignement par la position de symbole de paragraphe
On teste cet algorithme dans le corpus test, et compare le résultat avec l’alignement
manuel. Voici le résultat représenté graphiquement:
Figure 2-14 L'alignement du volume « L’aube » de « Jean-Christophe » par Romain Rolland par la position
de symbole de paragraphe
La ligne jaune représente l’alignement manuel, et la ligne verte représente
l’alignement automatique ; ce qui est en rose représente l’alignement automatique
31
superposé à l’alignement manuel (et donc l’alignement correct). Le résultat n'est pas
satisfaisant. L’analyse statistique de précision, rappel et F-mesure est :
Algo 1
Point trouvé
(manuel)
point trouvé
(automatique)
284
323
correct point
trouvé
(automatique)
118
Précision
Rappel
F-Mesure
0.365325077
0.415492958
0.388797364
Cet algorithme rend un résultat qui est facilement affecté par les phrases courtes : par
exemple, dans la figure 2-15, il y a deux paragraphes dans le texte français et trois
paragraphes dans le texte chinois ; l’alignement correct est réalisé entre le 1er
paragraphe du texte français et le 1er paragraphe du texte chinois ; mais comme le 2ème
paragraphe du texte chinois est court, la position de son symbole de fin de paragraphe
est plus proche du 1er paragraphe du texte français que du 1er paragraphe du texte
chinois ; le 1er paragraphe du texte français est aligné avec les 1er et 2ème paragraphes
(en bloc ) du texte chinois.
Figure 2-15 Capture d’écran du résultat aligné et sorti dans Excel
32
2.5.2.2 Calcul de la distance par les positions du début et de la fin de
paragraphe
Le deuxième algorithme est basé sur une méthode baseline dans les travaux de
Gelbukh 2006. L’idée principale est d’utiliser deux positions du début et de la fin de
paragraphe pour calculer la distance des paires de paragraphes dans le corpus
bilingue : on prend le même corpus bilingue de la figure 2-13, cette fois-ci, PA réfère
au paragraphe dans la langue française et PB réfère au paragraphe dans la langue
chinoise, la distance entre PA et PB est :
Distance(PA, PB) = |début(PA)-début(PB)|+|fin(PA)-fin(PB)|
Le début(PA) et la fin(PA) sont les positions relatives du début et de la fin du
paragraphe PA dans le texte, et de même pour le paragraphe PB. On calcule les
distances de chaque paire de paragraphes, et puis on les utilise pour l’alignement dans
la matrice.
Figure 2-16 Distance de positions relative de Paragraphe
La matrice ci-dessous, le vertical est la langue française, l’horizontal est la langue
chinoise, les cellules sont remplies par les distances obtenues :
Pb1
Pb2
Pb3
Pb4
Pa1
Pa2
Pa3
Pa4
Pa5
0.1
0.65
1.35
1.80
0.20
0.30
1.05
1.50
0.55
0.10
0.60
1.15
1.00
0.45
0.25
0.70
1.50
0.95
0.25
0.20
Figure 2-17 Matrice d’alignement de longueur de paragraphe
Le chemin le plus court est construit par les cellules colorées en rouge qui ont les
valeurs les plus petites. Les paires des paragraphes concernées par ces cellules sont
33
alignées : (Pa1, Pb1), (Pa2, Pb1), (Pa3, Pb2), (Pa4, Pb3) et (Pa5, Pb4). Il semble identique à
l’alignement du 1er algorithme. On teste cet algorithme dans le corpus à tester, le
résultat est :
Figure 2-18 L'alignement du volume « L’aube » de « Jean-Christophe » par Romain Rolland par la
longueur des paragraphes
Sans doute, ce résultat ressemble-t-il à l’alignement de la figure 2-14. L’analyse
statistique de précision, rappel et F-mesure est :
Algo 2
Point trouvé
(manuel)
point trouvé
(automatique)
284
307
correct point
trouvé
(automatique)
126
Précision
Rappel
0.410423453
0.443661972
F-Mesure
0.426395939
Le résultat de cet algorithme est aussi facilement affecté par la longueur du
paragraphe : par exemple (voir figure 2-19), l’alignement de corpus (a) est un
alignement manuel, mais si l’on utilise l’alignement par deux positions du début et de
la fin de paragraphe, le résultat est (b).
34
Figure 2-19 Fail d'alignement par la longueur des paragraphes
0%
70%
100%
65%
0.05
1.05
75%
0.70
0.30
100%
1.05
0.05
Figure 2-20 Alignement par la longueur des paragraphes
Dans la figure 2-20, le 1er paragraphe du texte français est bien aligné avec le 1er
paragraphe du texte chinois parce qu’ils ont une distance plus petite, mais la distance
entre le 1er paragraphe du texte français et le 2ème paragraphe du texte chinois n’est
plus la plus petite ; celle de 2ème paragraphe du texte français avec 2ème paragraphe du
texte chinois est plus petite ; par conséquent, l’alignement est représenté par la
matrice ci-dessus.
2.5.3 Troisalgorithmesproposéspourcalculerladistance.
Après avoir passé en revue deux algorithmes baseline ci-dessus qui donnent des assez
mauvais résultats, on propose trois algorithmes de calcul de la distance par des «
ancres » de paragraphes, c’est-à-dire des paires de mots se traduisant mutuellement,
provenant d’un dictionnaire bilingue – autrement dit, il faut des ressources lexicales
extérieures pour améliorer les résultats, car dans le cas du pair français-chinois on ne
peut pas avoir recours à des cognats. Les pairs sont constitués à partir :
‐
du nombre d’ancres (Section 2.5.3.2).
‐
du nombre de fractions d’ancres dans le corpus bilingue entier (Section 2.5.3.3).
‐
du nombre de fractions d’ancres dans le corpus bilingue entier et le nombre de
fractions d’ancres dans les paragraphes concernés (Section 2.5.3.4).
On utilise toujours le même corpus bilingue pour tester et évaluer ces algorithmes.
35
2.5.3.1 Ancre et méthode de comptage d’ancre.
Chaque paragraphe source avec sa traduction comportent des paires de mots qui se
traduisent mutuellement. On appelle ces derniers des « ancres » de paragraphes. En
les utilisant, on peut calculer la distance entre les paragraphes dans le corpus bilingue,
et puis réaliser un alignement. On a défini dans la section 2.1 la notion de mot dans ce
travail : un mot doit est trouvé dans un dictionnaire. Par conséquent, à l’aide d’un
grand dictionnaire bilingue, on extrait toutes les ancres possibles dans un corpus
bilingue, ces ancres peuvent être construites par des mots simples, et aussi par des
mots composés dépendant le dictionnaire. Le processus peut être illustré comme suit :
Figure 2-21 Extraire des ancres des paragraphes
Dans la figure 2-21, les ancres (paires de mots) sont : (mot1, zh1), (mot2, zh2), (mot3,
zh3), (mot4, zh4) etc.
L’algorithme automatique dans ce travail pour compter le nombre d’ancres dans
chaque paire de paragraphes est :
Figure 2-22 Une paire des paragraphes et la distance de cette paire des paragraphes
36
En raison de la suppression ou l'insertion, et même l'inversion des mots dans une
traduction, on ne peut pas parfaitement déterminer quels mots et quelles traductions
sont liées et ils sont donc comptés plusieurs fois : par exemple dans l’ancre (mot1, zh1)
dans la figure 2-22, le paragraphe français contient le mot1 2 fois, le paragraphe
chinois contient le zh1 3 fois ; par conséquent, le nombre total d’ancre (mot1, zh1) est
6 (=2 x 3).
Cet algorithme rend des « mots fréquents » encore plus fréquents ; il affecte donc le
calcul de distance des paragraphes, surtout dans le 1er algorithme qui calcule la
distance par seulement le nombre d’ancres.
2.5.3.2 Calculer la distance par le nombre des ancres
Cet algorithme est une base pour calculer la distance. Il utilise simplement le nombre
d’ancres, c’est-à-dire :
La distance entre une paire de paragraphe PA et PB est :
Ce dernier a pour but d’obtenir une distance entre 0 et 1 : la valeur la plus grande
devient la plus petite ; plus les distances sont petites, plus les paragraphes concernés
sont similaires (voir Figure 2-23).
37
y=(1/2)^x
9
8
7
6
5
4
y=(1/2)^x
3
2
1
0
‐4
‐2
0
2
4
6
8
Figure 2-23 y=(1/2)x
Par exemple, on trouve toutes les ancres dans un corpus bilingue, et puis on remplit
dans la matrice de la figure 2-24 le nombre des ancres.
P1fr P2fr P3fr P4fr P5fr P6fr P1zh
P2zh
P3zh
P4zh
P5zh
P6zh
P7zh
8 6 12 4 2 4 2 2 2 2 0 0 2 2 2 4 0 0 8 8 4 4 0 6 6 0 6 8 2 0 2 0 4 4 0 2 10
0
6
4
6
4
Figure 2-24 Calculer les distances des paires de paragraphes par le nombre des ancres de mots
Dans cette matrice, les lignes représentent la langue française, les colonnes la langue
chinoise. En fait, à travers cette matrice, on peut trouver le chemin d’alignement (le
chemin rouge) qui contient le nombre des ancres le plus grand que tous les autres.
Afin d’intégrer la matrice dans l’algorithme de programmation dynamique, on a
besoin de la convertir par l’algorithme de la figure 2-23. Autrement dit, on convertit
ces nombres de sorte que, plus le nombre d’ancres est grand, plus la distance est petite.
La matrice de la figure 2-24 est transformée en matrice de la figure 2-25 :
38
P1fr
P2fr
P3fr
P4fr
P5fr
P6fr
P1zh
P2zh P3zh P4zh
P5zh
P6zh P7zh
0.00390625 0.015625 0.00024414 0.0625 0.25 0.0625 0.25 0.25 0.25 0.25 1 1 0.015625 1 0.015625 0.0039063
0.25 1 0.25 1 0.063
0.063
1 0.25 0.25 0.25 0.25 0.063
1 1 0.0039063
0.0039063
0.0625 0.0625 1 0.015625 0.00097656 1 0.015625 0.0625 0.015625 0.0625 Figure 2-25 Résultat de la matrice convertie par y = (1/2)x
Dès que cette matrice est créée, l’étape suivante est de passer dans l’algorithme de
programmation dynamique pour chercher un chemin dont la valeur est la moins
élevée en partant du haut à gauche vers le bas à droite. Evidemment, dans cette
matrice, le chemin dont la valeur est la plus petite est construit par les cellules
colorées en rouge ; il est identique à la figure 2-24.
On teste cet algorithme dans le corpus à tester, mais il ne rend pas un résultat
satisfaisant (voir Figure 2-26):
Figure 2-26 Alignement par le nombre des ancres
La ligne jaune représente un alignement manuel ; la ligne verte représente un
alignement automatique ; il n’existe que quelques points roses qui représentent un
alignement automatique superposé à l’alignement manuel.
39
Après avoir analysé ces problèmes, on trouve que notre méthode sur le comptage de
nombre d’ancre affecte la qualité du résultat : chaque mot d’une langue avec toutes
ses traductions peut se construire avec plusieurs ancres. Par conséquent, le mot
fréquent peut avoir un plus grand nombre d’ancres que le mot rare ; le paragraphe
long peut avoir plus d’ancres que le paragraphe court ; un paragraphe long peut être
aligné avec un paragraphe court, car ils ont plus de paires d’ancres que deux
paragraphes courts, par exemple :
Figure 2-27 Problème d'alignement par le nombre des ancres
Le paragraphe PA contient 300 mots en total, et 70 mot1 (Zh1 est la traduction), la
distance entre PA et P2, PB et P2 ; sans doute, PA et P2 sont-ils plus proches : ils ont
au moins 140 (70 x 2) paires de mots (mot1 et zh1) trouvés ; même si tous les mots
dans PB et P2 sont trouvés, leur nombre d’ancres est toujours plus petite. Par
conséquent, le chemin le plus court passe par PA et P1, PA et P2, mais ne passe
jamais par PB et P2.
Ce problème est souvent causé par des « mots fréquents », comme « de/的, il/他, est/
是 etc.». On peut limiter la fonction de ces mots pour optimiser le résultat. On
propose d’ignorer le comptage de ces mots fréquents ou de changer la méthode de
comptage. Le tableau suivant représente une partie des mots les plus fréquents trouvés
dans le corpus à tester :
40
Figure 2-28 les mots fréquents
Si on ignore les dix premiers mots dans cette liste, le résultat est mieux que la figure
2-29 (haute), la ligne verte est plus proche que la ligne jaune.
Si on ignore tous les mots qui ont une fréquence supérieure à 2 (voir figure 2-29
(bas)), le résultat est meilleur, mais le résultat n’est pas plus fiable ; il ressemble à un
alignement qui n’a aucune ancre trouvée, dont le chemin est la diagonale : tous les
points sont identiques à l’alignement manuel.
41
Figure 2-29 Ignore les dix premiers mots le plus fréquents (haute) et Ignore tous les mots qui ont une
fréquence plus de 2 (bas)
42
2.5.3.3 Calcul la distance par la fraction des ancres dans le texte entier
Cet algorithme modifie la méthode de calcul d’ancre dans le but de limiter la fonction
des mots fréquents, c’est-à-dire en donnant aux mots fréquents une valeur plus petite
et aux mots rares une valeur plus grande. On utilise une valeur spécifique de paire de
mots (VSM) pour atteindre ce but. Elle est :
Le calcul des distances des paires de paragraphes par le nombre d’ancre devient un
calcul par le nombre de VSM. La méthode est :
P1fr P2fr P3fr P4fr P1zh P2zj
P3zh
1.964101985 0.192913576 0.520618431
1.486690929 51.81230372 10.06269798
2.881670739 11.21888223 28.16021192
0.059010752 0.46160304 0.171308494
P4zh 0.000324726 0.09205561 0.003344587 1.390861203
Figure 2-30 PVS de corpus bilingue
La valeur de PVS fonctionne pour mesurer la similitude des paires des paragraphes, et
ces valeurs sont stockées dans la matrice de la figure 2-30 ; elles sont comme le
nombre d’ancres dans la figure 2-24 ; ces valeurs ne se réfèrent pas encore à des
distances de paires de paragraphes ; parce que la plage de valeurs est entre 0 ~ ∞, on a
besoin d’une distance contrôlée entre 0 ~ 1 : par conséquent, on les convertit par
l’algorithme suivant, (voir la figure 2-31):
43
Figure 2-31 Distance calculée par (9/10)^PVS(Pa, Pb)
Dans ce cas, la matrice de la figure 2-30 est convertie en matrice de la figure 2-32.
Dans cette dernière matrice, plus la valeur (ou distance) de cellule est petite, plus la
paire de paragraphes concernée est similaire. P1fr P2fr P3fr P4fr P1zh 0.813069 0.855013 0.738146 0.993802 P2zj
0.97988
0.004258
0.306656
0.952529
P3zh
0.946625
0.346383
0.051459
0.982113
P4zh 0.999966 0.990348 0.999648 0.86369
Figure 2-32 Matrice convertie par (9/10)^PVS(Pa,Pb)
On teste aussi cet algorithme dans le corpus à tester, voir la figure 2-33,
44
Figure 2-33 Alignement par VSM de corpus bilingue, le volume "l'aube" de Jean-Christophe de Romain
Rolland
En comparant avec l’alignement manuel, ce résultat est meilleur qu’auparavant. Dans
deux textes qui contiennent plus de deux cents paragraphes, il n’y a que sept endroits
erronés qui sont trouvés. L’analyse statistique de précision, rappel et F-mesure est :
Algo 4
Point trouvé
(manuel)
point trouvé
(automatique)
correct point
trouvé
(automatique)
284
283
276
Précision
Rappel
0.975265018 0.971830986
F-Mesure
0.973544974
Ici, on propose un fichier d'html, il nous permet de faciliter à analyser le résultat
d'analyser en détail : ce fichier est construit comme une matrice, la 1ère ligne contient
des cellules qui sont des paragraphes de texte d’une langue (chinois ici), la 1ère
colonne contient des cellules qui sont des paragraphes de texte d’une autre langue
(français ici) ; et puis, dans toutes les autres cellules, on a la coordonnée de la cellule
(par exemple, « 1 2 »), la distance de la paire de paragraphe (par exemple, «
45
0.91494075812 »), la liste de toutes les ancres trouvées et nombre de chaque forme
d’ancre (voir Figure 2-34).
Figure 2-34 Résultat en format HTML
A l’aide de ce fichier, ces erreurs seront bien déterminées :
46
Erreur de type 1 : Dans cet algorithme de matrice, le nombre de cellules concernées
est petit, la somme de valeur des cellules est souvent petite. L’alignement automatique
prend donc dans la figure 2-33 (1) les cellules (4,4), (5,5) et (6,6) plutôt que les (4,4),
(4,5), (5,6) et (6,6) qui est un alignement manuel (Voir la figure 2-35).
Paragraphes concernés dans le texte original:
Ligne 4
Ligne 5
Ligne 6
– Bon Dieu ! qu’il est laid ! fit le vieux,
d’un ton convaincu. Il alla reposer la
lampe sur la table.
Louisa fit une moue de petite fille
grondée. Jean-Michel la regarda du coin
de l’œil, et rit.
– Tu ne voudrais pas que je te dise qu’il
est beau ? Tu ne me croirais pas. Allons,
ce n’est pas de ta faute. Ils sont tous
comme cela.
Ligne 4
Ligne 5
Ligne 6
“天哪!他多丑!"老人语气很
肯定的说。
他把灯放在了桌上。
鲁意莎撅着嘴,好似挨了骂的
小姑娘,约翰·米希尔觑着她笑
道:“你总不成要我说他好看吧?
说了你也不会信。得了罢,这又不
是你的错,小娃娃都是这样的。”
Figure 2-35 Erreur 1
L'alignement automatique a choisi la cellule bleue au lieu de deux cellules jaunes,
parce que deux cellules contiennent une valeur en total plus grand que la valeur de la
cellule bleu. La solution est de réduire relativement les valeurs des cellules, comme :
47
Y=Distance actuelle
Nouvelle distance = Yn
Parce que pour la cellule qui n’a la distance que comme 1, ça ne change pas la valeur
après cette traitement, mais pour des valeurs qui sont entre 0 et 1 deviendront le plus
petites. Mais la valeur « n » est un chiffre à manipuler, si elle est trop grande, le
résultat va être affecté, parce qu’il y a possibilité des paires de paragraphes qui auront
dû être alignés mais n’ont aucun d’ancre trouvée, dans ce cas, ils seront plus
distingués. Mais si la valeur de « n » est trop petite, ça n’affecte pas le résultat. Donc,
dans ce corpus à tester, on la fera varier entre 5 et 10, l’erreur de type 1 est résolue et
les autres résultats ne sont pas modifiés.
Type erreur 2 : Dans la figure 2-36, le résultat d’alignement montre le point faiblesse
dans cet algorithme, un paragraphe long avec un paragraphe court ont beaucoup de
possibilités d’avoir plus des ancres que ceux-ci de deux paragraphes courts, ces
premiers sont plus similaire. Par exemple, le paragraphe chinois 181 est plus long que
182, et puis le 1er a beaucoup plus de mots correspondant au paragraphe français 195
que le 2ème. Le paragraphe chinois 181 qui est mal aligné avec le paragraphe français
195 est un paragraphe avant ce qui est correct (paragraphe chinois 182).
Paragraphes concernés dans le texte original:
Ligne 194
La chute dégrisa un peu Melchior.
Après avoir juré, sacré, bourré de coups
de poing la chaise qui lui avait joué ce
tour, après avoir vainement tenté de se
relever, il s’affermit sur son séant, le dos
appuyé à la table ; et il reconnut le pays
environnant. Il vit Christophe qui
pleurait : il l’appela. Christophe voulait
se sauver ; il ne pouvait bouger.
Melchior l’appela de nouveau ; et
comme l’enfant ne venait pas, il jura de
colère. Christophe s’approcha, en
tremblant de tous ses membres.
Melchior l’attira vers lui, et l’assit sur
ses genoux. Il commença par lui tirer les
oreilles, en lui faisant, d’une langue
pâteuse et bredouillante, un sermon sur
le respect que l’enfant doit à son père.
Puis, il changea brusquement d’idée, et
le fit sauter dans ses bras en débitant des
inepties : il se tordait de rire. De là, sans
transition, il passa à des idées tristes ; il
s’apitoya sur le petit et sur lui-même ; il
le serrait, le couvrait de baisers et de
larmes ; et finalement, il le berça, en
entonnant le De Profundis. Christophe
ne faisait aucun mouvement pour se
Ligne 181
一跤跌下,曼希沃清醒了些。
把摔他下地的椅子骂着,咒着,捶
了几拳,挣扎着想站起而站不起来
之后,他背靠着桌子坐定了,开始
认出周围的环境。他看见克利斯朵
夫哭着,就叫他过去。克利斯朵夫
想逃,可是挪不动身子。曼希沃又
叫他,看孩子站着不动就生了气,
赌起咒来。克利斯朵夫只得浑身哆
嗦的向前。曼希沃把他拉过去,抱
他坐在膝上,先拧着孩子的耳朵,
结结巴巴的,把儿童应该如何尊重
父亲的话教训了一顿。随后,他忽
然改变了念头,一边说着傻话一边
把他在怀里颠簸,哈哈大笑。然后
他又急转直下的想到不快活的念
头,哀怜孩子,哀怜自己,紧紧搂
着他,几乎教他喘不过气,把眼泪
和亲吻盖满着孩子的脸;末了,他
高声唱着我从深处求告,摇着孩子
给他催眠。克利斯朵夫吓昏了,一
①点不敢挣扎。他在父亲怀里闷死
了,闻到一股酒气,听着醉汉的打
嗝儿,给讨厌的泪水与亲吻的口水
48
Ligne 195
dégager ; il était glacé d’horreur.
Étouffé contre la poitrine de son père,
sentant sur sa figure l’haleine chargée de
vin et les hoquets de l’ivrogne, mouillé
par les baisers et les pleurs répugnants,
il agonisait de dégoût et de peur. Il eût
voulu crier, et nul cri ne pouvait sortir
de sa bouche. Il resta dans cet état
affreux, un siècle, à ce qu’il lui parut, –
jusqu’à ce que la porte s’ouvrît et que
Louisa entrât, un panier de linge à la
main. Elle poussa un cri, laissa tomber
le panier, se précipita vers Christophe, et
avec une violence que nul ne lui aurait
crue, elle l’arracha des bras de
Melchior :
– Ah ! misérable ivrogne ! cria-t-elle.
Ligne 196
Ses yeux flambaient de colère.
沾了一脸,他又害怕又恶心的在那
儿受难。他真想叫喊,可是一声也
喊不出。他觉得这可怕的情形仿佛
有一世纪之久,——直到后来,房
门一开,鲁意莎挽着一篮衣服进来
了。她大叫一声,把篮摔在地下,
拿出她从来未有的狠劲,奔过来从
曼希沃怀里抢出了克利斯朵夫。
Ligne 182
“哎哟!该死的酒鬼!"她嚷着,眼
里冒着火。
Figure 2-36 Erreur 2
Type Erreur 3 : Dans la figure 2-37, on a vu que cette erreur se ressemble à l’erreur
2. Le seul différent est le paragraphe chinois 60 aligné avec le paragraphe français 67
est un paragraphe après ce qui est correcte (paragraphe chinois 59).
Paragraphes concernés dans le texte original:
Ligne 66
Le vieux soupira, se leva et dit :
Ligne 59
Ligne 67
– Allons.
Ligne 60
老人叹了口气站起来:“好吧,
我走啦。”
他过去把刺人的须在她脑门上
轻轻拂了一下,问她可要点儿什么
不要,然后拈小了灯走了。屋子里
暗得很,他和椅子撞了一下。但他
没有下楼已想起儿子醉后归来的情
景;在楼梯上他走一步停一步,想
着他独自回家所能遭遇的种种危
险……
49
Ligne 68
Il vint près d’elle, lui effleura le front de
sa barbe râpeuse ; il demanda si elle
n’avait besoin de rien, baissa la lumière
de la lampe, et partit en heurtant les
chaises, dans l’obscurité de la chambre.
Mais il n’était pas dans l’escalier qu’il
songeait à son fils revenant ivre ; et il
s’arrêtait à chaque marche ; il imaginait
mille dangers à le laisser rentrer seul…
Figure 2-37 Erreur 3 capture d’écran de resultat.html
Autre type d’erreur (type erreur 4): à travers ce fichier plus détail, on trouvé une
autre erreur. Le paragraphe 36 dans le texte chinois est représenté en deux dans le
texte français (42 et 43). Ici, le paragraphe français 43 et le paragraphe chinois 36 ne
contiennent pas beaucoup de mots qui se correspondent, parce que en chinois, on ne
dit pas « ce n’est pas un joli cadeau que je t’ai fait là », il est complètement changé
par le traducteur « 是我为难了你。».
是我为难了你。
Etre-moi-mettre dans l’embarras-LE-toi
C’est moi qui te met dans l’embarras.
C’est un cas de la traduction littéraire, la traduction est une façon de passer des
informations au niveau sémantique. Donc, l’alignement par ancres est difficile à
réaliser dans ce cas.
Paragraphes concernés dans le texte original:
Ligne 42
Le vieux la regarda en hochant la tête :
Ligne 36
老人望着她,摇了摇头:“可
50
Ligne 43
– Ma pauvre fille, ce n’est pas un joli
cadeau que je t’ai fait là.
Ligne 44
– C’est ma faute à moi, dit-elle. Il ne
devait pas m’épouser. Il a regret de ce
qu’il a fait.
Ligne 37
怜的小媳妇,是我难为了你。”
“那只能怪我。他不该娶我
的。他一定在那里后悔呢。”
Figure 2-38 Erreur spéciale
D’auprès toutes les analyses de ces sept erreurs, on trouve que, sauf des types d’erreur
spéciale (1 et 4), les erreurs principales concentrent sur deux types (2 et 3) : si on
utilise des graphes pour représenter ces problèmes, ils sont illustrés comme suit :
Figure 2-39 Corpus (a) avec son alignement manuel, (b) est un alignement automatique de corpus (a) et
corpus (c) avec son alignement manuel, (d) alignement automatique de corpus (c).
Les problèmes apparaissent dans une traduction qui modifie le nombre de paragraphe,
on peut dire que c’est un problème de longueur de paragraphe :
51
‐
Dans (a), le 2ème paragraphe français aurait du s’aligner avec le 1er paragraphe
chinois, mais il est aligné automatiquement avec le 2ème paragraphe chinois étant
donné que ce dernier est plus long, et qu’il contient beaucoup plus d’ancres avec
le paragraphe français.
‐
(c) et (b), idem.
2.5.3.4 Calcul de la distance par la fraction des ancres dans le paragraphe et
dans le texte
Cet algorithme est basé sur l’algorithme de calcul de la distance par la fraction
d’ancre dans le texte ci-dessus. On ajoute un autre facteur, la fraction de toutes les
ancres dans une paire de paragraphes, pour résoudre le problème vient de la différente
longueur de paragraphe. Il est :
En fait, la fraction de toutes les ancres dans une paire de paragraphes obtenue est une
valeur qui fait que plus la valeur est grande, plus la paire de paragraphes concernée est
similaire. Afin d’adopter l’algorithme de programmation dynamique, on a besoin de
les inverser, c’est-à-dire, plus la valeur est petite, plus la paire de paragraphes
concernée est similaire. Cette transformation est réalisée comme suit:
La fraction d’ancre dans le texte doit être analysée de la même manière,
La distance est un produit de la fraction de toutes les ancres dans le texte et dans le
paragraphe :
52
Le teste sur le corpus est comme l'indique la figure 2-40 :
Figure 2-40 Alignement de corpus bilingue par la fraction d’ancre dans le texte et dans le paragraphe, le
corpus est le volume "l'aube" de Jean-Christophe de Romain Rolland
Cet algorithme a l’air meilleur, car seules deux erreurs sont trouvées dans ce résultat.
L’analyse statistique de précision, rappel et F-mesure est :
Algo 5
Point trouvé
(manuel)
point trouvé
(automatique)
correct point
trouvé
(automatique)
284
284
282
Précision
Rappel
0.992957746 0.992957746
F-Mesure
0.992957746
L’analyse de détail est comme :
53
Erreur 1 :
Les paragraphes français 188 et 189 sont traduits par un paragraphe chinois 177. Le
paragraphe français court 189 ne contient que 4 mots (3 formes). Ces trois formes ont
des traductions correspondantes dans les paragraphes chinois 177 et 178. La paire de
paragraphe (189, 177) contient beaucoup plus d'ancres que la paire de paragraphes
(189, 178) à cause du paragraphe 177 qui est plus long que le paragraphe 178.
L’algorithme de calcul de la distance par la fraction des ancres dans le texte a
normalement un résultat bien aligné de cette paire de paragraphes. Mais après l’ajout
du facteur de la fraction des ancres dans le paragraphe, le résultat a été modifié, parce
que la différence de longueur entre les paragraphes (189, 178) est moindre que dans
les paragraphes (189, 177): les premiers sont donc plus proches.
Paragraphes concernés dans le texte original:
Ligne 188
Ligne 189
Ligne 190
Ligne 191
Un soir, vers sept heures, il était seul à
la maison. Les petits frères se
promenaient avec Jean-Michel. Louisa
lavait le linge, au fleuve. La porte
s’ouvrit, et Melchior fit irruption. Il était
sans chapeau, débraillé ; il exécuta pour
entrer une sorte d’entrechat, et il alla
tomber sur une chaise devant la table.
Christophe commença à rire, pensant
qu’il s’agissait d’une de ses farces
habituelles ; et il vint vers lui. Mais dès
qu’il le vit de près, il n’eut plus envie de
rire. Melchior était assis, les bras
pendants, et regardait devant lui, sans
voir, avec des yeux qui clignotaient ; sa
figure était cramoisie ; il avait la bouche
ouverte ; il en sortait de temps en temps
un gloussement stupide. Christophe fut
saisi. Il crut d’abord que son père
plaisantait ; mais voyant qu’il ne
bougeait pas, il fut pris de peur.
– Papa ! papa ! criait-il.
Ligne 177
一天晚上七点光景,只有
他一个人在家。小兄弟们跟着老祖
父散步去了,母亲在河边洗衣服。
门一开,曼希沃闯了进来;他光着
头,衣衫不整,蹦蹦跳跳的,一倒
便倒在桌前的椅子里。克利斯朵夫
笑了,以为他象平常一样又来玩把
戏了,便迎上前去。但走近一看,
他再也笑不上来了。曼希沃坐在那
里,垂着手臂,眨巴着眼睛望着前
面,脸色通红,张着嘴,不时发出
很可笑的蝈蝈声。克利斯朵夫愣住
了。他先是以为父亲开玩笑,可是
看他一动不动,便害怕了。他喊
着:“爸爸!爸爸!”
Ligne 178
曼希沃仍是象母鸡一样蝈蝈的
叫。克利斯朵夫无可奈何的抓着他
的胳膊,尽力的推他摇他:“爸
爸,好爸爸,你回答我啊!”
Melchior continuait à glousser comme
une poule. Christophe lui saisit le bras
avec désespoir, et le secoua de toutes ses
forces :
– Papa, cher papa, réponds-moi ! Je t’en
supplie !
54
Figure 2-41 Erreur 1
Erreur 2:
Cette erreur est identique à l'erreur 1, bien que les paragraphes (227, 210) aient plus
d'ancres que (227, 211), mais une telle différence de longueur de paragraphes affecte
toujours le résultat.
Paragraphes concernés dans le texte original:
Ligne 226
Ligne 227
Ligne 228
Ligne 229
Quelques semaines après, un des gamins
avec qui il jouait dans la rue ne vint pas
à l’heure habituelle. Un du groupe dit
qu’il était malade ; et l’on s’accoutuma
à ne plus le voir aux jeux : on avait
l’explication, c’était tout simple. – Un
soir, Christophe était couché, de bonne
heure ; et du réduit où était son lit, il
voyait la lumière dans la chambre de ses
parents. On frappa à la porte. Une
voisine vint causer. Il écouta
distraitement, se contant une histoire
suivant son habitude ; les mots de la
conversation ne lui arrivaient pas tous.
Brusquement, il entendit la voisine qui
disait qu’ « il était mort ». Tout son sang
s’arrêta : car il avait compris de qui il
s’agissait. Il écouta, retenant son souffle.
Ses parents s’exclamaient. La voix
bruyante de Melchior cria :
– Christophe, entends-tu ? Le pauvre
Fritz est mort.
Ligne 210
过了几星期,有个在街上和他
一起玩耍的孩子,到了平时该来的
时候竟没有来;有人说他病了;从
此他不来玩也没有人奇怪。事情已
经有了解释,不是挺简单吗?——
一天晚上,克利斯朵夫很早上了
床,从他的一角看见父母屋里还亮
着灯光。有人敲门,一位邻居的太
太来谈天。他心不在焉的听着,一
边照例编他自己的故事,并没把人
家的谈话句句听清。忽然邻人说了
句:“他死了",克利斯朵夫的血便
马上停住:因为他知道说的是谁,
就屏着气听下去。他的父母大惊小
怪的叫了几声。曼希沃又扯着他的
粗嗓子嚷道:“克利斯朵夫,听见
没有?可怜的弗理兹死了。”
Ligne 211
克利斯朵夫挣扎了一下,静静
的回答说:“是的,爸爸。”
Christophe fit un effort, et répondit d’un
ton tranquille :
– Oui, papa.
55
Figure 2-42 Erreur 2
On utilise aussi un graphe pour représenter ces problèmes, comme suit :
Figure 2-43 Corpus (a) avec son alignement manuel, (b) est un alignement automatique de corpus (a) et
corpus (c) avec son alignement manuel, (d) alignement automatique de corpus (c).
Ces problèmes ressemblent aux problèmes de l’algorithme d’alignement par la
fraction d’ancre dans le texte (Section 2.5.3.3), mais ils sont inversés. Deux
paragraphes ayant des longueurs proches sont plus similaires, mais deux paragraphes
56
français traduits par un paragraphe chinois, s’il y a un autre paragraphe qui suit
(paragraphe 2 dans (a) et (b)) ou procédé (paragraphe 1 dans (c) et (d)), donc un des
paragraphes français va être aligné avec ce dernier paragraphe chinois.
A travers des évaluations de cinq algorithmes d’alignement automatique, on trouve
que l’algorithme d’alignement par la fraction d’ancre dans le texte entier et les
paragraphes est une méthode meilleure, il peut bien fonctionner pour un alignement
de paragraphe malgré quelques erreurs.
2.6 Alignementdephrasedanslamatrice
La méthode d'alignement de phrase concernée dans notre travail est aussi basée sur le
résultat d'alignement de paragraphe qui est obtenu par le dernier algorithme, elle
réutilise cet algorithme pour réaliser un alignement de phrase dans la matrice. Par
conséquence, la méthode principale de l'alignement de phrase est pareil comme
l'alignement de paragraphe, sauf les délimiteurs entre des segments: point final, point
d'interrogation et point d'exclamation.
Le résultat d'alignement de paragraphe a donné plusieurs paires de paragraphes
alignées, dès qu'on entre l'alignement de phrase, on prend chaque fois une paire de
paragraphe et appliquer un processus d'analyse comme suite:
‐
‐
‐
‐
utiliser les délimiteurs pour segmenter chaque phrase.
utiliser le dictionnaire bilingue pour chercher des ancres.
utiliser l'algorithme pour calculer la distance.
utiliser l'algorithme pour trouver le chemin d'alignement.
Pour savoir si cette méthode est-t-elle utile dans l'alignement de phrase, on prend le
résultat d'alignement de paragraphe de corpus d'Aube. Et puis, on utilise toujours une
analyse statistique pour évaluer le résultat d'alignement, certes, une comparaison avec
l'alignement manuel est une nécessité.
Après avoir aligné de chaque paire de paragraphe, on sort ces résultats en format
HTML, on a en total 257 fichiers HTML.
57
A travers une suite d'analyse de ces fichiers, on a obtenu que:
1. Notre méthode peux fonctionner aussi dans l'alignement de phrase. (on indique le
résultat d'évaluation statistique ci-dessous)
2. Un résultat d'alignement de paragraphe nous permet d'avoir un résultat
d'alignement de phrase plus correct et plus efficace. Même s'il n'y a pas d'ancre
trouvée dans une paire de phrase (voir Figure suivante):
Pour stocker le résultat d'analyse de ces fichiers, on crée un fichier Excel "ali-Phrase"
avec des éléments:
58
‐
‐
‐
‐
‐
‐
‐
ID: numéro de paire de paragraphe (fichier html)
nbr_ph_fr: nombre de phrases français dans une paire de paragraphe
nbr_ph_zh: nombre de phrases chinois dans une paire de paragraphe
ali_manuel: nombre de points trouvés par un alignement manul
ali_automatiq: nombre de points trouvés par l'alignement automatique
ali_auto_corr: nombre de points trouvés et corrects par l'alignement automatique.
ali_para_corr: est-ce que cette paire de paragraphe est bien aligné (0 -> nom et 1-> oui)
Figure 2-44 Capture d'écran d'Excel
Le corpus Aube contient 1547 phrases français et 1457 chinois. Le résultat
d'alignement de paragraphe contient en total 257 paires de paragraphe (ID commence
par 0, le chiffre est après la combinaison des bloques de paragraphes alignées). Et puis,
le résultat d'alignement de phrase contient 1610 paires de phrase (sans combinaison).
Leur chiffre statistique est:
Algo 5
Point trouvé
(manuel)
point trouvé
(automatique)
correct point
trouvé
(automatique)
1589
1610
1548
Précision
Rappel
F-Mesure
0.961490683 0.974197609 0.967802438
2.7 Evaluationdelastratégied’alignement
Dans le chapitre I, on a indiqué la stratégie d’alignement générale. On respecte bien
cette stratégie pendant tous les travaux précédents. Et maintenant, on va évaluer cette
stratégie en comparant le résultat d’alignement de phrase obtenu ci-dessus et le
résultat d’alignement de phrase direct sans via le niveau paragraphe. On utilise
toujours les trois valeurs statistique, voir ci-dessous, le résultat obtenu par la stratégie
est beaucoup mieux que l’alignement direct. On confirme maintenant que la stratégie
d’alignement peut sert à l’alignement de corpus des langues éloignées, et rend un
résultat mieux que l’alignement direct au niveau de phrase.
59
Précision
Rappel
F-Mesure
direct
0.894985250737
0.863403528742
0.878910776362
indirect
0.961490683
0.974197609
0.967802438
Dans ce chapitre, on a testé dans le cadre cinq différents algorithmes pour calculer la
distance de chaque paire de paragraphe. La précision de résultat, du 1er jusqu'à le
dernier, devient de plus en plus haute. Mais il existe toujours des problèmes, par
exemple dans le dernier algorithme, le facteur de longueur de paragraphe peut
corriger l'erreur fabriquée dans l'algorithme 4, mais il donne aussi une autre erreur.
Une amélioration sera dans le travail futur. Et puis, on a fait un alignement de phrase,
et obtenu un résultat avec une haute précision, il présente la stratégie d'alignement
d'un grain gros jusqu'à un grain fine est utile, et l'alignement dans la matrice peut
fonctionner pour l'alignement de phrase. Dans le chapitre suivant, on parlera de
Python Script pour réaliser ce travail.
60
3. Procédé utilisé dans l'alignement
Ce chapitre décrit le procédé de l’alignement automatique de corpus bilingue par la
fraction d’ancre dans le texte entier et les paragraphes. On représente donc le travail
réalisé par la programmation : Créer le dictionnaire bilingue, extraction d’ancre,
alignement de corpus bilingue.
3.1 LangagePython
On réalise ce projet à l’aide d’un langage informatique Python, qui est un langage de
programmation multi-paradigme. Il favorise la programmation impérative structurée
et orientée objet.
Le site du python : http://www.python.org/
Le lien de téléchargement est : http://www.python.org/download/releases/2.7.4/
Parce que la version 2.7.4 de Python a beaucoup plus de modules tiers que la version
3.x, on choisit la version 2.7.4.
Un script de Python :
Enregistrer ce script dans un fichier « .py », par exemple bonjour.py, et puis lancer ce
script dans la ligne de commande suivant, on aura un retour d’information « bonjour ».
Module de Python:
‐
marshal : Convertir des objets Python à des flux d'octets et à l'arrière (avec
des contraintes différentes).
‐
time : Accès en temps et conversions.
‐
re : Opérateurs expression régulière.
61
‐
codecs : Coder et décoder des données et des ruisseaux.
‐
sys : Accéder aux paramètres et fonctions spécifiques au système.
‐
unicodedata : Accédez à la base de données Unicode
‐
collections : Les types de données à haute performance
‐
string : Opérations sur les chaînes ordinaires
‐
numpy :
NumPy est le paquet fondamental pour le calcul scientifique avec Python
Site de numy : http://www.numpy.org/
Téléchargement : http://www.scipy.org/Download
Pour utiliser les fonctionne dans un module, il y a deux méthode :
 import
 from module import fonction
Par exemple :
La différence entre ces deux façons est :
import time : appelle le module « time », si on a besoin d'utiliser une fonction
comme « time() », on a besoin utilise « time.time() »
from time import time : charger la fonction « time() » dans le module « time »,
maintenant, cette fonction est comme une fonction de script, on utilise seulement par
(time()).
3.2 Prétraitements
Les prétraitements d’alignement automatique par des fractions d’ancre dans le texte
entier et les paragraphes sont illustrés comme suit :
62
Les prétraitements ont deux buts principaux:
‐
Un large dictionnaire bilingue fr-zh qui contient de côté français les mots en
deux formes, token et lemma.
‐
Un texte français dont les mots sont en deux formes, token et lemma.
3.2.1 Extractionetcombinaisondedictionnairesexistants
Le dictionnaire bilingue utilisé dans l’alignement automatique par le nombre des
ancres vient d’une reproduction de deux dictionnaires français-chinois. Chaque entrée
du dictionnaire produit est sous un format, un seul mot français et un seul mot chinois,
ils se traduisent mutuellement. Par conséquent, même si une entrée contenant un mot
français et plusieurs traductions chinoises dans deux dictionnaires originaux, les
traductions seront séparées une par une, elles reconstruisent avec le mot français des
nouvelles entrées, également le cas pour des entrées qui contient un mot chinois et
plusieurs mots français. Dans l’exemple suivant, on reprend une partie du dictionnaire
français-chinois.
一连 /de suite/à la file/sans interruption/
一通 /une fois/
一遍 /une fois/
一遍又一遍 /encore et encore/à maintes reprises/maintes fois/
一道 /ensemble/avec/côte à côte/en compagnie de/
一部 /une partie/la plupart/
一部分 /une partie/la plupart/
Chaque entrée contient un mot chinois et sa traduction en français. Elles contiennent
aussi un mot chinois et deux ou plusieurs traductions en français. En plus, deux
entrées contient deux mots chinois différents, mais leurs traductions identiques,
comme « 一通/一遍 », « 一部/一部分 ». Ces entrées sont reconstruites, chaque
63
entrée contient strictement un mot en chinois et un mot en français, comme le montre
la figure suivante :
一连 de suite
一连 à la file
一连 sans interruption
一通 une fois
一遍 une fois
一遍又一遍 encore et encore
一遍又一遍 à maintes reprises
一遍又一遍 maintes fois
一道 ensemble
一道 avec
一道 côte à côte
一道 en compagnie de
一部 une partie
一部 la plupart
一部分 une partie
一部分 la plupart
Figure 3-1 Dictionnaire produit
La sélection des dictionnaires français-chinois n’est pas facile, bien qu’il y ait
beaucoup de dictionnaires bilingues électroniques en ligne, il est difficile de trouver
un dictionnaire bien formé qui a suffisamment de données et un droit libre
d'utilisation. On choisit deux dictionnaires venant d’un projet franco-chinois
commencé par Chine Informations à partir de 2009, dans un objectif de donner libre
accès à la connaissance. Ces deux dictionnaires, l’un 123930 lignes et l’autre 25286
lignes, peuvent être téléchargés dans les sites suivants :
‐
http://www.chine-informations.com/chinois/open/CFDICT/
‐
http://abloz.com/huzheng/stardict-dic/zh_CN/
Ces deux dictionnaires sont sous des formats différents; afin de les transformer en
format cible, ils sont nécessairement analysés indépendamment.
3.2.1.1 Traitement du dictionnaire « cfdict.u8 »
Le premier dictionnaire « cfdict.u8 » est un fichier .u8 encodé en UTF-8 qui contient
toutes les entrées dans un seul format:
Traditionnel
Simplifié
[pin1 yin1] /traduction 1/traduction 2/...
64
‐
Traditionnel est le chinois traditionnel (繁体字), il représente un mot en
chinois qui est écrit de la manière traditionnelle.
‐
Simplifié est le chinois simplifié (简体字), un système d’écriture utilisé par
les chinois après l’année 1956.
‐
Pin yin est un système de romanisation (transcription phonétique en écriture
latine) du mandarin.
‐
Traduction est le mot en français qui véhicule le même sens que le mot en
chinois.
Les « simplifié » et « traduction » sont les éléments demandés dans le format cible,
l’extraction de ces éléments est basée sur une analyse de la structure de chaque ligne.
On peut trouver que, à l’exception d’un symbole « / » qui segmente des mots en
français dans l’élément de traduction, le délimiteur pour segmenter tous les éléments
de chaque entrée est des espaces. Mais l’espace est utilisé aussi pour segmenter dans
la partie de prononciation et la partie de la traduction française, des prononciations ou
des mots composés, par exemple :
一刀兩斷 一刀两断 [yi1 dao1 liang3 duan4] /rupture nette/résolution ferme de rompre
une relation/
Dans le cas d’entrée qui ne peut pas être découpée en quatre parties par l’espace, on
propose une méthode d’utilisation de "l'expression régulière". Une expression
régulière est en informatique une chaîne de caractères que l’on appelle parfois un
motif et qui décrit un ensemble de chaînes de caractères possibles selon une syntaxe
précise. Elles sont utilisées par les informaticiens dans l’édition et le contrôle de texte.
Par conséquent, on crée l’expression régulière ci-dessous pour répondre à chaque
entrée dans le dictionnaire cfdict.u8.
 « \A » représente le début de l’entrée
 « ^Z » représente la fin de l’entrée
 « (.+) (.+) (\[.+\]) /(.+) » représente quatre éléments de l’entrée et chaque
parenthèse répond à un élément.
Dans la script de programmation, l’idée d’analyse est :
65
Le programme analyse le dictionnaire français-chinois entrée par entrée, il compile
d’abord l’expression régulière ci-dessus par la commande :
Et puis il l’assortit à chaque entrée du dictionnaire par
Pour extraire les éléments demandés, il faut utiliser les commandes
66
Dès que deux éléments sont extraits, on peut commencer les nettoyages de mot et la
segmentation des multi-traductions :
‐
Nettoyage de mot
o
La fonction cleanMot() nettoie les contenus dans les parenthèses qui
sont des commentaires, des complémentaires de mots :
一聲 一声 [yi1 sheng1] /premier ton (en mandarin) (ton haut et plat)/un son/spécificatif : un
coup (de canon)/
萬國宮 万国宫 [Wan4 guo2 gong1] /Palais des Nations (Genève)/
三鮮 三鲜 [san1 xian1] /trois ingrédients frais (en cuisine)/
o
La fonction cleanSpMot() nettoie des explications qui sont les mots en
gras dans les exemples:
一聲 一声 [yi1 sheng1] /premier ton (en mandarin) (ton haut et plat)/un son/spécificatif : un
coup (de canon)/
三色之藍 三色之蓝 [san1 se4 zhi1 lan2] /Trois Couleurs : Bleu/
壁廂 壁厢 [bi4 xiang1] /côté/latéral : être à côté/à côté de/
‐
La segmentation des multi-traductions est d’utiliser la commande suivante
pour segmenter les éléments de traductions, s’ils contiennent plusieurs
traductions et délimitent par « / »
偏心眼 偏心眼 [pian1 xin1 yan3] /partialité/être partiel/
偏極化 偏极化 [pian1 ji2 hua4] /polarisation/polarisé/
偏離 偏离 [pian1 li2] /dévier/s'écarter/
A la fin, pour ces éléments nettoyés et segmentés, on utilise la commande ci-dessous
pour les reconstruire dans un nouveau dictionnaire en format cible.
3.2.1.2 Traitement du dictionnaire « cfdict.txt »
Le deuxième dictionnaire est un ficher de stardict au format binaire. Afin d’avoir un
fichier lisible, on utilise le logiciel « stardict-editor.exe » pour transformer le fichier
original vers un fichier de texte brut (.txt). Le Stardict-Editor est un logiciel d’éditeur
67
dédié pour éditer le dictionnaire de Stardict et transformer son format entre
dictionnaire et texte.
Le site de téléchargement : http://code.google.com/p/stardictproject/
Petit manuel de stardict-editor pour décompiler un dictionnaire de Stardict:
 Télécharger et installer le Stardict.
 Trouver et ouvrir stardict-editor.exe dans le même dossier de Stardict.
 Sélectionner l’onglet « DeCompile/Verify »
 Cliquer le bouton « Browse » et sélectionner le fichier .ifo dans le dossier de
dictionnaire. Pour décompiler, il faut un fichier .dict qui existe dans le même
dossier. Mais, il n’existe pas normalement ce fichier dans le dictionnaire
téléchargé, on fait donc un petit travail pour obtenir ce fichier :
 Décompression du dictionnaire téléchargé.
 Renommer le fichier .dict.dz vers .dict.gz
 Décompression le fichier .dict.gz, on obtient le fichier .dict
 Cliquer le bouton « Decompile » pour obtenir un fichier .txt.
Le fichier cfdict.txt obtenu est encodé au format UTF-8, il contient des entrées dans
les formats suivants :
‐ Simplifié
pin1yin1 catégorie\ntraduction1 / traduction2 / …
‐ Simplifié
pin1yin1 catégorie\n1. traduction1 \n2. traduction2 / traduction3 …
‐ Simplifié
pin1yin1 catégorie1\ntraduction1\n\npin2yin2 catégorie2\ntraduction2 /
traduction3 …
‐ Simplifié
pin1yin1 catégorie\ntraduction1 / traduction2 /\n\npin2yin2
catégorie\ntraduction1 / traduction2 / …
Chaque entrée du dictionnaire est sous un des quatre formats suivants. Les symboles:
\t, \n\n, (\n, \n1, \n2 …), / sont des délimiteurs pour segmenter régulièrement des
éléments de chaque entrée, et ils ont aussi un ordre de priorité, « \t » > « \n\n » > « \n,
\n1, \n2 … » > « / » :
‐
« \t » segmente la partie gauche qui est l’élément en chinois et la partie
droite qui contient des éléments : Pinyin, catégorie et traduction.
‐
« \n\n » segmente la partie droite quand le mot en chinois est un polyphone
qui peut être traduit par des mots français véhiculant des sens différents.
‐
« \n, \n1, \n2 … » segmente l’élément de traduction avec deux autres
éléments : pinyin et catégorie. Il segmente aussi toutes les traductions
possibles.
68
« / » segmente seulement les traductions.
‐
Deux éléments demandés sont extraits par une suite d’analyses. Ces analyses
dépendent de l’ordre de priorité. La segmentation de « \t » permet d’obtenir l’élément
en chinois, mais l’élément de traduction (français) est obtenu après l’analyse du
résultat du segment de « \n, \n1, \2 … », par exemple :
一发千钧
yīfāqiānjūn phrase\nun danger imminent / cela ne tient qu'à un cheveu
1. Cette entrée est segmentée d’abord par le « \t » pour obtenir deux parties :
一发千钧
2.
yīfāqiānjūn phrase\nun danger imminent / cela ne tient qu'à un cheveu
Et puis, la partie droite est segmentée par « \n, \n1, \2 … » : parce que « \n\n
» n’existe pas, le résultat est :
[(yīfāqiānjūn phrase), (un danger imminent / cela ne tient qu'à un cheveu)]
3. Dans le cas où « \n\n » existe, par rapport l’ordre de priorité, on l'analyse
avant « \n, \n1, \2 … » comme :
不幸
búxìng n.\nmalheur\n\nbùxìng n.\nmalheur / infortune\n\nbúxìng n.\nmalheur
不幸 búxìng n.\nmalheur bùxìng n.\nmalheur / infortune búxìng n.\nmalheur
Après, chaque élément sauf l’élément en chinois est analysé comme l’étape 2.
4. On ignore les éléments de pinyin et catégorie, on utilise « \ » pour segmenter
l’élément de traduction, comme :
un danger imminent
cela ne tient qu'à un cheveu
5. A la fin, on reconstruit tous ces éléments dans un dictionnaire cible comme
ce qui est fait dans l’analyse de « cfdict.u8 ».
3.2.1.3 Combinaisons deux dictionnaires
Après les traitements de ces deux dictionnaires, nous avons obtenu deux nouveaux
dictionnaires dans un format commun. Ensuite, on combine ces deux dictionnaires.
Afin d’éviter les doublons dans le dictionnaire combiné, on utilise la fonction set()
dans le langage Python pour filtrer les doublons, cette fonction est une méthode
simple et plus efficace. La combinaison de deux dictionnaires est juste dic1+dic2. Le
script est la fonction extraireMotfrzh() dans le transf-dict.py.
69
Le résultat est obtenu après avoir exécuté le script « transf-dict.py » par la ligne de
commande ci-dessous. Un nouveau dictionnaire, nommé « frzhdic.dict » est créé dans
le dossier « DICT ». L’analyse du cfdict.txt a duré 2.63s et l’analyse du cfdict.u8 a
duré 10.19s, le travail a duré en total 14.07s et un dictionnaire contenant 190514
lignes a été créé.
3.2.2 Lexiquedesformesfléchiesdufrançais(lefff)
Le Lexique des formes fléchies du français, ou Lefff, est un lexique électronique de la
langue française, librement disponible. C'est un lexique morphologique et syntaxique:
il associe à chaque forme fléchie des informations morphologiques (lemme, étiquette
morphologique) et syntaxiques (cadre de sous-catégorisation, autres propriétés
syntaxiques). Il est destiné à être directement utilisé dans des applications de
traitement automatique des langues, en essayant toutefois d’être indépendant des
choix théoriques de ses utilisateurs, et en particulier des théories syntaxiques.
Pour lier le texte français et le dictionnaire bilingue, on utilise le point connecté qui
représente des mots de mêmes formes qui se trouvent des deux côtés. La majorité de
mots dans le texte français sont fléchis (conjugaison et déclinaison), mais celles dans
le dictionnaire bilingues sont presque tous sous forme non-fléchie (forme de base
comme l'infinitif, etc). Par conséquent, il faut pouvoir lemmatiser très vite tous les
mots qu'on rencontre. Afin d'atteindre cet objectif, il faut une représentation
arborescente du lefff. Voici en graphe la représentation arborescente (voir Figure 3-2).
Afin d'éviter de devoir recharger à chaque utilisation cette structure arborescente, la
représentation en Python est stockée en tant qu'objet Python grâce au module marshal,
qui permet d'écrire et récupérer un objet python. Par exemple, la représentation
arborescente des mots ce, cette et ces, est la suivante :
70
Figure 3-2 Structure d'arbre du dictionnaire lefff
La version du lefff prise dans ce travail comporte 534498 entrées qui correspondantes
à environ 110.000 lemmes distincts.
achromatisai
100
v
achromatiser_____1 Default
[pred='achromatiser_____1<Suj:cln|scompl|sinf|sn,Obj:(cla|sn)>',@pers,cat=v,@J1s]
J1s
%actif
achromatisaient
100
v
achromatiser_____1 Default
[pred='achromatiser_____1<Suj:cln|scompl|sinf|sn,Obj:(cla|sn)>',@pers,cat=v,@I3p]
I3p
%actif
Mégisseront 100 v [pred='mégisser_____1<Suj:cln|scompl|sinf|sn,Obj:(cla|sn)>',@pers,cat=v,@F3p] mégisser_____1 Default
F3p %actif
Les éléments demandés pour créer le lefff.marshall sont les tokens dans la première
partie et les lemmas qui sont les mots après « pred= » et avant « ______ ». Le script
qui extrait ces éléments utilise d’abord « \t » pour séparer chaque entrée. Il rend une
liste contenant tous les éléments d’entrée.
Mégisseront
100
v
[pred='mégisser_____1<Suj:cln|scompl|sinf|s
n,Obj:(cla|sn)>',@pers,cat=v,@F3p]
mégisser_____1
Default
F3p
%actif
Le 1er élément est le token. Et le lemma est dans le 3ème élément, pour l’extraire, il
faut passer une analyse par la commande suivante :
‐
Prendre le troisième élément, s’il commence par « [pred=' ».
eg : [pred='mégisser_____1<Suj:cln
‐
Séparer l’élément qui suit le « [pred=' » par « ___ » pour créer une nouvelle liste,
et prendre le 1er élément de la liste, si ce dernier contient « _ », donc le filtrer.
ex : mégisser_____1<Suj:cln
(mégisser, 1<Suj:cln)
mégisser
A la fin, tous les éléments extraits sont stockés dans un dictionnaire binaire (.marshall)
par les commandes :
dic={}
for els, pred in listeEntree : #prendre le token et lemma dans els et pred
d = dic
for lett in els: #lire chaque fois une lettre du token
d[lett]=d.get(lett,({},{})) #si dans le dictionnaire d, on trouve la clé « lett », on rend
sa valeur à d[lett], sinon on rend un nouvelle valeur
71
({},{}) à d[lett].
d,e=d[lett] #on rend la clé au d, la valeur à e
e[pred]= None #Donner le lemma comme la clé et « None » comme la valeur au dictionnaire
3.2.3 Annotationparlafonctiontag()
La tag() est une fonction pour annoter le texte français. Le texte annoté a pour but
d’indexer les positions des mots. A l’aide de lefff.marshall, le texte annoté peut
donner aussi les lemmas des mots.
Le texte annoté est sous un format comme le montre l’exemple ci-dessous :
Tous les éléments sont stockés dans une liste, et chaque élément de la liste contient 6
parties :
o début de token, le nombre de mot avant le token.
o fin de token, le nombre de mot après le token.
o début de caractère, le nombre de caractère avant le token(espace
compris).
o fin de caractère, le nombre de caractère après le token.
o token, le mot original dans le texte.
o lemma, le mot qui vient de token lemmatisé (ex : vais > aller).
Le processus d’annotation est comme suit :
72
Il y a un cas particulier pour le "mot composé", comme par exemple pour « du moins
»:
Ce mot composé se trouve dans le dictionnaire lefff.marshall, il est donc : annoté
ensemble bien qu'il soit aussi annoté séparément comme des mots simples.
3.2.4 Lemmatisationdudictionnairefrzh.dict
Nous avons indiqué dans la section ci-dessus, que les dictionnaires « lefff.marshall »
et « frzh.dict » produisent un nouveau dictionnaire « frzh.marshall » pour chercher les
bonnes paires de mots comme les ancres d’alignement. Il contient non seulement les
mots originaux dans le frzh.dict et il contient aussi les lemmas des mots venant de
lefff.marshall. Par conséquent, le nouveau dictionnaire est plus large. En considérant
la taille du dictionnaire, et que le dictionnaire sera réutilisé pour plusieurs textes, le
dictionnaire doit être transformé dans un format simple et facile à lire. Nous
73
choisissons aussi de stocker le dictionnaire en format marshall comme lefff.marshall.
La structure est une représentation arborescente comme lefff.marshall, chaque point
de branche étant le mot au lieu de la lettre dans le lefff.marshall:
Le mot simple est comme fr-mot1, le mot composé est comme « fr-mot1 fr-mot2 » ou
« fr-mot1 fr-mot2 fr-mot3 »
Le processus d’analyse est le suivant :
Ci-dessous, un exemple d’une transformation d’une partie du dictionnaire frzh.dict :
bonjour
bonjour
viens
du moins
你好
早上好
过来
至少
Après avoir annoté par la fonction tag() , le mot « viens » est lemmatisé vers « venir ».
On reconstruit le dictionnaire avec tous les tokens et lemmas comme :
bonjour
bonjour
viens
venir
du moins
你好
早上好
过来
过来
至少
A la fin, tous les mots en français et les traductions sont stockés dans le dictionnaire
qui a une structure arborescente :
74
Les commandes pour créer la structure du dictionnaire sont:
dic = {}
for fr, zh in listeEntree :
#Créer le dictionnaire de la structure d’arbre
d=dic
for tok in fr.split(“ ”) : #lire chaque fois un mot simple, si c’est le mot composé
d[tok]=d.get(tok,({},{})) #si dans le dictionnaire d, on trouve la clé « tok », on
rend sa valeur à d[tok], sinon on rend un nouvelle
valeur ({},{}) à d[tok]
d,e=d[tok] #on rend la clé au d, la valeur à e
e[zh]= None #Donner le lemma comme la clé et « None » comme la valeur au dictionnaire e
3.3 Trouverdesancresd’alignement
Après une suite de prétraitements, on a deux fichiers pour extraction des ancres dans
le corpus bilingue : le dictionnaire lemmatisé et le texte français lemmatisé du corpus
bilingue.
L’extraction des ancres de corpus bilingue est illustrée comme suit :
75
 Extraction dans le texte français de tous les mots ou expressions françaises qui
sont dans le dictionnaire bilingue. Le résultat est sous un format de dictionnaire
de Python « transdico fr »:
Chaque élément du dictionnaire contient deux parties, la traduction du mot
français trouvé et une liste des positions où se trouve le mot français. Ensuite, on
crée une liste A pour stocker toutes les traductions :
 Extraction dans le texte chinois de tous les mots chinois qui sont dans la liste A.
Le résultat est représenté comme un dictionnaire de Python « transdico zh ».
Chaque élément du dictionnaire contient deux parties comme « transdico fr », le
mot chinois trouvé et une liste des positions où se trouve le mot chinois dans le
texte chinois.
Jusqu’à présent, on peut trouver toutes les ancres par « transdico fr » et « transdico zh
». On garde ces deux dictionnaires pour l’étape suivante étant donné qu’on a besoin
d’analyser ces données indépendamment. On va le préciser dans la section suivante.
76
3.4 Créer une matrice et calculer la distance de chaque paire de
paragraphes.
Une fois que « transdico fr » et « transdico zh » sont créés, on commence à calculer
les distances des paires de paragraphes :
A. Créer une matrice, la taille de matrice dépend du nombre de paragraphes
des textes français et chinois. La matrice est pré-remplie par un.
B. Remplir la distance dans la matrice.
77
3.5 Trouverlemeilleuralignement.
A la base des distances de toutes les paires de paragraphes, on trouve le meilleur
alignement par un algorithme de programmation dynamique. Dans la figure suivante,
il y a 4 matrices: la première est la matrice de la distance, la 2ème matrice est la
matrice d’algorithme, la 3ème matrice est une matrice pour enregistrer les sens de
chaque cellule, la dernière est une matrice pour montrer le chemin d’alignement.
Dans la programmation, la deuxième matrice est pré-remplie par 999 au lieu d’un
nombre allant vers l'infini ; l'origine est (0,0) rempli par 0, et puis la valeur de la
cellule (0+1, 0+1) dépend de trois cellules : (0,0), (1,0) et (0,1). Il prend la valeur
minimum de ces trois cellules et plus avec la valeur dans la première matrice. La
troisième matrice enregistre la sélection entre trois cellules par 0, 1 et -1 :
‐
Si la valeur minimum était le M2(x,y), la valeur de M3(x,y) = 0
‐
Si la valeur minimum était le M2(x,y+1), la valeur de M3(x,y) = 1
‐
Si la valeur minimum était le M2(x+1, y), la valeur de M3(x,y) = -1.
Le script a pour but de créer les 2ème et 3ème matrices.
78
lines = matrix.shape[0] #prend le nombre de colonnes de la 1er matrice
colons = matrix.shape[1] #prend le nombre de rangées de la 1er matrice
warp = ones( (lines+1,colons+1), dtype=float )*999 #créer le 2ème matrice
directions = zeros( (lines,colons), dtype=int ) #créer le 3ème matrice
warp[0,0]=0
for i in xrange(lines):
for j in xrange(colons):
#trouver la valeur minimum de trois cellules
mini = min(warp[i,j+1], warp[i+1,j], warp[i,j])
warp[i+1][j+1]=matrix[i,j]+mini #remplir le 2ème matrice
#remplir le 3ème matrice
if mini == warp[i,j]:
directions[i,j] = 0
elif mini == warp[i,j+1]:
directions[i,j] = 1
else :
directions[i,j] = -1
Une fois qu’on a la troisième matrice, on crée la quatrième matrice pré-remplie par
zéro, et puis on remplit cette matrice grâce à la 3ème matrice pour trouver le chemin
d’alignement par 0 et 1. Le point d''origne est la dernière cellule. Le processus est:
‐
‐
‐
‐
Remplir d’abord le dernier point par 1.
Si la valeur de troisième matrice était 0, on va aller au point (x-1, y-1), et le rempli
par 1.
Si la valeur de troisième matrice était 1, on va aller au point (x-1, y), et le rempli par
1.
Si la valeur de troisième matrice était -1, on va aller au point (x, y-1), et le rempli par
1.
Le script a pour but de trouver le chemin d’alignement par 0 et 1 :
lines = matrix.shape[0] #prend le nombre de colonnes de la 1er matrice
colons = matrix.shape[1] #prend le nombre de rangées de la 1er matrice
alignment = zeros( (lines,colons), dtype=int ) #créer le 4ème matrice
#remplir la matrice
f,g=lines-1,colons-1
while f>=0 or g>=0:
alignment[f,g]=1
if directions[f,g]==0:
f-=1
g-=1
elif directions[f,g]==1:
f-=1
else:
g-=1
Le chemin construit par 1 dans la quatrième matrice est le chemin d’alignement.
3.6 MoyendeprogrammersurPython
Python fournit un interpréteur Python (commande), on peut exécuter directement le
script de Python. Par exemple :
79
Grâce à cet inter préteur Python, on peut gagner du temps, parce que le dictionnaire
français/chinois est énorme : chaque chargement prend beaucoup de temps (environ
30s). En utilisant cette méthode, on peut ne charger qu’une seule fois le dictionnaire ;
ensuite, on peut tester, modifier l’algorithme d’alignement avec ce dictionnaire en
mémoire.
3.7 Sortiederésultat
La sortie de résultat dans cette programmation est distingué en trois mode selon les
usages différents:
1. Mode Debug, il crée trois fichiers:
Matrice HTML, selon différente demande, si on donne un fichier alignement
manuel, la cellule rouge représente que les alignements automatique et manuel sont
identiques. la cellule bleu représente l'alignement automatique, mais la cellule jaune
représente l'alignement manuel.
80
Si on ne donne pas de fichier d'alignement manuel, toutes les cellules
représentent en bleu (alignement automatique).
2. Mode Texte brut, il sort deux fichiers, un fichier français et un autre fichier chinois,
alignés. Dans ces fichiers, si les paragraphes sont alignés en bloques, ils sont donc
combiné.
3. Mode MySQL, il sert à saisir les données dans la base de données de MySQL pour
l'application en ligne. La structure de la base de donné est simple:
81
Un tableux contient trois élément:
a) id: identification de chaque paire de phrase
b) fr_ph: phrase français
c) zh_ph: phrase chinois
Chaque ligne est construite par 1 "id", 1 "fr_ph" et 1 "zh_ph". "fr_ph" et "zh_ph" est
donc une paire de phrase obtenu de l'alignement.
3.8 Miseenligne
La mise en ligne est le dernier tâche dans ce projet, notre objectif est pour les gens qui
en a besoin. Dans chaque recherche, on sort une liste de paires de phrases qui contient
de mot clé, comme suite:
82
Pour mettre l'application en ligne, on a besoin trois chose pour construire un system:
Pour réaliser ceci, il y en a beaucoup de moyen
‐
‐
‐
Apache+MySQl+PHP
Apache+MySQL+Python
etc.
On utilise dans ce travail la structure "Apache, MySQL, Python et Django".
‐
‐
‐
Apache: Serveur de website
MySQL: Base de donnée
Django: Framwork de site, écirt par Python
Dans notre application, la fonction principale jusqu'à la termine de ce travail est, que
le moteur de recherche prend un mot ou une expression français(e) comme le mot clé,
l'application va le(a) chercher dans la base de données, s'il a trouvé, il retourne la liste
de paire de phrase alignée, et coloré le mot clé en rouge.
Il y a des travaux à faire dans le futur, par exemple:
- Fonction de recherche par le mot chinois.
- Fonction qui coloré en deux côté les mots
- S'il y aura beaucoup de paire de phrase, il faut un filtrage de doublon.
- etc.
83
4. Conclusion
Au cours du travail de ce mémoire, on a montré les différences entre deux systèmes
d’écriture : françaises et chinoises. A cause de ces différences, l'alignement de corpus
bilingue français/chinois est différent que celui entre deux systèmes d'écriture
occidentaux. Par conséquence, pour l'alignement le corpus bilingue français/chinois,
on a fait un prétraitement de texte : normalisation le texte en fraction. Dans les
conditions limites : notion de différents termes, suppression de note de bas de page,
non-compte d’inversion, suppression et insertion de segment. Nous comparons des
résultats de cinq différentes méthodes, on a confirmé notre méthode, alignement dans
la matrice par des ancres, peut fonctionner pour l'alignement de corpus bilingue
français/chinois, sans segmentation du texte chinois, elle a obtenu un résultat ayant la
qualité jusqu’à 96%. On a trouvé aussi que la stratégie d'alignement de paragraphe à
phrase fonctionne bien dans deux langues éloignées.
Dans le troisième chapitre, on a montré le processus de programmation en détail. On a
créé un dictionnaire bilingue franco-chinois. La structure d'arborescence du fichier
marshal sert à économiser la taille de stockage et le temps de chargement. Pour la
mise en ligne, on a présenté aussi à la fin notre structure de serveur Python.
Nous terminons ce travail, puisque de nombre de questions ont été soulevées. On
désire dans le travail futur pour répondre ces questions, et continuer tester dans les
conditions moins limites. On avait obtenu des paires de paragraphe, de phrase alignée,
ces paires alignées peuvent servir à des autres alignements, par exemple, chercher des
paires de phrase le plus fréquentes, et les utiliser comme une ancre de phrase dans un
alignement de paragraphe.
84
Bibliographie
A Gelbukh & G Sidorov. 2006. Alignment of Paragraphs in Bilingual Texts using
Bilingual Dictionaries and Dynamic Programming.
Gale, W. A. & Church, K. W. 1993. A program for aligning sentences in bilingual
corpora.
Jörg TIEDEMANN. 2011. Bitext Alignment.
Jody Foo. 2009 An overview of bitext alignment algorithms.
Kim GERDES. 2010. POVERTY DRIVEN BILINGUAL ALIGNMENT.
Miao Jun. 2012. Approches textométriques de la notion de style du traducteur.
85
Annexe
LescriptPythondeproduireledictionnairebilingue
#! /usr/bin/env python
# -*- coding: UTF-8 -*#---------------------------------------------------------------------------------------------------------------------#Ce script sert à un projet d'alignement des corpus bilingue entre français et chinois.
#Auteur: Kim Gerdes
#
Kun JIN
#Lieu: Université Sorbonne nouvelle à Paris, France
#Date: 29-08-2012
#Description:
#C'est un script pour transformer et combiner deux dictionnaire cfdict.u8 et cfdict.txt trouvé dans
les sites suivants:
#
cfdict.u8 - http://www.chine-informations.com/chinois/open/CFDICT/
#
cfdict.txt - http://abloz.com/huzheng/stardict-dic/zh_CN/
#Pour sortie un résultat en format:
#
simplifié
traduction
#Manuel:
#
1. Mettre ce script avec ces deux dictionnaire dans un même dossier
#
2. Exécuter la ligne de commande:
#
python transf-dict.py
#---------------------------------------------------------------------------------------------------------------------######################
#Importer des modules#
######################
import codecs,re,time
###############################################################################
########
#Prédéfinir la variable verbose qui décider afficher ou non les informations de retour#
#Prédéfinir la variable doublon pour activer ou non la filtrage de doublon
#
###############################################################################
########
verbose=False
# verbose=True
# doublon=False
doublon=True
#########################
#Prédéfinir les dossiers#
#########################
dossierDict="../DICT/"
dossierRes="../RESULTAT/"
dossierScr="../SCRIPT/"
##################
#Nettoyage de mot#
86
##################
def cleanMot(mot):
mot = mot.lower()
mot = mot.strip()
mot = re.sub("\[.+?\]",r"",mot)
mot = re.sub("\(.+?\)",r"",mot)
mot = re.sub(u"(.+? )",r"",mot)
mot = re.sub("\A[ \t\.]*",r"",mot) # start with letter no new line, no blank space, no point
return mot
####################################
#Analyse le dictionnaire cfdict.txt#
####################################
def getDict1(inf=dossierDict+"cfdict.txt"):
#Le dictionnaire est bien formé, contenant 5 symboles:
#
1. Tabulation "\t", le segmenteur entre la partie gauche (le chinois) et la partie droite
(pinyin, catégorie et traductions françaises)
#
2. \n\n, segmente la partie droit par les différents prononciations(pinyin).
#
定时炸弹
dīngshíàndàn n.d.\nbombe à retardement\n\ndìngshízhàdàn
n.\nbombe à retardement\n\ndīngshíàndàn n.d.\nbombe à retardement
#
3."\n1.","\n2.", signifient le nombre de traduction synonyme.
#
宗
#
4. "\n", segmente la partie droite entre la partie pinying-catégorie et la partie traduction
#
宗教 zōngjiào n.\nreligion
#
5. "/", segmente la partie traduction entre les traductions différentes
#
官
guān n.\nfonctionnaire / officier / mandarin
#Notre analyse sur ce dictionnaire est basé sur ces symboles, il faut l'analyser par l'ordre de ces
symboles indiqués ce-dessus.
#-------------------#Compter le temps passé sur cette analyse
ti = time.time()
#Rendre une information, ex: si verbose est True, affichier le7 texte
if verbose: print "Opening the dictionary:", inf
#Ouvrir le fichier en décodant "UTF-8"
f=codecs.open(inf,"r","utf-8")
frlist=[]
frlists=[]
#Compiler un expression, pour analyser la ligne en format:
#不含糊
bùhánhu v.\n1. sans ambiguité / explicite\n2. peu ordinaire / vraiment
bon
exp=re.compile("\\\\n[1-9]*")
i=0
lists=[]
#Lecture du texte ligne par ligne
for line in f:
i+=1
zhmots=[]
frmots=[]
#____Segmenter chaque ligne en deux parties: chinoise et française, par leur
segmenteur, la tabulation "\t".#
zh,fr=line.strip().split("\t")
#____Segmenter la partie chinoise par le segmenteur, la virgule ",", et créer une
liste.
if u"," in zh:
zhmots=zh.split(u",")
else:
87
zhmots=[zh] #en cas qu'il existe un seul mot chinois.
#____Segmenter la partie droite par "\n\n".
if "\\n\\n" in fr:
#
if verbose: print "\\n\\n trouvé_____", fr
frlists=fr.split("\\n\\n")
else:
frlists=[fr]
for frlist in frlists:
#____Segmenter la partie droite par "\n \n1 ou \n2 etc.", et extraire la
partie de traduction par [1:]
frlist=exp.split(frlist)[1:]
#Combiner en une suite de caractère par "/", et puis segmenter par "/", ex:
#审
shěn v.\n1. examiner / vérifier\n2. juger\n3. interroger
fr1 = "/".join(frlist)
frlists=fr1.split("/")
for wfr in frlists:
wfr = cleanMot(wfr) #Nettoyage de mot, non parathèses, non
nouvelle ligne, non espace, non point
#Une fois la nettoyage téminéé, c'est possible qu'il reste plus
rien.
if not wfr: continue
#en cas de:
#护养 hùyǎng v.\n1. cultiver, soigner / abriter\n2. maintenir
#segmente par "," la partie de traduction.
if u"," in wfr:
if verbose: print "Ponctuation , trouvé_____", wfr
wfrs = wfr.split(u",")
else:
wfrs=[wfr]
frmots+=wfrs
#Stocker le résultat dans une liste formé.
for a in zhmots:
a = cleanMot(a)
if not a: continue
for b in frmots:
b = cleanMot(b)
if not b: continue
if doublon:lists+=[b+"\t"+a]
else:lists+=[[b,a]]
print "____",time.time()-ti,"seconds for",i,"entries from dico:",inf
return lists
###################################
#Analyse le dictionnaire cfdict.u8#
###################################
def getDict2(inf=dossierDict+"cfdict.u8"):
#Le dictionnaire est sous format:
#
Traditionnel Simplifié [pin1 yin1] /traduction 1/traduction 2/...
#Chaque ligne contient 4 parties ci-dessus, nous utilisons une expression régulière
#pour matcher et prendre les partie 2 et 4, puis analyer ces deux parties pour obtenir un résultat.
#-------------------#Compter le temps passé sur cette analyse
ti = time.time()
if verbose: print "Opening the dictionary:", inf
#Ouvrir le fichier en décodant "UTF-8"
f=codecs.open(inf,"r","utf-8")
88
i=0
lists=[]
#Créer une expression régulière pour matcher la ligne.
p=re.compile("\A(.+) (.+) (\[.+\]) /(.+)/\Z")
for line in f:
#
if i == 5000:break
i+=1
zhmots=[]
frmots=[]
line=line.strip()
m=p.match(line)
zh=m.group(2) #Prendre le 2ème partie de la ligne
fr=m.group(4) #Prendre le 4ème partie de la ligne
zhmots=[zh]
fr=cleanMot(fr) #Nettoyage de mot, non parathèses, non nouvelle ligne, non
espace, non point
if "/" in fr: #segmenter la 4ème partie par le segmenteur "/"
wfrs=fr.split("/")
else:
wfrs=[fr]
frmots=wfrs
#Stocker le résultat dans une liste formée
for a in zhmots:
a = cleanMot(a) #Nettoyage de mot, non parathèses, non nouvelle ligne,
non espace, non point
if not a: continue
for b in frmots:
b = cleanMot(b)
if not b: continue
if doublon:lists+=[b+"\t"+a]
else:lists+=[[b,a]]
print "____",time.time()-ti,"seconds for",i,"entries from dico:",inf
return lists
##################################################
#Sortir le résultat dans le fichier "frzh.dict" #
##################################################
def extraireMotfrzh(ouf=dossierDict+"frzh.dict"):
tii=time.time()
dic1=getDict1()
dic2=getDict2()
dic=dic1+dic2
f=codecs.open(ouf,"w","utf-8")
i=0
if doublon:
#si l'option doublon active, filtrer les doublons
for a in sorted(list(set(dic))):
i+=1
f.write(a+"\n")
f.close()
else:
for a,b in sorted(dic):
i+=1
f.write(a+"\t"+b+"\n")
f.close()
print "____Work finished, taken",time.time()-tii,"seconds for",i,"entries"
#-----------Control------------
89
if __name__ == "__main__":
extraireMotfrzh()
LescriptPythond’extractiondesancres
# -*- coding: UTF-8 -*import marshal, time, re, codecs, sys, unicodedata
from collections import OrderedDict
from configure import *
#ON/OFF pour rendre des informations d'analyse
verbose = False
#verbose = True
#Variable globale
renotword=re.compile("\W",re.U) #matche aucun de caractère non-alphanumerique; équivalant au
set [^a-zA-Z0-9_], re.U => re.UNICODE
renotwords=re.compile("\W+",re.U+re.I+re.M)
reword=re.compile("\w+$",re.U)
#-----------Créer les dictionnaires--------------def picklefff(inf=dossierDict+"lefff.txt",outf=dossierDict+"lefff.marshall"):
"""
donner le fichier lefff.txt, la ligne du fichier contient par exemple:
mégisseront
100
v
[pred='mégisser_____1<Suj:cln|scompl|sinf|sn,Obj:(cla|sn)>',@pers,cat=v,@F3p]
mégisser_____1 Default F3p
%actif
Chercher tous les mots qui a un lemma (après [pred=') différent de token, par
conséquence dans l'exemple:
token = mégisseront
lemma = mégisser
mettre-les dans un dictionnaire avec une structure d'arbre:
{"m":({"é":({"g":({"i":({"s":({"s":({"e":({"r":({"o":({"n":({"t":({}:{mégisser:None}),{})
,{}),{}),{}),{}),{}),{}),{}),{}),{})}
dumps le dictionaire dans le outfile
"""
ti = time.time()
dic = {}
count = 0
syls=0
pred=""
els=["",""]
f = codecs.open(inf,"r","utf-8")
for li in f :
# example:
# mégisseront 100
v
[pred='mégisser_____1<Suj:cln|scompl|sinf|sn,Obj:(cla|sn)>',@pers,cat=v,@F3p]
mégisser_____1 Default F3p
%actif
count += 1
if not count%10000: print count,li
els = li.lower().split("\t") # lower !!!!!!
#filtrage: cours qui a comme lemme : donner cours etc...
if els[2] in ["cf","cfi","pri","prel"]:
continue
90
if
els[3].startswith("[pred='"):pred=els[3][7:].split("__")[0].replace("_","
")
#extraire le lemma
else: continue
if els[2] in ["poncts","ponctw","parentf","parento","ilimp","epsilon"] or
els[2].startswith("cl") or els[2].endswith(";"):continue
if pred!=els[0] or renotword.search(pred):
# Garder seulement les lemmas qui sont différents de token ou
expressions (mots composé) !
d=dic
for lett in els[0]: #.lower()
#Chaque lettre d'entrée (la form de mot)
d[lett]=d.get(lett,({},{}))
d,e=d[lett]
e[pred]= None
# utiliser un dictionaire au lieu d'une liste, dans ce cas, un token peut
avoir des preds différents, mais un seul de chaque pred.
# On ne garde pas de catégorie.
print "____",time.time()-ti,"seconds pour",count,"entrées"
print "Dump le dictionaire dans",outf,"..."
g = open(outf,"wb")
marshal.dump(dic, g)
g.close()
print "____",time.time()-ti,"seconds"
return dic
def picklbilingual(lefffdic=dossierDict+"lefff.marshall", inf=dossierDict+"frzh.dict",outf=False):
"""
donner des entrées:
crotte 屎
crotte 粪
certificat autorisant la détention 拘留证
mettre-les dans un dictionaire d'arbre par token (différent de picklefff:lettre)
dump dictionaire dans le outfile
"""
ti = time.time()
dic = {}
count = 0
f = codecs.open(inf,"r","utf-8")
for li in f:
els=li.strip().split("\t")
if len(els)==2:
fr,zh=els
ts = tag(fr.strip().lower(),lefffdic)
count += 1
if not count%10000: print count,li
#ts a l'air quelque chose come: [(0, 1, 0, 2, u'du', {}), (0, 2, 0, 8, u'du
moins', {u'du moins': None}), (1, 2, 2, 8, u'moins', {}), (3, 4, 9, 13, u'ils', {})]
ds=[dic]
for t in ts: # pour chaque mot dans le ts
if t[1]-t[0]!=1:continue # garder seulement le
ls = set([t[4]] + t[5].keys()) # le token + le lemmas
newds,es=[],[]
for d in ds:
for tok in ls:
d[tok]=d.get(tok,({},{}))
91
nextd,e=d[tok]
newds+=[nextd]
es+=[e]
ds=newds
for e in es:
e[zh]= None
print "____",time.time()-ti,"seconds pour",count,"entrées"
if outf==True:
outfile=dossierDict+"frzh.marshall"
print "dump le dictionaire dans",outfile,"..."
g = open(outfile,"wb")
marshal.dump(dic, g)
g.close()
print "____",time.time()-ti,"seconds"
return dic
#-------------Fonction de tag--------------------def tag(text,dic,timing=False):
"""
prendre un texte et un dictionnaire
Donner tous les tags (=lemmas) possibles pour chaque mot ou suite de mots
- Effacer d'abord le texte: pas de espace double, ni nouvelles lignes, ...
- Puis chercher tous les symboles
bouger les tokpos dans chaque \W, donner lemma vide si tag==lemma ou (multitoken) mots composés
- rendre annot, une liste comme :
[(0, 1, 0, 2, u'du', {}), (0, 2, 0, 8, u'du moins', {u'du moins': None}), (1, 2, 2, 8, u'moins',
{}), (3, 4, 9, 13, u'ils', {})]
chaque élément:
token début
token fin
char début
char fin
token
lemma
"""
if timing:ti = time.time()
annot=[]
text = re.sub(r"[\r\t\n ]+"," ",text.lower()).strip()
tokpos=0
lastwasletter=True
pieces=[(tokpos,0,"",dic,{})] # position de début, index de lettre, string, dictionoaire
utilisé, finposition dictionnaire (contient des lemmas comme keys)
for i,symb in enumerate(text+" "):
newpieces=[]
if reword.match(symb): # le symbole est une lettre
for (t,j,w,d,e) in pieces:
d,e=d.get(symb,({},{})) # chercher le symb dans le
dictionnaire actuel, garder le résultat: continuation dic, finpos dic
newpieces+=[(t,j,w+symb,d,e)]
lastwasletter=True
92
else: # le symbol n'est pas de lettre
if lastwasletter:tokpos+=1
for (t,j,w,d,e) in pieces:
# if e!=0: last symb wasn't already non-letter,
# if the word is known or is a simple token (=only contains
letters)
# (because we don't want unknown groups of words)
# we put it in the annotations
x=d.get(symb,None) # see if we can continue with a non letter
if e!=0 and (e or reword.match(w)) :
if not x or not x[1]: # this avoids double entries for d'
etc
#print "ajoute annot",t,tokpos,w,e
annot += [ (t,tokpos,j,i,w,e) ]
if x: # if we found a multiword expression:
# print "multiword starts",x[1]
newpieces+=[(t,j,w+symb,x[0],x[1])]
if x[1]:
#print x[1]
annot += [ (t,tokpos,j,i,w,x[1]) ]
lastwasletter=False
#print newpieces
newpieces += [(tokpos,i,"",dic,0)] # we start over with the original
dictionary
#print "newpieces",[(t,j,w,e) for (t,j,w,d,e) in newpieces]
pieces = newpieces
if timing:
sec = time.time()-ti
print "____*******",sec,"seconds"
print 1000000*sec/text.count(" "),"seconds per 1000000 words"
print annot
print "____*******"
# print annot,"annot"
return annot
def chargerdict(picklefile):
print "Lire le dictionnaire",picklefile
ti = time.time()
g = open(picklefile,"rb")
dic = marshal.load(g)
print "____",time.time()-ti,"seconds"
return dic
#-----------------Extraction des ancres-----------------------------transtable
=
dict((i,u"
")
for
unicodedata.category(unichr(i)).startswith('P'))
for c in u"|+?*":transtable[ord (c)]=u" "
i
in
xrange(sys.maxunicode)
if
res=re.compile(ur"\s+",re.U)
93
def extractStrangeWords(text,regoodcharrange):
#return [rer.sub(u"",w.group(0)).strip() for w in regoodcharrange.finditer(text) if
rer.sub(u"",w.group(0)).strip()]
for w in regoodcharrange.finditer(text): # find all matchobjects matching regoodcharrange,
this may contain spaces and punctuation
for sw in res.split(w.group(0).translate(transtable)): # iterate over all sequence of
letters or number (we replace punctuation by spaces, and then split)
if sw: yield sw # if not empty, yield it
def lookupfr(lefffdic,text,dic,perdict):
"""
Pour une texte et un dictionnaire bilingue
les fonctionnes rendent seulement une liste de traductions avec leur positions (number of
paragraph) dans le texte original, mais pas de mot original.
"""
tagged = tag(text.lower()+"\n",lefffdic)
translations={}
dics=[]
back={}
if perdict==False:
perdict=[]
else:
perdict=[perdict]
if verbose: print "_____"
for s,e,p1,_,t,d in tagged:
if e-s==1: # le mot simple
newdics=[]
for sw in [t]+d.keys(): # pour chaque forme qu'on trouve dans des
positions actuelles.
for d in [dic]+dics+perdict:
a = d.get(sw,())
if a:
if verbose: print "________________",sw
for trans in a[1]:
if
verbose:
print
"found
translation",trans
translations[trans]=translations.get(trans,set()).union(set([p1]))
back[trans]=back.get(trans,[])+[t]
# print "______________Translation
is :",trans,translations[trans]
if a[0]:
#"found word of a multiword entry
continuing with",a[0]
newdics+=[a[0]]
dics=newdics
# print "__________________________________________"
nl=re.compile("[\n]",re.U+re.M)
frtranslations=OrderedDict()
parags = [m.start() for m in nl.finditer(text+"\n")]
for t in sorted(translations):
# print t, sorted(translations[t])
for pos in sorted(translations[t]):
# print "pos",pos
for i,parpos in enumerate([0]+parags):
94
# print pos,i,parpos,parags[i]
if pos>=parpos and pos<parags[i]:
frtranslations[t]=frtranslations.get(t,[])+[i]
# print "remembered",t, "in",i,"paragraph"
break
parags=text.split("\n")
for pi,para in enumerate(parags):
for
k
in
extractStrangeWords(para,re.compile(ur"[\d\u3000\uFFFF]+",re.U+re.I)):
k=k.lower() # important for annoying words like C 大调 that become c
大调
frtranslations[k]=frtranslations.get(k,[])+[pi]
back[k]=back.get(trans,[])+[k]
if verbose:
print "__________________________________________"
print "frtranslations"
for w in frtranslations:print w,frtranslations[w]
print "__________________________________________"
print "look up french translation end"
return frtranslations,len(parags),back
def lookupzh(textchinesefile,translations):
"""
takes
- a file name: textchinesefile
- a translation ditionary: translations (only using the keys, ignoring the values)
gives back
a dictionary of found words -> paragraphs where they appear
"""
l=sorted(translations)
l.reverse()
#ls = [l[:len(l)/2],l[len(l)/2:]]
zhtranslations=OrderedDict()
pcount=0
for line in codecs.open(textchinesefile,"r","utf-8"):
line = line.strip()
reg=re.compile(ur"("+u"|".join(l)+")",re.U)
if line and reg.search(line):
for match in reg.finditer(line):
match=match.group(0)
if verbose: print line,"__________",match
zhtranslations[match]=zhtranslations.get(match,[])+[pcount]
pcount+=1
if verbose:
print "__________________________________________"
print "zhtranslations"
for w in zhtranslations:print w,zhtranslations[w]
print "__________________________________________"
print "look up chinese end"
return zhtranslations,pcount
def pickAncre(frtext,zhtext,perdict=False):
#charger dictionnaires: lefff, frzh et dictionnaire personalisé
lefff=chargerdict(dossierDict+"lefff.marshall")
bidict=chargerdict(dossierDict+"frzh.marshall")
95
if perdict:
perdict=makedict(lefff,perdict)
#charger les textes à aligner
fr=open(frtext).read().decode("utf-8")
zh=open(zhtext).read().decode("utf-8")
#Transformer le format win -> unix
fr = re.sub(r"[\r\n]+","\n",fr.lower()).strip()
zh = re.sub(r"[\r\n]+","\n",zh.lower()).strip()
#Extraction des ancres des paragraphes
frtranslations,frpnum,back = lookupfr(lefff,fr,bidict,perdict)
zhtranslations,zhpnum = lookupzh(zhtext,frtranslations)
return fr,zh,frtranslations,frpnum,back,zhtranslations,zhpnum
def makedict(lefff,inf=dossierDict+"frzh.dict"):
bilinguedic = picklbilingual(lefff,inf)
return bilinguedic
if __name__ == "__main__":
import sys
lefff=picklefff()
picklbilingual(lefff,sys.argv[0])
LescriptPythond’alignementautomatique
# -*- coding: UTF-8 -*import marshal, time, re, codecs, numpy, string, sys, unicodedata, os
from collections import OrderedDict
from numpy import *
from configure import *
#ON/OFF pour rendre des informations d'analyse
verbose = False
#verbose = True
#--------------Alignement------------------------------------def alignByMatrix(matrix):
"""
diagonal:0
left: -1
up: 1
"""
print "________________alignement"
lines = matrix.shape[0]
colons = matrix.shape[1]
warp = ones( (lines+1,colons+1), dtype=float )*999
directions = zeros( (lines,colons), dtype=int )
alignment = zeros( (lines,colons), dtype=int )
#
print directions
warp[0,0]=0
for i in xrange(lines):
#print
#
print "i:",i
for j in xrange(colons):
96
#
#
#
#
#
#
#
#
#
#
print "j:",j,
mini = min(warp[i,j+1], warp[i+1,j], warp[i,j])
warp[i+1][j+1]=matrix[i,j]+mini
print min
if mini == warp[i,j]:
print "d:",0
directions[i,j] = 0
elif mini == warp[i,j+1]:
print "d:",1,i,j
directions[i,j] = 1
else :
print "d:",-1,i,j
directions[i,j] = -1
print "warp matrice End, direction end"
print warp
print "directions"
print directions
f,g=lines-1,colons-1
while f>=0 or g>=0:
alignment[f,g]=1
if directions[f,g]==0:
f-=1
g-=1
elif directions[f,g]==1:
print 1,f,g
f-=1
else:
print -1,f,g
g-=1
print "Alignement end"
return alignment
#----------outFile--------------------def outMatrix(matrix,filename):
line = matrix.shape[0]
colone = matrix.shape[1]
f = open(dossierRes+filename,"w")
for x in xrange(line):
for y in xrange(colone-1):
f.write(str(matrix[x,y])+"\t")
f.write(str(matrix[x,y+1])+"\n")
f.close()
def connectText(frtext,zhtext,m,distance,ouf=dossierRes+"textalign"):
nbPar1=frtext.split("\n")
nbPar2=zhtext.split("\n")
f=open(ouf,"w")
l=m.shape[0]
c=m.shape[1]
for x in xrange(l):
for y in xrange(c):
if m[x,y]==1:
f.write(nbPar1[x].strip().encode("utf8")+"\t"+nbPar2[y].strip().encode("utf-8")+"\t"+str(distance[x,y])+"\n")
97
f.close()
return
def htmlMatrix(frtext,zhtext,back,m,wm,alignment,fileManulAlign,htmlfilename=dossierRes+"m1.html",allfilename="aligned.txt",maxhtml=1000):
ti = time.time()
frparags=frtext.split("\n")
zhparags=zhtext.split("\n")
frpn=len(frparags)
zhpn=len(zhparags)
ok=frpn<maxhtml and zhpn<maxhtml
if ok:
print "writing html visualization into",htmlfilename
out=codecs.open(htmlfilename,"w","utf-8")
out.write("""<html>
<head><title>Alignment Matrix </title>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF8">
<style type="text/css">
td { border:thin solid #ddd;font-size:10px }
;
</style></head><body>\n<table>\n""")
else:
print "not ok, no html file"
rows=[]
allzhm=[]
#fr,zh="",""
frplocks,zhplocks=[],[]
quality=[]
frparagiblocks,zhparagiblocks=[],[]
#frparags[0],zhparags[0]
lfr,lzh=-1,-1
for fri,frp in enumerate(frparags):
restrow=""
alleum=[]
for zhi,zhp in enumerate(zhparags):
if not ok and not fri*zhi%10000: print fri,zhi
#print fri,zhi, "______________",len(fr.split("\n")),len(zh.split("\n"))
#,wm[fri][zhi]
if alignment[fri][zhi]:
# print "aligning ",fri,zhi
if isinstance(fileManulAlign, numpy.ndarray):
if alignment[fri][zhi]==fileManulAlign[fri][zhi]:
if ok: restrow+=u"\n<td style='border:thick
solid red;'>\n"
else:
if ok: restrow+=u"\n<td style='border:thick
solid blue;'>wrong\n"
else:
if ok: restrow+=u"\n<td style='border:thick solid
blue;'>\n"
if fri==lfr:
#zh+=" "+zhp
zhplocks[-1]+=" "+zhp
98
zhparagiblocks[-1]+= [zhi]
quality[-1]+= [m[fri][zhi]]
elif zhi==lzh:
#fr+=" "+frp
frplocks[-1]+= " "+frp
frparagiblocks[-1]+= [fri]
quality[-1]+= [m[fri][zhi]]
else:
#fr+="\n"+frp
#zh+="\n"+zhp
frplocks+=[frp]
zhplocks+=[zhp]
quality+=[ [m[fri][zhi] ] ]
frparagiblocks+=[ [fri] ]
zhparagiblocks+=[ [zhi] ]
lfr,lzh=fri,zhi
elif ok:
if isinstance(fileManulAlign, numpy.ndarray):
if fileManulAlign[fri][zhi]:
restrow+=u"\n<td style='border:thick
solid
yellow;'>\n"
else:
restrow+=u"\n<td>\n"
else:
restrow+=u"\n<td>\n"
if ok:
restrow+=str(fri+1)+"
"+str(zhi+1)+"<br/>"+str(m[fri][zhi])+"<br/>"+"<br/>
".join(["<span
style='color:blue;'>"+z+"</span> ("+str(cz)+") :"+"-".join(list(set(back[z]))) for z,cz in
wm[fri][zhi] or []])+u"\n</td>\n"
#n'afficher pas de mots trouvés
#
restrow+=str(fri)+"
"+str(zhi)+"<br/>"+str(m[fri][zhi])+u"\n</td>\n"
for newz, newzc in wm[fri][zhi] or []:
allzhm+=[newz]
alleum+=back[newz]
if ok:
r=re.compile("("+"|".join(list(set(alleum)))+")",re.U+re.I)
frp=r.sub(r"<span style='color:green;'>\1</span>",frp)
leftc="\n<tr>\n<td>\n"+str(fri+1)+"<br/>"+frp+u"\n</td>\n"
restrow+="\n</tr>\n"
rows+=[leftc+ " "+restrow]
if ok:
toprow="\n<tr>\n\n<td>\n\n</td>\n"
r=re.compile("("+"|".join(allzhm)+")",re.U+re.I)
if ok:
for zhi,zhp in enumerate(zhparags):
toprow+=u"\n<td>\n"+str(zhi+1)+"<br/>"+r.sub(r"<span
style='color:blue;'>\1</span>",zhp)+u"\n</td>\n"
#else:toprow+=u"\n<td>\n"+str(zhi)+"<br/>"+zhp+u"\n</td>\n"
toprow+="\n</tr>\n"
out.write(toprow)
out.write("\n".join(rows))
out.write("\n</table>\n</body></html>")
out.close()
99
out=codecs.open(dossierRes+"fr-"+allfilename,"a","utf-8")
out.write("\n".join(frplocks))
out.close()
out=codecs.open(dossierRes+"zh-"+allfilename,"a","utf-8")
out.write("\n".join(zhplocks))
out.close()
out=codecs.open(dossierRes+"qu-"+allfilename,"a","utf-8")
out.write("\n".join( [ str( sum(qli)/len(qli) ) for qli in quality ]
out.close()
print "____",time.time()-ti,"seconds"
return zip( frparagiblocks,zhparagiblocks )
))
#--------------charger l'alignement manuel--------------------def loadManuelAlign(tma):
ranges=re.split("\n",tma.strip())
colonnes=re.split("\t",ranges[0])
m= numpy.zeros((len(ranges),len(colonnes)), int)
for x, r in enumerate(ranges):
cs=re.split("\t",r)
for y,c in enumerate(cs):
m[x,y]=c
return m
#----------------Différent méthode pour construire la matrice--------------------#----------------1er algo-------------------def makeMatrix1(namebitext,frtranslations,frpnum,zhtranslations,zhpnum,frtext,zhtext,back):
print "Exécutation du 1er algo"
print "Type de matrice fr parags x zh parags:",frpnum,zhpnum
paraFr=frtext.split("\n")
paraZh=zhtext.split("\n")
m= numpy.zeros((frpnum,zhpnum), float)
wm = numpy.empty( (frpnum,zhpnum), list)
zhtranslations, zhtotcount=converti(zhtranslations)
frtranslations, frtotcount=converti(frtranslations)
for i,w in enumerate(zhtranslations):
for zpi,czh in zhtranslations[w].iteritems():
for fpi,cfr in frtranslations[w].iteritems():
vsm=(1.0*czh*cfr)/(len(zhtranslations[w])*len(frtranslations[w])) #meilleur algo
m[fpi,zpi]=m[fpi,zpi]+vsm
wm[fpi][zpi]=(wm[fpi][zpi] or [])+[[w,czh*cfr]]
# outMatrix(m,"VSMP.txt") #écrire le résultat dans le fichier.
# print paraFr[25]
# print paraZh[22]
# print zhtranslations[u"父亲"]
# print frtranslations[u"父亲"]
nm = numpy.ones((frpnum,zhpnum),float)
for x in xrange(frpnum):
for y in xrange(zhpnum):
mx=float(9.0/10.0)**m[x,y]
nm[x,y]=mx
outMatrix(nm,namebitext+"-distance-1.txt") #écrire le résultat dans le fichier.
print "Fin de construction de la matrice"
return nm,wm
100
#------------2ème algo------------------def makeMatrix2(namebitext,frtranslations,frpnum,zhtranslations,zhpnum,frtext,zhtext,back):
print "matrix of type fr parags x zh parags:",frpnum,zhpnum
paraFr=frtext.split("\n")
paraZh=zhtext.split("\n")
m= numpy.ones((frpnum,zhpnum), float)
wm = numpy.empty( (frpnum,zhpnum), list)
zhtranslations, zhtotcount=converti(zhtranslations)
frtranslations, frtotcount=converti(frtranslations)
for i,w in enumerate(zhtranslations):
n = zhtotcount[w]*frtotcount[w]+1.0
for zhpi,czh in zhtranslations[w].iteritems():
for frpi,cfr in frtranslations[w].iteritems():
# computing the fraction of matched characters / total number of
chars in the parag couple
# gets smaller if high fraction used for matching
x = 1-1.0* ( cfr*len(back[w][0]) + cfr*len(w) ) /
( len(paraFr[frpi]) + len(paraZh[zhpi]) )
wm[frpi][zhpi]=(wm[frpi][zhpi] or [])+[[w,czh*cfr]]
# (ceu * czh) / n gets smaller if word is frequent in whole corpus
- and bigger if frequent in the paragraph
# (1-(ceu * czh) / n) contrary!
# m[frpi][zhpi] = (m[frpi][zhpi]) * (1-(cfr * czh) / n) * x ** 5
#mellieur algo
m[frpi][zhpi] = (m[frpi][zhpi]) * (1-(cfr * czh) / n) * x
# m[frpi][zhpi] = (m[frpi][zhpi]) * x
outMatrix(m,namebitext+"-distance-2.txt") #écrire le résultat dans le fichier.
print "Fin de construction de la matrice"
return m,wm
#------------------4ème algo-----------------def makeMatrix0(namebitext,frtranslations,frpnum,zhtranslations,zhpnum,frtext,zhtext,back):
"""
c'est une algo qui prend le nombre des mots trouvés dans le bitexte, en filtrant les
mots fréquents
"""
print "matrix of type fr parags x zh parags:",frpnum,zhpnum
m= numpy.zeros((frpnum,zhpnum), float)
# wm= numpy.empty((frpnum,zhpnum), list)
for i,w in enumerate(zhtranslations):
# print zhtranslations.keys().index(w),w.encode("utf-8"), len(zhtranslations[w])
#give back the word found
# if i==12 or i == 63 or i == 29 or i == 14 or i == 66 or i== 17 or i== 230 or i==
208 or i== 16:continue
if len(zhtranslations[w])>2:continue
for zpi in zhtranslations[w]:
for fpi in frtranslations[w]:
m[fpi,zpi]=m[fpi,zpi]+1+1
#
wm[fpi,zpi]=(wm[fpi,zpi]
or
[])+[zhtranslations.keys().index(w)]
# outMatrix(wm,"VSMP.txt") #écrire le résultat dans le fichier.
for x in xrange(frpnum):
for y in xrange(zhpnum):
m[x,y]=float(1.0/2.0)**m[x,y] # plus grand, rend une valeur plus petit
outMatrix(m,namebitext+"-distance-0.txt") #écrire le résultat dans le fichier.
print "AlignMatrix end"
101
return m
def converti(dic):
"""
give dic->
{zh1:[numpara1,numpara2,numpara3,numpara1,numpara3]}
return ndic
{zh1:{numpara1:frequnceInPara1, numpara2:freq2, numpara3:freq3}}
"""
ndic={}
diccount={}
for w in dic:
ndic[w]={}
for n in dic[w]:
ndic[w][n]=ndic[w].get(n,0)+1
diccount[w]=len(dic[w])
return ndic, diccount
#--------------charger l'alignement manuel--------------------def loadManuelAlign(tma):
ranges=re.split("\n",tma.strip())
colonnes=re.split("\t",ranges[0])
m= numpy.zeros((len(ranges),len(colonnes)), int)
for x, r in enumerate(ranges):
cs=re.split("\t",r)
for y,c in enumerate(cs):
m[x,y]=c
return m
def
align(namebitext,fr,zh,frtranslations,frpnum,back,zhtranslations,zhpnum,fileManulAlign=False):
if fileManulAlign:
fileManulAlign=open(fileManulAlign).read().decode("utf-8")
fileManulAlign=loadManuelAlign(fileManulAlign)
# ----------------algo0-----------m=makeMatrix0(namebitext,frtranslations,frpnum,zhtranslations,zhpnum,fr,zh,back)
resalign=alignByMatrix(m)
outMatrix(resalign,namebitext+"-resalign-0.txt")
# ----------------algo1-----------#
m,wm=makeMatrix1(namebitext,frtranslations,frpnum,zhtranslations,zhpnum,fr,zh,back)
resalign=alignByMatrix(m)
outMatrix(resalign,namebitext+"-resalign-1-tmp.txt")
htmlMatrix(fr,zh,back,m,wm,resalign,fileManulAlign,dossierRes+namebitext+"algo1.html")
#----------------algo2-----------m,wm=makeMatrix2(namebitext,frtranslations,frpnum,zhtranslations,zhpnum,fr,zh,back)
resalign=alignByMatrix(m)
outMatrix(resalign,namebitext+"-resalign-2.txt")
htmlMatrix(fr,zh,back,m,wm,resalign,fileManulAlign,dossierRes+namebitext+"algo2.html")
LescriptPythondecontrôlelessaisisd’entrées
# -*- coding: UTF-8 -*102
from configure import *
from dict import *
import align
def fileIn(text=1):
if text==1:
namebitext = "aube"
frenchText = dossierText+"aube.fr.txt"
chineseText = dossierText+"aube.zh.txt"
fileManulAlign= dossierRes+"manuelAlign.txt"
perdict=dossierDict+"perfrzh.dict" #Dictionnaire personnalisé
return namebitext, frenchText, chineseText, perdict, fileManulAlign
t1=fileIn(3)
z1=pickAncre(t1[1],t1[2],t1[3])
def align1():
align.align(t1[0],z1[0],z1[1],z1[2],z1[3],z1[4],z1[5],z1[6],t1[4])
if __name__ == "__main__":
align1()
103
Auteur
Документ
Catégorie
Без категории
Affichages
4
Taille du fichier
1 783 Кб
Étiquettes
1/--Pages
signaler