Archives de la catégorie : Eclipse

Manipuler une application développée sous Eclipse sans Eclipse

Eclipse et Ant

Eclipse est un Environnement de Développement Intégré (IDE) libre et extensible, parfaitement adapté au développement d’application en Java.
Bien entendu, un projet réalisé sous Eclipse n’est en général pas destiné à être diffusé et exécuté avec Eclipse. C’est à ce niveau qu’intervient Ant, qui est intégré par défaut dans Eclipse.

Ant (pour Another Neat Tool, un autre outil cool) est un projet open source de la fondation Apache écrit en Java permettant d’automatiser des opérations telles que la compilation, comme le logiciel make largement utilisé sous Linux pour les programmes écrits en C ou C++.
Ant est principalement utilisé pour automatiser la construction de projets en langage Java : compilation, génération de Javadoc, archivage sous forme distribuable (JAR).

Générer un fichier Ant avec Eclipse

Pour générer un fichier Ant avec Eclipse, il suffit de faire :

File → Export… → General>Ant Buildfiles → Next.

Il faut ensuite sélectionner votre projet puis cliquer sur Finish. Eclipse génère alors le fichier Ant (build.xml par défaut). Ce fichier Ant vous permet maintenant d’utiliser la commande ant en ligne de commande pour compiler votre projet :$ ant build par exemple.

Générer un fichier exécutable JAR avec Eclipse, ou Ant

Pour générer un fichier exécutable JAR avec Eclipse, il suffit de faire :

File → Export… → Java>Runnable JAR file → Next.

Il faut alors renseigner la boîte de dialogue Runnable JAR File Export (configuration à exécuter, chemin du Jar…) puis cliquer sur Finish. Noter que cette boîte de dialogue Eclipse propose également de créer un fichier Ant qui permettra de générer à nouveau le JAR ensuite.

Publié dans UIMA, Eclipse | Tagué | Laisser un commentaire

UIMA Document Analyzer : « java.lang.OutOfMemoryError: java heap space »

Si lors de l’exécution de l’outil Document Analyzer d’UIMA vous obtenez l’erreur « java.lang.OutOfMemoryError: java heap space », c’est probablement qu’il faut augmenter la taille de la mémoire allouée à la machine virtuelle Java. Le paramètre -Xms<size> permet de préciser la taille initiale tandis que le paramètre -Xmx<size> permet de préciser la taille maximale.

Pour augmenter la taille de la mémoire allouée à la machine virtuelle Java de l’outil Document Analyzer sous Eclipse, aller dans :
Run → Run Configurations… → Java Application → UIMA Document Analyser

Puis, dans la zone d’édition du cadre VM arguments de l’onglet Arguments, ajouter à la fin :
-Xms256M -Xmx2024M

Publié dans UIMA, Eclipse | Tagué | Laisser un commentaire

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.
  1. 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 → LibrariesAdd External JARs… ; sélectionner le fichier uima-core.jar dans le répertoire apache-uima/lib.
  2. 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).
  3. 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.
  4. 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).
  5. 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.
  6. 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
  7. 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

    Puis cliquer sur Run.

Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users’ Guides)

Sommaire UIMA sur ce blog
Publié dans UIMA, TALN, Eclipse | Tagué , , , , | Laisser un commentaire

Installation complète de l’environnement de développement UIMA sous Linux

Ce billet décrit comment installer complètement l’environnement de développement UIMA sous une station de travail Linux sans avoir besoin des droits d’administrateur. Par installation complète il faut comprendre l’installation de tout ce qui est nécessaire : le SDK Java, Eclipse, les plugins nécessaires et le SDK UIMA.

Installation du SDK Java

La première étape consiste, si ce n’est déjà fait, à installer la dernière version du kit de développement de logiciels (SDK) Java. Commencer par télécharger le fichier d’installation (jdk-6u4-linux-i586.bin dans mon cas) dans le répertoire de son choix. Saisir ensuite, dans un shell, en étant dans le répertoire où le fichier a été téléchargé et où l’installation doit se faire :

$ chmod +x jdk-6u4-linux-i586.bin
$ ./jdk-6u4-linux-i586.bin

(Il vous faut répondre yes aux termes du contrat pour réaliser l’installation)

Installation de l’environnement de développement intégré (IDE) Eclipse

Si ce n’est déjà fait, installer la dernière version d’Eclipse (version 3.3.1.1, build id M20071023-1652 au moment de l’écriture de ce billet). L’installation se résume à décompresser à l’endroit de son choix le fichier téléchargé.

Pour exécuter la version d’Eclipse qui vient d’être d’installée avec la version de Java installée précédemment, il faut saisir dans un shell une ligne de commande du style (penser à créer un raccourci) :


$ ~/eclipse/eclipse -vm ~/jdk1.6.0_04/bin/


Ensuite, dans Eclipse, il faut préciser la version de Java qui sera utilisée. Aller dans :

Window → Preferences… → Java → Installed JREs → Add…

Puis préciser :

JRE name : Java jdk1.6.0_04

JRE home directory : ~/jdk1.6.0_04

Valider en cliquant sur Ok, puis penser à cocher la nouvelle version du JRE ajoutée avant de valider de nouveau en cliquant sur Ok.

Vérifier également, la cas échéant, que la variable d’environnement ECLIPSE_HOME est correcte (i.e. désigne bien le répertoire ~/eclipse) dans :

Window → Preferences… → Java → Build Path → Classpath Variables

Installation du plugin Eclipse EMF

Il faut ensuite installer le plugin EMF utilisé par UIMA. En fait, avec la dernière version d’Eclipse, Eclipse Modeling Framework (EMF) Updates apparait automatiquement dans la liste des sites d’installation automatique de plugins (sinon, se référer à EMF Update Manager Site). Une fois Eclipse lancé, il suffit donc de faire :

Help → Software Updates → Find and Install… → Search for new features to install → Next

Puis sélectionner Eclipse Modeling Framework (EMF) Updates, Ignore features not applicable to this environment et Automatically select mirrors puis Finish.

Ensuite déployer Eclipse Modeling Framework (EMF) Updates pour sélectionner EMF SDK 2.3.1 puis :

Next → I accept the terms in the license agreements → Next → Finish → Install All → Yes

Installation du plugin Eclipse UIMA

On peut alors passer à l’installation du plugin Eclipse d’UIMA :

Help → Software Updates → Find and Install… → Search for new features to install → Next → New Remote Site…

Saisir :

Name : Apache UIMA

URL : http://www.apache.org/dist/uima/eclipse-update-site

Puis Ok.

Sélectionner Apache UIMA, Ignore features not applicable to this environment et Automatically select mirrors puis Finish.

Sélectionner Apache UIMA puis :

Next → I accept the terms in the license agreements → Next → Finish → Install All → Yes

Installation du SDK UIMA

Il faut enfin installer le kit de développement de logiciels (SDK) UIMA. Télécharger la dernière version binaire (Binary) du SDK d’UIMA pour java, puis décompresser à l’endroit de votre choix le fichier téléchargé.

Éditez votre fichier .bashrc pour définir les variables d’environnement UIMA_HOME et JAVA_HOME et modifier le PATH en ajoutant les lignes suivante à la fin du fichier (adapter /home/audibert à votre propre installation, mais ne pas utiliser ~ qui cause parfois des problèmes) :

export UIMA_HOME="/home/audibert/apache-uima"
export JAVA_HOME="/home/audibert/jdk1.6.0_04"
export PATH=${PATH}:${UIMA_HOME}/bin


Puis saisir la commande suivante dans un shell pour mettre à jours les chemins des exemples du SDK :


$ adjustExamplePaths.sh


Penser à lire le fichier README dans le répertoire apache-uima pour plus d’information sur l’installation du SDK UIMA ainsi que pour une procédure permettant de tester votre installation (également décrite ici).

Sous Eclipse, vérifier également que la variable d’environnement UIMA_HOME est correcte (i.e. désigne bien le répertoire /home/audibert/apache-uima) dans :

Window → Preferences… → Java → Build Path → Classpath Variables

Si ce n’est pas le cas, il faut la modifier (bouton Edit…) ou la définir (bouton New…).

Si tout s’est bien passé, tous les fichiers concernant l’installation complète de l’environnement de développement UIMA doivent être répartis dans les répertoires apache-uima pour le SDK UIMA, eclipse pour l’environnement de développement intégré Eclipse et les plugins installés et jdk1.6.0_04 pour le JDK Java.

UIMA Manuals and Guides

Sommaire UIMA sur ce blog

Publié dans UIMA, Eclipse | Laisser un commentaire