Archives de la catégorie : TALN

Ontology-based semantic annotation: an automatic hybrid rule-based method

microorganism-bacteria-485x728

In the perspective of annotating a text with respect to an ontology, we have participated in the sub-task 1 of the Bacteria Biotopes BioNLP Shared Task whose aim is to detect, in the text, Bacteria Habitats and associate to them one or several categories from the Onto-Biotope ontology provided for the task.

We have used a rule-based machine learning algorithm (WHISK) combined with a rule-based automatic ontology projection method and some rote learning. The combination of these three sources of rules leads to good results with a SER measure close to the winner and the best F-measure.

BB_BioNLP-ST

The sub-task 1 of the BB BioNLP-ST ranks competitors using the SER measure that must be as close as possible to 0. We are quite close to the winner with a SER of 48,7% against 46%. Our F-measure (60,8%) is even better than the winner’s F-measure (57%). Without our mistake, we would have been placed equal first with a far better F-measure (62,9%).

12/12/2014 … finalement premier ! — Une erreur s’était glissée dans l’implémentation de la mesure SER des évaluateurs. Finalement, le LIPN (nous) est premier. Plus d’un an après, cela n’a hélas pas la même saveur…

L’article Ontology-based semantic annotation: an automatic hybrid rule-based method sur HAL
BioNLP Shared Task 2013 (Hosted by the ACL BioNLP workshop Workshop)

Publié dans UIMA, TALN | Tagué , | Laisser un commentaire

Tutoriel UIMA I (variante) : code de l’annotateur utilisant directement le CAS plutôt que le JCas

La partie 3. Développer le code de l’annotateur du Tutoriel UIMA I : création d’un composant d’annotation propose le code Java d’un annotateur utilisant l’interface Java JCas du CAS pour injecter les annotations dans le CAS. Voici le code réalisant le même travail sans utiliser le JCas :
import org.apache.uima.analysis_component.CasAnnotator_ImplBase;
import org.apache.uima.analysis_engine.AnalysisEngineProcessException;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.FeatureStructure;
import org.apache.uima.cas.Type;
import java.text.BreakIterator;
public class TokenCASAnnotator extends CasAnnotator_ImplBase {
  public void process(CAS aCAS) throws AnalysisEngineProcessException {
    BreakIterator iterToken = BreakIterator.getWordInstance();
    iterToken.setText(aCAS.getDocumentText());
    int deb = iterToken.first();
    int fin = iterToken.next();
    while (fin != BreakIterator.DONE) {
      Type TokenCAS = aCAS.getTypeSystem().getType("Token");
      FeatureStructure fs = aCAS.createAnnotation(TokenCAS, deb, fin);v       aCAS.getIndexRepository().addFS(fs);
      deb = fin;
      fin = iterToken.next();
    }
  }
}
Publié dans UIMA, TALN | Tagué , | Laisser un commentaire

Principes d’une chaîne de traitements UIMA

L’objectif d’une chaîne de traitements UIMA est d’extraire de façon automatique des informations structurées à partir d’un document non structuré (texte, image, vidéo, etc.). Une chaîne de traitements UIMA respecte généralement les étapes suivantes :
  1. Charger un document non structuré (comme le texte du Petit Prince de Saint-Exupéry dans l’illustration ci-dessous).
  2. Générer le schéma d’annotation commun (Common Analysis Structure ou CAS) qui encapsulera toutes les annotations concernant le document analysé, ainsi que le document lui-même.
  3. Enchaîner les composants d’annotation (un segmenteur, un analyseur d’entités nommées et un annalyseur morpho-syntaxique dans l’illustration ci-dessous).
  4. Générer une sortie (généralement un fichier xmi) à partir des annotations contenues dans le CAS (le fichier xmi généré est visualisé dans l’outil UIMA Document Viewer dans l’illustration ci-dessous).
Exemple de chaîne de traitements UIMA
Publié dans UIMA, TALN | Tagué , , | Laisser un commentaire

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 :
Pour compléter cette liste, voici quelques réservoirs de composants UIMA :
Publié dans Cours, UIMA, TALN | Laisser un commentaire

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 :

Publié dans TALN | 1 commentaire

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 YaTe
    > 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.
Publié dans TALN | 2 commentaires

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 incontournables Sélection d’Articles
Publié dans UIMA, TALN | Laisser un commentaire

Tutoriel UIMA I : création d’un composant d’annotation (Analysis Engine) en utilisant le JCas

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 → LibrariesAdd 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. 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();
        }
      }
    }

    Le code ci-dessus passe par l’interface Java JCas pour injecter les annotations dans le CAS. Le recours à cette interface n’est pas indispensable.
  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. Exécuter le Document Analyzer pour tester le composant d’annotation
    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 composant d’annotation.
  6. Exécuter sous Eclipse le Document Analyzer pour tester le composant d’annotation
    Commencer par importer le projet exemple d’UIMA : File → Import… → General → Existing Project into Workspace → Next ; puis dans Select root directory sélectionner le répertoire racine d’UIMA ; puis Finish.
    Si ce n’est pas déjà fait, il faut ajouter votre projet dans le ClassPath de la configuration du Document Analyzer : Run → Run Configurations… → UIMA Document Analyzer → Onglet ClassPath
    Il est maintenant possible d’exécuter directement le CPE GUI pour tester le composant : Run → Run Configurations… → UIMA Document Analyzer → Run
  7. Tester le composant d’annotation avec le Document Analyzer

    Il faut remplir les champs du Document Analyzer de la manière suivante :
    • Imput Directory: UIMA_HOME/examples/data
    • Output Directory: UIMA_HOME/examples/data/processed
    • Location of Analysis Engine XML Descriptor: chemin/du/descripteur/de/composant
    Puis cliquer sur Run.

Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users’ Guides)
Sommaire UIMA sur ce blog
Publié dans UIMA, TALN, Eclipse | Tagué , , , , | Laisser un commentaire

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
Publié dans TALN | 3 commentaires

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
Publié dans Cours, TALN | Laisser un commentaire