Nombre d'occurrences et fréquence d'un terme

Le nombre d'occurrences d'une forme (dans un document, une collection) correspond au nombre de fois que cette forme apparaît.

La fréquence (sous entendu d'occurrence) d'une forme d'un document correspond au nombre d'occurrences de la forme dans le document relativement à la somme du nombre d'occurrences de toutes les formes (éventuellement * 100 pour avoir un poucentage) du document (on pourrait changer document par collection)

Souvent la notion de fréquence est abusivement confondue avec le nombre d'occurrences.

La somme du nombre d'occurrences de toutes les formes constitue une normalisation du nombre d'occurrences.  Le nombre d'occurrence rend compte de "l'importance" d'un terme. La normalisation du nombre d'occurrences d'un terme rend possible la comparaison de deux documents de longueurs différentes.

On peut aussi normaliser par un $log_10$ : de [1 occurrence;+inf) dans [0;4[ (à peu près).

Alimenter son LinkedIn, Twitter, Dokuwiki... avec un flux RSS

Dernière mise à jour : vendredi 22 octobre 2010


En tant que chercheur il est important de communiquer sur ses activités aux différentes communautés auxquelles on appartient.

Le propre du Web 2.0 est de facilement diffuser du contenu et d'en construire de nouveaux à partir d'existants (ainsi que d'en modifier aisément leur forme). C'est le principe de base des réseaux sociaux. LinkedIn, Twitter et Dokuwiki font parties de ces vecteurs de communication du moment.

Néanmoins on ne peut passer son temps à alimenter ces vecteurs, a fortiori quand il s'agit de diffuser la même information sur chacun d'eux !

La solution que j'ai choisie pour communiquer et éviter de perdre du temps dans la recopie des informations que je souhaite communiquer est de tenir ce blog et d'offrir un accès à son contenu à l'aide d'une syndication RSS que j'inscris aux différents réseaux sociaux que j'utilise. 

Une seule entrée et autant de sorties que les applications le permettent. Une bonne application web 2.0 doit pouvoir se nourrir de flux RSS (éventuellement filtrés par le biais des tags) ainsi que pouvoir alimenter d'autres applications.

• Pour LinkedIn : au moins deux moyens
• soit avec l'application blog link
• soit  en créant un groupe, et par le menu "Manage News Feeds" ajouter le flux RSS que vous souhaitez "manger" 
• Pour twitter http://twitterfeed.com/
• Pour Dokuwiki, il suffit d'insérer le code suivant {{rss>http://enicolashernandez.blogspot.com/feeds/posts/default 8 author date 1h }}

Ici 6 raisons qui font de votre blog votre meilleur outil social  et là quelques passerelles entre d'autres outils sociaux

Conférences et journaux sur les aspects ingénierie de la langue

Une version statique et perenne de ce post ici.

Conférences 

• ICTAI : International Conference on Tools with Artificial Intelligence 
• IAAI: Innovative Applications in AI
• DocEng: ACM Symposium on Document Engineering
• LREC: Language Resources and Evaluation Conference
• AIMSA: Artificial Intelligence: Methodology, Systems, Applications
• IJAIT: International Journal on Artificial Intelligence Tools (rang 2)

Journaux

• Natural Language Engineering meets the needs of professionals and researchers working in all areas of computerised language processing, whether from the perspective of theoretical or descriptive linguistics, lexicology, computer science or engineering. Its aim is to bridge the gap between traditional computational linguistics research and the implementation of practical applications with potential real-world use. As well as publishing research articles on a broad range of topics ¿ from text analysis, machine translation, information retrieval and speech analysis and generation to integrated systems and multi modal interfaces ¿ it also publishes special issues on specific areas and technologies within these topics, an industry watch column and book reviews. 
• Language Resources and Evaluation is the first publication devoted to the acquisition, creation, annotation, and use of language resources, together with methods for evaluation of resources, technologies, and applications. Language resources include language data and descriptions in machine readable form used to assist and augment language processing applications, such as written or spoken corpora and lexica, multimodal resources, grammars, terminology or domain specific databases and dictionaries, ontologies, multimedia databases, etc., as well as basic software tools for their acquisition, preparation, annotation, management, customization, and use. Evaluation of language resources concerns assessing the state-of-the-art for a given technology, comparing different approaches to a given problem, assessing the availability of resources and technologies for a given application, benchmarking, and assessing system usability and user satisfaction. 
• La revue Document Numérique publie des articles qui concernent la gestion des documents. Dans ce cadre, il s'agit des documents vus comme supports ou comme finalité d'un processus. Cet aspect concerne les étapes du processus éditorial technique de workflow et de groupware et de reengineering des processus… Les documents sont considérés sous leurs représentations les plus diverses : document image, document révisable, document structuré, document composé d'objets. Les supports jouent un rôle important. Les outils nécessaires à chacune des étapes du processus éditorial sont décrits, ainsi que les aspects juridiques des documents numériques et les méthodes de mise en oeuvre. http://dn.revuesonline.com/ (Hermes / Lavoisier - http://www.revuesonline.com/)
• La revue d'Ingénierie des Systèmes d'Information (ISI) est constituée de numéros thématiques faisant chacun le point sur un aspect traditionnel ou émergent dans le domaine des bases de données et des systèmes d'information. Le domaine des systèmes d'information représente « l'étude des utilisations efficaces de l'information et de son impact potentiel sur les systèmes logiciels et sur les technologies de l'information sur le monde des humains, de l'organisation et du social » (Cushing et Lucas, 1990). La revue d'Ingénierie des Systèmes d'Information est donc destinée à faire le point plusieurs fois par an sur un aspect spécifique des systèmes d'information. Dans cette optique, une personnalité reconnue du domaine sera sollicitée pour prendre la responsabilité d'un numéro spécial. http://isi.revuesonline.com/Publication en français et en anglais (Hermes / Lavoisier - http://www.revuesonline.com/ ; Revues des Sciences et Technologies de l'Information (RSTI))
• Revue pluridisciplinaire destinée à offrir un outil de synthèse aux chercheurs et industriels français en informatique, la revue de Technique et Science Informatiques (TSI) favorise la publication rapide des travaux et fournit un support de transfert bidirectionnel des connaissances entre recherche et industrie. Les articles sont regroupés en trois rubriques scientifiques : synthèse, application et recherche. TSI, la seule revue française de haut niveau en informatique scientifique et technique : rend compte plus rapidement des évolutions scientifiques, couvre de manière plus active les différents champs de connaissance : architectures, bases de données et de connaissances, intelligence artificielle, génie logiciel, concurrence, communication, parallélisme,… réalise des numéros thématiques qui présentent systématiquement des synthèses des domaines scientifiques concernés. http://tsi.revuesonline.com/ (Hermes / Lavoisier - http://www.revuesonline.com/ ; Revues des Sciences et Technologies de l'Information (RSTI))

Sélection d'articles de ACL'2010

Sélection d'articles d'ACL'2010 sur l'analyse du discours en général




Discours

• P10-2028 [bib]: Minwoo Jeong; Ivan Titov Unsupervised Discourse Segmentation of Documents with Inherently Parallel Structure 
• P10-1120 [bib]: Amit Dubey The Influence of Discourse on Syntax: A Psycholinguistic Model of Sentence Processing 
• P10-1073 [bib]: WenTing Wang; Jian Su; Chew Lim Tan Kernel Based Discourse Relation Recognition with Temporal Ordering Information 
• P10-5003 [bib]: Bonnie Webber; Markus Egg; Valia Kordoni Discourse Structure: Theory, Practice and Use

Co-reference

• P10-1142 [bib]: Vincent Ng Supervised Noun Phrase Coreference Research: The First Fifteen Years 
• P10-1144 [bib]: Marta Recasens; Eduard Hovy Coreference Resolution across Corpora: Languages, Coding Schemes, and Preprocessing Information 
• P10-1143 [bib]: Cosmin Bejan; Sanda Harabagiu Unsupervised Event Coreference Resolution with Rich Linguistic Features 
• P10-1128 [bib]: Ryu Iida; Syumpei Kobayashi; Takenobu Tokunaga Incorporating Extra-Linguistic Information into Reference Resolution in Collaborative Task Dialogue 

Réutiliser des outils externes via des commandes shell dans un composant UIMA

Parce que de nombreux outils de TAL non-natifs UIMA sont utilisés par la communauté, parce que ces outils ont souvent requis des investissements conséquents en fonds financiers et en temps de développement, il est  nécessaire de se poser la question de la possibilité de réutilisation de ces outils au sein de chaînes de traitement UIMA avant d'en développer des équivalents en natif.


Le présent composant UIMA shell a pour objet l'implémentation d'un Analysis Engine permettant l'exécution d'une commande shell sur un élément du CAS (Common Analysis Structure) et l'enrichissement du CAS avec le résultat du traitement. L'entrée de la commande peut être soit le SofaDataString d'une vue spécifiée, soit le texte couvert par un type d'annotation (lesquelles elles-même apparaîssent optionnellement dans certains contextes marqués par un autre type annotation). La sortie peut être produite soit sous la forme d'un SofaDataString d'une nouvelle vue créée pour l'occasion ou bien comme valeur d'une feature de type String d'une annotation spécifiée elle aussi créée pour l'occasion.

Son principal objectif est donc de permettre d'utiliser au sein d'une chaîne UIMA des outils accessibles en ligne de commande, lesquels réalisent leur traitement soit sur l'entrée standard (stdin) soit sur un fichier via son nom passé en argument et produisent leur résultat sur la sortie standard (stdout).

L'implémentation présente les caractéristiques suivantes :

• utilisation de l'API shell de F Martini (distribuée sous licence CeCILL-C), laquelle permet de simplifier l'exécution de programme et de ligne de commande depuis Java
• gestion de multiples formats des commandes à exécuter où la donnée à traiter peut aussi bien provenir de l'entrée standard ou constituer un fichier texte passé en argument, être récupéré du système de fichier, pipé, redirigé... 
• traitement de la commande shell sous forme d'un thread
• paramétrage libre et générique des éléments du CAS (view/annotation/feature) d'entrée (à traiter) et de sortie (à créer) notamment à l'aide de l'API java.lang.reflect (constitue des exemples de code générique)

La suite de ce travail pourra être la conception d'un composant type connecteur permettant de récupérer sous forme de types des informations structurées contenues dans des fichiers au format CSV-like (Comma Separated Value), XML... quelle que soit la sémantique de leur structure.

Le code source du composant est disponible sur http://code.google.com/p/uima-shell/ 

UIMA Type mapping

Lorsque l'on souhaite développer un composant à l'aide de l'architecture Apache UIMA, celle-ci requiert de définir les types d'information que l'on souhaite manipuler ainsi que leur organisation ; on appelle cela définir son système de types. D'un point de vue conception de logiciel, cela permet notamment de réaliser un contrôle syntaxique des entrées et des sorties des composants.

Apache UIMA offre la liberté de définir son propre système de types et par conséquent plusieurs systèmes de types peuvent être proposés pour modéliser les mêmes informations. Cette liberté de définition de systèmes de types peut donc conduire à des problèmes d'interopérabilité entre des composants manipulant des informations conceptuellement identiques mais étant en pratique définies par des modélisations distinctes.

Par exemple, word, mot voire token sont des noms différents qui peuvent éventuellement être utilisés pour désigner le même type d'information.

Le uima-type-mapper est un composant qui offre un moyen de conversion d'annotations définies par un système de type donné (appelé type source) vers des annotations définies par un autre système de types (appelés types cibles). En pratique, il permet de faire le pont entre des composants manipulant des annotations ayant des types d'information conceptuellement identiques mais de noms distincts. Les annotations produites par un premier composant peuvent être utilisées en entrée d'un second via notre composant qui réalise la conversion.

Les conversions sont déclarées à l'aide de règles qui spécifient pour des types source donnés de réaliser une opération de création d'une ou plusieurs annotations de types cible aux offsets des annotations de type source rencontrées. Il est possible de spécifier des contraintes sur les caractéristiques de annotations de type source. La cohérence sémantique des types à convertir est laissée libre à l'utilisateur.

En pratique, l'implémentation repose sur

• W3C XPath comme langage déclaratif d'expression des contraintes sur la structure des types des annotations source
• Apache JXPath comme moteur qui implémente le traitement des règles
• java.lang.reflect API pour rendre générique le composant en autorisant la désignation de tout type héritant de uima.tcas.Annotation pour faire l'objet de conversion

La fonction de spécification de contraintes sur les annotations à convertir peut conduire à utiliser ce composant comme un composant d'analyse à base de règles des structures sémantiques UIMA. En effet, le composant peut être utilisé pour réaliser de la reconnaissance de motifs d'annotations au sein d'une structure d'annotations UIMA et de la réalisation d'opérations sur les(/relativement aux) motifs reconnus telles que la création d'annotations, la mise à jour d'annotations, et la suppression d'annotations. Actuellement seule la première opération est gérée, mais les fonctions déjà implémentées dans le composant en font de lui une preuve de concept.

Si vous utilisez ce travail dans vos travaux de recherche, merci de citer l'article suivant 

Nicolas Hernandez, Fabien Poulard, Matthieu Vernier, Jérôme Rocheteau, "Building a French-speaking community around UIMA, gathering research, education and industrial partners, mainly in Natural Language Processing and Speech Recognizing domains", LREC 2010 Workshop 'New Challenges for NLP Frameworks', La Valleta : Malta 

Le code source du composant disponible sur http://code.google.com/p/uima-type-mapper/ 

Sélection d'articles de LREC'2010

En général avant chaque participation à un colloque, je sélectionne une série d'articles qui couvrent mes intérêts de recherche.

Par ailleurs depuis le début de l'année universitaire 2010, nous essayons toutes les trois semaines environ de faire un point biblio sur un colloque du moment. Chacun lit un article en prévision de la rencontre et éventuellement après un rapide tour de table des articles lus, si l'assistance le souhaite le présente pendant une dizaine de minutes. Ces réunions sont informelles, interactives et durent 30 à 45 minutes.

Autant faire partager ce travail. Parmi les thèmes qui m'intéressent il y a l'analyse du discours, les architectures de TAL et les outils d'analyse générique, et l'extraction d'information/connaissances.

J'essayerai d'être systématique sur le thème de l'analyse de discours.

Ci-dessous une première sélection issue de LREC'2010

• 58 Nathanael Chambers and Dan Jurafsky A Database of Narrative Schemas
• 330  Raffaella Bernardi, Manuel Kirschner and Zorana Ratkovic Context Fusion: The role of Discourse Structure and Centering Theory
• 184  Sara Tonelli, Giuseppe Riccardi, Rashmi Prasad and Aravind Joshi Annotation of Discourse Relations for Conversational Spoken Dialogs
• 336  Xuchen Yao, Irina Borisova and Mehwish Alam The PDTB XML: the XMLization of the Penn Discourse Treebank 2.0
• 479  Amal Al-Saif and Katja Markert The Leeds Arabic Discourse Treebank: Annotating Discourse Connectives for Arabic
• 481 Ioana Vasilescu, Sophie Rosset and Martine Adda-Decker On the role of discourse markers in interactive spoken question answering systems
• 582 Stergos Afantenos, Pascal Denis and Philippe Muller Learning Recursive Segments for Discourse Parsing
• 796  Markus Egg and Gisela Redeker How complex is discourse structure?
• 820 Rui Wang and Caroline Sporleder Constructing a Textual Semantic Relation Corpus Using a Discourse Treebank
• 935  Rashmi Prasad and Aravind Joshi Shallow Discourse Parsing: Exploiting Sentence Position and Paragraph Structure for Classifying Connectives and Identifying their Arguments

Dans quel repertoire deposer ses ressources UIMA ?

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.

Repertoires de ressources UIMA (outils, composants, documentations)

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.

*** Yoshinobu Kano, Luke McCrohon, Sophia Ananiadou, and Junichi Tsujii. 2009. Integrated NLP evaluation system for pluggable evaluation metrics with extensive interoperable toolkit. In Proceedings of the Workshop on Software Engineering, Testing, and Quality Assurance for Natural Language Processing (SETQA-NLP 2009), pages 22–30, Boulder, Colorado, June. 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.

Modifier le Build Path de votre projet Eclipse

Le Build Path peut se définir à la création du projet

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 par la suite ces déclarations grâce au menu Properties de votre projet, voir ci-dessous)

 Par la suite, vous pouvez le modifier selon différentes alternatives

1. Dans la vue Package Explorer cliquer droit sur
1. la racine projet > 
1. Properties > Java Build Path > Libraries
2. ou Build Path > Configure Build Path > Libraries
2. Referenced Libraries > Build Path > Configure Build Path > Libraries
2.  Dans Libraries, vous pouvez ajouter les packages
• 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

Créer un projet Eclipse pour le développement d'un composant UIMA

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

L'usage de Maven est utilisé par les gens d'Apache. Il est recommandé lorsqu'on fait du développement conséquent. 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 une approche sans Maven, en particulier l'étape de création du projet, 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 la déclaration manuelle les dépendances qui vont bien dans le projet Eclipse et la déclaration des répertoires qui peut être utilise à ajouter au build path.

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, uima-tools, uima-cpe et uima-document-annotation 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 facilite 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
6. Ajouter les répertoires desc et resources au build path (Bouton droit sur les répertoires et Build Path >  Add to Build Path) 

Construire une chaîne de traitement UIMA à partir de composants existants

Mis à jour le 5 Janvier 2012

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

Le lien suivant explique comment installer les Apache UIMA Addons Annotators et Tools (en gros il s'agit de récupérer le binary des addons de la page http://uima.apache.org/downloads.cgi et de le désarchiver dans UIMA_HOME).

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 des composants que vous souhaitez utiliser : 
• ajouter dans votre build path les jars des composants des composants que vous souhaitez manipuler. Personnellement je le fais en étendant la variable UIMA_HOME et en parcourant le répertoire addons/annotator... mais cela suppose que vous ayez installer les addons dans le répertoire d'installation de UIMA.
  Les jars des addons contiennent en général les descripteurs qui permettent d'utiliser les composants. Le build path rend accessible "by name" les descripteurs... Cela est nécessaire pour spécifier par la suite à notre chaine de traitement quels sont les composants à utiliser.
  Vous n'avez pas de à placer les ressources de ces composants dans le répertoire resource, elles sont elles aussi accessible via le build path.
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 
• Astuce : je crée un sous-répertoire dans desc qui porte le nom du projet (cela aide à s'y retrouver lorsqu'il y a plusieurs des descripteurs définis dans un CLASSPATH). 
• Astuce :  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 le build path 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

Gestion du temps - lois et degrés de priorité

D'après les commentaires et l'adaptation de Pierre STOUFF d'un document qu'il a reçu lors d'une formation sur la gestion du temps

LOIS
Loi de Carlson ou loi des séquences homogènes de travail

" Tout travail interrompu sera moins efficace et prendra plus de temps que s'il était effectué de manière continue"

Loi de Parkinson ou loi de la tendance à l'auto-inflation du temps dépensé

"Le temps investi dans un travail en fonction du temps disponible"

LOI D'ILLITCH ou loi de la contre-productivité du temps investi au-delà d'un certain seuil

"Au delà d'un certain seuil horaire, la productivité du temps investi décroit puis devient négative"

UNE ACTIVITE EST URGENTE SI

"Une activité est urgente si... sa non réalisation immédiate entraîne (avec une forte probabilité) des conséquences nuisibles, irréversibles, irrémédiables. L'urgence est souvent provoquée par l'extérieur."

UNE ACTIVITE EST IMPORTANTE SI

"Une activité est importante si... elle contribue à la réalisation des objectifs de la fonction"

ORGANISER C'EST

"Organiser, c'est remettre régulièrement en cause ce qui existe pour l'améliorer."

LES DEGRES DE PRIORITE

Se concentrer sur un nombre limité de priorités (3 à 5 dans la plupart des cas), privilégier l'importance (contributions, résultats) par rapport à ce qui est urgent (délai, échéance).

1. = IMPORTANT ET URGENT (doit être fait cette semaine)
2. = IMPORTANT (peut attendre à la semaine suivante)
3. = URGENT (à faire prochainement)

Installer et utiliser UIMA TextMarker

Mise à jour le 15 Mars 2011

Ce post fut initialement écrit pour la version TextMarker_1.0.0.201002031959.

Il a été révisé pour la version courante qui est TextMarker_1.0.0.201102241433

La prochaine version est attendue pour... ?

TextMarker est avant tout une bibliothèque libre (licence LGPL) pour le développement d'applications d'extraction d'information à base de règles 

sur des éléments de surface et des annotations existantes

. En tant que bibliothèque il peut s'utiliser relativement simplement au sein d'un Analysis Engine d'Apache UIMA.

C'est aussi un environnement de développement au sein d'Eclipse base sur le framework DLTK 

 (Dynamic Languages Toolkit) 

qui offre via ses plugins un éditeur de règles, des composants pour l'explication de l'inférence des règles et un processus de construction d'Analysis Engines et Systemes de Types.

Il est développé par Peter Kluegl and Martin Atzmueller and Frank Puppe à l'unversité de Wuerzburg (de).

La documentation s'est enrichi considérablement entre 2010/02 et 2011/02. Un certain nombre de dépendances, et de possibilités d'utilisation font que ce n'est pas toujours évident de comprendre comment le faire fonctionner.


Il est possible de l'utiliser hors Eclipse (cf. FAQ), voir pour cela le post Utiliser UIMA TextMarker au sein d'un Analysis Engine (i.e. hors Eclipse).

INSTALLER AU SEIN D'ECLIPSE
La page d'installation référence deux approches possibles soit automatiquement via des sites updates soit manuellement en copiant manuellement les bons plugins et features dans les sous répertoires d'Eclipse. 

Installation automatique au sein d'Eclipse 3.5 via les updates sites
Un update site se déclare via le menu  (Help > Install new softwares). Il peut être utile (si des problèmes sont rencontrés) de redémarrer Eclipse entre chaque installation à l'aide de la commande eclipse -clean.

1. Ajouter http://www.apache.org/dist/uima/eclipse-update-site UIMA (version 2.3) Update site ;
2. Ajouter http://download.eclipse.org/technology/dltk/updates-dev/1.0 DLTK Core Framework (version 1.X) update site pour plugins ; Attention TextMarker utilise actuellement DLTK 1.0 et Eclipse 3.6 update site fournit seulement DLTK 2.0
3. Ajouter http://download.eclipse.org/releases/galileo  Eclipse Modeling Framework (EMF) ; (probablement déjà disponible dans vos Available Sofware Sites) ; 

L'installation de TextMarker ci-dessous conduira Eclipse à récupérer ce qu'il faut sur les  updates site ajoutés ci-dessus.

1. Ajouter http://ki.informatik.uni-wuerzburg.de/~pkluegl/updatesite TextMarker update site ; sélectionner "Work with", déselectionner "Group items by category" et sélectionner "Contact all update sites during install to find required software", sélectionner le TextMarker feature. Le CEV feature est déjà contenu dans le TextMarker feature.
2. Optionnel : Si vous désirez des visualisations HTML alors installer aussi le CEV HTML feature présenté lors de l'update de TextMarker. Par contre ajouter d'abord les XPCom puis XULRunner features http://ftp.mozilla.org/pub/mozilla.org/xulrunner/eclipse/
   Personnellement lors de l'installation de 2011/02 XPCom a pu s'installer mais pas XULRunner, il manquait des dépendances dans les update sites.

Installation manuelle au sein d'Eclipse 3.5

L'installation peut aussi être manuelle en copiant le contenu des répertoires plugins et features de l'archive de TextMarker dans les répertoires de même nom d'Eclipse (contient CEV feature et HTML feature). Ce que j'ai finalement fait en 2011/02.

UTILISER TEXTMARKER AU SEIN D'ECLIPSE

A partir du Getting Started on déduit les étapes suivantes

Initialiser avec

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)

 Exécuter avec

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)

Si des problèmes se produisent, 

Problème avec le data path lors de l'exécution, vous pouvez effectuer ce que la note suivante indique

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.    

A noter que

• 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

Problème de "Interpreter installation TextMarker Interpreter does not exist" lors de l'exécution 

non résolu... je cherchais éventuellement à modifier le build path pour lui indiquer les deux bibliothèques importantes, mais cela ne semble pas fonctionner.

Pour aller plus loin dans la compréhension du projet exemple

LIENS

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

Récupérer des plugins Eclipse hors IDE

Souhaitant automatiser la procédure de récupération et d'installation d'Eclipse, j'ai aussi cherché à récupérer automatiquement les plugins à partir du web.

Cela m'a conduit à produire le script get-and-install-eclipse-plugins.sh

Ce script prend en entrée l'url d'un site distributeur de plugins eclipse, le nom sous lequel vous souhaitez archiver les plugins récupérés et optionnellement la racine du répertoire d'Eclipse dans lequel vous souhaitez installer les plugins.
Le script récupére le fichier artifacts.xml sur lequel il s'appuie pour récupérer les jar plugins et features correspondants au plugin spécifié.
Si plusieurs versions des jars sont disponibles, il récupère la plus récente.
Le script fonctionne sous Ubuntu avec Bash et Perl.

Télécharger sur  http://e.nicolas.hernandez.free.fr/pro/doku.php?id=misc:software:get-and-install-eclipse-plugins

Scripts de téléchargement et d'installation d'un environnement pour utiliser Apache UIMA (>2.3) et développer avec sous Eclipse

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

La version datée du 7/02/2010 intègre les versions suivantes des outils 

• 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

Télécharger ici les scripts d'installation d'un environnement d'utilisation et développement Apache UIMA

Installer Apache Tomcat (6.0.20 Binary)

QU'EST CE QUE C'EST ?
Apache Tomcat est une implémentation open source des technologies Java Servlet et JavaServer Pages (JSP), on dit aussi que c'est un conteneur de servlet. 
Différentes versions d'Apache Tomcat sont disponibles pour différentes version de spécifications de Servlet et de JSP.

• Servlet/JSP Spec. 2.5/2.1 works with Apache Tomcat version 6.0.X
• Servlet/JSP Spec. 2.4/2.0 works with Apache Tomcat version 5.5.X

RECUPERER APACHE TOMCAT
Apache Tomcat est disponible à l'adresse http://tomcat.apache.org

export APACHETOMCATNAME=apache-tomcat

export APACHETOMCATVERSION=-6.0.20

export APACHETOMCATARCHIVEEXT=.zip

wget http://mir2.ovh.net/ftp.apache.org/dist/tomcat/tomcat-6/v6.0.20/bin/"${APACHETOMCATNAME}${APACHETOMCATVERSION}${APACHETOMCATARCHIVEEXT}"

INSTALLER ET CONFIGURER
Configurer la variable APPLIDIR qui indique votre répertoire d'installation.

# Set APPLIDIR

export APPLIDIR=.

unzip "${APACHETOMCATNAME}${APACHETOMCATVERSION}${APACHETOMCATARCHIVEEXT}" -d $APPLIDIR
ln -s "${APACHETOMCATNAME}${APACHETOMCATVERSION}" "$APPLIDIR/${APACHETOMCATNAME}"

Il s'agit maintenant de rajouter à votre .bashrc la variable d'environnement CATALINA_HOME et de la faire pointer vers la racine d'Apache Tomcat désarchivé.

export CATALINA_HOME="$APPLIDIR/${APACHETOMCATNAME}"

Le fichier RUNNING.txt à la racine de votre installation indique comment configurer plusieurs instances de Tomcat, pour cela vous aurez besoin de déclarer la variable d'environnement CATALINA_BASE. Si nécessaire lui donner la valeur de CATALINA_HOME.

DOCUMENTATION
La documentation informe sur comment installer et configurer, créer une première application web, la déployer, gérer les applications web présentes, gérer la sécurité (connexion SSL, droits d'accès...), accéder à une base de données...

EXECUTER
La documentation en ligne et le fichier RUNNING.txt à la racine de votre installation fournissent des informations complémentaires. Le 1er pour éxecuter Tomcat comme démon, le second pour éxecuter Tomcat à la main. 
Démarrer Tomcat avec

$CATALINA_HOME/bin/startup.sh

Après démarrage, les applications par défaut incluses dans Tomcat seront disponibles en visitant

http://localhost:8080/

Arrêter Tomcat à l'aide de

$CATALINA_HOME/bin/shutdown.sh

DEPLOYER
http://tomcat.apache.org/tomcat-6.0-doc/deployer-howto.html
...

MANAGER
Le manager est une application web (installée par défaut dans le context path /manager) qui permet de gérer les autres applications : les déployer, recharger,  undéployer, démarrer, arrêter...
Par défaut, l'application Manager est désactivée. Si vous n'avez pas configuré $CATALINA_BASE/conf/server.xml pour sélectionner un fichier de définition des utilisateurs, des passwords et des rôles autres que   $CATALINA_BASE/conf/tomcat-users.xml, alors éditez le et associer le avec role manager avec une combinaison username/password (la créer ou utiliser une existante). Cela doit donner quelque chose comme :

role rolename="manager"user username="tomcat" password="s3cret" roles="manager"

Pour utiliser le manager se rendre sur

http://localhost:8080/manager/html/

...

Installer les UIMA Addons Annotators & tools

Mise à jour 2011 04 26 : Version courante des addons est toujours la 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://uima.apache.org/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