Archives de la catégorie : UIMA

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

par Laurent publié le 27 juin 2013
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

Manipuler une application développée sous Eclipse sans Eclipse

par Laurent publié le 5 avril 2012
Eclipse et Ant
Eclipse est un Environnement de Développement Intégré (IDE) libre et extensible, parfaitement adapté au développement d’application en Java. Bien entendu, un projet réalisé sous Eclipse n’est en général pas destiné à être diffusé et exécuté avec Eclipse. C’est à ce niveau qu’intervient Ant, qui est intégré par défaut dans Eclipse.

Ant (pour Another Neat Tool, un autre outil cool) est un projet open source de la fondation Apache écrit en Java permettant d’automatiser des opérations telles que la compilation, comme le logiciel make largement utilisé sous Linux pour les programmes écrits en C ou C++. Ant est principalement utilisé pour automatiser la construction de projets en langage Java : compilation, génération de Javadoc, archivage sous forme distribuable (JAR).
Générer un fichier Ant avec Eclipse
Pour générer un fichier Ant avec Eclipse, il suffit de faire :
File → Export… → General>Ant Buildfiles → Next.
Il faut ensuite sélectionner votre projet puis cliquer sur Finish. Eclipse génère alors le fichier Ant (build.xml par défaut). Ce fichier Ant vous permet maintenant d’utiliser la commande ant en ligne de commande pour compiler votre projet :$ ant build par exemple.
Générer un fichier exécutable JAR avec Eclipse, ou Ant
Pour générer un fichier exécutable JAR avec Eclipse, il suffit de faire :
File → Export… → Java>Runnable JAR file → Next.
Il faut alors renseigner la boîte de dialogue Runnable JAR File Export (configuration à exécuter, chemin du Jar…) puis cliquer sur Finish. Noter que cette boîte de dialogue Eclipse propose également de créer un fichier Ant qui permettra de générer à nouveau le JAR ensuite.
Publié dans UIMA, Eclipse | Tagué | Laisser un commentaire

UIMA : taille des annotations, un problème de taille ?

par Laurent publié le 26 mars 2012

Prenons une corpus de texte brut occupant 32 468 605 Octets (soit 31 Mo) totalisant 6 468 522 mots (ponctuation comprise). L’étiquetage de ce corpus au format tabulaire (comme celui que produit TreeTagger ou de Cordial Analyseur) avec 12 colonnes nous a conduit à un fichier de 763 866 469 Octets (soit 728 Mo).
Le rapport est ici de 1 pour 24 entre le corpus de départ et le corpus annoté.

Passons maintenant à un fichier d’annotation xmi produit par UIMA pour représenter les mêmes annotations. Le format est bien plus verbeux qu’un fichier tabulaire puisqu’il s’agit d’XML. Nous obtenons un fichier de 5 919 830 882 Octets (soit 5645 Mo ou encore 5,5 Go).
Le rapport est ici de 1 pour 182 entre le corpus de départ et le corpus annoté par UIMA !

Ne s’agit-il pas là d’un problème de taille pour des corpus de grande taille ?

Publié dans UIMA | Tagué | Laisser un commentaire

UIMA Document Analyzer : « java.lang.OutOfMemoryError: java heap space »

par Laurent publié le 23 mars 2012

Si lors de l’exécution de l’outil Document Analyzer d’UIMA vous obtenez l’erreur « java.lang.OutOfMemoryError: java heap space », c’est probablement qu’il faut augmenter la taille de la mémoire allouée à la machine virtuelle Java. Le paramètre -Xms<size> permet de préciser la taille initiale tandis que le paramètre -Xmx<size> permet de préciser la taille maximale.

Pour augmenter la taille de la mémoire allouée à la machine virtuelle Java de l’outil Document Analyzer sous Eclipse, aller dans : Run → Run Configurations… → Java Application → UIMA Document Analyser
Puis, dans la zone d’édition du cadre VM arguments de l’onglet Arguments, ajouter à la fin : -Xms256M -Xmx2024M

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

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

par Laurent publié le 22 mars 2012
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

UIMA : Les annotations

par Laurent publié le 21 mars 2012
Les annotations permettent d’apporter des informations sur des éléments. Dans le cas de corpus textuels, ces éléments sont généralement des segments de textes. Les annotations peuvent être intégrées au document ou, au contraire, être déportées dans un fichier ou une zone séparés. UIMA a fait le choix de représenter les annotations d’une manière déportée. Ce choix présente deux avantages principaux :
  1. Le document source n’est pas altéré par l’insertion d’annotations.
  2. Déporter les annotations peut autoriser la représentation d’annotations concurrentes ou enchâssées.
Bien entendu, le recours à des annotations déportées nécessite la mise en place d’un système d’adressage pour référencer des segments du texte source. Dans UIMA, une annotation hérite généralement du type uima.tcas.annotation qui définit deux attributs begin et end. C’est deux attributs permettent d’identifier le début et la fin du segment annoté en terme de nombre de caractères depuis le début du texte analysé.
Il existe plusieurs façons de réaliser une telle indexation. La figure ci-dessus en illustre deux. Le choix fait par UIMA correspond à l’indexation inférieure qui pointe entre les caractères (ce qui est cohérent avec la philosophie des itérateurs java).
  • Le mot JULES est indexé de la manière suivante : begin = 0 et end = 5
  • Le mot VERNE est indexé de la manière suivante : begin = 6 et end = 11
La capture d’écran ci-dessous montre un exemple d’annotations visualisées dans l’outil Document Viewer d’UIMA. Le texte annoté est « 0123456789 ».
Publié dans UIMA | Tagué | Laisser un commentaire

Principes d’une chaîne de traitements UIMA

par Laurent publié le 21 mars 2012
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

Qu’est-ce que UIMA ?

par Laurent publié le 21 mars 2012

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. Lancé par IBM, et maintenant en incubation à la fondation Apache, UIMA est en cours de normalisation à l'OASIS (Organization for the Advancement of Structured Information Standards). L'objectif de ce framework est de proposer une architecture supportant les différentes étapes du traitement d'un document non structuré (texte, image, vidéo, etc.) en vue d'en extraire de façon automatique des informations structurées. UIMA ne décrit ni comment ces informations doivent être extraites du texte, ni la façon de s'en servir. Par contre, cette plate-forme de développement prend en charge de nombreuses problématiques de façon native comme la réutilisation de composants, la montée en charge et le déploiement distribué, la prise en compte des erreurs, la mise en œuvre de services web, etc.

Le site Apache UIMA propose un schéma illustrant bien les différentes facettes d’UIMA.

Les composants (Components) sont les briques de base permettant de bâtir une application UIMA complète. Les composants d’annotation (Annotators sur le schéma) sont les composants qui supportent la responsabilité la plus importante qui est d’effectuer des traitements (un traitement par composant en principe). Le système de types permet de définir la hiérarchie de types (type au sens informatique du terme) qui supportera les annotations (i.e. c’est le diagramme de classes des annotations).

Les Frameworks sont l’ensemble des bibliothèques et outils permettant de développer et d’exécuter des applications UIMA.

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

Tutoriel UIMA V : Parcourir des annotations en utilisant le CAS

par Laurent publié le 19 mars 2012
Le CAS maintient un index pour chacun des types d’annotations. Il est possible de récupérer un iterateur permettant de parcourir les annotations d’un type donné sans utiliser les classes Java automatiquement créées par JCasGen (comme dans le Tutoriel UIMA IV). Ce tutoriel montre comment parcourir, en utilisant le CAS (plutôt que le JCas), les annotations du Tutoriel UIMA I (Token) pour afficher dans la console le texte qu’elles annotent.
  1. Il faut commencer par créer un nouveau descripteur de composant : File → New → Others → UIMA → Analysis Engine Descriptor File (cf. Tutoriel UIMA I).
  2. Il faut ensuite développer le code de l’annotateur associé en créant une classe héritant de la classe JTextAnnotator_ImplBase (cf. Tutoriel UIMA I), puis écrire le code proprement dit :
    import org.apache.uima.analysis_component.CasAnnotator_ImplBase;
    import org.apache.uima.cas.CAS;
    import org.apache.uima.cas.FSIndex;
    import org.apache.uima.cas.Type;
    import org.apache.uima.cas.FSIterator;
    import org.apache.uima.cas.text.AnnotationFS;
    public class ParcoursCasAnnotator extends CasAnnotator_ImplBase {
      public void process(CAS aCAS) {
        Type TokenCAS = aCAS.getTypeSystem().getType("Token");
        FSIndex tokenIndex = aCAS.getAnnotationIndex(TokenCAS);
        FSIterator tokenIter = tokenIndex.iterator();
        while (tokenIter.isValid()) {
          AnnotationFS annot = (AnnotationFS) tokenIter.get();
          System.out.println(annot.getCoveredText());
          tokenIter.moveToNext();
        }
      }
    }
  3. Il faut enfin créer le composant d’annotation agrégé (Tokenisation du Tutoriel UIMA I + parcours des annotations de ce tutoriel) comme décrit dans le Tutoriel UIMA III, puis tester ce composant d’annotation agrégé (Aggregate Analysis Engine Descriptor) en utilisant le Document Analyzer comme décrit à la fin du Tutoriel UIMA I.
Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users’ Guides)
Sommaire UIMA sur ce blog
Publié dans UIMA | Tagué , , | Laisser un commentaire

Tutoriel UIMA IV : Parcourir des annotations en utilisant le JCas

par Laurent publié le 8 mars 2012
Le CAS maintient un index pour chacun des types d’annotations. Il est possible de récupérer un iterateur permettant de parcourir les annotations d’un type donné. Le plus simple étant d’utiliser les classes Java automatiquement créées par le JCasGen. Ce tutoriel montre comment parcourir, en utilisant le JCas, les annotation du Tutoriel UIMA I (Token) pour afficher dans la console le texte qu’elles annotent.
  1. Il faut commencer par créer un nouveau descripteur de composant : File → New → Others → UIMA → Analysis Engine Descriptor File (cf. Tutoriel UIMA I).
  2. Il faut ensuite développer le code de l’annotateur associé en créant une classe héritant de la classe JTextAnnotator_ImplBase (cf. Tutoriel UIMA I), puis écrire le code proprement dit :
    import org.apache.uima.analysis_component.JCasAnnotator_ImplBase;
    import org.apache.uima.jcas.JCas;
    import org.apache.uima.cas.FSIndex;
    import org.apache.uima.cas.FSIterator;
    public class ParcoursJCasAnnotator extends JCasAnnotator_ImplBase {
      public void process(JCas aJCas) {
        FSIndex tokenIndex = aJCas.getAnnotationIndex(Token.type);
        FSIterator tokenIter = tokenIndex.iterator();
        while (tokenIter.isValid()) {
          System.out.println(((Token)tokenIter.next()).getCoveredText());
        }
      }
    }
  3. Il faut enfin créer le composant d’annotation agrégé (Tokenisation du Tutoriel UIMA I + parcours des annotations de ce tutoriel) comme décrit dans le Tutoriel UIMA III, puis tester ce composant d’annotation agrégé (Aggregate Analysis Engine Descriptor) en utilisant le Document Analyzer comme décrit à la fin du Tutoriel UIMA I.
Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users’ Guides)
Sommaire UIMA sur ce blog
Publié dans UIMA | Tagué , | Laisser un commentaire