samedi 10 décembre 2011

Mise en correspondance de vues via un Aggregate pour interconnecter des composants UIMA (view et sofa name mapping)

Après avoir rappelé quelques notions (que le lecteur averti peut ne pas lire), le post expose brièvement le problème et présente avec un exemple la mise en oeuvre d'une solution de mise en correspondance de vues au sein d'un Aggregate.

Bref rappel de quelques notions
Les chapitres 5 et 6 de la documentation UIMA tutorials_and_users_guides [1;2] rappellent les définitions des notions d'Artifact, Sofa et View.
Brièvement l'Artifact est la chose non structurée que l'on souhaite analyser. Le Sofa (Subject of Analysis) est une représentation de l'Artifact (e.g. HTML). Une annotation metadata est de l'information associée à un Sofa particulier pour en décrire une sous région. La notion de View simplifie les choses quand plusieurs versions de l'Artifact sont nécessaire à différentes étapes de l'analyse (e.g. une version sans balise d'un document XML). Les notions de Sofa et de CAS View sont liées. Dans l'implémentation Apache actuelle (2.4), à chaque Sofa est associé une seule View et à chaque View un seul Sofa. Le nom qui désigne une vue particulière est Sofa name pour des raisons historiques mais cela s'applique indifféremment à View aussi.
L'analyse d'un composant UIMA (AE - Analysis Engine) porte toujours sur une vue. Il peut y en avoir plusieurs. L'AE peut en créer. Les résultats d'analyse peuvent être associés sur les vues traitées ou bien sur les vues créées.
Un AE qui travaille seulement sur une seule vue est appelée "single-view component" et dans le cas contraire "multi-view/multi-sofa component".
Par défaut, si rien n'est spécifié il y a qu'une seule view et celle-ci a le sofa name de "_InitialView".

Problème d'interopérabilité pour interconnecter des composants développés indépendamment
Le développeur d'AE est libre de choisir le nom qu'il souhaite pour désigner ses vues d'entrée et ses vues de sortie.
Cela conduit naturellement à quelques petits soucis lorsque l'on veut interconnecter des composants ayant des noms de vue différents.

Le mécanisme de mise en correspondance des vues au niveau d'un Aggregate
La section 6.4 de la documentation explique et présente différentes situations de mises en correspondance : au sein d'un Aggregate, d'un CPE, d'une application UIMA, pour des services distants. Je rapporte et illustre la solution au sein d'un AE Aggregate.

Pour cela, j'utilise deux composants : l'XmlDetagger présent dans les exemples fournis avec Apache UIMA [4] et le Whitespace Tokenizer des addons de la Sandbox d'Apache UIMA [5].

L'XmlDetagger est un composant multiple vues qui retire les balises d'un document XML. Il lit l'XML d'une vue input nommée "xmlDocument". Le contenu textuel est écrit dans une nouvelle vue output appelée "plainTextDocument".
Le Whitespace Tokenizer est un composant simple vue qui travaille sur la vue par défaut (i.e.  "_InitialView") et qui ajoute à celle-ci des annotations de phrases et de tokens.

Rapidement, je mets en place un projet Java sous Eclipse. J'y ajoute la UIMA Nature, déclare les répertoires desc et resources dans le build path ainsi que les bibliothèques de UIMA [6]. Je rajoute au  le build path les bibliothèques uima-examples [10] et addon whitespace tokenizer [9] qui vont servir pour notre chaîne.

Je crée un descripteur d'AE Aggregate [7] et j'y ajoute by name en pipeline : d'abord l'XmlDetagger  puis le Whitespace Tokenizer (je déclare les bons types à produire en output dans les capabilities).

A la sauvegarde le message suivant s'affiche
Error in AE Descriptor
The Descriptor is invalid for the following reason:
ResourceInitializationException: The output Sofa "plainTextDocument" in component "XmlDetagger" is not mapped to any output Sofa in its containing aggregate, "demoSofaNameMappingAAE". (Descriptor path ...) 

Ce n'est pas réellement une erreur si l'on sait ce que l'on fait. Une vue qui n'est pas utilisée par exemple n'a pas besoin d'être mise en correspondance dans l'Aggregate.
En l'état si on exécute cet AE avec le DocumentAnalyzer [8] sur un document XML quelconque, on obtiendra l'erreur suivante :
org.apache.uima.analysis_engine.AnalysisEngineProcessException: Annotator processing failed. Caused by: org.apache.uima.cas.CASRuntimeException: No sofaFS with name xmlDocument found. 
Vraissemblablement ici il y a des vues qui requièrent d'être mise en correspondance et cela va se faire au niveau de l'Aggregate.

La première chose à faire est d'indiquer que la vue sur laquelle travaille en entrée XmlDetagger, à savoir xmlDocument, correspond à _InitialView dans l'Aggregate. Autrement dit, la vue d'entrée par défaut de l'Aggregate,  _InitialView, doit être mise en correspondance avec la vue d'entrée, xmlDocument, de l'XmlDetagger.
Au sein du descripteur de l'Aggregate, c'est dans la section capabilities que l'on déclare les vues sur lesquelles on travaille (sous section component capabilities) et celles entre lesquelles on réalise des mises en correspondance (sous section sofaMappings).
On ajoute d'abord la vue xmlDocument comme input (entrée) en faisant un add sofa dans la component capabilities.
Ensuite on indique dans la sous section sofaMappings que pour le composant (componentKeyXmlDetagger sa vue (componentSofaNamexmlDocument correspond à la vue dans l'aggregate (aggregateSofaName_InitialView.
Par les éléments componentKey et componentSofaName on désigne le composant et la vue souhaitée chez celui-ci comme devant intervenir dans un mapping. L'élément aggregateSofaName est la clé partagée entre les éléments sofaMapping.
Cette dernière opération doit se faire pour partie à la main en éditant le source (personnellement je n'y arrive pas via l'éditeur du formulaire). Cela donne
<capability>
...
  <inputSofas>
    <sofaName>xmlDocument</sofaName>
  </inputSofas>
  ...
et
  <sofaMappings>
    <sofaMapping>
      <componentKey>XmlDetagger</componentKey>
      <componentSofaName>xmlDocument</componentSofaName>
      <aggregateSofaName>_InitialView</aggregateSofaName>
    </sofaMapping>
  </sofaMappings>
Si on réexécute l'AE on se rend compte que ce n'est pas encore l'idéal car le Whitespace Tokenizer travaille sur l'_InitialView par défaut et traite donc ce qui correspond à l'xmlDocument au lieu du plainTextDocument.
On rajoute dans l'élément inputSofas
<sofaName>_InitialView</sofaName>
et l'élément suivant
  <sofaMapping>
      <componentKey>WhitespaceTokenizer</componentKey>
      <componentSofaName>_InitialView</componentSofaName>
      <aggregateSofaName>plainTextDocument</aggregateSofaName>
    </sofaMapping>
La vue plainTextDocument du XmlDetagger n'a pas été redéfinie dans l'Aggregate, il n'y a pas d'ambiguité. Ce que produit le XmlDetagger au sein de sa vue output plainTextDocument est accessible sous ce même nom au sein de l'Aggregate qui le met en correspondance avec la vue input du
WhitespaceTokenizer.   
L'exécution fonctionne comme attendu finalement.  

Quelques commentaires supplémentaires

Au niveau de l'Aggregate après mise en correspondance, le nom de la vue du componentSofaName
sera renommé en le nom de la vue déclarée dans aggregateSofaName.
Les vues avec leur nom précédent ne seront plus accessibles. Une fois sérialisée en XMI, on constatera sela en cherchant la valeur de l'attribut sofaID.
Les composants d'Apache OpenNLP sont des composants multiples vues et requièrent en général l'usage de mises en correspondance.


Liens

[1] 5. Annotations, Artifacts & Sofas
[2] 6. Multiple CAS Views
[3] 6.4. Sofa Name Mapping
[4] UIMA_HOME/examples/descriptors/analysis_engine/XmlDetagger.xml
[5] http://uima.apache.org/sandbox.html#whitespace.tokenizer
[6] Créer un projet Eclipse pour le développement d'un composant UIMA
[7] Construire une chaîne de traitement UIMA à partir de composants existants
[8] Exécuter un traitement ou une chaîne de traitement sous UIMA (avec UIMAJ et en local)
[9] UIMA_HOME/addons/annotator/WhitespaceTokenizer/lib/uima-an-wst.jar
[10] UIMA_HOME/lib/uima-examples.jar

mercredi 7 décembre 2011

Création d'un portail collaboratif "Texte, Discours et Document"

Partisan du travail collaboratif au niveau scientifique, je tente la création d’un (Google) document publié sur le Web et visible en édition par tous (sans nécessité de compte) pour construire un portail de ressources ayant trait à l’étude, la modélisation, la reconnaissance automatique et les exploitations applicatives des mécanismes d’organisation de l’information au niveau du ”Texte, Discours et Document”.
Cette page est avant tout un outil personnel. Peut être cela servira t elle à d’autres ? J’invite dans tous les cas toute personne intéressée à contribuer !  
Par ressources, j’entends appels à communication, journaux majeurs, (web|bibli)ographie, personnes, équipes, projets, outils, corpus, etc.
Les objectifs sont la veille au niveau national et international et la cartographie du domaine selon les disciplines (traitement automatique des langues, linguistique, psycholinguistique, ingénierie des documents...) et courants théoriques.
Les approches ayant une visée de traitement automatique seront privilégiées.


Le portail se trouve ici !

Ajouter un dépot (repository) Maven à votre forge Google Code grâce à Subversion


Discutés aux deux adresses ci-dessous mais l'alternative d'utiliser un dépot public est conseillée

  1. http://stackoverflow.com/questions/1280470/maven-repository-for-google-code-project
  2. http://www.thewebsemantic.com/2009/04/11/your-very-own-google-code-maven-repo/

Mesurer le nombre de visites sur votre projet hébergé sous Google Code grâce à Google Analytics

Ce post décrit la procédure pour "track visits to Google code projects in Google Analytics".
  1. Anyone may sign up for a free Google Analytics account. Once you have an account
  2. Add a profile for a new domain and specify URL http://code.google.com/
  3. Edit the profile that you just created to change its Website URL to http://code.google.com/p/votre-nom-de-projet/ 
  4. Paste your Google Analytics profile's Web Property ID below and save changes. 
  5. About 24 hours after you add your Web Property ID, your profile should begin to indicate that it is receiving data.

    Publier une Javadoc sous forge Google Code

    La procédure est la suivante
    1. Récupérez la racine du projet
      • svn checkout https://votre-nom-de-projet.googlecode.com/svn/ votre-nom-de-projet --username votre.username
      • cd votre-nom-de-projet
    2. Ajoutez un répertoire javadoc au versionning
      • svn mkdir javadoc 
    3. Réalisez l'export de la javadoc via Eclipse se sera plus simple
    4. Ajoutez les fichiers javadoc au versionning
      • svn add javadoc/*
    5. Ajoutez les propriétés adéquates pour que svn interprète les fichiers de la javadoc  avec le bon type mime
      • find  javadoc -name "*.html" -exec svn propset svn:mime-type text/html  {} + ;
      • find  javadoc -name "*.css" -exec svn propset svn:mime-type text/css  {} + ;
      • find  javadoc -name "*.jpeg" -exec svn propset svn:mime-type image/jpeg  {} + ;
    6. Commitez vos ajouts
      • svn commit javadoc/ -m "ajout de la javadoc"
    7. Votre javadoc devrait être désormais accessible via l'url http://votre-nom-de-projet.googlecode.com/svn/javadoc/index.html ; ajoutez ce lien dans la section de links de Administer > Project Summary

    Publier sur le Web et partager les droits d'édition à tous d'un Google document

    Dans la quête de la recherche d'outils facilitant le travail collaboratif je tente d'utiliser un Google Document qui désormais offrent des fonctionnalités de partage des droits d'édition à tous (sans nécessité de posséder un compte) ainsi que de publication Web.

    La procédure ci-dessous est légèrement différente de celle trouvée sur des réponses officielles (publication de vos documents et publication sur le web). Peut être est ce dû à un retard de mise à jour de la documentation ?

    La procédure a été testée avec un Google Document, mais reste valable a priori pour tout type de documents (document, feuille de calcul, présentation...). Ici vous trouverez un exemple de Google Document publié et ouvert à l'édition (il s'agit d'un site sérieux merci de ne pas le modifier à moins que vous souhaitiez y contribuer).

    Les deux actions, partage de la visibilité et publication sur le web, supposent que vous venez d'ouvrir ou de créer votre Google Document.

    Pour partager la visibilité (notamment en édition) 
    1. Cliquer sur l'icone "Share". Une fenêtre de configuration intitulée "Share settings" apparaît.
    2. Cliquer sur "Change"  au niveau de la première ligne du tableau "Who has access" (par défaut l'accès est limité : "Private - Only the people listed below can access"). Une fenêtre intitulée "Visibility options" apparaît
    3. Sélectionner  "Public on the web. Anyone on the Internet can find and access. No sign-in required."
    4. Et enfin changer l'accès de "Can view" à "Can edit" au niveau de la ligne "Access:Anyone (no sign-in required)" qui a dû apparaître.
    Pour publier sur le Web un Google document
    1. Dans le menu File, cliquer sur "Publish to the Web". Une fenêtre "Control publishing" s'affiche.
    2. Laisser coché "Automatically republish when changes are made".
    3. Cliquer sur "Start publishing" et confirmer. Vous obtiendrez un lien vers le document publié
    4. Par ailleurs, le lien par lequel vous éditiez votre document est désormais public. Vous pouvez le faire circuler.
    Remarques
    • Attention, il est important de noter que la publication sur le Web et sa visibilité sont deux concepts indépendants. 
    • Les contributeurs du Web n'auront pas accès aux options de partage mais pourront intervenir sur la publication.
    • Ils n'auront pas non plus accès à l'historique des modifications ("File > Revision history")
    • Ils pourront télécharger le document dans divers formats (notamment PDF)
    • Ils ne pourront pas changer les notifications qui sont propres à un compte à moins qu'ils ne soient connectés.

    vendredi 22 juillet 2011

    Sélection d'articles de TALN'2011

    Le programme de la conférence est disponible à http://taln2011.org/

    Les articles suivant ont été sélectionnés pour leurs accointances avec le traitement automatique du discours

    • Laurence Danlos. Analyse discursive et informations de factivité 
    • Patrick Saint-Dizier. TextCoop: un analyseur de discours basé sur les grammaires logiques
    • Charlotte Roze. Vers une algèbre des relations de discours pour la comparaison de structures discursives
    • Laurence Longo (Université de Strasbourg), Amalia Todirascu (Université de Strasbourg). RefGen, outil d'identification automatique des chaînes de référence en français
    • Delphine Bernhard and Anne-Laure Ligozat. Analyse automatique de la modalité et du niveau de certitude : application au domaine médical 
    • Laurence Danlos and Charlotte Roze. Traduction (automatique) des connecteurs de discours
    • Maxime Amblard, Michel Musiol and Manuel Rebuschi. Une analyse basée sur la S-DRT pour la modélisation de dialogues pathologiques
    • Yann Mathet (Université de Caen), Antoine Widlöcher (Université de Caen). GlozzQL : un langage de requêtes incrémental pour les textes annotés
    • Marion Laignelet, Mouna Kamel and Nathalie Aussenac-Gilles. Enrichir la notion de patron par la prise en compte de la structure textuelle - Application à la construction d'ontologie





    mercredi 8 juin 2011

    UIMA sur HADOOP

    Faire tourner des applications UIMA sur HADOOP.
    En Février dernier (2011), IBM a fait un gros coup de pub avec son système Watson qui a gagné le jeu Jeopardy aux Etats-Unis contre des joueurs humains (il s'agit de retrouver la question à partir d'une réponse soumise). Le système utilisait UIMA et HADOOP...

    mercredi 25 mai 2011

    Construire des modélisations du French Treebank pour le UIMA HMM Tagger

    Mise à jour le 1 juin. Précision sur le traitement des mots composés du French Treebank

    Ce post décrit la procédure que j'ai mise en place pour construire des modélisations de type HMM (Hidden Markov Model) utilisées par le Tagger de la UIMA sandbox à partir d'un corpus XML qui porte des annotations sur des tokens mots, à savoir le corpus French Treebank.

    Ci-dessous je présente 
    • les données d'entraînement utilisées
    • la procédure d'entraînement et sa mise en oeuvre
    • les composants requis
    • le paramétrage des composants 
    • le contenu d'un projet Eclipse autonome que je distribue et qui illustre la phase d'entraînement de modélisations et la phase d'étiquetage à partir de modélisations construites.
    • les opérations à réaliser au sein du projet Eclipse pour entraîner une modélisation ou étiqueter des textes à partir d'une modélisation existante
    • des problèmes qu'il reste à rêgler pour améliorer les modélisations
    • une FAQ
    Le projet Eclipse est téléchargeable ici. Il s'agit de l'importer dans Eclipse. La donnée d'entraînement n'est pas distribuée (consulter la page dédiée au corpus pour cela, seul un exemple que j'ai construit est distribué). Les modélisations construites à partir du corpus sont présentes et sont distribuées sous licence Apache v2. Toutes les dépendances requises à l'exécution sont présentes.

    Corpus d'entraînement : le French Treebank (training data set)
    J'ai utilisé une version UTF-8 de Juillet 2010 du corpus French Treebank. Ce corpus a été construit à l'Université de Paris 7. Consulter Abeille et al, 2003, Building a treebank for French, in Treebanks, Kluwer pour plus de détails. Contacter A. Abeille pour obtenir une version de ce corpus.

    L'information annotée dans ce corpus permet de construire (entre autres) des modélisations pour l'analyse morphosyntaxique de token mots telles que de
    • l'étiquetage grammatical (part of speech (pos) tagging), 
    • de la morphologie flexionnelle (inflection analysis (mph)), 
    • de la sous-catégorisation grammaticale (subcategorization analysis (subcat)
    • et de la lemmatisation (lemmatization (lemma)).
    Je précise que la procédure décrite ici est indépendante du format XML de la donnée d'entraînement dans la mesure où la seule contrainte soit que l'annotation à apprendre doit être décrite à l'aide d'un balisage en ligne XML (c'est-à-dire couvrant la zone de texte annotée). Le composant d'importation (uima-connectors) que j'utilise me permet cela.

    Procédure de construction de modélisation (training process)
    La procédure de construction de modélisation est la suivante
    1. importation des informations portées par les éléments et attributs XML en annotations génériques au sein d'un CAS représentant le document.
    2. entraînement d'une modélisation HMM à partir de ces annotations
    La mise en oeuvre de la procédure
    • utilise un composant générique pour l'importation des informations XML -les informations sont importées sous la forme d'annotations génériques- et implique l'utilisation d'un composant assurant la transformation des annotations génériques en annotations à même d'être prise en compte par le composant suivant d'apprentissage.
    • utilise les paramètres des différents composants pour spécifier 
      • les vues sur lesquelles travailler : la vue dans laquelle est chargée le document XML et celle où se trouve seulement le contenu textuel avec les annotations importées
      • les featurePath qui pointent le trait de l'annotation dont il faut considérer la valeur pour l'apprentissage
    Composants utilisés (components)
    En pratique j'ai utilisé trois Analysis Engines (AE) appartenant à trois projets distincts pour la phase de construction 
    • le premier, XML2CAS de uima-connectors, permet de parcourir des documents XML et de transformer les éléments et attributs XML en annotations des zones de texte couvertes.
    • le second, annotationMapper de uima-type-mapper, permet de sélectionner et transformer les annotations produites par le uima-connectors en annotations que prendra en entrée le dernier composant d'entraînement (ce projet est aussi appelé uima-annotation-mapper)
    • le troisième, hmmModelTrainer de uima-tagger de la sandbox Apache UIMA, permet d'entraîner une modélisation.
    Et j'ai utilisé deux AE distincts pour la phase d'étiquetage
    • le premier, whitespaceTokenizer de whitespace tokenizer, permet de découper un texte en phrases et mots.
    • le second, tagger de uima-tagger de la sandbox Apache UIMA, permet d'étiqueter un texte à l'aide d'une modélisation.
    A propos de l'Apache UIMA Sandbox HMM Tagger
    • J'ai utilisé la version présente dans UIMA Annotator Addons 2.3.1 qui corrige une anomalie https://issues.apache.org/jira/browse/UIMA-2106 (rapport d'anomalie + correctif). Cette version qui applique le correctif n'est pas encore distribuée à l'heure de l'écriture de ce message, mais se trouve présente dans le répertoire subversion du Tagger dès la version 1088626. Une version compilée avec les sources est fournie.
    • La partie apprentissage portée par l'AE hmmModelTrainer permet de spécifier le trait de l'annotation (featurePath) à prendre en compte pour l'entraînement. Néanmoins celui-ci ne permet pas de spécifier des contraintes notamment sur la valeur d'autres traits présents dans l'annotation dont on a défini le featurePath. Or ici nous en avons besoin pour sélectionner seulement certaines des annotations produites par le XML2CAS
    • La partie étiquetage portée par l'AE tagger ne permet pas à l'heure actuelle de spécifier le trait à annoter. En l'état, quelle que soit la modélisation, le Tagger affecte la valeur prédite au featurePath suivant org.apache.uima.TokenAnnotation:posTag. Ce n'est pas très embêtant si l'on sait ce que l'on fait. Le patch https://issues.apache.org/jira/browse/UIMA-2110  soumis à Apache vise à rendre plus générique le Tagger et résoudre notamment cette limite. Entre autre il permet de spécifier sous forme d'un featurePath le trait de l'annotation auquel il faut donner la valeur prédite par la modélisation. Ce patch n'a pas encore accepté par Apache.
    Paramétrage des composants utilisés (parameter settings)

    L'AE XML2CASAE 
    • produit des annotations XMLElementAnnotation et XMLAttributeAnnotation pour chaque élément XML rencontré. 
      • Les traits de XMLElementAnnotation permettent de connaître le nom de l'élément XML et les noms et les valeurs de ses attributs. Deux structures de données sont disponibles pour cela, l'une d'elle est un tableau de référence vers des annotations XMLAttributeAnnotation correspondant à chacun de leurs attributs. Les XMLAttributeAnnotation correspondent à une annotation pour chaque attribut. Elles déclarent le nom de l'élément XML qu'elles caractérisent ainsi que le nom et la valeur de l'attribut.
    •  prend les paramètres suivants 
      • nom de la vue à créer avec seulement le contenu textuel du document XML (PlainTextOutputView). La vue où se trouve le document textuel peut aussi être spécifiée si elle est différente de celle par défaut. Ici PlainTextDocument
      • nom des éléments XML à transformer en annotations dans le CAS  (XmlTagsToTurnIntoAnnotation). Ici w, qui correspond à la balise du French Treebank pour mot.
    L'AE annotationMapper 
    • prend en paramètre un fichier de règles qui assurent la transformation d'une annotation en une autre (RulesFile). 
    • Globalement ici la règle permet d'une part de sélectionner les annotations XMLAttributeAnnotation qui correspondent à des attributs de mots (balises w) et qui ont un attribut non nul dont on désire utiliser la valeur comme base d'apprentissage (cat, subcat, lemma, mph, ee, ...), et d'autre part de créer pour chacune de ces annotations une annotation manipulable par le composant d'apprentissage avec un trait initialisé à la valeur à apprendre.
    • Ici la règle crée des org.apache.uima.TokenAnnotation et instancie la valeur du trait posTag. On pourrait pour chaque caractéristique apprise changer le trait à considérer. Ce n'est pas très pertinent pour notre construction. Un même trait peut acceillir tour à tour les valeurs du corpus pour chaque entraînement.
    • A noter qu'il est possible de spécifier avec le hmmModelTrainer le featurePath à considérer comme base d'entraînement. Néanmoins celui-ci ne permet pas de spécifier des contraintes notamment sur la valeur d'autres traits présents dans l'annotation dont on a défini le featurePath. Or ici nous en avons besoin pour sélectionner un sous ensemble des XMLAttributeAnnotation parmi celles produites par le XML2CAS. C'est cette situation qui justifie notamment l'utilisation de l'annotationMapper.
    L'AE  hmmModelTrainer 
    • prend en paramètre 
      • le  featurePath qui pointe le trait de l'annotation dont il faut considérer la valeur pour l'apprentissage (FeaturePathPOS)
      • le nom et chemin du fichier de modélisation à créer (ModelExportFile)
    L'AE  tagger 
    • prend en paramètre 
      • le  featurePath qui pointe le trait de l'annotation qu'il faut instancier avec la valeur prédite par la modélisation (TokenFeaturePath)
      • le nom et chemin du fichier de modélisation à utiliser (ModelFile)
    • Le descripteur qui met en oeuvre cet AE l'utilise plusieurs fois consécutivement avec des jeux de valeurs différentes pour appliquer les différents modélisations. 
    • Nous avons étendu le type org.apache.uima.TokenAnnotation à cet effet. Consulter le fichier desc/FrenchTreebankTS.xml
    Contenu du projet Eclipse (Eclipse project description)
    Le projet Eclipse est globalement un projet java ayant la UIMA Nature et ses sous répertoires desc et resources  déclarés comme appartenant au build path. Le post suivant décrit comment créer un projet Eclipse en rajoutant dans le build path les dépendances minimales UIMA requises pour exécuter une chaîne de traitement UIMA.
    • Le répertoire lib contient toutes les dépendances requises, celles de uima, celles des AE de notre chaîne (uima-common, uima-connectors, jxpath et uima-type-mapper) avec notamment le whitespace tokenizer(uima-an-wst) de la UIMA Sandbox et la version patchée du HMMTagger (uima-an-tagger). Ces dépendances ont été déclarées dans le .classpath. Elles seront accessibles lors de l'import du projet.
    • Le répertoire data/input contient un sous répertoire FrenchTreebank avec un fichier exemple qui reprend la structure XML d'un fichier du corpus original. Ce fichier a en fait été construit a posteriori à partir d'analyses produites. Il peut dans le cas présent servir de base d'exemple de la chaîne d'entraînement. Le répertoire contient aussi un sous répertoire text-fr avec des textes en français qui peuvent servir pour tester l'étiquetage à partir des modélisations construites.
    • Le répertoire data/output accueille les résultats d'exécution des chaînes de traitement, aussi bien les xmi (xmi) que les modélisations (models).
    • Le répertoire resources/models contient les modélisations construites sur le corpus FrenchTreebank (les jeux d'étiquettes (ou tagset) sont décrits ici)
      • FrenchTreebankPosUimaHmmTaggerModel.dat: part of speech (pos) tagging ('cat' attribute in the French Treebank)
      • FrenchTreebankMphUimaHmmTaggerModel.dat: inflection analysis
      • FrenchTreebankSubcatUimaHmmTaggerModel.dat: subcategorization analysis
      • FrenchTreebankEeUimaHmmTaggerModel.dat: combination of part of speech (pos) tagging, subcategorization analysis and inflection analysis
      • FrenchTreebankLemmaUimaHmmTaggerModel.dat: lemmatization 
    • Le répertoire resources contient aussi un fichier de règle pour la transformation d'annotations en autres. Cela permet de faire le pont entre le composant d'importation et le HMMTrainer. Son nom ici est XML2CAS-to-HMMTagger_annotationMapperRules.xml
    • Le répertoire desc contient 
      • le descripteur de la chaîne utile pour la construction des modélisations à savoir XML2CAS-annotationMapper-HMMTrainModel-FrenchTreeBank-AAE.xml 
      • un descripteurs de chaîne pour l'étiquetage à partir d'une modélisation à savoir wst-FrenchTreebank-HmmTagger-AAE.xml. Celle disponible par défaut dans l'addon convient très bien mais requiert quelques manipulations pour spécifier le bon fichier de modélisation et étiquetera toujours le featurePath org.apache.uima.TokenAnnotation:posTag
      • un descripteur qui sert pour déclarer l'importation d'un Type System étendant le type TokenAnnotation avec de nouveaux attributs susceptibles d'accueillir le résultat d'étiquetage de différentes modélisations (morphologie, lemmatisation, ...) à savoir FrenchTreebankAE.xml qui importe FrenchTreebankTS.xml.
    Réaliser la construction d'une modélisation (running the training process)
    Le post suivant explique comment exécuter une chaîne de traitement UIMA.

    Pour réaliser la construction d'une modélisation, utiliser le descripteur desc/XML2CAS-annotationMapper-HMMTrainModel-FrenchTreeBank-AAE.xml qui constitue un aggregate d'AE présentés ci-dessus en pipeline.
    1. Placer votre corpus sous la forme d'un seul fichier dans le répertoire data/input/FrenchTreebank. Un fichier exemple est fourni. Une manipulation est décrite ci-dessous pour produire un seul fichier à partir des différents fichiers du French Treebank.
    2. Spécifier dans le fichier de règles de l'annotationMapper le nom de l'attribut XML du corpus French Treebank sur lequel vous souhaitez réaliser l'apprentissage (cat, subcat, lemma, mph, ee, ...)
    3. Spécifier le nom du fichier de modélisation à produire dans le paramètre du descripteur 
    4. Lancer le documentAnalyzer (par exemple) pour exécuter la chaîne en spécifiant surtout l'input
    Réaliser l'étiquetage à partir d'une modélisation (running the tagging process)
    Pour cela utiliser le descripteur desc/wst-FrenchTreebank-HmmTagger-AAE.xml
    1. Les données traitées doivent être des fichiers textes
    2. Spécifier le fichier de modélisation dans le paramètre du descripteur
    3. Spécifier le featurePath de l'annotation à créer avec la valeur prédite par la modélisation
    4. Lancer le documentAnalyzer (par exemple) pour exécuter la chaîne 
    Limites actuelles des modélisations
    • Le corpus compte des mots simples et des mots composés, tout deux balisés avec le même élément. Les mots composés imbriquent des mots simples. Ceux-ci n'ont pas avec les mêmes traits que leurs homologues non imbriqués. La construction de ces modélisations a considéré les mots composés mais non les mots simples imbriqués. 
    Les mots composés sont de la forme suivante
    <w cat="D" ee="D-def-fp" ei="Dfp" lemma="le" mph="fp" subcat="def"></w> <w cat="N" ee="N-C-fp" ei="NCfp" lemma="banque centrale" mph="fp" subcat="C"> <w catint="N">banques</w> <w catint="A">centrales</w> </w>
    ou bien 
    <w cat="ADV" ee="ADV" ei="ADV" lemma="à tout prix"> <w catint="P">à</w> <w catint="D">tout</w> <w catint="N">prix</w> </w>
    La règle de sélection utilisée par l'annotation mapper met des contraintes sur la présence de certains traits. Pour rappel, la contrainte est 
    <Contrainte>.[@elementName='w' and @attributeName='cat' and @attributeValue!=""]</Contrainte>
    En conséquence, les mots simples composants les mots composés ne sont pas considérés.
      A l'inverse, si l'on ne souhaite pas considérer les mots composés mais les mots simples on peut écrire une contrainte comme celle-ci (on filtre sur la présence d'un caractère blanc)
      <Contrainte>.[@elementName='w' and not(contains(@coveredText,' '))]</Contrainte>
        Mais là effectivement nous n'avons plus accès aux traits du mots composés. Cela ne pose pas de problème pour de l'entrainement de découpeur en mots ou en phrases.
          L'apprentissage d'un étiqueteur morphosyntaxique sur des mots composés ne semble pas non plus poser problème.
            Si vraiment on voulait ne pas considérer les mots simples, on pourrait imaginer une contrainte avec alternative qui exclurait les mots composés et considèrerait les traits des mots simples mais cela ne concernerait pas tous les traits (ici seulement les étiquettes grammaticales : cat et catint).
            • Le processus de lemmatisation via l'algorithme utilisé présente des abérations lorsqu'il ne connaît pas le mot à lemmatiser. En effet, il va lui affecter le lemme d'un mot qu'il connaît et avec lequel il partage le plus grand suffixe commun.
            • ...
            Un seul "gros" fichier d'entraînement
            Le corpus French Treebank est un ensemble de fichiers XML. Utilisant un AE et non un Collection Reader (CR) de uima-connector, il me fallait un seul fichier XML contenant toute la collection. Une petite ligne de shell me résoud le problème
            echo '<?xml version="1.0" encoding="UTF-8"?>' > frenchTreebank.xml ; echo "<ftb>" >> frenchTreebank.xml ; for f in `ls lmf*.xml`; do echo $f; export HEAD=`head -1 $f`; if [ "$HEAD" == '<?xml version="1.0" encoding="UTF-8"?><text>' ]; then echo "<text>" >> frenchTreebank.xml; fi;  cat $f |grep -v "xml version" >> frenchTreebank.xml; done ; echo "</ftb>" >> frenchTreebank.xml 
            Environnement d'exécution
            J'ai réalisé mes traitements sur un système linux via Eclipse.
            J'ai eu à augmenter les capacités de la machine virtuelle Java lors de l'exécution de la chaîne de traitement. Via Eclipse, j'ai rajouté la valeur -Xmx2048m dans le menu Run Configurations > Arguments > VM Arguments.
            La machine que j'utilisais offre 16 Go de RAM et un processeur Intel Xeon W3565 @ 3.20GHz.

            Implémentation de l'algorithme Viterbi du HMM Tagger 
            L'implémentation actuelle (src/main/java/org/apache/uima/examples/tagger/Viterbi.java) fonctionne grosso modo de la sorte (il y a ici d'autres détails techniques cachés) :
            Pour chaque mot phrase d'une phrase on cherche à lui attribuer une probabilité d'étiquette pour cela : 
            on regarde si on connaît la probabilité du mot ou de sa forme en minuscule sinon on cherche le suffixe le plus long en commun avec un mot connu sinon on lui attribue la probabilité d'un mot prédéfini.

            lundi 28 mars 2011

            Sélection d'articles de COLING'2010

            Le programme entier est disponible à http://nlp.stanford.edu/coling10/full-program.html
            Les articles téléchargeables de http://www.aclweb.org/anthology/C/C10/

            Deux sessions de 4 présentations chacune sur le Discours. Des communications aussi lors de la session poster.  Importance des questions de modélisation des structures (générale du discours et en particulier temporel) et de la résolution des anaphores/co-référence. On trouve notamment 2 contextes applicatifs du moment : Opinion Mining et Event Extraction. Au moins 2 articles (outils, protocoles d'annotation) sur le PDT (Prague Dependency Treebank - corpus Czech).

            Quelques articles qui m'intéressent
            • C10-1001 [bib]: Stergos Afantenos; Nicholas Asher Testing SDRT’s Right Frontier
            • C10-2118 [bib]: Rashmi Prasad; Aravind Joshi; Bonnie Webber Realization of Discourse Relations by Other Means: Alternative Lexicalizations
            • C10-2172 [bib]: Zhi-Min Zhou; Yu Xu; Zheng-Yu Niu; Man Lan; Jian Su; Chew Lim Tan Predicting Discourse Connectives for Implicit Discourse Relation Recognition
            • C10-1087 [bib]: Shachar Mirkin; Jonathan Berant; Ido Dagan; Eyal Shnarch Recognising Entailment within Discourse


            mercredi 16 mars 2011

            Utiliser TextMarker au sein d'un Analysis Engine (i.e. hors Eclipse)

            Ce post vient compléter le post précédent où je traduisais les manipulations à réaliser pour installer et utiliser TextMarker au sein d'Eclipse. Vous n'avez pas besoin de lire ce précédent post pour comprendre et réaliser les opérations décrites dans le présent post.

            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 (AE) 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'université de Wuerzburg (de).

            La FAQ de TextMarker indique comment développer une application Java qui utilise TextMarker. De l'explication, on en déduit certains éléments pour utiliser au sein d'un AE.

            DEUX PRE-REQUIS : des bibliothèques et le projet exemple
            L'utilisation de TextMarker requiert deux bibliothèques. Il s'agit de 
            • AntLR 3.1.3
            • de.uniwue.tm.textmarker.engine
            AntLR se trouve disponible soit directement sur le site officiel soit dans le plugin Eclipse de TextMarker via l'update site mais pas dans l'archive dédiée à l'installation manuelle (tout au moins il semble manquer des éléments dans le jar supposé plugins/de.uniwue.dltk.textmarker.antlr_3.1.3.201102241433.jar car j'obtiens un java.lang.ClassNotFoundException: org.antlr.runtime.CharStream) . 
            Pour rappel, on ajoute un update site à Eclipse via le menu  Help > Install new softwares (sélectionner et installer les éléments présentés)
            La bibliothèque de.uniwue.tm.textmarker.engine se trouve disponible indifféremment via Eclipse update site ou via l'archive pour l'installation manuelle (la première est en générale plus récente). Ces bibliothèques se trouveront dans le répertoire ECLIPSE_HOME/plugins.

            Le projet exemple fournit des exemples de descripteurs d'AE et de TS. Le récupérer. Je vous invite à consulter les différents fichiers du répertoire script et bien entendu la documentation en ligne (menu de gauche chapitre Langage) pour comprendre. Globalement l'ensemble de scripts sert à annoter différents éléments d'un référence bibliographique...

            VOTRE PREMIER AE AVEC TEXTMARKER
            Afin de réaliser un premier AE, le plus simple est de
            • créer dans Eclipse un Java Project
            • y copier les répertoires descriptor, script, resources, input et output du projet Exemple
            • ajouter dans le build path les bibliothèques d'UIMA habituelle pour faire fonctionner un AE (dans UIMA_HOME/lib, sélectionner uima-core, uima-cpe, uima-document-annotation, uima-tools)
            • ajouter dans le build path les deux bibliothèques requises par TextMarker et qui ont été récupérés selon la manipulation décrite ci-dessus. Ci l'on s'appuie sur l
              ECLIPSE_HOME/plugins/de.uniwue.dltk.textmarker.antlr_3.1.3.201103101605/antlr-3.1.3.jar
              ECLIPSE_HOME/plugins/de.uniwue.tm.textmarker.engine_1.0.0.201103101605.jar
            • ajouter dans le build path les répertoires descriptor, script et resources
            Avant d'exécuter, je jète un oeil aux descripteurs d'AE en ouvrant avant le Component Descriptor Editor et constate une erreur...
            Les descripteurs se trouvent dans descriptor.de.uniwue.example. Il s'agit de
            • AuthorEngine.xml, MainEngine.xml, TestEngine.xml, TitleEngine.xml, YearEngine.xml
            Seul TestEngine s'édite sans souci...
            ... Les autres se plaignent qu'il manque la déclaration du configurationParameter "descriptorPaths", je le rajoute donc pour chacun à la mano à l'aide du Text Editor
                  <configurationParameter>
                    <name>descriptorPaths</name>
                    <type>String</type>
                    <multiValued>true</multiValued>
                    <mandatory>false</mandatory>
                  </configurationParameter>
            et le place sous l'élément

                  <configurationParameters searchStrategy="language_fallback">
            Je lance enfin l'exécution à l'aide du documentAnalyser en spécifiant l'input et  l'output. Tour à tour je teste les différents descripteurs. Ceux ci peuvent s'exécuter indépendamment les uns des autres.
            • AuthorEngine.xml et TitleEngine.xml fonctionne directement sans souci, des annotations peuvent être visualisées dans le XMI produit.
            • YearEngine.xml et MainEngine.xml requièrent de modifier leurs capabilities dans leur descripteur afin de spécifier les types des annotations que je désire visualiser... il y en a pas mal.
            • TestEngine.xml, ne fonctionne pas (null exception)
            POUR ALLER PLUS LOIN


            TODO


            Comment créer son propre AE utilisant TextMarker ?
            • http://tmwiki.informatik.uni-wuerzburg.de/Wiki.jsp?page=AnalysisEngine
            Comment écrire un script TextMarker ?
            • Menu de gauche Langage avec la première section http://tmwiki.informatik.uni-wuerzburg.de/Wiki.jsp?page=Introduction
            • http://tmwiki.informatik.uni-wuerzburg.de/Wiki.jsp?page=Dictionaries

            lundi 14 mars 2011

            Rédaction d'un rapport de stage

            Mise à jour le 23 mars 2011
            Ce document doit encore être modifié notamment pour indiquer les livrables attendues à chaque étape du déroulement d'un projet.

            A l'attention de mes étudiants, une compilation de conseils que j'ai glanés ces dernières années (merci à mes collègues).

            Conseils de rédaction
            • Faites des phrases courtes ou des listes plutôt que des longues phrases.
            • Pour chaque phrase ou paragraphe, réfléchissez à l'effet que vous voulez produire sur le lecteur. Mettez vous à sa place et demandez vous si ce que vous avez écrit lui permet de comprendre le message que vous souhaitez lui faire passer.
            • Faites suivre systématiquement la première apparition d'un terme spécifique à votre domaine d'une définition et d'un exemple illustrant ce qui tombe sous votre définition et ce qui n'est pas couvert par votre définition
            • Expliquez toujours un acronyme lors de sa première occurrence
            • Des schémas sont toujours bon car ils permettent souvent de comprendre plus rapidement.
            • Pensez à faire des schémas assez légers. Les gros schémas peuvent toujours être simplifiés en regroupant des parties qui sont explicitées/détaillées ailleurs.
            • Vous pouvez être amené à décrire le travail réalisé par quelqu'un d'autre que vous. Il faut que cela soit clairement dit. Vous avez le droit de faire des citations et le devoir de citer les sources dans une bibliographie en fin de votre document.
            • La compréhension de votre rapport principal ne doit pas nécessiter de se reporter constamment aux annexes.
            • N'hésitez pas à mettre quelques notes de bas de page. Ceux-ci ne doivent pas contenir des informations nécessaires à la compréhension seulement des complémentaires.
            • Chaque figure doit avoir un titre (éventuellement une légende explicative), un numéro, et être référencée dans le texte. Une figure non citée par la suite fait perdre la piste de lecture.
            • Préférez une numérotation des titres avec des chiffres plutôt que farfelue qui mélange lettres, chiffres et numération romaine
            • Ayez un style sobre, aéré et consistant (choisissez vous une norme dès le départ, par exemple : ligne de code en "Courier New" ou "DejaVu sans mono" taille 10 aligné à gauche, texte normal en "arial" taille 10 ou 11 justifié, etc.).
            • Numérotez vos pages.
            • en tête et pied de page bien venu avec nom du projet (éventuellement abrégé) et noms des étudiants
            • Pensez à faire une table des matières (éventuellement deux : une sommaire au début et complète à la fin)
            • Faites un glossaire si nécessaire
            • Ne recopiez pas introduction, résumé en français et en anglais, présentation de l'entreprise, conclusion d'anciens rapports de stage. Le plus souvent, ce sont de très mauvais textes qui sont recopiés !
            • N'écrivez pas des choses que vous ne comprenez pas.
            Contenu d'un rapport
            Pour mes étudiants en DUT 2eme année, 30 pages environ.

            Page de garde
            • titre de votre projet
            • date de réalisation (éventuellement numéro de version)
            • noms des étudiants et leur groupe
            • nom de l'encadrant
            • logo des entités encadrantes ou commanditaires
            Introduction 
            Globalement 1 page avec un paragraphe par item.

            • contexte du projet
            • présentation du sujet qui doit être compréhensible pour quelqu'un qui n'est pas du domaine
            • annonce du plan du rapport
            Environnement
            1-2 pages
            • Situation de l'établissement où vous avez fait votre stage, au sein de l'entreprise
            • Fonctionnalités de cet établissement (production, administration, etc.)
            • Situation du service où vous avez fait votre stage, au sein de l'établissement de l'entreprise où vous avez fait votre stage
            • Environnement matériel et logiciel dans lequel vous avez travaillé
            Expression du besoin
            Autour de 5 pages (essentiellement sur le détail de l'expression du besoin)
            • Contexte détaillé : problèmes ayant amenés le client à proposer ce sujet, enjeux qui pourraient être solutionnés par votre travail
            • Présentation de l'existant et de ses limites
            • Situation de ce que vous avez réalisé au sein des applications existantes dans la solution utilisée auparavant par l'entreprise
            • Brève description de ce qui vous a été fourni : documents ? ressources logicielles ? 
            • L'expression des besoins qui vous a été fournie. Si celle-ci vous a été donnée sous forme écrite, la fournir entre guillemets. 
            • L'environnement matériel et logiciel que vous deviez utiliser
            Spécification (documents d'analyse)
            10-12 pages

            • Choix d'orientation : ce que vous avez décidé de faire/ne pas faire dans le projet, et la justification (faisabilité, temps, coût, complexité,...)
            • Couche/package de votre architecture en dissociant les aspects métiers, IHM et interaction avec la base de donnée
            • Modèle des données 
            • Modèle des objets : 
              • 1 ou + diagrammes de classe (découpage en package). Les attributs et rôles en français, les invariants en français. Si certaines relations d'héritage nécessitent des commentaires, vous pouvez les insérer dans le document
            • Prototypage de l'interface homme machine
            • Cas d'utilisation : 1 ou + diagrammes de cas d'utilisation
            • Scénarios d'utilisation : diagrammes de séquence (scénario normal, avec alternatives et avec erreurs). Tests d'acceptation (suite d'opérations et résultats attendus dans une situation donnée)
            • Diagramme d'états pour modéliser le comportement de chaque algo important
            Conception
            5-7 pages

            • Choix d'implantation : 
              • comment se traduit la spécification formelle en terme de langage objet ; pour chaque élément de l'analyse (classe, opération, relations), décrivez comment il sera réalisé (attribut de classe, méthode d'objet, méthode statique, instance de classe existante, nouvelle classe, etc.)
                • chaque classe de l'analyse doit être identifiée avec soit une nouvelle classe, soit une classe existante
                • chaque opération doit être associée à une classe pour en faire une méthode
              • de même pour la mise en oeuvre au niveau de la base de donnée
              • et de la conception de l'IHM
            • Structure de fichiers du projet, les fichiers les plus importants
            • Diagrammes d'interaction : pour chaque cas d'utilisation, donner 1 ou + diagrammes de séquence en utilisant les classes et méthodes définies dans les choix d'implantation.
            • Description des opérations : pour chaque méthode critique, décrire son fonctionnement en pseudo-code ou en utilisant une machine à états.
            • Description des cycles de vie : pour chaque classe qui le nécessite (dès l'instant que le cycle de vie n'est pas trivial), décrire le cycle de vie de ses objets par une machine à états.
            • Tests unitaires : pour chaque classe, donner un jeu de test unitaire et de tests d'intégration. Préciser aussi l'ordre d'intégration des classes

            Test de votre logiciel
            0-4 pages

            • Test boîte blanche vs test boîte noire, stratégie de test. Comment ont été constitués les jeux de test. Qui les a constitué ? Résultat des tests.
            • Tests unitaires : trace d'exécution (ne doivent apparaître que les erreurs) + commentaires
            • Tests de scénarios de l'analyse : mise à jour et complément éventuels des scénarios + résultats des tests + commentaires
            • Synthèse : analyse de l'ensemble des tests, comparaison des résultats avec ce qui était prévu dans l'analyse et la conception


            Démarche que vous avez suivie
            2-4 pages
            • La démarche de travail que vous avez suivi entre vous et avec votre encadrant
            • Répartition formelle : qui est sensé faire quoi dans le groupe de projet, description précise du découpage des tâches pour la phase en cours
            • Répartition effective : qui a fait quoi et quand (soit de manière hebdomadaire soit en découpant en 4 périodes : "avant le début officiel du projet en janvier au retour des vacances de noël", "depuis début Janvier et avant la semaine dédiée au projet et les vacances d'Hiver", "durant la semaine de projet", "après la semaine de projet et avant le rendu du rapport" . Si vous travaillez séparément, désignez un coordinateur.
            • Compte rendu sur l'activité d'analyse, de conception, de codage et de test
              • notamment les difficultés rencontrées : problèmes qui vous ont particulièrement gêné pendant l'analyse, la conception, la réalisation et les tests, autres
            • Compte rendu sur le travail général

            Conclusion
            1 à 3 pages

            • bilan de ce qui a été réalisé en regard de l'existant et de ce qui était attendu
            • perspectives pour poursuivre
            Annexes
            • Eventuellement le cahier des charges
            • Manuel Utilisateur
              • Description des procédures pour réaliser 
                • l'installation,
                • la configuration
                • et l'utilisation de l'application 
                  • les aspects généraux de(s) l'interface(s) ou bien intégration des copies d'écran
                  • les différentes opérations disponibles dans l'application et comment les exécuter
              • Description des problèmes courants
              • Mini foire aux questions
              • Paquetage des fichiers sources


            Livrables
            une archive contenant

            • les sources du code src, 
            • javadoc (documentez avec la syntaxe JAVADOC chaque classe, attribut, méthode ou exception. Générez la doc HTML et empaquetez le tout (doc + classes squelettes))
            • doc/userGuide (binaire et source)
            • doc/rapport (binaire et source)
            tar zcf -`date +%Y%m%d`-`date +%H%M`.tgz projet/