fusion de données lexicales

UNIVERSITÉ CHARLES DE GAULLE LILLE 3

UFR LETTRES MODERNES

MASTER 1 ALLC, MENTION SDL, SPÉCIALITÉ TAL (TRAITEMENT AUTOMATIQUE DE LE

LANGUE)

RAPPORT DE STAGE :

FUSION DE DONNÉES LEXICALES

DANS LE CADRE DU PROJET MOT À MOT

DATE DE LA SOUTENANCE : 16-17 SEPTEMBRE 2010

TUTEUR DE STAGE : M. MATHIEU MANGEOT

LIEU DU STAGE :

GROUPE D'ÉTUDE EN TRADUCTION AUTOMATIQUE DES LANGUES ET DE LA

PAROLE

© Gros Vincent, 2009-2010

ii

REMERCIEMENTS

Je tiens tout d'abord à remercier Mathieu Mangeot, mon tuteur de stage, pour m'avoir encadré et pour sa confiance. Ses conseils pertinents et les "discussions du jeudi" m'ont été très profitables.

Je remercie également Hong Thaï Nguyen pour son aide concernant le vietnamien, Mutstuko Tomokiyo et Christian Boitet, pour leurs critiques concernant mon mémoire portant sur les dictionnaires électroniques du japonais.

Merci de manière générale à toute l'équipe du GETALP pour son accueil et pour m'avoir accepté en tant que stagiaire.

iii

TABLE DES MATIÈRES

Remerciements...........................................................................................................2 Table des matières.....................................................................................................3 Table des Figures.......................................................................................................5 Introduction...............................................................................................................6 1 Présentation du GETALP.....................................................................................8

1.1. Bref historique du GETALP.........................................................................8 1.2. Le GETALP aujourd'hui..............................................................................8

1.2.1 Présentation..............................................................................................8 1.2.2 Un exemple de projet soutenu par le GETALP : Aximag.......................9

2 Contexte de la mission.........................................................................................11 2.1. Le projet Mot à Mot.....................................................................................11 2.2. Description du stage....................................................................................12

2.2.1 Les objectifs...........................................................................................12 2.2.2 Les autres critères de la mission.............................................................13

3 Déroulement du stage..........................................................................................14 3.1. Au préalable : approfondir les connaissances............................................14

3.1.1 Enseignement du PERL en M1 et besoins relatifs au stage...................14 3.1.2 Les subroutines.......................................................................................14 3.1.3 Les modules...........................................................................................16

3.2. Les ressources mises à disposition..............................................................17 3.2.1 Les sources : des dictionnaires structurés en XML................................17 3.2.2 Les autres ressources liées au projet Mot à Mot....................................18 3.2.3 Démarrage du traitement des ressources................................................20

3.3. Aspect général des programmes..................................................................20 3.3.1 Pour une réutilisation des scripts : la conception d'un "pattern" ...........20 3.3.2 Traitement du XML : choix des modules XML::Twig et XML::Writer...........................................................................................................................21

3.4. Les algorithmes de programmation............................................................22 3.4.1 Les transformations................................................................................22

iv

3.4.2 La fusion.................................................................................................24 3.5. Résultats.......................................................................................................25

3.5.1 Schématisation des résultats pour le français.........................................25 3.5.2 Résultats pour le vietnamien..................................................................27 3.5.3 Temps de traitement des programmes....................................................27

4 Conclusion Générale...........................................................................................28 4.1. Évaluation critique du stage........................................................................28 4.2. Bilan personnel............................................................................................30

4.2.1 Sur la mission.........................................................................................30 4.2.2 Immersion dans le monde de la recherche.............................................30

Références Bibliographiques..................................................................................31 Références Documentaires......................................................................................32 Annexe......................................................................................................................33

Le modèle des programmes PERL du stage : le "pattern"................................33 Liste des programmes et leur fonction................................................................38

v

TABLE DES FIGURES

Figure 1 : Utilisation de Aximag pour le vietnamien, sur le site de Aximag....10Figure 2 : Affichage à l'écran d'un message d'information...............................15Figure 3 : Utilisation d'une subroutine..............................................................15Figure 4 : Script PERL Moduletest.pm.............................................................16Figure 5 : Script principal Test.pl.....................................................................16Figure 6 : Résultat de l'exécution de Test.pl.....................................................17Figure 7 : Les ressources lexicales qui seront fusionnées.................................17Figure 8 : Exemple de structure XML pour le français (projet Mot à Mot).....19Figure 9 : Algorithme principal et subroutine entry d'une transformation.......24Figure 10 : Schématisation de l'obtention du volume français de Mot à Mot. .26Figure 11 : Schéma d'une version orientée objet des programmes du stage.....29

vi

INTRODUCTION

Dans le cadre de ma première année de Master, j'ai effectué un stage au sein du Groupe pour la Traduction Automatique/Traitement Automatisé des Langues et de la Parole (GETALP) situé sur le campus des universités de Grenoble. Il s'est déroulé du 12 avril au 25 juin 2010.

L'objectif de mon travail était la réalisation d'un script PERL permettant de construire un squelette de données lexicales pour le projet Mot à Mot, dirigé par Mathieu Mangeot. Ce projet universitaire permettra par le biais d'un travail collaboratif sur internet la mise en place d'un dictionnaire multilingue qui porte sur les langues d'Asie du Sud-Est peu informatisées, à l'instar du vietnamien. Le français et l'anglais feront également parties des langues traitées par ce projet. Le squelette de données sera mis à la disposition des contributeurs en tant que base de travail.

Cette mission très enrichissante dans un laboratoire de recherche me permet d'un côté de mettre en pratique les compétences acquises durant ma formation, et notamment concernant le langage de programmation PERL et dans une moindre mesure les structures XML, et d'un autre côté, ce stage m'offre un premier aperçu du monde de la recherche.

Ce présent rapport clôture le travail effectué au GETALP. Il permet à la fois de rendre compte des différentes tâches effectuées pour parvenir au résultat demandé, et à la fois de dresser un bilan personnel de cette expérience.

La rédaction de ce rapport commence avant tout par une présentation du laboratoire, afin de donner une image de ce qu'est le GETALP aujourd'hui, en s'appuyant sur un bref historique de son évolution et en donnant quelques exemples de projets récents.

La deuxième partie définit le contexte dans lequel s'inscrit le stage. Il s'agit pour cela de présenter dans un premier temps le projet Mot à Mot, puis dans un deuxième temps de fixer la mission qui m'a été confiée.

La troisième partie est consacrée au travail effectué. En se référant à l'enseignement du langage PERL à l'université de Lille 3, quelques éléments de programmation seront abordés, nécessaire à la bonne compréhension des programmes réalisés pendant le stage. Une brève présentation des ressources qui

vii

seront fusionnées amorce véritablement la description de la mission. Elle peut être résumée en trois étapes : tout d'abord l'étude des ressources, afin de proposer l'algorithme le plus efficace possible, puis la transformation des ressources et enfin la fusion des données.

Un bilan critique sur le stage et l'appréciation personnelle de cette expérience à Grenoble concluent ce rapport.

1 Présentation du GETALP

1 PRÉSENTATION DU GETALP 1.1. Bref historique du GETALP

Le GETALP résulte de la fusion des équipes GEOD et GETA en 2006. Le traitement de la langue écrite est le domaine du GETA, tandis que GEOD se concentre sur le traitement de la parole.

Le GETA (Groupe d'Étude pour la Traduction Automatique) est issu du CETA (C pour Centre), laboratoire du CNRS sous la direction de B.Vauquois, qui a été fondé aux débuts de la recherche en Traduction Automatique (TA) en France (1961-1970). Les membres du CETA ont en autres choses construit le premier système de "deuxième génération" au monde.

À partir de 1971, le CETA devient un laboratoire universitaire, le GETA. Les recherches des années 1970 et 1980 se tournent non plus vers la TA du veilleur (traduction totalement automatique et grossière, sans pré-édition ni post-édition), mais vers la TA du réviseur (traductions brutes destinées à être révisées). B.Vauquois dirigea le GETA jusqu'à son décès en 1985.

Au début des années 1990, le GETA se tourne vers la TAO individuelle, et continue aujourd'hui les recherches dans ce domaine.

1.2. Le GETALP aujourd'hui 1.2.1 Présentation

Le GETALP est une équipe dirigée par Hervé Blanchon du Laboratoire d'Informatique de Grenoble (LIG). Autour d'une vingtaine de membres permanents (pour la plupart enseignants-chercheurs), gravite un effectif similaire de doctorants, de stagiaires et de post-doc.

Le but principal des recherches du GETALP est le développement d'une informatique multilingue organisé en six axes thématiques1 :

1. Traduction Automatique et Traitement Assisté par Ordinateur ;

1 Les Thèmes de recherche sont issus du descriptif du GETALP à l'adresse suivante : http://www.liglab.fr/spip.php?article97

8

http://www.liglab.fr/spip.php?article97

1.2. Le GETALP aujourd'hui

2. Plates-formes associées aux Traitement Automatique des Langues ;

3. Collecte et construction de ressources linguistiques ;

4. Multilinguisme dans les systèmes d'information ;

5. Reconnaissance automatique de la parole, des sons et des dialectes ;

6. Analyse sonore et interaction dans les environnements perceptifs.

1.2.2 Un exemple de projet soutenu par le GETALP : AXIMAG

AXIMAG propose un accès multilingue aux sites Web, c'est-à-dire que la navigation dans un site est rendue possible dans plusieurs langues. La gestion des langues se fait via une passerelle2 de traduction collaborative, l'iMAG (interactive Multilingual Access Gateway). Les pages sont traduites à la volée, grâce à une mémoire de traductions dédiée, qui contient d'une part les traductions obtenues par un ou plusieurs systèmes de traduction automatique (selon les choix du site internet), d'autre part les traductions manuelles obtenues par post-édition des résultats de traduction. En effet, l'un des avantages de ce système est la possibilité laissée au visiteur du site de modifier en temps réel les traductions qui sont vérifiées par un locuteur natif (servant de modérateur).

Le point fort de cette technologie est l'utilisation d'une mémoire de traductions propre à chaque site (et donc spécialisée), combinée à l'aspect collaboratif. Ainsi, contrairement aux passerelles de traduction automatique existantes, à l'instar de Google Translate ou de SYSTRANet, la traduction est contrôlée et en constante amélioration. Un autre avantage réside dans le faible coût de traduction.

Aujourd'hui, les principales "vitrines" de ce projet sont les sites Web de la métropole de Grenoble3, celui du LIG4 et le site de AXIMAG.

2 Une passerelle est un service Web qui permet lors de la visite d'un site d'effectuer des modifications sur les données à afficher, sans que cela change les possibilités du site pour le visiteur. Ainsi les liens internes du site seront toujours accessibles au sein de la passerelle.

3 http://www.lametro.fr/ . L'anglais et le chinois sont disponibles.4 http://www.liglab.fr/ . De nombreuses langues sont disponibles.

9

http://www.liglab.fr/

http://www.lametro.fr/

1.2. Le GETALP aujourd'hui

10

Figure 1 : Utilisation de Aximag pour le vietnamien, sur le site de Aximag

2 Contexte de la mission

2 CONTEXTE DE LA MISSION

2.1. Le projet Mot à Mot

Initialisé il y a moins d'un an, l'objectif principal du projet Mot à Mot est l'informatisation de langues peu dotées d'Asie du Sud-Est. Il s'agit pour cela de construire un système lexical multilingue en combinant plusieurs dictionnaires bilingues et en offrant une part importante au travail collaboratif. Le projet Mot à Mot s'occupe dans un premier temps des liens lexicaux entre le français (dans une moindre mesure l'anglais) et prioritairement le vietnamien et le khmer. Il est le fruit d'une coopération entre les laboratoires MICA de Hanoï (Vietnam), ITC de Phnom Penh (Cambodge) et le GETALP, dont le responsable de ce projet, Mathieu Mangeot, fait partie.

La mise en place du projet Mot à Mot peut se résumer en trois parties :

• La récupération des données existantes, en utilisant des ressources lexicales variées (monolingues ou multilingues par exemple) ;

• La recherche et la constitution de communautés de personnes susceptibles de contribuer à un tel projet, via les jeux sérieux lexicaux5 ;

• La mise en route des contributions en ligne sur le web6.

Ce projet se destine à l'observation de plusieurs phénomènes. Il s'agit tout d'abord d'évaluer la dynamique de contribution autour de chaque dictionnaire. Un système notant l'importance de la contribution (en donnant entre une et cinq étoiles selon la qualité et/ou la quantité des contributions) est prévu pour récompenser les

5 Les jeux sérieux lexicaux, ou JeuxDeMots, sont des sites internet permettant la récupération de données lexicales à travers des défis asynchrones entre un joueur A et un joueur B. La version française existe depuis 2007, la version vietnamienne est opérationnelle depuis peu, et la version cambodgienne est en cours de traduction. Cf. Lafourcade et Joubert:2008.

6 Le dictionnaire sera mis en ligne via la plateforme Jibiki qui permet la gestion des ressources lexicales par des contributeurs. Cf. Mangeot:2001.

11

2.1. Le projet Mot à Mot

contributeurs. Enfin, Mot à Mot permettra l'étude de plusieurs hypothèses formulées dans de précédents travaux, notamment la bijectivité7 des liens bilingues et la construction d'un système lexical multilingue8.

2.2. Description du stage 2.2.1 Les objectifs

La plateforme Jibiki existe et est déjà utilisée par d'autres projets (à l'instar du GDEF9). Les sites JeuxDeMots (les jeux sérieux lexicaux) sont également en ligne ou en passe d'être opérationnels.

Il est donc nécessaire de commencer à rassembler un premier squelette de données, afin de proposer aux futurs contributeurs une première esquisse du projet qui servira de point de départ pour les contributions. Il semble en effet plus facile d'améliorer des articles et de les utiliser comme exemple pour en créer de nouveaux, que de proposer un projet complètement vierge et donc sans repère.

Dans cette optique, la mission consiste à utiliser des ressources lexicales préexistantes et gratuites, de les adapter afin de les rendre conformes aux schémas XSD mis en place au sein du projet Mot à Mot, puis de les fusionner afin d'établir un premier squelette de données. Ce travail concerne principalement le français et le vietnamien.

Chacune des ressources est structurée en XML. La transformation et la fusion des ressources seront réalisées grâce à des scripts PERL.

7 Soit un lien de traduction entre un mot A de langue A et un mot B de langue B, si l'on peut relier un sens SA du mot A à un sens SB du mot B, alors le lien est bijectif et SB peut être relié à SA.

8 Cf. Polguère:20069 Le Grand Dictionnaire Estonien Français, accessible à l'adresse suivante :

http://www.estfra.ee/GDEF.po

12

http://www.estfra.ee/GDEF.po

2.2. Description du stage

2.2.2 Les autres critères de la mission

Au-delà d'une obligation de résultat, c'est-à-dire obtenir la fusion des données, il m'a été demandé de réfléchir à une forme idéale du script, en utilisant notamment des pointeurs Xpath, qui permettrait d'obtenir une version de qualité.

J'ai en outre ajouté personnellement plusieurs critères de rigueur notamment le nommage des fichiers selon leur catégorie (source, résultat, scripts, scripts secondaires), les noms de variables identiques pour tous les programmes, ainsi que l'ajout systématique de commentaires pour décrire les programmes.

13

3 Déroulement du stage

3 DÉROULEMENT DU STAGE

3.1. Au préalable : approfondir les connaissances 3.1.1 Enseignement du PERL en M1 et besoins relatifs au stage

Le langage PERL fait l'objet d'un enseignement en Master 1 TAL à l'université de Lille 3 durant un semestre. Le déroulement de ce cours permet ainsi de découvrir la programmation PERL et d'en acquérir les bases principales. Suite à ce premier apprentissage, un projet de concordancier nous a été proposé en tant qu'évaluation, ce qui permettait de mettre à profit les connaissances étudiées en cours.

Les notions qui ont été présentées lors de l'ultime séance étaient les tables de hachage, les fonctions (ou subroutine, ce terme sera utilisé par la suite), et enfin les modules.

Dans la continuité de cet enseignement, le stage me permet ainsi de mettre en pratique ces dernières notions et de m'orienter vers une utilisation plus avancée du langage PERL.

3.1.2 Les subroutines

Les subroutines sont des sous-éléments au sein d'un programme que l'on "appelle" dans l'algorithme principal pour exécuter une tâche particulière. L'intérêt des subroutines est multiple : tout d'abord alléger l'algorithme principal du programme ce qui améliore la lisibilité du code, puis de séparer les différentes tâches secondaires une à une (ce qui accroît également la lisibilité), enfin de répéter des tâches en n'écrivant qu'une seule fois le code.

À titre d'exemple, supposons un programme exécutant une centaine de traitements différents10. Après chacun d'eux, on souhaite afficher à l'écran un message d'information unique comme suit : « Le traitement est fini. ». Il nous faudra donc écrire autant de fois que nécessaire la ligne de code suivante :

10 Il s'agit cependant d'un cas très exagéré en comparaison des programmes réalisés durant ce stage. Une transformation, par exemple, est un programme qui va modifier la structure XML d'un fichier de manière répétitive, il n'y aura donc que quelques traitements, qui seront cependant exécutés plusieurs milliers de fois (selon le nombre d'éléments <entry>).

14

3.1. Au préalable : approfondir les connaissances

print (STDERR "Le traitement est fini.\n");

Figure 2 : Affichage à l'écran d'un message d'information

Malheureusement, si nous décidons de modifier ce message d'information, par exemple si nous voulons ajouter la phrase « Tout s'est bien déroulé. », il nous faudrait alors modifier une centaine de fois la même ligne de code. En créant une subroutine MyMessage, nous devons certes indiquer une centaine de fois l'appel de cette fonction dans notre algorithme, mais en réalité la subroutine se situera dans une autre partie du script (généralement à la fin), et il suffira de modifier cette subroutine une seule fois pour que le changement désiré soit pris en compte pour chaque appel de MyMessage.

Voici grossièrement ce que donnerait le programme avec la subroutine :

#!/usr/bin/PERLuse strict; TRAITEMENT 1;MyMessage;TRAITEMENT 2;MyMessage;…TRAITEMENT N;MyMessage;

sub MyMessage {print (STDERR "Le traitement est fini. Tout s'est bien

déroulé\n");}

Figure 3 : Utilisation d'une subroutine

15


3.1.3 Les modules

Les modules sont des scripts PERL spéciaux que l'on peut utiliser pour ajouter des fonctionnalités à un programme. Ils sont stockés dans des fichiers NOM.pm (pm pour PERL Module) et intégrés dans le programme par use NOM; (ou par require NOM;). Ils sont donc extérieurs au programme que l'on crée, ce qui allège le script principal.

Il existe des milliers de modules PERL disponibles gratuitement. Aujourd'hui nous pouvons distinguer deux catégories de modules : les modules standards, ceux qui sont fournis avec l'interpréteur PERL, et les modules CPAN, disponibles sur internet pour être téléchargés selon les besoins de l'utilisateur11. Par exemple, pour analyser un document XML, de nombreux parseurs12 ont vu le jour sur le site CPAN, notamment XML::Simple, Lib::XML et XML::Twig.

Il est également possible d'écrire ses propres modules. L'exemple ci-dessous permet d'appeler un module, Moduletest.pm qui affiche un message test à l'écran lorsqu'il est appelé dans le programme principal. Pour appeler notre module dans cet exemple, nous utiliserons require :

#!/usr/bin/PERLuse warnings;print "Ici se manifeste le module \"moduletest.pm\"\n";1;

Figure 4 : Script PERL Moduletest.pm

#!/usr/bin/PERL -wprint "Ici se manifeste le script principal\n";require Moduletest;

Figure 5 : Script principal Test.pl

11 http://www.cpan.org/ 12 De l'anglais "parser" signifiant parcourir, analyser. Un parseur est un analyseur syntaxique.

16

http://www.cpan.org/


Ici se manifeste le script principalIci se manifeste le module "moduletest.pm"

Figure 6 : Résultat de l'exécution de Test.pl

Dans le langage PERL, la finalité d'une utilisation des modules est de permettre une Programmation Orientée Objet (POO)13, qui offre une amélioration importante du développement et de la maintenance des applications, essentiellement grâce à un gain de temps non-négligeable.

3.2. Les ressources mises à disposition 3.2.1 Les sources : des dictionnaires structurés en XML

Titre Type Langue Nombre d'entrées

Morphalou 2.0 Monolingue français 98 810 entrées

VietDict Bilingue français-vietnamien 41 041 entrées

VietDict Bilingue vietnamien-français 39 071 entrées

FeM (French English

Malay)

Multilingue français-anglais/malais

20 000 entrées (approximation)

FeV (French English

Vietnamese)

Multilingue français-anglais/vietnamien/

malais/thaï

17 764 entrées

Figure 7 : Les ressources lexicales qui seront fusionnées

13 Pour plus d'informations sur le POO en PERL, il existe notamment un très bon tutoriel à l'adresse suivante : http://djibril.developpez.com/tutoriels/perl/poo/ (juillet 2009, 56 pages).

17

http://djibril.developpez.com/tutoriels/perl/poo/

3.2. Les ressources mises à disposition

3.2.2 Les autres ressources liées au projet Mot à Mot

Des exemples de structure XML du projet Mot à Mot et les schémas XSD14 ont été réalisés par Mathieu Mangeot et Hong Thaï Nguyen pour le français, l'anglais et le vietnamien. Les exemples de structures illustrent le résultat que je dois obtenir.

Dans le projet Mot à Mot, la racine <m:volume> contient des éléments-fils <m:entry>. Chacun des éléments <m:entry> possède un élément <m:head>, donnant les caractéristiques principales de l'entrée (le mot-vedette, sa prononciation, sa catégorie syntaxique), suivi d'éléments <m:sense> concernant notamment les définitions, les traductions et les exemples. Un élément <m:sense> correspond à un sens du mot-vedette.

La figure ci-après montre l'exemple du français.

14 Les schémas XSD (SML Schemas Document), sont plus récents que le Documents DTD (Document Type Definition). L'avantage des XSD est qu'ils sont eux-mêmes des documents XML, donc tous les outils (parseurs, XSLT, Xpath, …) sont utilisables sur des schémas XSD. La structure est en outre décrite de manière plus fine qu'une DTD. Pour plus de renseignements : http://www.w3.org/XML/Schema.

18

http://www.w3.org/XML/Schema


<?xml version="1.0" encoding="UTF-8" standalone="yes" ?><m:volume name="Motamot_fra" source-language="fra" xmlns:d="http://www-clips.imag.fr/geta/services/dml" xmlns="http://www-clips.imag.fr/geta/services/dml/motamot" xmlns:m="http://www-clips.imag.fr/geta/services/dml/motamot" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=

"http://www-clips.imag.fr/geta/services/dml/motamot http://www-clips.imag.fr/geta/services/dml/motamot_fra.xsd"> <m:entry id="" level=""> <m:head> <m:headword>abandonner</m:headword> <m:pronunciation>abãdoné</m:pronunciation> <m:pos>v.t.</m:pos> </m:head> <m:sense id="s1" level=""> <m:definition>

<m:label>action sur un objet</m:label> <m:formula>humain ou animal X ~ entité Y</m:formula> </m:definition>

<m:gloss>laisser tomber un truc</m:gloss> <m:translations> <m:translation idrefaxie="" idrefentry="" idreflexie="" lang=""/> </m:translations> <m:examples> <m:example>On peut abandonner son chien au refuge d'une association de protection sans enfreindre la loi.</m:example> </m:examples> <m:idioms> </m:idioms> </m:sense> </m:entry> </m:volume>

Figure 8 : Exemple de structure XML pour le français (projet Mot à Mot)

19


3.2.3 Démarrage du traitement des ressources

Le premier travail consiste à analyser les structures des sources lexicales pour les traitements futurs. En réalisant une schématisation des ressources, une correspondance avec les structures XML du projet Mot à Mot a pu être mise en place. Cette comparaison entre les structures est le point de départ des scripts de transformation réalisés par la suite.

En parallèle, il était nécessaire de tester le traitement des fichiers XML via le langage PERL, notamment par la sélection de modules CPAN. Des échantillons de chaque ressource ont permis d'effectuer des essais, pour comparer par exemple, la durée d'exécution des programmes tests.

3.3. Aspect général des programmes 3.3.1 Pour une réutilisation des scripts : la conception d'un "pattern"

Tous les programmes qui ont été conçus durant le stage possédaient les éléments suivants (dans l'ordre d'apparition dans le programme) :

1. Un en-tête, donnant diverses informations nécessaires à l'utilisation du programme (notamment les arguments possibles, sa date de création, son principe d'utilisation) ;

2. Les méta-directives, c'est-à-dire tous les appels de modules (par exemple le parser XML::Twig) ;

3. Le prologue, dans lequel les variables globales et les conditions portant sur les arguments sont spécifiées, ainsi que l'ouverture des fichiers entrants et sortants ;

4. L'algorithme principal, par exemple il s'agit pour les transformations de parcourir le document grâce au parseur, en appelant pour chaque élément <entry> la subroutine entry ;

5. L'ensemble des subroutines, dont info (pour les messages d'information pendant l'exécution du programme) et help (pour l'écran d'aide).

20

3.3. Aspect général des programmes

Le "pattern"15 contient les éléments du programme qui seront systématiquement utilisés16. Il s'agit des éléments 1 à 3 et d'une partie des subroutines (info et help, élément 5). Ce système permet de gagner du temps lors de la création d'un script, et de ne s'occuper que de l'algorithme principal et des subroutines spécifiques à cet algorithme, tout en conservant une forme agréable et unique pour l'ensemble des programmes. Le "pattern" est indiqué en annexe.

3.3.2 Traitement du XML : choix des modules XML::Twig et XML::Writer

Le XML permet de définir une structure arborescente d'un document, ce qui offre entre autre la possibilité de récupérer les données présentes dans le document pour les utiliser.

Cette récupération de données nécessite un outil, le parseur, qui parcourt le document et qui est capable d'en extraire les informations qu'il contient. On obtient alors un sous-ensemble arborescent de la structure initiale. Par exemple, dans un élément <dictionnaire>, il est possible de récupérer un élément <entrée>, qui est à la fois un sous-élément de <dictionnaire> et à la fois une structure arborescente, contenant par exemple <mot-vedette> et <prononciation>.

On distingue deux catégories de parseurs XML :

• Les parseurs validants permettant de vérifier qu'un document XML est conforme à sa DTD ou son schéma XSD ;

• Les parseurs non validants se contentant de vérifier que le document XML est bien formé (c'est-à-dire qu'il respecte la syntaxe XML de base).

En outre les parseurs XML sont divisés en deux types de traitement :

• L'ensemble de la structure est chargé en mémoire. Le besoin en mémoire est important, mais son utilisation est relativement simple. Il s'agit du Document Object Model (DOM) ou tree-based. C'est une spécification de la norme W3C (World Wibe Web Consortium) ;

15 "Pattern" signifie patron ou modèle en français.16 Certains éléments, par exemple la subroutine aide ou l'en-tête, doivent être complétés ou subir

quelques modifications, car ils dépendent directement du programme. Cependant les modifications restent légères.

21

3.3. Aspect général des programmes

• Seule une partie de la structure est chargée en mémoire, par exemple à partir d'un élément donné. C'est ce qu'on appelle le mode événementiel (ou event-based). Son besoin en mémoire est très inférieur au système DOM, et est donc très utilisé pour les gros documents XML. Cependant son utilisation est plus complexe, car l'information n'est pas conservée. Il s'agit du Simple API for XML (méthode SAX).

Il existe en PERL un module très complet (et surtout très documenté) qui est capable de gérer les deux approches DOM et SAX : XML::Twig. Conçu par Michel Rodriguez, il est stable, régulièrement mis à jour, et il est recommandé pour les gros fichiers. Le seul inconvénient que l'on pourrait lui octroyer est le fait qu'il soit non-validant.

Le module XML::Twig a permis ainsi de réaliser des programmes tests avec l'approche DOM, la méthode la plus facile à apprivoiser. Cependant, l'exécution de ces programmes sur les fichiers sources demandait un temps très long (presque une heure pour la transformation de VietDict français-vietnamien), ou alors conduisait à un problème de mémoire. Il a donc fallu adapter les algorithmes à une approche SAX, c'est-à-dire en ne gardant rien en mémoire.

Pour créer des fichiers XML (le fichier de sortie), XML::Twig est suffisamment capable pour ne pas utiliser d'autres modules. Cependant, XML::Writer est d'une telle simplicité d'utilisation qu'il a finalement été utilisé pour l'ensemble des programmes.

3.4. Les algorithmes de programmation 3.4.1 Les transformations

Une transformation se décompose en deux parties : l'algorithme principal et la subroutine entry.

L'algorithme principal est simple, il consiste à définir le Twig_handler (du module XML::Twig) sur l'élément XML correspondant à une entrée dans un dictionnaire (<entry>). Le Twig_handler permet de définir l'événement voulu, c'est-à-dire dans le cas présent le début de l'élément <entry>. Cet événement déclenche

22

3.4. Les algorithmes de programmation

l'appel à la subroutine entry, dans lequel des modifications du sous-arbre sont codées. La complexité de la subroutine est dépendante du traitement à effectuer à partir de la source.

Lorsque les modifications sont effectives pour une entrée, la mémoire est purgée et le parseur passe à l'entrée suivante, jusqu'à la fin du document XML.

Concernant l'écriture dans le fichier en sortie, une balise ouvrante sera déterminée par startTag via XML::Writer, une balise fermante par endTag; Il est également possible de définir un élément vide (par exemple, <translation/>) via emptyTag. Enfin les attributs sont ajoutés à la suite de la balise, à l'instar de <m:entry> dans l'exemple ci-après.

Parmi l'ensemble des transformations, seule celle concernant la source FeV a présenté des difficultés. Ces problèmes s'expliquent par le fait que le dictionnaire FeV possède une structure plate, c'est-à-dire que tous les sous-éléments contenus dans une entrée sont frères. Il est donc difficile de dégager les éléments qui seront contenus dans <m:head> et ceux qui seront dans chaque <m:sense>.

Voici l'algorithme et la subroutine entry dans une forme simplifiée17 :

17 Certaines variables sont définies dans le "pattern".

23


my $twig = XML::Twig->new ( output_encoding => $encoding, Twig_handlers => {$in_entry => \&entry,}, );$twig->parsefile($FichierXML);############################################################sub entry {my ($twig, $twig_entry) = @_;my $entry = $twig_entry->name;$writer->startTag( "m:entry", 'id' => 'fra.' . $twig_entry->field($in_headword), 'level' => "" ); $writer->startTag("m:head"); $writer->startTag("m:headword"); $writer->characters($twig_entry->field($in_headword)); $writer->endTag("m:headword"); $writer->startTag("m:pronunciation"); $writer->endTag("m:pronunciation"); $writer->endTag("m:head");$writer->endTag("m:entry");$twig->purge;return;}

Figure 9 : Algorithme principal et subroutine entry d'une transformation

3.4.2 La fusion

Contrairement aux transformations, l'algorithme de la fusion est complexe. Il s'agit en effet de comparer deux fichiers possédant une même structure XML (celle de Mot à Mot). Avec l'approche DOM, cette comparaison semble accessible, car l'arborescence est entièrement chargée en mémoire, on peut sans problème passer d'une entrée à l'autre (avec par exemple next_sibling). Ce qui n'est pas le cas avec l'approche SAX, puisqu'une seule entrée est chargée en mémoire pour chaque fichier. L'entrée suivante n'existe pas (encore), et si on décide de la charger en mémoire, c'est alors la précédente qui disparaît.

24


La fusion est composée de l'algorithme principal et de deux subroutines : next_entry, pour récupérer l'entrée suivante dans l'un ou l'autre fichier, et fusion, qui fusionne deux entrées en une seule.

De manière générale, l'algorithme consiste à comparer lexicographiquement le mot-vedette A du fichier A et le mot-vedette B du fichier B :

• Si A>B : B est situé avant A dans l'ordre alphabétique. B est copié dans le fichier de sortie, et on passe au mot-vedette B+1. A reste en mémoire ; on relance l'algorithme pour comparer A et B+1.

• Si A<B, A est situé avant B dans l'ordre alphabétique. A est copié dans le fichier de sortie, et on passe au mot-vedette A+1. B reste en mémoire ; on relance l'algorithme pour comparer A+1 et B.

• Si A=B, A et B sont identiques. A et B sont fusionnés, et on passe aux mot-vedettes A+1 et B+1 ; on relance l'algorithme pour comparer A+1 et B+1.

Lorsque le parcours d'un des deux fichiers est terminé, les entrées restantes dans l'autre fichier sont ajoutées dans le fichier de sortie.

La fusion de deux entrées a été simplifiée en la concaténation des éléments <m:sense>, en renouvelant la numérotation de ces éléments.

Pour éviter des problèmes de comparaison dus à la présence de caractères accentués, le module Text::StripAccents est utilisé pour considérer tout caractère accentué comme étant équivalent à un caractère non-accentué.

3.5. Résultats 3.5.1 Schématisation des résultats pour le français

Pour chacune des quatre ressources dont la langue source est le français, un programme de transformation a été réalisé, donnant un fichier transformé prêt à être fusionné. Trois fusions sont ensuite nécessaires pour obtenir un unique volume du dictionnaire Mot à Mot. Des liens de traduction vers le vietnamien principalement, mais aussi l'anglais, le malais et le thaï ont été créés.

25

3.5. Résultats

Figure 10 : Schématisation de l'obtention du volume français de Mot à Mot

26

FeV

FeM

Morphalou 2.0

VietDict

Transformation

Transformation

Transformation

Transformation

A

B

C

D

Fusion 1

Fusion 2

Fusion 3

Volume françaisDu projet Mot à Mot

3.5. Résultats

3.5.2 Résultats pour le vietnamien

Il est envisageable d'utiliser le sources dans de nouvelles transformations pour ensuite les fusionner avec le VietDict vietnamien-français. Cependant cette éventualité n'a pas été réalisée, car le vietnamien est une langue cible de ces sources.

Le volume du vietnamien pour le projet Mot à Mot se résume donc à la transformation du VietDict vietnamien-français.

3.5.3 Temps de traitement des programmes

Exécution du Programme : Durée moyenne du traitement :

V_for_VietDict_fravie.pl 1min40

V_for_VietDict_viefra.pl 1min15

V_for_Morphalou2.pl 10min

V_for_FeM.pl 1min40

V_for_FeV.pl 3min

V_for_Fusion.pl 9min30

27

4 Conclusion Générale

4 CONCLUSION GÉNÉRALE

4.1. Évaluation critique du stage

L'objectif principal consistait à élaborer un script PERL permettant de fusionner des données lexicales structurées en XML. Ce programme fonctionne, et de plus par l'utilisation des subroutines, est facilement modifiable pour la suite du projet Mot à Mot.

Il a également fallu réaliser des scripts PERL pour transformer les fichiers sources selon les schémas XSD du projet Mot à Mot propre à chaque langue. L'idéal aurait été un seul et unique programme, cependant cette recherche n'a pas aboutie. Néanmoins, un "pattern" a été élaboré pour accélérer la mise en forme des programmes et éviter ainsi de construire entièrement chaque programme.

Pour effectuer les traitements, deux modules ont été d'une grande importance : XML::Twig, pour parcourir les fichiers et repérer les éléments voulus, et XML::Writer pour écrire le fichier de sortie. Il était également possible de n'utiliser que le premier module, XML::Twig, ce qui n'a pas été proposé, faute de temps. Ce système fonctionne néanmoins très bien, et la particularité du langage PERL se résume par sa devise, TIM TOWTDI : There Is More Than One Way To Do It (« il y a plus d'une façon de le faire »). Ainsi ce que je propose est une solution parmi d'autres.

L'utilisation de modules enfin, est certes un premier pas vers la POO (Programmation Orientée Objet), cependant cette appellation n'est pas applicable à l'ensemble du projet que je soumets. Une évolution envisageable pourrait donc être d'utiliser la POO et d'améliorer ainsi le projet du point de vue de la lisibilité et de la maintenance. Le schéma ci-après montre ce qu'aurait pu être un projet entièrement en POO.

28

4.1. Évaluation critique du stage

Figure 11 : Schéma d'une version orientée objet des programmes du stage

Plusieurs questions d'ordre linguistique non résolues marquent la fin du stage, notamment concernant les catégories syntaxiques en vietnamien, et le traitement des définition et des gloses (faut-il spécifier une rédaction spécifique, et l'appliquer au squelette de données ?). Ces questions sont intervenues lors de mon travail, et j'ai pu partager mes idées avec Mathieu Mangeot et Hong Thaï Nguyen, mais ils seront les seuls à proposer une solution réelle.

29

Volume langue XDe Mot à Mot

Programme principal traitant la Ressource A

Module Transformation.pm Module Fusion.pm

Autres modules

Ressource A à ajouter Volume langue X

De Mot à Mot

4.2. Bilan personnel

4.2. Bilan personnel 4.2.1 Sur la mission

Je suis très heureux d'avoir eu l'opportunité de travailler dans les bureaux du GETALP sur un projet tel que Mot à Mot. L'ambiance de travail et le cadre de vie étaient très agréables. La liberté accordée sur les horaires m'a permis de rester certains jours très tard le soir, ce qui a évité plus d'une fois l'oubli d'une idée ou l'arrêt d'une exécution (les fusions étaient très longues à une certaine période).

Une possible réutilisation de mes scripts autour du français et du japonais pourrait être un objectif personnel, qui me permettrait entre autre de mettre en pratique les idées que je n'ai pas pu exploiter durant le stage. En effet, la durée de stage, conjuguée à une obligation de résultat, m'a contraint à l'abandon de certaines applications que j'aurai aimé au moins tester. Ainsi les programmes nécessitent entre 5 et 10 modules (en comptant les modules standards). Certains ont besoin d'être installés, il y a donc une préparation supplémentaire avant l'utilisation des programmes par d'autres utilisateurs. Proposer une solution avec un minimum de modules aurait sans doute était l'étape suivante du travail, en supprimant l'appel de XML::Writer par exemple. Créer mes propres modules, pour me diriger vers une application POO, est également un aspect que j'aurai voulu examiner.

4.2.2 Immersion dans le monde de la recherche

Le contact avec les personnes travaillant au GETALP a également été un point positif. Évidemment, je ne pouvais pas passer dans chaque bureau pour discuter de chaque projet en cours. Cependant j'ai pu partager quelques opinions avec les autres stagiaires présents et quelques membres du GETALP (chercheurs, doctorants, etc.), j'ai également fait la découverte de certains projets (passés et actuels).

J'ai en outre pu assister à deux soutenances de thèse particulièrement intéressantes, tant sur les thèses en elles-mêmes que sur le déroulement de ces deux après-midi.

J'ai enfin pu participer aux soutenances de stage de Master Recherche en Informatique, cette demi-journée a également été fructueuse.

30

Références Bibliographiques

RÉFÉRENCES BIBLIOGRAPHIQUES

Lafourcade M. et Joubert A. (2008) « JeuxDeMots : un prototype ludique pour l’émergence de relations entre termes. » In JADT 2008 : 9es Journées internationales d’Analyse statistique des Données Textuelles, Lyon, France, pp. 657–666.

Mangeot M. (2010), « Projet Mot à mot : élaboration d’un système lexical multilingue par le biais de dictionnaires bilingues », Actes des journées scientifiques LTT 2009, Lisbonne, Portugal, 15-17 octobre 2009, 12 p.

Mangeot M. et Nguyen H.T. (2009), « Building lexical resources: towards programmable contributive platforms », Proc. IEEE-RIVF 2009, DaNang, VietNam, 14-16 July 2009, Vol 1/1, pp. 84-92.

Mangeot M. (2001), « Environnements centralisés et distribués pour lexicographes et lexicologues en contexte multilingue. », Thèse de nouveau doctorat, Spécialité Informatique, Université Joseph Fourier Grenoble I, jeudi 27 septembre 2001, 280 p.

Polguère A. (2006) « Structural properties of Lexical Systems : Monolingual and Multilingual Perspectives. », Proceedings of the Workshop on Multilingual Language Resources and Interoperability (COLING/ACL 2006), Sydney, pp.50-59.

31

Références Documentaires

RÉFÉRENCES DOCUMENTAIRES

• Le LIG, l'équipe GETALP

◦ http://www.liglab.fr/

◦ http://getalp.imag.fr/xwiki/bin/view/Main/

• Aximag

◦ http://aximag.fr/

◦ http://www- clips.imag.fr/geta/herve.blanchon/Recherche/Projets/AXiMAG/AXiMAG.html

• Modules XML du langage Perl

◦ http://djibril.developpez.com/tutoriels/perl/perl-xml/#LII-2-a

◦ http://search.cpan.org/dist/XML-Twig/Twig.pm

32

http://search.cpan.org/dist/XML-Twig/Twig.pm

http://djibril.developpez.com/tutoriels/perl/perl-xml/#LII-2-a

http://www-clips.imag.fr/geta/herve.blanchon/Recherche/Projets/AXiMAG/AXiMAG.html



http://aximag.fr/

http://www.liglab.fr/

http://getalp.imag.fr/xwiki/bin/view/Main/

Annexe

ANNEXE

Le modèle des programmes PERL du stage : le "pattern"

#!/usr/bin/perl

#==================================================================######----- NOM.pl -----######==================================================================# Auteur : V.GROS# Version 1.0 # Dernières modifications : jj mois 2010# Synopsis : # # Remarques : - # - #------------------------------------------------------------------# Usage : perl NOM.pl -v -from source.xml -to MAM.xml ## -v : affiche les informations du STDERR## Pour les options avancées :## -date "date" : pour spécifier la date (par défaut : la date du jour (localtime)# -erreur "message d'erreur" : pour spécifier le message d'erreur (ouverture de fichiers)# -encodding "format d'encodage" : pour spécifier le format d'encodage (par défaut UTF-8)# -help : pour afficher l'aide#==================================================================

#==================================================================###--- METADIRECTIVES ---###

use strict;use warnings;use utf8;use IO::File; use Getopt::Long; # pour gérer les arguments.

use XML::Twig; # (non inclus dans le core de Perl), pour le parsing de la source.use XML::Writer; # (non inclus dans le core de Perl), pour le fichier de sortie.

33


#==================================================================###--- PROLOGUE ---###

#------------------------------------------------------------------##-- Les balises de la source/de la sortie (MAM) --##

# ----------------------------------------------------------# MODIFIEZ/SUPPRIMEZ CES VARIABLES SELON LE TRAITEMENT VOULU# ----------------------------------------------------------

my $ref_root = 'volume'; # la racine (par exemple : <volume> ou <dictionary>).my $ref_entry = 'entry' ; # l'élément dans la source qui correspond à <m:entry> dans MAM.my $ref_sense = 'sense' ; # idem pour l'élément <m:sense> dans MAM.

my $in_root = 'volume'; my $in_entry = 'entry'; my $in_headword = ''; my $in_sense = 'sense'; my $in_translation = ''; my $in_examples = ''; my $in_example = ''; my $in_else1 = ''; my $in_else2 = '';

#------------------------------------------------------------------##-- Gestion des options --##

my ($date, $FichierXML, $FichierResultat, $erreur, $encoding) = ();my ($verbeux, $help) = ();my $count_entry = ;

GetOptions( 'date|time|t=s' => \$date, # flag de type -date ou --date, ou -time ou --time, ou -t ou --t # (=s : string) 'source|in|from|i=s' => \$FichierXML, 'sortie|out|to|o=s' => \$FichierResultat, 'erreur|error|e=s' => \$erreur, 'encodage|encoding|enc|f=s'=> \$encoding, 'help|h' => \$help, 'verbeux|v' => \$verbeux, );

34


if (!(defined $date)) {$date = localtime;};if (!(defined $FichierXML)) {&help;};# si le fichier source n'est pas spécifié, affichage de l'aide.if (!(defined $FichierResultat)) {$FichierResultat = $FichierXML;};if (!(defined $erreur)) {$erreur = "|ERROR| : problem opening file :";};if (!(defined $encoding)) {$encoding = "UTF-8";};if (defined $help) {&help;};

#------------------------------------------------------------------##-- Configuration de l'output --##

my $output = new IO::File(">$FichierResultat");my $writer = new XML::Writer( OUTPUT => $output, DATA_INDENT => 3, # indentation, 3 espaces DATA_MODE => 1, # changement ligne. ENCODING => $encoding,);$writer->xmlDecl($encoding);

#------------------------------------------------------------------if ( defined $verbeux ) {&info('a');};# message dans le STDERR (voir subroutine 'info') indiquant le démarrage du programme.

#==================================================================###--- ALGORITHME PRINCIPAL ---###

if ( defined $verbeux ) {&info('b');};

#------------------------------------------------------------------

#------------------------------------------------------------------if ( defined $verbeux ) {&info('c');};

#------------------------------------------------------------------# Fin du fichier en sortie :$writer->endTag("m:$ref_root");$output->close();

#------------------------------------------------------------------if ( defined $verbeux ) {&info('d');};

35


#==================================================================###--- SUBROUTINES ---###

sub info{my $info = shift @_;if ($info =~ 'a')

{print (STDERR

"=====================================================\n");print (STDERR "\t~~~~ Mise en route du programme $0 ~~~~\n");print (STDERR

"=====================================================\n");}

elsif ($info=~ 'b'){print (STDERR

"=====================================================\n");print (STDERR "Parcours du fichier source\n");print (STDERR

"------------------------------------------------------\n");}

elsif ($info=~ 'c'){print (STDERR "Le fichier source a ete correctement

evalue\n");print (STDERR

"------------------------------------------------------\n");print (STDERR "Ecriture des changements dans le fichier final

$FichierResultat \n");print (STDERR

"------------------------------------------------------\n");}

elsif ($info =~ 'd'){print (STDERR "~~~~ Fermeture du programme $0 ~~~~\n");print (STDERR

"=====================================================\n");my $time = times ;my $FichierLog = 'LOG.txt';open(my $FiLo, ">>:encoding($encoding)", $FichierLog) or die

("$erreur $!\n");print {$FiLo}"==================================================\n",

36


"RAPPORT : ~~~~ $0 ~~~~\n","--------------------------------------------------\n","Fichier source : $FichierXML\n","--------------------------------------------------\n","Fichier final : $FichierResultat\n","--------------------------------------------------\n","Date du traitement : ", $date, "\n","--------------------------------------------------\n","Lapsed time : ", $time, " s\n","==================================================\n";}

}

sub help {print (STDERR "=====================================================\n");print (STDERR "HELP\n");print (STDERR "=====================================================\n");print (STDERR "usage : $0 -i <sourcefile.xml> -o <outfile.xml>\n\n") ;print (STDERR "options : -h affichage de l'aide\n") ;print (STDERR " -e le message d'erreur (ouverture de fichiers)\n") ;print (STDERR " -f le format d'encodage\n");print (STDERR " -v mode verbeux (STDERR et LOG)\n");print (STDERR " -t pour la gestion de la date (initialement : localtime)\n");print (STDERR "=====================================================\n");}

#==================================================================1 ;

37

Liste des programmes et leur fonction

Liste des programmes et leur fonction

Programme Fonction

V_for_FeM.pl Transformation du FeM

V_for_Fev.pl Transformation du FeV

V_for_Fusion.pl Fusion de deux fichiers XML

V_for_Morphalou2.pl Transformation de Morphalou 2.0

V_for_VietDict_fravie.pl Transformation de VietDict

V_for_VietDict_viefra.pl Transformation de VietDict

W_for_Changing_one_Tag.pl Modification d'une balise XML

W_for_Changing_Tags.pl Modifie toutes les balises (structure Mot à Mot uniquement)

W_for_Concatenation.pl Concatène deux fichiers XML

W_for_Pattern.pl Modèle de programme

W_for_Sort.pl Tri les entrées

38