Installation

Sur cette page, téléchargez la dernière version à dézipper.

Pour lancer le logiciel : se placer dans le répertoire App d'Unitext et lancer le jar : $ java -jar Unitex.jar
Il faudra, lors du premier lancement, décider de l'emplacement des données ainsi que de la langue (et les choix sont nombreux !).

Utilisation

Très brièvement, les étapes sont :

1. importez un texte en effectuant les prétraitements nécessaires
2. appliquez une concordance à partir du menu Text/Local Pattern
   • la solution “expression régulière” est rapide dans le cas d'une recherche simple de concordance (bien que l'expression régulière puisse être élaborée)  ;
   • la solution des “graphs” permet des requêtes beaucoup plus complexes (exploitation des catégories grammaticales, croisement des données, plusieurs chemins/solutions possibles) ;

Exemple d'utilisation

Dans le cadre de la recherche Onyme concernant la détection et l'extraction de données de type opinion, le logiciel nous a aidé à élaborer et à tester des règles lexicales avant de les développer en java.

• À partir des résultats d'une recherche sur le terme “disponibilité” sur la base de données, sous PGAdmin, nous avons pu enregistrer un corpus de verbatims pertinents dans un fichier texte (peu importe les guillemets mais encodé en UTF-16, ce qui est important pour Unitex) ;
  

  Extraction de verbatims sous PGAdmin

• importer le .txt enregistré dans Unitex sous le menu text/open (et non open preprocess text) ;
• faire le preprocessing du texte, ce qui génère un “.snt” et la visualisation du texte brut ;
• extraire des concordances à partir du menu text/local Pattern (ou ctrl+L) ;
• choisir entre une expression régulière ou un graph et appliquer les paramètres voulus puis cliquer sur search ;
cheap camel cigarettes
• paramétrer d'autres éléments pour la mise en forme (ordre alphabétique, etc.) de la concordance ou directement cliquer sur build concordance ;

Résultats

• À partir d'une expression régulière, ici simplement “disponibilité” :

→ 200 réponses



Extraits des résultats d'une requête simple sur le terme disponibilité

L'ordre alphabétique est ici à gauche du terme et on voit qu'il y a souvent une virgule qui le précède, qu'il se situe donc souvent en début de syntagme.
L'ordre à droite serait plus pertinent pour détecter des collocations (disponibilité des vendeuses apparaît probablement très souvent) ;

• À partir d'un graph :

La rédaction d'un graph se fait sous le menu FSGraph/New (assez difficile de prise en main, il faut être un peu patient … mais ça vaut le coup !)
Le graph appliqué pour notre exemple ressemble à cela :



Exemple d'un graph de base

L'objectif étant de voir s'il y a beaucoup de prépositions qui suivent directement le terme “disponibilité” en sortie :
Le processus pour appliquer le graph est le même que pour les expressions régulières sauf qu'il faut aller chercher le fichier .grf précédemment enregistré.

→ 66 réponses (sur un total de 200 réponses)



Extrait résultats du terme

Conclusion

L'intérêt d'Unitex dans ce cadre est qu'on peut facilement faire évoluer le graph pour affiner et adapter les règles aux corpus. Ainsi, il s'agira ensuite de voir s'il y a plus fréquemment (et si cela fait sens) un terme intermédiaire entre disponibilité et les prépositions, s'il n'y a pas des collocations voir expressions très figées qu'il serait plus pertinent de traiter dans le programme plutôt que de passer par des chemins détournés générant du bruit et du temps de développement.

Pour une bonne prise en main du logiciel, le manuel Unitex rédigé par le LIPN (Paris Nord) est très bien fait, mieux vaut le garder sous le coude !

Les standards : RDF, XML et RDFS

Les triplets RDF

RDF, abréviation de Ressource description Framework, est à concevoir comme un modèle de représentation. Il est à la base de la logique de représentation et de structuration des savoirs. Ces derniers s'organisent autour de plusieurs graphes, collections de triplets dans lesquels chaque élément de connaissance se présente sous la forme : sujet, prédicat, objet.

Représentation schématique courante du triplet RDF

Exemple de triplet RDF

Le RDF n'est pas (malgré certaines confusions rencontrées) directement associé au XML. Il sert de modèle, pose les principes de structuration pour des schémas appelés aussi vocabulaires. Certains de ces schémas sont proposés et/ou validés par le Word Wide Web Consortium (W3C) : OWL, SKOS, etc. Certains sont indépendants : FOAF, etc. Nous y reviendrons.

En outre, le RDF est fondé sur la notion d'URI, adresse locale ou distante des ressources. Les objets et les prédicats sont associés aux URI, les objets peuvent également l'être.

Syntaxe XML

Le XML (eXtensible Markup Language) est une syntaxe de description, langage informatique conçu pour structurer et partager les données. Le XML répond à certains principes rigoureux dont la validation nécessite le plus souvent une DTD ou autre schéma de description. Le XML doit surtout répondre à une logique structurelle, une rigueur syntaxique, mais également à une logique informationnelle, une rigueur dans la formulation (ce qui lui donne ce degré sémantique).

Exemple d'une structure xml sans schéma associé :

	
		21
		266
	
	
		
			Programming the semantic Web
		
	

RDF/XML

Appuyé sur la syntaxe du XML, le RDF offre une logique de structuration des savoirs. On parle alors de RDF/XML. Exprimé dans ce langage, la structure précédemment prise pour exemple pourrait rendre compte des relations entre les différents éléments en définissant des sujets, des objets et des prédicats.

Par exemple : Programming the semantic web est un titre ; un titre se donne à un ouvrage ; un ouvrage a un certain nombre de pages ; un éditeur édite un ouvrage; etc. Une succession de triplet permettant d'inférer automatiquement des raisonnements de type : Programming the semantic web est un ouvrage de 266 pages édité par O'Reilly.

RDF Schéma

RDF Schéma est le vocabulaire de structuration proposé pour la description du savoir. Répandu aussi sous l'acronyme RDFS, il répond aux principes du RDF (collection de triplets organisés en graphes) et propose des noms de balises et attributs XML standardisés (tant dans leur forme que dans leur organisation) pour l'échange et le partage des données décrivant les savoirs.

Ces trois aspects fondamentaux du web sémantique sont quelque peu complexes (et non exhaustifs… nous aurions pu également aborder N3, N-Triple, Turtle, RDFa, etc.). Ce pourquoi il semble intéressant de faire une redirection vers un diaporama assez clair sur le sujet, proposé par Les Petites Cases et disponible sur SlideShare.
La suite de ce billet présente quelques vocabulaires spécifiques dont OWL est le plus adapté pour les ontologies. Nous verrons cependant que d'autres vocabulaires existent et cohabitent selon les besoins.

Quelques schémas existants

Il y a donc des schémas standardisés pour une fonction précise et qui répondent aux précédents principes exposés. Il y a par ailleurs des exemples d'implémentation de ces schémas partagés par des communautés (puisque tel est l'objectif). Ci-dessous une brève présentation de quelques schémas pour l'exemple.

Web Ontology language (OWL)

Schéma de description standardisé par le W3C, le OWL est un vocabulaire poussé décrivant les savoirs. Au-delà d'une hiérarchie, OWL offre des possibilités très affinées d'inférence et de raisonnement permettant ainsi la manipulation d'ontologie. Très complexe, sa structure prend trois formes, de la plus simple à la plus complexe : OWL Lite, OWL DL et OWL Full qui diffèrent par quelques principes de structuration mais qui restent compatibles. La version Full sert à décrire et à inférer de la manière la plus complexe possible, se voulant au plus proche des raisonnements humains. La version simplifiée ainsi que l'intermédiaire permettent de répondre à plusieurs degrés d'attentes dans la définition de l'ontologie (selon les besoins, les objectifs et les moyens).

OWL se présente sous la forme de classes, de propriétés et d'instances.

Une classe comprend une collection de propriétés et décrit un ensemble d'instances. À savoir que toutes les ontologies en OWL ont une “super classe” appelée Thing dont toutes les autres classes sont des sous-classes. Soumises au principe de subsomption, les classes héritent des propriétés des classes qui les dominent.

Les propriétés font la richesse du schéma. Elles permettent d'associer des domaines, de restreindre ces associations, de définir des types de données, de définir des raisonnements logiques, etc. Elles peuvent être hiérarchisées et caractérisées (par exemple si elles sont symétriques (si un individu est lié à un autre par une propriété alors le second est également lié au premier par cette même propriété : si A estFrère de B alors B estFrère de A)

Les instances de classes, appelés aussi axiomes sont les membres de ces ensembles. En d'autres termes, ce sont les objets des domaines. Elles sont définies par leur appartenance à une classe et des propriétés. Ces dernières permettent à la fois d'associer les individus (owl:sameAs permet d'associer Charlie Parker et The Bird) mais également de typer les données auxquelles doivent correspondre les individus (une date d'album correspond à un format particulier de date).

SKOS

Simple Knowledge Organization System (ou Système simple d'organisation des connaissances) est un modèle de structuration adapté aux données terminologiques structurées types thesaurus, vocabulaires contrôlés, classification ou encore les tags issus de la folksonomie (tag, descriptions de contenu par les utilisateurs).

Un exemple est visible sur le site de bibliothèque du Congrès qui a traduit son langage d'indexation LSCH en SKOS. L'autorité web semantics illustre la forme et ce qu'il est possible de faire avec SKOS.

• http://id.loc.gov/authorities/sh2002000569.rdf où web semantic est présenté sous sa forme xml/rdf et définit comme une instance de la classe concept ;

  
  
  World Wide Web
  
  
  

• http://www.w3.org/TR/skos-reference/skos.html#Concept où la classe “concept” est présentée au format html
• sous l'onglet “vizualisation”, une heuristique du vocabulaire permet une navigation animée

Dubin Core

Autre schéma très utilisé dans le domaine des sciences de l'information, le Dublin Core est un schéma de description de données bibliographiques pour des ressources documentaires numériques ou non : site Internet, monographie, blog, eBook, etc. Il permet l'échange de description bibliographiques pour les bibliothèques par exemple.
Le Dublin Core (DCMI) se présente sous la forme d'une quinzaine d'éléments de descriptions (titre, auteur, éditeur, date, format, etc. listés sur ce guide d'utilisation) :

DCMI Metadata Terms in the /terms/ namespace



2010-10-11

L'utilisation cumulée de SKOS et du DublinCore est donc une solution assez intéressante pour la description de ressources bibliographiques. C'est pourquoi, si nous reprenons l'exemple de la bibliothèque du Congrès, nous remarquons qu'elle utilise ces deux schémas dans sa définition de Web sémantique

2000-04-28T00:00:00-04:00


2001-10-01T09:56:06-04:00

L'objet “web sémantique” est donc ici définit en RDF, associé aux autres objets de la terminologie du thesaurus de la LSCH par le SKOS et l'ensemble de cette définition est elle-même associée à des métadonnées présentées en DublinCore.

FOAF

Friend-of-a-Friend est un modèle de structuration des données sur les personnes dont les spécifications se retrouvent sur cette page. Il permet de structurer des données sur les individus, de les partager et surtout de faire des liens entre ces données. À l'heure du web social son intérêt est donc croissant.
Un exemple est présenté ci-dessous :

  
  
  
  


Marina Soler
Melle
Marina
Soler
Mumasiquery
8778033c8713243356fa6190ca32673658e10c78

Des descriptions FOAF sont en ligne. Pour les trouver, une recherche de type “foaf.rdf” permet d'accéder à des exemples assez bien fournis. Nous pouvons à nouveau remarquer sur ces pages l'utilisation récurrente du Dublin Core et autres vocabulaires de description (par exemple).

Conclusion

En conclusion nous pouvons confirmer que le monde des ontologies informatiques présente deux problématiques interdépendantes : la forme et le fond, la logique structurelle et informationnelle. l'objectif étant, sur un domaine général ou spécifique, pouvoir établir des relations de manière automatisée entre deux éléments du réel.
Le modèle des triplets RDF structure la manière de voir et de décrire le monde ; les vocabulaires l'appliquant font s'entremêler les idées, les faits et les objets à l'aide de propriétés plus ou moins complexifiés. À partir des différents exemples, nous nous apercevons qu'une multitude d'idées, de faits ou encore d'objets peut être décrite et structurée dans une ontologie informatique ; et selon si elle se place dans domaine spécifique, un vocabulaire spécialisé et adapté peut exister.

—–

sources non citées dans l'article

• Word Wide Web Consotium, W3C Consulté le 24 juin 2011.
• Xavier Laclot, Introduction à OWL, un langage XML d'ontologies Web. 2005
• Wikipédia RDF. Consulté le 21 juin 2011
• Wikipédia OWLConsulté le 21 juin 2011
• Wikipédia RDFS. http://fr.wikipedia.org/wiki/RDFS. Consulté le 21 juin 2011

Dans ce billet nous allons utiliser un cas client pour illustrer la démarche et présenter les outils que nous avons utilisé.

Le cadre du projet est l’amélioration de l’agent conversationnel (ou bot) développé par un client. Parmis les différents points, il y a celui d’améliorer sa capacité à reconnaître et classer les messages de type “interaction sociale”. Voici un exemple d’interactions sociales simples :

• “Bonjour” / “Hello” (catégorisation de l’interaction sociale: OUVERTURE)
• “A bientôt” / “Au revoir” / “Bye” (FERMETURE)
• “Comment vas tu?” / “Comment ça va?” (SANTE)
• “T’es trop nul” (DESAPPROBATION)
• …

Nous avons notamment en charge le développement d’un composant qui reçoit en entrée une phrase et qui fournit en sortie une liste de catégories (si le message est bien une interaction sociale). Le format de sortie est une liste d’objets de type SocialInteraction :

Le composant doit gérer les messages comportant plusieurs catégories (Ex: “Salut, comment ça va?” = OUVERTURE + SANTE) et attribuer un score (représentant une probabilité) pour chaque catégorie.

Voila pour le contexte.

Besoins

1. Constituer un jeu représentatif AVEC le client (corpus de test). Cela implique de pouvoir stocker des messages et la sortie attendue
2. Mettre au point un indicateur précis et conforme à notre perception des résultats pour chaque composant*.
3. Lancer l’exécution du composant de catégorisation sur tout le corpus de test et calculer pour chaque exécution notre indicateur.
4. Produire un rapport proposant plusieurs niveaux de lecture : une synthèse (agrégation de tous les scores) et le détail de chaque exécution.
5. Automatiser au maximum l’évaluation et la production des rapports (point 3 et 4).

*L’ensemble du projet comporte une dizaine de composants à évaluer

À partir des points 3., 4. et 5. on pense rapidement aux tests unitaires, JUnit et la génération de rapports HTML … Seulement, pour l’avoir employé dans un précédent projet à des fin d’évaluation, il s’avère encore complexe d’utiliser JUnit dans le cadre d’exécution suivant :

Ecrire 1 test qui s’exécutera N fois avec des données différentes

TestNG : le framework de tests next generation

TestNG est un framework de tests sembable à JUnit, qui est né pour palier à certaines limites de ce dernier. Parmis les fonctionnalités intéressantes de TestNG, nous avons trouvé :

• Possibilité d’organiser les tests en groupes et de leur donner un nom “lisible” (autre que le nom de la méthode). Ex: “Catégorisation sociale”
• Possibilité d’employer des méthodes avec paramètres
• l’annotation @DataProvider qui permet de créer très facilement des composants qui vont “alimenter” les tests en données d’entrée.
• La fourniture d’une API pour la création de rapports (nous détaillerons dans la partie reporting)
• Intégré à Maven, soit via le plugin par défaut (maven-surefire-plugin) ou soit via le maven-antrun-plugin (requérant la création d’un petit script Ant pour lancer TestNG)
• très bien intégré à Eclipse via un excellent plug-in

Avec toutes ces fonctionnalités nous possédons presque l’outillage nécessaire pour réaliser l’évaluation de notre composant de classification.

Gestion de l’indicateur

F-Mesure

Nous avons choisi la formule F-Mesure car elle reflète bien l’écart entre le résultat produit et le résultat attendu en intégrant les notions de précision (P) et rappel (R).

Le résultat est un nombre entre 0 et 1, résultat qu’il est donc facile de convertir un pourcentages.

Intégration de la F-Mesure dans les tests TestNG

Bien qu’étant souple et extensible, TestNG est un framework de tests unitaires. A l’instar de JUnit il fonctionne avec des Assertions. Or une assertion est soit vraie, soit fausse. Mais ne peut en aucun cas être à 50% vraie…

L’astuce que nous employons est de considérer qu’une F-Mesure < à 1 fait échouer l’assertion évaluant l’égalité entre le résultat attendu et le résultat produit, et surcharger le modèle java des AssertionError pour pouvoir enregistrer notre score afin de l’afficher dans le rapport :

package evaluator;

/**
* An assertion error that hold a score
* @author tvibes
*/
public class AssertionScoreError extends AssertionError {

	private double score = 0.0;

	public AssertionScoreError(Object detailMessage, double score) {
		super("" +  detailMessage);
		if (detailMessage instanceof Throwable)
			initCause((Throwable) detailMessage);

		this.score = score;
	}

	public double getScore() { return this.score; }
}

Il ne reste qu’a créer une méthode assertScore() qui va nous permettre de lever nos AssertionScoreError :

package evaluator;

/**
 * @author tvibes
 */
public class ExtendedAssert {

	public static void fail(double score){
		fail(null, score);
	}
	public static void fail(String message, double score){
		throw new AssertionScoreError(message == null ? "" : message, score);
	}
	static public void assertScore(String message, double score){
		if(score<1)
			fail(message, score);
	}
}

Les méthodes @DataProvider : “alimenter” nos méthodes de tests en données.

Plus simple à manipuler que l’équivalent JUnit @Parameters, c’est véritablement la fonctionnalité qu’il nous fallait pour pouvoir jouer notre test de composant sur un corpus de test. Le Data Provider est une méthode statique qui doit retourner Object[][] (voir documentation)

package evaluator.unit.testng;

import static evaluator.ExtendedAssert.assertScore;

import java.util.ArrayList;
import java.util.List;
import org.testng.annotations.Test;
import evaluator.dataproviders.SocialDataProvider;
import evaluator.scoring.IScoringService;
import ac.search.SocialSearcher;
import ac.output.SocialInteraction;

/**
* @author tvibes
*/
@Test(suiteName="Tests unitaires", testName="Classification")
public class ClassificationTest {

	IScoringService<List<SocialInteraction>> scoringService = null;

	public ClassificationTest(){
		scoringService = new evaluator.scoring.FMeasureSocialInteractionService();
	}

	/**
	* Test method for "message classification"
	* @param testMessage
	*         A test message
	* @param classes
	*         A list with the expected business objects (SocialInteraction)
	*/
	@Test(dataProvider="createSocialMessage")
	public void testClassificationNG(String testMessage, List<SocialInteraction> classes){
		SocialSearcher searcher = new SocialSearcher();
		List<SocialInteraction> current = searcher.getSocialResults(testMessage);
		double score = scoringService.calculate(current, classes);
		assertScore("Résultat: " + current.toString(), score);
	}

	@DataProvider(name="createSocialMessage")
	public static Object[][] createSocialMessage(){
		Object[][] corpus = new Object[][]{
			{"Bonjour", new SocialInteraction(SocialInteraction.OUVERTURE, 100)},
			{"Au revoir", new SocialInteraction(SocialInteraction.FERMETURE, 100)},
		};
	}
}

Dans cet exemple, la méthode data provider fourni un corpus contenant 2 phrases avec le résultat attendu.
Il est possible d’externaliser la méthode dans une classe “dédiée” grâce à l’attribut dataProviderClass de l’annotation @Test. Pour notre projet, cette classe dédiée charge un corpus de tests (280 messages) depuis une base de données et TestNG appelle la méthode testClassificationNG autant de fois que nécessaire.
Nous avons développé un service qui calcule le score (à l’aide de la formule F-Mesure) que l’on invoque ici.
Notre méthode spécifique assertScore() permet donc de lever une AssertionScoreError si le score est < à 1 (on est jamais trop exigeant ).

Gestion des corpus de tests

Pour des questions pratiques, nous stockons le corpus de test dans une base de données dont voici le modèle physique :

Modèle physique pour le stockage du corpus de test

La table DATA est la plus importante : c’est elle qui contient les verbatims ainsi que les résultats attendus. Les résultats attendus (colonne expected) sont des objets que le module TAL est censés produire.

Pour l’accès au corpus de tests, nous ajoutons quelques librairies bien utiles :

• Xstream : Librairie permettant de sérialiser un objet au format XML. Ainsi nous stockons n’importe quel objet dans notre table DATA, et le XML est plus souple que le binaire.
• simple-jndi : Conteneur JNDI léger (42 Ko) et idéal pour les tests car il ne tire aucune dépendance et ne nécessite aucune ligne de code pour charger le conteneur et une DataSource
• jTDS : Connecteur JDBC open-source pour Microsoft SQL Server (Le SGBDR étant imposé par le client pour le projet global nous avons conservé ce système pour notre base de corpus de tests)

Reporting

ReportNG

Un des points noirs pour notre projet dans les briques rassemblées jusqu’ici est la génération de rapport par TestNG : les rapports sont vraiment moches (J’espère que Cédric Beust me pardonnera, si un jour il lit ce billet). Heureusement, l’extensibilité du framework (existence d’une API de reporting) a fait que des développeurs ont mis au point des modules de génération de rapports beaucoup plus esthétiques. C’est le cas de Dan Dyer qui propose le plug-in ReportNG

ReportNG est disponible dans le repository Maven ou sur Github.

A la base ReportNG prévoit la possibilité de surcharger la feuille de style. C’est bien, mais insuffisant pour nous : Nous avons besoin de modifier les pages pour y faire apparaître nos indicateurs. ReportNG utilise le moteur de template Velocity.

• les +: Je n’avais jamais utilisé Velocity, mais il s’avère être un excellent choix car il est vraiment simple à appréhender. Par ailleurs, il convient bien avec le modèle d’objets de TestNG.
• les -: ReportNG embarque ses templates dans le Jar et ne prévoit pas de moyen de sépcifier d’autres templates. De plus, la classe chargée de la génération du rapport (classe HTMLReporter qui implémente org.testng.IReporter) défini tous ces attributs et méthodes en private ce qui rend plus difficile la surcharge.

Exemple de rapport - l'évaluation de nombreux composants est présentée

Grâce à quelques helpers que nous déclarons dans le contexte Velocity, nous pouvons mettre en forme notre rapport de synthèse qui agrège les scores de l’ensemble des tests. Les différents résultats sont “colorés” de manière à identifier rapidement les séries de tests qui donnent de bons résultats ou ceux qui en donnent de mauvais et sur lesquels nous allons devoir travailler! (exemple: vert = score > à 80%; rouge sombre = score < à 20%)

maven-site-plugin

Ce plug-in pour Maven permet d’ajouter des pages de documentation ou d’analyse à nos rapports. Je ne vais pas détailler cette partie, la documentation du plug-in permet de rapidement comprendre comment générer un “maven site” et y intégrer les rapports produits par ReportNG.

Conclusion

Dans notre précédent billet, nous tentions de démontrer à quel point l’évaluation continue des résultats est importante dans un projet R&D.

Avec TestNG, nous disposons de l’outil permettant de concrétiser cette démarche d’évaluation sans avoir passé trop de temps sur la mise au point. Il s’intègre bien à Maven et nous pourrions aller jusqu’à déclencher l’évaluation à chaque commit dans les composants de traitement, sur notre serveur Hudson et regénérer les rapports.

Par ailleurs, cet ensemble pourra être réutilisé dans nos autres projets. Il ne nous suffira plus que :

• de constituer les corpus de tests
• coder que les services d’évaluation.