Traitement Automatique du Langage Naturel (TALN) : Outils d’analyse de données textuelles

Le Traitement automatique du langage naturel (TALN) ou Traitement automatique des langues (TAL) est une discipline à la frontière de la linguistique, de l'informatique et de l'intelligence artificielle, qui concerne l'application de programmes et techniques informatiques à tous les aspects du langage humain [Wikipedia].
Dans le cadre du Master Informatique 2ème année, spécialité Modélisation Informatique des Connaissances et du Raisonnement (MICR), de L’École Doctorale Galilée, je dispense un cours sur les Outils d'analyse de données textuelles.
Le plan du support de cours de la première séance est :

1. Introduction au Traitement Automatique du Langage Naturel
2. Niveaux de traitements et principaux outils
3. Plateformes d'annotations linguistiques
4. Apache UIMA

Voici quelques sites rassemblant ou inventoriant des outils pour le TALN :

• Natural Language Software Registry
• OpenNLP
  
• Standford NLP
  
• CCG Software
  
• CLARIN
  
• ATALA
  
• IMS
• ISLanD
  

Pour compléter cette liste, voici quelques réservoirs de composants UIMA :

• Apache UIMA
  
• UIMA-FR
  

Présentation projetée
Tutoriel UIMA sur UIMA-FR

TreeTagger pour l'étiquetage morpho-syntaxique et la lemmatisation

L'étiquetage morpho-syntaxique d'un texte (Part-of-Speech tagging ou POS tagging en anglais), est souvent l'une des premières étapes en traitement automatique des langues (TAL). Il consiste à identifier pour chaque mot sa classe morpho-syntaxique (catégorie grammaticale, genre, nombre, temps...) à partir de son contexte. La lemmatisation désigne l'analyse lexicale consistant à retrouver la forme canonique d'un mot fléchie appelée le lemme.
TreeTagger permet d'effectuer les opérations décrites ci-dessus et peut également être utilisé comme un « chunker » pour identifier des parties du discours et délimiter des groupes syntaxiques.

Installation de TreeTagger
La procédure est décrite sur le site de TreeTagger. Pour l'installer sous Linux pour l'anglais et le français, il suffit de :

• Télécharger le paquetage tree-tagger à l'endroit définitif de son choix
• Télécharger le script d'étiquetage dans le même répertoire
• Télécharger le script d'installation dans le même répertoire
• Télécharger les fichiers de paramétrage pour l'anglais, le français encodé en Latin1 et le français encodé en utf8 toujours dans le même répertoire
• Exécuter le script d'installation depuis le dit répertoire
  > sh install-tagger.sh
• Si vous voulez que les autres utilisateurs du système puissent utiliser TreeTagger, il faut probablement résoudre des problèmes de droits
  > chmod -R a+rX repInstallTreeTagger
  
• Reste enfin à tester l'installation
  > echo 'Hello world!' | repInstallTreeTagger/cmd/tree-tagger-english

La page de TreeTagger
Tree Tagger : Etiquetage morpho-syntaxique et Lemmatisation

YaTeA : un extracteur de candidats terme

Un terme est une structure linguistique (un mot ou un groupe de mots) qui dénote un concept. YaTeA (Yet Another Term ExtrActor) permet d'identifier dans un corpus des groupes nominaux qui peuvent correspondre à des termes (c.-à-d. des candidats de terme). Cet outil a été développé par Thierry Hamon et Sophie Aubin au LIPN dans le cadre du projet ALVIS. YaTeA peut également prendre en entrée une ressource terminologique externe.

Installation de YaTeA (en étant root) :

• Configurer le module CPAN / Invoquer le shell :
  > perl -MCPAN -we 'shell'
• Installer les modules dont YaTeA dépend (quit pour quitter le shell CPAN)
  cpan> install YAML
  cpan> install Config::General
  cpan> install Parse::Yapp
  cpan> install Module::Build
  cpan> quit
• Télécharger Lingua-YaTeA-0.5.tar.gz :
  http://search.cpan.org/~thhamon/Lingua-YaTeA-0.5/
• Le décompresser
  > tar -xvzf Lingua-YaTeA-0.5.tar.gz
• Installer YaTeA
  > perl Makefile.PL
  > make
  > make test
  > make install
• Vérifier que l'installation à bien copié les répertoires etc/yatea/, share/doc/ et share/YaTeA. Sinon, c'est à vous de le faire :
  > cp -r etc/yatea /usr/local/etc/.
  > cp -r share/doc /usr/local/share/.
  > cp -r share/YaTeA /usr/local/share/.
  

Utilisation de YaTeA

YaTeA prend en entrée un corpus tabulaire produit par TreeTagger. Pour exécuter YaTeA, il suffit de taper la commande suivante :
> yatea -rcfile yatea.rc corpus.ttg
yatea.rc est le fichier de paramétrage du traitement. Un exemple se trouve dans /usr/local/etc/yatea/yatea.rc. En fonction de votre installation, ce fichier doit contenir les lignes suivantes :
CONFIG_DIR = /usr/local/share/YaTeA/config
LOCALE_DIR = /usr/local/share/YaTeA/locale
language = EN
Si le corpus est en français plutôt qu'en anglais, il suffit de remplacer EN par FR.
YaTeA créer un répertoire portant le même nom que le corpus spécifié pour y stocker les résultats du traitement.

YaTeA sur CPAN
Improving Term Extraction with Terminological Resources, S. Aubin and T. Hamon
YaTeA : Extraction des termes

Quelques liens pertinents concernant UIMA

L'objet de ce billet est de rassembler une sélection de liens que je juge pertinents concernant l'environnement de développement UIMA (Unstructured Information Management Architecture).

Liens fondamentaux

• UIMA, a project of the Apache incubator
• Apache UIMA Documentation
• UIMA-FR
  
• Nicolas Hernandez : UIMA
  
• Towards an Interoperability Standard for Text and Multi-Modal Analytics
  
• OASIS Unstructured Information Management Architecture (UIMA) TC
• Objectives of OASIS Unstructured Information Management Architecture (UIMA) TC

Sélection d'Articles

• An Annotation Type System for a Data-Driven NLP Pipeline
• UIMA peut-il réconcilier le text-mining et les outils sémantiques ? (Towards Knowledge Acquisition from Information Extraction)
• Design and implementation of the UIMA Common Analysis System
  

Sommaire UIMA sur ce blog

Tutoriel UIMA III : enchaîner des composants d'annotation

L'opération consistant à enchaîner plusieurs composants est extrêmement simple et ne requiert aucune écriture de code.

1. Créer un Aggregate Analysis Engine Descriptor :
   File → New → Others → UIMA → Analysis Engine Descriptor File ; préciser le nom dans le champs File name: puis Finish. Faire ensuite un clic droit sur le fichier .xml ainsi créé puis Open With → Component Descriptor Editor. Dans l'onglet Overview, cocher Aggrerate comme Engine Type.
2. Dans l'onglet Aggregate, ajouter tous vos annotateur en cliquant sur Add...
3. Enfin, dans l'onglet Capabilities, il faut préciser les types utilisés, et s'ils le sont en entrée ou en sortie, en cliquant sur Add Type.

Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users' Guides)
Sommaire UIMA sur ce blog

Tutoriel UIMA II : paramétrage d'un composant d'annotation

1. Déclarer des paramètres
   Pour déclarer des paramètres pour un composant, il suffit de se rendre dans l'onglet Parameters du descripteur XML de l'annotateur (clic droit sur le fichier .xml puis Open With → Component Descriptor Editor). L'onglet Parameter Settings permet de donner une valeur par défaut aux paramètres déclarés.
2. Accéder aux paramètres
   Supposons que le paramètre maChaine de type String ait été préalablement déclarée au niveau du descripteur XML de l'annotateur (cf. ci-dessus). On peut accéder à ce paramètre dans le code Java de l'annotateur de la manière suivante :
   

   
   

   String monParametre = (String) this.getContext().getConfigParameterValue("maChaine");

   La méthode getContext() permet de récupérer un objet du type UimaContext qui centralise l'accès aux différentes facettes du contexte de l'annotateur comme les paramètres ou l'historique des événements (logging).
3. Accéder aux paramètres depuis la méthode initialize()
   Un moyen plus propre d'accéder aux paramètres est de surcharger la méthode initialize(UimaContext), appelée automatiquement par le framework lors de l'instanciation de l'annotateur, qui reçoit justement comme paramètre un objet du type UimaContext :
   

   private String monParametre;
   public void initialize(UimaContext aContext) throws ResourceInitializationException {
     super.initialize(aContext);
     monParametre = (String) aContext.getConfigParameterValue("maChaine");
   }

Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users' Guides)
Sommaire UIMA sur ce blog

Tutoriel UIMA I : création d'un composant d'annotation (Analysis Engine)

Ce billet décrit comment créer un composant d'annotation (Analysis Engine) UIMA simple qui segmente un fichier texte en mots.

1. Préparation du projet dans Eclipse
   Lancer Eclipse puis : File → New → Other... → Java → Java Project → Next. Saisir un nom dans le champs Project name: puis cliquer sur Finish.
   Il faut ensuite attacher la librairie UIMA au projet : Project → Properties → Java Build Path → Libraries → Add External JARs... ; sélectionner le fichier uima-core.jar dans le répertoire apache-uima/lib.
   
2. Définir un type dans le schéma d’annotation
   Le schéma d’annotation commun (Common Analysis Structure ou CAS dans UIMA) encapsule toutes les annotations concernant le document analysé ainsi que le document lui-même. Il nous aurons besoin du type Token dans cette structure, nous allons donc le déclarer dans un système de types : File → New → Others → UIMA → Type System Descriptor File ; préciser le nom dans le champs File name: puis Finish.
   Faire ensuite un clic droit sur le fichier .xml ainsi créé puis Open With → Component Descriptor Editor. Dans l'onglet Type System cliquer sur Add Type et saisir le nom dans le champs Type Name: (ex : Token) et préciser uima.tacs.Annotation dans le champs Supertype:.
   L'action d'enregistrer vos modifications doit générer automatiquement les fichiers associés (ex : Token_Type.java et Token.java).
3. Développer le code de l'annotateur
   Il faut créer une classe héritant de la classe JTextAnnotator_ImplBase correspondant à l'implémentation par défaut d'un annotateur de données textuelles : File → New → Class ; saisir le nom de la classe dans le champs Name: TokenAnnotator ; préciser la classe org.apache.uima.analysis_component.JCasAnnotator_ImplBase dans le champs Superclass: ; puis cliquer sur Finish.
   Il ne reste plus qu'à écrire le code proprement dit :
   

   import org.apache.uima.analysis_component.JCasAnnotator_ImplBase;
   import org.apache.uima.analysis_engine.AnalysisEngineProcessException;
   import org.apache.uima.jcas.JCas;
   import java.text.BreakIterator;
   public class TokenAnnotator extends JCasAnnotator_ImplBase {
    public void process(JCas aJCas) throws AnalysisEngineProcessException {
      BreakIterator iterToken = BreakIterator.getWordInstance();
      iterToken.setText(aJCas.getDocumentText());
      int deb = iterToken.first();
      int fin = iterToken.next();
      while (fin != BreakIterator.DONE) {
        Token token = new Token(aJCas);
        token.setBegin(deb);
        token.setEnd(fin);
        token.addToIndexes();
        deb = fin;
        fin = iterToken.next();
      }
    }
   }

4. Descripteur du composant d'annotation (Analysis Engine Descriptor)
   L'architecture UIMA impose qu'un annotateur soit décrit par un fichier XML appelé Analysis Engine Descriptor : File → New → Others → UIMA → Analysis Engine Descriptor File ; préciser le nom dans le champs File name: puis Finish.
   Faire ensuite un clic droit sur le fichier .xml ainsi créé puis Open With → Component Descriptor Editor. Indiquer le fichier java implémentant l'annotateur dans le champs Name of the java class file de l'onglet Overview.
   Dans l'onglet Type System, il faut énumérer les types que l'annotateur utilise. Cliquer d'abord sur Set DataPath dans la colonne Imported Type Systems pour indiquer le chemin du fichier XML contenant schéma d’annotation commun (Type System Descriptor). Dans la même colonne, cliquer ensuite sur Add... pour sélectionner ce fichier.
   Enfin, dans l'onglet Capabilities, il faut préciser, parmi les types énumérés dans l'onglet Type System, lesquels sont utilisés et s'ils le sont en entrée ou en sortie. Cliquer sur Add Type, sélectionner la ligne correspondant à votre token et préciser que le type est utilisé en sortie uniquement (Out) puis valider (Ok).
5. Tester le composant
   Il faut commencer par mettre à jour la variable d'environnement CLASSPATH pour y ajouter le chemin vers votre répertoire bin. Dans un shell, saisir :
   export CLASSPATH=$CLASSPATH:chemin/vers/votre/bin
   Vous pouvez alors exécuter le script documentAnalyzer.sh qui vous permettra de tester votre annotateur.
6. Tester le composant sous Eclipse
   Commencer par importer le projet exemple d'UIMA : File → Import... → General → Exusting Project into Workspace → Next ; puis dans Select root directory sélectionner le répertoire racine d'UIMA ; puis Finish.
   Il est maintenant possible d'exécuter directement le CPE GUI pour tester le composant :
   

Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users' Guides)
Sommaire UIMA sur ce blog

Les entités nommées : Installer TagEn sous Linux

Les entités nommées sont une appellation générique pour désigner les noms propres de personnes, de lieux, d'organismes, mais aussi des dates, des prix, etc.

TagEN est un outil de reconnaissance d'entités nommées développé par Jean-François Berroyer et Thierry Poibeau, au Laboratoire d'Informatique de Paris-Nord (LIPN). L'implémentation de TagEN est basée sur des automates à états-finis et utilise pour cela la plate-forme Unitex développée à l'Université de Marne-la-Vallée.

Pour installer TagEN, il faut commencer par le télécharger, puis :

1. Décompresser l'archive TagEN.tar.gz à l'endroit définitif de son choix
2. Exécuter le script compile dans le répertoire TagEN/src

Pour utiliser TagEN, il faut lui spécifier l'un des modes renseignés dans le fichier tagen.conf, comme :

• mucfr : entités nommées MUC (français) ;
• equer : domaine médical (français) ;
• bio : genes, proteins and species names (english) ;
  
• carnivore : carnivore plants (english) ;
  

Par exemple, pour exécuter TagEN sur le fichier ptprince.txt en utilisant le mode mucfr, il faut saisir la commande :

./tagen :mucfr ptprince.txt

Voici quelques extraits du fichier ptprince.tag.txt produit en sortie :

[...]Quand il est <timex><time>midi</time></timex> aux <enamex><location>Etats-Unis</location></enamex>, le soleil, tout le monde sait, se couche sur la <enamex><location>France</location></enamex>.[...]
[...]J'ai vu une maison de <numex><money>cent mille francs</money></numex>[...]
[...]le rayonnement du cadeau de <timex><date>Noël</date></timex> que je recevais[...]
[...]ce sera ce soir vers <timex><time>sept heures quarante</time></timex>[...]

Remarque : il existe une option -t (ex : ./tagen -t :mucfr ptprince.txt) qui ne semble pas documentée et qui produit un résultat plus synthétique contenant le type et les offsets des entités nommées identifiées :

enamex 31 36
person 31 36
enamex 367 372

T. Poibeau (2003) - The Multilingual Named Entity Recognition Framework.

Installation d'UIMA sous Linux (... Suite)

1. Verifying Your Installation (extrait du fichier README dans le répertoire apache-uima)
   
   To test the installation, run the documentAnalyzer.sh:
   

   $ documentAnalyzer.sh

   This should pop up a Document Analyzer window. Set the values displayed in this GUI to as follows:
   
   • Input Directory: UIMA_HOME/examples/data
   • Output Directory: UIMA_HOME/examples/data/processed
   • Location of Analysis Engine XML Descriptor: UIMA_HOME/examples/descriptors/analysis_engine/PersonTitleAnnotator.xml
   Replace UIMA_HOME above with the path of your Apache UIMA installation.
   
   Next, click the Run button, which should, after a brief pause, pop up an Analyzed Results window.
   Double-click on one of the documents to display the analysis results for that document.
   
   
   
2. View the examples code with Eclipse (extrait du document UIMA Overview & SDK Setup section 3.2. Setting up Eclipse to view Example Code)
   
   
   You can create a special project in Eclipse to hold the examples. Here's how:
   
   • In Eclipse, if the Java perspective is not already open, switch to it by going to:
     

     Window → Open Perspective → Java

   • Select the File → Import menu option.
   • Select General/Existing Project into Workspace and click the Next button.
   • Click Browse and browse to the UIMA_HOME directory.
   • Click Finish. This will create a new project called uimaj-examples in your Eclipse workspace. There should be no compilation errors.
   To verify that you have set up the project correctly, check that there are no error messages in the Problems view.

Sommaire UIMA sur ce blog

Installation complète de l'environnement de développement UIMA sous Linux

Ce billet décrit comment installer complètement l'environnement de développement UIMA sous une station de travail Linux sans avoir besoin des droits d'administrateur. Par installation complète il faut comprendre l'installation de tout ce qui est nécessaire : le SDK Java, Eclipse, les plugins nécessaires et le SDK UIMA.

1. Installation du SDK Java

   La première étape consiste, si ce n'est déjà fait, à installer la dernière version du kit de développement de logiciels (SDK) Java. Commencer par télécharger le fichier d'installation (jdk-6u4-linux-i586.bin dans mon cas) dans le répertoire de son choix. Saisir ensuite, dans un shell, en étant dans le répertoire où le fichier a été téléchargé et où l'installation doit se faire :
   

   $ chmod +x jdk-6u4-linux-i586.bin
   $ ./jdk-6u4-linux-i586.bin
   

   (Il vous faut répondre yes aux termes du contrat pour réaliser l'installation)

2. Installation de l'environnement de développement intégré (IDE) Eclipse

   Si ce n'est déjà fait, installer la dernière version d'Eclipse (version 3.3.1.1, build id M20071023-1652 au moment de l'écriture de ce billet). L'installation se résume à décompresser à l'endroit de son choix le fichier téléchargé.
   Pour exécuter la version d'Eclipse qui vient d'être d'installée avec la version de Java installée précédemment, il faut saisir dans un shell une ligne de commande du style (penser à créer un raccourci) :
   

   $ ~/eclipse/eclipse -vm ~/jdk1.6.0_04/bin/

   Ensuite, dans Eclipse, il faut préciser la version de Java qui sera utilisée. Aller dans :
   

   Window → Preferences... → Java → Installed JREs → Add...

   Puis préciser :
   

   JRE name : Java jdk1.6.0_04
   JRE home directory : ~/jdk1.6.0_04

   Valider en cliquant sur Ok, puis penser à cocher la nouvelle version du JRE ajoutée avant de valider de nouveau en cliquant sur Ok.
   Vérifier également, la cas échéant, que la variable d'environnement ECLIPSE_HOME est correcte (i.e. désigne bien le répertoire ~/eclipse) dans :
   

   Window → Preferences... → Java → Build Path → Classpath Variables
   

3. Installation du plugin Eclipse EMF

   Il faut ensuite installer le plugin EMF utilisé par UIMA. En fait, avec la dernière version d'Eclipse, Eclipse Modeling Framework (EMF) Updates apparait automatiquement dans la liste des sites d'installation automatique de plugins (sinon, se référer à EMF Update Manager Site). Une fois Eclipse lancé, il suffit donc de faire :
   

   Help → Software Updates → Find and Install... → Search for new features to install → Next

   Puis sélectionner Eclipse Modeling Framework (EMF) Updates, Ignore features not applicable to this environment et Automatically select mirrors puis Finish.
   Ensuite déployer Eclipse Modeling Framework (EMF) Updates pour sélectionner EMF SDK 2.3.1 puis :
   

   Next → I accept the terms in the license agreements → Next → Finish → Install All → Yes
   

4. Installation du plugin Eclipse UIMA

   On peut alors passer à l'installation du plugin Eclipse d'UIMA :

   Help → Software Updates → Find and Install... → Search for new features to install → Next → New Remote Site...
   

   Saisir :
   

   Name : Apache UIMA
   URL : http://www.apache.org/dist/uima/eclipse-update-site
   

   Puis Ok.
   Sélectionner Apache UIMA, Ignore features not applicable to this environment et Automatically select mirrors puis Finish.
   Sélectionner Apache UIMA puis :
   

   Next → I accept the terms in the license agreements → Next → Finish → Install All → Yes

5. Installation du SDK UIMA

   Il faut enfin installer le kit de développement de logiciels (SDK) UIMA. Télécharger la dernière version du SDK d'UIMA, puis décompresser à l'endroit de votre choix le fichier téléchargé.
   Éditez votre fichier .bashrc pour définir les variables d'environnement UIMA_HOME et JAVA_HOME et modifier le PATH en ajoutant les lignes suivante à la fin du fichier :
   

   export UIMA_HOME="~/apache-uima"
   export JAVA_HOME="~/jdk1.6.0_04"
   export PATH=${PATH}:${UIMA_HOME}/bin

   Puis saisir la commande suivante dans un shell pour mettre à jours les chemins des exemples du SDK :
   

   $ adjustExamplePaths.sh

   Penser à lire le fichier README dans le répertoire apache-uima pour plus d'information sur l'installation du SDK UIMA ainsi que pour une procédure permettant de tester votre installation (également décrite ici).

Sous Eclipse, vérifier également que la variable d'environnement UIMA_HOME est correcte (i.e. désigne bien le répertoire ~/apache-uima) dans :

Window → Preferences... → Java → Build Path → Classpath Variables

Si ce n'est pas le cas, il faut la modifier (bouton Edit...) ou la définir (bouton New...).

Si tout s'est bien passé, tous les fichiers concernant l'installation complète de l'environnement de développement UIMA doivent être répartis dans les répertoires apache-uima pour le SDK UIMA, eclipse pour l'environnement de développement intégré Eclipse et les plugins installés et jdk1.6.0_04 pour le JDK Java.

UIMA Manuals and Guides (Overview and Setup)
Sommaire UIMA sur ce blog

UIMA (Unstructured Information Management Architecture)

UIMA (Unstructured Information Management Architecture) est un framework de développement et de déploiement d'applications de traitement des données non structurées.

Je maintiens une page autonome concernant UIMA ici

Cours : Informatique & linguistique

La linguistique informatique ou, suivant l'appellation anglo-saxonne, la linguistique computationnelle, est une discipline issue des développements de l'informatique dans le domaine des sciences du langage. Le domaine de la linguistique informatique recouvre toutes les applications informatiques qui ont trait au langage naturel. Par langage naturel on entend le langage tel qu'il est parlé spontanément par les êtres humains (le français, l'anglais, le russe, le wolof, etc.), par opposition aux langages formels utilisés en logique, en mathématique, en informatique, etc.
L'objet premier de la linguistique informatique est le traitement automatique du langage (TAL), c'est-à-dire l'analyse et la génération automatique du langage, et plus précisément, l'élaboration de modèles computationnels d'analyse et de génération à partir desquels on peut réaliser des logiciels capables de comprendre ou de produire des énoncés en langue naturelle.
Cette unité d'enseignement présente les bases de la théorie des automates et des langages formels : automates à états finis, expressions régulières, grammaires régulières, grammaires indépendantes du contexte, analyseurs syntaxiques ascendants et descendants.

Table des matières :

• La linguistique informatique
• Langages formels et leurs représentations
• Langages réguliers (type 3)
• Langages hors contexte (type 2)
• Analyseurs (parser) syntaxiques
  

Fichier pdf