Archives de la catégorie : Recherche

Composant d’annotation (Analysis Engine)

Le composant d’annotation (Analysis Engine ou AE) est le composant élémentaire d’une chaîne de traitements UIMA. Son rôle est d’effectuer un traitement (comme l’étiquetage morpho-syntaxique) en utilisant éventuellement des annotations contenues dans le CAS (comme une segmentation en mots) et en produisant de nouvelles annotations dans le CAS (comme les étiquettes morpho-syntaxique de chacun des mots).

Un composant d’annotation UIMA (Analysis Engine) est constitué de deux parties distinctes :

  • Un descripteur de composant (componant descriptor) qui constitue la partie déclarative. Il contient des méta-données qui décrivent le composant (types de données en entrée et en sortie, identité …) et est stocké dans un fichier XML.
  • Un annotateur (Annotator) qui est en fait le code (en Java par exemple) effectuant le traitement proprement dit du composant.

En résumé :

Composant d’annotation = Descripteur de composant + Annotateur
Analysis Engine = Componant Descriptor + Annotator

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

Descripteur XML de composant (Component Descriptors)

Les composants UIMA sont composés de deux parties distinctes :

  1. une partie déclarative (le descripteur de composant)
  2. un code (en Java par exemple)

La partie déclarative est représentée dans un fichier XML et est appelée descripteur de composant (Component Descriptor). Le descripteur de composant contient des méta-données qui décrivent le composant. C'est le moyen qu'UIMA utilise pour mettre en œuvre les mécanismes de découverte, de réutilisation et de composition de composants.

Le descripteur de composant permet de renseigner, entre autres, les informations suivantes :

  • nom, version, auteur, description et surtout le nom de la classe implémentant le composant (onglet Overview)
  • Système de types utilisé (onglet Type System)
  • Types utilisés (i.e. requis) dans le CAS par le composant (onglet Capabilities)
  • Types renseignés dans le CAS par le composant (onglet Capabilities)

Sous Eclipse, un tel descripteur peut être édité avec le Component Descriptor Editor.

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

UIMA : Le système de types (Type System ou TS)

Pour composer un CAS, UIMA propose quelques types de base et permet de les étendre grâce au concept de système de types (Type System ou TS). Un système de types est une hiérarchie de types qui défini l’ensemble des types qu’il est possible d’utiliser dans le CAS.

Chaque composant UIMA (i.e. chaque Analysis Engines) défini son propre système de types. Pour assurer la cohérence d’une chaîne d’annotation UIMA, il est préférable que chacun des systèmes de types des composants de la chaîne soit un sous-ensemble d’un système de types plus général décrivant tous les types d’annotations que la chaîne peut produire.

Un système de types est décrit dans un fichier XML qui peut être édité sous Eclipse par le Component Descriptor Editor :

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

UIMA : Le schéma d’annotation commun (Common Analysis Structure ou CAS)

Le schéma d’annotation commun (Common Analysis Structure ou CAS) est une notion centrale dans UIMA. Le CAS encapsule toutes les annotations concernant le document analysé ainsi que le document lui-même. Un CAS comporte deux types d’éléments :
  1. Le documents, appelé Sofa pour Subject of Analysis dans UIMA.
  2. Des annotations générées par des composants d’annotation.

Le CAS est une structure orientée objets permettant aux différents composants d’une chaîne d’annotation UIMA de représenter et d’échanger leurs annotations respectives. UIMA propose quelques types de base et permet de les étendre grâce au concept de système de types (Type System).

L’interface Java permettant de manipuler le CAS depuis du code Java se nomme JCas (cf. Tutoriel IV), mais le CAS reste tout de même accessible en Java sans passer par cette interface (cf. Tutoriel V).

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

UIMA : La chaîne de traitement (Collection Processing Engine)

Collection Processing Engine

Une chaîne de traitement UIMA comporte trois types d’éléments :
  1. Le Collection Reader : généralement le premier élément de la chaîne, il permet de créer des CAS autour de chaque ressource.
  2. Les Analysis Engines (AE) : raison d’être de la chaîne, ils effectuent les traitements en utilisant les annotations contenues dans le CAS et en produisant de nouvelles annotations dans le CAS. Un CAS Consumer est un Analysis Engine particulier qui n’est pas destiné à enrichir un CAS mais qui génère une sortie (généralement un fichier) à partir des annotations contenues dans le CAS.
  3. Le Workflow Controller : c’est lui qui orchestre l’exécution des Analysis Engines. On peut distinguer deux types de Workflow Controller :
    • le CPM (Collection Processing Manager ou CPM) et les service Vinci (Vinci Services) ;
    • et le tout nouveau AS (Asynchronous Scaleout) bien plus flexible.
L’outil graphique Collection Processing Engine Configurator (UIMA CPE GUI sous Eclipse), instancie un Workflow Controller du type CPM appelé FixedFlow qui consiste simplement à enchaîner séquentiellement un Collection Reader, puis un certain nombre d’Analysis Engine et enfin un CAS Consumer, comme illustré sur la figure en début de billet. UIMA représente une telle chaîne de traitement dans un descripteur appelé Collection Processing Engine (CPE).
Publié dans UIMA | 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 Enseignement, 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 III : enchaîner des composants d’annotation

Apache UIMA utilise le même type de fichier de description (Component Descriptor) pour désigner un composant ou une chaîne de traitement. Le fichier descripteur est :
  • soit configuré comme primitif dans le cas où il décrit un traitement élémentaire (comme dans le Tutoriel UIMA I),
  • soit configuré comme agrégé (aggregate) dans le cas où il fait référence à d’autres descripteurs de fichiers primitifs ou agrégés.
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.
  4. Il ne reste plus qu’à tester l’Aggregate Analysis Engine Descriptor en utilisant le Document Analyzer comme décrit à la fin du Tutoriel UIMA I.
Publié dans UIMA | Tagué , | Laisser un commentaire