Tutoriel UIMA III : enchaîner des composants d'annotation

L'opération consistant à enchaîner plusieurs composants est extrêmement simple et ne requiert aucune écriture de code.

1. 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.
2. Dans l'onglet Aggregate, ajouter tous vos annotateur en cliquant sur Add...
3. 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.

Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users' Guides)
Sommaire UIMA sur ce blog

Tutoriel UIMA II : paramétrage d'un composant d'annotation

1. 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.
2. 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).
3. 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

Comment utiliser un séparateur décimal point à la place de la virgule sous OpenOffice.org en français ?

Pour pouvoir utiliser le point comme séparateur décimal sous OpenOffice.org en français, il suffit de spécifier dans Format → Cellules → Nombres l'option Anglais.

La manipulation est décrite dans la FAQ de OpenOffice.org
Cf. également Une virgule sousOpenOffice.orgg en français

Autre solution sous Ubuntu : aller dans Système → Préférences → Clavier → Agencement, et choisir le clavier "France" et supprimer le clavier "France - Autre" (clavier par défaut).

Forum Ubuntu-fr.org

Tutoriel UIMA I : création d'un composant d'annotation (Analysis Engine)

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 → Libraries → Add 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. Il 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();
      }
    }
   }

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. Tester le composant
   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 annotateur.
6. Tester le composant sous Eclipse
   Commencer par importer le projet exemple d'UIMA : File → Import... → General → Exusting Project into Workspace → Next ; puis dans Select root directory sélectionner le répertoire racine d'UIMA ; puis Finish.
   Il est maintenant possible d'exécuter directement le CPE GUI pour tester le composant :
   

Tutoriel et guide du développeur UIMA (puis cliquer sur Tutorials and Users' Guides)
Sommaire UIMA sur ce blog

Les entités nommées : Installer TagEn sous Linux

Les entités nommées sont une appellation générique pour désigner les noms propres de personnes, de lieux, d'organismes, mais aussi des dates, des prix, etc.

TagEN est un outil de reconnaissance d'entités nommées développé par Jean-François Berroyer et Thierry Poibeau, au Laboratoire d'Informatique de Paris-Nord (LIPN). L'implémentation de TagEN est basée sur des automates à états-finis et utilise pour cela la plate-forme Unitex développée à l'Université de Marne-la-Vallée.

Pour installer TagEN, il faut commencer par le télécharger, puis :

1. Décompresser l'archive TagEN.tar.gz à l'endroit définitif de son choix
2. Exécuter le script compile dans le répertoire TagEN/src

Pour utiliser TagEN, il faut lui spécifier l'un des modes renseignés dans le fichier tagen.conf, comme :

• mucfr : entités nommées MUC (français) ;
• equer : domaine médical (français) ;
• bio : genes, proteins and species names (english) ;
  
• carnivore : carnivore plants (english) ;
  

Par exemple, pour exécuter TagEN sur le fichier ptprince.txt en utilisant le mode mucfr, il faut saisir la commande :

./tagen :mucfr ptprince.txt

Voici quelques extraits du fichier ptprince.tag.txt produit en sortie :

[...]Quand il est <timex><time>midi</time></timex> aux <enamex><location>Etats-Unis</location></enamex>, le soleil, tout le monde sait, se couche sur la <enamex><location>France</location></enamex>.[...]
[...]J'ai vu une maison de <numex><money>cent mille francs</money></numex>[...]
[...]le rayonnement du cadeau de <timex><date>Noël</date></timex> que je recevais[...]
[...]ce sera ce soir vers <timex><time>sept heures quarante</time></timex>[...]

Remarque : il existe une option -t (ex : ./tagen -t :mucfr ptprince.txt) qui ne semble pas documentée et qui produit un résultat plus synthétique contenant le type et les offsets des entités nommées identifiées :

enamex 31 36
person 31 36
enamex 367 372

T. Poibeau (2003) - The Multilingual Named Entity Recognition Framework.

Résoudre un problème d'affichage ou de clavier sous Ubuntu

Sous Ubuntu, depuis une console, la commande suivante

sudo dpkg-reconfigure xserver-xorg

permet de régénérer le fichier /etc/X11/xorg.conf. Cette commande peut permettre de régler des problèmes de serveur graphique, de résolution d'écran, de clavier ou de souris. Toute la configuration, bien assistée et bien explicitée, se passe en mode texte. Il faut donc utiliser les flèches, la touche TAB et la touche Entrée pour naviguer et la touche espace pour les cases à cocher.

Les ampoules basse consommation participent au réchauffement climatique !

Dans son livre, L'énergie en 21 questions, chapitre 7, Pierre Bacher nous explique que les lampes basse consommation sont très fortement recommandées dans les grandes installations commerciales et dans les 10% de logements qui utilisent des énergies renouvelables. Mais pour 90% des autres foyers, le gain en production de CO2 d'une ampoule basse consommation est soit pratiquement nul (dans le cas d'un chauffage électrique) soit complètement négatif (dans le cas d'un chauffage au gaz par exemple). L'explication vient du fait qu'une ampoule classique perd énormément d'énergie (son rendement est faible), mais que l'énergie perdue se transforme en chaleur : or, quand on chauffe son logement, cette énergie n'est pas perdue. Ainsi, lorsque l'on utilise des ampoules basse consommation, le système de chauffage du logement doit compenser cette perte d'énergie calorifique. Le bilan globale en terme de production de CO2 n'est alors souvent pas favorable. La publicité faite pour ces lampes peut se justifier comme symbole des économies d'énergie, mais pas comme moyen de préserver le climat !

La fonte des glaces des pôles entraine-t-elle la monté du niveau de la mer ?

La physique c'est fantastique est un site sympathique de vulgarisation concernant la physique et la chimie. Par exemple, ce site explique ici pourquoi la fonte d'un glaçon flottant à la surface d'un verre rempli d'eau à ras bord ne fait pas déborder le verre. La conclusion est par contre très surprenante :

Ce problème [...] permet de mieux comprendre l'actualité : il est souvent dit dans les médias que le réchauffement de la Terre va faire fondre les glaces du pôle et qu'ainsi certains pays seront engloutis. Or ceci est faux [...] en fait ce n'est pas la fonte des glaces qui va provoquer la montée des eaux des océans mais un autre phénomène très courant : un liquide se dilate [...] quand la température augmente [...]

Cette conclusion est tout simplement erronée. En effet, il faut distinguer deux sortes de glaces :

• les calottes, posés sur les continents, qui peuvent atteindre plusieurs milliers de mètres d'épaisseur,
  
• et les banquises, flottant sur la mer, qui peuvent atteindre 15 mètres d'épaisseur.

S'il est exact que la fonte de la banquise n'entraine pas directement de montée du niveau de la mer, il en va tout autrement pour les calottes de l'Antarctique et du Groenland ! Ainsi, la fonte totale de ces calottes entrainerait une montée du niveau de la mer d'environ 77 mètres ! Depuis 1880, le niveau de la mer est monté de 12 cm environ. 5 cm sont dus à la dilatation thermique et 7 cm à la fonte des calottes.

Évolution du climat à court terme et à long terme
Élévation du niveau marin par fonte des glaces ?

TV multiposte (télévision sur l'ordinateur) avec VLC

En étant abonné à Free, pour pouvoir regarder une chaine télé, ou écouter une station de radio, sur l'ordinateur, il faut :

1. Configurer le pare-feux (firewall). Par exemple, avec Firestarter, il suffit, dans l'onglet Politique du trafic entrant, d'autoriser les connexions de l'hôte mafreebox.freebox.fr.
2. Lancer VLC, puis Fichier → Ouvrir un fichier (avancé)... et saisir http://mafreebox.freebox.fr/freeboxtv/playlist.m3u dans le champs Ouvrir et enfin valider (Ok). Faites ensuite apparaitre la Liste de lecture et choisissez votre chaine.
   

Le plus simple est de configurer un raccourci (Lanceur d'application personnalisé) avec la commande suivante :

vlc -vvv http://mafreebox.freebox.fr/freeboxtv/playlist.m3u

Installation d'UIMA sous Linux (... Suite)

1. Verifying Your Installation (extrait du fichier README dans le répertoire apache-uima)
   
   To test the installation, run the documentAnalyzer.sh:
   

   $ documentAnalyzer.sh

   This should pop up a Document Analyzer window. Set the values displayed in this GUI to as follows:
   
   • Input Directory: UIMA_HOME/examples/data
   • Output Directory: UIMA_HOME/examples/data/processed
   • Location of Analysis Engine XML Descriptor: UIMA_HOME/examples/descriptors/analysis_engine/PersonTitleAnnotator.xml
   Replace UIMA_HOME above with the path of your Apache UIMA installation.
   
   Next, click the Run button, which should, after a brief pause, pop up an Analyzed Results window.
   Double-click on one of the documents to display the analysis results for that document.
   
   
   
2. View the examples code with Eclipse (extrait du document UIMA Overview & SDK Setup section 3.2. Setting up Eclipse to view Example Code)
   
   
   You can create a special project in Eclipse to hold the examples. Here's how:
   
   • In Eclipse, if the Java perspective is not already open, switch to it by going to:
     

     Window → Open Perspective → Java

   • Select the File → Import menu option.
   • Select General/Existing Project into Workspace and click the Next button.
   • Click Browse and browse to the UIMA_HOME directory.
   • Click Finish. This will create a new project called uimaj-examples in your Eclipse workspace. There should be no compilation errors.
   To verify that you have set up the project correctly, check that there are no error messages in the Problems view.

Sommaire UIMA sur ce blog