Où déposer ses ressources ? Le post suit un rapport des répertoires de ressources UIMA existants.

Le CMU est un répertoire public. Il est possible de déposer/retirer des pears de 25 Mo maximum. Ceux-ci sont automatiquement vérifiés comme étant des pears. Cela marche avec Apache UIMA 2.3. Un service de dépot de ressources autres est indiqué mais ne semble pas fonctionner/ être disponible.

Concenant le répertoire Apache, il est possible de déposer une contribution chez Apache moyennant le respect de certaines conditions et en suivant une certaine procédure.

Les 3 répertoires suivants, DKPro, Julie lab, et U-Compare
sont privés. On ne peut faire que de la récupération de l'existant.


Le répertoire de uima-fr.org accueille indifféremment tout type de ressources (outils, composants, documentation, ...) dans différents formats. Il n'offre pour l'instant pas d'outil automatique de soumission et de gestion de ressoures et il convient de contacter les coordinateurs pour déposer une ressource.

Un bref coup d'oeil sur les dépots de ressources UIMA existant dans le monde. J'en compte disponibles en Allemagne, au Royaume Uni, au Japon, aux USA et depuis peu en France.

• the LTI repository at the Carnegie Mellon University
• the Apache repository 
• the DKPro repository at the Darmstadt University  *
• the Julie lab repository at the Jena University **
• the U-Compare project repository ***
• et bien entendu le depot de uima-fr.org promu notamment par le LINA de l'Université de Nantes ****  

* Iryna Gurevych, Max Mühlhäuser, Christof Müller, Jürgen Steimle, Markus Weimer, and Torsten Zesch and. 2007. Darmstadt knowledge processing repository based on uima. In Proceedings of the First Workshop on Unstructured Information Management Architecture at Biannual Conference of the Society for Computational Linguistics and Language Technology, Tübingen, Germany.


** Udo Hahn, Ekaterina Buyko, Katrin Tomanek, Scott Piao, John McNaught, Yoshimasa Tsuruoka, and Sophia Ananiadou. 2007. An annotation type system for a datadriven nlp pipeline. In The LAW at ACL 2007 – Proceedings of the Linguistic Annotation Workshop, pages 33– 40. Prague, Czech Republic, June 28-29, 2007. Stroudsburg, PA: Association for Computational Linguistics.

**** Nicolas Hernandez, Fabien Poulard, Matthieu Vernier, et Jérôme Rocheteau. 2010. Building a French-speaking community around UIMA, gathering research, education and industrial partners, mainly in Natural Language Processing and Speech Recognizing domains. To appear in LREC Proceedings 2010, Malta.

Jérôme Rocheteau décrit en détail comment mettre en place un projet Eclipse pour le développement d'un composant UIMA. Il explique notamment comment activer la gestion de dépendances vers les bibliothèques uimaj-core et uimaj-tools avec Maven.

L'usage de Maven est a recommandé. Mais il requiert l'installation de plugin et un accès réseau au moins à la création pour la récupération des dépendances. Je détaille ici l'étape de création du projet et l'ajout de la UIMA Nature (qui requiert elle aussi l'installation de plugins eclipse disponibles dans un sous répertoire de votre UIMA_HOME depuis la 2.3) ainsi que comment déclarer manuellement les dépendances qui vont bien dans le projet Eclipse.

CREER UN PROJET ECLIPSE POUR LE DÉVELOPPEMENT D'UN COMPOSANT UIMA

1. Créer un nouveau Projet Java : File > New > Java Project > 
2. Donner un Project Name et vérifier le JRE (>=1.5) > Next > Libraries (vous pourrez toujours modifier le Build Path de votre projet Eclipse)
3. Ajouter les dépendances uima-core et uima-tools présentes dans UIMA_HOME/lib :
   
• soit par Add External Jar
  
• soit par Variable qu'il vous faudra étendre voire définir le répertoire qu'elle désigne. Préférez cette démarche qui faciliter la portabilité du projet au sein de différents workspaces
• Cette manipulation n'est pas nécessaire quand vous utilisez Maven
  
4. Finish
5. Ajouter la UIMA Nature : Dans la vue Package Explorer cliquer droit sur le projet > Add UIMA Nature

Apache UIMA utilise le même type de fichier de description pour désigner un composant ou une chaîne de traitement. On peut d'ailleurs voir un composant comme une chaîne de traitement qui a minima ne compte qu'un seul composant à exécuter. Le fichier descripteur est

• soit configuré comme primitif si il désigne un traitement élémentaire. La classe implémentant le traitement sera alors désignée.
• soit configuré comme aggregate si le descripteur référence d'autres descripteurs de fichiers primitif ou aggregate.

C'est de cette manière que l'on peut réaliser de l'encapsulation de traitement.

Le lien suivant explique comment exécuter une chaîne de traitement existantes avec UIMA (en ligne de commande, par un GUI hors Eclipse, au sein d'Eclipse).

Ces utilisations sont illustrées avec des descripteurs présents dans les exemples de code fourni avec UIMAJ. Dans le cadre de ce post nous allons utiliser des composants UIMA Annotator Addons, à savoir le

• WhiteSpaceTokenizer qui découpe en mots, TokenAnnotation, et phrases, SentenceAnnotation, un texte fourni en entrée
• SnowballAnnotator qui effectue une racinisation des TokenAnnotations et rajoute un trait stem aux TokenAnnotation
• Tagger qui rajoute un trait posTag aux TokenAnnotation

Nous réaliserons la construction de notre chaîne à partir d'Eclipse qui offre, à travers ses plugins, les éditeurs de descripteurs qui nous facilitent la tâche.

1. Créer un projet Eclipse pour le développement d'un composant UIMA 
2. Rendre accessible à votre projet les jar et les descripteurs des composants que vous souhaiter utiliser : 
• ajouter dans votre build path les jars des composants des composants que vous souhaitez manipuler
• placer les descripteurs des composants dans le repertoire desc ; personnellement j'ai créé une variable UIMA_ANNOTATOR_HOME et ai importé dans desc les différents fichiers descripteurs que je souhaitais. L'avantage est qu'Eclipse reproduit la structure parente des descripteurs ce qui aide pour s'y retrouver dans les descripteurs.
• placer les ressources de ces composants dans le répertoire resource
3. Dans la vue Package Explorer cliquer droit sur le répertoire desc du projet > New > Other > UIMA > optez pour "Analysis Engine Descriptor File" > Donner lui un nom 
• Personnellement je spécifie le nom des descripteur d'Analysis Engine avec le suffixe AE pour les distinguer des descripteurs de Type System (suffixe TS) par exemple).
4. Dans la vue Package Explorer cliquer droit sur le fichier descripteur que vous venez de créer > Open With > Component Descriptor Editor
5. Sur l'onglet "Overview", spécifier l'engine type : Aggregate
6. Sur l'onglet "Aggregate", 
• le bouton "Add" permet d'ajouter des composants présents dans les lib de votre projet. Par exemple les CR/CC de uima-tools. Privilégiez des import "By name". "By Location" permet d'ajouter des composants n'importe où sur votre système de fichier moyennant la spécification ultérieur de son descripteur.
• Le bouton "Find AE" permet de chercher tous les descripteurs des composants développés sous forme de projet Eclipse actuellement "ouvert" dans votre Workspace y compris le projet courant. Sans spécification, il retourne tous les descripteurs. Privilégiez des import "By name".
• Le Bouton "Add Remote" permet d'ajouter des composants déployés sur des machines distantes
• Ajouter les descripteurs "WhiteSpaceTokenizer", "SnowballAnnotator" et "HmmTagger"dans cet ordre avec le boutton "Add"
7. Sur l'onglet "Capabilities",  cliquer sur  "add Type" et cliquer sur les cases in/out de chaque type.  
8. Exécuter la chaîne (voir la section Exécuter sous Eclipse)

TODO

• Installer et utiliser des composants par runPearInstaller.sh 
• Déployer un composant pour un accès distant et ajouter des composants distants dans une chaîne locale
• Utiliser le flow controler
• Utiliser les UIMA Annotators Addons : OpenCalais Annotator s'interface avec un service web ; Dictionnary et RegExp Annotator requièrent l'ajout de ressources

On peut aussi réaliser les manipulations manuellement au sein d'Eclipse. Pour cela ajouter les sites suivants dans Eclipse (Help > Install new softwares). Redémarrer Eclipse entre chaque installation à l'aide de la commande eclipse -clean

1. http://releases.mozilla.org/pub/mozilla.org/xulrunner/releases/1.8.1.3/contrib/eclipse/ ; sélectionner  XPCOM et XULRunner ;
2. http://download.eclipse.org/releases/galileo (probablement déjà disponible dans vos Available Sofware Sites) ; sélectionner Eclipse Modeling Framework(EMF) ;
3. http://www.apache.org/dist/incubator/uima/eclipse-update-site ; sélectionner UIMA (version 2.3) ;
4. http://download.eclipse.org/technology/dltk/updates ; sélectionner le DLTK Core framework 1.0 ;
5. copier le contenu des répertoires plugins et features de l'archive de TextMarker dans les répertoires de même nom d'Eclipse

1. Importer le projet exemple dans votre workspace
2. Ouvrir la perspective TextMarker (Window > Open Perspective)
3. Stopper la construction automatique, nettoyer et relancer la construction afin de configurer les bons chemins dans tous les composants générés (Project > Stop Build Automatically and do Clean)

1. Vous pouvez ouvrir les fichiers.tm présents dans scripts avec le TextMarker Source Editor (Ouvrir avec >  TextMarker Source Editor) ; mais ce ne sont que des fichiers textes 
2. Supprimer les fichiers présents dans output
3. Lancer TextMarker en cliquant bouton droit Run As > Text Marker et en selectionnant Main.tm ; rien d'apparent ne se produit, mais le répertoire output se remplit à nouveau

 Constater que cela marche

1. Le répertoire output se remplit
2. Faire un open with Web Browser sur les fichiers html du répertoire output pour visualiser le résultat du traitement
3. Le mieux est de lancer un annotation viewer pour visualiser les annotations contenus dans le XMI ; un simple éditeur XML peut faire cela aussi sinon : Run as > Run configurations > Java Applications > org.apache.uima.tools.AnnotationViewerMain en spécifiant en input le répertoire output de TM et en spéciant comme TypeSystem le descriptors/de/uniwue/example/MainTypeSystem.xml. Attention il se peut que vous ayez besoin de lancer cela d'un projet java où les lib de UIMA sont déclarés et avec une copie du répertoire descripteurs de TM déclaré en répertoire source (éventuellement un jcasgen dans le MainEngine.xml)

Clean and rebuild the example project in order to set the correct paths in all generated components (also the path to the main script location). If the builder preference "import by name" is activated, then a new TextMarker project should rather be created in order to automatically include the correct UIMA datapath. Simply copy all elements into the newly created project afterwards.  

• Pour spécifier un data path à utiliser pour trouver une resource by name faire sur le projet bouton droit > Properties > UIMA CDE Property page > entrer autant de chemins absolus que souhaités séparés par le séparateur de classpath
• Pour configurer la résolution des imports à la création des descripteurs ou pour utiliser des imports by name à la création des descripteurs faire Window > Preferences > TextMarker > Builder

• Téléchargement : https://sourceforge.net/projects/textmarker/)
• Documentation : http://tmwiki.informatik.uni-wuerzburg.de

Afin de me faciliter la vie, ainsi celles de mes étudiants, j'ai mis en place un environnement qui regroupe tous les pré-requis pour  utiliser Apache UIMA et développer avec sous Eclipse.

FEATURES

• Scripts pour assister le téléchargement et l'installation d'un environnement pour utiliser Apache UIMA et développer avec sous Eclipse. 
• La configuration est centralisée pour faciliter la prise en compte les futures mise à jour des outils requis pour l'environnement
• Ces outils requis sont Java JDK Sun, Eclipse, plugins eclipse (UIMA, Subversion et Maven), Apache UIMA (UIMAJ, UIMA-AS, UIMACPP, Addons), Apache tomcat, OpenNLP, maven, ant, subversion 
• Les scripts sont distribués sous licence GPLv3 (liberté de modifier et redistribuer le travail, redistribution des travaux dérivés sous la même licence, mise à disposition du code source) 
• Testés sous Ubuntu 8.10 - Hardy et 9.04 - Jaunty Jackalope

VERSION

• Java Sun Development Kit  (jdk-6u17-linux-i586)
• Eclipse Galileo (3.5)
• Plugins UIMA,  subversion subeclipse,  maven m2eclipse        
• Apache UIMA 2.3.0-incubating
• OpenNLP v1.3
• Apache Tomcat 6.0.20

TELECHARGEMENT

Update 20100212: Validé pour Apache UIMA Version 2.2.2-incubating Binary sous linux et Version 2.3.0-incubating

INSTALLATION
Rien de plus simple pour installer les UIMA Annotator Addons and tools

1. Récupérer l'archive addons (celles ci contient tout ce qui est annoncé dans le titre) disponible sur http://incubator.apache.org/uima/downloads.cgi

export UIMAADDONSDISTANTDIR=uimaj-annotator-addons-2.3.0-incubating

export UIMAADDONSARCHIVEFILE=uimaj-annotator-addons-2.3.0-incubating-bin.zip

wget "http://mirror.mkhelif.fr/apache/incubator/uima/binaries/${UIMAADDONSDISTANTDIR}/${UIMAADDONSARCHIVEFILE}"

2. Puis l'installer en la désarchivant dans votre le répertoire parent de votre UIMA_HOME car l'archive contient le répertoire apache-uima qui contient le répertoire addons. De cette manière addons se retrouvera dans votre apache-uima.

unzip "${UIMAADDONSARCHIVEFILE}" -d "$UIMA_HOME/.."

CONFIGURATIONS

Apache UIMAJ Version 2.2.2-incubating contient

• les annotators suivant  DictionaryAnnotator, RegularExpressionAnnotator, Tagger, WhitespaceTokenizer dans apache-uima/addons/annotator 
• les outils suivant SimpleServer, PearPackagingAntTask, PearPackagingMavenPlugin dans apache-uima/addons

Apache UIMAJ Version 2.3.0-incubating contient

• les annotators suivant BSFAnnotator, Lucas, Tagger, ConceptMapper, OpenCalaisAnnotator, TikaAnnotator, ConfigurableFeatureExtractor, RegularExpressionAnnotator  WhitespaceTokenizer, DictionaryAnnotator, SnowballAnnotator dans apache-uima/addons/annotator 
• les outils suivant SimpleServer, FsVariables PearPackagingAntTask dans apache-uima/addons

Update 20100326: Définition de traitement et chaînes de traitement + précision de l'utilisation d'Eclipse pour l'exécution Update 20100212: Validé pour Apache UIMAJ 2.2.*-incubating et  UIMAJ 2.3.*-incubating

Apache UIMA ne distingue pas la notion de traitement de celle de chaîne de traitement. Il ne manipule que des chaînes de traitement qui a minima ne compte qu'un seul traitement/composant à exécuter. La description de la chaîne est réalisée à partir d'un fichier descripteur qui est

• soit configuré comme primitif si il désigne un traitement élémentaire. La classe implémentant le traitement sera alors désignée.
• soit configuré comme aggregate si il désigne une chaîne de traitement. Dans ce cas il référencera d'autres descripteurs de fichiers primitif ou Aggregate.

C'est de cette manière que l'on peut réaliser de l'encapsulation de traitement.

Les différentes manières d'exécuter un traitement sont illustrés avec des descripteurs présents dans les exemples de code fourni avec UIMAJ.

$UIMA_HOME/examples/descriptors/analysis_engine/

EN LIGNE DE COMMANDE
Le UIMA_HOME/README indique comment réaliser un test d'installation. Il s'agit d'exécuter un AnnotatorEngine et d'observer si le résultat correspond au traitement attendu à l'aide de l'outil $UIMA_HOME/bin/runAE.sh

• Argument 1, on indique un descripteur d'AnnotatorEngine, par exemple : PersonTitleAnnotator.xml, SimpleTokenAndSentenceAnnotator.xml, SimpleNameRecognizer_RegEx_TAE.xml 
• Argument 2, un répertoire source où se trouve des fichiers .txt à traiter
• Argument 2, un répertoire de destination des résultats produits
  

$UIMA_HOME/bin/runAE.sh $UIMA_HOME/examples/descriptors/analysis_engine/SimpleTokenAndSentenceAnnotator.xml $UIMA_HOME/examples/data/ $UIMA_HOME/examples/data/processed

A TRAVERS UN GUI HORS ECLIPSE 
Par exemple à l'aide de la commande $UIMA_HOME/bin/documentAnalyzer.sh

• InputDirectory doit diriger vers : applications/apache-uimaj/examples/data
• OutputDirectory doit diriger vers : applications/apache-uimaj/examples/data/processed
• Location of Analysis Engine XML Descriptor : applications/apache-uimaj/examples/descriptors/analysis_engine/SimpleTokenAndSentenceAnnotator.xml

Puis Run et double cliquer sur un fichier pour lancer le Java Viewer (en ligne de commande il s'agit du programme annotationViewer.sh)


AU SEIN D'ECLIPSE

1. Cela requiert de créer un projet Eclipse pour le développement d'un composant UIMA
2. Pour exécuter les outils veiller à ajouter dans les libraries du projet en plus de uima-core et uima-tools, uima-cpe ! Tous ces packages se trouvent dans UIMA_HOME/lib
3. Cliquer sur le projet avec le bouton droit dans la vue Package Explorer > Run as > Run Configurations > Java Application
4. Puis
1. Dans Name: donnez le nom que vous souhaitez à la place New_configuration, par exemple DocumentAnalyser
2. Dans Project: vérifiez que vous êtes dans le bon projet Eclipse
3. Dans Main Class: cherchez la classe DocumentAnalyzer, vous devez trouver (si vous avez bien ajouter le package uima-tools) org.apache.uima.tools.docanalyzer.DocumentAnalyzer
5. Apply > Run ; le DocumentAnalyser exportera les résultats en XMI et exécutera l'Annotation Viewer

Pour visualiser les fichiers XMI préalablement générés

1. réalisez la même démarche avec la classe Annotation Viewer

• un regroupement de projets libres liés au traitement automatique des langues (TAL) 
• et un ensemble d'outils de TAL développés en Java, qui utilisent la bibliothèque d'apprentissage automatique OpenNLP Maxent et qui permettent les traitements suivant : le découpage en phrases, la détection d'entités nommées, la résolution de la coréférence...

wget http://prdownloads.sourceforge.net/opennlp/opennlp-tools-1.3.0.tgz?download

wget -rc http://opennlp.sourceforge.net/models-1.3/

find opennlp.sourceforge.net/models-1.3/ -name "index*" -exec rm {} + ;

mv opennlp.sourceforge.net/models-1.3 opennlp-models-1.3.0

zip -r opennlp-models-1.3.0.zip opennlp-models-1.3.0

rm -r opennlp.sourceforge.net

Ensuite il faut compiler les outils (requiert JAVA_HOME, ant est dispo dans lib/). Après avoir migrer les deux archives dans votre répertoire d'applications (ici $APPLI).

tar -xvzf opennlp-tools-1.3.0.tgz

ln -s opennlp-tools-1.3.0 opennlp

cd opennlp

./build.sh

export OPENNLP_HOME=$APPLI/opennlp

unzip opennlp-models-1.3.0.zip -d $OPENNLP_HOME

ln -s opennlp-models-1.3.0 $OPENNLP_HOME/models

export OPENNLP_HOME=$APPLI/opennlp

export CLASSPATH=${OPENNLP_HOME}/lib/ant.jar:${OPENNLP_HOME}/lib/jakarta-ant-optional.jar:${OPENNLP_HOME}/lib/jwnl-1.3.3.jar:${OPENNLP_HOME}/lib/maxent-2.4.0.jar:${OPENNLP_HOME}/lib/trove.jar:${OPENNLP_HOME}/output/opennlp-tools-1.3.0.jar:${CLASSPATH}

echo "Jules Verne was a French author who helped pioneer the science-fiction genre. He was born in the bustling harbor city of Nantes in Western France in 1828." > /tmp/text ;
java opennlp.tools.lang.english.SentenceDetector \
${OPENNLP_HOME}/models/english/sentdetect/EnglishSD.bin.gz < /tmp/text |
java -Xmx400m opennlp.tools.lang.english.NameFinder \
${OPENNLP_HOME}/models/english/namefind/*.bin.gz

1. Déclarer en répertoire source le répertoire oppennlp_wrappers/src en cliquant bouton droit et Build Path > Use As Source Folder
2. Cliquer sur le projet examples avec le bouton droit puis Properties > Java Build Path > Add Variables > OPENNLP_HOME > Extend > et ajouter les bibliothèques
   

AVERTISSEMENT

Cette page avait été écrit pour décrire l'installation de  l'implémentation Java d'Apache UIMA (uimaj)  Version Binary 2.2.2-incubating sous Linux.

Depuis j'ai produit un ensemble de scripts pour gérer automatiquement le téléchargement et l'installation d'un environnement pour utiliser Apache UIMA (>2.3) et développer avec sous Eclipse.


INTRODUCTION
La documentation officielle référence deux guides 

•   l'UIMA overview and SDK Setup
•   le Getting started (une page ciblée sur l'installation de Java UIMA )

Jérôme Rocheteau décrit comment installer Apache UIMA Java en récupérant les sources sur le dépôts subversion et en les installant avec Maven.

Ci-dessous nous rapportons une synthèse en français des grandes étapes pour la version d'Apache UIMA 2.2.2-incubating et d'Eclipse Galileo 3.5.1; cela comprend l'application du correctif hf1.


1. Installation d'Eclipse et de ses plugins 
Eclipse n'est pas nécessaire pour l'installation et l'utilisation du framework Apache UIMA ou du SDK. Les outils Apache sont utilisables hors IDE même si la tendance serait à privilégier leur intégration seulement au sein de celui-ci (voir le CAS Editor).
Eclipse est néanmoins recommandé pour le développement de composants UIMA.
Nous renvoyons au billet http://enicolashernandez.blogspot.com/2009/12/comment-installer-eclipse-galileo-351.html pour l'installation d'Eclipse et de ses plugins. Nous supposons l'installation de Eclipse Galileo 3.5.1

2. Installation du framework Apache UIMA, de son SDK et des codes exemples


1. Sur http://incubator.apache.org/uima/downloads.cgi récupérer les archives des versions binaires pour Linux des latest official releases de 

• UIMA Java framework and SDK à savoir uimaj-2.2.2-incubating-bin.zip
• UIMA core hotfix 1
  
• UIMA Annotator Addons & Simple Server & Pear packaging tools

2. Désarchiver l'archive "UIMA Java framework and SDK" dans le répertoire de votre choix. Pour ce qui suit nous supposons l'existance d'un répertoire d'applications désigné par la variable d'environnement $APPLI

cd $APPLI

unzip uimaj-2.2.2-incubating-bin.zip

mv apache-uima apache-uimaj-2.2.2-incubating-bin
ln -s apache-uimaj-2.2.2-incubating-bin apache-uimaj