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.
-
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 → Libraries → Add External JARs… ; sélectionner le fichier uima-core.jar dans le répertoire apache-uima/lib.
-
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). -
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. -
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). -
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. -
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 -
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
- Imput Directory:
Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users’ Guides)
Sommaire UIMA sur ce blog
Sommaire UIMA sur ce blog
Publié dans UIMA, TALN, Eclipse
Tagué Analysis engine, CAS, Component descriptor, Document analyzer, JCAS
Laisser un commentaire
