Blog d'un jeune (chercheur) entrepreneur en TAL - Sciences & Recherche

Web2Day 2013 : données et analyse prédictive

Fabien Poulard — Sun, 05 May 2013 13:13:00 +0200

Les 16 et 17 mai prochains se déroulera la 5ème édition du web2day, le festival du numérique dédié à lʼinnovation et au Web. L'évènement est organisé par lʼassociation Atlantic 2.0, le réseau des acteurs du Web et de lʼinnovation numérique en Pays de la Loire, et prendra place à Stereolux, sur lʼîle de Nantes, pour la deuxième année consécutive.

Lors de cette édition j'aurai l'immense plaisir d'animer la partie du thème sur l'enjeux des données dédiée à l'analyse prédictive, ou «Comment peut-on utiliser les données du moment pour prédire les données à venir ?». L'autre partie du thème sur l'opportunité économique des données est gérée par Claire de Libertic, ultime experte de l'open data.

Personnellement, je suis convaincu que les données sont le pétrole de demain. Nous travaillons d'ailleurs, à Dictanova, sur des systèmes d'extractions et des raffineries dédiées à ces nouveaux composés numériques. Leur exploitation en masse offre des perspectives de nouveaux usages dont nous n'entrevoyons qu'une infime partie. Encore faut-il être en mesure d'aller puiser ces données au sein des entreprises ou sur le Web, de les nettoyer, les structurer, les consolider et enfin les exploiter.

L'une des facettes les plus impressionnantes de l'exploitation massive des données est celle des modèles prédictifs. Ces systèmes sont en plein boom ! Sur Amazon ils vous invitent à consulter des articles qui peuvent vous intéresser. Sur Last.fm et Netflix ils vous recommandent les prochaines œuvres musicales ou cinématographiques à consulter. Sur vos téléphones portables ils anticipent le contenu du message que vous êtes en train de rédiger. Pour l'opération Miss Tweet (détail de l'analyse), nous les avons mis en œuvre pour prédire l'issue de l'élection de Miss France... et demain ?

Et bien justement, nous en parlerons vendredi 17 Mai 2013 lors de la 5e édition du Web2Day, avec au menu :

J'espère que vous viendrez nombreux pour échanger avec nous !

Travaux Pratique TALN - Contexte syntaxique

Fabien Poulard — Mon, 21 Nov 2011 23:42:00 +0100

Les séances précédentes ont été consacrées à l'analyse lexicale et morphologique. Il est temps de se détacher de la dimension lexicale des textes pour tendre vers la dimension syntaxique.

Les rôles grammaticaux

Tous les mots n'ont pas la même fonction dans la phrase, chaque mot a un rôle grammatical propre qui indique la façon dont il participe à la construction du sens. Ainsi les déterminants (le, la, les, ...) ne jouent pas un rôle aussi crucial que les noms communs ("champion", "médaille", "concours", ...). Ils font parti de l'outillage grammatical qui permet de faire collaborer les mots afin de produire du sens.

Dans le cadre de cette séance de TP, je propose de travailler sur les catégories grammaticales suivantes :

l'article, le déterminant : le, la, les, l', un, une, des, ...
le nom : médaille, champion, podium, éléphant, ...
l'adjectif : grande, téméraire, puissant, ordonnée, ...
le pronom : je, me, moi, se, ...
le verbe : manger, courir, être, penser, ...
l'adverbe : lentement, doucement, rapidement, ...
la préposition : à, en, sur, sous, sans, avec, ...
la conjonction : mais, ou, et, donc, ...

Les mots de chacune de ces catégories ont une fonction propre dans la phrase : qualifier le nom, faire référence à une personne ou un objet, décrire l'action ou l'état, coordonner des propositions... Si vous voulez en savoir plus, vous pouvez aller lire ceci.

Il est possible de lister de manière exhaustive (ou suffisamment exhaustive) les mots de certaines catégories grammaticales : les déterminants, les pronoms, les conjonctions et dans une certaine mesure les prépositions. Toutefois, il est très difficile de lister les noms, les verbes, les adjectifs ou encore les adverbes ; et ce pour deux raisons : les mots pouvant prendre ces rôles sont très nombreux et il est possible d'en générer une quasi-infinité de nouveaux, par composition notamment.

Lister les mots des catégories déterminant, pronom, conjonction et préposition

Même si l'ont peut donner une liste quasi-exhaustive des mots qui appartiennent aux catégories grammaticales déterminant, pronom, conjonction et préposition ; il peut être difficile de réaliser ces listes de tête.

Encore une fois, le corpus peut-être d'un grand secours. En effet, du fait de la combinaison de leur nombre réduit (par comparaison aux noms et verbes par exemple) et de leur rôle primordial dans la phrase, ces mots sont sont parmi les mots les plus fréquents. Un simple comptage d'occurrence permet donc d'en découvrir un certain nombre :

import codecs
# Chargement du corpus prétraité (découpé en mots)
fh = codecs.open("Discours-Sarkozy-v20111025.preproc.txt", "r", "utf-8")
words   = fh.read().split()
fh.close()
# Comptage des mots
from nltk import FreqDist
fd = FreqDist()
for w in words:
	fd.inc(w.lower())
# Affichage du Top 50 avec leur nombre d'occurrence
fd.items()[:50]
 
[(u',', 111161), (u'de', 83656), (u'.', 76146), (u'la', 57608), 
(u"l'", 41454), (u'et', 38519), (u'le', 37246), (u'les', 35018),
(u'que', 33457), (u'\xe0', 31767), (u'est', 29416), (u'des', 27233),
(u"d'", 26458), (u'je', 21483), (u'qui', 21432), (u'en', 21317),
(u'pas', 20128), (u'un', 19782), (u'pour', 18374), (u'il', 17286),
(u'une', 16512), (u'nous', 16031), (u"c'", 15082), (u'a', 14891),
(u'dans', 13862), (u'on', 13849), (u'vous', 13799), (u'du', 13605),
(u'ne', 13502), (u'ce', 13231), (u"qu'", 12629), (u"n'", 12400),
(u'au', 9723), (u'plus', 9494), (u'y', 7980), (u'sur', 7845), 
(u'france', 7687), (u'mais', 7638), (u'avec', 6869), (u':', 6556),
(u"j'", 6408), (u'se', 5870), (u"s'", 5809), (u'sont', 5791), 
(u'par', 5724), (u'cela', 5536), (u'cette', 5430), (u'ont', 5230),
(u'aux', 5145), (u'si', 5009)]

Cette approche combinée à notre connaissance de la grammaire française nous permet de constituer assez rapidement la liste des mots de chacune des catégories déterminant, pronom, conjonction et préposition.

Cette approche n'est toutefois pas satisfaisant pour les "puristes", notamment car le corpus est loin d'être représentatif de la langue mais également car nous nous limitons ici aux mots et négligeons les locutions.

Voici néanmoins une proposition de liste construite de cette manière :

# Proposition de liste non exhaustive de mots pour les rôles grammaticaux
# déterminants, pronoms, conjonctions et prépositions
dico = {
	# ARTICLES / DETERMINANTS
	"DET": ["le", "la", "les", "l'", "un", "une", "des", "d'",
		"du", "de", "au", "aux", "ce", "cet", "cette", "ces",
		"mon", "son", "ma", "ta", "sa", "mes", "ses",
		"notre", "votre", "leur", "nos", "vos", "leurs",
		"aucun", "aucune", "aucuns", 
		"tel", "telle", "tels", "telles",
		"tout", "toute", "tous", "toutes",
		"chaque"],
	# PRONOM
	"PRO": ["je", "tu", "il", "elle", "on", "nous", "vous", "ils", "elles",
		"me", "m'", "moi", "te", "t'", "toi",
		"se", "y", "le", "lui", "soi", "leur", "eux", "lui",
		"qui", "que", "quoi", "dont" "où"],
	# CONJONCTION
	"CONJ": ["mais", "ou", "et", "donc", "or", "ni", "car",
		"que", "quand", "comme", "si",
		"lorsque", "quoique", "puisque"],
	# PREPOSITION
	"PREP": ["à", "derrière", "malgré", "sauf",
		"selon", "avant", "devant", "sous", "avec", 
		"en", "par", "sur", "entre", "parmi", 
		"envers", "pendant", "vers", "dans", "pour", "de", 
		"près", "depuis", "sans"]
}

Le contexte syntaxique en renfort

Les différents mots extraits précédemment vont nous être utiles pour capturer les mots des autres catégories.

Nous allons fouiller le contexte des mots listés précédemment afin d'identifier des règles qui nous permettraient de trouver automatiquement les catégories grammaticales des autres mots. Pour ce faire nous allons utiliser un outil bien connu des linguistes : le concordancier.

Nltk fournit un concordancier qui est certes un peu limité mais bien suffisant pour notre étude :

t = nltk.Text(words, name="discours_sarkozy")
t.concordance("je", width=50, lines=10)

ce qui nous donne le résultat :

Displaying 10 of 21483 matches:
re avec vous ce matin . Je sais qu' il y a plus de
onsulat dans le monde . Je salue tous ces Français
 , c' est sympathique ! Je suis donc venu vous voi
France-Syrie du Sénat . Je suis également venu ave
la Syrie et la France . Je n' oublie pas Bernard B
des parents d' élèves . Je voudrais vous féliciter
État sera à vos côtés . Je trouve cela formidable 
aissera pas tomber . Et je trouve que c' est merve
nt engagés à ce point . Je veux saluer également l
nsi que les autorités . Je salue ici la présence

L'utilisation du concordancier nous permet de lister un certain nombre de règles qui semblent généralisables :

le "or" en début de phrase est une conjonction alors que le "or" précédé d'un déterminant est un nom ;
les déterminants semblent précéder des noms ;
les pronoms sont en général suivis d'un verbe ou d'un autre pronom
les adjectifs sont en général précédés d'un verbe ou d'un nom
...

Outre ces quelques règles auxquelles il est très certainement possible de trouver des contre-exemples, on peut surtout noter que les mots ne s'acoquinent pas avec n'importe qui. Chaque mot a des accointances privilégiées avec certaines catégories grammaticales (le déterminant avec le nom par exemple, ...). En d'autres termes, il semble exister une structure syntaxique propre à la langue... sa compréhension nous permettrait de faire un pas de plus dans la compréhension du langage par la machine.

Algorithme de Brill

Intuition

Prenons une phrase du corpus :

[u'Je', u'sais', u"qu'", u'il', u'y', u'a', u'plus',
 u'de', u'3 000', u'Fran\xe7ais', u'en', u'Syrie', u',', 
 u'\xe0', u'Damas', u',', u'\xe0', u'Alep', u',', u'o\xf9', 
 u'nous', u'avons', u'notre', u'plus', u'ancien', u'consulat', 
 u'dans', u'le', u'monde', u'.']

Un certain nombre des mots qui composent cette phrase sont connus car ils appartiennent aux catégories grammaticales déterminant, pronom, préposition ou conjonction. C'est le cas notamment de Je, qu', il, y, de, en, à, à, où, nous, notre, dans et le. L'idée est donc d'affecter à ces mots leur étiquette la plus probable et aux autres l'étiquette ?, soit :

[('Je', 'PRO'), ('sais', '?'), ("qu'", 'PRO'), ('il', 'PRO'),
 ('y', 'PRO'),  ('a', '?'), ('plus', '?'), ('de', 'PREP'), 
 ('3 000', '?'), ('Fran\xe7ais', '?'), ('en', 'PREP'), 
 ('Syrie', '?'), (',', 'PUN'), ('\xe0', 'PREP'), ('Damas', '?'), 
 (',', 'PUN'), ('\xe0', 'PREP'), ('Alep', '?'), (',', 'PUN') , 
 ('o\xf9', 'PREP'), ('nous', 'PRO'), ('avons', '?'), 
 ('notre', 'DET'), ('plus', '?'), ('ancien', '?'), ('consulat', '?'), 
 ('dans', 'PREP'), ('le', 'DET'), ('monde', '?'), ('.', 'PUN')]

L'application de règles simples naïves telles que :

Un pronom est suivi d'un pronom ou d'un verbe ;
Un déterminant est suivi d'un adjectif ou d'un nom ;
Une préposition est suivie d'un nom propre, d'un pronom ou d'un déterminant ;
Un adjectif est suivi d'un adjectif, d'un nom ou d'une ponctuation ;
...

permettent de deviner les catégories grammaticales qui peuvent s'appliquer aux mots inconnus de nos dictionnaires. Nous pourrons ensuite compléter notre dictionnaire de ces nouveaux et ainsi enrichir notre connaissance itérativement.

C'est grosso modo le concept de l'algorithme de Brill...

Fonctionnement

L'algorithme de Brill parcourt les mots du texte. Si la forme textuelle est présente dans son dictionnaire, il lui associe la catégorie grammaticale la plus probable, c-à-d celle la plus communément rencontrée pour ce mot. Lorsque la forme textuelle n'est pas présente dans le dictionnaire, il lui associe l'étiquette NOM ou NOM PROPRE si elle commence par une majuscule. Une fois cette première passe opérée, l'algorithme applique des règles de transformation des étiquettes telles que vues précédemment.

On dit que l'algorithme est guidé par l'erreur (error-driven) car il fait appel à de l'apprentissage supervisé (sélection des règles).

Pour en savoir plus, vous pouvez lire cet article écrit par Brill lui-même.

Brill dans nltk

Nltk intègre une implémentation de l'algorithme de Brill, ainsi que l'outillage nécessaire à l'entraînement d'un nouvel étiqueteur.

Travaux Pratique TALN - Morphologie et contexte syntaxique

Fabien Poulard — Mon, 14 Nov 2011 18:55:00 +0100

Dans le TP précédent nous nous sommes limité à l'analyse des mots en-dehors de tout contexte. Il s'est alors agi de découper un texte en mots puis de compter ces derniers.

Dans ce second TP, nous allons nous intéresser à la morphologie des mots (leur forme textuelle). Nous explorerons notamment deux procédés de normalisation morphologique : la racinisation et la lemmatisation. Nous découvrirons ensuite que le contexte des mots, combiné à leur morphologie, peut nous apprendre bien des choses.

Je considère comme acquis le découpage en phrases et en mots (si ce n'est pas le cas, vous pouvez vous rafraîchir la mémoire ici). Nous allons dans cette partie directement travailler sur une version du corpus des discours de N. Sarkozy déjà découpée en phrases et en mots.

La fonction ci-dessous permet de charger la liste des phrases du corpus et pour chaque phrase la liste des mots qui la compose :

def load_preprocessed_corpus(finput="Discours-Sarkozy-v20111025.preproc.txt"):
	"""
	Load the content of a preprocessed file as a list of sentences which happen
	to be a list of words.
	"""
	fh = codecs.open(finput, "r", "utf-8")
	corpus = fh.read()
	fh.close()
	sents = []
	for sent in corpus.split("\n"):
		sents.append( sent.split() )
	return sents

Exemple d'utilisation :

>>> sentences = load_preprocessed_corpus("Discours-Sarkozy-v20111025.preproc.txt")
>>> "Nombre de phrases  : %d" % len(sentences)
'Nombre de phrases  : 84325'
>>> "Nombre de mots : %d" % len([w for s in sentences for w in s])
'Nombre de mots : 2017309'

Morphologie : des expressions rationnelles à l'algorithme de Porter

Nous allons avoir besoin d'un outil puissant pour exprimer par intention les formes textuelles que nous allons manipuler : les expressions rationnelles. Celles-ci permettent de décrire un langage régulier pour lequel il sera possible de générer un automate acceptant. La plupart des langages informatiques récents offrent des bibliothèques permettant de manipuler ces expressions et les automates en découlant. Python ne fait pas exception à la règle.

Les expressions rationnelles sont gérés sous Python par le module re. Il serait trop long de présenter l'utilisation des expressions rationnelles avec Python ici, et d'autres le font beaucoup mieux que moi.

France, Français, Française, Françaises...

Le nuage de mots généré précédemment contient des mots très similaires, c'est le cas notamment de français et française. Les expressions rationnelles peuvent nous permettre de les considérer ensemble :

>>> import re
>>> len(re.findall(u"\\bfrançais\\b", text))
1031
>>> len(re.findall(u"\\bfrançaise\\b", text))
1286
>>> len(re.findall(u"\\bfran[cç]ais\\w\\b", text))
2661
>>> tous_francais = set()
>>> for m in re.finditer(u"\\bfran[cç]ais\\w*\\b", text):
...     tous_francais.add( m.group(0) )
>>> tous_francais
set([u'fran\xe7aise', u'fran\xe7ais', u'fran\xe7aises'])

Généralisation : vers l'algorithme de Porter

L'exemple précédent nous montre que nous pourrions profiter d'une normalisation morphologique des mots collectés afin de rendre mieux compte de la distribution lexicale. Après tout français, française et françaises correspondent tous trois au même mot français tel qu'on le trouve dans le dictionnaire.

En effet, française et françaises sont des flexions de l'adjectif français. En linguistique, on oppose flexions et dérivations :

La flexion consiste à ajouter un affixe au mot afin de refléter un changement au niveau grammatical, du genre, du nombre, de la personne, etc., sans que cette modification morphologique n'altère le sens du lexème d'origine ;
La dérivation consiste à créer un nouveau lexème, c-à-d un nouveau mot avec un nouveau sens, par l'ajout d'un affixe.

Les règles flexionnelles en français semblent assez régulières : ajout d'un "e" pour marquer le féminin, d'un "s" pour le pluriel... Ne pourrait-on pas définir un algorithme capable de déconstruire ces flexions afin de retrouver le lexème d'origine, au masculin singulier ?

Petit exercice :

Tentez de produire une liste exhaustive des suffixes utilisés pour marquer le genre et le nombre en français
Recherchez toutes les formes textuelles qui utilisent ces suffixes

Proposition de corrigé :

all_words = set([w.lower() for w in words])
 
def evaluation_suffix(suffix):
	global raw_text
	regexp = re.compile(r"\b(\w+)%s\b"%suffix, re.I|re.U)
	map = {}
	# Collecter les mots avec le suffixe
	for m in regexp.finditer(raw_text):
		avec_suffixe = m.group(0)
		sans_suffixe = m.group(1)
		if not map.has_key(avec_suffixe):
			map[avec_suffixe] = {
				"sans_suffixe": sans_suffixe,
				"sans_suffixe_existe": False}
	# Chercher les occurrences sans suffixe
	for k in map.keys():
		sans_suffixe = map[k]["sans_suffixe"].lower()
		map[k]["sans_suffixe_existe"] = (sans_suffixe in all_words)
	# Rapport
	nb_est_suffixe = len([k for k in map.keys() if map[k]["sans_suffixe_existe"]])
	nb_est_pas_suffixe = len(map) - nb_est_suffixe
	if nb_est_suffixe > nb_est_pas_suffixe:
		print "%s est un suffixe (%d/%d)" % (suffix, nb_est_suffixe, nb_est_pas_suffixe)
	else:
		print "%s n'est PAS un suffixe (%d/%d)" % (suffix, nb_est_suffixe, nb_est_pas_suffixe)
 
suffixes = ["ous", "aux", "s", "e", "ais", "ives", "ent", "es", "ai", "ons", "ez", "t", "ait", "ions", "iez", "aient", "ant", "le", "les", "ne", "nes", "x"]
 
for suffix in suffixes:
	evaluation_suffix(suffix)

Algorithme de Porter

L'algorithme de Porter offre un cadre algorithmique pour la désuffixation des mots. Le fonctionnement de l'algorithme est décrit en de nombreux endroits sur le Web, notamment ici ou sur mon propre blog. S'il a été mis au point pour l'anglais, il est tout à fait envisageable de l'utiliser pour le français (d'ailleurs certains l'ont fait).

L'idée de l'algorithme de Porter est de déconstruire les flexions pour retrouver la forme canonique des mots : le lemme. Par exemple : retirer le suffixe "aux" de chevaux et le remplacer par "al" pour obtenir le singulier. Les règles de Porter sont déclenchées lorsque deux conditions sont réunies :

le mot se termine par un suffixe particulier
le radical (mot privé dudit suffixe) respecte un motif particulier, le plus généralement un certain nombre de pseudo-syllabes

Le code python ci-dessous est une proposition d'implémentation de la règle de Porter pour normaliser journaux et chevaux en respectivement journal et cheval :

def compute_m(w):
     pseudosyllabs = ""
     for c in w:
             if c in ['a', 'e', 'i', 'o', 'u', 'y']:
                     if len(pseudosyllabs)==0 or pseudosyllabs[-1]=="C":
                             pseudosyllabs += "V"
             else:
                     if len(pseudosyllabs)==0 or pseudosyllabs[-1]=="V":
                             pseudosyllabs += "C"
     return pseudosyllabs.count("VC")
 
# Règle de Porter : (m=1 && *c) aux -> al
# Le mot se termine par aux, a un radical composé d'une pseudo-syllabe et qui se termine par une consomne
def regle_porter_aux(w):
     if w.endswith("aux"):
          radical = w[:-3]
          if not radical[-1] in ['a', 'e', 'i', 'o', 'u', 'y']:
               return radical + "al"
     return w
 
>>> regle_porter_aux("journaux")
'journal'
>>> regle_porter_aux("chevaux")
'cheval'
>>> regle_porter_aux("agneaux")
'agneaux'

Petit exercice :

Écrire d'autres règles pour le français dans le formalisme proposé par Porter
À partir du travail de compilation des formes flexionnelles du français par B. Sagot, pouvez-vous inférer automatiquement toutes les règles de Porter pour le français ?

Travaux Pratique TALN - Le lexique

Fabien Poulard — Mon, 24 Oct 2011 22:38:00 +0200

Malgré notre projet de création d'entreprise, je tenais à continuer à enseigner le TALN à l'Université. Outre l'intérêt pragmatique du chef d'entreprise qui souhaite ainsi repérer les éléments prometteurs à recruter, l'enseignement est une des meilleures manières de prendre du recul sur un domaine.

Cette année je compte mettre de côté UIMA pour me concentrer sur l'expérimentation. J'ai donc décidé de me tourner vers Python, mon langage de cœur, et les bibliothèques NLTK et scikit-learn.

Pour ce premier TP, je compte faire réfléchir les étudiants sur l'analyse lexicale : découpage d'un texte en mots, calculer une distribution sur un document, puis un corpus, filtrer les mots qui participent peu à l'expression du sens et visualiser un texte à partir de son lexique.

Constitution du corpus

Si la construction du corpus est toujours primordiale, celle-ci revêt un enjeu d'autant plus stratégique en enseignement que le corpus peut captiver ou repousser les étudiants.

J'ai un temps été tenté par les messages de condoléances laissés par les fans d'Apple à l'occasion de la mort de Steve Jobs. Neil Kodner a réalisé une superbe analyse sur le sujet. Toutefois, je préfère faire travailler mes étudiants sur le français qui a des propriétés particulières qu'on ne retrouve pas en anglais, notamment sa forte flexionnalité.

À l'occasion du lancement par Google d'un concours de visualisation de données sur la thématique des élections présidentielles 2012, je me suis une nouvelle fois tourné vers les discours politiques. Ceux-ci sont souvent chargés de symboles qui s'expriment souvent par le lexique, d'où l'intérêt de les utiliser dans ce genre d'étude. Bien sûr l'objectif n'est pas de chercher à atteindre la qualité des études menées avec brillo par Jean Véronis, mais simplement se faire la main sur quelques textes contemporains d'intérêts.

Pour la constitution du corpus, je me suis simplement tourné vers le site de l'Élysée. J'avais commencé à collecter les différents discours de notre président, mais une mise-à-jour du site (fortement inspiré du site de la Maison Blanche) m'avait coupé dans mon élan. Le point positif est que ce nouveau site met l'accent sur l'accessibilité. J'ai écrit un petit script Python qui permet d'aller récupérer tous les discours. Il est un peu simpliste et ramène donc un peu de bruit, mais suffisamment peu pour que le résultat soit exploitable :

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Scrap the speeches from M. President Sarkozy :)
 
import sys
import codecs
import urllib2
from BeautifulSoup import BeautifulSoup
 
for did in range(12300):
	sys.stdout.write("Dealing with page %d..."%did)
	try:
		# Collect the page
		uh    = urllib2.urlopen("http://www.elysee.fr/president/root/bank/print/%d.htm" % did)
		html  = uh.read()
		uh.close()
		# Check it is a discourse (discourse subcategory)
		if html.find("/president/root/core/D00018") >= 0:
			# Extract the text
			soup  = BeautifulSoup(html)
			zone  = soup.body.find("div", id="zonePrincipale")
			texts = [t.strip() for t in zone.findAll(text=True) if len(t.strip())>0]
			# Export it
			fh = codecs.open("%d.txt"%did, "w", "utf-8")
			for t in texts:
				fh.write(t + "\n\n")
			fh.close()
			sys.stdout.write("done\n")
		else:
			sys.stdout.write("ignored\n")
	except Exception:
		sys.stdout.write("error\n")

À l'heure de l'écriture de ce billet, le script permet de collecter 588 discours (ou pages identifiées comme tels) pour un total de 1943116 mots. L'export de l'extraction peut-être téléchargé ici.

Découpage en mots

J'ai déjà discuté plusieurs fois du découpage en mots sur ce blog : avec NLTK ou de manière plus théorique.

Je vois trois façons d'approcher le problème du découpage en mots :

Rechercher les sous-chaînes qui constituent les mots ;
Rechercher les sous-chaînes qui séparent les mots ;
Identifier les frontières entre les mots et les non-mots.

La première approche est celle qui a été auparavant discutée sur ce blog. L'idée générale est qu'un mot (ou plus précisément un lexème) est une séquence continue de lettres ou de chiffres. Les choses se compliquent lorsque l'on considère les cas particuliers : les articles et pronoms contractés (l', d', j', m', ...) ; les composés lexicaux à apostrophe (aujourd'hui, ...) ; les composés lexicaux à traits d'union (arc-en-ciel, peut-être, sauve-qui-peut, ...) ; les valeurs numériques (14 000, 14,18, 30 %, ...) ; les acronymes (ASSEDIC, ASCII, ...) ; les sigles (C-4, c-à-d, i.e., ...) ou encore les unités de mesure (A/m, km/h, ...).

La seconde approche me semble biaisée par nature. Elle fonctionne suffisamment bien pour l'anglais où l'on peut envisager découper un texte en mots en coupant à l'endroit des espaces. Elle est toutefois inefficace pour le français étant donné le nombre de cas où les mots sont séparés par une chaîne vide (présence d'un apostrophe, ponctuation, ...).

La dernière approche serait celle que je mettrais en œuvre si je devais implémenter un algorithme de découpage en mot par apprentissage. L'idée serait alors de classer chaque caractère dans une des catégories : début de mot, fin de mot ou n'appartenant pas à un mot. Je ne connais pas l'état de l'art des techniques de tokenisation automatique, mais une approche par n-grammes caractères devrait assez bien fonctionner. Il faudrait toutefois étudier lequel du contexte gauche ou droit est le plus important (si l'un des deux est plus important que l'autre).

Pour l'exercice nous utiliserons le RegexpTokenizer de nltk avec l'expression régulière suivante (à améliorer éventuellement) :

import re
from nltk.tokenize.regexp import RegexpTokenizer
 
reg_words = r'''(?x)
          aujourd'hui    # exception 1
        | prud'hom\w+ # exception 2
        | \d+(,\d+)?\s*[%€$] # les valeurs
        | \d+                # les nombres
        | \w'                 # les contractions d', l', j', t', s'
        | \w+(-\w+)+    # les mots composés
        | (\d|\w)+         # les combinaisons alphanumériques
        | \w+               # les mots simples
        '''
tokenizer = RegexpTokenizer(reg_words, flags=re.UNICODE|re.IGNORECASE)

L'utilisation du RegexpTokenizer est des plus simple, il suffit d'appeler la méthode tokenize sur un texte pour obtenir en retour la liste des mots extraits dudit texte :

>>> tokenizer.tokenize(text)

[u'Hommage', u'\xe0', u'M', u'Aim\xe9', u'C\xc9SAIRE', u'ALLOCUTION', u'DE', u'M', u'LE', u'PR\xc9SIDENT', u'DE', u'LA', 
u'R\xc9PUBLIQUE', u'FRAN\xc7AISE', u'A\xe9roport', u'de', u'Fort-de-France', u'Martinique', u'Dimanche', u'20', u'Avril', u'2008', u"C'", 
u'est', u'avec', u'une', u'profonde', u'\xe9motion', u'que', u'je', u'viens', u"aujourd'hui", u'rendre', u"l'", u'hommage', u'de', u'la', 
u'Nation', u'\xe0', u'Aim\xe9', u'C\xc9SAIRE', u'qui', u'nous', u'a', u'quitt\xe9s', u'jeudi', u'dernier', u'Ma', u'place', u'ne', u'pouvait', 
u'\xeatre', u"aujourd'hui", u'que', u'sur', u'cette', u'terre', u'de', u'Martinique', u'aux', u'c\xf4t\xe9s', u'de', u'ceux', u'qui', u'sont', 
u'dans', u'la', u'peine', u'Mes', u'premi\xe8res', u'pens\xe9es', u'vont', u'naturellement', u'\xe0', u'la', u'famille', u'endeuill\xe9e', 
u'qu', u'avec', u'les', u'ministres', u'je', u'rencontrerai', u'dans', ...

Distribution des mots

L'objet du découpage en mot est, outre de se confronter à la difficulté bien réelle de la tâche, de mesurer la distribution du lexique dans le corpus des discours. Plus simplement dit, il s'agit de compter le nombre d'occurrences de chacun des mots utilisés. Par mot, j'entends ici lexie (bien sûr ^^), soit la forme textuelle qui fait référence au mot tel qu'on le trouve dans le dictionnaire.

Pour le comptage des mots, il est possible d'utiliser un simple dictionnaire en gérant l'ajout d'une clé pour chaque nouveau mot rencontré. NLTK propose toutefois une classe qui permet de s'affranchir de cette déclaration et de se concentrer uniquement sur le comptage : la classe FreqDist.

from nltk.probability import FreqDist
 
# Comptage des mots à la création
fdist = FreqDist(  tokenizer.tokenize(text)  )
 
# ... ou bien en parcourant la liste
fdist = FreqDist()
for word in  tokenizer.tokenize(text):
     fdist.inc( word.lower() )

En plus d'économiser la déclaration des mots, la classe ordonne automatiquement les mots par fréquence décroissante :

>>> fdist.items()[:30]

[(u'de', 53), (u'la', 36), (u'qui', 23), (u'et', 19), (u"l'", 18), (u'un', 17), (u'\xe0', 14), (u'des', 13),
 (u'que', 13), (u'les', 12), (u'le', 11), (u'a', 10), (u'est', 10), (u'homme', 10), (u'sa', 9),
 (u'aim\xe9', 8), (u'c\xe9saire', 8), (u'je', 8), (u"c'", 7), (u'dans', 7), (u'du', 7), (u'cet', 6),
 (u'france', 6), (u'martinique', 6), (u'nous', 6), (u'ses', 6), (u'avec', 5), (u'ce', 5), (u"d'", 5), (u'martiniquais', 5)]

Filtrage des mots non signifiants

Tous les mots d'un texte ne jouent pas le même rôle : certains participent à la construction du sens (je les appellerai signifiants), d'autres ont un rôle d'assemblage (je les appellerai outils). La catégorisation est volontairement extrêmement grossière. Toute la profondeur de l'analyse lexicale réside précisément dans le juste filtrage des mots qui n'apporte pas de sens dans le contexte de l'énonciation. Comment les sélectionner ?

Une hypothèse simple, mais qui fonctionne assez bien, est de considérer que les mots les plus communs ne participent pas à l'élaboration du sens. L'hypothèse est globalement validé si l'on observe le top 50 des mots du corpus :

>>> fdist.items()[:50]

[(u'de', 101164), (u'la', 67872), (u'le', 48749), (u'et', 42159), (u"l'", 41465), (u'les', 36784), (u'que', 33999),
 (u'\xe0', 31771), (u'des', 30118), (u'est', 30097), (u"d'", 26459), (u'en', 22888), (u'qui', 22072), (u'je', 21717),
 (u'un', 20687), (u'pas', 20162), (u'pour', 19479), (u'du', 18521), (u'il', 17603), (u'une', 17362), (u'a', 16495),
 (u'nous', 16219), (u"c'", 15088), (u'dans', 14612), (u'vous', 14175), (u'on', 13874), (u'ce', 13645), (u'ne', 13540),
 (u'qu', 12816), (u"n'", 12401), (u'au', 11463), (u'plus', 9716), (u'sur', 8973), (u'france', 8316), (u'avec', 8311), (u'y', 8047),
 (u'mais', 7662), (u'pr\xe9sident', 7540), (u"j'", 6409), (u'par', 6384), (u'se', 6252), (u'sous', 6225), (u'r\xe9publique', 6179),
 (u'sont', 5905), (u"s'", 5809), (u'aux', 5673), (u'publi\xe9', 5586), (u'class\xe9', 5576), (u'cette', 5564), (u'cela', 5555)]

Dans les faits, il semble important de conserver des mots tels que france ou république. Au final, il est donc préférable d'opérer la sélection manuellement.

Une première phase de filtrage consiste à supprimer toutes les entrées qui correspondent aux mots outils classiques (déterminants, pronoms, verbes être et avoir, ...). NLTK propose une telle liste de mots :

from nltk.corpus import stopwords
 
for sw in stopwords.words("french"):
     if fdist.has_key(sw):
          fdist.pop(sw)

Il faut ensuite la compléter en observant manuellement, parmi les mots les plus fréquents, ceux qui n'apportent pas d'information sur le contenu d'un discours politique. J'ai déposé une proposition d'anti-dictionnaire composé de 318 mots, encodés en UTF-8, dans l'espace de téléchargement du corpus.

Le top 50 des mots du corpus une fois l'anti-dictionnaire appliqué est beaucoup plus parlant :

>>> fdist.items()[:50]

[(u'france', 8316), (u'pr\xe9sident', 7540), (u'r\xe9publique', 6179), (u'monde', 4083), (u'fran\xe7ais', 3194),
 (u'europe', 3189), (u'travail', 2434), (u'ministre', 2331), (u'\xe9tat', 2175), (u'politique', 2130),
 (u'fran\xe7aise', 1812), (u'question', 1770), (u'crise', 1755), (u'avenir', 1515), (u'entreprises', 1480),
 (u'r\xe9forme', 1430), (u's\xe9curit\xe9', 1424), (u'vie', 1424), (u'besoin', 1420), (u'conseil', 1397),
 (u'international', 1319), (u'emploi', 1318), (u'recherche', 1314), (u'gouvernement', 1308), (u'\xe9conomie', 1253),
 (u'd\xe9veloppement', 1194), (u'etat', 1153), (u'palais', 1136), (u'paris', 1123), (u'droit', 1098),
 (u'histoire', 1079), (u'service', 1074), (u'\xe9conomique', 1054), (u'syst\xe8me', 1046), (u'enfants', 1006),
 (u'jeunes', 1000), (u'afrique', 985), (u'moyens', 954), (u'europ\xe9enne', 950), (u'plan', 941), (u'croissance', 925),
 (u'nationale', 903), (u'amis', 900), (u'loi', 888), (u'ministres', 885), (u'sant\xe9', 885), (u'projet', 873),
 (u'hommes', 842), (u'euros', 833), (u'culture', 829)]

Visualisation

La dernière étape du TP consiste à visualiser les données ainsi collectées. Il existe plusieurs méthodes de visualisation de ce type de données (voir notamment ce billet de Jean Véronis), j'ai choisi la plus simple de toutes : le nuage de mots.

J'utilise l'outil Wordle pour générer mes nuages, et plus particulièrement l'interface avancée qui permet d'indiquer soit même les mots retenus et leur pondération.

J'ai retenu pour le nuage les 500 mots les plus présents dans le corpus. Leur pondération est calculée à partir de leur fréquence multipliée par 10000 :

for w in fdist.keys()[:500]:
     print "%s:%d" % (w, int(fdist.freq(w)*10000))

Le résultat est visible dans la galerie publique de Wordle, ou ci-dessous :

Présentation aux Rendez-vous de la recherche à la Cantine de Nantes

Fabien Poulard — Tue, 05 Apr 2011 20:45:00 +0200

Aujourd'hui, J'ai joué le jeu des Rendez-vous de la Recherche (RdvR pour les intimes) à La Cantine de Nantes. J'y ai présenté mon parcours de jeune chercheur, mon équipe et mon domaine de recherche : le Traitement Automatique des Langues (TAL).

Les Rendez-vous de la Recherche sont organisés par Jean Bézivin et Jean-Pierre Guédon, L'objectif de ces présentations informelles est de faire se rencontrer le monde de la recherche et de l'industrie. Le chercheur présente ses travaux, son équipe et son domaine. Les industriels piochent dans le flot d'information les éléments qui pourraient permettre de résoudre certaines de leurs problématiques et échangent sur ce sujet avec le chercheur. Ceci peut déboucher sur des collaborations, des initiatives...

Le support de ma présentation est disponible sur scribd.

Je soutiens ma thèse !

Fabien Poulard — Thu, 17 Mar 2011 17:00:00 +0100

Je soutiendrai ma thèse le Jeudi 24 mars 2011 à 9h30 dans la salle 3 du LINA.

Non seulement la séance est publique, mais de plus vous êtes tous cordialement invité à y assister. Le contenu est détaillé dans la suite du billet.

Titre de la thèse : Détection de dérivation de texte

Mots-clés : détection de dérivation, révisions, plagiat, approche par signature, mesures de similarité, recherche d'information

Résumé de la thèse :

L'Internet permet la production et la diffusion de contenu sans effort et à grande vitesse. Cela pose la question du contrôle de leur origine. Ce travail s'intéresse à la détection des liens de dérivation entre des textes. Un lien de dérivation unit un texte dérivé et les textes préexistants à partir desquels il a été écrit. Nous nous sommes concentré sur la tâche d'identification des textes dérivés étant donné un texte source, et ce pour différentes formes de dérivation. Notre première contribution consiste en la définition d'un cadre théorique posant les concepts de la dérivation ainsi qu'un modèle mulitidimensionnel cadrant les différentes formes de dérivation. Nous avons ensuite mis en place un cadre expérimental constitué d'une infrastructure logicielle libre, de corpus d'évaluation et d'un protocole expérimental inspiré de la RI. Les corpus Piithie et Wikinews que nous avons développé sont à notre connaissance les seuls corpus en français pour la détection de dérivation. Finalement, nous avons exploré différentes méthodes de détection fondées sur l'approche par signature. Nous avons notamment introduit les notions de singularité et d'invariance afin de guider le choix des descripteurs utilisés pour la modélisation des textes en vue de leur comparaison. Nos résultats montrent que le choix motivé des descripteurs, linguistiques notamment, permet de réduire la taille de la modélisation des textes, et par conséquence des coûts de la méthode, tout en offrant des performances comparables à l'approche état de l'art beaucoup plus volumineuse.

Jury de la thèse :

M. François Yvon, Professeur à l'Université de Paris Sud 11 (rapporteur)
M. Patrice Bellot, Maître de conférences à l'Université d'Avignon (rapporteur)
Mme Josiane Mothe, Professeur à l'Institut Universitaire de Formation des Maître de Toulouse (examinateur)
M. Claude de Loupy, Dirigeant et co-fondateur de Syllabs (invité)
Mme Béatrice Daille, Professeur à l'Université de Nantes (directrice de thèse)
M. Nicolas Hernandez, Maître de conférences à l'Université de Nantes (encadrant)

Publications :

Poulard, F., N. Hernandez and B. Daille. 2011, Detecting derivatives using specific and invariant descriptors, Proceedings of the 12th International Conference on Computational Linguistics and Intelligent Text Processing (CICLing 2011), Tokyo, Japan.

Hernandez, N., F. Poulard, M. Vernier and J. Rocheteau. 2010, Building a French-speaking community around UIMA, gathering research, education and industrial partners, mainly in Natural Language Processing and Speech Recognizing domains, Workshop Abstracts LREC 2010 Workshop 'New Challenges for NLP Frameworks', La Valleta Malte, p.64. http://hal.archives-ouvertes.fr/hal-00481459/en/

Poulard, F., N. Hernandez, S. D. Afantenos and B. Daille. 2010, Evaluation de descripteurs statistiques et linguistiques pour la détection de dérivation de texte, Document numérique, 13, 3/2010, p.69-93. http://hal.archives-ouvertes.fr/hal-00554351/en/.

Dejean, C., M. Fortun, C. Massot, V. Pottier, F. Poulard and M. Vernier. 2010, Un étiqueteur de rôles grammaticaux libre pour le français intégré à Apache UIMA, Actes de la 17e Conférence sur le Traitement Automatique des Langues Naturelles 17e Conférence sur le Traitement Automatique des Langues Naturelles, Montréal, Canada. http://hal.archives-ouvertes.fr/hal-00493847/en/.

Poulard, F., S. D. Afantenos and N. Hernandez. 2009, Nouvelles considérations pour la détection de réutilisation de texte, Actes de la 16ème conférence sur le Traitement Automatique des Langues Naturelles, Senlis France, p.67. http://hal.archives-ouvertes.fr/hal-00401072/en/.

Hernandez, N., F. Poulard, S. Afantenos, M. Vernier J. Rocheteau. 2009, Apache UIMA pour le Traitement Automatique des Langues, 16ème conférence sur le Traitement Automatique des Langues Naturelles (TALN'09) - Session Démonstration. http://hal.archives-ouvertes.fr/hal-00423728/en/,

Poulard, F., T. Waszak, N. Hernandez and P. Bellot. 2008, Repérage de citations, classification des styles de discours rapporté et identification des constituants citationnels en écrits journalistiques, Actes de la 15e Conférence sur le Traitement Automatique des Langues Naturelles Traitement Automatique des Langues Naturelles, Avignon, France, p.450-459. http://hal.archives-ouvertes.fr/hal-00401011/en/.

Poulard, F. 2008, Analyse quantitative et qualitative de citations extraites d'un corpus journalistique, Actes de la 12e édition de RECITAL Rencontre des Etudiants-Chercheurs en Informatique et en Traitement Automatique des Langues (RÉCITAL), Avignon France, p.101-110. http://hal.archives-ouvertes.fr/hal-00401001/en/.

I'm going to defend my PhD thesis !

Fabien Poulard — Thu, 17 Mar 2011 16:30:00 +0100

I will defend my PhD thesis on March, 24th 2011 at 9:30 am in room 3 of LINA.

Not only is the defense public, but you are welcome to attend. The thesis content is detailed in the rest of this bill.

Title: Detecting textual derivatives

Keywords: detection of derivation, revisions, plagiarism, signature approach, similarity metrics, information retrieval

Abstract:

Thanks to the Internet, the production and publication of content is possible with ease and speed. This possibility raises the issue of controling the origins of this content. This work focuses on detecting derivation links between texts. A derivation link associates a derivative text and the pre-existing texts from which it was written. We focused on the task of identifying derivative texts given a source text for various forms of derivation. Our first contribution is the definition of a theoretical framework defines the concept of derivation as well as a model framing the different forms of derivation. Then, we set up an experimental framework consisting of free software tools, evaluation corpora and evaluation metrics based on IR. The Piithie and Wikinews corpora we have developed are to our knowledge the only ones in French for the detection of derivation links. Finally, we explored different methods of detection based on the signature-based approach. In particular, we have introduced the notions of specificity and invariance to guide the choice of descriptors used to modelize the texts in the expectation of their comparison. Our results show that the choice of motivated descriptors, including linguistically motivated ones, can reduce the size of the modelization of texts, and therefore the cost of the method, while offering performances comparable to the much more voluminous state of the art approach.

Thesis jury:

M. François Yvon, Professor at Université de Paris Sud 11 (rapporteur)
M. Patrice Bellot, Assistant professor at Université d'Avignon (rapporteur)
Mme Josiane Mothe, Professor at Institut Universitaire de Formation des Maître de Toulouse (examiner)
M. Claude de Loupy, Director and co-founder of Syllabs (guest)
Mme Béatrice Daille, Professor at Université de Nantes (director)
M. Nicolas Hernandez, Assistant professor at Université de Nantes (supervisor)

Publications:

Poulard, F., N. Hernandez and B. Daille. 2011, Detecting derivatives using specific and invariant descriptors, Proceedings of the 12th International Conference on Computational Linguistics and Intelligent Text Processing (CICLing 2011), Tokyo, Japan.

Hernandez, N., F. Poulard, M. Vernier and J. Rocheteau. 2010, Building a French-speaking community around UIMA, gathering research, education and industrial partners, mainly in Natural Language Processing and Speech Recognizing domains, Workshop Abstracts LREC 2010 Workshop 'New Challenges for NLP Frameworks', La Valleta Malte, p.64. http://hal.archives-ouvertes.fr/hal-00481459/en/

Poulard, F., N. Hernandez, S. D. Afantenos and B. Daille. 2010, Evaluation de descripteurs statistiques et linguistiques pour la détection de dérivation de texte, Document numérique, 13, 3/2010, p.69-93. http://hal.archives-ouvertes.fr/hal-00554351/en/.

Dejean, C., M. Fortun, C. Massot, V. Pottier, F. Poulard and M. Vernier. 2010, Un étiqueteur de rôles grammaticaux libre pour le français intégré à Apache UIMA, Actes de la 17e Conférence sur le Traitement Automatique des Langues Naturelles 17e Conférence sur le Traitement Automatique des Langues Naturelles, Montréal, Canada. http://hal.archives-ouvertes.fr/hal-00493847/en/.

Poulard, F., S. D. Afantenos and N. Hernandez. 2009, Nouvelles considérations pour la détection de réutilisation de texte, Actes de la 16ème conférence sur le Traitement Automatique des Langues Naturelles, Senlis France, p.67. http://hal.archives-ouvertes.fr/hal-00401072/en/.

Hernandez, N., F. Poulard, S. Afantenos, M. Vernier J. Rocheteau. 2009, Apache UIMA pour le Traitement Automatique des Langues, 16ème conférence sur le Traitement Automatique des Langues Naturelles (TALN'09) - Session Démonstration. http://hal.archives-ouvertes.fr/hal-00423728/en/,

Poulard, F., T. Waszak, N. Hernandez and P. Bellot. 2008, Repérage de citations, classification des styles de discours rapporté et identification des constituants citationnels en écrits journalistiques, Actes de la 15e Conférence sur le Traitement Automatique des Langues Naturelles Traitement Automatique des Langues Naturelles, Avignon, France, p.450-459. http://hal.archives-ouvertes.fr/hal-00401011/en/.

Poulard, F. 2008, Analyse quantitative et qualitative de citations extraites d'un corpus journalistique, Actes de la 12e édition de RECITAL Rencontre des Etudiants-Chercheurs en Informatique et en Traitement Automatique des Langues (RÉCITAL), Avignon France, p.101-110. http://hal.archives-ouvertes.fr/hal-00401001/en/.

Visualiser un espace à plusieurs dimensions en 3D

Fabien Poulard — Thu, 17 Mar 2011 00:03:00 +0100

L'analyse en composantes principales (ACP) permet de calculer les hyperplans d'un espace vectoriel tel qu'une projection sur ces plans conserve un maximum d'entropie. Cette approche permet entre autres choses de projeter des espaces ayant un très grand nombre de dimensions dans des espaces de dimensions réduites tout en limitant la perte d'information.

L'utilisation combinée de scikit-learn et de matplotlib permet de produire très rapidement des réductions de dimension et de les visualiser. J'utilise ces bibliothèques pour visualiser dans un espace à 2 ou 3 dimensions des espaces vectoriels correspondant à des représentations de documents à l'aide de traits particuliers.

Je travaille actuellement sur le projet TTC au sein de mon équipe. Je suis chargé de développer un classifieur de pages Web selon leurs intentions de communication. S'il existe bon nombre de travaux sur la classification des documents Web, dans notre cas nous cherchons une approche indépendante de la langue. Nous travaillons en effet sur sept langues différentes plus ou moins éloignées (français, anglais, allemand, espagnol, letton, russe et chinois). Voilà le contexte et le problème posé.

J'explore un certain nombre de traits qui pourraient s'avérer pertinent pour ladite tâche (URL, structure HTML, n-grammes caractères...). Il est cependant compliqué d'évaluer qualitativement si les traits retenus permettent de différencier les "intentions de communication" auxquelles nous nous intéressons. Une manière très subjective, mais également très efficace, de mesurer cette capacité est de visualiser les clusters formés par les documents dans l'espace vectoriel défini par nos traits. Chaque document est représenté par un vecteur des valeurs correspondant aux différents traits sélectionnés. Ces traits sont cependant très nombreux et l'espace vectoriel correspondant ne peut pas être directement représenté sous forme graphique.

Afin d'aisément visualiser les documents dans ces espaces vectoriels j'effectue une projection sur seulement trois dimensions et je visualise le résultat sous forme d'un graphique de type "nuage de points". Les trois combinaisons sont en réalité des combinaisons algébriques de l'ensemble des dimensions de mon espace vectoriel obtenues par une approche en composantes principales.

Il est assez aisé de mettre en œuvre une telle approche avec scikit-learn :

# Importation de l'approche par composantes principales
from scikits.learn.pca import PCA
 
# On utilise un ensemble de données exemple classique : Iris
from scikits.learn import datasets
iris = datasets.load_iris()
 
# Préparation de la méthode PCA pour une projection sur 3 dimensions
pca = PCA(n_components=3)
# Calcul de la projection à partir des données exemples
pca.fit(iris.data)
# Application de la projection aux données
newdata = pca.transform(iris.data)

La variable newdata contient alors une projection de nos données sur le nouvel espace vectoriel en 3 dimensions. Je peux ainsi visualiser les documents dans ce nouvel espace en utilisant Pylab issue de matplotlib :

# Utilisation de Pylab et de mplot3d intégré à matplotlib
import pylab as pl
import mpl_toolkits.mplot3d.axes3d as p3
 
# Création de la figure dans laquelle nous allons représenté notre nuage de points
# qui sera composée de 3 dimensions (Axes3D)
fig=pl.figure()
ax = p3.Axes3D(fig)
# Les données Iris se répartissent entre 3 classes (0, 1 et 2), nous allons coloré chacune de
# ces classes différemment afin de les visualiser
# Nous utilisons également le nom réel (iris.target_names) des classes dans la légende
for color, classe, nom_classe in zip("rgb", [0, 1, 2], iris.target_names):
	# newdata[iris.target==classe,0] permet de récupérer la première colonne (0) de la 
	# sous-matrice correspondant aux instances de la classe "classe"
	ax.scatter3D(newdata[iris.target==classe,0], 
	  newdata[iris.target==classe,1], newdata[iris.target==classe,2], 
	  c=color, label=nom_classe)
# On ajoute les données à la figure et on dessine le tout
fig.add_axes(ax)
pl.show()

Et voici le résultat :

La projection en 3D permet très facilement (et très subjectivement) d'identifier les trois clusters correspondant aux trois classes et d'ainsi valider les traits retenus pour représenter les instances.

Cours de TALN (3) : n-grammes

Fabien Poulard — Wed, 12 Jan 2011 00:00:00 +0100

Voilà le troisième et dernier opus du cours dont je parlais ici. J'avais présenté le premier opus ici et le second ici.

L'intégralité du cours et des ressources nécessaires sont disponibles ici, ce qui inclut notamment le support de cours. Le travail intègre les éléments vus précédemment et les étudiants exploitent encore le corpus des discours de Nicolas Sarkozy.

J'ai revu les objectifs à la baisse. J'ai essayé de recentrer un peu le contenu sur la partie théorique étant donné que celle-ci est beaucoup plus présente dans cette partie (propriété de Markov et probabilités conditionnelles). Je ne délaisse pour autant pas les exercices de mise en pratique qui me semblent fondamentaux pour un module de "découverte".

À l'issue de cette dernière séance j'espère que les étudiants auront compris :

le principe de la propriété de Markov ;
comment celle-ci est mise en œuvre au travers des n-grammes ;
l'importance du contexte dans la compréhension du texte ;
ce qu'on entend derrière un "modèle de langage".

Et j'espère encore une fois qu'ils auront pris du plaisir dans mon cours... Normalement ils devraient être en mesure de créer de nouveaux nuages de mots en utilisant cette fois des filtrages un peu plus élaborés. Voici ceux que j'ai généré à partir de l'énoncé en utilisant l'outil WordItOut et mon script d'extraction :

Nuage des 100 trigrammes mots les plus fréquents des discours de Nicolas Sarkozy :

Nuage des 100 trigrammes mots les plus fréquents des discours de Nicolas Sarkozy après suppression des mots ouils :

Nuage des 100 trigrammes mots les plus fréquents des discours de Nicolas Sarkozy, restriction aux noms et adjectifs uniquement :

Nuage des 100 trigrammes mots les plus fréquents des discours de Nicolas Sarkozy, restriction aux verbes et adverbes uniquement :

Cours de TALN (2) : morphologie et étiquetage des rôles grammaticaux

Fabien Poulard — Sun, 09 Jan 2011 22:59:00 +0100

Voilà le second opus du cours dont je parlais ici. J'avais présenté le premier opus ici.

L'intégralité du cours et des ressources nécessaires est disponible ici, ce qui inclut :

le support de cours ;
deux fables de La Fontaine, découpées en mots, pour expérimenter l'analyse morpho-syntaxique ;
un script python pour extraire les noms communs du corpus des discours de Nicolas Sarkozy.

La plupart des ressources utilisées lors du corpus précédent seront réexploitées dans ce cours. Les étudiants peuvent ainsi valoriser les connaissances précédemment acquises.

À l'issue de cette seconde séance mon objectif est d'avoir enseigné aux étudiants :

des connaissances suffisantes à la compréhension de l'algorithme de Porter ;
l'intérêt de l'analyse morphologique pour la compréhension des textes ;
l'utilisation de Tree Tagger, un étiqueteur de rôles grammaticaux ;
l'intérêt de la catégorisation des mots selon leurs rôles grammaticaux.

Python et Tree Tagger

Fabien Poulard — Sun, 09 Jan 2011 19:30:00 +0100

Tree Tagger est un outil d'étiquetage des rôles grammaticaux disponible pour plusieurs plateformes et pour plusieurs langues. Si sa licence n'est pas libre, il peut être utilisé dans un cadre de recherche ou bien pour l'éducation.

Il existe un projet de wrapper Python pour cet outil qui pourrait m'être utile pour mon cours de TALN.

Pour utiliser le wrapper, il faut tout d'abord installer Tree Tagger. Pour Linux et le français, la démarche est la suivante :

Télécharger l'archive contenant l'outil ;
La décompresser dans un répertoire dédié ;
Télécharger le fichier de paramètre pour le français (utf-8)
Le décompresser et le déplacer dans un répertoire lib à la racine du répertoire contenant Tree Tagger en le renommant french.par

Vous pouvez alors tester le bon fonctionnement de l'étiqueteur en vous plaçant dans ledit répertoire, puis :

shell$ echo -e "Ceci\nest\nun\ntrès\ncourt\ntexte\nà\nétiqueter\n."\
  |bin/tree-tagger -token -lemma -quiet lib/french.par
Ceci	PRO:DEM	ceci
est	VER:pres	être
un	DET:ART	un
très	ADV	très
court	ADJ	court
texte	NOM	texte
à	PRP	à
étiqueter	VER:infi	étiqueter
.	SENT	.

La signification des étiquettes est expliquée ici.

Une fois l'étiqueteur installé sur le système, il faut récupérer le wrapper Python. Il n'en existe pas de version directement téléchargeable à ma connaissance. Il faut donc le récupérer depuis le dépôt du projet par subversion :

svn co https://subversion.cru.fr/ttpw/trunk/treetaggerwrapper.py

La version présente sur le dépôt au moment de la rédaction de cet billet n'est pas fonctionnelle. J'ai remonté un bug à ce sujet à l'auteur. Il suffit d'appliquer le patch que j'ai proposé pour rendre le wrapper fonctionnel.

L'utilisation est ensuite assez simple, il suffit d'importer le module dans le code Python, puis de préciser la langue (TAGLANG) et le répertoire d'installation (TAGDIR). Par défaut, le wrapper est configuré pour exploiter l'encodage latin1. Le fichier de paramètre pour le français est en utf-8, tout comme mon environnement de développement. J'ai donc également précisé que je voulais utiliser cet encodage (TAGINENC et TAGOUTENC) :

import treetaggerwrapper
# Construction et configuration du wrapper
tagger = treetaggerwrapper.TreeTagger(TAGLANG='fr',TAGDIR='/tmp',
  TAGINENC='utf-8',TAGOUTENC='utf-8')
# Utilisation
tags = tagger.TagText(u"Ceci est un très court texte à étiqueter.")
print tags

Le résultat du traitement est une liste des triplets mot, rôle grammatical et lemme.

[u'Ceci\tPRO:DEM\tceci', u'est\tVER:pres\t\xeatre', 
 u'un\tDET:ART\tun', u'tr\xe8s\tADV\ttr\xe8s', 
 u'court\tADJ\tcourt', u'texte\tNOM\ttexte', u'\xe0\tPRP\t\xe0',
 u'\xe9tiqueter\tVER:infi\t\xe9tiqueter', u'.\tSENT\t.']

Voici un petit morceau de code qui permet de structurer un petit peu mieux cette sortie :

class TreeTaggerWord:
  def __init__(self, triplet):
    self.word,self.postag,self.lemma = triplet

def formatTTG(output):
  words = []
  for w in output:
    words.append(TreeTaggerWord(w.split("\t")))
  return words

Les données en sortie sont alors accessibles comme des attributs de la classe TreeTaggerWord :

import treetaggerwrapper
# Construction et configuration du wrapper
tagger = treetaggerwrapper.TreeTagger(TAGLANG='fr',TAGDIR='/tmp',
  TAGINENC='utf-8',TAGOUTENC='utf-8')
# Utilisation
tags = tagger.TagText(u"Ceci est un très court texte à étiqueter.")
data = formatTTG(tags)
print data[0].word
print data[0].postag
print data[0].lemma

PPDA accusé de plagiat... une opportunité pour ma thèse ?

Fabien Poulard — Thu, 06 Jan 2011 14:05:00 +0100

C'est l'un des sujets chauds de cette rentrée hivernale : il semblerait que le livre à paraître sur Hemingway de PPDA publié par les Éditions Arthaud soit un plagiat. C'est le quotidien L'Express qui a levé le lièvre, rapidement relayé par bien d'autres.

Cette histoire serait une très belle illustration pour conclure ma thèse sur la dérivation de texte ! Si PPDA ou les éditions d'Arthaud voulaient bien m'envoyer une version du livre, je pourrais la confronter à l'aide de mes algorithmes sur la biographie signée Peter Griffin et parue en français aux éditions Gallimard. Mais parle-t-on bien de plagiat et qu'est-ce que cela signifie ?

Qu'est-ce que le plagiat ?

Le TLFI (Trésor de la Langue Française Informatisée) définit le plagiat comme l'action d'emprunter à un ouvrage original et à son auteur des éléments dont on s'attribue abusivement la paternité en les reproduisant, avec plus ou moins de fidélité, dans une œuvre que l'on présente comme personnelle. Le plagiat est condamné par la morale en ce que le plagiaire profite d'une gloire indue qui aurait dû profiter à l'auteur original. Ce qui représentait pour Diderot le délit le plus grave qui puisse se trouver dans la République des Lettres.

En réalité, le plagiat est un délit moral qui n'a pas forcément de pendant juridique. Les délits assimilables à du plagiat se distribuent entre les atteintes au droit d'auteur (Code de la propriété intellectuelle, Première partie : la propriété littéraire et artistique) et la contrefaçon (Code de la propriété intellectuelle, Deuxième partie : la propriété industrielle) mais une grande partie de ces délits n'est pas constituée. Les affaires ne sont d'ailleurs portées devant les tribunaux que lorsque le préjudice a des conséquences commerciales (en littérature majoritairement). Ce serait potentiellement le cas pour le cas de PPDA, excepté que seul la partie concernée (Gallimard très probablement) peut déposer une plainte ; Me Éolas serait bien plus compétent que moi sur ce sujet.

Ce qui est paradoxale c'est que le plagiat est perçu comme un acte moralement condamnable tandis que la réutilisation de contenu ou d'idées est souvent associée au processus créatif. En réalité, la frontière entre les deux est assez floue. Ainsi, pour Giraudoux (1928, Acte I, scène 6), le plagiat est la base de toutes les littératures, excepté de la première, qui d'ailleurs est inconnue. Dans le Palimpsestes (Genette, 1982), Genette analyse des enchevêtrements d'œuvres : de la copie à l'allusion lointaine. Il montre qu'un texte peut toujours en cacher un autre, mais qu'il le dissimule rarement tout à fait, prenant pour exemple l'Ulysse de Joyce qui est, d'après sa terminologie, l'hypertexte (œuvre dérivée) de l'Odyssée d'Homère qui en est l'hypotexte (œuvre originale). Les pastiches et les parodies sont autant d'exemples du potentiel créatif de la réutilisation.

En réalité, comme tout ce qui relève de la morale, le plagiat est une notion culturelle. Ainsi, bien que le droit d'auteur soit assez uniformisé au niveau international par le traité de Berne (1886), chaque pays possède son propre système de protection du droit d'auteur, lorsqu'il en possède. Les États-Unis par exemple n'ont signé le traité qu'un siècle plus tard, réticents à la vision franco-allemande centrée sur l'auteur et son droit moral. Cette notion est même encore plus éparse puisqu'elle est perçue différemment au sein des branches d'un même métier. Thomas (2009) montre qu'un processus d'écriture considéré comme du plagiat par la presse écrite et qui entraînerait le renvoi du journaliste est très couramment usité à la TV et à la Radio. Clough (2003a) notamment consacre un chapitre de sa thèse à la description de la réutilisation dans le journalisme.

Quelles sont les preuves ?

Les accusations de plagiat défraient la chronique assez courrament, particulièrement lorsqu'elles concernent des œuvres à succès telles qu'Harry Potter. Pourtant très peu de ces accusations se concluent sur des condamnations. En fait, les institutions juridiques commencent tout juste à s'équiper de moyens leur permettant de prendre des décisions concernant les affaires de "plagiat". Ainsi, l'Institute for Linguistic Evidences, financé notamment par le United States Department of Justice travaille à la mise au point de méthodes permettant d'obtenir des preuves reconnues par un tribunal. Cet institut travaille notamment sur l'outil ALIAS (Automated Linguistic Identification and Assessment System) (Chaski, 2001) qui a partiellement passé les normes de Frye et Daubert qui définissent l'admissibilité d'un témoignage scientifique lors d'un procès aux États-Unis.

Dans le cas de PPDA, les accusations de Jérôme Dupuis sont soutenues par des dizaines et des dizaines de paragraphes qui s'apparentent à des "copier-coller", souvent grossièrement maquillés par des inversions de phrases ou l'usage effréné de synonymes. Il présente même plusieurs exemples de ces copier-coller fallacieux, précisant que des suppressions, des inversions et des paraphrases ont été opérées pour tenter de dissimuler la reprise.

En tant que chercheur, j'en ai l'eau à la bouche. Toutes ces modifications sont difficiles à réunir sous forme d'un corpus afin d'être étudiées ou bien pour évaluer les algorithmes de détection. PPDA m'offrirait là un joli cadeau de noël ! Il serait intéressant de calculer la couverture des deux textes et évaluer ainsi quantitativement et objectivement la quantité de reprise. Pour l'heure on est tenu de croire (ou non) aux preuves du journaliste de l'Express.

La défense de PPDA et de son éditeur

PPDA et son éditeur s'alignent sur la même ligne de défense : ils nient tout en bloc accusant l'envoie d'une version de travail provisoire :

... les Editions Arthaud tiennent à préciser que le texte imprimé, qui a été diffusé par erreur à la presse en décembre, était une version de travail provisoire. Elle ne correspond pas à la version définitive validée par l'auteur...

Je ne suis pas convaincu et je ne suis pas le seul ! Je passerai sur la vieille combine du nègre qui est illégale en droit français pour me concentrer sur la version de travail provisoire. L'auteur et l'éditeur reconnaissent ici qu'une version de travail temporaire contenait des passages complets de la biographie écrite par Peter Griffin. Je me pose plusieurs questions :

si c'est une version de travail temporaire, pourquoi y coller des passages d'un autre livre et ne pas plutôt laisser des blancs ?
pourquoi tenter de modifier ces passages recopiés s'ils sont destinés à être supprimés par la suite ?
si ce ne sont les passages, il semble du moins que le plan du livre de PPDA soit très similaire à celui de Griffin, n'est-ce pas une forme de plagiat ?

La notion morale de plagiat me posant problème dans ma thèse, j'y ai introduit une notion plus scientifique à mon goût : la dérivation. Je définis la dérivation comme ceci (extrait de ma thèse) :

Nous considérons qu'un texte dérive d'un autre lorsque la préexistence de l'un, que nous appelons texte source, est une condition nécessaire à l'aboutissement de l'écriture de l'autre, que nous appelons texte dérivé. Le texte source influence (dans ses idées, dans son expression, dans sa structure...) l'auteur du texte dérivé, de telle façon qu'il a eu un impact dans ses choix d'écriture. Il en découle que si cet auteur est privé de la connaissance d'un texte source alors il produira un texte différent de celui qu'il aurait produit en sa connaissance.

Il me semble que dans le contexte présent il existe bel et bien un lien de dérivation entre le livre de Peter Griffin et celui de PPDA... Je meurs d'envie de fouiller un peu plus dans ce sens là. Si jamais quelqu'un possède une version électronique de chacun des livres, je serais heureux de pouvoir les analyser. D'ici là, je retourne à la rédaction du mien de manuscrit :)

Petit script pour découvrir les expressions rationnelles

Fabien Poulard — Tue, 04 Jan 2011 15:21:00 +0100

Comme j'en discutais dans mon billet précédent, mon premier cours cette année a principalement porté sur les expressions rationnelles. J'ai tiré deux bilans de ce cours :

il faut que les étudiants manipulent au maximum
il faut qu'ils comprennent mieux ce qui se passe dans les moteurs d'expressions rationnelles pour corriger leurs erreurs

J'ai donc écrit un script Python pour les accompagner dans leur découverte des expressions rationnelles.

Le script est disponible ici.

Il prend en paramètre une expression de la forme 'm/<regexp>/' ou 's/<regexp>/<remplacement>/' selon la tâche à tester.

Petit exemple de fonctionnement :

$ ./test-re.py 's/([0-9]{1,3}\.[0-9]{1,3})\.[0-9]{1,3}\.[0-9]{1,3}/Réseau IP \1.0.0/'
Checking configuration...Replacing mode.
Ready. Hit ^D to stop the program.
test-re>> 192.168.1.1
RES> Matching
	Matched: ...192.168.1.1... (0, 11)
	Context: ->[192.168.1.1]<-
	Groups:
		1- 192.168
Substitution
	Original:	 192.168.1.1
	Replaced:	 Réseau IP 192.168.0.0
test-re>> mon adresse ip : 174.12.32.65 mon masque 255.255.255.0    
RES> Matching
	Matched: ...174.12.32.65... (17, 29)
	Context: ->mon adresse ip : [174.12.32.65] mon masque 255.255.255.0<-
	Groups:
		1- 174.12
Substitution
	Original:	 mon adresse ip : 174.12.32.65 mon masque 255.255.255.0
	Replaced:	 mon adresse ip : Réseau IP 174.12.0.0 mon masque Réseau IP 255.255.0.0

Cours de TALN (1) : expressions rationnelles

Fabien Poulard — Mon, 03 Jan 2011 16:54:00 +0100

Voilà, suite à mon précédent billet, je me suis décidé à me lancer dans l'écriture du cours que je dois donner demain.

L'intégralité du cours et des ressources nécessaires est disponible ici, ce qui inclut :

le support de cours ;
une version allégée du corpus des discours de Nicolas Sarkozy ;
un corpus de fichiers de logs (logs d'authentification, d'erreurs d'Apache et de connexions à un vhost Apache) ;
et quelques exemples de code en Python.

À l'issue de cette première séance mon objectif est d'avoir enseigné aux étudiants :

des connaissances suffisantes à la compréhension et à l'écriture d'expressions rationnelles ;
l'utilisation des expressions rationnelles à travers les outils grep et sed ainsi qu'au sein du langage Python ;
et qu'ils aient perçu les difficultés d'une problématique classique en TALN : le découpage en mots.

Bien entendu un autre objectif implicite est de leur avoir donné envie de creuser un peu plus loin et d'avoir suffisamment aiguisé leur curiosité pour qu'ils s'intéressent à la suite du cours... et au TALN en général. Bilan des objectifs demain :)

En bonus pour les plus efficaces, la possibilité de générer un joli nuage des mots les plus prononcés dans les discours de notre président dans le style de celui-ci :

Un cours de TALN parfait ?

Fabien Poulard — Mon, 03 Jan 2011 00:55:00 +0100

Depuis le début de mon doctorat j'ai eu la chance de pouvoir dispenser plusieurs enseignements autour du TALN. Malheureusement je n'ai jamais été responsable du module et je n'ai jamais tellement eu la liberté d'enseigner comme je le souhaitais. Personnellement je n'ai pas aimé la façon dont le TALN m'a été enseigné et par conséquent je n'aime pas l'enseigner de la même façon qu'il me l'a été.

Quelle aurait été le cours de TALN que j'aurais aimé avoir ? Certainement quelque chose mieux ancré dans le TALN d'aujourd'hui et orienté vers les méthodes et les applications !

Cette année, j'enseigne encore une fois le TALN à l'EPUN : 9h de TP destinés à des étudiants de 1ère année d'ingénieur. La différence c'est que cette fois j'ai plus ou moins quartier libre. Cette liberté est toute relative puisque je ne suis responsable que des TP et que ceux-ci devront coller aux cours (sur lesquels je n'ai aucune prise). Toutefois, cette année je ne suis pas tenu de donner un projet noté. En d'autres termes, je peux exploiter la totalité des heures pour faire des exercices : apprendre en faisant comme on dit.

Habituellement, les travaux pratiques sont faits en Perl, un langage que je n'apprécie pas du tout alors qu'il est certainement le langage favoris de ma communauté. Sans disserter sur les raisons de notre désamour, je pense qu'il n'apporte rien d'autre qu'un bon moteur pour les expressions rationnelles. S'il y a dix ans cette spécificité justifiait son choix, aujourd'hui tous les langages généralistes supportent aussi bien les expressions rationnelles. Le comble est qu'il n'existe pas (à ma connaissance) de plateforme (modules, extensions...) permettant de faire du TALN en Perl, alors qu'on en trouve pour Python et Java.

Plutôt que Perl, je pense que je vais faire travailler mes étudiants avec Python. Outre le fait qu'il me sera beaucoup plus aisé de corriger les projets (les programmes Perl des gens qui ne maîtrisent pas le langage peuvent être la cause de sérieuses crises de nerf), l'apprentissage du langage Python leur sera utile pour d'autres projets scientifiques (voir ici, ici ou encore là). De plus, le cadriciel nltk permet d'aborder rapidement les principales tâches du TALN sans avoir à tout réimplémenter. Le cadriciel est notamment très bien documenté, ce qui ne gâche rien !

Au niveau corpus, je ne sais pas encore très bien sur quoi je vais les faire travailler car il y a malheureusement assez peu de corpus français intéressants pour l'enseignement. Remplacez intéressants pour l'enseignement par on se fout qu'il soit représentatif, on veut juste pouvoir faire des exercices marrants et observer des phénomènes linguistiques simples. J'hésite entre mon corpus sur les discours de Nicolas Sarkozy ou celui que j'ai constitué à partir de Wikinews. Je pourrais également utiliser le French TreeBank qui a l'avantage d'être arboré (découpage en mots et annotation des rôles grammaticaux) mais je ne suis pas sûr que sa licence le permette. Je pourrais également explorer certaines œuvres du projet Guteberg. Il manque clairement un corpus libre tout plein d'annotations pour le français !

Enfin au niveau du contenu il va falloir que je me creuse un petit peu la tête. Le cours présente pas mal (trop ?) de choses : expressions rationnelles, analyse morphologique (algorithme de Porter notamment), analyse syntaxique mais également un peu de n-grammes, des modèles de Markov cachés et j'en oublie certainement...

Le premier cours est mardi prochain, il va falloir que je me casse la tête d'ici là. Je pense les faire travailler sur des choses simples :

quelques exercices sur les expressions rationnelles
prise en main de NLTK
découpage en mots
loi de Zipf
une super application de l'utilisation du découpage en mots et des expressions rationnelles ???

Si certains d'entre-vous ont des ressources, des supports de cours ou des idées qui pourraient m'inspirer... n'hésitez pas ! :)

UIMA insights : le doigt dans le workflow

Fabien Poulard — Mon, 20 Sep 2010 00:08:00 +0200

Les opérations logicielles en traitement automatique des langues sont souvent très importantes, très coûteuse, mais également parallélisables. C'est l'un des avantages indéniables d'UIMA, par le choix d'une architecture par composants, de permettre de paralléliser les traitements assez simplement.

La programmation d'un composant UIMA doit donc se faire avec en tête l'idée qu'il pourrait être déployé pour un traitement parallélisé. Lorsque comme moi on n'a pas cette habitude, on se heurte rapidement à des petits obstacles techniques. Dans le cas présent, il s'agissait de développer un composant qui exportait les résultats d'un calcul dans un fichier CSV.

Mon problème

La chaîne de traitement que j'utilise pour ma thèse calcule des scores de similarité entre des documents. Afin de simplifier l'évaluation de mon système, je souhaite réunir tous ces scores de similarité dans un même fichier CSV.

La solution naïve qui fonctionne presque consiste à ce que le composant ouvre un fichier et y écrive au fur et à mesure. Les systèmes ne rechignent pas à ce que plusieurs processus écrivent en même temps dans le même fichier... Malheureusement ils ne s'assurent pas non plus d'ordonnancer les requêtes d'écriture au risque que chacun écrive sur la copie de son voisin !

Voici le résultat que j'attends :

 source-document00003.txt;suspicious-document00016.txt;not-derivative;0.0016992353
 source-document00003.txt;suspicious-document00040.txt;not-derivative;0.23280424
 source-document00267.txt;suspicious-document00055.txt;derivative;0.14148398

et voici ce que ça peut donner quand les différents processus décident d'écrire en même temps :

 source-document00003.txt;suspicious-docsource-document00003.txt;suspicious-source-document00267.txt;suspicious-document00055.txt;derivative;0.14148398
 ument00016.txt;not-derivative;0.0016992353
 document00040.txt;not-derivative;0.23280424

Le workflow d'UIMA

J'avais déjà rapidement présenté le workflow d'UIMA dans mon billet sur les ressources. Un petit résumé des épisodes précédents ne sera peut-être pas de trop.

Comme d'habitude, pour simplifier, on va considérer qu'on utilise uniquement le flow controler par défaut qui fait s'enchaîner séquentiellement les composants. Cela revient à considérer que la sortie d'un composant alimente directement l'entrée du composant suivant, à la manière des pipes dans le monde Unix.

Dans cette configuration, UIMA regroupe les chaînes de CAS processors (les composants qui manipulent les CAS) dans autant de processing pipelines que l'attribut processingUnitThreadCount du CPE le demande, comme l'illustre le schéma ci-dessous :

l est nécessaire d'instancier les composants utilisés autant de fois qu'il y a de processing pipelines. Jusque-là, rien de bien nouveau en réalité. Mais ce que j'ai découvert récemment, douloureusement bien entendu, c'est que cette instanciation ne se faisait pas au sein des pipelines, mais au sein du thread principal du CPE. Soit la procédure suivante, pour chaque composant :

Instanciation du composant dans le thread principal du CPE ;
Appel de la méthode initialize() toujours dans le thread principal ;
Création des threads des pipelines et rattachement des composants à ces derniers ;
Appels successifs à process() au sein de ces threads ;

Ma solution

J'aurais certes pu faire le choix d'utiliser le système des ressources pour mon composant, comme je le préconise dans mon billet précédent. Toutefois, je n'ai pas eu le temps de manipuler le système des ressources et il est grand temps que j'en finisse avec ma thèse :) Je me suis donc tourné vers quelque chose de plus direct.

Mon choix s'est donc porté sur la création d'autant de fichiers qu'il y a d'instances de mon composant. Je suffixe tout simplement le nom du fichier par l'identifiant du thread courant. Cette méthode fonctionne suffisamment bien, mais nécessite bien entendu de concaténer l'ensemble des fichiers à la fin du traitement. De plus elle ne permet pas directement de garder une trace de l’ordonnancement des écritures ! Dans mon cas ce n'était pas un prérequis.

Pour la petite histoire, j'ai découvert que la méthode initialize() était appelée dans le thread principal car tous mes fichiers étaient suffixés par l'identifiant 1. J'ai donc simplement déplacé l'ouverture des fichiers dans la méthode process() en ajoutant un test pour s'assurer que cette initialisation n'avait pas déjà eu lieu.

Voici le code (synthétique) correspondant, toute l'astuce réside dans le Thread.currentThread().getId() :

public void process(JCas aJCas) throws AnalysisEngineProcessException {
	// Check the streams have been initialized
	if (theStream == null) {
		Long tid = Thread.currentThread().getId();
		theStream =new PrintStream( 
			new File( theExportSuffix + ".__" + tid), "utf-8");
	}
	// Select the right view
	JCas view = aJCas.getView(theViewName);
	...

Un rapide tokeniseur en mots pour le français

Fabien Poulard — Wed, 08 Sep 2010 00:10:00 +0200

Parmi les addons distribués avec UIMA, le composant WhitespaceTokenizer permet de découper les textes en "mots" en s'appuyant sur les espaces et autres blancs. Malheureusement si cette approche est acceptable pour l'anglais, elle est beaucoup plus problématique pour le français. Le découpage en mots n'est pas une tâche forcément évidente et qui nécessiterait un réel travail. Partagé entre la nécessité d'une tokenisation correcte et le peu de temps qui me reste pour terminer ma thèse, voici une proposition suffisamment acceptable pour mes besoins.

Idée et objectifs

Mon idée est d'exploiter la catégorie générale des caractère telles que définies dans la norme Unicode pour détecter les frontières des mots. Une rupture dans la catégorie des caractères indiquant vraisemblablement un changement de mot.

Je souhaite que mon composant soit en mesure d'identifier correctement tous les mots détectés par le WhitespaceTokenizer (c'est un minimum), ainsi que les cas problématiques tels que :

les articles et pronoms contractés (l', d', j', m', ...)
les composés lexicaux à apostrophe (aujourd'hui, ...)
les composés lexicaux à traits d'union (arc-en-ciel, peut-être, sauve-qui-peut, ...)
les valeurs numériques (14 000, 14,18, 30 %, ...)
les acronymes (ASSEDIC, ASCII, ...) et les sigles (C-4, c-à-d, i.e., ...)
les unités de mesure (A/m, km/h, ...)

Mise en œuvre

Catégories générales des caractères unicodes

La norme unicode offre sept catégories générales de caractère :

Unicode	Java (getType)
les lettres (L)
Ll	LOWERCASE_LETTER
Lu	UPPERCASE_LETTER
Lm	MODIFIER_LETTER
Lo	OTHER_LETTER
Lt	TITLECASE_LETTER
les marques (M)
Mc	COMBINING_SPACING_MARK
Me	ENCLOSING_MARK
Mn	NON_SPACING_MARK
les nombres (N)
Nd	DECIMAL_DIGIT_NUMBER
Nl	LETTER_NUMBER
No	OTHER_NUMBER
les ponctuations (P)
Pc	CONNECTOR_PUNCTUATION
Pd	DASH_PUNCTUATION
Pe	END_PUNCTUATION
Pi	INITIAL_QUOTE_PUNCTUATION
Pf	FINAL_QUOTE_PUNCTUATION
Po	OTHER_PUNCTUATION
Ps	START_PUNCTUATION
les symboles (S)
Sc	CURRENCY_SYMBOL
Sm	MATH_SYMBOL
Sk	MODIFIER_SYMBOL
So	OTHER_SYMBOL
les séparateurs (Z)
Zl	LINE_SEPARATOR
Zp	PARAGRAPH_SEPARATOR
Zs	SPACE_SEPARATOR
divers (C)
Cc	CONTROL
Cf	FORMAT
Co	PRIVATE_USE
Cs	SURROGATE
Cn	UNASSIGNED

Le site Fileformat fournit une liste et une description exhaustive des caractères contenus dans ces différentes catégories.

Description des mots

Mots pleins

Les mots pleins sont ceux qui se composent uniquement d'une suite de caractères alphanumériques, on peut les reconnaître à l'aide de l'automate suivant :

Le cas de l'apostrophe

Les articles et pronoms contractés précédent un autre mot, ils se composent d'une seule lettre et d'un apostrophe. Les apostrophes appartiennent à la catégorie Po qui contient également le point d'exclamation, le dièse, ... ou bien à Lm. Il est préférable d'établir une liste des caractères correspondant. L'apostrophe (U+0027) et le modifieur apostrophe (U+02BC) sont les deux caractères qui semblent correspondre pour le français.

Les composés lexicaux à apostrophe sont quant à eux formés de deux séquences alphabétiques connectées par un apostrophe (aujourd'hui, ...).

L'automate permettant de reconnaître ces deux formes de mots :

Le cas du trait d'union

Le trait d'union est utilisé dans plusieurs configurations : pour les composés lexicaux (arc-en-ciel, peut-être, sauve-qui-peut, ...) et certains sigles sigles (C-4, c-à-d, ...). D'une manière générale certaines ponctuations sont employées au sein des mots : le point pour les abréviations (i.e., M., ...), ou le slash pour les unités de mesure (A/m, km/h, ...).

Les traits d'union sont regroupés dans la catégorie ''Punctuation, dash'' (''Pd''), les autres ponctuations (slash et point) sont placées dans ''Punctuation, other'' (''Po''). L'important c'est que ladite ponctuation soit placée entre deux séquences de lettres :

Les valeurs numériques particulières

Finalement le dernier cas particulier concerne les valeurs numériques complexes (14 000, 14,18, 30 %, -3, ...). La catégorie ''Symbol, Currency'' (''Sc'') nous intéresse particulièrement. Le symbole ''%'' se trouve dans la catégorie ''Punctuation, other' (''Po''), tandis que le point et la virgule décimale correspondent respectivement à U+002E et U+002C.

Algorithmie

La tokenisation s'effectue sur un flux continue de caractères. L'utilisation d'automates classiques tels que présentés précédemment n'est pas forcément possible car l'utilisation commune ne correspond pas forcément à une grammaire régulière et ils sont non déterministes. En gros nous pouvons nous retrouver dans ces cas de figure :

Parfois l'espace sépare un mot, parfois il est contenu au sein d'un mot (entre le nombre et la monnaie par exemple) ;
Parfois le passage d'un mot à un autre se fait en consommant un ou plusieurs caractères (espace), parfois le caractère de séparation appartient à l'un des deux mots (apostrophe) ;
La consommation d'un caractère inattendu ne doit pas interrompre le fonctionnement : une décision doit être prise (couper le mot ou pas).

Ma proposition consiste à mettre en œuvre une sorte de transducteur à pile. La pile permet uniquement de conserver un historique des derniers caractères consommés afin de découper les mots à une position antérieure si nécessaire (symbole de monnaie non trouvé mais espace consommé par exemple). L'utilisation d'un transducteur permet d'enovyer des signaux indiquant si une coupure de mot doit avoir lieu ou non.

Les signaux envoyés par le système peuvent être les suivants :

start_word un nouveau mot commence ;
end_word le mot courant se termine, le caractère juste consommé n'en faisant pas parti ;
end_words_prev le mot courant se termine au caractère anté-précédent ;
switch_word le mot courant se termine sur le caractère consommé, le caractère courant appartient à un nouveau mot ;
switch_word_prev le mot courant se termine au caractère anté-précédent, le caractère courant appartient à un nouveau mot ;
nop aucune opération

L'automate ci-dessous correspond à ce transducteur :

les états en N (orange) correspondent à l'automate de reconnaissance des valeurs numériques ;
les états en L (bleu) correspondent à une combinaison des automates de reconnaissance des mots alphabétiques ;
les transitions en rouge correspondent aux cas d'erreur où il faut prendre une décision ;
les transitions en vert correspondent aux cas attendus de changement de mot.

Implémentation

J'ai recherché une bibliothèque Java pour manipuler des transducteurs... mais je n'ai rien trouvé. J'ai donc tout implémenté manuellement ce qui n'est pas formidable pour le maintient du code. J'ai donc implémenté également plusieurs tests unitaires.

Au final, les cas où les symboles monnétaires sont espacés des nombres par un espace pose problème, mais j'ai choisi de laisser tel quel car je ne vois pas de solution pratique (je ne vois plus grand chose en fait).

Chose intéressante, mon implémentation à base de transducteur est plus rapide de près de 40% que le composant WhitespaceTokenizer sur un petit corpus de test, mais d'autres tests donnent les deux annotateurs ex-aequo. La qualité du résultat est sans comparaison, comme l'illustre l'exemple ci-dessous :

 "Le Roi a reçu en audience en début d’après-midi au Château

Résultat du WhitespaceTokenizer : {", Le, Roi, a, reçu, en, audience, en, début, d, ’, après, -, midi, au, Château}

Résultat de notre composant : {", Le, Roi, a, reçu, en, audience, en, début, d’, après-midi, au, Château}

Distribution

Les jar avec les sources et le descripteur sont disponibles ici.

J'ai également ouvert un dépôt sur github pour ceux qui voudraient contribuer.

Calculer le recouvrement de deux textes avec NLTK

Fabien Poulard — Thu, 26 Aug 2010 00:11:00 +0200

Mon travail de thèse, sobrement intitulée Détection de dérivations de texte, consiste à évaluer la probabilité qu'un texte dérive d'un autre. Une des applications, que je déteste mais qui a l'avantage de parler à la plupart des gens, est la détection de plagiat.

Une approche, naïve mais simple à mettre en œuvre, consiste à calculer le nombre de mots que deux textes partagent. Voici une proposition d'implémentation d'une telle technique tirant partie de la bibliothèque NLTK.

Le calcul de la couverture en terme de mots de deux textes n'a rien de bien compliqué dans la mesure où :

il nous est possible de découper le texte en mots ;
nous savons compter le nombre de mots qu'ils ont en commun.

Pour le découpage en mots, nous allons utiliser la bibliothèque NLTK (j'utilise la version bêta de la 2.0) qui propose une méthode word_tokenize :

import nltk
nltk.word_tokenize(u"A sentence to be tokenized")
 
[u'A', u'sentence', u'to', u'be', u'tokenized']

Le tokeniseur est loin d'être parfait, notamment pour les textes qui ne sont pas de l'anglais, mais il fonctionne suffisamment bien pour l'utilisation que nous en avons. Ce serait beaucoup plus problématique pour une tâche de recherche d'information par exemple.

Nous passerons donc le contenu des fichiers à comparer à cette fonction qui nous retourne la liste des mots correspondant. Il nous faut alors calculer l'intersection des deux listes de mots.

Les objets set offrent une méthode intersection qui ferait l'affaire. Cependant la conversion en un ensemble va faire disparaître les doublons, or nous aimerions avoir un recouvrement aussi précis que possible. Nous définissons donc une fonction qui va calculer l'intersection de deux listes. Elle peut certainement être largement améliorée (ne pas hésiter à proposer une correction), mais suffira pour l'exemple :

def intersect_list(lst1, lst2):
	"""
	Calcule l'intersection entre deux listes
	"""
	# Intersection
	inter = []
	# Calcul des éléments en commun
	common = set(lst1).intersection(lst2)
	# Construction de la liste commune
	for e in common:
		nbe = min(lst1.count(e), lst2.count(e))
		for i in range(nbe):
			inter.append(e)
	return inter

Nous avons désormais en main tous les éléments nécessaire pour écrire un petit script qui calculera le taux de recouvrement en mots entre deux fichiers textes.

Voici le script complet pour ceux que ça intéresse :

#! /usr/bin/python
# -*- coding: utf-8 -*-
#
# Script permettant de calculer le taux de recouvrement en mots entre les
# deux textes passés en paramètre.
 
import nltk
import os.path
import sys
import codecs
 
def loadTxt(fic):
	"""
	Charge le contenu textuel du fichier en paramètre
	"""
	fh  = codecs.open(fic, "r", "utf-8", errors='ignore')
	txt = fh.read()
	fh.close()
	return txt
 
def intersect_list(lst1, lst2):
	"""
	Calcule l'intersection entre deux listes
	"""
	# Intersection
	inter = []
	# Calcul des éléments en commun
	common = set(lst1).intersection(lst2)
	# Construction de la liste commune
	for e in common:
		nbe = min(lst1.count(e), lst2.count(e))
		for i in range(nbe):
			inter.append(e)
	return inter
 
# Vérifie qu'il y a bien deux fichiers passés en paramètre du script
if len(sys.argv) == 3:
	# Charge les textes des fichiers
	txt1 = loadTxt(sys.argv[1])
	txt2 = loadTxt(sys.argv[2])
	# Tokenisation en mots
	txt1toks = nltk.word_tokenize(txt1)
	txt2toks = nltk.word_tokenize(txt2)
	# Calcul de la couverture
	incommon = intersect_list(txt1toks, txt2toks)
	# Affichage
	print "Couverture de %s par rapport à %s" % (sys.argv[1],sys.argv[2])
	print "\t%f" % (float(len(incommon))/len(txt1toks))
	print "Couverture de %s par rapport à %s" % (sys.argv[2],sys.argv[1])
	print "\t%f" % (float(len(incommon))/len(txt2toks))
else:
	print "Utilisation :"
	print "\t%s <fichier 1> <fichier 2>" % sys.argv[0]

Bien entendu, le taux de recouvrement en mots n'est pas très performant pour évaluer le degré de dérivation entre deux textes. Une manière de l'améliorer serait de calculer le taux de recouvrement de n-grammes plutôt. J'attends vos propositions :)

Parcours des annotations couvertes par une autre annotation

Fabien Poulard — Thu, 01 Apr 2010 11:11:00 +0200

Lorsque l'on travaille avec Apache UIMA et que l'on ajoute un nombre important d'annotations, il arrive un moment où l'on va vouloir filtrer certaines de ces annotations en fonction d'autres. Ainsi, assez couramment on éprouve le besoin de devoir récupérer des annotations qui couvrent la même zone de texte qu'une autre. Par exemple :

récupérer les mots contenus dans une phrases ;
récupérer les paragraphes dans un document ;
…

Il y a au moins deux approches dans Apache UIMA qui permettent de répondre à ce besoin : le subiterator et le FSMatchConstraint.

Utilisation du subiterator

L'approche basée sur le subiterator ne peut fonctionner que si les types que l'on cherche à accéder sont couverts par le type couvrant au sens de UIMA, c-à-d en terme de priorité des types (cf. [la javadoc de TypePriorities] ou cet email).

Considérons une annotation A qui couvre des annotations B de la manière suivante :

Il y a du texte et les annotations sont sur ce texte ...
[-----A:1-----]   [---A:2---]  [--------A:3--------]
 [B:1] [B:2]       [B:3]        [B:4]  [B:5] [B:6]

Dans l'exemple ci-dessus, nous sommes intéressés par les annotations B couvertes par l'annotation A:3, en d'autres termes les annotations B:4, B:5 et B:6.

La méthode est la suivante :

On récupère un pointeur sur l'annotation couvrante qui nous intéresse (A:3), à l'aide d'un itérateur par exemple ;
On récupére l'index des annotations couvertes (les B) ;
On appelle la méthode subiterator de l'index des annotations couvertes (B) en passant en paramètre l'annotation couvrante (A:3), la méthode nous retourne un itérateur sur les annotations B couvertes par A:3, soit B:4, B:5 et B:6.

Voici le code correspondant :

// Récupération des index
AnnotationIndex annAIdx = (AnnotationIndex) jcas.getAnnotationIndex(A.type);
AnnotationIndex annBIdx = (AnnotationIndex) jcas.getAnnotationIndex(B.type);
// On recherche ''A:3''
FSIterator annAIt = annAIdx.iterator();
while (annAIt.hasNext()) {
  A monA3 = (A) annAIt.next();
  // On récupére l'itérateur sur les annotations B couvertes par A3
  FSIterator annBSousA3It = annBIdx.subiterator(monA3);
  while (annBSousA3It.hasNext()) {
    // On récupére successivement B4, B5 et B6
    B annB = (B) annBSousA3It.next();
    System.out.println("Sous A3 : "+annB);
  }
}

Utilisation des contraintes (FSMatchConstraint)

Lorsque l'on ne connaît pas les priorités des types ou bien qu'elles ne correspondent pas à ce que l'on souhaite faire, il est nécessaire de passer par un mécanisme plus complexe (mais beaucoup plus puissant) : le système de contraintes d'index.

Dans le cas présent, nous allons définir une contrainte imposant que les attributs begin et end d'une annotation d'un type donné correspondent à une certaine valeur : celle de l'annotation couvrante. Puis nous pourrons générer un itérateur qui retournera les annotations de l'index qui respectent cette contrainte.

Voici l'implémentation d'une méthode qui fait cela :

/**
 * 
 * This method provides an iterator over typed annotations that either 
 * have an offset embedded in that of a given annotation in a document, 
 * or have the same offset as these annotation. 
 * 
 * @param theDocument  the document in which stand the source and
 *                                         target annotations
 * @param theAnnotation  the source annotation under which target 
 *                                         annotations that have to be drawn out
 * @param theType            the type of the target annotations that have 
 *                                         to be drawn out from the document under 
 *                                         the source annotation
 * @param isStrict              the boolean that defines the offset matching,
 *                                         offsets strictly equal if isStrict is true, begin 
 *                                         offsets greater or equal and end offsets less 
 *                                         or equal otherwise.  	
 * @return                           the iterator over the type theType annotations 
 *                                          which stand under the annotation theAnnotation 
 *                                          in the document theDocument 
 * 
 * @author Fabien Poulard
 * @author Jérôme Rocheteau
 * 
 * @license Apache 2.0
 */
public FSIterator subiterator(JCas theDocument, Annotation theAnnotation,Type theType,boolean isStrict) {
	// Ajout: déclaration de la variable type
	Type theAnnotationType = theAnnotation.getType();
	// On utilise le constraint factory
	ConstraintFactory theConstraints = theDocument.getConstraintFactory();
	// On définit les contraintes sur le début de l'annotation
	FSIntConstraint beginConstraint = theConstraints.createIntConstraint();
	if (isStrict) { 
		beginConstraint.eq(theAnnotation.getBegin());
	} else {
		beginConstraint.geq(theAnnotation.getBegin()); 
	}
	Feature beginFeature = theAnnotationType.getFeatureByBaseName("begin");
	FeaturePath beginPath = theDocument.createFeaturePath();
	beginPath.addFeature(beginFeature);
	FSMatchConstraint begin = theConstraints.embedConstraint(beginPath,beginConstraint);
	// ... puis sur la fin de l'annotation
	FSIntConstraint endConstraint = theConstraints.createIntConstraint();
	if (isStrict) {
		endConstraint.eq(theAnnotation.getEnd());
	} else {
		endConstraint.leq(theAnnotation.getEnd());
	}
	Feature endFeature = theAnnotationType.getFeatureByBaseName("end");
	FeaturePath endPath = theDocument.createFeaturePath();
	endPath.addFeature(endFeature);
	FSMatchConstraint end = theConstraints.embedConstraint(endPath, endConstraint);
	// JR: on définit une contrainte sur le type d'annotation
	FSTypeConstraint typeConstraint = theConstraints.createTypeConstraint();
	typeConstraint.add(theType); // 
	FeaturePath typePath = theDocument.createFeaturePath();
	FSMatchConstraint type = theConstraints.embedConstraint(typePath, typeConstraint);
	// On combine les contraintes
	FSMatchConstraint beginAndEnd = theConstraints.and(type,theConstraints.and(begin, end));
	// On génère un itérateur respectant ces contraintes
	FSIterator filteredIterator =
	theDocument.createFilteredIterator(theDocument.getAnnotationIndex().iterator(), beginAndEnd);
	return filteredIterator;
}

Cette méthode prend en paramètre le JCas dans lequel travailler, l'annotation couvrante (l'annotation A3 dans l'exemple précédent), le type d'annotation qui nous intéresse (le type B pour reprendre l'exemple précédent) et un booléen qui permet de préciser si l'on souhaite une correspondance exacte ou approximative des frontières.

Tests unitaires pour UIMA avec UUTUC

Fabien Poulard — Tue, 16 Mar 2010 15:45:00 +0100

La qualité du code développé dans le cadre des activités de recherche scientifique n'est pas toujours aussi bon qu'on pourrait l'espérer. Outre la nécessité (évidente à mes yeux) d'ouvrir le codes des activités scientifiques financées par l'État et les collectivités territoriales, il est également nécessaire de suivre de bonnes pratiques de programmation. L'écriture de tests unitaires et leur exécution régulière est une de ces bonnes pratiques.

Je présente dans ce billet un cas d'utilisation de la bibliothèque UUTUC, présentée lors du Workshop sur l'Ingénierie Logiciel, les Tests et l'Assurance Qualité pour le Traitement des Langues Naturelles (SETQA-NLP 2009), pour tester l'implémentation d'une bibliothèque développée et utilisée dans le cadre de ma thèse (tddts-uima-shingling).

Principe de UUTUC

UUTUC est une bibliothèque offrant un certain nombre de méthodes facilitant le processus de test des composants UIMA. On y trouve notamment un certain nombre de classes de type Factory qui facilitent la mise en place de chaînes de traitement simples pour expérimenter les composants.

À l'aide de ces classes, l'exécution d'un AE sur un simple fichier texte se résume à ces quelques lignes :

AnalysisEngine engine = 
  AnalysisEngineFactory.createAnalysisEngineFromPath("descriptors/tutorial/ex1/RoomNumberAnnotator.xml");
JCas jCas = 
  AnalysisEngineFactory.process(engine, "data/WatsonConferenceRooms.txt");

Le couplage de UUTUC avec JUnit permet de mettre en place un banc de tests unitaires :

Afin de tester la conformité de l'implémentation avec les spécifications attendues ;
Prévenir les problèmes de régression lors de l'évolution des composants

Écriture de tests unitaires

J'utilise le framework JUnit 4 pour les tests unitaires. Il suffit de faire précéder les méthodes considérées comme des tests par @Test pour qu'elles soient reconnues comme telles par JUnit. Exemple :

import org.junit.Test;
import static org.junit.Assert.*;
...
/**
 * This class defines the tests for the main methods of the Shingle class.
 */
public class ShingleTest {
  ...
  /**
   * This method just checks that the isComplete method works
   * @throws InvalidShingleException 
   * @throws OverloadShingleException 
   */
  @Test
  public void completeness() throws InvalidShingleException, OverloadShingleException {
	Shingle s1 = new Shingle(2);
	assertFalse( s1.isComplete() ); // before any adding
	s1.add( theShingleItems[0] );
	assertFalse( s1.isComplete() ); // after a first adding
	s1.add( theShingleItems[0] );
	assertTrue( s1.isComplete() ); // should be complete by now
  }
  ...
}

Combiné à UUTUC, il permet de mettre en place un environnement UIMA assez simplement. Ainsi dans l'exemple ci-dessous, nous définissons une méthode à exécuter avant chaque test (@Before) qui crée un JCas et y ajoute quelques annotations à l'aide des Factory de UUTUC :

/** Static data for testing */
private static String CAS_CONTENT = 
   "Suisse : inauguration d'une nouvelle synagogue, une première depuis 50 ans";
private static Integer[][] CAS_OFFSETS = { {0,6}, {9,21}, {22,24}, {24,27}, 
   {28,36}, {37,46}, {48,51}, {52,60}, {61,67}, {68,74} };
...
/**
 * This method is used to set up the testing environment, creating the
 * data necessary for the different tests methods.
 */
@Before 
public void setUp() throws UIMAException, IOException, ShinglingTestingException {
	// Set up a CAS with a couple of shingle items in
	TypeSystemDescription tsd = TypeSystemDescriptionFactory
			.createTypeSystemDescription("shingling-ts");
	theTestingCas = JCasFactory.createJCas(tsd);
	theTestingCas.setDocumentText(CAS_CONTENT);
	for(Integer[] idx: CAS_OFFSETS) {
		AnnotationFactory.createAnnotation(theTestingCas, 
						idx[0], idx[1], ShingleItem.class) );
	}
}

Malheureusement il y a assez peu de documentation concernant UUTUC. Il est ainsi régulièrement nécessaire d'aller jeter un œil au code source qui heureusement est très bien écrit.

Intégration avec Maven

Maven modélisant toutes les étapes du cycle de développement, il intègre une étape test entre le compile et le package. La gestion des tests unitaires se faisant quant à eux au travers du plugin maven-surefire-plugin.

Il faut tout d'abord rajouter dans le pom.xml les informations de dépendance sur UUTUC et JUnit :

<repository>
  <snapshots>
    <enabled>false</enabled>
  </snapshots>
  <id>uutuc-googlecode</id>
  <name>uutuc Google Code repository</name>
  <url>http://uutuc.googlecode.com/svn/repo/</url>
</repository>
...
<!-- UUTUC for testing -->
<dependency>
  <groupId>org.uutuc</groupId>
  <artifactId>uutuc</artifactId>
  <version>0.9.10</version>
  <optional>false</optional>
  <scope>test</scope>
</dependency>
<!-- JUnit 4 for testing -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.3.1</version>
  <scope>test</scope>
</dependency>

Il suffit ensuite de faire appel au plugin maven-surefire-plugin qui prend en charge tout ce qui concerne les tests, sous réserve que ces derniers soient bien présents dans src/test/java :

<!-- Testing -->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <configuration>
    <reportFormat>brief</reportFormat>
    <useFile>false</useFile>
  </configuration>
</plugin>

Il est alors possible de lancer l'exécution des tests avec Maven :

$ mvn test
...
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running tddts.uima.shingling.ShingleTest
Tests run: 16, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 3.992 sec

Results :

Tests run: 16, Failures: 0, Errors: 0, Skipped: 0
...

Plus d'excuse pour ne pas tester votre code maintenant ! L'excuse de faire du prototypage pour la recherche n'en est pas une bonne dès que les résultats que vous publiez dépendent de la qualité dudit code. C'est votre intégrité et honnêteté scientifique qui est en jeux ;)