Le traitement automatique des langues naturelles

1. Introduction

a. Présentation

Le traitement automatique du langage (TAL) est avant tout utilisé sur des langages formels. Il s’agit d’une application d’un domaine des mathématiques qui s’attache à définir des « langages » avec des grammaires formelles : un ensemble de règles permettant de construire, de valider, d’interpréter, etc. des « textes » au sens très large du terme.

Les langages informatiques sont un type de langage formel. Les compilateurs et interpréteurs sont des programmes dédiés à l’analyse d’un code source pour un langage donné.

Les langages formels sont à opposer aux « langages naturels », les langages utilisés « naturellement par les humains », c’est-à-dire qui ont évolué selon les usages, les régions, etc. au cours des siècles. Les « langues » utilisées pour communiquer telles que le français, l’anglais, etc. font partie du langage naturel.

Le traitement automatique du langage naturel (TALN) hérite évidemment des techniques et méthodes appliquées aux langages formels. Cependant, la nature des objets étudiés rend le processus bien plus complexe.

La validation grammaticale d’une instruction Python est d’une simplicité difficilement qualifiable comparée à la validation grammaticale d’une phrase écrite en français.

Un langage naturel demande donc un ensemble de techniques et d’objets particuliers pour son analyse. L’utilisation de dictionnaires (par exemple un ensemble de mots, associés ou non à des propriétés), aussi appelés corpus, est très répandue. Des techniques de « racinisation » (stemming en anglais) sont aussi développées selon les langues.

La racinisation consiste à extraire le radical (ou la racine) d’une entité lexicale (typiquement un mot). Cela signifie identifier la partie commune à un ensemble de versions déclinées, accordées, conjuguées, etc. d’un même terme. Par exemple, en français...

Modélisation de sujet avec LDA et LSI

1. Extraire une liste de mots d’un texte

a. Analyse lexicale ou tokenization

L’un des prétraitements nécessaires à l’utilisation des algorithmes présentés dans ce chapitre est la transformation d’un texte en liste de mots. Cette étape de transformation d’un texte en liste d’entités lexicales (appelées « tokens ») peut être effectuée à l’aide des fonctions du module nltk.tokenize. La fonction wordpunct_tokenize() permet de transformer un texte (l’instance de str passée en argument) en liste de mots et de caractères de ponctuation.

Bien que ce problème puisse sembler trivial au premier abord, il se révèle en réalité plus compliqué qu’il n’y paraît. Il est possible de télécharger l’ensemble « punkt » qui contient un algorithme non supervisé pour effectuer cette opération (et un modèle pré-entraîné pour l’anglais).

Exemples d’utilisation de wordpunct_tokenize()

>>> from nltk.tokenize import wordpunct_tokenize 
>>> txt1 = "Une phrase d'exemple." 
>>> wordpunct_tokenize(txt1) 
['Une', 'phrase', 'd', "'", 'exemple', '.'] 
>>> txt2 = """Une phrase d'exemple. 
... Mais qui est, cette fois, à l'intérieur d'un texte 
... plus complexe.""" 
>>> wordpunct_tokenize(txt2) 
['Une', 'phrase', 'd', "'", 'exemple', '.', 'Mais', 'qui', 'est', ',', 
'cette', 'fois', ',', 'à', 'l', "'", 'intérieur', 'd', "'", 'un', 'texte', 
'plus', 'complexe', '.']

Le module nltk.tokenize propose aussi la séparation d’un texte en liste de phrases avec la fonction sent_tokenize(). Cependant, les algorithmes présentés dans ce chapitre n’utilisent que le nombre d’occurrences d’un mot dans un texte, la notion de phrase...

Exemples d’application

1. Depuis l’historique d’un navigateur web

a. Réutilisation de l’analyse de l’historique

De la même manière que le module ui.utils du chapitre Partitionnement automatique de données a été réutilisé, le package navhisto du chapitre Analyser un historique de navigation web le sera aussi.

Il faut rappeler que ce package contient un ensemble de classes permettant d’accéder au contenu des historiques des navigateurs web. Et d’un système de mise en cache du contenu récupéré en ligne. Ces fonctionnalités seront utilisées ici comme source de documents texte.

Dans la suite de ce chapitre, il sera considéré que le package navhisto a été inclus au package courant, que ce soit par une copie ou par un lien symbolique.

b. Adaptation de l’interface d’extraction

Le module corpus va devoir implémenter un ensemble de fonctions dédiées à la transformation d’une liste d’URL en liste de vecteurs TF-IDF. La première étape est donc d’écrire une fonction de conversion d’URL vers une liste de mots.

Il faut se rappeler que l’opération de récupération en ligne est coûteuse en temps, de même que le traitement d’un document HTML. Cette méthode sera donc appelée par les workers d’un Pool du module multiprocessing. L’utilisation du cache sera encore une fois soumise à une initialisation à la création du sous-processus.

Cette fois, la fonction globals() qui procure l’accès aux dictionnaires des variables globales sera utilisée pour stocker l’instance de navhisto.UrlCache.

from bs4 import BeautifulSoup 
 
from .navhisto import UrlCache 
[...] 
 
def url2text(url): 
   """ Retourne une liste de mots associée à une URL 
       Arguments : 
           url -- l'URL à analyser 
   """ 
   cache = globals()['cache'] 
   status, html = cache.get(url) 
   doc = BeautifulSoup(html, features="html.parser") 
   [x.extract() for x in doc.findAll(('style'...

Extraire les sujets d'un ensemble de textes