Blog d'un jeune (chercheur) entrepreneur en TAL - Tag - nltk

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 :

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 ! :)

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 :)

Tokenisation en mots avec NLTK

Fabien Poulard — Wed, 05 Mar 2008 14:39:00 +0100

Le toolkit NLTK intègre plusieurs algorithmes permettant de découper un texte en mots. Ce billet présente plusieurs d'entre eux.

Un point sur la tokenisation

La tokenisation est l'opération de segmenter un acte langagier en unités "atomiques" : les tokens. Les tokenisations les plus courantes sont le découpage en mots ou bien en phrases. Ainsi la tokenisation en mots de la phrase Tout le monde attendait une véritable furia rouge. nous donnerait les composants mots : Tout, le, monde, attendait, une, véritable, furia, rouge, ..

En traitement automatique des langues (TAL), la tokenisation est surtout utilisée lors des prétraitements afin d'identifier des unités de "haut niveau" sur lesquelles porteront l'analyse. De plus, le terme "tokenisation" est couramment associé à l'idée de "découpage en mots", soit une analyse morphologique des actes langagiers.

Nous nous intéressons par la suite aux outils disponibles au sein de NLTK pour réaliser une segmentation en mots.

Tokenisation avec NLTK

Nous allons utiliser le langage Python, et notamment le package NLTK, pour tokeniser en mots. Avant toute chose, il est nécessaire d'ouvrir une console python et d'importer nltk à l'aide de la commande import nltk :

Python 2.5.1 (r251:54863, Oct  5 2007, 13:36:32) 
[GCC 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import nltk

Si vous obtenez un message d'erreur comme ci-dessous, c'est que le paquet nltk n'est pas installé ou bien que Python n'arrive pas à le trouver. Cette page devrait vous permettre de résoudre le problème.

>>> import nltk
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named nltk

Nous allons travailler sur deux textes, le premier en anglais et le second en français. Les textes en anglais posent assez peu de problèmes alors que ceux en français nous confrontent à certaines subtilités. Ces deux textes sont issus de wikipédia et peuvent donc être utilisés, diffusés ou modifiés librement en accord avec la licence GFDL.

Stockons le texte en français dans la variable txt_fr :

>>> txt_fr = u"""
Rapidement, ils ont été fondus avec un alliage de plomb (80 %), d’antimoine (5 %) 
et d'étain (15 %) dans des matrices. L’ouvrier typographe se servait d’un composteur 
sur lequel il alignait les caractères, lus à l’envers, de gauche à droite, piochés dans 
une boîte appelée « casse ». Les caractères du haut de la casse étaient appelés les 
capitales (majuscules) et ceux du bas — les minuscules — les bas-de-casse."""

... et celui en anglais dans la variable txt_en :

>>> txt_en = u"""
Monty Python, or The Pythons, is the collective name of the creators of Monty Python's 
Flying Circus, a British television comedy sketch show that first aired on the BBC on 5 
October 1969. A total of 45 episodes were made over four series. The Python phenomenon 
developed from the original television series into something much larger in scope and impact."""

Découpage naïf avec split

Dans le formalisme Python, les deux chaînes unicodes précédentes sont en réalité des instances de la classe unicode. Cette classe possède une méthode split() qui permet d'éclater la chaîne en une liste de composants à partir d'un caractère séparateur passé en paramètre. Si jamais aucun séparateur n'est spécifié, les caractères correspondant à des espaces sont utilisés comme séparateurs.

>>> txt_fr.split()
[u'Rapidement,', u'ils', u'ont', ...]

>>> txt_en.split()
[u'Monty', u'Python,', u'or', u'The', ...]

Cette approche naïve de découpage à l'aide des séparateurs espaces fonctionne globalement plutôt bien, excepté lorsque des éléments ponctuatifs sont accolés aux mots. Pour la suite, il est nécessaire de définir des mesures d'évaluation de la qualité de la tokenisation en mots. Nous utilisons des mesures régulièrement en TALN :

la précision : proportion, parmi les mots identifiés, de mots corrects ;
le rappel : proportion, parmi les mots attendus, de mots identifiés.

Étant donné que nous manipulons des listes, nous pouvons adopter une approche ensembliste dans la définition des mesures de précision et de rappel. Ainsi, avec W le résultat attendu de la segmentation en mots et T le résultat calculé, on pose :

Précision(T, W) = |T ⋂ W| / |T|
Rappel(T, W) = |T ⋂ W| / |W|

Ce qui nous donne, en tenant compte du fait que nous manipulons des listes et non des ensembles, l'implémentation ci-dessous. Notez toutefois que le calcul des mesures est approximative, mais suffisamment précise pour nos besoins. Une version exacte devrait être utilisé pour une évaluation scientifiquement correcte et précise.

def metrics(lstcomp, lstref) :
    card_intersec = 0.0 # force à utiliser la division non entière
    for t in set(lstcomp) :
        card_intersec += min(lstref.count(t), lstcomp.count(t))
    precision = card_intersec/len(lstcomp)
    rappel = card_intersec/len(lstref)
    return (precision, rappel)

Le calcul de ces mesures nécessite d'avoir une tokenisation de référence. Afin de vous éviter le fastidieux travail de tokenisation à la main, voici ci-dessous les deux tokenisations de référence que j'ai utilisé par la suite :

Pour le texte en français :

>>> ref_toks_fr = [u'Rapidement', u',', u'ils', u'ont', u'\xe9t\xe9', u'fondus', u'avec', u'un', u'alliage', u'de', 
u'plomb', u'(', u'80 %', u')', u',', u'd\u2019', u'antimoine', u'(', u'5 %', u')', u'et', u'd\'', u'\xe9tain', u'(', u'15 %', u')',
u'dans', u'des', u'matrices', u'.', u'L\u2019', u'ouvrier', u'typographe', u'se', u'servait', u'd\u2019', u'un',
u'composteur', u'sur', u'lequel', u'il', u'alignait', u'les', u'caract\xe8res', u',', u'lus', u'\xe0', u'l\u2019', 
u'envers', u',', u'de', u'gauche', u'\xe0', u'droite', u',', u'pioch\xe9s', u'dans', u'une', u'bo\xeete', u'appel\xe9e',
u'\xab', u'casse', u'\xbb', u'.', u'Les', u'caract\xe8res', u'du', u'haut', u'de', u'la', u'casse', u'\xe9taient', 
u'appel\xe9s', u'les', u'capitales', u'(', u'majuscules', u')', u'et', u'ceux', u'du', u'bas', u'\u2014', u'les', 
u'minuscules', u'\u2014', u'les', u'bas', u'-', u'de', u'-', u'casse', u'.']

... et pour le texte en anglais :

>>> ref_toks_en = [u'Monty', u'Python', u',', u'or', u'The', u'Pythons', u',', u'is', u'the', u'collective', u'name',
u'of', u'the', u'creators', u'of', u'Monty', u'Python', u'\'s', u'Flying', u'Circus', u',', u'a', u'British', u'television',
u'comedy', u'sketch', u'show', u'that', u'first', u'aired', u'on', u'the', u'BBC', u'on', u'5', u'October', u'1969',
u'.', u'A', u'total', u'of', u'45', u'episodes', u'were', u'made', u'over', u'four', u'series', u'.', u'The', u'Python', 
u'phenomenon', u'developed', u'from', u'the', u'original', u'television', u'series', u'into', u'something', 
u'much', u'larger', u'in', u'scope', u'and', u'impact', u'.']

L'application de nos mesures montre clairement que l'utilisation de split est plus efficace sur l'anglais que sur le français, la différence entre les deux tokenisations étant importantes autant en terme de précision (74% pour le français, contre 88% pour l'anglais), que de rappel (57% pour le français, contre 79% pour l'anglais). Notons toutefois que le texte en français est un peu plus compliqué que celui en anglais. L'utilisation d'un corpus parallèle nous permettrait une comparaison plus exacte des résultats.

>>> metrics(txt_fr.split(), ref_toks_fr)
(0.74647887323943662, 0.56989247311827962)

>>> metrics(txt_en.split(), ref_toks_en)
(0.8833333333333333, 0.79104477611940294)

Les résultats de l'algorithme naïf, bien qu'encourageant, peuvent être améliorés, notamment en employant des automates pour repérer des structures particulières telles que les données numériques, les sigles, ...

Utilisation d'expressions régulières

Si les langues naturelles ne sont pas des langages réguliers, les mots les composant peuvent l'être. NLTK offre une classe RegexpTokenizer qui permet d'effectuer une tokenisation à partir d'une description des tokens par le biais d'une expression régulière. Dans la théorie des automates, les expressions régulières sont capables de reconnaître les langages réguliers, tout comme les automates déterministe à états finis.

À partir de l'expérimentation précédente, nous allons utiliser un expression régulière qui définit plusieurs types de mots :

les mots composés uniquement de lettres ;
les contractions des mots outils (l', d', ...) ;
les pourcentages ;
les nombres ;
les éléments ponctuatifs et signes diacritiques (tout ce qui n'est ni espace, ni alphanumérique).

Cette catégorisation dépend bien entendu de la langue, et n'est pas exhaustive (prise en compte des monnaies, sigles, ...).

Nous utilisons la possibilité dans Python de structurer les expressions régulières de manière plus compréhensible à l'aide de l'instruction (?x). Pour en savoir plus sur les expressions régulières dans Python, se référer à la documentation de référence.

>>> tok2 = nltk.RegexpTokenizer(r'''(?x)
          \d+(\.\d+)?\s*%   # les pourcentages
        | \w'               # les contractions d', l', ...
        | \w+               # les mots pleins
        | [^\w\s]           # les ponctuations
        ''')

La simple utilisation d'une typologie des mots et l'écriture de règles en conséquence nous permet d'augmenter significativement les performances, notamment en terme de rappel, pour chacune des langues. Ainsi la précision est de 92% pour le français (97% pour l'anglais) et la précision de 96% (99% pour l'anglais).

>>> metrics(tok2.tokenize(txt_fr), ref_toks_fr)
(0.91752577319587625, 0.956989247311828)

>>> metrics(tok2.tokenize(txt_en), ref_toks_en)
(0.97058823529411764, 0.9850746268656716)

Intéressons nous aux cas problématiques, i.e. les mots qui ne sont pas correctement identifiés. Pour l'anglais il s'agit des marques d'appartenance en 's. En effet, ces dernières sont spécifiques à l'anglais et n'ont pas été prises en compte dans la mise au point de notre expression régulière plus particulièrement adaptée au français. Pour le français, le problème provient des apostrophes unicodes.

>>> set(ref_toks_en).difference(tok2.tokenize(txt_en))
set([u"'s"])

>>> set(ref_toks_fr).difference(tok2.tokenize(txt_fr))
set([u'd\u2019', u'L\u2019', u'l\u2019'])

Le tokeniseur ci-dessous prend en compte les résultats de notre expérimentation précédente. L'introduction de caractères unicodes complique largement l'écriture de l'expression régulière.

>>> reg_words = r'''(?x)
          \d+(\.\d+)?\s*%   # les pourcentages
        | 's                # l'appartenance anglaise 's
        | \w'               # les contractions d', l', j', t', s'
        '''
>>> reg_words += u"| \w\u2019"      # version unicode
>>> reg_words += u"|\w+|[^\w\s]" # avec les antislashs
>>> tok3 = nltk.RegexpTokenizer(reg_words)

>>> metrics(tok3.tokenize(txt_en), ref_toks_en)
(1.0, 1.0)

>>> metrics(tok3.tokenize(txt_fr), ref_toks_fr)
(1.0, 1.0)

Nous obtenons ainsi une tokénisation parfaite. Bien entendu, cette performance est à relativiser par rapport à la taille de notre échantillon. Si vous souhaitez obtenir une évaluation plus intéressante - et que vous avez une quelques cycles calculs à dépenser - vous pouvez tester le nouveau tokenizer sur le Brown Corpus qui est intégré à NLTK :

>>> metrics(tok3.tokenize(nltk.corpus.brown.raw()),
            nltk.corpus.brown.words())

NLTK et la loi de Zipf (Traduction et Reprise de ACM Crossroads)

Fabien Poulard — Sun, 10 Feb 2008 18:36:00 +0100

Ce billet reprend partiellement l'article du journal ACM Crossroads sur NLTK. Il illustre le potentiel du toolkit NLTK (Natural Language Toolkit) pour Python en montrant l'application de la loi de Zipf sur le corpus Gutenberg.

Loi de Zipf

La loi de Zipf, du nom de George Kingsley Zipf, correspond à l'observation empirique de la distribution de la fréquence des mots dans un texte.

L'observation de G. K. Zipf est que les textes sont constitués d'un grand nombre de mots qui apparaissent peut de fois et au contraire d'un petit nombre de mots très fréquents dans le texte. En d'autres termes, la fréquence (f) d'un mot dans un texte est corrélée à son rang (f(n)) par une loi du type : f(rang) x rang = K avec K une constante.

Nous allons tenter de vérifier l'application de cette loi sur le corpus Gutenber, un des corpus distribués avec NLTK.

Script Python utilisant NLTK

La version de NLTK utilisée au sein lors de la rédaction de l'article contenu dans le ACM Crossroad semble un petit peu ancien. Voici donc une version actualisée qui devrait fonctionner avec les dernières versions du Toolkit :

>>> from nltk.corpus import gutenberg
>>> from nltk.probability import FreqDist
>>> from nltk.draw.plot import Plot
>>> fd = FreqDist()
>>> for word in gutenberg.words():
...        fd.inc(word)
...
>>> ss = fd.sorted()
>>> points = []
>>> for index,word in enumerate(ss):
...     points.append( (index+1, fd[word]) ) 
...
>>> Plot(points, scale='log').mainloop()

La première partie du script permet simplement de permettre au script d'accéder à quelques éléments du toolkit tel que :

le corpus Gutenberg ;
la classe FreqDist permettant de comptabiliser des entités et extraire des informations de distribution de ces entités ;
l'objet Plot permettant de tracer un graphique à partir des données que nous aurons extraites ;

>>> from nltk.corpus import gutenberg
>>> from nltk.probability import FreqDist
>>> from nltk.draw.plot import Plot

La seconde partie du code permet dans un premier temps d'instancier la classe FreqDist.

>>> fd = FreqDist()

Nous utilisons l'objet obtenu (fd) pour comptabiliser chacun des mots du corpus. Ce corpus est composé de plusieurs textes. Nous pouvons accéder aux identifiants de ces textes par le biais de la méthode items :

>>> gutenberg.items
('austen-emma', 'austen-persuasion', 'austen-sense', 'bible-kjv', 'blake-poems', 'blake-songs', 'chesterton-ball', 'chesterton-brown',
 'chesterton-thursday', 'milton-paradise', 'shakespeare-caesar', 'shakespeare-hamlet', 'shakespeare-macbeth', 'whitman-leaves')

L'article original parcourait les textes un par un en utilisant la méthode raw. Ceci est incorrect car raw donne accès au contenu du texte comme une chaîne de caractères. Nous choisissons d'utiliser la méthode words qui retourne la liste des mots du corpus dans leur ordre chronologique d'apparition.

>>> for word in gutenberg.words():
...       fd.inc(word)

La classe FreqDist est extrêmement pratique pour calculer une distribution des éléments d'un texte. Les méthodes de la classe permettent d'obtenir rapidement des informations sur cette distribution :

>>> fd.max()
','
>>> fd[',']
146772
>>> fd.Nr(146772)
1
>>> fd['.']
57046
>>> fd.freq('.')
0.027755950431840863

Ainsi, pour connaître les dix mots les plus présents dans le corpus et leur fréquence respective :

>>> for w in fd.sorted()[:10]:
...     print "%3s : %0.2f%%" % (w, fd.freq(w)*100)
... 
  , : 7.14%
the : 4.87%
and : 3.17%
 of : 2.85%
  . : 2.78%
  : : 2.28%
 to : 1.69%
 in : 1.21%
  I : 1.14%
  a : 1.13%

La dernière partie du script compile les informations de la distribution des mots sous la forme de coordonnées (x,y) avec :

x le rang du mot
y la fréquence du mot dans le corpus

Pour calculer le rang du mot, on extrait une version classée par fréquence décroissante de l'objet fd que l'on transforme en enumerable grâce à la fonction enumerate de Python. Un énumérable de la séquence seq est une liste de tuples du type : (0, seq[0]) (1, seq[1]) .... Il suffit donc d'ajouter 1 au premier éléments des tuples pour obtenir le rang :

>>> ss = fd.sorted()
>>> points = []
>>> for index,word in enumerate(ss):
...     points.append( (index+1, fd.freq(word)) ) 
...

La dernière étape consiste à tracer un graphe à partir de cette liste de coordonnées grâce à la classe Plot :

>>> Plot(points, scale='log').mainloop()