Réflexions sur le "désambiguïseur"

J'ai commencé à regarder d'un peu plus près le code source de LanguageTool, le but étant de mieux comprendre le fonctionnement du programme et de voir comment implanter un désambiguïseur. L'opération s'est révélée un peu laborieuse étant donné que je suis débutante en Java et qu'il m'a fallu apprivoiser un peu ce langage...
J'ai essayé de voir comment utiliser l'interface "disambiguator", récemment ajoutée à LanguageTool (par Jozef Ličko). Elle permet l'implantation éventuelle d'un désambiguïseur pour les différentes langues supportées par le programme. Il nous reste donc à développer ce désambiguïseur pour le français.

Pour ce qui est de la désambiguïsation en elle-même, nous allons reprendre les règles écrites par Myriam pour Gramadoir. Nous avons plusieurs possibilités pour les formaliser. Nous pourrions les écrire simplement au format texte, ou bien encore conserver leur formalisme actuel. Nous avons plutôt décidé de les réécrire dans un fichier au format XML. Ce formalisme a l'avantage d'être plus facilement lisible et modifiable par des linguistes, qui ne sont pas forcément informaticiens. Par ailleurs, nous restons ainsi cohérents avec le programme qui utilise déjà ce formalisme pour les règles d'erreurs.
Nous allons donc garder les règles écrites pour Gramadoir et conserver leur ordre. Cet ordre est essentiel et correspond à une précision décroissante des règles : il y a d'abord des règles particulières qui traitent des cas précis, puis des règles par défaut un peu plus générales, et enfin des règles brutes très générales qui traitent tous les cas qui ne l'ont pas été par les précédentes règles.
Après l'étape du tagging, lorsque les mots ont reçu leur(s) étiquette(s), il faut vérifier si une règle de désambiguïsation dans le fichier XML peut s'appliquer à un mot ambigu. Plus précisément, il faut passer toutes les règles en revue, dans l'ordre, jusqu'à ce que l'une d'entre elles soit applicable à un des tags, et ne conserver alors que le tag correspondant à cette règle.

Les classes java intervenant dans la détection des fautes de grammaire vont nous servir d'exemple et nous permettre de mieux voir comment construire notre désambiguïseur. Même si le fonctionnement n'est pas vraiment identique, on retrouve le système du "pattern matching" (concordance entre 2 éléments) entre des règles en XML, et des mots et leur contexte.

Des problèmes à prévoir

Les règles s'appuient sur le contexte du mot ambigu. Myriam a indiqué à leur sujet que si le contexte est lui-même ambigu (au niveau des catégories morpho-syntaxiques), ces règles ne peuvent pas fonctionner. Nous allons nous aussi bien sûr être confrontés à ce problème.
Si la désambiguïsation est effectuée linéairement, au fur et à mesure, nous aurons alors un contexte gauche désambiguïsé et un contexte droit très souvent encore ambigu. Or quelques règles (environ 1 sur 5) utilisent ce contexte droit. Il est donc à prévoir qu'elles ne pourront, dans certains cas, pas s'appliquer. Pour ce qui est des règles qui portent sur le contexte gauche, elles sont dépendantes de la bonne désambiguïsation de ce contexte. En cas d'erreur, la suite de la désambiguïsation peut être mal effectuée.

Pour le moment, nous n'allons pas chercher à améliorer la désambiguïsation. Nous n'en avons malheureusement pas le temps. Ceci fera probablement l'objet d'un travail ultérieur. Nous avons tout de même réfléchi à des solutions. Il faudrait par exemple que le traitement ne se fasse pas linéairement, mais plutôt en fonction des mots ambigus ou pas : commencer par désambiguïser les mots qui peuvent l'être de manière sûre, ceux dont le contexte n'est pas ambigu par exemple, et continuer jusqu'à ce que tous les mots de la phrase soient traités, en gardant les cas les plus compliqués pour la fin.
Il faudrait aussi pouvoir revenir en arrière pour pouvoir corriger une mauvaise désambiguïsation. Et comme nous l'avons déjà vu, une segmentation en chunks pourrait également être utile.