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
Analysis Engine = Componant Descriptor + Annotator
Descripteur XML de composant (Component Descriptors)
Les composants UIMA sont composés de deux parties distinctes :
- une partie déclarative (le descripteur de composant)
- 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.
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 :
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 :
- Le documents, appelé Sofa pour Subject of Analysis dans UIMA.
- 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).
UIMA : La chaîne de traitement (Collection Processing Engine)
Une chaîne de traitement UIMA comporte trois types d’éléments :
- 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.
- 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.
-
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.
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 :
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 :
- Introduction au Traitement Automatique du Langage Naturel
- Niveaux de traitements et principaux outils
- Plateformes d’annotations linguistiques
- 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
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
- UIMA, a project of the Apache incubator
- Apache UIMA Documentation
- UIMA-FR
- Nicolas Hernandez : UIMA
- Tutoriel (et environnement) d’introduction à UIMA proposé par le LINA lors de l’édition 2009 des Rencontres Mondiales du Logiciel Libre (RMLL)
- Towards an Interoperability Standard for Text and Multi-Modal Analytics
- OASIS Unstructured Information Management Architecture (UIMA) TC
- Objectives of OASIS Unstructured Information Management Architecture (UIMA) TC
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.
-
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. - Dans l’onglet Aggregate, ajouter tous vos annotateur en cliquant sur Add…
- 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.
- 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.
Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users’ Guides)
Construire une chaîne de traitement UIMA à partir de composants existants (chez Nicolas Hernandez)
Exécuter un traitement ou une chaîne de traitement sous UIMA (chez Nicolas Hernandez)
Sommaire UIMA sur ce blog
Construire une chaîne de traitement UIMA à partir de composants existants (chez Nicolas Hernandez)
Exécuter un traitement ou une chaîne de traitement sous UIMA (chez Nicolas Hernandez)
Sommaire UIMA sur ce blog
Tutoriel UIMA II : paramétrage d’un composant d’annotation
- Déclarer des paramètres
Pour déclarer des paramètres pour un composant, il suffit de se rendre dans l’onglet Parameters du descripteur XML de l’annotateur (clic droit sur le fichier .xml puis Open With → Component Descriptor Editor). L’onglet Parameter Settings permet de donner une valeur par défaut aux paramètres déclarés. - Accéder aux paramètres
Supposons que le paramètre maChaine de type String ait été préalablement déclarée au niveau du descripteur XML de l’annotateur (cf. ci-dessus). On peut accéder à ce paramètre dans le code Java de l’annotateur de la manière suivante :
String monParametre = (String) this.getContext().getConfigParameterValue("maChaine");
La méthode getContext() permet de récupérer un objet du type UimaContext qui centralise l’accès aux différentes facettes du contexte de l’annotateur comme les paramètres ou l’historique des événements (logging). - Accéder aux paramètres depuis la méthode initialize()
Un moyen plus propre d’accéder aux paramètres est de surcharger la méthode initialize(UimaContext), appelée automatiquement par le framework lors de l’instanciation de l’annotateur, qui reçoit justement comme paramètre un objet du type UimaContext :
private String monParametre;
public void initialize(UimaContext aContext) throws ResourceInitializationException {
super.initialize(aContext);
monParametre = (String) aContext.getConfigParameterValue("maChaine");
}
Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users’ Guides)
Sommaire UIMA sur ce blog
Sommaire UIMA sur ce blog
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
Livres
National Geographic
