Memoire

UNIVERSIT STENDHAL GRENOBLE 3

LABORATOIRE LIDILEM

CONCEPTION ET DVELOPPEMENT D'UN FORMALISME

DE CORRECTION GRAMMATICALE AUTOMATIQUE

- APPLICATION AU FRANAIS -

Agns Souque

Juin 2007

Mmoire de Master 2 Sciences du Langage,mention Industries de la Langue,

Spcialit parole, crit et conception d'outilspour l'apprentissage des langues,

Parcours Traitement Automatiquede la Langue Ecrite et de la Parole

Orientation Recherche

Directeur de mmoire : Thomas Lebarb, Matre de confrences

2Table des matires

Introduction......................................................................................................................9

Chapitre 1 : Existant......................................................................................................11

1. Structure gnrale d'un correcteur grammatical......................................................111.1. Tokenization.................................................................................................................11

1.2. Tagging et dsambigusation.......................................................................................121.3. Segmentation en syntagmes minimaux.......................................................................12

1.4. Dtection des fautes.....................................................................................................12

2. Travail de M. Lechelt : adaptation au franais d'un correcteur existant..................132.1. Analyse de diffrents correcteurs................................................................................13

2.1.1. Rejet de GRAC et de LanguageTool...................................................................13

2.1.2. Slection de An Gramadir.................................................................................14

2.2. Adaptation de An Gramadir la correction grammaticale du franais.....................14

2.2.1. La tokenization....................................................................................................14

2.2.2. Le tagging............................................................................................................152.2.3. La dtection des fautes........................................................................................15

2.2.4. La rdaction des rgles........................................................................................16

2.3. valuation et perspectives...........................................................................................17

2.3.1. valuation et limites de An Gramadir...............................................................17

2.3.2. Perspectives.........................................................................................................19

3. LanguageTool .........................................................................................................203.1. Rejet de la premire version de l'outil.........................................................................20

3.1.1. Structure de LanguageTool l'poque................................................................20

3.1.2. Points faibles l'origine du rejet.........................................................................22

3.2. volutions et nouvelle version de l'outil.....................................................................22

3.2.1. volutions du systme.........................................................................................22

3.2.2. Structure actuelle de LanguageTool....................................................................23

4. Conclusion...............................................................................................................24

Chapitre 2 : Adaptation de LanguageTool la correction du franais.....................25

1. Test des rgles existantes.........................................................................................251.1. Test et erreurs dtectes...............................................................................................25

31.2. Problme de l'ambigut catgorielle..........................................................................26

1.3. Tentative de contournement du problme...................................................................28

2. Implantation d'un dsambiguseur...........................................................................282.1. Choix d'un type de dsambiguseur.............................................................................28

2.2. Choix d'un formalisme pour les rgles........................................................................29

2.3. Intgration dans LanguageTool...................................................................................29

3. Importation des rgles de An Gramadir dans LanguageTool................................303.1. Importation des rgles de dsambigusation...............................................................30

3.1.1. Reprsentation en XML.......................................................................................30

3.1.2. Rcriture des rgles............................................................................................31

3.2. Importation des rgles d'erreurs..................................................................................35

3.2.1. Rcriture automatique........................................................................................35

3.2.2. Rcriture des rgles sur les syntagmes verbaux.................................................36

3.2.3. Rcriture des rgles sur les syntagmes nominaux.............................................37

4. Augmentation des rgles partir d'un corpus de fautes..........................................394.1. Analyse des fautes commises......................................................................................39

4.1.1. Fautes d'orthographe............................................................................................39

4.1.2. Fautes dj dtectes par LanguageTool.............................................................40

4.1.3. Fautes a priori non dtectables............................................................................40

4.1.4. Fautes dtectables avec un nouveau formalisme.................................................40

4.1.5. Fautes dtectables avec le formalisme actuel de LanguageTool.........................41

4.2. Rdaction de nouvelles rgles d'erreurs......................................................................41

4.2.1. Accord Dterminant + Nom + Verbe..................................................................41

4.2.2. Accord en nombre tre + Participe pass ou Adjectif........................................42

4.2.3. Confusion entre la forme verbale et la forme nominale......................................42

4.2.4. Confusion entre "on" et ont"................................................................................43

4.2.5. Confusion entre "cet", "cette", "ces" et "c'est".....................................................43

4.2.6. Accord Pronom relatif "qui" + Verbe :................................................................44

5. Typologie des erreurs corriges...............................................................................445.1. Les erreurs corriges par LanguageTool.....................................................................44

5.1.1. Les erreurs de proximit phontique...................................................................45

5.1.2. Les erreurs d'accord dans le syntagme nominal..................................................45

5.1.3. Les erreurs dans le groupe verbal........................................................................45

45.1.4. Les erreurs d'accord avec le sujet........................................................................46

5.2. Des fautes d'orthographe ou de grammaire ?..............................................................46

5.2.1. Point de vue linguistique : orthographe lexicale et orthographe grammaticale. .47

5.2.2. Point de vue informatique : correction orthographique et correction grammaticale..................................................................................................................47

5.2.3. Chevauchement des fautes d'orthographe et de grammaire................................48

5.3. Les fautes du dactylographe........................................................................................49

6. Conclusion...............................................................................................................50

Chapitre 3 : Amlioration du formalisme de LanguageTool.....................................51

1. Critique des limites du formalisme actuel...............................................................511.1. Le "pattern-matching" rigide......................................................................................51

1.1.1. Explosion combinatoire des rgles......................................................................51

1.1.2. Ncessit et impossibilit de prvoir tous les contextes......................................52

1.1.3. Limitation au contexte immdiat.........................................................................54

1.2. De nombreuses fausses alarmes..................................................................................54

1.2.1. Mots ambigus.......................................................................................................55

1.2.2. Mots mal tiquets...............................................................................................55

1.2.3. Dtections multiples............................................................................................56

1.2.4. Dtections en cascade..........................................................................................56

2. Premire volution du formalisme...........................................................................562.1. Segmentation en chunks et unification de structures de traits.....................................57

2.1.1. Chunks.................................................................................................................572.1.2. Rappels sur les structures de traits et l'unification...............................................59

2.2. Intrt de la combinaison chunks-unification pour la correction grammaticale.........592.2.1. Correction "intra-chunk".....................................................................................59

2.2.2. Correction "inter-chunks"....................................................................................602.2.3. Aide la dsambigusation..................................................................................60

2.3. Vrification orthographique........................................................................................61

3. Dveloppement d'un nouveau formalisme...............................................................613.1. Description du formalisme..........................................................................................61

3.1.1. lment ....................................................................................................61

3.1.2. lment .............................................................................................63

3.1.3. lment .............................................................................................63

53.1.4. lment ..................................................................................................63

3.1.5. lment ...............................................................................................64

3.1.6. lment .................................................................................................64

3.1.7. lment .................................................................................................65

3.1.8. lment ...............................................................................................66

3.1.9. lment ...........................................................................................67

3.2. Interprtation du formalisme.......................................................................................67

3.3. Conception d'un calculateur d'unification...................................................................69

3.3.1. Pr-requis.............................................................................................................69

3.3.2. Fonctionnement du module de calcul d'unification.............................................70

3.3.3. Dveloppement....................................................................................................72

3.3.4. Test du prototype.................................................................................................73

4. Conclusion...............................................................................................................75

Chapitre 4 : Conclusions et perspectives ....................................................................77

1. Premier correcteur grammatical OpenOffice.org....................................................77

2. Proposition de formalisme.......................................................................................772.1. Nouvelle structure ......................................................................................................78

2.2. Dveloppement de rgles partir d'un corpus............................................................79

2.2.1. Constitution d'un corpus d'erreurs.......................................................................79

2.2.2. Analyse du corpus...............................................................................................80

3. Intgration au projet OpenOffice.org.......................................................................81

4. Vers une autre approche de la correction grammaticale..........................................82

Glossaire..........................................................................................................................83

Bibliographie..................................................................................................................87

Webographie...................................................................................................................89

6Remerciements

Thomas Lebarb, mon directeur de recherche prfr, pour sa patience et la confiance qu'il m'a accorde,

la socit Nuxeo pour sa collaboration, et plus particulirement Laurent Godard pour son soutien technique et ses conseils aviss,

Jean-Pierre Chevrot et Agns Millet, pour m'avoir fourni le prcieux corpus sur lequel s'appuie une partie de mon travail,

la communaut LanguageTool, et en particulier Marcin Mikowski pour le temps qu'il m'a consacr, et sans l'aide de qui une partie de mon travail n'aurait pu tre ralise,

Virginie, pour ses relectures... "pointilleuses", pour ses petites ritournelles qui me poursuivront vie : "on est un... lapin" et "on ne se base pas...",

tout le bureau I110 et ses pices rapportes : Ninie, Alexia, Mathieu, Delphine, Tiphaine, Julien et Nico pour leur bonne humeur constante et leurs minutes culturelles,

toute l'quipe du DIP, en particulier Roseline pour sa gentillesse, Marie-Christine et Antoine pour avoir partag leur bureau, et Claude et Olivier pour leur acte hroque,

mon Hros, mon Dieu, mon Matre, pour m'avoir pousse, sans jamais me laisser tomber...

mon pre, ma mre, Irne et Daniel pour leurs prcieux encouragements et leurs coups de main ponctuels.

Introduction 7

IntroductionCe travail s'inscrit dans le cadre du projet communautaire OpenOffice.org dans la continuit du stage de Master 2 Industrie de la langue de Myriam Lechelt. Il est encadr par Thomas Lebarb, matre de confrences l'universit Stendhal, qui a initi cette recherche avec Laurent Godard de la socit Nuxeo-InDesko.

L'objectif de ce travail interdisciplinaire (linguistique et informatique) est la cration d'un outil de correction grammaticale libre pour le franais, pouvant tre intgr l'environnement bureautique, ou utilis indpendamment de celui-ci. Dans ce domaine, les outils existants sont gnralement des logiciels propritaires aux cots d'intgration levs, qui sont peu ou pas dcrits dans la littrature, et ferms toute amlioration externe. Nos travaux de recherche visent donc, de manire plus gnrale, dvelopper un outil de correction grammaticale gnrique, dont les ressources langagires seront accessibles et modifiables.

Dans un premier chapitre, nous exposons le fonctionnement gnral des correcteurs grammaticaux. Nous rsumons ensuite le travail qui a t ralis par Myriam Lechelt pour adapter l'un d'entre eux au franais. Il s'agit de An Gramadir, un outil libre cr pour le galique. Les conclusions sur cette adaptation en ont montr les limites, et pour cette raison, nous avons dcid de travailler sur un autre correcteur, LanguageTool, que nous prsentons et dont nous pensons qu'il est mieux adaptable au franais.

Le second chapitre est consacr la transcription des travaux de M. Lechelt dans le formalisme actuel de LanguageTool. Nous avons tout d'abord combl une lacune de l'outil, en ralisant l'implantation d'un module de dsambigusation, puis nous avons import les rgles de An Gramadir. Nous dtaillons alors comment nous les avons modifies et simplifies. L'analyse d'un corpus de fautes de grammaire nous a ensuite permis de complter ces rgles, et pour finir nous dfinissons la typologie des erreurs traites.

Dans le chapitre 3, aprs avoir critiqu certaines limites de LanguageTool, telle que l'explosion combinatoire des rgles, nous proposons un nouveau formalisme pour y remdier. Fond sur la combinaison de deux principes linguistiques, la segmentation en chunks et l'unification, ce formalisme permet la dtection des fautes d'accords avec seulement quelques rgles gnriques. Nous le dcrivons, puis nous prsentons un prototype d'outil de calcul d'unification que nous avons dvelopp, permettant de montrer la faisabilit de ce que nous avons dcrit.

Chapitre 1 : Existant 8

Chapitre 1 : ExistantDans ce chapitre, nous commenons par expliquer le fonctionnement gnral des correcteurs grammaticaux. Nous rsumons ensuite le travail qui a t effectu pour adapter au franais un de ces outils : "An Gramadir", sans oublier les conclusions auxquelles ce travail a men, qui ne sont pas toutes positives. Pour cette raison, nous nous sommes tourne vers un autre correcteur, LanguageTool, que nous prsentons et sur lequel nous travaillons dans les chapitres suivants.

1. Structure gnrale d'un correcteur grammatical

L'objectif de notre travail est de dvelopper un correcteur grammatical. Il semble donc naturel de commencer par prsenter, de manire gnrale, comment ce type d'outils fonctionne. La figure 1 ci-dessous illustre la succession des diffrentes tapes de traitement dont nous parlons : la tokenization, l'tiquetage, la dsambigusation, la segmentation en syntagmes minimaux, et enfin la dtection des fautes. Ces tapes sont identiques d'un correcteur l'autre, mais avec des mthodes variables. En revanche, certaines ne sont pas toujours prsentes. Les zones hachures, dans la figure 1, correspondent aux tapes qui ne sont pas effectues systmatiquement par tous les outils de correction grammaticale.

Figure 1: Structure gnrale d'un correcteur grammatical(les zones hachures correspondent aux traitements facultatifs)

1.1. TokenizationLe premier traitement consiste dcouper le texte en phrases, puis les phrases en mots, ou plus exactement en tokens. C'est la segmentation, ou tokenization, ralise par le tokenizer. Nous emploierons indiffremment les termes mot, au sens forme graphique, et token, pour dsigner l'unit issue de la segmentation, bien que le terme le plus appropri soit token.En effet, le mot en linguistique peut dsigner une unit smantique constitue de plusieurs mots graphiques. Par exemple pomme de terre est une unit compose de 3 mots graphiques, et sera segmente en 3 tokens distincts. Par ailleurs, les units obtenues aprs la tokenization peuvent aussi tre des signes de ponctuation.La segmentation du texte en phrase s'appuie principalement sur les marqueurs de dbut et de fin

TOKENIZATIONDETECTION

DESFAUTES

rglesd'erreurs

rgles degrammaire

ou

Texte vrifier

phraseset

tokenstexte

tiquet

texte tiquetdsambigus

TAGGING

tiquetagemorphosyntaxique Dsambigusation

rglesprobabilits etoucorpus

Textecorrig

phrasessegmentesen chunks

CHUNKING


de phrases que sont les majuscules ou les points par exemple. La tokenization des phrases en mots prend elle aussi appui sur la ponctuation, ainsi que sur les espaces.

Dans certaines langues comme le franais, les points des abrviations ou des sigles, les apostrophes, et les tirets dans certains mots, peuvent induire le tokenizer en erreur, et conduire une mauvaise segmentation.

1.2. Tagging et dsambigusation

L'tiqueteur (ou tagger) effectue ensuite l'tiquetage morphosyntaxique (ou tagging). Chaque mot se voit attribuer une ou plusieurs tiquettes (tag), contenant des informations sur la catgorie grammaticale (verbe, nom, pronom, etc), ainsi que sur ses traits de sous-catgorisation (genre, nombre, temps, personne, etc). Ces tags proviennent d'un lexique de formes flchies tiquetes.Les mots qui reoivent plusieurs tags sont les mots ambigus. Il s'agit de mots ayant des homographes avec des informations morphosyntaxiques diffrentes, comme le mot bte qui peut tre "nom fminin singulier", "adjectif masculin singulier" ou "adjectif fminin singulier".

Une dsambigusation est ncessaire pour limiter le nombre d'tiquettes de ces mots et amliorer par la suite la dtection de fautes de grammaire.

Une premire mthode pour dsambiguser les mots est la mthode probabiliste. Elle ncessite un corpus d'apprentissage sans erreurs, tiquet avec les informations morphosyntaxiques. Des calculs sont alors effectus. Il s'agit de la probabilit que tel mot ait tel tag, ou encore la probabilit qu'un mot ait un certain tag en fonction des tags des mots qui l'entourent. Lors de l'tiquetage, ces probabilits sont appliques aux mots du texte analys, et chaque mot reoit alors le tag qui correspond la plus forte probabilit.L'algorithme de (Brill, 1994) permet de gnrer des rgles de dsambigusation tablies statistiquement.

Une autre mthode consiste utiliser des rgles manuelles de dsambigusation (Vergne, 2000), sous forme d'expressions rgulires et fondes sur le contexte immdiat. Chaque rgle consiste en un modle (ou pattern) d'un contexte en prsence duquel tel mot prend tel tag.

Certains correcteurs utilisent la mthode probabiliste, d'autres les rgles manuelles, certains combinent les deux mthodes, enfin d'autres ne font pas du tout de dsambigusation.

1.3. Segmentation en syntagmes minimaux

Le dcoupage en syntagmes minimaux, (ou chunking), permet de travailler un niveau intermdiaire entre la phrase et le mot, en dfinissant des groupes de mots. Cette tape concerne peu de correcteurs, mais nous la mentionnons tout de mme car, comme nous le verrons par la suite, ce type de segmentation peut tre trs utile dans le traitement automatique des langues (Abney, 1991). Ceci nous intresse particulirement pour l'outil que nous souhaitons dvelopper, et nous en reparlons donc de manire plus dtaille dans le point 2.1.1. du chapitre 3.


1.4. Dtection des fautes

Une fois l'tiquetage termin, commence alors l'tape de vrification de la grammaire. Il existe l encore deux manires de procder, toutes deux fondes sur le principe du pattern-matching, c'est--dire sur la correspondance exacte entre un lment et un modle.

Certains correcteurs utilisent des rgles de grammaire. Elles dcrivent des patterns grammaticalement corrects. Si une partie du texte ne correspond aucun pattern, une erreur est dtecte.

D'autres correcteurs utilisent au contraire des rgles d'erreurs. Ils comparent alors le texte non pas des modles corrects, mais des modles de fautes. Une erreur est dtecte lorsque le texte et le pattern concident.

2. Travail de M. Lechelt : adaptation au franais d'un correcteur existant

Dans le cadre de son mmoire de Master 2, (Lechelt, 2005) a initi un travail dont nous prenons la suite, et dont l'objectif est, terme, de crer un outil de correction grammaticale libre pour le franais, pouvant tre intgr OpenOffice.org.

Afin de ne pas raliser entirement un nouvel outil, (Lechelt, 2005) a analys plusieurs correcteurs grammaticaux libres dj existants dans d'autres langues, afin de dterminer lequel pourrait tre le plus facilement adapt au franais.Suite cette analyse, elle a modifi et complt l'outil slectionn, pour pouvoir prendre en charge la correction du franais. L'valuation du systme ainsi transform, bien qu'assez satisfaisante, a mis en vidence certaines limites. Quelques amliorations supplmentaires ont donc t suggres, ainsi qu'une approche alternative pour la cration d'un outil entirement nouveau.

2.1. Analyse de diffrents correcteurs

2.1.1. Rejet de GRAC et de LanguageTool

Trois correcteurs grammaticaux libres, disponibles dans des langues trangres, ont t analyss. Le premier a t rapidement cart, sa ralisation n'tant pas encore acheve. Il s'agit de GRAC (GRAmmar Checker) (Web : GRAC), un correcteur indpendant de toute langue, dvelopp par M. Biais. Il utilise la mthode probabiliste pour la dsambigusation, et des rgles de grammaire pour la dtection des fautes.

L'analyse a ensuite port sur LanguageTool (Web : LAN), un correcteur libre de style et de grammaire, dvelopp initialement pour l'anglais par (Naber, 2003). L'outil a retenu l'attention, mais aprs comparaison avec le troisime, il a finalement t lui aussi rejet. En effet, la version de LanguageTool analyse l'poque faisait appel une mthode probabiliste pour dsambiguser les mots, mthode dont nous verrons les inconvnients par la suite, au chapitre 1 dans le point 3.1.2.

C'est donc An Gramadir (Web : Gramadir), le dernier outil analys, qui a finalement t retenu pour l'adaptation au franais.


2.1.2. Slection de An Gramadir

An Gramadir est un correcteur dvelopp en Perl par K. Scannell. Il a t initialement cr pour le galique, puis adapt d'autres langues, principalement minoritaires, telles que le gallois, le breton, ou encore le tagalog.C'est un systme base de rgles. Les rgles sont crites manuellement, sous forme d'expressions rgulires, et s'appuient sur le contexte. Certaines servent la dsambigusation, les autres sont des rgles d'erreurs pour la vrification grammaticale.

Aprs avoir segment le texte en phrases, puis en tokens, le systme procde l'tiquetage morphosyntaxique des mots. Chacun reoit une tiquette, ou plusieurs s'il est ambigu.

Les rgles de dsambigusation interviennent alors pour retirer les tags inappropris, en fonction de leur contexte immdiat.

Le dernier traitement consiste ensuite dtecter les fautes grammaticales l'aide des rgles d'erreurs. Si le texte analys concide avec une rgle, cela signifie qu'il contient une erreur.Un message est alors renvoy l'utilisateur pour lui dcrire la faute dtecte et lui suggrer une correction.

Nous illustrons les diffrentes tapes de traitement dans An Gramadir avec la figure 2, dans laquelle nous voyons galement apparatre les traitements qui sont effectus par d'autres correcteurs. Nous pouvons ainsi situer An Gramadir par rapport aux autres outils dans le domaine.

Figure 2: Structure du correcteur An Gramadir

2.2. Adaptation de An Gramadir la correction grammaticale du franais

Pour adapter le correcteur de K. Scannell la langue franaise, plusieurs modifications ont t ncessaires, sur les diffrentes tapes de traitement.

2.2.1. La tokenization

Les premires modifications concernent la segmentation. Le tokenizer initial, cr pour le galique, n'tait en effet pas capable de traiter les apostrophes, les traits d'union, et les points contenus dans les sigles, trs frquents en franais.

CHUNKINGTOKENIZATIONDETECTION

DESFAUTES

rglesd'erreurs

rgles degrammaire

ou

Texte vrifier

phraseset

tokenstexte

tiquet


TAGGING


rglesprobabilits oucorpus

Textecorrig



La solution adopte dans (Lechelt, 2005) consiste rechercher dans le lexique les chanes de caractres qui contiennent un de ces signes problmatiques, et que le tokenizer rencontre. Les chanes prsentes dans le lexique sont conserves telles quelles, car elles sont considres comme un seul token. En revanche, les chanes qui ne figurent pas dans ce lexique sont dcomposes en deux units distinctes.

2.2.2. Le tagging

La mthode de tagging en elle-mme n'a pas t modifie dans (Lechelt, 2005). En revanche, il a bien sr fallu adapter un lexique tiquet franais en amont, et des rgles de dsambigusation en aval du tagger.

a) Le lexique tiquet

Pour effectuer le tagging, il est ncessaire d'avoir un lexique de formes flchies tiquetes morphosyntaxiquement. Le jeu d'tiquettes (ou tagset) de ce lexique doit tre dfini de manire permettre une bonne correction grammaticale, et doit tre compatible avec l'outil qui va l'utiliser.

Le lexique DICO [Web : DIC], de la Bibliothque Universelle ABU [Web : ABU], a t choisi pour tre implant dans An Gramadir. Pour cela, il a d subir plusieurs transformations, qui ont abouti la cration d'un nouveau lexique : InDico.

Un nouveau jeu d'tiquettes a d'abord t dfini, en fonction de celui de DICO, et des informations ncessaires une bonne correction. Des entres du lexique ont t modifies, supprimes ou ajoutes. Les informations morphosyntaxiques ont ensuite t traduites dans le formalisme de An Gramadir, et certaines ont t modifies en fonction du nouveau tagset. l'issu de toutes ces transformations, le nouveau lexique InDico a pu tre utilis dans An Gramadir pour tiqueter des textes en franais.

b) La dsambigusation

Une fois l'tiquetage effectu, s'est pos le problme de la dsambigusation. Des tests sur corpus ont fait ressortir 46% de mots ambigus, les plus nombreux tant les noms, les adjectifs, les dterminants et les verbes.

Une base de rgles de dsambigusation a donc t construite, en s'appuyant sur la mthode des rgles par dfaut explique par J. Vergne et E. Giguet (Vergne & Giguet, 1998).Ainsi, une premire srie de rgles particulires dsambiguse des cas prcis. Elle est suivie de rgles par dfaut qui sont un peu plus gnrales, et pour finir des rgles dites brutes traitent tous les cas d'ambigut non rsolus par les rgles prcdentes. Ces dernires rgles sont ncessaires dans la mesure o la vrification grammaticale dans An Gramadir ne tolre aucune ambigut.

2.2.3. La dtection des fautes

Dans (Lechelt, 2005), le premier travail concernant cette tape a t d'observer de nombreux textes produits sur internet, afin de dterminer les fautes de grammaire les plus courantes, et de traiter si possible celles-ci en priorit.Les principales erreurs mises en vidence par cette observation, et qui pouvaient a priori tre traites par An Gramadir, sont les diverses fautes d'accords (au sein du groupe nominal, entre


le sujet et le verbe) et les confusions entre homophones (a et sa / m'a et ma / et er / ces, ses, c'est et s'est).D'autres types de fautes sont ressortis, mais ne semblaient pas pouvoir tre traits avec An Gramadir. Il s'agit des erreurs de concordance des temps, des oublis de mots, comme la particule ne de la ngation par exemple, des fautes de style, ou encore des erreurs morphologiques, comme la contraction de de + le en du par exemple, ou bien l'lision devant une voyelle de certains mots grammaticaux comme que ou le.

Ce travail d'observation effectu, des rgles de dtection des fautes ont pu tre crites. Il s'agit de rgles d'erreurs, qui dcrivent des modles de fautes de grammaire, et qui permettent de signaler les erreurs dans le texte lorsqu'elles concident avec ceux-ci.

L'ensemble des rgles cres dans (Lechelt, 2005) permet de dtecter des fautes d'accords dans les syntagmes nominaux (dterminants, adjectifs et noms), entre le sujet et le verbe lorsqu'ils sont proches, ou bien entre le sujet et les adjectifs attributs, ou les participes passs, prcds de l'auxiliaire tre. Les rgles couvrent aussi quelques fautes de proximit phontique, comme ce et se, ou encore son et sont.

2.2.4. La rdaction des rgles

Nous avons vu que An Gramadir utilise des rgles la fois pour la dsambigusation et pour la dtection des fautes. Les deux types ont peu prs la mme structure. Elles sont constitues de balises et de noms de macros, dfinies dans un fichier part.

Les macros sont des expressions rgulires qui dcrivent des types de mots, en fonction de leur catgorie et de leurs traits. Elles vitent d'avoir citer tous les mots dans les rgles en donnant un identifiant gnral ceux de certains types. Par exemple, la macro suivante permet d'utiliser l'identifiant ANYDFS dans les rgles pour dsigner tout dterminant fminin singulier :

s/ANYDFS/(?:]*>)*(?:]*>)*/g

NB : les * dans les rgles signifient que le caractre prcdent peut tre prsent entre 0 et x fois. Ils sont distinguer de ceux qui prcdent les exemples agrammaticaux.

a) Les rgles de dsambigusation

Dans les rgles de dsambigusation, les balises entourent le mot ambigu et ses tags, qui sont eux-mmes entours des balises . Un espace spare le mot ambigu de son contexte droit et/ou gauche, qui est lui aussi entour de balises. La catgorie grammaticale du contexte dfinit le nom de ses balises. Ainsi, un nom sera entre et et un verbe entre et .La rgle est spare en deux parties par deux points ":". gauche se trouvent le mot ambigu et son contexte ; la partie droite consiste en une balise contenant le tag attribuer au mot ambigu.Une rgle de dsambigusation est donc du type :

ANYDFSANYTHING ANYTHING:

ANYDMS correspond au nom de la macro que nous avons donne en exemple plus haut.ANYTHING correspond une macro qui dcrit une chane quelconque de caractres.Ainsi, la rgle ci-dessus signifie qu'un dterminant fminin singulier ambigu, suivi d'un nom quelconque, est un dterminant fminin singulier ().


Nous avons vu plus haut que les rgles de dsambigusation sont de trois types : particulires, par dfaut et brutes. L'ordre dans lequel les diffrents types de rgles apparaissent dans le fichier est trs important. Les rgles les plus gnrales doivent se trouver la fin, pour que toutes les rgles plus prcises puissent s'appliquer auparavant.

b) Les rgles d'erreurs

Tout comme les rgles de dsambigusation, les rgles d'erreurs sont constitues de balises et de noms de macros. La partie gauche dcrit le contexte de la faute, c'est--dire les lments proches du mot qui entretiennent une relation avec lui, et la partie droite indique le type d'erreur.Ainsi, la rgle suivante dcrit une erreur d'accord en nombre entre un dterminant singulier (macro DS) et un nom pluriel (macro NP) :

ANYTHING ANYTHING:NOMBRE

Nous pouvons d'ores et dj constater que les macros et les rgles de An Gramadir sont difficilement lisibles et comprhensibles. Il parat peu envisageable que des linguistes se lancent dans la rdaction de nouvelles rgles, moins qu'ils ne soient aussi de bons informaticiens.

2.3. valuation et perspectives

Nous venons d'exposer les diffrents traitements dont An Gramadir a fait l'objet dans (Lechelt, 2005) pour son adaptation au franais. Il tait ncessaire ensuite d'valuer la version ainsi modifie, afin d'observer son efficacit et ses limites, puis de dterminer les amliorations apporter pour obtenir un outil bien adapt la langue franaise.

2.3.1. valuation et limites de An Gramadir

a) valuation par GRACE

L'valuation a principalement port sur la nouvelle version du tagger, aprs modifications. La dtection des fautes tant dpendante du tagging, il tait primordial de mesurer celui-ci pour pouvoir ensuite travailler sur la vrification grammaticale.

Cette valuation du tagger a t ralise l'aide des outils de GRACE (Grammaire et Ressources pour les Analyseurs de Corpus et leur valuation) [Web : GRC]. Ces outils permettent, entre autre, de mesurer la qualit des analyseurs morphosyntaxiques en termes de dcision (proportion de mots dsambiguss) et de prcision (proportion de mots dsambiguss correctement).

Les rsultats obtenus ont permis d'effectuer les modifications ncessaires dans l'ordre des rgles de dsambigusation, afin d'obtenir les meilleurs taux de dcision et de prcision possibles. Finalement, les rgles permettent donc de dsambiguser 98,88% des mots ambigus (dcision), dont 84,49% avec le bon tag (prcision).

L'valuation a aussi permis de mettre en vidence des erreurs d'tiquetage et des mots non dsambiguss.


b) Limites du systme pour la correction du franais

Comme nous l'avons dit, la dtection des fautes est dpendante de l'tiquetage. Or, l'valuation du tagger a montr ses faiblesses. Ce qui conduit une premire limitation que nous pouvons voquer. Elle concerne les rgles de dsambigusation. Nous avons vu qu'elles sont fondes sur l'environnement immdiat du mot ambigu. Or ceci peut poser plusieurs problmes.

Tout d'abord, certains mots dpendent d'un contexte loign et ne peuvent donc pas tre dsambiguss d'aprs leur environnement immdiat. Ensuite, le contexte sur lequel s'appuient les rgles est susceptible d'tre faux, ou inconnu. Il ne faut pas oublier que le but final de l'outil est de dtecter des fautes, et qu'il y a donc probablement des fautes dans le texte, et donc dans le contexte. D'autre part, il est tout fait possible que l'environnement immdiat d'un mot ambigu soit lui-mme ambigu. Dans ce cas, les rgles ne peuvent pas non plus s'appliquer.Ces diffrents problmes sont l'origine de nombreuses erreurs ou absences de dsambigusation.

La seconde limite dcoule en partie de la premire et concerne les rgles de dtection des fautes. En effet, les rgles d'erreurs s'appliquent principalement sur les tiquettes des mots. Si celles-ci sont errones suite une mauvaise dsambigusation, certaines rgles deviennent inutilisables et laissent passer des fautes de grammaire. Mais les erreurs d'tiquetage peuvent aussi venir directement du lexique utilis pour le tagging. S'il contient des erreurs, des mots mal tiquets, ou bien au contraire s'il ne contient pas certains mots avec certaines tiquettes, les anomalies sont rpercutes directement sur le texte.

Nous pouvons enfin rappeler qu'un des dfauts des rgles est d'imposer la prvision de toutes les fautes susceptibles d'tre commises, ce qui est impossible. (Lechelt, 2005) a calcul par exemple qu'il y avait 1458 combinaisons possibles pour un syntagme nominal du type dterminant + nom + adjectif et dterminant + adjectif + nom. Ceci est d au fait que chacune de ces trois catgories peut avoir le genre masculin, fminin ou picne (masculin et fminin identiques), et le nombre singulier, pluriel ou invariable.Mme si nous ne tenons pas compte des combinaisons correctes, qui n'ont pas leur place parmi les rgles d'erreurs, si nous voulons crer une rgle pour chaque combinaison fausse possible, la quantit de rgles ncessaires reste trs lourde.De plus, nous n'avons voqu ici que des combinaisons relatives aux syntagmes nominaux, avec un seul dterminant, nom et adjectif. En ralit, les mots ne se combinent pas toujours de manire aussi simple, et il est en fait impossible, en franais, d'numrer exhaustivement toutes les combinaisons de mots qui peuvent tre rencontres. Nous pourrions crer un trs grand nombre de rgles, mais elles ne couvriraient jamais toute les possibilits de la langue, et alourdiraient considrablement le traitement.

2.3.2. Perspectives

a) Amliorations de An Gramadir

Nous avons vu que les erreurs d'tiquetage sont un point faible du systme. Ces erreurs peuvent venir du lexique ou dcouler d'une mauvaise dsambigusation, et sont responsables ensuite d'autres erreurs de dsambigusation, et de mauvaises dtections des fautes de grammaire.


Parmi les propositions pour amliorer An Gramadir, outre la ncessit d'augmenter le nombre de rgles de dsambigusation, il a donc d'abord t suggr, dans (Lechelt, 2005), de retravailler le lexique :

Il faudrait commencer par vrifier et uniformiser les entres, dont certaines sont incohrentes. En effet, des mots picnes ou invariables apparaissent sous deux entres distinctes : masculin et fminin, ou bien singulier et pluriel. Il serait bon de n'avoir qu'une seule entre, avec un tag "picne" ou "invariable" selon les cas. Les pronoms auraient aussi besoin d'tre uniformiss.

Certains tags pourraient ensuite tre complts avec de nouveaux traits, pour affiner la dsambigusation. Par exemple, le trait antpos ou postpos pour les adjectifs, le traits verbe d'tat, un trait sur la transitivit des verbes, etc. L'ajout d'une transcription phontique permettrait une meilleure dtection des fautes de proximit phontique.

Nous pourrions enrichir le lexique avec d'autres lexiques spcialiss disponibles, comme celui des noms propres.

Le lexique et ses tags devraient tre rcrits au format XML, ce qui faciliterait le traitement des donnes par le correcteur.

Un autre point faible de An Gramadir concerne les rgles d'erreurs, qui ne dtectent qu'une petite varit de fautes et ne sont pas assez nombreuses. Il faudrait donc les complter, mais aussi utiliser les possibilits offertes par le dcoupage en chunks, ou syntagmes. Comme nous allons le voir dans le point suivant, les chunks seraient utiles pour dtecter d'autres types d'erreurs, comme la concordance des temps, les accords sujet-verbe, ou encore les accords des participes passs aprs l'auxiliaire avoir. Il n'est en effet pas possible de dtecter de telles fautes avec un systme uniquement fond sur le contexte immdiat.

b) Approche alternative pour la conception d'un nouvel outil

An Gramadir n'a pas t conu pour une langue comme le franais, et son adaptation a permis de mettre en vidence ses limites pour traiter une telle langue. Une approche alternative a donc t propose dans (Lechelt, 2005) pour concevoir entirement un nouvel outil.

La nouvelle approche propose combine deux principes linguistiques : le dcoupage en chunks et l'unification de structures de traits.

Le dcoupage en chunksLe chunk, que nous venons d'voquer, est une unit constitue d'une srie de mots tous

contigus les uns aux autres et regroups autour d'une tte lexicale, le plus souvent un nom ou un verbe, plus rarement un adverbe, un adjectif ou un pronom. (E. Giguet 98). Cette notion de groupe de mots peut s'avrer trs utile, notamment pour vrifier les accords sujet-verbe lorsque le sujet n'est pas un simple pronom personnel.

Les chunks ont la proprit de ne pas pouvoir se chevaucher ou s'imbriquer. Le dbut d'un chunk implique donc la fin du chunk prcdent. Il est aussi facile de les dfinir en fonction de leurs limites, qui peuvent tre la ponctuation, les conjonctions, les pronoms relatifs, les prpositions, les dterminants, etc. Il n'est alors pas ncessaire de construire une liste fige de tous les modles de chunks possibles, ce qui serait impossible en franais.


L'unification de structures de traitsLes structures de traits dcrivent chaque lment d'une phrase un numrant ses

caractristiques linguistiques, syntaxiques ou smantiques, sous la forme de liste de couples trait-valeur. Les tiquettes des mots en sont un exemple. Les informations contenues dans les tags correspondent aux traits.

L'unification consiste combiner les traits de deux tags et vrifier leur compatibilit. Deux structures de traits peuvent s'unifier si elles ont les mmes valeurs pour des traits identiques, mais pas dans le cas de valeurs contradictoires pour un mme trait.

Par exemple, l'unification n'est pas possible entre le tag du nom genoux et celui du dterminant le, car la valeur du trait nombre n'est pas identique :

En utilisant l'unification de structure de traits, la dtection des fautes au sein d'un chunk est possible, mme si un mot est ambigu ou mal tiquet. De plus, en attribuant des traits au chunks, ils peuvent alors s'unifier entre eux, et des erreurs entre groupes de mots peuvent ainsi tre dtectes, comme par exemple l'accord entre le groupe nominal sujet et le groupe verbal.Il faut cependant veiller corriger d'abord les fautes "intra-chunk", de manire ce que le chunk possde les bons traits, pour pouvoir s'unifier par la suite aux autres chunks lors de la vrification "inter-chunks".

3. LanguageTool Parmi les correcteurs analyss dans (Lechelt, 2005), LanguageTool de D. Naber a t rejet l'poque, avec hsitation. Comme An Gramadir, il se fondait sur des rgles d'erreurs rdiges la main, mais il procdait diffremment quant au tagging et la dtection des fautes.Nous allons voir que depuis l'analyse ralise par Lechelt (2005), LanguageTool a beaucoup volu. La version disponible aujourd'hui semble tre bien mieux adapte la correction du franais que ne l'tait celle de l'poque.

3.1. Rejet de la premire version de l'outil

3.1.1. Structure de LanguageTool l'poque

La figure 3 ci-dessous reprsente la structure de la premire version de LanguageTool. Elle utilisait la fois des rgles, pour la correction, et des probabilits pour la dsambigusation. Elle tait compose de plusieurs modules programms dans le langage python.

Legenre = masculinnombre = singulier

genouxgenre = masculinnombre = plurielU = chec


Figure 3: Structure de LanguageTool - version 1

Le texte tait d'abord dcoup en phrases, puis en mots. Les mots taient ensuite tiquets, et dsambiguss par une mthode statistique, qui ncessitait au pralable un apprentissage sur corpus. Pour chaque mot, LanguageTool dterminait la probabilit que ce mot ait tel tag, puis la probabilit qu'il se trouve dans un certain contexte (entre un tag A et un tag B ). Le tag pour lequel la somme de ces deux probabilits tait la plus forte tait appliqu au mot. Des rgles crites manuellement venaient en complment pour dsambiguser les mots qui n'avaient pas pu l'tre avec le systme de probabilits.

Suite au tagging, LanguageTool effectuait une tape de chunking, c'est--dire de segmentation des phrases en syntagmes minimaux (chunks), principalement nominaux ou verbaux. Les chunks taient dtermins en fonction de patrons prdfinis, contenus dans un fichier. Les rgles dfinissant les patrons de chunks taient du type : dbut de chunk, fin de chunk, nom du chunk. Lors de l'analyse de la phrase, si une suite de mots correspondait un modle, alors cette suite tait dfinie comme chunk. C'tait un atout par rapport An Gramadir, mme s'il ne s'agissait que d'un chunker trs basique.

Arrivait enfin l'tape de dtection des fautes de grammaire. Cette tape utilisait une base de rgles d'erreurs formalises en XML. Chaque rgle contenait un identifiant (id), un nom (name), le modle de l'erreur (pattern), une explication de la rgle (message) destination de l'utilisateur, et un exemple de l'erreur commise (example).Les rgles pouvaient aussi bien porter sur les mots que sur les tags ou sur les chunks.

L'exemple suivant correspond un extrait d'une rgle d'erreur d'accord entre un dterminant et un nom en anglais, dans le cas o a, an ou one sont suivis d'un chunk nominal pluriel (NPP) :

"(a|an|one)"_NPPFor plural nouns use the plural article the

Pour dtecter les fautes, le systme comparait le texte avec les rgles d'erreurs, et plus prcisment avec le pattern de chaque rgle. S'il y avait correspondance, le systme indiquait qu'une erreur avait t dtecte.

TOKENIZATIONDETECTION

DESFAUTES

rglesd'erreurs

rgles degrammaire

ou

Texte vrifier

phraseset

tokenstexte

tiquet


TAGGING



Textecorrig


CHUNKING


3.1.2. Points faibles l'origine du rejet

Le rejet de LanguageTool, lors de l'analyse des diffrents correcteurs, avait sa principale origine dans l'utilisation de probabilits pour le tagging. Mais les tests raliss sur l'outil avaient aussi mis en vidence d'autres points faibles.

Tout d'abord, comme nous venons de l'voquer, le tagger utilisait une mthode probabiliste qui avait sembl moins matrisable qu'un tagging base de rgles. En effet, s'il y a une erreur de dsambigusation, il est impossible de savoir d'o elle vient. En utilisant des rgles, il est plus facile de retrouver et modifier la rgle qui gnre une erreur de dsambigusation. Par contre, les rgles ont l'inconvnient de devoir tre trs nombreuses pour couvrir le plus de cas possibles.

Ensuite, pour dterminer les probabilits ncessaires au tagger, il fallait effectuer une phase d'apprentissage sur un corpus tiquet, or il n'en existait pas de libre. Il aurait donc fallu en constituer un, contenant le plus de structures syntaxiques possibles, afin d'avoir des probabilits pour un maximum de cas. Cela aurait demand un travail considrable, et il n'tait de toutes manires pas possible de construire un corpus exhaustif.

Par ailleurs, le fait de devoir recourir un corpus pour l'apprentissage entrane une dpendance totale ce corpus, pour tous les traitements et les dtections de fautes ultrieures.

En ce qui concerne les rgles d'erreurs, elles s'appliquaient sur des mots ou des chunks. Or, les rgles de formation des syntagmes induisaient que dans certains cas, comme par exemple un nom singulier seul, un mot n'tait pas intgr un chunk alors qu'il aurait d l'tre. Les rgles s'appuyant normalement sur un syntagme pour dtecter une erreur, ne pouvaient donc plus s'appliquer si elles rencontraient un mot la place, mme s'il y avait effectivement une erreur. Ces rgles devaient par ailleurs tre les plus exhaustives possibles, et le chunking le plus prcis possible, afin de couvrir un maximum de fautes et de limiter ainsi le silence (non-dtection de certaines fautes).

Pour finir, rappelons que LanguageTool a t initialement cr pour la langue anglaise. Sa grammaire est telle qu'elle permet de crer une liste assez complte des patrons de chunks. Or, en franais, il n'est pas envisageable d'numrer tous les syntagmes.

3.2. volutions et nouvelle version de l'outil

3.2.1. volutions du systme

LanguageTool a beaucoup volu depuis l'analyse de la premire version, et semble pouvoir tre mieux adapt pour la correction du franais.

Le programme a tout d'abord t entirement rcrit en Java, pour un meilleur support du format XML utilis pour les rgles. La DTD de ces rgles a d'ailleurs t amliore.

Un nouvel tiqueteur morphosyntaxique, plus compact, a t implant. En revanche, tel que nous pouvons le voir dans la figure 4 qui suit, le dsambiguseur a t supprim, ainsi que le dcoupage en chunks. Ils taient en effet peu utiles pour les langues supportes (l'anglais principalement), et surtout l'origine d'erreurs d'tiquetage, entranant par la suite beaucoup de bruit (dtection de fautes qui n'en sont pas).


Un dveloppement de l'intgration de l'outil dans la suite OpenOffice.org a par ailleurs t ralis. Ceci nous intresse particulirement puisque l'un de nos objectifs est d'y implanter la correction grammaticale du franais.

Signalons aussi d'autres amliorations de LanguageTool, qui ne nous concernent pas toutes directement pour l'adaptation au franais. Par exemple, de nombreuses rgles ont t ajoutes, pour la gestion notamment des majuscules, des faux-amis ou de la ponctuation, et de nouveaux tags sont venus complter le jeu d'tiquettes existant.

3.2.2. Structure actuelle de LanguageTool

Figure 4: Structure de LanguageTool - Version 2

La nouvelle structure de LanguageTool, telle qu'illustre dans la figure 4, est actuellement compose de plusieurs classes Java qui effectuent :

la segmentation du texte en phrases, puis en mots

l'tiquetage morphosyntaxique des mots : partir d'un lexique de formes flchies, chacune ayant une tiquette avec des informations morphosyntaxiques (catgorie grammaticale et traits de sous-catgorisation), chaque mot du texte reoit une tiquette, ou plusieurs s'il est ambigu. Aucune dsambigusation n'tant effectue, les mots qui ont plusieurs tiquettes les conservent toutes. Ainsi bte aura 3 tags : "nom fminin singulier", "adjectif masculin singulier" et "adjectif fminin singulier".

la dtection des erreurs de grammaire : elle s'effectue par comparaison du texte avec une base de rgles dcrivant des erreurs. Si une partie du texte correspond une rgle, alors une faute est signale.

Les rgles d'erreurs sont formalises en XML, et composes de plusieurs lments :

id et name : l'identifiant et le nom de la rgle. pattern : le modle de l'erreur. Le texte lui est compar lors de la vrification. Il se

prsente gnralement sous forme d'expressions rgulires. message : une description de la rgle, l'usage de l'utilisateur. example : un exemple d'nonc correspondant la faute commise. Il y a en gnral au

moins deux exemples : un exemple d'nonc correct et un exemple d'nonc incorrect.

CHUNKING

TAGGING

DsambigusationtiquetagemorphosyntaxiqueTOKENIZATIONDETECTION

DESFAUTES

rglesd'erreurs

rgles degrammaire

ou

Texte vrifier

phraseset

tokenstexte

tiquet



Textecorrig



Voici un exemple de rgle en franais :

ma

Voulez vous crirem'a?

Il marpondu.

Il m'arpondu.

Cette rgle dtecte une confusion dans l'utilisation des homophones m'a et ma. Si le texte vrifier contient ma suivi d'un verbe (V.*), alors il y a une erreur. Dans ce cas, un message est renvoy l'utilisateur : le token ma est mis en vidence (mark_to="-1"), et le message et les exemples s'affichent.

4. Conclusion

Dans ce chapitre, aprs avoir fait une prsentation gnrale des correcteurs grammaticaux, nous avons rsum le travail ralis par Lechelt (2005) sur l'un d'entre eux, An Gramadir pour l'adapter la correction grammatical du franais. Cette adaptation a mis en vidence les limites de l'outil, pour le traitement du franais. Ces limites viennent d'une part de rgles qui s'appuient sur un contexte potentiellement faux ou ambigu, d'autre part de rgles qui reposent sur un systme de pattern matching rigide et qui impliquent de prvoir toutes les combinaisons de mots possibles.

Malgr les propositions de Lechelt (2005) afin d'amliorer l'adaptation de An Gramadir, le systme reste limit pour la correction du franais. La conception d'un nouvel outil, fond sur l'unification de structures de traits et sur le chunking, a sembl tre la meilleure alternative. Il a donc t dcid de laisser An Gramadir de ct.

Nous avons aussi prsent le correcteur LanguageTool. S'il a t rejet l'poque dans (Lechelt, 2005), pour l'adaptation au franais, il a aujourd'hui beaucoup volu. Sa structure actuelle permettrait de dpasser les limites atteintes par An Gramadir.Dans le chapitre suivant, nous prsentons le travail effectu sur LanguageTool, dont l'importation de toutes les rgles crites par Lechelt (2005).

Chapitre 2 : Adaptation de LanguageTool la correction du franais 22

Chapitre 2 : Adaptation de LanguageTool la correction du franais

Comme nous l'avons dj indiqu, LanguageTool pourrait devenir, aprs quelques modifications, un correcteur grammatical bien adapt au franais. C'est pourquoi nous avons dcid de commencer travailler sur cet outil.Ce chapitre dcrit comment nous avons dot le correcteur des rgles ncessaires la dtection des fautes de grammaire.

Tout d'abord, nous avons test rapidement quelques rgles en franais, dj prsentes dans le correcteur. Ce test nous a permis de mettre en vidence les inconvnients de l'absence de dsambiguseur dans LanguageTool. Nous avons donc t amene en dvelopper un prototype.

Notre travail a consist ensuite importer les rgles crites pour An Gramadir. Nous allons voir les problmes rencontrs, ainsi que les diffrentes modifications que nous avons d apporter aux rgles pour qu'elles fonctionnent correctement dans LanguageTool.Nous avons aussi complt la base de rgles d'erreurs, partir d'un corpus de fautes que nous avons tudi, et dont nous avons extrait des erreurs non encore traites par le programme.Pour finir avec ce travail sur les rgles, nous verrons quelle est la typologie des fautes que LanguageTool est finalement capable de dtecter en franais.

1. Test des rgles existantes

Parmi les rgles d'erreurs crites par Lechelt (2005) pour An Gramadir, une petite dizaine avait t importe dans LanguageTool par Marcin Mikowski, un des principaux dveloppeurs du programme. Dans un premier temps notre travail a consist tester rapidement ces quelques rgles, afin de nous familiariser avec le formalisme utilis, et de reprer des problmes ventuels, pour nous permettre par la suite de raliser l'importation des nouvelles rgles dans les meilleures conditions.

1.1. Test et erreurs dtectes

Les rgles franaises dj prsentes dans LanguageTool concernent la confusion entre des mots grammaticaux homophones : a/sa, a/, se/ce, ma/m'a et sont/son.

Nous avons test ces rgles sur des petites phrases trs simples, que nous avons crites. Chacune contient au moins un des mots sur lesquels portent les rgles. Le tableau ci-aprs reprend quelques unes de ces phrases, et donne en colonne de droite la suggestion de correction indique par le programme. Les phrases prcdes de "*" sont des phrases agrammaticales.


Phrase teste Correction suggre1. Sa voiture est en panne. *a voiture est en panne2. *a voiture est en panne. Sa voiture est en panne.3. La visite a dur longtemps. *La visite dur longtemps.4. *La visite dur longtemps. Phrase correcte5. Il se livre la police. *Il ce livre la police.6. *Il ce livre la police. Il se livre la police.7. Je peux utiliser ce tlphone ? *Je peux utiliser se tlphone ?8. *Je peux utiliser se tlphone ? Phrase correcte9. Ces traits ne sont pas droits. *Ces traits ne son pas droits.10. *Ces traits ne son pas droits. Phrase correcte11. Il a publi son livre. *Il a publi sont livre.12. *Il a publi sont livre. Il a publi son livre.

Le tableau ci-dessus permet de faire plusieurs observations. Tout d'abord, les phrases correctes (1, 3, 5, 7, 9 et 11) sont toutes dtectes comme fausses, et les suggestions de correction les concernant contiennent toutes une erreur. Ensuite, parmi les phrases agrammaticales (2, 4, 6, 8, 10 et 12), la moiti d'entre elles est corrige correctement, mais dans l'autre moiti, l'erreur n'est pas dtecte.Par ailleurs, pour les phrases 1-2, 5-6 et 11-12, la correction d'une phrase teste correspond l'autre phrase teste. Ainsi, 2 est la correction de 1, et 1 est la correction de 2. Que nous crivions a ou sa dans les phrases 1 et 2, ce ou se dans les phrases 5 et 6, ou encore son ou sont dans les phrases 11 et 12, la phrase n'est donc finalement jamais considre comme correcte.

1.2. Problme de l'ambigut catgorielle

Nous avons vu prcdemment que la dernire version de LanguageTool ne fait pas de dsambigusation. Sachant cela, les rsultats obtenus notre test n'ont rien de surprenant.

Les mots ambigus ont plusieurs tags. Lors de l'application des rgles d'erreurs, il suffit que l'un d'entre eux corresponde une rgle pour que celle-ci soit applique, mme si un ou plusieurs autres tags du mot ne correspondent pas cette rgle.

Prenons en exemple les deux rgles portant sur la confusion entre sa et a :

1. Si sa est suivi d'un verbe ou d'un pronom, alors il y a une erreur. Il faut remplacer sa par a.

2. Si a est suivi d'un nom, alors il y a une erreur. Il faut remplacer a par sa.


Prenons maintenant les deux phrases suivantes, ainsi que leur tiquetage ralis par LanguageTool :

a) Sa voiture est en panne.

Sa [Sa/D f s]voiture [voiture/V sub pres 1 s,

voiture/V sub pres 3 s,voiture/V imp pres 2 s,voiture/V ind pres 1 s,voiture/V ind pres 3 s,voiture/N f s]

est [est/V etre ind pres 3 s,est/J e p,est/J e s,est/N m s]

en [en/P,en/R pers obj e sp]

panne [panne/V sub pres 1 s,panne/V sub pres 3 s,panne/V imp pres 2 s,panne/V ind pres 1 s,panne/V ind pres 3 s,panne/N f s]

. [./M fin,]

b) *a voiture est en panne.

a [a/A,

a/R dem m s]voiture [voiture/V sub pres 1 s,

voiture/V sub pres 3 s,voiture/V imp pres 2 s,voiture/V ind pres 1 s,voiture/V ind pres 3 s,voiture/N f s]

est [est/V etre ind pres 3 s,est/J e p,est/J e s,est/N m s]

en [en/P,en/R pers obj e sp]

panne [panne/V sub pres 1 s,panne/V sub pres 3 s,panne/V imp pres 2 s,panne/V ind pres 1 s,panne/V ind pres 3 s,panne/N f s]

. [./M fin,]


Nous voyons que le mot voiture a plusieurs tiquettes. Il peut s'agir du nom fminin voiture (voiture/N f s) ou du verbe voiturer (voiture/V ...). Il est donc ambigu au niveau de la catgorie.

Lors de la vrification des phrases, tous les tags d'un mot sont pris en compte pour l'application des rgles.La rgle 1 s'applique, tort, la phrase a) car elle trouve sa, suivi d'un mot tiquet "verbe". Il aurait fallu ici que le tag "verbe" soit ignor et que seul le tag "nom" soit pris en compte puisque c'est celui qui correspond au mot voiture dans cet exemple.La rgle 2. s'applique la phrase b) car elle trouve a, suivi du mot tiquet "nom". Il est alors suggr de remplacer a par sa. Ici, la dtection est correcte. Il y a bien une faute.

Les noncs a) et b) sont donc tout deux considrs comme faux cause de la prsence de plusieurs tiquettes pour le mot voiture.

1.3. Tentative de contournement du problme

Nous avons tent de rduire le bruit provoqu par la rgle 1 en la modifiant. Par exemple :sa, suivi d'un verbe, suivi de tout mot l'exclusion d'un verbe.Il est rare que deux verbes se suivent, sauf dans les temps composs. En dehors des auxiliaires, s'il y a deux verbes aprs sa, c'est alors sans doute parce que le premier est en fait ambigu avec un nom. Dans ce cas, aucune erreur ne doit tre dtecte, et la rgle doit donc tre applique au contraire s'il n'y a pas deux verbes aprs sa.La rgle ainsi modifie permet de pallier en partie le problme de l'ambigut de voiture, mais nous avons ralis alors qu'il serait ncessaire d'avoir des rgles beaucoup plus complexes et prcises pour contourner l'absence de dsambigusation, et le fait que beaucoup de mots ont plusieurs tiquettes.

Nous avons donc pris conscience du fait qu'il est absolument ncessaire d'ajouter un dsambiguseur LanguageTool, entre le tagging et la vrification des phrases.

Le petit test ralis n'avait pas pour but d'valuer la qualit du programme. Il nous a juste permis de nous familiariser un peu avec lui, et surtout de mettre en vidence un des principaux problmes de l'outil, savoir l'ambigut des tags d'un grand nombre de mots.

2. Implantation d'un dsambiguseur

La version de LanguageTool sur laquelle nous avons travaill disposait depuis peu d'une interface pour l'implantation d'un dsambiguseur, mais l'outil en lui mme n'avait pas t dvelopp. Nous avons donc rflchi la manire de le raliser.

2.1. Choix d'un type de dsambiguseur

Comme nous l'avons expliqu dans le chapitre 1 dans le point 1.2. sur la structure d'un correcteur grammatical, il existe deux types de dsambiguseurs : statistiques, ou base de rgles. Nous avons dj mentionn plusieurs dfauts des outils statistiques, comme la ncessit d'un corpus d'apprentissage et la dpendance celui-ci. Notre choix a donc port sur un dsambiguseur base de rgles. De plus, nous disposions dj d'une base de rgles que nous pouvions rutiliser, savoir celle crite par Lechelt (2005), pour An Gramadir.


2.2. Choix d'un formalisme pour les rgles

Un formalisme est un langage qui permet de dcrire des phnomnes linguistiques de manire non-ambigu, afin de pouvoir tre compris et trait par un ordinateur. Il possde pour cela les mmes caractristiques que les langages informatiques, savoir la non-ambigut smantique et syntaxique.

Notre choix ayant port sur un dsambiguseur base de rgles, il nous fallait dfinir un formalisme pour reprsenter ces rgles. Nous avions plusieurs possibilits :

Nous pouvions les rcrire dans un simple format texte, en supprimant les balises (, , etc.) et en sparant les informations par des tabulations par exemple. L'avantage de cette mthode est la rapidit de traitement par le programme.Nous pouvions aussi utiliser des expressions rgulires, un peu comme dans An Gramadir, avec le systme "rechercher-remplacer". Mais de telles rgles sont compliques rdiger, et leur traitement coteux en Java.

La solution qui nous a sembl la meilleure tait la rcriture en XML. Bien que plus lourd traiter par le programme, ce formalisme a plusieurs avantages. Tout d'abord, il est dj utilis pour les rgles d'erreurs. Il semble plus cohrent que les diffrents types de rgles soient reprsents de manire similaire au sein d'un mme programme. C'est aussi un formalisme assez ouvert qui permet l'implantation de nombreuses fonctionnalits et l'criture simplifie de rgles.Mais il est surtout beaucoup plus facilement lisible et modifiable par des linguistes, qui ne sont pas ncessairement informaticiens. Ceci est un point trs important si nous voulons raliser un correcteur accessible toute personne souhaitant contribuer son dvelopement et l'enrichissement de la base de rgles.

Dans le chapitre 2 dans le point 3.1., nous expliquons comment nous avons rcrit les rgles de dsambigusation pour les adapter au formalisme que nous avons choisi.

2.3. Intgration dans LanguageTool

Aprs avoir dfini le type d'outil ncessaire, il ne nous restait plus qu' en crire le code en Java.

Nous avons commenc par tudier la manire dont les rgles d'erreurs en XML sont charges, puis utilises par le programme, puisque nous devons raliser un traitement peu prs similaire pour les rgles de dsambigusation. Nous avons identifi les classes impliques dans le processus, et que nous devions adapter pour l'implantation d'un dsambiguseur.

Comme nous ne matrisions pas suffisamment le langage Java pour raliser nous mme le code dans un dlai raisonnable, Mikowski, un dveloppeur de LanguageTool qui avait ralis l'importation des premires rgles franaises, nous a propos son aide.Pour crire le code ncessaire l'implantation de notre dsambiguseur, il avait besoin d'un fichier XML contenant quelques rgles, de la DTD1 correspondante, ainsi que d'un petit corpus de phrases pour effectuer des tests.Pour la DTD, nous avons repris celle des rgles d'erreurs, rules.dtd, puisque nous avons choisi

1 La DTD (Document Type Definition) est document associ des fichiers XML, et qui dfinit le modle de structure que ces fichiers XML doivent respecter. Elle indique les noms des lments pouvant apparatre, ainsi que leur contenu (sous-lments et attributs) http://fr.wikipedia.org/wiki/DTD


d'utiliser le mme formalisme. Nous y avons ajout un lment et son attribut postag, et avons retir les lments inutiles pour la dsambigusation, comme par exemple , ou .Le fichier XML a ensuite t cr avec quelques rgles simples de dsambigisation extraites de An Gramadoir dont la structure est prsente dans le point suivant.Nous avons enfin rdig quelques phrases pour tester le dsambiguseur. Ce sont des phrases elles aussi trs simples, mais qui ont la particularit de gnrer de nombreuses fausses alarmes lors de la dtection des fautes, du fait de la mauvaise, ou plutt de l'absence de dsambigusation.

Ces trois fichiers ont permis Mikowski d'implanter trs rapidement un dsambiguseur oprationnel pour le franais. Notre travail d'importation des rgles de An Gramadir en a t facilit. Il en est de mme quant la rdaction ultrieure de nouvelles rgles. Sans ce nouvel outil, nous aurions t obligs de contourner les ambiguts en grant des exceptions au sein des rgles d'erreurs, qui auraient alors t beaucoup plus complexes et sans doute moins efficaces.

3. Importation des rgles de An Gramadir dans LanguageTool

Dans le chapitre prcdent, nous avons parl des rgles construites par (Lechelt, 2005) pour An Gramadir, savoir les rgles pour la dsambigusation et pour la dtection des fautes. Nous avons rcrit toutes ces rgles de manire ce qu'elles soient utilisables dans le formalisme de LanguageTool.

3.1. Importation des rgles de dsambigusation

3.1.1. Reprsentation en XML

LanguageTool ne disposait pas de dsambiguseur avant que Mikowski ne nous aide en implanter un. Il n'existait pas de fichier de rgles de dsambigusation au sein du programme. Nous avons donc cr un nouveau fichier de rgles, et dfini une manire de reprsenter ces rgles en XML, le formalisme choisi.

Pour commencer, rappelons la structure des rgles de dsambigusation de An Gramadir :

ANYDFSANYTHING ANYTHING:

De manire gnrale, le mot ambigu et ses tags sont entours des balises , son contexte, droit ou gauche, est entour de balises indiquant sa catgorie, et la partie droite de la rgle, isole par ":", prcise le tag appliquer.Pour rcrire les rgles en XML, nous devons donc pouvoir indiquer quel est le mot ambigu, de quoi est constitu son contexte immdiat, et quel est le tag appliquer pour supprimer ou rduire l'ambigut.

Nous avons choisi de garder une structure aussi proche que possible de celle dj utilise pour les rgles d'erreurs. Redonnons en exemple la structure de la rgle prsente au point 3.2.2 du chapitre 1 :


ma

Voulez vous crirem'a?

Il marpondu.

Il m'arpondu.

Pour les rgles de dsambigusation, nous avons modifi cette structure de la manire suivante :

Les attributs mark_to et mark_from, permettant d'indiquer l'emplacement de l'erreur, ont simplement t remplacs par mark. Cet attribut de permet de dsigner le mot qui est ambigu. Mark="0" indique que c'est le premier token du qui doit tre dsambigus.

Les lments et ont t supprims car il n'y a pas d'information renvoyer l'utilisateur.

Un lment a t ajout. Il contient la nouvelle tiquette appliquer au mot ambigu, la place de celles qu'il possde dj.

Voici la reprsentation que nous obtenons de la rgle de dsambigusation donne en exemple plus haut :

Le token dsign comme ambigu par l'attribut mark du pattern est le dterminant D f s. Certains dterminants peuvent en effet avoir aussi une tiquette "Nom", "Adjectif", ou encore "Pronom personnel objet". La rgle indique que si le dterminant est suivi d'un nom quelconque ("N.*"), il doit alors prendre le tag : dterminant fminin singulier ("D f s").Ainsi, dans la phrase "la fuite est rpare", cette rgle peut dsambiguser la, qui a 3 tiquettes possibles ("nom fem. sing.", "pronom pers. obj. 3me pers. fem. sing.", "dt. fem. sing.") et lui donner le tag de dterminant fminin singulier ("D f s").

3.1.2. Rcriture des rgles

Une fois leurs structures dfinies, nous avons pu commencer la rcriture des rgles de dsambigusation de An Gramadir. Comme elles n'taient pas trs nombreuses (environ 150), nous avons procd manuellement, en prenant soin d'effectuer quelques tests de contrle au fur et mesure.


Comme nous l'avons mentionn dans le chapitre 1, Lechelt (2005) a dfini trois types de rgles de dsambigusation (particulires, par dfaut, brutes), dont l'ordre d'apparition a une grande importance. Nous avons donc cr notre fichier de rgles en XML en essayant de conserver cet ordre.

a) Gnralisation et regroupement de certaines rgles

Nous avons trs vite pu remarquer que le formalisme XML, beaucoup plus souple que celui de An Gramadir, permettrait de gnraliser, de regrouper certaines rgles, et d'en rduire ainsi le nombre.

Les rgles concernant la dsambigusation des verbes conjugus s'appuient toutes directement sur les pronoms personnels je, tu, il, nous et vous, et non sur leurs tiquettes. Nous avons prfr utiliser l'tiquette de chaque pronom, plutt que le pronom lui-mme.Ainsi, au lieu de : je + V, nous avons crit : R pers suj 1 s + V.Ceci a par ailleurs permis d'tendre elles, ou elle et on, les rgles qui ne prenaient en compte que ils ou il. L'attribut skip dans une balise dfinit le nombre de mots qui peuvent tre facultativement ignors avant de trouver le token suivant. Cet attribut nous a permis de runir plusieurs rgles en une seule. Par exemple, les 3 rgles de la ngation permettant de dsambiguser pas dans An Gramadir :

ne + X + X + pas : [Nn]e ANYTHING ANYTHING pas:

ne + X + pas : [Nn]e ANYTHING pas:

ne + pas : [Nn]e pas:

ont pu tre rduites une seule rgle, en indiquant qu'un maximum de 2 mots pouvait tre ignors entre ne et pas :

ne|npas|point|plus|jamais

Nous avons ainsi galement tendu la rgle point, plus et jamais. Grce la possibilit d'utiliser l'oprateur logique "OU" dans les expressions rgulires, nous avons regroup d'autres rgles proches. Par exemple, An Gramadir contient deux sries de rgles du type :

Dterminant ambigu + Nom = DterminantANYDMSANYTHING ANYTHING:

Dterminant ambigu + Adjectif = DterminantANYDMSANYTHING ANYTHING:

Nous les avons runies pour ne faire qu'une seule srie de rgles :

Dterminant ambigu + Nom OU Adjectif = Dterminant


Dans sa toute premire version, le dsambiguseur fonctionnait en remplaant tous les tags du mot ambigu par le nouveau tag indiqu par . Cette mthode avait l'inconvnient de nous obliger crire une rgle pour chaque combinaison possible dans un tag. Par exemple, les combinaisons genre-nombre des tags de dterminants, noms ou adjectifs :

une rgle pour "Dterminant masculin singulier"

une deuxime rgle pour "Dterminant masculin pluriel"

une troisime rgle pour "Dterminant masculin invariable"

etc.

Dans certains cas, il aurait t utile de pouvoir filtrer les mauvais tags en conservant les bons, au lieu d'effectuer un remplacement de tous les tags par celui indiqu dans , ce qui nous permettrait de rduire le nombre de rgles.

Nous avons expos notre problme Mikowski, qui a rapidement modifi le fonctionnement de l'outil selon nos indications. Grce l'ajout d'un lment match dans la balise , il est dsormais possible de rcuprer les tiquettes du mot ambigu et de lui rattribuer uniquement les bonnes. L'outil agit donc comme un filtre, qui permet de retirer les mauvais tags tout en conservant les bons. Mais il est aussi toujours possible d'utiliser la premire mthode, celle du remplacement.

Grce cette modification de l'outil, nous avons encore rduit considrablement le nombre de rgles en les gnralisant. Il n'tait en effet plus ncessaire d'avoir une rgle pour chaque combinaison. Ainsi, nous avons par exemple exprim dans une rgle unique les rgles pour dsambiguser les noms, qui taient au nombre de 9 dans An Gramadir (toutes les combinaisons avec masculin, fminin ou picne, et singulier, pluriel ou invariable).

Dans cette rgle, lorsque le dsambiguseur rencontre un mot qui a un tag "nom", l'lment match rcupre les informations compltes de ce tag (catgorie, genre et nombre), et les applique au mot pour le dsambiguser.Ainsi, bien qu'ils aient des genres et nombres diffrents, les noms farfadet et btises seront tous deux dsambiguss par cette mme rgle, qui leur redonnera respectivement leur tag "N m s" et "N f p".


b) Autres modifications

Ajout de rglesLes petits tests de contrle que nous avons raliss au fur et mesure nous ont conduit

effectuer quelques ajustements. Il nous est par exemple apparu ncessaire d'ajouter quelques rgles.

Nous avons complt les rgles sur les pronoms personnels objet en ajoutant les cas de l', le, la, les et lui. Aux rgles sur les verbes, nous avons ajout le cas de l'imparfait aux 1re et 2me personnes du singulier, ainsi que le cas du conditionnel prsent aux 1re et 3me personnes du singulier. Nous avions en effet de fausses dtections d'erreurs dues aux ambiguts entre ces personnes ces temps et mode.

Nous avons aussi ajout une rgle provisoire pour attribuer un tag aux nombres. Ceux-ci ne sont en effet pas tiquets par le tagger car ils ne figurent pas dans le lexique. Un travail ultrieur sur ce lexique sera ncessaire pour le corriger et le complter, afin que cette rgle n'ait plus lieu d'tre.

Modification de rglesNous avons ensuite modifi quelques rgles afin d'augmenter un peu leur couverture, car

nous avions remarqu que des ambiguts n'taient pas leves dans certains cas :

Nous avons ajout la possibilit de trouver la particule ne de la ngation entre deux pronoms personnels, car dans le cas de phrases ngatives, les rgles de dsambigusation des pronoms personnels objet ne pouvaient pas s'appliquer.

Les rgles sur les deux pronoms personnels sujet nous et vous ne permettaient de dsambiguser les pronoms que s'ils taient suivis d'un verbe. Or, ils peuvent tout aussi bien tre suivis par un adverbe ("nous ne sommes pas ...") ou par un pronom personnel objet ("nous les avons quitts").Pour que la dsambigusation soit effectue dans plus de cas, nous avons donc modifi les rgles en question, en faisant suivre nous et vous par un verbe, un adverbe ou un pronom personnel objet.

Dplacement de rglesAprs l'importation des rgles, nous avons remarqu que certaines d'entre elles ne

s'appliquaient pas, car le mot avait dj t dsambigus auparavant, par une rgle plus gnrale.

Les rgles sur les verbes ambigus prcds d'un pronom personnel sujet taient dans ce cas. Lorsque un verbe tait ambigu avec un nom, une premire rgle lui donnait par dfaut l'tiquette "Nom", et il ne pouvait alors plus tre identifi comme un verbe prcd d'un pronom par une rgle suivante.Pour rsoudre ce problme, nous avons dplac les rgles sur les verbes conjugus avant les rgles sur l'ambigut nom-verbe.

Nous avons aussi hsit intervertir deux rgles :

1. Dterminant + Nom ambigu = Nom

2. Dterminant + Adjectif ambigu + Nom = Adjectif


Le problme est qu'un trs grand nombre de mots ont les deux tiquettes "Nom" et "Adjectif", et en franais, bien que les adjectifs soient gnralement placs aprs le nom, il arrive aussi frquemment qu'ils se trouvent avant. En effet, dans (Tesnires, 1959) le franais est class parmi les langues centrifuges mitiges, dans lesquelles les adjectifs sont majoritairement postposs.En cas d'ambigut, la premire rgle attribue automatiquement le tag "Nom" au mot qui suit le dterminant. Nous perdons alors tous les cas o l'adjectif est antpos.

Si nous intervertissons les deux rgles, supposer que le nom soit lui aussi ambigu avec un adjectif, nous perdons dans ce cas les adjectifs postposs.

Finalement, aprs avoir compar la dsambigusation dans les deux cas, il est apparu que les rsultats taient lgrement meilleurs en intervertissant les rgles. Nous avons donc modifi leur ordre initial, tout en restant conscients qu'il faudra raliser des tests plus complets, pour valuer rellement l'incidence d'une telle modification sur la dsambigusation.

3.2. Importation des rgles d'erreurs

D'une part, nous avons parl plus haut d'une dizaine de rgles sur les homophones grammaticaux (a/sa, a/, se/ce, ma/m'a et sont/son), dj importes dans LanguageTool par Mikowski. D'autre part, le fichier de rgles d'erreurs cr par Lechelt (2005) pour An Gramadir comporte environ 520 entres. Il nous restait donc un peu plus de 500 rgles importer. Parmi elles, environ 90% concernent les syntagmes nominaux, et les 10% restant concernent les syntagmes verbaux.

3.2.1. Rcriture automatique

Nous n'avons pas rcrit toutes les rgles la main car elles taient trop nombreuses. Nous avons donc cr un petit programme en Python permettant de les transformer automatiquement en XML, c'est--dire de dfinir leur nom (name), leur identifiant (id), le modle de la faute (pattern), le message (message) et les exemples (example) destination de l'utilisateur.

Ainsi, par exemple, la rgle de An Gramadir du type :ANYTHING ANYTHING ANYTHING:NOMBRE

a t automatiquement rcrite en :

Il y a une erreur d'accord en nombreexemple correctexemple incorrect

Les balises et des rgles sur les syntagmes verbaux ont ensuite t personnalises, et les patterns quelquefois modifis.


3.2.2. Rcriture des rgles sur les syntagmes verbaux

Nous avons en premier lieu travaill sur la partie pattern des rgles, avant de personnaliser les messages et exemples retourns l'utilisateur.

a) Le pattern

Les rgles d'erreurs qui s'appliquent aux syntagmes verbaux concernent principalement l'accord entre le pronom personnel et le participe pass ou l'adjectif, aprs l'auxiliaire tre, l'accord entre le pronom personnel et le verbe, et les confusions dans l'utilisation des diffrentes formes verbales.Tout comme dans les rgles de dsambigusation, nous avons pu gnraliser quelques rgles et effectuer certains regroupements.

Nous avons tout d'abord remplac chaque pronom personnel sujet par son tiquette. Cela nous a permis de traiter il et on avec la mme rgle, sur l'accord du participe pass ou de l'adjectif, puisqu'ils sont tous deux taggs "masculin singulier".Dans les rgles d'accord avec le verbe, nous avons galement ainsi group il, elle et on d'une part, et ils et elles d'autre part. Nous avons d'ailleurs en mme temps complt ces rgles puisque le cas des fminins elle et elles n'taient pas traits par An Gramadir.Le cas de l'lision de je qui devient j' n'tait pas non plus pris en compte. Nous avons remdi ce problme en gnralisant la rgle sur je tout pronom personnel sujet 1re personne du singulier.

Nous avons ensuite pu runir plusieurs rgles. Dans An Gramadir, il faut par exemple 4 rgles pour dire qu'il y a une erreur si :

je est suivi d'un verbe la 1re personne du pluriel[Jj]e ANYTHING:AGGREEMENT

je est suivi d'un verbe la 2me ou 3me personne[Jj]e ANYTHING:AGGREEMENT

je est suivi d'un mot quelconque, puis d'un verbe la 1re personne du pluriel[Jj]e ANYTHING ANYTHING:AGGREEMENT

je est suivi d'un mot quelconque, puis d'un verbe la 2me ou 3me personne[Jj]e ANYTHING ANYTHING:AGGREEMENT

Dans LanguageTool, nous avons tout regroup en une seule rgle :

Le pronom personnel n'est pas accord avec le verbe

je travailleje travaillons

Tout comme dans les rgles de dsambigusation, nous avons ici utilis l'attribut skip pour autoriser un mot facultatif entre le pronom personnel et le verbe, et pour ainsi viter d'avoir rdiger plusieurs rgles.


Nous avons aussi runi deux rgles qui concernaient l'accord du pronom personnel sujet, soit avec le participe pass aprs l'auxiliaire tre, soit avec l'adjectif aprs l'auxiliaire tre. Nous avons juste utilis l'oprateur logique "OU" pour que la rgle s'applique au participe pass OU l'adjectif. Ainsi :

Pronom personnel sujet + tre + adjectifet Pronom personnel sujet + tre + Participe pass

ont pu tre exprims dans une seule rgle :Pronom personnel sujet + tre + Participe pass OU Adjectif

Nous avons finalement rduit 15 le nombre des rgles d'erreurs sur les groupes verbaux, qui tait de 62 dans An Gramadir, tout en augmentant leur couverture, ce qui nous permet de dtecter plus de fautes ventuelles.

Une fois les patterns des rgles bien dfinis, nous avons spcifi pour chacun les attributs mark_from et mark_to, permettant l'affichage prcis de la faute lors de la correction.

b) Le message et les exemples

Le programme que nous avons crit, pour transformer les rgles automatiquement, a gnr pour chacune d'elle un message et des exemples par dfaut, qu'il a fallu par la suite personnaliser. Nous avons donc rdig un message pour chaque type de faute, et des exemples adapts chaque situation.Ainsi, pour les rgles d'accord entre le pronom personnel et le verbe, nous avons crit le message : "Il y a une faute d'accord entre le pronom personnel et le verbe", et nous avons cr des exemples, corrects et incorrects, pour chaque rgle : "je travaille" et "*je travaillez", "tu travailles" et "*tu travaillent", etc.

3.2.3. Rcriture des rgles sur les syntagmes nominaux

a) De rgles trs nombreuses

Les rgles sur les groupes nominaux sont trs nombreuses (environ 450). Les lments sur lesquels elle portent - dterminants, noms et adjectifs peuvent se combiner de diffrentes manires. Ils peuvent tre masculin, fminin ou picne et singulier, pluriel ou invariable, et tre pour certains en quantit variable (les adjectifs principalement). Les combinaisons d'erreurs possibles deviennent alors vite trs nombreuses.Si nous reprenons le jeu d'tiquettes cr par Lechelt (2005) pour an An Gramadir, savoir D pour dterminant, N pour nom et J pour adjectif, nous avons alors des rgles pour toutes les combinaisons suivantes :

D J J N J J - D J N J J - D J J N J - D J N J - D N J J - D J J N -D J N - D N J - DN

De plus, les rgles de An Gramadir prennent galement en compte les nombres, taggs Y. Nous avons donc les combinaisons suivantes qui viennent se rajouter aux premires :

D Y J J N - D Y N J J - D Y J N - D Y N J - D Y N - Y J N - Y N

Nous avons conserv les rgles telles que rcrites par notre programme en Python, sans en modifier le pattern comme nous l'avons fait pour les rgles sur les syntagmes verbaux, puisqu'il n'y avait pas de regroupement possible.Nous n'avons pas non plus personnalis les attributs mark_from et mark_to, ni les exemples,


car cela aurait pris normment de temps, et comme nous allons le voir par la suite, nous n'allons pas conserver ces rgles dans leur structure actuelle. Pour tester les rgles et savoir si elles dtectent bien les erreurs, il nous suffisait d'avoir des patterns bien dfinis. Nous n'avions pas besoin des exemples ou des messages. Nous avons simplement crit deux messages p

Documents

Memoire