Archives du tag : Annotation (UIMA)

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 : 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

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