Archives du tag : Annotator

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

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

Composant d’annotation (Analysis Engine)

par Laurent publié le 30 janvier 2012

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)

par Laurent publié le 29 novembre 2011

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