Wiki du LAMA (UMR 5127) - Contributions [fr]

Fouille de données textuelles à partir des "Exercices de style" de R. Queneau

2018-05-26T18:23:08Z

Bouvier :

La '''fouille de données''', également appelée forage de données, analyse de données ou encore ''data mining'', consiste en l'extraction d'information à partir d'une quantité importante de données. Pour cela, on utilise un ensemble d'algorithmes issus de différentes disciplines scientifiques comme les statistiques ou l'informatique par exemple. Le but de ces algorithmes est de permettre, en fonction de différents critères, d'extraire un maximum de connaissances d'une grande quantité de données. L'analyse de données est très utilisée dans le monde professionnel dans des domaines variés tels que la détection de fraudes, la gestion des relations avec les clients, l'optimisation des sites web ou encore l'analyse de la consommation. Elle a pour but de souligner les relations entre les données (points communs, différences...) afin d'en tirer seulement les informations les plus intéressantes. Les résultats de l'utilisation des algorithmes d'analyse de données sont souvent sous forme de représentations graphiques qui permettent de mettre en évidence les informations.

L'analyse de données textuelles est une spécialisation de la fouille de données et repose sur les même principes, seulement elle utilise des algorithmes spécialisés ayant pour but d'obtenir de l'information à partir d'un texte ou d'un corpus de textes.

A travers un corpus de textes, nous expliquerons notamment les techniques de TF/IDF permettant d'extraire les mots significatifs du corpus. Toutes les fonctions et procédures dont nous aurons besoin ici seront écrites en Python.

== Présentation du corpus de textes traité ==

Ici, nous présenterons différentes techniques de fouille de données textuelles à partir de l'ouvrage ''« Exercices de style »'' de Raymond Queneau. Ce livre, publié en 1947, raconte 99 fois la même histoire de manière différente à chaque fois. Cet ouvrage est un exemple d'une contrainte littéraire utilisée en tant que moteur créatif et est un des premiers textes du mouvement Oulipo dont Raymond Queneau sera l'un des membres les plus importants. Le mouvement Oulipo (Ouvroir de littérature potentielle) est un groupe de littéraires et de mathématiciens qui se définissent comme des « rats qui construisent eux-mêmes le labyrinthe dont ils se proposent de sortir. » Les membres de l'Oulipo réfléchissait autour de la notion de « contrainte » afin d'écrire de nouveaux ouvrages ayant pour but d'encourager la création.

L'histoire de base du texte de Raymond Queneau se résume en quelques lignes :

''« Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »''

Un fichier contenant tous les textes du corpus sera disponible en annexe.

== Traitement préliminaire du corpus de textes ==

=== Gestion de la ponctuation, des majuscules et des sauts de ligne ===

Pour être exploité, le corpus de textes doit d'abord être traité au préalable, afin de permettre une utilisation simplifiée des algorithmes d'analyse de données. En effet, des éléments comme la ponctuation, les sauts de ligne ou encore les majuscules/minuscules peuvent compliquer l'utilisation des algorithmes ceux-ci ne sont pas traités en amont. Il est donc nécessaire de créer une procédure permettant de gérer ces éléments. Celle-ci devra gérer les aspects suivants : le remplacement de toutes les majuscules du texte par des minuscules, ainsi que le remplacement de la ponctuation et des sauts de ligne par le caractère « » (un espace). Elle prendra en argument un fichier texte que l'on souhaite modifier, ainsi qu'un numéro de fichier (afin de faciliter la gestion lorsque l'on possède un grand nombre de fichier) et écrira le texte modifié dans un nouveau fichier nommé <code>"modif{:03}.txt".format(i)</code> . Vous pouvez trouver ci-dessous le code en Python d'une telle procédure :

<pre>
def modification_texte(fichier_in,i):
"""
fichier_in : nom du fichier à modifier
i : numéro du fichier
"""

ponctuation = [",",";",":",".","?","!","«","»","(",")","\"","…","'","-","’"]
f_in = open(fichier_in, mode = "r")
f_out = open(("modif{:03}.txt".format(i)), mode = "w")
ligne = "initialisation"
while (ligne != "") : #Tant que la fin du fichier n'est pas atteinte.
ligne = f_in.readline()
ligne = ligne.lower()
for c in ligne :
if (c in ponctuation) or (c == "\n") :
f_out.write(" ")
else :
f_out.write(c)
f_in.close()
f_out.close()
</pre>

On peut également créer une procédure qui prend en argument un dossier de fichiers à modifier et qui exécute la procédure présentée ci-dessus sur tous les fichiers de ce dossier (cela permet de gérer l'intégralité du corpus de textes).

<pre>
def modification_texte_dossier(dossier_in):
"""
dossier_in : dossier de fichiers à modifier.
"""
import os
os.chdir(dossier_in)
liste_fichiers = os.listdir(dossier_in)
for i in range (len(liste_fichiers)):
modification_texte(liste_fichiers[i],i+1)
</pre>

Pour les toutes les fonctions décrites ci-dessous, on utilisera les textes modifiés (sans ponctuation, sans majuscules et sans sauts de ligne).

=== Création de fonctions utiles pour la fouille de données textuelles ===

Nous allons avoir besoin de créer quelques fonctions de base, très utiles pour l'utilisation des algorithmes d'analyse de données textuelles.

Il est donc nécessaire de créer une fonction qui permet de compter le nombre de mots total du corpus de texte, afin de savoir quelle quantité de données il faudra gérer. La fonction suivante permet de compter le nombre de mots d'un fichier. Elle prend en paramètre un fichier texte et renvoie le nombre de mots contenus dans ce fichier.

<pre>
def compte_mots(fichier):
"""
fichier : fichier texte sur lequel on doit compter le nombre de mots qu'il contient
"""
f = open(fichier, mode = "r")
mots = []
ligne = f.readline()
ligne2 = ligne.split()
mots = mots + ligne2
f.close()
return len(mots)
</pre>

Il faut donc maintenant créer une fonction qui parcourt l'intégralité du corpus afin de connaître le nombre de mots total que contient celui-ci. Cette fonction prend en paramètre un dossier de fichiers textes (le corpus) et renvoie le nombre total de mots contenus dans les fichiers textes de ce dossier.

<pre>
def compte_mots_dossier(dossier):
"""
dossier : dossier de fichier texte (corpus de textes complet)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
total = 0
for i in range (len(liste_fichiers)):
total = total + compte_mots(liste_fichiers[i])
return total
</pre>

En utilisant cette fonction, on peut savoir que le corpus traité contient 14755 mots.

Il est également nécessaire de créer une fonction qui stocke tous les mots du corpus dans un tableau (chaque mot n'apparaît qu'une seule fois dans le tableau). On crée donc d'abord une fonction qui stocke tous les mots d'un fichier. Celle-ci prendra en argument un fichier texte et renverra un tableau contenant chaque mot du fichier texte (pas de doublons dans le tableau).

<pre>
def stocke_mots_fichier(fichier):
"""
fichier texte duquel on souhaite tirer une liste de mots
"""
tab = []
f = open(fichier, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
if not (c in tab) :
tab.append(c)
f.close()
return tab
</pre>

Comme précédemment, on a donc maintenant besoin d'une fonction qui puisse parcourir l'intégralité du corpus de texte. Celle-ci prend en paramètre un dossier de fichiers (le corpus de textes) et renvoie un tableau contenant tous les mots du corpus, chaque mot n’apparaissant qu'une seule fois.

<pre>
def stocke_mots_dossier(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes complet)
"""
tab = []
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
for f in liste_fichiers:
tab_fichier = stocke_mots_fichier(f)
for c in tab_fichier :
if not (c in tab):
tab.append(c)
return tab
</pre>

Nous avons donc maintenant l'intégralité des mots du corpus stockés dans un tableau (disponible en annexe). En utilisant la commande <code>len(stocke_mots_dossier(dossier))</code>, on obtient que le corpus contient 3774 mots différents les uns des autres.

== Première approche : comptage du nombre d'apparition de chaque mot dans le corpus ==

=== Présentation de la méthode sur 1 texte ===

La première méthode à laquelle on pense pour tirer de l'information d'un grand nombre de données textuelles est de regarder le nombre de fois que chaque mot apparaît dans le corpus. Prenons un exemple sur le texte suivant :

<pre>
Le texte de base.

Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus.
</pre>

Dans ce texte, les termes qui apparaissent le plus souvent sont :
* « un » apparaît 10 fois.
* « le » apparaît 5 fois.
* « de » apparaît 3 fois.
* « il» apparaît 3 fois.
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.

Les informations obtenues ne sont donc pas très intéressantes car elle ne permettent pas de dégager les mots spécifiques à ce texte. En effet, avec cette méthode, on obtiendra principalement les mots outils de la langue française, qui n'ont pas spécialement grand intérêt du fait qu'ils sont présents dans la quasi-totalité des textes et que nous cherchons à définir les mots spécifiques à un texte. Ce que nous pouvons faire pour palier à ce problème est de définir manuellement une liste de mots-outils (disponible en annexe) qui ne seront pas pris en compte dans le comptage des mots. Le problème de cette liste est qu'elle doit être définie à la main par l'utilisateur.

Si l'on néglige la présence de ces mots-outils dans le texte, voici la liste des termes qui apparaissent le plus souvent :
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.
* « voyageur » apparaît 2 fois.

Les autres mots du texte sont des mots-outils où n'apparaissent qu'une seule fois : il n'est donc pas intéressant de les retenir. Nous obtenons donc une liste de mots spécifiques à ce texte qui permet de dégager quelques informations à propos de ce dernier : on sait qu'il parle d'un « homme » et d'un « voyageur » et on peut supposer qu'au moins l'un des deux est qualifié de « jeune ».

Nous avons donc pu tirer une information plus concise du texte à partir de l'intégralité des mots qui le compose.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Il est donc nécessaire d'avoir une fonction qui calcule le nombre d’occurrences de chaque mot dans le corpus. Cette fonction prendra en paramètre un dossier de fichiers textes (le corpus de textes complet) et renverra un dictionnaire avec comme clés les mots contenus dans les fichiers et comme valeurs le nombre de fois où apparaît le mot associé.

<pre>
def occurrence_mots(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
occurrences = {}
for t in liste_fichiers :
f = open(t, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
occurrences[c] = occurrences.get(c,0)+1
f.close()
return occurrences
</pre>

Il est maintenant nécessaire d'afficher les mots dont l'occurrence est la plus élevée. Pour cela nous aurons besoin d'une procédure qui prend en paramètres le corpus de textes et un entier n et qui affiche la liste des n mots apparaissant le plus dans le corpus (donc affichés selon l'ordre décroissant des occurrences).

<pre>
def affiche_occurrence_décroissant(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
for i in range (0,min(n,len(tab))):
print("Mot {:03} : '{:30} fréquence : {:03}".format(i+1,tab[i][0] + "\'",tab[i][1]))
</pre>

Grâce à cette procédure nous obtenons que les mots qui apparaissent le plus souvent dans le corpus sont (la liste des 50 premiers mots est disponible en annexe) :
* « un » apparaît 575 fois.
* « de » apparaît 457 fois.
* « la » apparaît 294 fois.
* « et » apparaît 275 fois.
* « il » apparaît 274 fois.
* ...

Comme sur l'exemple avec un seul texte, ce sont les mots-outils de la langue française qui apparaissent le plus dans ce corpus (ils sont même davantage mis en avant car le corpus de texte étant plus long, les mots-outils sont encore plus utilisés), ce qui ne nous apporte pas grand chose comme information sur les spécificités du corpus.

Il est donc nécessaire de créer une procédure similaire à la précédente, qui permette de gérer les mots-outils. Celle-ci doit avoir pour arguments un dossier contenant les textes du corpus ainsi qu'un entier n, comme la précédente. Elle affichera la liste des n mots qui apparaissent le plus dans le corpus, sans les mots-outils (la liste de ceux-ci était entrée manuellement) et sans les mots de taille égale à 1 caractère que l'on considère comme non pertinents.

<pre>
def affiche_occurrence_décroissant2(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : entier représentant le nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
i = 0
numero_mot = 1
while (numero_mot <= n) and (i < len(tab)) :
if (((tab[i][0]) not in mots_outils) and (len(tab[i][0]) > 1)) :
print("Mot {:03} : '{:30} fréquence : {:03}".format(numero_mot,tab[i][0] + "\'",tab[i][1]))
numero_mot = numero_mot + 1
i = i+1
</pre>

Si l'on exécute cette fonction, voici la liste des termes qui apparaissent le plus souvent dans le corpus (la liste des 50 premiers mots est disponible en annexe) :
* « autobus » apparaît 93 fois.
* « chapeau » apparaît 69 fois.
* « long » apparaît 66 fois.
* « cou » apparaît 66 fois.
* « devant » apparaît 64 fois.
* « bouton » apparaît 58 fois.
* « jeune » apparaît 52 fois.
* « tard » apparaît 51 fois.
* « place » apparaît 51 fois.
* « homme » apparaît 48 fois.
Les données obtenues sont donc plus pertinentes et nous donnent plus d'information sur l'histoire racontée dans le corpus. En effet, on peut par exemple déduire que l'« autobus » le « chapeau » ou encore le « bouton » sont des éléments centraux de l'histoire car ils apparaissent de nombreuses fois dans le corpus.

Cette méthode permet donc d'avoir une vue d'ensemble sur ce dont parlent les textes, mais le principal inconvénient est qu'il faille rentrer une liste de mots-outils de la langue française, sachant que celle-ci n'est pas fixée et peu plus ou moins varier selon les textes analysés.

== Méthode des TF-IDF ==
Cette méthode permet justement de gérer automatiquement les mots-outils d'un corpus, sans que l'utilisateur ait besoin de rentrer une liste au préalable.

=== Présentation de la méthode sur une quantité de données réduite ===

Dans cette partie, nous utiliserons les textes suivants, l'exemple portera sur le texte 3.

*Texte 1 :

<pre>
Rétrograde.

Tu devrais ajouter un bouton à ton pardessus, lui dit son ami. Je le rencontrai au milieu de la cour de Rome, après l'avoir quitté se précipitant avec avidité vers une place assise. Il venait de protester contre la poussée d'un autre voyageur, qui, disait-il, le bousculait chaque fois qu'il descendait quelqu'un. Ce jeune homme décharné était porteur d'un chapeau ridicule. Cela se passa sur la plate-forme d'un S complet ce midi-là.
</pre>

*Texte 2 :

<pre>
Distinguo.

Dans un autobus (qu'il ne faut pas prendre pour un autre obus), je vis (et pas avec mon vit) un personnage (qui ne perd son âge) coiffé d'un feutre mou bleu (et non de foutre blême), feutre cerné d'un fil tressé (et non de tril fessé). Il disposait (et non dix posait) d'un long cou (et pas d'un loup con). Comme la foule se bousculait (non que la boule se fousculât), un nouveau voyageur (non veau nouillageur) déplaça le susdit (et non suça ledit plat). Cestuy râla (et non cette huître hala), mais voyant une place libre (et non ployant une vache ivre) s'y précipita (et non si près s'y piqua).
Plus tard je l'aperçus (non pas gel à peine su) devant la gare Saint-Lazare (et non là ou l'hagard ceint le hasard) qui parlait avec un copain (il n'écopait pas d'un pralin) au sujet d'un bouton de son manteau (qu'il ne faut pas confondre avec le bout haut de son menton).
</pre>

*Texte 3 :

<pre>
Passé indéfini.

Je suis monté dans l'autobus de la porte Champerret. Il y avait beaucoup de monde, des jeunes, des vieux, des femmes, des militaires. J'ai payé ma place et puis j'ai regardé autour de moi. Ce n'était pas très intéressant. J'ai quand même fini par remarquer un jeune homme dont j'ai trouvé le cou trop long. J'ai examiné son chapeau et je me suis aperçu qu'au lieu d'un ruban il y avait un galon tressé. Chaque fois qu'un nouveau voyageur montait, ça faisait de la bousculade. Je n'ai rien dit, mais le jeune homme au long cou a tout de même interpellé son voisin. Je n'ai pas entendu ce qu'il lui a dit, mais ils se sont regardés d'un sale oeil. Alors, le jeune homme au long cou est allé s'asseoir précipitamment. En revenant de la porte Champerret, je suis passé devant la gare Saint-Lazare.
J'ai vu mon type qui discutait avec un copain. Celui-ci a désigné du doigt un bouton juste au-dessus de l'échancrure du pardessus. Puis l'autobus m'a emmené et je ne les ai plus vus. J'étais assis et je n'ai pensé à rien.
</pre>

==== Le TF ====

Le TF (''Term-Frequency'') d'un terme, autrement appelé la fréquence « brute » est précisément le nombre d’occurrences de ce terme dans un texte. Par abus de langage, on parle de « fréquence ». Comme cette méthode a déjà été vue précédemment, nous nous contenterons ici de calculer le TF pour des mots qui nous serviront d'exemple pour la suite et d'introduire une fonction qui permettra de calculer le TF d'un mot dans un texte.
Pour le texte 3, on a donc :
* Pour le mot « un », <math>TF = 7</math>
* Pour le mot « de », <math>TF = 7</math>
* Pour le mot « homme », <math>TF = 3</math>
* Pour le mot « autobus », <math>TF = 2</math>
* Pour le mot « pardessus », <math>TF = 1</math>
* Pour le mot « ruban », <math>TF = 1</math>
Nous retrouvons donc le même problème que précédemment où les mots-outils sont mis en avant.

Le code de la fonction qui permet de calculer le TF d'un mot dans un texte est disponible ci-dessous :

<pre>
def calcul_TF(fichier,mot):
"""
fichier : fichier texte que l'on va parcourir
mot : chaîne de caractères dont on souhaite compter le nombre d'apparitions
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
f = open(fichier, mode = "r")
ligne = f.readline()
Freq = ligne.count(mot)
f.close()
return Freq
</pre>

==== L'IDF ====

Pour palier au problème que pose le TF, nous introduisons l'IDF. En effet, avec la méthode des TF, tous les termes qui apparaissent dans un document avec la même fréquence auront la même importance. Or, les termes qui se trouvent dans peu de documents permettent de mieux différencier ces derniers des textes dans lesquels ils se trouvent en nombre élevé. Ces termes ont donc un pouvoir de discrimination plus grand que celui des termes apparaissant dans beaucoup de documents. L'IDF (''inverse document frequency'') est une mesure de l'importance du terme dans l'ensemble du corpus. La formule de l'idf est la suivante :

<math>idf_{t}=\ln{\frac{N}{df_{t}}} </math>
* où <math>N</math> est le nombre total de documents dans le corpus
* et <math>df_{t}</math> le nombre de documents où le terme <math>t</math> apparaît (on doit avoir <math>df_{t} \ne 0 </math>, autrement dit le mot doit se trouver dans au moins un texte du corpus)

On cherchera donc d'abord à créer une fonction qui permette de calculer le df d'un mot dans un corpus de textes. Cette fonction prend en arguments un dossier de fichiers textes (le corpus de documents) et un mot pour lequel on souhaite calculer le df. Elle renvoie le df de ce mot, c'est-à-dire le nombre de fichiers où ce mot apparaît.

<pre>
def calcul_df(dossier,mot):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre le df
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
nombre_doc = 0
for c in liste_fichiers :
f = open(c, mode = "r")
texte = f.readline()
if mot in texte :
nombre_doc = nombre_doc + 1
f.close()
return nombre_doc
</pre>

La fonction qui permet de calculer l'idf d'un terme est donc définie simplement de la manière suivante :
<pre>
def calcul_idf(dossier,mot,nombre_docs):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre l'idf
nombre_docs : entier représentant le nombre de documents du corpus
"""
return log(nombre_docs / (calcul_df(dossier,mot)))
</pre>

En utilisant ces fonctions, on peut donc avoir l'idf des mots du texte 3 pour lesquels nous avons calculé le tf précédemment (dans l'exemple, le nombre total de documents est de 3) :
* Pour le mot « un », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « de », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « homme », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « autobus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « pardessus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « ruban », <math>idf=\ln{\frac{3}{1}} \approx 1,099</math>

==== Le TF-IDF ====

Le TF-idf s'obtient en multipliant les deux valeurs obtenues :

<math>TFidf_{t} = TF_{t} \times idf_{t} </math>

où <math>t</math> est le terme pour lequel on calcule le TF-idf.

Pour l'exemple précédent (texte 3), on a donc :
* Pour le mot « un », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « de », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « homme », <math>TFidf = 3 \times 0,405 = 1,215</math>
* Pour le mot « autobus », <math>TFidf = 2 \times 0,405 = 0,81</math>
* Pour le mot « pardessus », <math>TFidf = 1 \times 0,405 = 0,405</math>
* Pour le mot « ruban », <math>TFidf = 1 \times 1,099 = 1,099</math>

On obtient donc les mots par ordre de pertinence : homme, autobus, pardessus, un, de. Cela a permis de supprimer les mots-outils qui se trouvaient dans les 3 documents et de faire ressortir d'autres mots importants.

Le mot « homme » a le TF-idf le plus élevé, car il apparaît 3 fois dans le texte 3 et apparaît uniquement dans 2 textes sur 3 du corpus.

Le mot « ruban » a un TF-idf plus élevé que les mots « autobus » et « pardessus » alors qu'il n’apparaît qu'une seule fois dans le texte 3, mais c'est parce qu'il n’apparaît que dans le texte 3, ce qui montre bien que le TF-idf permet de mettre en avant les spécificités de chaque texte.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Nous allons commencer par écrire une fonction qui permette de calculer l'intégralité des TF de chaque mot, texte par texte. Pour cela, nous aurons besoin des fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_TF(fichier,mot)</code> vues précédemment. Cette fonction devra prendre en argument un dossier de fichiers textes (le corpus de textes) et renverra une matrice rectangulaire qui contient sur chaque ligne le TF de chaque mot du corpus pour un texte donné. Le matrice devra donc avoir 100 lignes et 3774 colonnes et sera donc de la forme suivante :

<math> \begin{pmatrix} TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ ... & ... & ... & ... & ... \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \end{pmatrix} </math>

La première ligne représentant le 1er texte, la deuxième le 2ème, etc...

<pre>
def tf_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Création de la matrice rectangulaire
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice rectangulaire
for i in range (len(liste_fichiers)) :
fichier = liste_fichiers[i]
for j in range (len(liste_mots)) :
mot = liste_mots[j]
TF = calcul_TF(fichier,mot)
mat[i][j] = TF
return mat
</pre>

La matrice totale étant plutôt grande, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes :

<math> \begin{pmatrix} 5 & 1 & 3 & 1 & 10 & ... \\ 4 & 0 & 2 & 0 & 5 & ... \\ 4 & 0 & 8 & 0 & 9 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Il est également nécessaire de construire une fonction qui permette d'avoir l'idf de chaque mot dans le corpus. Nous utiliserons donc les fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_idf(dossier,mot,nombre_docs)</code>. Cette fonction a pour paramètre un dossier de fichiers textes (le corpus de textes) et renvoie un tableau qui contient l'idf de chaque mot apparaissant dans le corpus (le corpus contenant 3774 mots différents, la longueur de ce tableau est de 3774).

<pre>
def idf_par_mot(dossier):
""""
dossier : dossier de fichiers textes (corpus complet)
"""

os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier) #3774
T = [0]*len(liste_mots)
for i in range (len(T)):
mot = liste_mots[i]
idf = calcul_idf(dossier,mot,nombre_docs=100)
T[i] = idf
return T
</pre>

Voici un aperçu du résultat obtenu pour les premiers mots ("le", "texte", "de", "base", "un", "voyageur", "attend", "bus"). Les résultats sont arrondis au centième:

<math> \begin{pmatrix} 0.22 & 4.61 & 0.13 & 4.61 & 0.12 & 2.04 & 4.61 & 3.00 & ... \end{pmatrix} </math>

Maintenant que nous avons la matrice des TF et le tableau des idf de chaque mot, nous pouvons créer une fonction qui calculera le TF-idf de chaque mot. Celle-ci prendra en argument un dossier contenant des fichiers textes (le corpus de textes) et renverra une matrice qui contiendra le TF-idf de chaque mot pour chaque texte et qui sera de la même taille (100x3774) et de la même forme que celle des TF.

<pre>
def matrice_TFidf(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Initialisation de la matrice finale
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice finale
matrice_TF = tf_par_texte(dossier)
tableau_idf = idf_par_mot(dossier)
for i in range (len(matrice_TF)):
for j in range (len(matrice_TF[i])):
mat[i][j] = ((matrice_TF[i][j])*(tableau_idf[j]))
return mat
</pre>

La matrice finale étant trop grande pour apparaître ici, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes. Les résultats sont arrondis au centième :

<math> \begin{pmatrix} 1.12 & 4.61 & 0.38 & 4.61 & 1.17 & ... \\ 0.89 & 0.00 & 0.26 & 0.00 & 0.58 & ... \\ 0.89 & 0.00 & 1.02 & 0.00 & 0.105 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Les résultats n'étant pas facilement visibles sous forme de matrice, on peut maintenant créer une procédure qui permettra de mieux les visualiser. Cette procédure prend en argument le corpus de textes et renvoie les 10 TF-idf les plus élevés de chaque texte du corpus.

<pre>
def Top10_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""
os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier)
matrice = matrice_TFidf(dossier)
for i in range (len(matrice)):
print("Texte {:03}".format(i+1))
for j in range (10):
liste_TFidf = matrice[i]
TFidf_max = max(liste_TFidf)
position = liste_TFidf.index(TFidf_max)
mot = liste_mots[position]
print("{:02}. Mot : {:30} TFidf = {:10}".format(j+1,mot,str(TFidf_max)))
matrice[i][position] = 0
print("\n \n")
</pre>

La liste étant relativement longue, elle sera disponible en annexe et les résultats de cette procédure pour quelques textes seront exploités dans la partie suivante.

=== Exemples qui permettent de souligner les spécificités de certains textes du corpus ===

La liste des 10 TF-idf les plus élevés de chaque texte du corpus permet de mettre en avant les spécificités des différents textes.

En effet, pour le texte 098, on obtient la liste suivante :

<pre>
Texte 098
01. Mot : heu TFidf = 13.815510557964275
02. Mot : oh TFidf = 13.815510557964275
03. Mot : eh TFidf = 10.519673691959945
04. Mot : peuh TFidf = 7.824046010856292
05. Mot : ah TFidf = 7.013115794639964
06. Mot : tiens TFidf = 5.318520073865556
07. Mot : interjections TFidf = 4.605170185988092
08. Mot : psst TFidf = 4.605170185988092
09. Mot : hum TFidf = 4.605170185988092
10. Mot : ouf TFidf = 4.605170185988092
</pre>

Grâce à cette liste, on peut supposer que ce texte est écrit uniquement à l'aide d'« interjections », mot qui apparaît d'ailleurs à la 7ème place. Cela peut donc donner une idée de comment le texte est écrit sans même avoir à le lire. En effet, si on lit le texte 98, on peut vérifier que nos suppositions sont vraies.

<pre>
Interjections.
Psst ! heu ! ah ! oh ! hum ! ah ! ouf ! eh ! tiens ! oh ! peuh ! pouah ! ouïe ! ou ! aïe ! eh ! hein ! heu ! pfuitt !
Tiens ! eh ! peuh ! oh ! heu ! bon !
</pre>

Autre exemple, si on choisit le texte 045, on obtient la liste suivante :

<pre>
Texte 045
01. Mot : scène TFidf = 23.472138032568875
02. Mot : premier TFidf = 14.026231589279927
03. Mot : acte TFidf = 13.815510557964275
04. Mot : drelin TFidf = 13.815510557964275
05. Mot : voyageur TFidf = 12.241324971159328
06. Mot : ii TFidf = 11.736069016284437
07. Mot : monnaie TFidf = 9.210340371976184
08. Mot : i TFidf = 8.987196820661973
09. Mot : second TFidf = 7.824046010856292
10. Mot : comédie TFidf = 7.824046010856292
</pre>

Nous remarquons plusieurs mots comme "scène", "acte", "ii", "premier" qui se rapportent au vocabulaire utilisé dans les pièces de théâtre. Si on regarde le texte correspondant à cette liste, on peut voir que son titre est "comédie", qui apparaît dans la liste à la 10ème position et qu'il est effectivement écrit sous la forme d'une pièce de théâtre :

<pre>
Comédie.
Acte premier
Scène I
(Sur la plate-forme arrière d'un autobus S, un jour, vers midi.)
Le Receveur. -la monnaie, s'iou plaît. (Des voyageurs lui passent la monnaie.)
Scène II
(L'autobus s'arrête.)
Le Receveur. - laissons descendre. Priorités ? Une priorité ! C'est complet. Drelin, drelin, drelin.
Acte second
Scène I
(Même décor.)
Premier Voyageur (Jeune, long cou, une tresse autour du chapeau).
- On dirait, monsieur, que vous le faites exprès de me marcher sur les pieds chaque fois qu'il passe des
gens. Second Voyageur (hausse les épaules)
Scène II
(Un troisième voyageur descend.)
Premier Voyageur (s'adressant au public) : Chouette ! une place libre ! J'y cours. (Il se précipite dessus et
l'occupe.)
Acte troisième
Scène I
(La Cour de Rome.)
Un Jeune Élégant (au premier voyageur, maintenant piéton). -l'échancrure de ton pardessus est trop
large. Tu devrais la fermer un peu en faisant remonter le bouton du haut.
Scène II
(À bord d'un autobus S passant devant la cour de Rome.)
Quatrième Voyageur. -Tiens, le type qui se trouvait tout à l'heure avec moi dans l'autobus et qui
s'engueulait avec un bonhomme. Curieuse rencontre. J'en ferai une comédie en trois actes et en prose.
</pre>

La méthode des TF-idf permet donc bien de mettre en avant les différences qu'il peut y avoir entre les textes.

== Conclusion ==
Ici a été présentée la méthode des TF-idf car elle est puissante et que c'est une technique fondamentale de la fouille de données, mais il existe de nombreuses autres méthodes qui peuvent permettent d'arriver à des résultats différents selon les caractéristiques que l'on souhaite mettre en avant. Il existe par exemple des variantes du TF-idf qui permettent de mieux gérer les cas où les textes du corpus ont des tailles extrêmement différentes les uns des autres ou encore les techniques de LDA qui permettent d'extraire automatiquement les thématiques d'un corpus afin de construire des regroupements par thème.

Page réalisée par Rémi Bouvier, étudiant en L1 CMI-Info (2017-2018), dans le cadre du cours de VISI201.

Tuteur : Laurent Vuillon

== Annexes ==

* [http://www.mediafire.com/file/xafo0xzc49ba6va/Exercices_de_style.txt Textes du corpus]
* [http://www.mediafire.com/file/ni07ftjd3w0bn9c/Liste_mots_corpus.txt Liste des mots du corpus]
* [http://www.mediafire.com/file/riboz97iahtehoe/Liste_mots-outils.txt Liste des mots-outils] inspirée de [https://www.ranks.nl/stopwords/french cette liste].
* [http://www.mediafire.com/file/gzd435ccm3m04wc/50_mots_premi%C3%A8re_approche.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus]
* [http://www.mediafire.com/file/8tb1n5gktqt3d8j/50_mots_premi%C3%A8re_approche_sans_mots_outils.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus sans mots-outils]
* [http://www.mediafire.com/file/749cfscgnsh7n0k/50_premiers_TFidf.txt/file Top 50 des mots ayant le TFidf le plus élevé]
* [http://www.mediafire.com/file/k5n5n8nwpca52s6/Top10_TF_IDF_par_texte.txt/file Top 10 des TFidf les plus élevés pour chaque texte]
* [http://www.mediafire.com/file/07argu9or5ruu6r/code_python.py Code python complet]

== Sources ==

Wikipedia :

*[https://fr.wikipedia.org/wiki/Exploration_de_donn%C3%A9es Exploration de données]
*[https://fr.wikipedia.org/wiki/Analyse_des_donn%C3%A9es Analyse de données]
*[https://fr.wikipedia.org/wiki/TF-IDF TF-IDF]

Livre :
* ''"Recherche d'information : applications, modèles et algorithmes; Data mining, décisionnel et big data"'' de Amini et Gaussier aux éditions Eyrolles.

Fouille de données textuelles à partir des "Exercices de style" de R. Queneau

2018-05-26T18:18:36Z

Bouvier : Ajout de 2 annexes

La '''fouille de données''', également appelée forage de données, analyse de données ou encore ''data mining'', consiste en l'extraction d'information à partir d'une quantité importante de données. Pour cela, on utilise un ensemble d'algorithmes issus de différentes disciplines scientifiques comme les statistiques ou l'informatique par exemple. Le but de ces algorithmes est de permettre, en fonction de différents critères, d'extraire un maximum de connaissances d'une grande quantité de données. L'analyse de données est très utilisée dans le monde professionnel dans des domaines variés tels que la détection de fraudes, la gestion des relations avec les clients, l'optimisation des sites web ou encore l'analyse de la consommation. Elle a pour but de souligner les relations entre les données (points communs, différences...) afin d'en tirer seulement les informations les plus intéressantes. Les résultats de l'utilisation des algorithmes d'analyse de données sont souvent sous forme de représentations graphiques qui permettent de mettre en évidence les informations.

L'analyse de données textuelles est une spécialisation de la fouille de données et repose sur les même principes, seulement elle utilise des algorithmes spécialisés ayant pour but d'obtenir de l'information à partir d'un texte ou d'un corpus de textes.

A travers un corpus de textes, nous expliquerons notamment les techniques de TF/IDF permettant d'extraire les mots significatifs du corpus. Toutes les fonctions et procédures dont nous aurons besoin ici seront écrites en Python.

== Présentation du corpus de textes traité ==

Ici, nous présenterons différentes techniques de fouille de données textuelles à partir de l'ouvrage ''« Exercices de style »'' de Raymond Queneau. Ce livre, publié en 1947, raconte 99 fois la même histoire de manière différente à chaque fois. Cet ouvrage est un exemple d'une contrainte littéraire utilisée en tant que moteur créatif et est un des premiers textes du mouvement Oulipo dont Raymond Queneau sera l'un des membres les plus importants. Le mouvement Oulipo (Ouvroir de littérature potentielle) est un groupe de littéraires et de mathématiciens qui se définissent comme des « rats qui construisent eux-mêmes le labyrinthe dont ils se proposent de sortir. » Les membres de l'Oulipo réfléchissait autour de la notion de « contrainte » afin d'écrire de nouveaux ouvrages ayant pour but d'encourager la création.

L'histoire de base du texte de Raymond Queneau se résume en quelques lignes :

''« Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »''

Un fichier contenant tous les textes du corpus sera disponible en annexe.

== Traitement préliminaire du corpus de textes ==

=== Gestion de la ponctuation, des majuscules et des sauts de ligne ===

Pour être exploité, le corpus de textes doit d'abord être traité au préalable, afin de permettre une utilisation simplifiée des algorithmes d'analyse de données. En effet, des éléments comme la ponctuation, les sauts de ligne ou encore les majuscules/minuscules peuvent compliquer l'utilisation des algorithmes ceux-ci ne sont pas traités en amont. Il est donc nécessaire de créer une procédure permettant de gérer ces éléments. Celle-ci devra gérer les aspects suivants : le remplacement de toutes les majuscules du texte par des minuscules, ainsi que le remplacement de la ponctuation et des sauts de ligne par le caractère « » (un espace). Elle prendra en argument un fichier texte que l'on souhaite modifier, ainsi qu'un numéro de fichier (afin de faciliter la gestion lorsque l'on possède un grand nombre de fichier) et écrira le texte modifié dans un nouveau fichier nommé <code>"modif{:03}.txt".format(i)</code> . Vous pouvez trouver ci-dessous le code en Python d'une telle procédure :

<pre>
def modification_texte(fichier_in,i):
"""
fichier_in : nom du fichier à modifier
i : numéro du fichier
"""

ponctuation = [",",";",":",".","?","!","«","»","(",")","\"","…","'","-","’"]
f_in = open(fichier_in, mode = "r")
f_out = open(("modif{:03}.txt".format(i)), mode = "w")
ligne = "initialisation"
while (ligne != "") : #Tant que la fin du fichier n'est pas atteinte.
ligne = f_in.readline()
ligne = ligne.lower()
for c in ligne :
if (c in ponctuation) or (c == "\n") :
f_out.write(" ")
else :
f_out.write(c)
f_in.close()
f_out.close()
</pre>

On peut également créer une procédure qui prend en argument un dossier de fichiers à modifier et qui exécute la procédure présentée ci-dessus sur tous les fichiers de ce dossier (cela permet de gérer l'intégralité du corpus de textes).

<pre>
def modification_texte_dossier(dossier_in):
"""
dossier_in : dossier de fichiers à modifier.
"""
import os
os.chdir(dossier_in)
liste_fichiers = os.listdir(dossier_in)
for i in range (len(liste_fichiers)):
modification_texte(liste_fichiers[i],i+1)
</pre>

Pour les toutes les fonctions décrites ci-dessous, on utilisera les textes modifiés (sans ponctuation, sans majuscules et sans sauts de ligne).

=== Création de fonctions utiles pour la fouille de données textuelles ===

Nous allons avoir besoin de créer quelques fonctions de base, très utiles pour l'utilisation des algorithmes d'analyse de données textuelles.

Il est donc nécessaire de créer une fonction qui permet de compter le nombre de mots total du corpus de texte, afin de savoir quelle quantité de données il faudra gérer. La fonction suivante permet de compter le nombre de mots d'un fichier. Elle prend en paramètre un fichier texte et renvoie le nombre de mots contenus dans ce fichier.

<pre>
def compte_mots(fichier):
"""
fichier : fichier texte sur lequel on doit compter le nombre de mots qu'il contient
"""
f = open(fichier, mode = "r")
mots = []
ligne = f.readline()
ligne2 = ligne.split()
mots = mots + ligne2
f.close()
return len(mots)
</pre>

Il faut donc maintenant créer une fonction qui parcourt l'intégralité du corpus afin de connaître le nombre de mots total que contient celui-ci. Cette fonction prend en paramètre un dossier de fichiers textes (le corpus) et renvoie le nombre total de mots contenus dans les fichiers textes de ce dossier.

<pre>
def compte_mots_dossier(dossier):
"""
dossier : dossier de fichier texte (corpus de textes complet)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
total = 0
for i in range (len(liste_fichiers)):
total = total + compte_mots(liste_fichiers[i])
return total
</pre>

En utilisant cette fonction, on peut savoir que le corpus traité contient 14755 mots.

Il est également nécessaire de créer une fonction qui stocke tous les mots du corpus dans un tableau (chaque mot n'apparaît qu'une seule fois dans le tableau). On crée donc d'abord une fonction qui stocke tous les mots d'un fichier. Celle-ci prendra en argument un fichier texte et renverra un tableau contenant chaque mot du fichier texte (pas de doublons dans le tableau).

<pre>
def stocke_mots_fichier(fichier):
"""
fichier texte duquel on souhaite tirer une liste de mots
"""
tab = []
f = open(fichier, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
if not (c in tab) :
tab.append(c)
f.close()
return tab
</pre>

Comme précédemment, on a donc maintenant besoin d'une fonction qui puisse parcourir l'intégralité du corpus de texte. Celle-ci prend en paramètre un dossier de fichiers (le corpus de textes) et renvoie un tableau contenant tous les mots du corpus, chaque mot n’apparaissant qu'une seule fois.

<pre>
def stocke_mots_dossier(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes complet)
"""
tab = []
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
for f in liste_fichiers:
tab_fichier = stocke_mots_fichier(f)
for c in tab_fichier :
if not (c in tab):
tab.append(c)
return tab
</pre>

Nous avons donc maintenant l'intégralité des mots du corpus stockés dans un tableau (disponible en annexe). En utilisant la commande <code>len(stocke_mots_dossier(dossier))</code>, on obtient que le corpus contient 3774 mots différents les uns des autres.

== Première approche : comptage du nombre d'apparition de chaque mot dans le corpus ==

=== Présentation de la méthode sur 1 texte ===

La première méthode à laquelle on pense pour tirer de l'information d'un grand nombre de données textuelles est de regarder le nombre de fois que chaque mot apparaît dans le corpus. Prenons un exemple sur le texte suivant :

<pre>
Le texte de base.

Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus.
</pre>

Dans ce texte, les termes qui apparaissent le plus souvent sont :
* « un » apparaît 10 fois.
* « le » apparaît 5 fois.
* « de » apparaît 3 fois.
* « il» apparaît 3 fois.
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.

Les informations obtenues ne sont donc pas très intéressantes car elle ne permettent pas de dégager les mots spécifiques à ce texte. En effet, avec cette méthode, on obtiendra principalement les mots outils de la langue française, qui n'ont pas spécialement grand intérêt du fait qu'ils sont présents dans la quasi-totalité des textes et que nous cherchons à définir les mots spécifiques à un texte. Ce que nous pouvons faire pour palier à ce problème est de définir manuellement une liste de mots-outils (disponible en annexe) qui ne seront pas pris en compte dans le comptage des mots. Le problème de cette liste est qu'elle doit être définie à la main par l'utilisateur.

Si l'on néglige la présence de ces mots-outils dans le texte, voici la liste des termes qui apparaissent le plus souvent :
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.
* « voyageur » apparaît 2 fois.

Les autres mots du texte sont des mots-outils où n'apparaissent qu'une seule fois : il n'est donc pas intéressant de les retenir. Nous obtenons donc une liste de mots spécifiques à ce texte qui permet de dégager quelques informations à propos de ce dernier : on sait qu'il parle d'un « homme » et d'un « voyageur » et on peut supposer qu'au moins l'un des deux est qualifié de « jeune ».

Nous avons donc pu tirer une information plus concise du texte à partir de l'intégralité des mots qui le compose.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Il est donc nécessaire d'avoir une fonction qui calcule le nombre d’occurrences de chaque mot dans le corpus. Cette fonction prendra en paramètre un dossier de fichiers textes (le corpus de textes complet) et renverra un dictionnaire avec comme clés les mots contenus dans les fichiers et comme valeurs le nombre de fois où apparaît le mot associé.

<pre>
def occurrence_mots(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
occurrences = {}
for t in liste_fichiers :
f = open(t, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
occurrences[c] = occurrences.get(c,0)+1
f.close()
return occurrences
</pre>

Il est maintenant nécessaire d'afficher les mots dont l'occurrence est la plus élevée. Pour cela nous aurons besoin d'une procédure qui prend en paramètres le corpus de textes et un entier n et qui affiche la liste des n mots apparaissant le plus dans le corpus (donc affichés selon l'ordre décroissant des occurrences).

<pre>
def affiche_occurrence_décroissant(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
for i in range (0,min(n,len(tab))):
print("Mot {:03} : '{:30} fréquence : {:03}".format(i+1,tab[i][0] + "\'",tab[i][1]))
</pre>

Grâce à cette procédure nous obtenons que les mots qui apparaissent le plus souvent dans le corpus sont (la liste des 50 premiers mots est disponible en annexe) :
* « un » apparaît 575 fois.
* « de » apparaît 457 fois.
* « la » apparaît 294 fois.
* « et » apparaît 275 fois.
* « il » apparaît 274 fois.
* ...

Comme sur l'exemple avec un seul texte, ce sont les mots-outils de la langue française qui apparaissent le plus dans ce corpus (ils sont même davantage mis en avant car le corpus de texte étant plus long, les mots-outils sont encore plus utilisés), ce qui ne nous apporte pas grand chose comme information sur les spécificités du corpus.

Il est donc nécessaire de créer une procédure similaire à la précédente, qui permette de gérer les mots-outils. Celle-ci doit avoir pour arguments un dossier contenant les textes du corpus ainsi qu'un entier n, comme la précédente. Elle affichera la liste des n mots qui apparaissent le plus dans le corpus, sans les mots-outils (la liste de ceux-ci était entrée manuellement) et sans les mots de taille égale à 1 caractère que l'on considère comme non pertinents.

<pre>
def affiche_occurrence_décroissant2(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : entier représentant le nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
i = 0
numero_mot = 1
while (numero_mot <= n) and (i < len(tab)) :
if (((tab[i][0]) not in mots_outils) and (len(tab[i][0]) > 1)) :
print("Mot {:03} : '{:30} fréquence : {:03}".format(numero_mot,tab[i][0] + "\'",tab[i][1]))
numero_mot = numero_mot + 1
i = i+1
</pre>

Si l'on exécute cette fonction, voici la liste des termes qui apparaissent le plus souvent dans le corpus (la liste des 50 premiers mots est disponible en annexe) :
* « autobus » apparaît 93 fois.
* « chapeau » apparaît 69 fois.
* « long » apparaît 66 fois.
* « cou » apparaît 66 fois.
* « devant » apparaît 64 fois.
* « bouton » apparaît 58 fois.
* « jeune » apparaît 52 fois.
* « tard » apparaît 51 fois.
* « place » apparaît 51 fois.
* « homme » apparaît 48 fois.
Les données obtenues sont donc plus pertinentes et nous donnent plus d'information sur l'histoire racontée dans le corpus. En effet, on peut par exemple déduire que l'« autobus » le « chapeau » ou encore le « bouton » sont des éléments centraux de l'histoire car ils apparaissent de nombreuses fois dans le corpus.

Cette méthode permet donc d'avoir une vue d'ensemble sur ce dont parlent les textes, mais le principal inconvénient est qu'il faille rentrer une liste de mots-outils de la langue française, sachant que celle-ci n'est pas fixée et peu plus ou moins varier selon les textes analysés.

== Méthode des TF-IDF ==
Cette méthode permet justement de gérer automatiquement les mots-outils d'un corpus, sans que l'utilisateur ait besoin de rentrer une liste au préalable.

=== Présentation de la méthode sur une quantité de données réduite ===

Dans cette partie, nous utiliserons les textes suivants, l'exemple portera sur le texte 3.

*Texte 1 :

<pre>
Rétrograde.

Tu devrais ajouter un bouton à ton pardessus, lui dit son ami. Je le rencontrai au milieu de la cour de Rome, après l'avoir quitté se précipitant avec avidité vers une place assise. Il venait de protester contre la poussée d'un autre voyageur, qui, disait-il, le bousculait chaque fois qu'il descendait quelqu'un. Ce jeune homme décharné était porteur d'un chapeau ridicule. Cela se passa sur la plate-forme d'un S complet ce midi-là.
</pre>

*Texte 2 :

<pre>
Distinguo.

Dans un autobus (qu'il ne faut pas prendre pour un autre obus), je vis (et pas avec mon vit) un personnage (qui ne perd son âge) coiffé d'un feutre mou bleu (et non de foutre blême), feutre cerné d'un fil tressé (et non de tril fessé). Il disposait (et non dix posait) d'un long cou (et pas d'un loup con). Comme la foule se bousculait (non que la boule se fousculât), un nouveau voyageur (non veau nouillageur) déplaça le susdit (et non suça ledit plat). Cestuy râla (et non cette huître hala), mais voyant une place libre (et non ployant une vache ivre) s'y précipita (et non si près s'y piqua).
Plus tard je l'aperçus (non pas gel à peine su) devant la gare Saint-Lazare (et non là ou l'hagard ceint le hasard) qui parlait avec un copain (il n'écopait pas d'un pralin) au sujet d'un bouton de son manteau (qu'il ne faut pas confondre avec le bout haut de son menton).
</pre>

*Texte 3 :

<pre>
Passé indéfini.

Je suis monté dans l'autobus de la porte Champerret. Il y avait beaucoup de monde, des jeunes, des vieux, des femmes, des militaires. J'ai payé ma place et puis j'ai regardé autour de moi. Ce n'était pas très intéressant. J'ai quand même fini par remarquer un jeune homme dont j'ai trouvé le cou trop long. J'ai examiné son chapeau et je me suis aperçu qu'au lieu d'un ruban il y avait un galon tressé. Chaque fois qu'un nouveau voyageur montait, ça faisait de la bousculade. Je n'ai rien dit, mais le jeune homme au long cou a tout de même interpellé son voisin. Je n'ai pas entendu ce qu'il lui a dit, mais ils se sont regardés d'un sale oeil. Alors, le jeune homme au long cou est allé s'asseoir précipitamment. En revenant de la porte Champerret, je suis passé devant la gare Saint-Lazare.
J'ai vu mon type qui discutait avec un copain. Celui-ci a désigné du doigt un bouton juste au-dessus de l'échancrure du pardessus. Puis l'autobus m'a emmené et je ne les ai plus vus. J'étais assis et je n'ai pensé à rien.
</pre>

==== Le TF ====

Le TF (''Term-Frequency'') d'un terme, autrement appelé la fréquence « brute » est précisément le nombre d’occurrences de ce terme dans un texte. Par abus de langage, on parle de « fréquence ». Comme cette méthode a déjà été vue précédemment, nous nous contenterons ici de calculer le TF pour des mots qui nous serviront d'exemple pour la suite et d'introduire une fonction qui permettra de calculer le TF d'un mot dans un texte.
Pour le texte 3, on a donc :
* Pour le mot « un », <math>TF = 7</math>
* Pour le mot « de », <math>TF = 7</math>
* Pour le mot « homme », <math>TF = 3</math>
* Pour le mot « autobus », <math>TF = 2</math>
* Pour le mot « pardessus », <math>TF = 1</math>
* Pour le mot « ruban », <math>TF = 1</math>
Nous retrouvons donc le même problème que précédemment où les mots-outils sont mis en avant.

Le code de la fonction qui permet de calculer le TF d'un mot dans un texte est disponible ci-dessous :

<pre>
def calcul_TF(fichier,mot):
"""
fichier : fichier texte que l'on va parcourir
mot : chaîne de caractères dont on souhaite compter le nombre d'apparitions
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
f = open(fichier, mode = "r")
ligne = f.readline()
Freq = ligne.count(mot)
f.close()
return Freq
</pre>

==== L'IDF ====

Pour palier au problème que pose le TF, nous introduisons l'IDF. En effet, avec la méthode des TF, tous les termes qui apparaissent dans un document avec la même fréquence auront la même importance. Or, les termes qui se trouvent dans peu de documents permettent de mieux différencier ces derniers des textes dans lesquels ils se trouvent en nombre élevé. Ces termes ont donc un pouvoir de discrimination plus grand que celui des termes apparaissant dans beaucoup de documents. L'IDF (''inverse document frequency'') est une mesure de l'importance du terme dans l'ensemble du corpus. La formule de l'idf est la suivante :

<math>idf_{t}=\ln{\frac{N}{df_{t}}} </math>
* où <math>N</math> est le nombre total de documents dans le corpus
* et <math>df_{t}</math> le nombre de documents où le terme <math>t</math> apparaît (on doit avoir <math>df_{t} \ne 0 </math>, autrement dit le mot doit se trouver dans au moins un texte du corpus)

On cherchera donc d'abord à créer une fonction qui permette de calculer le df d'un mot dans un corpus de textes. Cette fonction prend en arguments un dossier de fichiers textes (le corpus de documents) et un mot pour lequel on souhaite calculer le df. Elle renvoie le df de ce mot, c'est-à-dire le nombre de fichiers où ce mot apparaît.

<pre>
def calcul_df(dossier,mot):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre le df
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
nombre_doc = 0
for c in liste_fichiers :
f = open(c, mode = "r")
texte = f.readline()
if mot in texte :
nombre_doc = nombre_doc + 1
f.close()
return nombre_doc
</pre>

La fonction qui permet de calculer l'idf d'un terme est donc définie simplement de la manière suivante :
<pre>
def calcul_idf(dossier,mot,nombre_docs):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre l'idf
nombre_docs : entier représentant le nombre de documents du corpus
"""
return log(nombre_docs / (calcul_df(dossier,mot)))
</pre>

En utilisant ces fonctions, on peut donc avoir l'idf des mots du texte 3 pour lesquels nous avons calculé le tf précédemment (dans l'exemple, le nombre total de documents est de 3) :
* Pour le mot « un », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « de », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « homme », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « autobus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « pardessus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « ruban », <math>idf=\ln{\frac{3}{1}} \approx 1,099</math>

==== Le TF-IDF ====

Le TF-idf s'obtient en multipliant les deux valeurs obtenues :

<math>TFidf_{t} = TF_{t} \times idf_{t} </math>

où <math>t</math> est le terme pour lequel on calcule le TF-idf.

Pour l'exemple précédent (texte 3), on a donc :
* Pour le mot « un », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « de », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « homme », <math>TFidf = 3 \times 0,405 = 1,215</math>
* Pour le mot « autobus », <math>TFidf = 2 \times 0,405 = 0,81</math>
* Pour le mot « pardessus », <math>TFidf = 1 \times 0,405 = 0,405</math>
* Pour le mot « ruban », <math>TFidf = 1 \times 1,099 = 1,099</math>

On obtient donc les mots par ordre de pertinence : homme, autobus, pardessus, un, de. Cela a permis de supprimer les mots-outils qui se trouvaient dans les 3 documents et de faire ressortir d'autres mots importants.

Le mot « homme » a le TF-idf le plus élevé, car il apparaît 3 fois dans le texte 3 et apparaît uniquement dans 2 textes sur 3 du corpus.

Le mot « ruban » a un TF-idf plus élevé que les mots « autobus » et « pardessus » alors qu'il n’apparaît qu'une seule fois dans le texte 3, mais c'est parce qu'il n’apparaît que dans le texte 3, ce qui montre bien que le TF-idf permet de mettre en avant les spécificités de chaque texte.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Nous allons commencer par écrire une fonction qui permette de calculer l'intégralité des TF de chaque mot, texte par texte. Pour cela, nous aurons besoin des fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_TF(fichier,mot)</code> vues précédemment. Cette fonction devra prendre en argument un dossier de fichiers textes (le corpus de textes) et renverra une matrice rectangulaire qui contient sur chaque ligne le TF de chaque mot du corpus pour un texte donné. Le matrice devra donc avoir 100 lignes et 3774 colonnes et sera donc de la forme suivante :

<math> \begin{pmatrix} TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ ... & ... & ... & ... & ... \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \end{pmatrix} </math>

La première ligne représentant le 1er texte, la deuxième le 2ème, etc...

<pre>
def tf_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Création de la matrice rectangulaire
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice rectangulaire
for i in range (len(liste_fichiers)) :
fichier = liste_fichiers[i]
for j in range (len(liste_mots)) :
mot = liste_mots[j]
TF = calcul_TF(fichier,mot)
mat[i][j] = TF
return mat
</pre>

La matrice totale étant plutôt grande, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes :

<math> \begin{pmatrix} 5 & 1 & 3 & 1 & 10 & ... \\ 4 & 0 & 2 & 0 & 5 & ... \\ 4 & 0 & 8 & 0 & 9 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Il est également nécessaire de construire une fonction qui permette d'avoir l'idf de chaque mot dans le corpus. Nous utiliserons donc les fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_idf(dossier,mot,nombre_docs)</code>. Cette fonction a pour paramètre un dossier de fichiers textes (le corpus de textes) et renvoie un tableau qui contient l'idf de chaque mot apparaissant dans le corpus (le corpus contenant 3774 mots différents, la longueur de ce tableau est de 3774).

<pre>
def idf_par_mot(dossier):
""""
dossier : dossier de fichiers textes (corpus complet)
"""

os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier) #3774
T = [0]*len(liste_mots)
for i in range (len(T)):
mot = liste_mots[i]
idf = calcul_idf(dossier,mot,nombre_docs=100)
T[i] = idf
return T
</pre>

Voici un aperçu du résultat obtenu pour les premiers mots ("le", "texte", "de", "base", "un", "voyageur", "attend", "bus"). Les résultats sont arrondis au centième:

<math> \begin{pmatrix} 0.22 & 4.61 & 0.13 & 4.61 & 0.12 & 2.04 & 4.61 & 3.00 & ... \end{pmatrix} </math>

Maintenant que nous avons la matrice des TF et le tableau des idf de chaque mot, nous pouvons créer une fonction qui calculera le TF-idf de chaque mot. Celle-ci prendra en argument un dossier contenant des fichiers textes (le corpus de textes) et renverra une matrice qui contiendra le TF-idf de chaque mot pour chaque texte et qui sera de la même taille (100x3774) et de la même forme que celle des TF.

<pre>
def matrice_TFidf(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Initialisation de la matrice finale
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice finale
matrice_TF = tf_par_texte(dossier)
tableau_idf = idf_par_mot(dossier)
for i in range (len(matrice_TF)):
for j in range (len(matrice_TF[i])):
mat[i][j] = ((matrice_TF[i][j])*(tableau_idf[j]))
return mat
</pre>

La matrice finale étant trop grande pour apparaître ici, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes. Les résultats sont arrondis au centième :

<math> \begin{pmatrix} 1.12 & 4.61 & 0.38 & 4.61 & 1.17 & ... \\ 0.89 & 0.00 & 0.26 & 0.00 & 0.58 & ... \\ 0.89 & 0.00 & 1.02 & 0.00 & 0.105 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Les résultats n'étant pas facilement visibles sous forme de matrice, on peut maintenant créer une procédure qui permettra de mieux les visualiser. Cette procédure prend en argument le corpus de textes et renvoie les 10 TF-idf les plus élevés de chaque texte du corpus.

<pre>
def Top10_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""
os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier)
matrice = matrice_TFidf(dossier)
for i in range (len(matrice)):
print("Texte {:03}".format(i+1))
for j in range (10):
liste_TFidf = matrice[i]
TFidf_max = max(liste_TFidf)
position = liste_TFidf.index(TFidf_max)
mot = liste_mots[position]
print("{:02}. Mot : {:30} TFidf = {:10}".format(j+1,mot,str(TFidf_max)))
matrice[i][position] = 0
print("\n \n")
</pre>

La liste étant relativement longue, elle sera disponible en annexe et les résultats de cette procédure pour quelques textes seront exploités dans la partie suivante.

=== Exemples qui permettent de souligner les spécificités de certains textes du corpus ===

La liste des 10 TF-idf les plus élevés de chaque texte du corpus permet de mettre en avant les spécificités des différents textes.

En effet, pour le texte 098, on obtient la liste suivante :

<pre>
Texte 098
01. Mot : heu TFidf = 13.815510557964275
02. Mot : oh TFidf = 13.815510557964275
03. Mot : eh TFidf = 10.519673691959945
04. Mot : peuh TFidf = 7.824046010856292
05. Mot : ah TFidf = 7.013115794639964
06. Mot : tiens TFidf = 5.318520073865556
07. Mot : interjections TFidf = 4.605170185988092
08. Mot : psst TFidf = 4.605170185988092
09. Mot : hum TFidf = 4.605170185988092
10. Mot : ouf TFidf = 4.605170185988092
</pre>

Grâce à cette liste, on peut supposer que ce texte est écrit uniquement à l'aide d'« interjections », mot qui apparaît d'ailleurs à la 7ème place. Cela peut donc donner une idée de comment le texte est écrit sans même avoir à le lire. En effet, si on lit le texte 98, on peut vérifier que nos suppositions sont vraies.

<pre>
Interjections.
Psst ! heu ! ah ! oh ! hum ! ah ! ouf ! eh ! tiens ! oh ! peuh ! pouah ! ouïe ! ou ! aïe ! eh ! hein ! heu ! pfuitt !
Tiens ! eh ! peuh ! oh ! heu ! bon !
</pre>

Autre exemple, si on choisit le texte 045, on obtient la liste suivante :

<pre>
Texte 045
01. Mot : scène TFidf = 23.472138032568875
02. Mot : premier TFidf = 14.026231589279927
03. Mot : acte TFidf = 13.815510557964275
04. Mot : drelin TFidf = 13.815510557964275
05. Mot : voyageur TFidf = 12.241324971159328
06. Mot : ii TFidf = 11.736069016284437
07. Mot : monnaie TFidf = 9.210340371976184
08. Mot : i TFidf = 8.987196820661973
09. Mot : second TFidf = 7.824046010856292
10. Mot : comédie TFidf = 7.824046010856292
</pre>

Nous remarquons plusieurs mots comme "scène", "acte", "ii", "premier" qui se rapportent au vocabulaire utilisé dans les pièces de théâtre. Si on regarde le texte correspondant à cette liste, on peut voir que son titre est "comédie", qui apparaît dans la liste à la 10ème position et qu'il est effectivement écrit sous la forme d'une pièce de théâtre :

<pre>
Comédie.
Acte premier
Scène I
(Sur la plate-forme arrière d'un autobus S, un jour, vers midi.)
Le Receveur. -la monnaie, s'iou plaît. (Des voyageurs lui passent la monnaie.)
Scène II
(L'autobus s'arrête.)
Le Receveur. - laissons descendre. Priorités ? Une priorité ! C'est complet. Drelin, drelin, drelin.
Acte second
Scène I
(Même décor.)
Premier Voyageur (Jeune, long cou, une tresse autour du chapeau).
- On dirait, monsieur, que vous le faites exprès de me marcher sur les pieds chaque fois qu'il passe des
gens. Second Voyageur (hausse les épaules)
Scène II
(Un troisième voyageur descend.)
Premier Voyageur (s'adressant au public) : Chouette ! une place libre ! J'y cours. (Il se précipite dessus et
l'occupe.)
Acte troisième
Scène I
(La Cour de Rome.)
Un Jeune Élégant (au premier voyageur, maintenant piéton). -l'échancrure de ton pardessus est trop
large. Tu devrais la fermer un peu en faisant remonter le bouton du haut.
Scène II
(À bord d'un autobus S passant devant la cour de Rome.)
Quatrième Voyageur. -Tiens, le type qui se trouvait tout à l'heure avec moi dans l'autobus et qui
s'engueulait avec un bonhomme. Curieuse rencontre. J'en ferai une comédie en trois actes et en prose.
</pre>

La méthode des TF-idf permet donc bien de mettre en avant les différences qu'il peut y avoir entre les textes.

== Conclusion ==
Ici a été présentée la méthode des TF-idf car elle est puissante et que c'est une technique fondamentale de la fouille de données, mais il existe de nombreuses autres méthodes qui peuvent permettent d'arriver à des résultats différents selon les caractéristiques que l'on souhaite mettre en avant. Il existe par exemple des variantes du TF-idf qui permettent de mieux gérer les cas où les textes du corpus ont des tailles extrêmement différentes les uns des autres ou encore les techniques de LDA qui permettent d'extraire automatiquement les thématiques d'un corpus afin de construire des regroupements par thème.

Page réalisée par Rémi Bouvier, étudiant en L1 CMI-Info (2017-2018), dans le cadre du cours de VISI201.

Tuteur : Laurent Vuillon

== Annexes ==

* [http://www.mediafire.com/file/xafo0xzc49ba6va/Exercices_de_style.txt Textes du corpus]
* [http://www.mediafire.com/file/ni07ftjd3w0bn9c/Liste_mots_corpus.txt Liste des mots du corpus]
* [http://www.mediafire.com/file/riboz97iahtehoe/Liste_mots-outils.txt Liste des mots-outils] inspirée de [https://www.ranks.nl/stopwords/french cette liste].
* [http://www.mediafire.com/file/gzd435ccm3m04wc/50_mots_premi%C3%A8re_approche.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus]
* [http://www.mediafire.com/file/8tb1n5gktqt3d8j/50_mots_premi%C3%A8re_approche_sans_mots_outils.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus sans mots-outils]
* [http://www.mediafire.com/file/749cfscgnsh7n0k/50_premiers_TFidf.txt/file Top 50 des mots avec le TFidf le plus élevé]
* [http://www.mediafire.com/file/k5n5n8nwpca52s6/Top10_TF_IDF_par_texte.txt/file Top 10 des TFidf pour chaque texte]
* [http://www.mediafire.com/file/07argu9or5ruu6r/code_python.py Code python complet]

== Sources ==

Wikipedia :

*[https://fr.wikipedia.org/wiki/Exploration_de_donn%C3%A9es Exploration de données]
*[https://fr.wikipedia.org/wiki/Analyse_des_donn%C3%A9es Analyse de données]
*[https://fr.wikipedia.org/wiki/TF-IDF TF-IDF]

Livre :
* ''"Recherche d'information : applications, modèles et algorithmes; Data mining, décisionnel et big data"'' de Amini et Gaussier aux éditions Eyrolles.

Fouille de données textuelles à partir des "Exercices de style" de R. Queneau

2018-05-21T17:50:49Z

Bouvier :

La '''fouille de données''', également appelée forage de données, analyse de données ou encore ''data mining'', consiste en l'extraction d'information à partir d'une quantité importante de données. Pour cela, on utilise un ensemble d'algorithmes issus de différentes disciplines scientifiques comme les statistiques ou l'informatique par exemple. Le but de ces algorithmes est de permettre, en fonction de différents critères, d'extraire un maximum de connaissances d'une grande quantité de données. L'analyse de données est très utilisée dans le monde professionnel dans des domaines variés tels que la détection de fraudes, la gestion des relations avec les clients, l'optimisation des sites web ou encore l'analyse de la consommation. Elle a pour but de souligner les relations entre les données (points communs, différences...) afin d'en tirer seulement les informations les plus intéressantes. Les résultats de l'utilisation des algorithmes d'analyse de données sont souvent sous forme de représentations graphiques qui permettent de mettre en évidence les informations.

L'analyse de données textuelles est une spécialisation de la fouille de données et repose sur les même principes, seulement elle utilise des algorithmes spécialisés ayant pour but d'obtenir de l'information à partir d'un texte ou d'un corpus de textes.

A travers un corpus de textes, nous expliquerons notamment les techniques de TF/IDF permettant d'extraire les mots significatifs du corpus. Toutes les fonctions et procédures dont nous aurons besoin ici seront écrites en Python.

== Présentation du corpus de textes traité ==

Ici, nous présenterons différentes techniques de fouille de données textuelles à partir de l'ouvrage ''« Exercices de style »'' de Raymond Queneau. Ce livre, publié en 1947, raconte 99 fois la même histoire de manière différente à chaque fois. Cet ouvrage est un exemple d'une contrainte littéraire utilisée en tant que moteur créatif et est un des premiers textes du mouvement Oulipo dont Raymond Queneau sera l'un des membres les plus importants. Le mouvement Oulipo (Ouvroir de littérature potentielle) est un groupe de littéraires et de mathématiciens qui se définissent comme des « rats qui construisent eux-mêmes le labyrinthe dont ils se proposent de sortir. » Les membres de l'Oulipo réfléchissait autour de la notion de « contrainte » afin d'écrire de nouveaux ouvrages ayant pour but d'encourager la création.

L'histoire de base du texte de Raymond Queneau se résume en quelques lignes :

''« Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »''

Un fichier contenant tous les textes du corpus sera disponible en annexe.

== Traitement préliminaire du corpus de textes ==

=== Gestion de la ponctuation, des majuscules et des sauts de ligne ===

Pour être exploité, le corpus de textes doit d'abord être traité au préalable, afin de permettre une utilisation simplifiée des algorithmes d'analyse de données. En effet, des éléments comme la ponctuation, les sauts de ligne ou encore les majuscules/minuscules peuvent compliquer l'utilisation des algorithmes ceux-ci ne sont pas traités en amont. Il est donc nécessaire de créer une procédure permettant de gérer ces éléments. Celle-ci devra gérer les aspects suivants : le remplacement de toutes les majuscules du texte par des minuscules, ainsi que le remplacement de la ponctuation et des sauts de ligne par le caractère « » (un espace). Elle prendra en argument un fichier texte que l'on souhaite modifier, ainsi qu'un numéro de fichier (afin de faciliter la gestion lorsque l'on possède un grand nombre de fichier) et écrira le texte modifié dans un nouveau fichier nommé <code>modif{:03}.txt".format(i)</code> . Vous pouvez trouver ci-dessous le code en Python d'une telle procédure :

<pre>
def modification_texte(fichier_in,i):
"""
fichier_in : nom du fichier à modifier
i : numéro du fichier
"""

ponctuation = [",",";",":",".","?","!","«","»","(",")","\"","…","'","-","’"]
f_in = open(fichier_in, mode = "r")
f_out = open(("modif{:03}.txt".format(i)), mode = "w")
ligne = "initialisation"
while (ligne != "") : #Tant que la fin du fichier n'est pas atteinte.
ligne = f_in.readline()
ligne = ligne.lower()
for c in ligne :
if (c in ponctuation) or (c == "\n") :
f_out.write(" ")
else :
f_out.write(c)
f_in.close()
f_out.close()
</pre>

On peut également créer une procédure qui prend en argument un dossier de fichiers à modifier et qui exécute la procédure présentée ci-dessus sur tous les fichiers de ce dossier (cela permet de gérer l'intégralité du corpus de textes).

<pre>
def modification_texte_dossier(dossier_in):
"""
dossier_in : dossier de fichiers à modifier.
"""
import os
os.chdir(dossier_in)
liste_fichiers = os.listdir(dossier_in)
for i in range (len(liste_fichiers)):
modification_texte(liste_fichiers[i],i+1)
</pre>

Pour les toutes les fonctions décrites ci-dessous, on utilisera les textes modifiés (sans ponctuation, sans majuscules et sans sauts de ligne).

=== Création de fonctions utiles pour la fouille de données textuelles ===

Nous allons avoir besoin de créer quelques fonctions de base, très utiles pour l'utilisation des algorithmes d'analyse de données textuelles.

Il est donc nécessaire de créer une fonction qui permet de compter le nombre de mots total du corpus de texte, afin de savoir quelle quantité de données il faudra gérer. La fonction suivante permet de compter le nombre de mots d'un fichier. Elle prend en paramètre un fichier texte et renvoie le nombre de mots contenus dans ce fichier.

<pre>
def compte_mots(fichier):
"""
fichier : fichier texte sur lequel on doit compter le nombre de mots qu'il contient
"""
f = open(fichier, mode = "r")
mots = []
ligne = f.readline()
ligne2 = ligne.split()
mots = mots + ligne2
f.close()
return len(mots)
</pre>

Il faut donc maintenant créer une fonction qui parcourt l'intégralité du corpus afin de connaître le nombre de mots total que contient celui-ci. Cette fonction prend en paramètre un dossier de fichiers textes (le corpus) et renvoie le nombre total de mots contenus dans les fichiers textes de ce dossier.

<pre>
def compte_mots_dossier(dossier):
"""
dossier : dossier de fichier texte (corpus de textes complet)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
total = 0
for i in range (len(liste_fichiers)):
total = total + compte_mots(liste_fichiers[i])
return total
</pre>

En utilisant cette fonction, on peut savoir que le corpus traité contient 14755 mots.

Il est également nécessaire de créer une fonction qui stocke tous les mots du corpus dans un tableau (chaque mot n'apparaît qu'une seule fois dans le tableau). On crée donc d'abord une fonction qui stocke tous les mots d'un fichier. Celle-ci prendra en argument un fichier texte et renverra un tableau contenant chaque mot du fichier texte (pas de doublons dans le tableau).

<pre>
def stocke_mots_fichier(fichier):
"""
fichier texte duquel on souhaite tirer une liste de mots
"""
tab = []
f = open(fichier, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
if not (c in tab) :
tab.append(c)
f.close()
return tab
</pre>

Comme précédemment, on a donc maintenant besoin d'une fonction qui puisse parcourir l'intégralité du corpus de texte. Celle-ci prend en paramètre un dossier de fichiers (le corpus de textes) et renvoie un tableau contenant tous les mots du corpus, chaque mot n’apparaissant qu'une seule fois.

<pre>
def stocke_mots_dossier(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes complet)
"""
tab = []
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
for f in liste_fichiers:
tab_fichier = stocke_mots_fichier(f)
for c in tab_fichier :
if not (c in tab):
tab.append(c)
return tab
</pre>

Nous avons donc maintenant l'intégralité des mots du corpus stockés dans un tableau (disponible en annexe). En utilisant la commande <code>len(stocke_mots_dossier(dossier))</code>, on obtient que le corpus contient 3774 mots différents les uns des autres.

== Première approche : comptage du nombre d'apparition de chaque mot dans le corpus ==

=== Présentation de la méthode sur 1 texte ===

La première méthode à laquelle on pense pour tirer de l'information d'un grand nombre de données textuelles est de regarder le nombre de fois que chaque mot apparaît dans le corpus. Prenons un exemple sur le texte suivant :

<pre>
Le texte de base.

Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus.
</pre>

Dans ce texte, les termes qui apparaissent le plus souvent sont :
* « un » apparaît 10 fois.
* « le » apparaît 5 fois.
* « de » apparaît 3 fois.
* « il» apparaît 3 fois.
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.

Les informations obtenues ne sont donc pas très intéressantes car elle ne permettent pas de dégager les mots spécifiques à ce texte. En effet, avec cette méthode, on obtiendra principalement les mots outils de la langue française, qui n'ont pas spécialement grand intérêt du fait qu'ils sont présents dans la quasi-totalité des textes et que nous cherchons à définir les mots spécifiques à un texte. Ce que nous pouvons faire pour palier à ce problème est de définir manuellement une liste de mots-outils (disponible en annexe) qui ne seront pas pris en compte dans le comptage des mots. Le problème de cette liste est qu'elle doit être définie à la main par l'utilisateur.

Si l'on néglige la présence de ces mots-outils dans le texte, voici la liste des termes qui apparaissent le plus souvent :
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.
* « voyageur » apparaît 2 fois.

Les autres mots du texte sont des mots-outils où n'apparaissent qu'une seule fois : il n'est donc pas intéressant de les retenir. Nous obtenons donc une liste de mots spécifiques à ce texte qui permet de dégager quelques informations à propos de ce dernier : on sait qu'il parle d'un « homme » et d'un « voyageur » et on peut supposer qu'au moins l'un des deux est qualifié de « jeune ».

Nous avons donc pu tirer une information plus concise du texte à partir de l'intégralité des mots qui le compose.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Il est donc nécessaire d'avoir une fonction qui calcule le nombre d’occurrences de chaque mot dans le corpus. Cette fonction prendra en paramètre un dossier de fichiers textes (le corpus de textes complet) et renverra un dictionnaire avec comme clés les mots contenus dans les fichiers et comme valeurs le nombre de fois où apparaît le mot associé.

<pre>
def occurrence_mots(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
occurrences = {}
for t in liste_fichiers :
f = open(t, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
occurrences[c] = occurrences.get(c,0)+1
f.close()
return occurrences
</pre>

Il est maintenant nécessaire d'afficher les mots dont l'occurrence est la plus élevée. Pour cela nous aurons besoin d'une procédure qui prend en paramètres le corpus de textes et un entier n et qui affiche la liste des n mots apparaissant le plus dans le corpus (donc affichés selon l'ordre décroissant des occurrences).

<pre>
def affiche_occurrence_décroissant(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
for i in range (0,min(n,len(tab))):
print("Mot {:03} : '{:30} fréquence : {:03}".format(i+1,tab[i][0] + "\'",tab[i][1]))
</pre>

Grâce à cette procédure nous obtenons que les mots qui apparaissent le plus souvent dans le corpus sont (la liste des 50 premiers mots est disponible en annexe) :
* « un » apparaît 575 fois.
* « de » apparaît 457 fois.
* « la » apparaît 294 fois.
* « et » apparaît 275 fois.
* « il » apparaît 274 fois.
* ...

Comme sur l'exemple avec un seul texte, ce sont les mots-outils de la langue française qui apparaissent le plus dans ce corpus (ils sont même davantage mis en avant car le corpus de texte étant plus long, les mots-outils sont encore plus utilisés), ce qui ne nous apporte pas grand chose comme information sur les spécificités du corpus.

Il est donc nécessaire de créer une procédure similaire à la précédente, qui permette de gérer les mots-outils. Celle-ci doit avoir pour arguments un dossier contenant les textes du corpus ainsi qu'un entier n, comme la précédente. Elle affichera la liste des n mots qui apparaissent le plus dans le corpus, sans les mots-outils (la liste de ceux-ci était entrée manuellement) et sans les mots de taille égale à 1 caractère que l'on considère comme non pertinents.

<pre>
def affiche_occurrence_décroissant2(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : entier représentant le nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
i = 0
numero_mot = 1
while (numero_mot <= n) and (i < len(tab)) :
if (((tab[i][0]) not in mots_outils) and (len(tab[i][0]) > 1)) :
print("Mot {:03} : '{:30} fréquence : {:03}".format(numero_mot,tab[i][0] + "\'",tab[i][1]))
numero_mot = numero_mot + 1
i = i+1
</pre>

Si l'on exécute cette fonction, voici la liste des termes qui apparaissent le plus souvent dans le corpus (la liste des 50 premiers mots est disponible en annexe) :
* « autobus » apparaît 93 fois.
* « chapeau » apparaît 69 fois.
* « long » apparaît 66 fois.
* « cou » apparaît 66 fois.
* « devant » apparaît 64 fois.
* « bouton » apparaît 58 fois.
* « jeune » apparaît 52 fois.
* « tard » apparaît 51 fois.
* « place » apparaît 51 fois.
* « homme » apparaît 48 fois.
Les données obtenues sont donc plus pertinentes et nous donnent plus d'information sur l'histoire racontée dans le corpus. En effet, on peut par exemple déduire que l'« autobus » le « chapeau » ou encore le « bouton » sont des éléments centraux de l'histoire car ils apparaissent de nombreuses fois dans le corpus.

Cette méthode permet donc d'avoir une vue d'ensemble sur ce dont parlent les textes, mais le principal inconvénient est qu'il faille rentrer une liste de mots-outils de la langue française, sachant que celle-ci n'est pas fixée et peu plus ou moins varier selon les textes analysés.

== Méthode des TF-IDF ==
Cette méthode permet justement de gérer automatiquement les mots-outils d'un corpus, sans que l'utilisateur ait besoin de rentrer une liste au préalable.

=== Présentation de la méthode sur une quantité de données réduite ===

Dans cette partie, nous utiliserons les textes suivants, l'exemple portera sur le texte 3.

*Texte 1 :

<pre>
Rétrograde.

Tu devrais ajouter un bouton à ton pardessus, lui dit son ami. Je le rencontrai au milieu de la cour de Rome, après l'avoir quitté se précipitant avec avidité vers une place assise. Il venait de protester contre la poussée d'un autre voyageur, qui, disait-il, le bousculait chaque fois qu'il descendait quelqu'un. Ce jeune homme décharné était porteur d'un chapeau ridicule. Cela se passa sur la plate-forme d'un S complet ce midi-là.
</pre>

*Texte 2 :

<pre>
Distinguo.

Dans un autobus (qu'il ne faut pas prendre pour un autre obus), je vis (et pas avec mon vit) un personnage (qui ne perd son âge) coiffé d'un feutre mou bleu (et non de foutre blême), feutre cerné d'un fil tressé (et non de tril fessé). Il disposait (et non dix posait) d'un long cou (et pas d'un loup con). Comme la foule se bousculait (non que la boule se fousculât), un nouveau voyageur (non veau nouillageur) déplaça le susdit (et non suça ledit plat). Cestuy râla (et non cette huître hala), mais voyant une place libre (et non ployant une vache ivre) s'y précipita (et non si près s'y piqua).
Plus tard je l'aperçus (non pas gel à peine su) devant la gare Saint-Lazare (et non là ou l'hagard ceint le hasard) qui parlait avec un copain (il n'écopait pas d'un pralin) au sujet d'un bouton de son manteau (qu'il ne faut pas confondre avec le bout haut de son menton).
</pre>

*Texte 3 :

<pre>
Passé indéfini.

Je suis monté dans l'autobus de la porte Champerret. Il y avait beaucoup de monde, des jeunes, des vieux, des femmes, des militaires. J'ai payé ma place et puis j'ai regardé autour de moi. Ce n'était pas très intéressant. J'ai quand même fini par remarquer un jeune homme dont j'ai trouvé le cou trop long. J'ai examiné son chapeau et je me suis aperçu qu'au lieu d'un ruban il y avait un galon tressé. Chaque fois qu'un nouveau voyageur montait, ça faisait de la bousculade. Je n'ai rien dit, mais le jeune homme au long cou a tout de même interpellé son voisin. Je n'ai pas entendu ce qu'il lui a dit, mais ils se sont regardés d'un sale oeil. Alors, le jeune homme au long cou est allé s'asseoir précipitamment. En revenant de la porte Champerret, je suis passé devant la gare Saint-Lazare.
J'ai vu mon type qui discutait avec un copain. Celui-ci a désigné du doigt un bouton juste au-dessus de l'échancrure du pardessus. Puis l'autobus m'a emmené et je ne les ai plus vus. J'étais assis et je n'ai pensé à rien.
</pre>

==== Le TF ====

Le TF (''Term-Frequency'') d'un terme, autrement appelé la fréquence « brute » est précisément le nombre d’occurrences de ce terme dans un texte. Par abus de langage, on parle de « fréquence ». Comme cette méthode a déjà été vue précédemment, nous nous contenterons ici de calculer le TF pour des mots qui nous serviront d'exemple pour la suite et d'introduire une fonction qui permettra de calculer le TF d'un mot dans un texte.
Pour le texte 3, on a donc :
* Pour le mot « un », <math>TF = 7</math>
* Pour le mot « de », <math>TF = 7</math>
* Pour le mot « homme », <math>TF = 3</math>
* Pour le mot « autobus », <math>TF = 2</math>
* Pour le mot « pardessus », <math>TF = 1</math>
* Pour le mot « ruban », <math>TF = 1</math>
Nous retrouvons donc le même problème que précédemment où les mots-outils sont mis en avant.

Le code de la fonction qui permet de calculer le TF d'un mot dans un texte est disponible ci-dessous :

<pre>
def calcul_TF(fichier,mot):
"""
fichier : fichier texte que l'on va parcourir
mot : chaîne de caractères dont on souhaite compter le nombre d'apparitions
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
f = open(fichier, mode = "r")
ligne = f.readline()
Freq = ligne.count(mot)
f.close()
return Freq
</pre>

==== L'IDF ====

Pour palier au problème que pose le TF, nous introduisons l'IDF. En effet, avec la méthode des TF, tous les termes qui apparaissent dans un document avec la même fréquence auront la même importance. Or, les termes qui se trouvent dans peu de documents permettent de mieux différencier ces derniers des textes dans lesquels ils se trouvent en nombre élevé. Ces termes ont donc un pouvoir de discrimination plus grand que celui des termes apparaissant dans beaucoup de documents. L'IDF (''inverse document frequency'') est une mesure de l'importance du terme dans l'ensemble du corpus. La formule de l'idf est la suivante :

<math>idf_{t}=\ln{\frac{N}{df_{t}}} </math>
* où <math>N</math> est le nombre total de documents dans le corpus
* et <math>df_{t}</math> le nombre de documents où le terme <math>t</math> apparaît (on doit avoir <math>df_{t} \ne 0 </math>, autrement dit le mot doit se trouver dans au moins un texte du corpus)

On cherchera donc d'abord à créer une fonction qui permette de calculer le df d'un mot dans un corpus de textes. Cette fonction prend en arguments un dossier de fichiers textes (le corpus de documents) et un mot pour lequel on souhaite calculer le df. Elle renvoie le df de ce mot, c'est-à-dire le nombre de fichiers où ce mot apparaît.

<pre>
def calcul_df(dossier,mot):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre le df
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
nombre_doc = 0
for c in liste_fichiers :
f = open(c, mode = "r")
texte = f.readline()
if mot in texte :
nombre_doc = nombre_doc + 1
f.close()
return nombre_doc
</pre>

La fonction qui permet de calculer l'idf d'un terme est donc définie simplement de la manière suivante :
<pre>
def calcul_idf(dossier,mot,nombre_docs):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre l'idf
nombre_docs : entier représentant le nombre de documents du corpus
"""
return log(nombre_docs / (calcul_df(dossier,mot)))
</pre>

En utilisant ces fonctions, on peut donc avoir l'idf des mots du texte 3 pour lesquels nous avons calculé le tf précédemment (dans l'exemple, le nombre total de documents est de 3) :
* Pour le mot « un », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « de », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « homme », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « autobus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « pardessus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « ruban », <math>idf=\ln{\frac{3}{1}} \approx 1,099</math>

==== Le TF-IDF ====

Le TF-idf s'obtient en multipliant les deux valeurs obtenues :

<math>TFidf_{t} = TF_{t} \times idf_{t} </math>

où <math>t</math> est le terme pour lequel on calcule le TF-idf.

Pour l'exemple précédent (texte 3), on a donc :
* Pour le mot « un », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « de », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « homme », <math>TFidf = 3 \times 0,405 = 1,215</math>
* Pour le mot « autobus », <math>TFidf = 2 \times 0,405 = 0,81</math>
* Pour le mot « pardessus », <math>TFidf = 1 \times 0,405 = 0,405</math>
* Pour le mot « ruban », <math>TFidf = 1 \times 1,099 = 1,099</math>

On obtient donc les mots par ordre de pertinence : homme, autobus, pardessus, un, de. Cela a permis de supprimer les mots-outils qui se trouvaient dans les 3 documents et de faire ressortir d'autres mots importants.

Le mot « homme » a le TF-idf le plus élevé, car il apparaît 3 fois dans le texte 3 et apparaît uniquement dans 2 textes sur 3 du corpus.

Le mot « ruban » a un TF-idf plus élevé que les mots « autobus » et « pardessus » alors qu'il n’apparaît qu'une seule fois dans le texte 3, mais c'est parce qu'il n’apparaît que dans le texte 3, ce qui montre bien que le TF-idf permet de mettre en avant les spécificités de chaque texte.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Nous allons commencer par écrire une fonction qui permette de calculer l'intégralité des TF de chaque mot, texte par texte. Pour cela, nous aurons besoin des fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_TF(fichier,mot)</code> vues précédemment. Cette fonction devra prendre en argument un dossier de fichiers textes (le corpus de textes) et renverra une matrice rectangulaire qui contient sur chaque ligne le TF de chaque mot du corpus pour un texte donné. Le matrice devra donc avoir 100 lignes et 3774 colonnes et sera donc de la forme suivante :

<math> \begin{pmatrix} TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ ... & ... & ... & ... & ... \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \end{pmatrix} </math>

La première ligne représentant le 1er texte, la deuxième le 2ème, etc...

<pre>
def tf_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Création de la matrice rectangulaire
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice rectangulaire
for i in range (len(liste_fichiers)) :
fichier = liste_fichiers[i]
for j in range (len(liste_mots)) :
mot = liste_mots[j]
TF = calcul_TF(fichier,mot)
mat[i][j] = TF
return mat
</pre>

La matrice totale étant plutôt grande, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes :

<math> \begin{pmatrix} 5 & 1 & 3 & 1 & 10 & ... \\ 4 & 0 & 2 & 0 & 5 & ... \\ 4 & 0 & 8 & 0 & 9 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Il est également nécessaire de construire une fonction qui permette d'avoir l'idf de chaque mot dans le corpus. Nous utiliserons donc les fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_idf(dossier,mot,nombre_docs)</code>. Cette fonction a pour paramètre un dossier de fichiers textes (le corpus de textes) et renvoie un tableau qui contient l'idf de chaque mot apparaissant dans le corpus (le corpus contenant 3774 mots différents, la longueur de ce tableau est de 3774).

<pre>
def idf_par_mot(dossier):
""""
dossier : dossier de fichiers textes (corpus complet)
"""

os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier) #3774
T = [0]*len(liste_mots)
for i in range (len(T)):
mot = liste_mots[i]
idf = calcul_idf(dossier,mot,nombre_docs=100)
T[i] = idf
return T
</pre>

Voici un aperçu du résultat obtenu pour les premiers mots ("le", "texte", "de", "base", "un", "voyageur", "attend", "bus"). Les résultats sont arrondis au centième:

<math> \begin{pmatrix} 0.22 & 4.61 & 0.13 & 4.61 & 0.12 & 2.04 & 4.61 & 3.00 & ... \end{pmatrix} </math>

Maintenant que nous avons la matrice des TF et le tableau des idf de chaque mot, nous pouvons créer une fonction qui calculera le TF-idf de chaque mot. Celle-ci prendra en argument un dossier contenant des fichiers textes (le corpus de textes) et renverra une matrice qui contiendra le TF-idf de chaque mot pour chaque texte et qui sera de la même taille (100x3774) et de la même forme que celle des TF.

<pre>
def matrice_TFidf(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Initialisation de la matrice finale
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice finale
matrice_TF = tf_par_texte(dossier)
tableau_idf = idf_par_mot(dossier)
for i in range (len(matrice_TF)):
for j in range (len(matrice_TF[i])):
mat[i][j] = ((matrice_TF[i][j])*(tableau_idf[j]))
return mat
</pre>

La matrice finale étant trop grande pour apparaître ici, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes. Les résultats sont arrondis au centième :

<math> \begin{pmatrix} 1.12 & 4.61 & 0.38 & 4.61 & 1.17 & ... \\ 0.89 & 0.00 & 0.26 & 0.00 & 0.58 & ... \\ 0.89 & 0.00 & 1.02 & 0.00 & 0.105 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Les résultats n'étant pas facilement visibles sous forme de matrice, on peut maintenant créer une procédure qui permettra de mieux les visualiser. Cette procédure prend en argument le corpus de textes et renvoie les 10 TF-idf les plus élevés de chaque texte du corpus.

<pre>
def Top10_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""
os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier)
matrice = matrice_TFidf(dossier)
for i in range (len(matrice)):
print("Texte {:03}".format(i+1))
for j in range (10):
liste_TFidf = matrice[i]
TFidf_max = max(liste_TFidf)
position = liste_TFidf.index(TFidf_max)
mot = liste_mots[position]
print("{:02}. Mot : {:30} TFidf = {:10}".format(j+1,mot,str(TFidf_max)))
matrice[i][position] = 0
print("\n \n")
</pre>

La liste étant relativement longue, elle sera disponible en annexe et les résultats de cette procédure pour quelques textes seront exploités dans la partie suivante.

=== Exemples qui permettent de souligner les spécificités de certains textes du corpus ===

La liste des 10 TF-idf les plus élevés de chaque texte du corpus permet de mettre en avant les spécificités des différents textes.

En effet, pour le texte 098, on obtient la liste suivante :

<pre>
Texte 098
01. Mot : heu TFidf = 13.815510557964275
02. Mot : oh TFidf = 13.815510557964275
03. Mot : eh TFidf = 10.519673691959945
04. Mot : peuh TFidf = 7.824046010856292
05. Mot : ah TFidf = 7.013115794639964
06. Mot : tiens TFidf = 5.318520073865556
07. Mot : interjections TFidf = 4.605170185988092
08. Mot : psst TFidf = 4.605170185988092
09. Mot : hum TFidf = 4.605170185988092
10. Mot : ouf TFidf = 4.605170185988092
</pre>

Grâce à cette liste, on peut supposer que ce texte est écrit uniquement à l'aide d'« interjections », mot qui apparaît d'ailleurs à la 7ème place. Cela peut donc donner une idée de comment le texte est écrit sans même avoir à le lire. En effet, si on lit le texte 98, on peut vérifier que nos suppositions sont vraies.

<pre>
Interjections.
Psst ! heu ! ah ! oh ! hum ! ah ! ouf ! eh ! tiens ! oh ! peuh ! pouah ! ouïe ! ou ! aïe ! eh ! hein ! heu ! pfuitt !
Tiens ! eh ! peuh ! oh ! heu ! bon !
</pre>

Autre exemple, si on choisit le texte 045, on obtient la liste suivante :

<pre>
Texte 045
01. Mot : scène TFidf = 23.472138032568875
02. Mot : premier TFidf = 14.026231589279927
03. Mot : acte TFidf = 13.815510557964275
04. Mot : drelin TFidf = 13.815510557964275
05. Mot : voyageur TFidf = 12.241324971159328
06. Mot : ii TFidf = 11.736069016284437
07. Mot : monnaie TFidf = 9.210340371976184
08. Mot : i TFidf = 8.987196820661973
09. Mot : second TFidf = 7.824046010856292
10. Mot : comédie TFidf = 7.824046010856292
</pre>

Nous remarquons plusieurs mots comme "scène", "acte", "ii", "premier" qui se rapportent au vocabulaire utilisé dans les pièces de théâtre. Si on regarde le texte correspondant à cette liste, on peut voir que son titre est "comédie", qui apparaît dans la liste à la 10ème position et qu'il est effectivement écrit sous la forme d'une pièce de théâtre :

<pre>
Comédie.
Acte premier
Scène I
(Sur la plate-forme arrière d'un autobus S, un jour, vers midi.)
Le Receveur. -la monnaie, s'iou plaît. (Des voyageurs lui passent la monnaie.)
Scène II
(L'autobus s'arrête.)
Le Receveur. - laissons descendre. Priorités ? Une priorité ! C'est complet. Drelin, drelin, drelin.
Acte second
Scène I
(Même décor.)
Premier Voyageur (Jeune, long cou, une tresse autour du chapeau).
- On dirait, monsieur, que vous le faites exprès de me marcher sur les pieds chaque fois qu'il passe des
gens. Second Voyageur (hausse les épaules)
Scène II
(Un troisième voyageur descend.)
Premier Voyageur (s'adressant au public) : Chouette ! une place libre ! J'y cours. (Il se précipite dessus et
l'occupe.)
Acte troisième
Scène I
(La Cour de Rome.)
Un Jeune Élégant (au premier voyageur, maintenant piéton). -l'échancrure de ton pardessus est trop
large. Tu devrais la fermer un peu en faisant remonter le bouton du haut.
Scène II
(À bord d'un autobus S passant devant la cour de Rome.)
Quatrième Voyageur. -Tiens, le type qui se trouvait tout à l'heure avec moi dans l'autobus et qui
s'engueulait avec un bonhomme. Curieuse rencontre. J'en ferai une comédie en trois actes et en prose.
</pre>

La méthode des TF-idf permet donc bien de mettre en avant les différences qu'il peut y avoir entre les textes.

== Conclusion ==
Ici a été présentée la méthode des TF-idf car elle est puissante et que c'est une technique fondamentale de la fouille de données, mais il existe de nombreuses autres méthodes qui peuvent permettent d'arriver à des résultats différents selon les caractéristiques que l'on souhaite mettre en avant. Il existe par exemple des variantes du TF-idf qui permettent de mieux gérer les cas où les textes du corpus ont des tailles extrêmement différentes les uns des autres ou encore les techniques de LDA qui permettent d'extraire automatiquement les thématiques d'un corpus afin de construire des regroupements par thème.

Page réalisée par Rémi Bouvier, étudiant en L1 CMI-Info (2017-2018), dans le cadre du cours de VISI201.

Tuteur : Laurent Vuillon

== Annexes ==

* [http://www.mediafire.com/file/xafo0xzc49ba6va/Exercices_de_style.txt Textes du corpus]
* [http://www.mediafire.com/file/ni07ftjd3w0bn9c/Liste_mots_corpus.txt Liste des mots du corpus]
* [http://www.mediafire.com/file/riboz97iahtehoe/Liste_mots-outils.txt Liste des mots-outils] inspirée de [https://www.ranks.nl/stopwords/french cette liste].
* [http://www.mediafire.com/file/gzd435ccm3m04wc/50_mots_premi%C3%A8re_approche.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus]
* [http://www.mediafire.com/file/8tb1n5gktqt3d8j/50_mots_premi%C3%A8re_approche_sans_mots_outils.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus sans mots-outils]
* [http://www.mediafire.com/file/07argu9or5ruu6r/code_python.py Code python complet]

== Sources ==

Wikipedia :

*[https://fr.wikipedia.org/wiki/Exploration_de_donn%C3%A9es Exploration de données]
*[https://fr.wikipedia.org/wiki/Analyse_des_donn%C3%A9es Analyse de données]
*[https://fr.wikipedia.org/wiki/TF-IDF TF-IDF]

Livre :
* ''"Recherche d'information : applications, modèles et algorithmes; Data mining, décisionnel et big data"'' de Amini et Gaussier aux éditions Eyrolles.

Fouille de données textuelles à partir des "Exercices de style" de R. Queneau

2018-05-21T14:41:39Z

Bouvier : Ajout des sources et des annexes + modifications mineures

La '''fouille de données''', également appelée forage de données, analyse de données ou encore ''data mining'', consiste en l'extraction d'information à partir d'une quantité importante de données. Pour cela, on utilise un ensemble d'algorithmes issus de différentes disciplines scientifiques comme les statistiques ou l'informatique par exemple. Le but de ces algorithmes est de permettre, en fonction de différents critères, d'extraire un maximum de connaissances d'une grande quantité de données. L'analyse de données est très utilisée dans le monde professionnel dans des domaines variés tels que la détection de fraudes, la gestion des relations avec les clients, l'optimisation des sites web ou encore l'analyse de la consommation. Elle a pour but de souligner les relations entre les données (points communs, différences...) afin d'en tirer seulement les informations les plus intéressantes. Les résultats de l'utilisation des algorithmes d'analyse de données sont souvent sous forme de représentations graphiques qui permettent de mettre en évidence les informations.

L'analyse de données textuelles est une spécialisation de la fouille de données et repose sur les même principes, seulement elle utilise des algorithmes spécialisés ayant pour but d'obtenir de l'information à partir d'un texte ou d'un corpus de textes.

A travers un corpus de textes, nous expliquerons notamment les techniques de TF/IDF permettant d'extraire les mots significatifs du corpus. Toutes les fonctions et procédures dont nous aurons besoin ici seront écrites en Python.

== Présentation du corpus de textes traité ==

Ici, nous présenterons différentes techniques de fouille de données textuelles à partir de l'ouvrage ''« Exercices de style »'' de Raymond Queneau. Ce livre, publié en 1947, raconte 99 fois la même histoire de manière différente à chaque fois. Cet ouvrage est un exemple d'une contrainte littéraire utilisée en tant que moteur créatif et est un des premiers textes du mouvement Oulipo dont Raymond Queneau sera l'un des membres les plus importants. Le mouvement Oulipo (Ouvroir de littérature potentielle) est un groupe de littéraires et de mathématiciens qui se définissent comme des « rats qui construisent eux-mêmes le labyrinthe dont ils se proposent de sortir. » Les membres de l'Oulipo réfléchissait autour de la notion de « contrainte » afin d'écrire de nouveaux ouvrages ayant pour but d'encourager la création.

L'histoire de base du texte de Raymond Queneau se résume en quelques lignes :

''« Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »''

Un fichier contenant tous les textes du corpus sera disponible en annexe.

== Traitement préliminaire du corpus de textes ==

=== Gestion de la ponctuation, des majuscules et des sauts de ligne ===

Pour être exploité, le corpus de texte doit d'abord être traité au préalable, afin de permettre une utilisation simplifiée des algorithmes d'analyse de données. En effet, des éléments comme la ponctuation, les sauts de ligne ou encore les majuscules/minuscules peuvent compliquer l'utilisation des algorithmes ceux-ci ne sont pas traités en amont. Il est donc nécessaire de créer une procédure permettant de gérer ces éléments. Celle-ci devra gérer les aspects suivants : le remplacement de toutes les majuscules du texte par des minuscules, ainsi que le remplacement de la ponctuation et des sauts de ligne par le caractère « » (un espace). Elle prendra en argument un fichier texte que l'on souhaite modifier, ainsi qu'un numéro de fichier (afin de faciliter la gestion lorsque l'on possède un grand nombre de fichier) et écrira le texte modifié dans un nouveau fichier nommé <code>modif{:03}.txt".format(i)</code> . Vous pouvez trouver ci-dessous le code en Python d'une telle procédure :

<pre>
def modification_texte(fichier_in,i):
"""
fichier_in : nom du fichier à modifier
i : numéro du fichier
"""

ponctuation = [",",";",":",".","?","!","«","»","(",")","\"","…","'","-","’"]
f_in = open(fichier_in, mode = "r")
f_out = open(("modif{:03}.txt".format(i)), mode = "w")
ligne = "initialisation"
while (ligne != "") : #Tant que la fin du fichier n'est pas atteinte.
ligne = f_in.readline()
ligne = ligne.lower()
for c in ligne :
if (c in ponctuation) or (c == "\n") :
f_out.write(" ")
else :
f_out.write(c)
f_in.close()
f_out.close()
</pre>

On peut également créer une procédure qui prend en argument un dossier de fichiers à modifier et qui exécute la procédure présentée ci-dessus sur tous les fichiers de ce dossier (cela permet de gérer l'intégralité du corpus de textes).

<pre>
def modification_texte_dossier(dossier_in):
"""
dossier_in : dossier de fichiers à modifier.
"""
import os
os.chdir(dossier_in)
liste_fichiers = os.listdir(dossier_in)
for i in range (len(liste_fichiers)):
modification_texte(liste_fichiers[i],i+1)
</pre>

Pour les toutes les fonctions décrites ci-dessous, on utilisera les textes modifiés (sans ponctuation, sans majuscules et sans sauts de ligne).

=== Création de fonctions utiles pour la fouille de données textuelles ===

Nous allons avoir besoin de créer quelques fonctions de base, très utiles pour l'utilisation des algorithmes d'analyse de données textuelles.

Il est donc nécessaire de créer une fonction qui permet de compter le nombre de mots total du corpus de texte, afin de savoir quelle quantité de données il faudra gérer. La fonction suivante permet de compter le nombre de mots d'un fichier. Elle prend en paramètre un fichier texte et renvoie le nombre de mots contenus dans ce fichier.

<pre>
def compte_mots(fichier):
"""
fichier : fichier texte sur lequel on doit compter le nombre de mots qu'il contient
"""
f = open(fichier, mode = "r")
mots = []
ligne = f.readline()
ligne2 = ligne.split()
mots = mots + ligne2
f.close()
return len(mots)
</pre>

Il faut donc maintenant créer une fonction qui parcourt l'intégralité du corpus afin de connaître le nombre de mots total que contient celui-ci. Cette fonction prend en paramètre un dossier de fichiers textes (le corpus) et renvoie le nombre total de mots contenus dans les fichiers textes de ce dossier.

<pre>
def compte_mots_dossier(dossier):
"""
dossier : dossier de fichier texte (corpus de textes complet)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
total = 0
for i in range (len(liste_fichiers)):
total = total + compte_mots(liste_fichiers[i])
return total
</pre>

En utilisant cette fonction, on peut savoir que le corpus traité contient 14755 mots.

Il est également nécessaire de créer une fonction qui stocke tous les mots du corpus dans un tableau (chaque mot n'apparaît qu'une seule fois dans le tableau). On crée donc d'abord une fonction qui stocke tous les mots d'un fichier. Celle-ci prendra en argument un fichier texte et renverra un tableau contenant chaque mot du fichier texte (pas de doublons dans le tableau).

<pre>
def stocke_mots_fichier(fichier):
"""
fichier texte duquel on souhaite tirer une liste de mots
"""
tab = []
f = open(fichier, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
if not (c in tab) :
tab.append(c)
f.close()
return tab
</pre>

Comme précédemment, on a donc maintenant besoin d'une fonction qui puisse parcourir l'intégralité du corpus de texte. Celle-ci prend en paramètre un dossier de fichiers (le corpus de textes) et renvoie un tableau contenant tous les mots du corpus, chaque mot n’apparaissant qu'une seule fois.

<pre>
def stocke_mots_dossier(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes complet)
"""
tab = []
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
for f in liste_fichiers:
tab_fichier = stocke_mots_fichier(f)
for c in tab_fichier :
if not (c in tab):
tab.append(c)
return tab
</pre>

Nous avons donc maintenant l'intégralité des mots du corpus stockés dans un tableau (disponible en annexe). En utilisant la commande <code>len(stocke_mots_dossier(dossier))</code>, on obtient que le corpus contient 3774 mots différents les uns des autres.

== Première approche : comptage du nombre d'apparition de chaque mot dans le corpus ==

=== Présentation de la méthode sur 1 texte ===

La première méthode à laquelle on pense pour tirer de l'information d'un grand nombre de données textuelles est de regarder le nombre de fois que chaque mot apparaît dans le corpus. Prenons un exemple sur le texte suivant :

<pre>
Le texte de base.

Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus.
</pre>

Dans ce texte, les termes qui apparaissent le plus souvent sont :
* « un » apparaît 10 fois.
* « le » apparaît 5 fois.
* « de » apparaît 3 fois.
* « il» apparaît 3 fois.
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.

Les informations obtenues ne sont donc pas très intéressantes car elle ne permettent pas de dégager les mots spécifiques à ce texte. En effet, avec cette méthode, on obtiendra principalement les mots outils de la langue française, qui n'ont pas spécialement grand intérêt du fait qu'ils sont présents dans la quasi-totalité des textes et que nous cherchons à définir les mots spécifiques à un texte. Ce que nous pouvons faire pour palier à ce problème est de définir manuellement une liste de mots-outils (disponible en annexe) qui ne seront pas pris en compte dans le comptage des mots. Le problème de cette liste est qu'elle doit être définie à la main par l'utilisateur.

Si l'on néglige la présence de ces mots-outils dans le texte, voici la liste des termes qui apparaissent le plus souvent :
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.
* « voyageur » apparaît 2 fois.

Les autres mots du texte sont des mots-outils où n'apparaissent qu'une seule fois : il n'est donc pas intéressant de les retenir. Nous obtenons donc une liste de mots spécifiques à ce texte qui permet de dégager quelques informations à propos de ce dernier : on sait qu'il parle d'un « homme » et d'un « voyageur » et on peut supposer qu'au moins l'un des deux est qualifié de « jeune ».

Nous avons donc pu tirer une information plus concise du texte à partir de l'intégralité des mots qui le compose.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Il est donc nécessaire d'avoir une fonction qui calcule le nombre d’occurrences de chaque mot dans le corpus. Cette fonction prendra en paramètre un dossier de fichiers textes (le corpus de textes complet) et renverra un dictionnaire avec comme clés les mots contenus dans les fichiers et comme valeurs le nombre de fois où apparaît le mot associé.

<pre>
def occurrence_mots(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
occurrences = {}
for t in liste_fichiers :
f = open(t, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
occurrences[c] = occurrences.get(c,0)+1
f.close()
return occurrences
</pre>

Il est maintenant nécessaire d'afficher les mots dont l'occurrence est la plus élevée. Pour cela nous aurons besoin d'une procédure qui prend en paramètres le corpus de textes et un entier n et qui affiche la liste des n mots apparaissant le plus dans le corpus (donc affichés selon l'ordre décroissant des occurrences).

<pre>
def affiche_occurrence_décroissant(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
for i in range (0,min(n,len(tab))):
print("Mot {:03} : '{:30} fréquence : {:03}".format(i+1,tab[i][0] + "\'",tab[i][1]))
</pre>

Grâce à cette procédure nous obtenons que les mots qui apparaissent le plus souvent dans le corpus sont (la liste des 50 premiers mots est disponible en annexe) :
* « un » apparaît 575 fois.
* « de » apparaît 457 fois.
* « la » apparaît 294 fois.
* « et » apparaît 275 fois.
* « il » apparaît 274 fois.
* ...

Comme sur l'exemple avec un seul texte, ce sont les mots-outils de la langue française qui apparaissent le plus dans ce corpus (ils sont même davantage mis en avant car le corpus de texte étant plus long, les mots-outils sont encore plus utilisés), ce qui ne nous apporte pas grand chose comme information sur les spécificités du corpus.

Il est donc nécessaire de créer une procédure similaire à la précédente, qui permette de gérer les mots-outils. Celle-ci doit avoir pour arguments un dossier contenant les textes du corpus ainsi qu'un entier n, comme la précédente. Elle affichera la liste des n mots qui apparaissent le plus dans le corpus, sans les mots-outils (la liste de ceux-ci était entrée manuellement) et sans les mots de taille égale à 1 caractère que l'on considère comme non pertinents.

<pre>
def affiche_occurrence_décroissant2(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : entier représentant le nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
i = 0
numero_mot = 1
while (numero_mot <= n) and (i < len(tab)) :
if (((tab[i][0]) not in mots_outils) and (len(tab[i][0]) > 1)) :
print("Mot {:03} : '{:30} fréquence : {:03}".format(numero_mot,tab[i][0] + "\'",tab[i][1]))
numero_mot = numero_mot + 1
i = i+1
</pre>

Si l'on exécute cette fonction, voici la liste des termes qui apparaissent le plus souvent dans le corpus (la liste des 50 premiers mots est disponible en annexe) :
* « autobus » apparaît 93 fois.
* « chapeau » apparaît 69 fois.
* « long » apparaît 66 fois.
* « cou » apparaît 66 fois.
* « devant » apparaît 64 fois.
* « bouton » apparaît 58 fois.
* « jeune » apparaît 52 fois.
* « tard » apparaît 51 fois.
* « place » apparaît 51 fois.
* « homme » apparaît 48 fois.
Les données obtenues sont donc plus pertinentes et nous donnent plus d'information sur l'histoire racontée dans le corpus. En effet, on peut par exemple déduire que l'« autobus » le « chapeau » ou encore le « bouton » sont des éléments centraux de l'histoire car ils apparaissent de nombreuses fois dans le corpus.

Cette méthode permet donc d'avoir une vue d'ensemble sur ce dont parlent les textes, mais le principal inconvénient est qu'il faille rentrer une liste de mots-outils de la langue française, sachant que celle-ci n'est pas fixée et peu plus ou moins varier selon les textes analysés.

== Méthode des TF-IDF ==
Cette méthode permet justement de gérer automatiquement les mots-outils d'un corpus, sans que l'utilisateur ait besoin de rentrer une liste au préalable.

=== Présentation de la méthode sur une quantité de données réduite ===

Dans cette partie, nous utiliserons les textes suivants, l'exemple portera sur le texte 3.

*Texte 1 :

<pre>
Rétrograde.

Tu devrais ajouter un bouton à ton pardessus, lui dit son ami. Je le rencontrai au milieu de la cour de Rome, après l'avoir quitté se précipitant avec avidité vers une place assise. Il venait de protester contre la poussée d'un autre voyageur, qui, disait-il, le bousculait chaque fois qu'il descendait quelqu'un. Ce jeune homme décharné était porteur d'un chapeau ridicule. Cela se passa sur la plate-forme d'un S complet ce midi-là.
</pre>

*Texte 2 :

<pre>
Distinguo.

Dans un autobus (qu'il ne faut pas prendre pour un autre obus), je vis (et pas avec mon vit) un personnage (qui ne perd son âge) coiffé d'un feutre mou bleu (et non de foutre blême), feutre cerné d'un fil tressé (et non de tril fessé). Il disposait (et non dix posait) d'un long cou (et pas d'un loup con). Comme la foule se bousculait (non que la boule se fousculât), un nouveau voyageur (non veau nouillageur) déplaça le susdit (et non suça ledit plat). Cestuy râla (et non cette huître hala), mais voyant une place libre (et non ployant une vache ivre) s'y précipita (et non si près s'y piqua).
Plus tard je l'aperçus (non pas gel à peine su) devant la gare Saint-Lazare (et non là ou l'hagard ceint le hasard) qui parlait avec un copain (il n'écopait pas d'un pralin) au sujet d'un bouton de son manteau (qu'il ne faut pas confondre avec le bout haut de son menton).
</pre>

*Texte 3 :

<pre>
Passé indéfini.

Je suis monté dans l'autobus de la porte Champerret. Il y avait beaucoup de monde, des jeunes, des vieux, des femmes, des militaires. J'ai payé ma place et puis j'ai regardé autour de moi. Ce n'était pas très intéressant. J'ai quand même fini par remarquer un jeune homme dont j'ai trouvé le cou trop long. J'ai examiné son chapeau et je me suis aperçu qu'au lieu d'un ruban il y avait un galon tressé. Chaque fois qu'un nouveau voyageur montait, ça faisait de la bousculade. Je n'ai rien dit, mais le jeune homme au long cou a tout de même interpellé son voisin. Je n'ai pas entendu ce qu'il lui a dit, mais ils se sont regardés d'un sale oeil. Alors, le jeune homme au long cou est allé s'asseoir précipitamment. En revenant de la porte Champerret, je suis passé devant la gare Saint-Lazare.
J'ai vu mon type qui discutait avec un copain. Celui-ci a désigné du doigt un bouton juste au-dessus de l'échancrure du pardessus. Puis l'autobus m'a emmené et je ne les ai plus vus. J'étais assis et je n'ai pensé à rien.
</pre>

==== Le TF ====

Le TF (''Term-Frequency'') d'un terme, autrement appelé la fréquence « brute » est précisément le nombre d’occurrences de ce terme dans un texte. Par abus de langage, on parle de « fréquence ». Comme cette méthode a déjà été vue précédemment, nous nous contenterons ici de calculer le TF pour des mots qui nous serviront d'exemple pour la suite et d'introduire une fonction qui permettra de calculer le TF d'un mot dans un texte.
Pour le texte 3, on a donc :
* Pour le mot « un », <math>TF = 7</math>
* Pour le mot « de », <math>TF = 7</math>
* Pour le mot « homme », <math>TF = 3</math>
* Pour le mot « autobus », <math>TF = 2</math>
* Pour le mot « pardessus », <math>TF = 1</math>
* Pour le mot « ruban », <math>TF = 1</math>
Nous retrouvons donc le même problème que précédemment où les mots-outils sont mis en avant.

Le code de la fonction qui permet de calculer le TF d'un mot dans un texte est disponible ci-dessous :

<pre>
def calcul_TF(fichier,mot):
"""
fichier : fichier texte que l'on va parcourir
mot : chaîne de caractères dont on souhaite compter le nombre d'apparitions
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
f = open(fichier, mode = "r")
ligne = f.readline()
Freq = ligne.count(mot)
f.close()
return Freq
</pre>

==== L'IDF ====

Pour palier au problème que pose le TF, nous introduisons l'IDF. En effet, avec la méthode des TF, tous les termes qui apparaissent dans un document avec la même fréquence auront la même importance. Or, les termes qui se trouvent dans peu de documents permettent de mieux différencier ces derniers des textes dans lesquels ils se trouvent en nombre élevé. Ces termes ont donc un pouvoir de discrimination plus grand que celui des termes apparaissant dans beaucoup de documents. L'IDF (''inverse document frequency'') est une mesure de l'importance du terme dans l'ensemble du corpus. La formule de l'idf est la suivante :

<math>idf_{t}=\ln{\frac{N}{df_{t}}} </math>
* où <math>N</math> est le nombre total de documents dans le corpus
* et <math>df_{t}</math> le nombre de documents où le terme <math>t</math> apparaît (on doit avoir <math>df_{t} \ne 0 </math>, autrement dit le mot doit se trouver dans au moins un texte du corpus)

On cherchera donc d'abord à créer une fonction qui permette de calculer le df d'un mot dans un corpus de textes. Cette fonction prend en arguments un dossier de fichiers textes (le corpus de documents) et un mot pour lequel on souhaite calculer le df. Elle renvoie le df de ce mot, c'est-à-dire le nombre de fichiers où ce mot apparaît.

<pre>
def calcul_df(dossier,mot):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre le df
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
nombre_doc = 0
for c in liste_fichiers :
f = open(c, mode = "r")
texte = f.readline()
if mot in texte :
nombre_doc = nombre_doc + 1
f.close()
return nombre_doc
</pre>

La fonction qui permet de calculer l'idf d'un terme est donc définie simplement de la manière suivante :
<pre>
def calcul_idf(dossier,mot,nombre_docs):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre l'idf
nombre_docs : entier représentant le nombre de documents du corpus
"""
return log(nombre_docs / (calcul_df(dossier,mot)))
</pre>

En utilisant ces fonctions, on peut donc avoir l'idf des mots du texte 3 pour lesquels nous avons calculé le tf précédemment (dans l'exemple, le nombre total de documents est de 3) :
* Pour le mot « un », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « de », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « homme », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « autobus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « pardessus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « ruban », <math>idf=\ln{\frac{3}{1}} \approx 1,099</math>

==== Le TF-IDF ====

Le TF-idf s'obtient en multipliant les deux valeurs obtenues :

<math>TFidf_{t} = TF_{t} \times idf_{t} </math>

où <math>t</math> est le terme pour lequel on calcule le TF-idf.

Pour l'exemple précédent (texte 3), on a donc :
* Pour le mot « un », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « de », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « homme », <math>TFidf = 3 \times 0,405 = 1,215</math>
* Pour le mot « autobus », <math>TFidf = 2 \times 0,405 = 0,81</math>
* Pour le mot « pardessus », <math>TFidf = 1 \times 0,405 = 0,405</math>
* Pour le mot « ruban », <math>TFidf = 1 \times 1,099 = 1,099</math>

On obtient donc les mots par ordre de pertinence : homme, autobus, pardessus, un, de. Cela a permis de supprimer les mots-outils qui se trouvaient dans les 3 documents et de faire ressortir d'autres mots importants.

Le mot « homme » a le TF-idf le plus élevé, car il apparaît 3 fois dans le texte 3 et apparaît uniquement dans 2 textes sur 3 du corpus.

Le mot « ruban » a un TF-idf plus élevé que les mots « autobus » et « pardessus » alors qu'il n’apparaît qu'une seule fois dans le texte 3, mais c'est parce qu'il n’apparaît que dans le texte 3, ce qui montre bien que le TF-idf permet de mettre en avant les spécificités de chaque texte.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Nous allons commencer par écrire une fonction qui permette de calculer l'intégralité des TF de chaque mot, texte par texte. Pour cela, nous aurons besoin des fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_TF(fichier,mot)</code> vues précédemment. Cette fonction devra prendre en argument un dossier de fichiers textes (le corpus de textes) et renverra une matrice rectangulaire qui contient sur chaque ligne le TF de chaque mot du corpus pour un texte donné. Le matrice devra donc avoir 100 lignes et 3774 colonnes et sera donc de la forme suivante :

<math> \begin{pmatrix} TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ ... & ... & ... & ... & ... \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \end{pmatrix} </math>

La première ligne représentant le 1er texte, la deuxième le 2ème, etc...

<pre>
def tf_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Création de la matrice rectangulaire
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice rectangulaire
for i in range (len(liste_fichiers)) :
fichier = liste_fichiers[i]
for j in range (len(liste_mots)) :
mot = liste_mots[j]
TF = calcul_TF(fichier,mot)
mat[i][j] = TF
return mat
</pre>

La matrice totale étant plutôt grande, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes :

<math> \begin{pmatrix} 5 & 1 & 3 & 1 & 10 & ... \\ 4 & 0 & 2 & 0 & 5 & ... \\ 4 & 0 & 8 & 0 & 9 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Il est également nécessaire de construire une fonction qui permette d'avoir l'idf de chaque mot dans le corpus. Nous utiliserons donc les fonctions <code>stocke_mots_dossier(dossier)</code> et <code>calcul_idf(dossier,mot,nombre_docs)</code>. Cette fonction a pour paramètre un dossier de fichiers textes (le corpus de textes) et renvoie un tableau qui contient l'idf de chaque mot apparaissant dans le corpus (le corpus contenant 3774 mots différents, la longueur de ce tableau est de 3774).

<pre>
def idf_par_mot(dossier):
""""
dossier : dossier de fichiers textes (corpus complet)
"""

os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier) #3774
T = [0]*len(liste_mots)
for i in range (len(T)):
mot = liste_mots[i]
idf = calcul_idf(dossier,mot,nombre_docs=100)
T[i] = idf
return T
</pre>

Voici un aperçu du résultat obtenu pour les premiers mots ("le", "texte", "de", "base", "un", "voyageur", "attend", "bus"). Les résultats sont arrondis au centième:

<math> \begin{pmatrix} 0.22 & 4.61 & 0.13 & 4.61 & 0.12 & 2.04 & 4.61 & 3.00 & ... \end{pmatrix} </math>

Maintenant que nous avons la matrice des TF et le tableau des idf de chaque mot, nous pouvons créer une fonction qui calculera le TF-idf de chaque mot. Celle-ci prendra en argument un dossier contenant des fichiers textes (le corpus de textes) et renverra une matrice qui contiendra le TF-idf de chaque mot pour chaque texte et qui sera de la même taille (100x3774) et de la même forme que celle des TF.

<pre>
def matrice_TFidf(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Initialisation de la matrice finale
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice finale
matrice_TF = tf_par_texte(dossier)
tableau_idf = idf_par_mot(dossier)
for i in range (len(matrice_TF)):
for j in range (len(matrice_TF[i])):
mat[i][j] = ((matrice_TF[i][j])*(tableau_idf[j]))
return mat
</pre>

La matrice finale étant trop grande pour apparaître ici, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes. Les résultats sont arrondis au centième :

<math> \begin{pmatrix} 1.12 & 4.61 & 0.38 & 4.61 & 1.17 & ... \\ 0.89 & 0.00 & 0.26 & 0.00 & 0.58 & ... \\ 0.89 & 0.00 & 1.02 & 0.00 & 0.105 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Les résultats n'étant pas facilement visibles sous forme de matrice, on peut maintenant créer une procédure qui permettra de mieux les visualiser. Cette procédure prend en argument le corpus de textes et renvoie les 10 TF-idf les plus élevés de chaque texte du corpus.

<pre>
def Top10_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""
os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier)
matrice = matrice_TFidf(dossier)
for i in range (len(matrice)):
print("Texte {:03}".format(i+1))
for j in range (10):
liste_TFidf = matrice[i]
TFidf_max = max(liste_TFidf)
position = liste_TFidf.index(TFidf_max)
mot = liste_mots[position]
print("{:02}. Mot : {:30} TFidf = {:10}".format(j+1,mot,str(TFidf_max)))
matrice[i][position] = 0
print("\n \n")
</pre>

La liste étant relativement longue, elle sera disponible en annexe et les résultats de cette procédure pour quelques textes seront exploités dans la partie suivante.

=== Exemples qui permettent de souligner les spécificités de certains textes du corpus ===

La liste des 10 TF-idf les plus élevés de chaque texte du corpus permet de mettre en avant les spécificités des différents textes.

En effet, pour le texte 098, on obtient la liste suivante :

<pre>
Texte 098
01. Mot : heu TFidf = 13.815510557964275
02. Mot : oh TFidf = 13.815510557964275
03. Mot : eh TFidf = 10.519673691959945
04. Mot : peuh TFidf = 7.824046010856292
05. Mot : ah TFidf = 7.013115794639964
06. Mot : tiens TFidf = 5.318520073865556
07. Mot : interjections TFidf = 4.605170185988092
08. Mot : psst TFidf = 4.605170185988092
09. Mot : hum TFidf = 4.605170185988092
10. Mot : ouf TFidf = 4.605170185988092
</pre>

Grâce à cette liste, on peut supposer que ce texte est écrit uniquement à l'aide d'« interjections », mot qui apparaît d'ailleurs à la 7ème place. Cela peut donc donner une idée de comment le texte est écrit sans même avoir à le lire. En effet, si on lit le texte 98, on peut vérifier que nos suppositions sont vraies.

<pre>
Interjections.
Psst ! heu ! ah ! oh ! hum ! ah ! ouf ! eh ! tiens ! oh ! peuh ! pouah ! ouïe ! ou ! aïe ! eh ! hein ! heu ! pfuitt !
Tiens ! eh ! peuh ! oh ! heu ! bon !
</pre>

Autre exemple, si on choisit le texte 045, on obtient la liste suivante :

<pre>
Texte 045
01. Mot : scène TFidf = 23.472138032568875
02. Mot : premier TFidf = 14.026231589279927
03. Mot : acte TFidf = 13.815510557964275
04. Mot : drelin TFidf = 13.815510557964275
05. Mot : voyageur TFidf = 12.241324971159328
06. Mot : ii TFidf = 11.736069016284437
07. Mot : monnaie TFidf = 9.210340371976184
08. Mot : i TFidf = 8.987196820661973
09. Mot : second TFidf = 7.824046010856292
10. Mot : comédie TFidf = 7.824046010856292
</pre>

Nous remarquons plusieurs mots comme "scène", "acte", "ii", "premier" qui se rapportent au vocabulaire utilisé dans les pièces de théâtre. Si on regarde le texte correspondant à cette liste, on peut voir que son titre est "comédie", qui apparaît dans la liste à la 10ème position et qu'il est effectivement écrit sous la forme d'une pièce de théâtre :

<pre>
Comédie.
Acte premier
Scène I
(Sur la plate-forme arrière d'un autobus S, un jour, vers midi.)
Le Receveur. -la monnaie, s'iou plaît. (Des voyageurs lui passent la monnaie.)
Scène II
(L'autobus s'arrête.)
Le Receveur. - laissons descendre. Priorités ? Une priorité ! C'est complet. Drelin, drelin, drelin.
Acte second
Scène I
(Même décor.)
Premier Voyageur (Jeune, long cou, une tresse autour du chapeau).
- On dirait, monsieur, que vous le faites exprès de me marcher sur les pieds chaque fois qu'il passe des
gens. Second Voyageur (hausse les épaules)
Scène II
(Un troisième voyageur descend.)
Premier Voyageur (s'adressant au public) : Chouette ! une place libre ! J'y cours. (Il se précipite dessus et
l'occupe.)
Acte troisième
Scène I
(La Cour de Rome.)
Un Jeune Élégant (au premier voyageur, maintenant piéton). -l'échancrure de ton pardessus est trop
large. Tu devrais la fermer un peu en faisant remonter le bouton du haut.
Scène II
(À bord d'un autobus S passant devant la cour de Rome.)
Quatrième Voyageur. -Tiens, le type qui se trouvait tout à l'heure avec moi dans l'autobus et qui
s'engueulait avec un bonhomme. Curieuse rencontre. J'en ferai une comédie en trois actes et en prose.
</pre>

La méthode des TF-idf permet donc bien de mettre en avant les différences qu'il peut y avoir entre les textes.

== Conclusion ==
Ici a été présentée la méthode des TF-idf car elle est puissante et que c'est une technique fondamentale de la fouille de données, mais il existe de nombreuses autres méthodes qui peuvent permettent d'arriver à des résultats différents selon les caractéristiques que l'on souhaite mettre en avant. Il existe par exemple des variantes du TF-idf qui permettent de mieux gérer les cas où les textes du corpus ont des tailles extrêmement différentes les uns des autres ou encore les techniques de LDA qui permettent d'extraire automatiquement les thématiques d'un corpus afin de construire des regroupements par thème.

Page réalisée par Rémi Bouvier, étudiant en L1 CMI-Info (2017-2018), dans le cadre du cours de VISI201.

Tuteur : Laurent Vuillon

== Annexes ==

* [http://www.mediafire.com/file/xafo0xzc49ba6va/Exercices_de_style.txt Textes du corpus]
* [http://www.mediafire.com/file/ni07ftjd3w0bn9c/Liste_mots_corpus.txt Liste des mots du corpus]
* [http://www.mediafire.com/file/riboz97iahtehoe/Liste_mots-outils.txt Liste des mots-outils] inspirée de [https://www.ranks.nl/stopwords/french cette liste].
* [http://www.mediafire.com/file/gzd435ccm3m04wc/50_mots_premi%C3%A8re_approche.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus]
* [http://www.mediafire.com/file/8tb1n5gktqt3d8j/50_mots_premi%C3%A8re_approche_sans_mots_outils.txt Top 50 des mots pour la méthode du comptage du nombre d’apparition de chaque mot dans le corpus sans mots-outils]
* [http://www.mediafire.com/file/07argu9or5ruu6r/code_python.py Code python complet]

== Sources ==

Wikipedia :

*[https://fr.wikipedia.org/wiki/Exploration_de_donn%C3%A9es Exploration de données]
*[https://fr.wikipedia.org/wiki/Analyse_des_donn%C3%A9es Analyse de données]
*[https://fr.wikipedia.org/wiki/TF-IDF TF-IDF]

Livre :
* ''"Recherche d'information : applications, modèles et algorithmes; Data mining, décisionnel et big data"'' de Amini et Gaussier aux éditions Eyrolles.

Fouille de données textuelles à partir des "Exercices de style" de R. Queneau

2018-05-21T11:21:41Z

Bouvier : Ajout partie 4.2 et 4.3

La '''fouille de données''', également appelée forage de données, analyse de données ou encore data mining, consiste en l'extraction d'information à partir d'une quantité importante de données. Pour cela, on utilise un ensemble d'algorithmes issus de différentes disciplines scientifiques comme les statistiques ou l'informatique par exemple. Le but de ces algorithmes est de permettre, en fonction de différents critères, d'extraire un maximum de connaissances d'une grande quantité de données. L'analyse de données est très utilisée dans le monde professionnel dans des domaines variés tels que la détection de fraudes, la gestion des relations avec les clients, l'optimisation des sites web ou encore l'analyse de la consommation. Elle a pour but de souligner les relations entre les données (points communs, différences...) afin d'en tirer seulement les informations les plus intéressantes. Les résultats de l'utilisation des algorithmes d'analyse de données sont souvent sous forme de représentation graphique qui permet de mettre en évidence les informations.

L'analyse de données textuelles est une spécialisation de la fouille de données et repose sur les même principes, seulement elle utilise des algorithmes spécialisés ayant pour but d'obtenir de l'information à partir d'un texte ou d'un corpus de textes.

A travers un corpus de textes, nous expliquerons notamment les techniques de TF/IDF permettant d'extraire les mots significatifs du corpus. Toutes les fonctions et procédures dont nous aurons besoin ici seront écrites en Python.

== Présentation du corpus de textes traité ==

Ici, nous présenterons différentes techniques de fouille de données textuelles à partir de l'ouvrage « Exercices de style » de Raymond Queneau. Ce livre, publié en 1947, raconte 99 fois la même histoire de manière différente à chaque fois. Cet ouvrage est un exemple d'une contrainte littéraire utilisée en tant que moteur créatif et est un des premiers textes du mouvement Oulipo dont Raymond Queneau sera l'un des membres les plus importants. Le mouvement Oulipo (Ouvroir de littérature potentielle) est un groupe de littéraire et mathématiciens qui se définissent comme des « rats qui construisent eux-mêmes le labyrinthe dont ils se proposent de sortir. » Les membres de l'Oulipo réfléchissait autour de la notion de « contrainte » afin d'écrire de nouveaux ouvrages ayant pour but d'encourager la création.

L'histoire de base du texte de Raymond Queneau se résume en quelques lignes :

''« Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »''

== Traitement préliminaire du corpus de textes ==

=== Gestion de la ponctuation, des majuscules et des sauts de lignes ===

Pour être exploité, le corpus de texte doit d'abord être traité au préalable, afin de permettre une utilisation simplifiée des algorithmes d'analyse de données. En effet, des éléments comme la ponctuation, les sauts de ligne ou encore les majuscules/minuscules peuvent compliquer l'utilisation des algorithmes s'ils ne sont pas traités en amont. Il est donc nécessaire de créer une procédure permettant de gérer ces éléments. Celle-ci devra gérer les aspects suivants : le remplacement de toutes les majuscules du texte par des minuscules, ainsi que le remplacement de la ponctuation et des sauts de ligne par le caractère « » (un espace). Elle prendra en argument un fichier texte que l'on souhaite modifier, ainsi qu'un numéro de fichier (afin de faciliter la gestion lorsque l'on possède un grand nombre de fichier). et écrira le texte modifié dans un nouveau fichier nommé « modif{:03}.txt".format(i) ». Vous pouvez trouver ci-dessous le code en Python d'une telle procédure :

<pre>
def modification_texte(fichier_in,i):
"""
fichier_in : nom du fichier à modifier
i : numéro du fichier
"""

ponctuation = [",",";",":",".","?","!","«","»","(",")","\"","…","'","-","’"]
f_in = open(fichier_in, mode = "r")
f_out = open(("modif{:03}.txt".format(i)), mode = "w")
ligne = "initialisation"
while (ligne != "") : #Tant que la fin du fichier n'est pas atteinte.
ligne = f_in.readline()
ligne = ligne.lower()
for c in ligne :
if (c in ponctuation) or (c == "\n") :
f_out.write(" ")
else :
f_out.write(c)
f_in.close()
f_out.close()
</pre>

On peut également créer une procédure qui prend en argument un dossier de fichiers à modifier et qui exécute la procédure présentée ci-dessus sur tous les fichiers de ce dossier (cela permet de gérer l'intégralité du corpus de textes).

<pre>
def modification_texte_dossier(dossier_in):
"""
dossier_in : dossier de fichiers à modifier.
"""
import os
os.chdir(dossier_in)
liste_fichiers = os.listdir(dossier_in)
for i in range (len(liste_fichiers)):
modification_texte(liste_fichiers[i],i+1)
</pre>

Pour les toutes les fonctions décrites ci-dessous, on utilisera les textes modifiés (sans ponctuation, sans majuscules et sans sauts de ligne).

=== Création de fonctions utiles pour la fouille de données textuelles ===

Nous allons avoir besoin de créer quelques fonctions de base, très utiles pour l'utilisation des algorithmes d'analyse de données textuelles.

Il est donc nécessaire de créer une fonction qui permet de compter le nombre de mots total du corpus de texte, afin de savoir quelle quantité de données il faudra gérer. La fonction suivante permet de compter le nombre de mots d'un fichier. Elle prend en paramètre un fichier texte et renvoie le nombre de mots contenus dans ce fichier.

<pre>
def compte_mots(fichier):
"""
fichier : fichier texte sur lequel on doit compter le nombre de mots qu'il contient
"""
f = open(fichier, mode = "r")
mots = []
ligne = f.readline()
ligne2 = ligne.split()
mots = mots + ligne2
f.close()
return len(mots)
</pre>

Il faut donc maintenant créer une fonction qui parcourt l'intégralité du corpus afin de connaître le nombre de mots total que contient celui-ci. Cette fonction prend en paramètre un dossier de fichiers textes (le corpus) et renvoie le nombre total de mots contenus dans les fichiers textes de ce dossier.

<pre>
def compte_mots_dossier(dossier):
"""
dossier : dossier de fichier texte (corpus de textes complet)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
total = 0
for i in range (len(liste_fichiers)):
total = total + compte_mots(liste_fichiers[i])
return total
</pre>

En utilisant cette fonction, on peut savoir que le corpus traité contient 14755 mots.

Il est également nécessaire de créer une fonction qui stocke tous les mots du corpus dans un tableau (chaque mot n'apparaît qu'une seule fois dans le tableau). On crée donc d'abord une fonction qui stocke tous les mots d'un fichier. Celle-ci prendra en argument un fichier texte et renverra un tableau contenant chaque mot du fichier texte (pas de doublons dans le tableau).

<pre>
def stocke_mots_fichier(fichier):
"""
fichier texte duquel on souhaite tirer une liste de mots
"""
tab = []
f = open(fichier, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
if not (c in tab) :
tab.append(c)
f.close()
return tab
</pre>

Comme précédemment, on a donc maintenant besoin d'une fonction qui puisse parcourir l'intégralité du corpus de texte. Celle-ci prend en paramètre un dossier de fichiers (le corpus de textes) et renvoie un tableau contenant tous les mots du corpus, chaque mot n’apparaissant qu'une seule fois.

<pre>
def stocke_mots_dossier(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes complet)
"""
tab = []
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
for f in liste_fichiers:
tab_fichier = stocke_mots_fichier(f)
for c in tab_fichier :
if not (c in tab):
tab.append(c)
return tab
</pre>

Nous avons donc maintenant l'intégralité des mots du corpus stockés dans un tableau. En utilisant la commande len(stocke_mots_dossier(dossier)), on obtient que le corpus contient 3774 mots différents les uns des autres.

== Première approche : comptage du nombre d'apparition de chaque mot dans le corpus ==

=== Présentation de la méthode sur 1 texte ===

La première méthode à laquelle on pense pour tirer de l'information d'un grand nombre de données textuelles est de regarder le nombre de fois que chaque mot apparaît dans le corpus. Prenons un exemple sur le texte suivant :

<pre>
Le texte de base.

Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus.
</pre>

Dans ce texte, les termes qui apparaissent le plus souvent sont :
* « un » apparaît 10 fois.
* « le » apparaît 5 fois.
* « de » apparaît 3 fois.
* « il» apparaît 3 fois.
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.

Les informations obtenues ne sont donc pas très intéressantes car elle ne permettent pas de dégager les mots spécifiques à ce texte. En effet, avec cette méthode, on obtiendra principalement les mots outils de la langue française, qui n'ont pas spécialement grand intérêt du fait qu'ils sont présents dans la quasi-totalité des textes et que nous cherchons à définir les mots spécifiques à un texte. Ce que nous pouvons faire pour palier à ce problème est de définir manuellement une liste de mots-outils qui ne seront pas pris en compte dans le comptage des mots. Le problème de cette liste est qu'elle doit être définie à la main par l'utilisateur.

Si l'on néglige la présence de ces mots-outils dans le texte, voici la liste des termes qui apparaissent le plus souvent :
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.
* « voyageur » apparaît 2 fois.

Les autres mots du texte sont des mots-outils où n'apparaissent qu'une seule fois : il n'est donc pas intéressant de les retenir. Nous obtenons donc une liste de mots spécifiques à ce texte qui permet de dégager quelques informations à propos de ce dernier : on sait qu'il parle d'un « homme » et d'un « voyageur » et on peut supposer qu'au moins l'un des deux est qualifié de « jeune ».

Nous avons donc pu tirer une information plus concise du texte à partir de l'intégralité des mots qui le compose.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Il est donc nécessaire d'avoir une fonction qui calcule le nombre d’occurrence de chaque mot dans le corpus. Cette fonction prendra en paramètre un dossier de fichiers textes (le corpus de textes complet) et renverra un dictionnaire avec comme clés les mots contenus dans les fichiers et comme valeurs le nombre de fois où apparaît le mot associé dans le corpus.

<pre>
def occurrence_mots(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
occurrences = {}
for t in liste_fichiers :
f = open(t, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
occurrences[c] = occurrences.get(c,0)+1
f.close()
return occurrences
</pre>

Il est maintenant nécessaire d'afficher les mots dont l'occurrence est la plus élevée. Pour cela nous aurons besoin d'une fonction qui prend en paramètre le corpus de textes et un entier n et qui renvoie la liste des n mots apparaissant le plus dans le corpus (donc affichés selon l'ordre décroissant des occurrences).

<pre>
def affiche_occurence_décroissant(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : nombre de mots que l'on souhaite afficher
"""
dico = occurence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
for i in range (0,min(n,len(tab))):
print("Mot {:03} : '{:30} fréquence : {:03}".format(i+1,tab[i][0] + "\'",tab[i][1]))
</pre>

Grâce à cette fonction nous obtenons que les mots qui apparaissent le plus souvent dans le corpus sont :
* « un » apparaît 575 fois.
* « de » apparaît 457 fois.
* « la » apparaît 294 fois.
* « et » apparaît 275 fois.
* « il » apparaît 274 fois.
* ...

Comme sur l'exemple avec un seul texte, ce sont les mots-outils de la langue française qui apparaissent le plus dans ce corpus (ils sont même davantage mis en avant car le corpus de texte étant plus long, les mots-outils sont encore plus utilisés), ce qui ne nous apporte pas grand chose comme information sur les spécificités du corpus.

Il est donc nécessaire de créer une fonction similaire à la précédente, qui permette de gérer les mots-outils. Celle-ci doit avoir pour argument un dossier contenant les textes du corpus ainsi qu'un entier n, comme la précédente. Elle renverra la liste des n mots qui apparaissent le plus dans le corpus, sans les mots-outils (la liste de ceux-ci était entrée manuellement) et sans les mots de taille égale à 1 caractère que l'on considère comme non pertinents.

<pre>
def affichage_occurrence_décroissant2(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : entier représentant le nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
i = 0
numero_mot = 1
while (numero_mot <= n) and (i < len(tab)) :
if (((tab[i][0]) not in mots_outils) and (len(tab[i][0]) > 1)) :
print("Mot {:03} : '{:30} fréquence : {:03}".format(numero_mot,tab[i][0] + "\'",tab[i][1]))
numero_mot = numero_mot + 1
i = i+1
</pre>

Si l'on exécute cette fonction, voici la liste des termes qui apparaissent le plus souvent dans le corpus :
* « autobus » apparaît 93 fois.
* « chapeau » apparaît 69 fois.
* « long » apparaît 66 fois.
* « cou » apparaît 66 fois.
* « devant » apparaît 64 fois.
* « bouton » apparaît 58 fois.
* « jeune » apparaît 52 fois.
* « tard » apparaît 51 fois.
* « place » apparaît 51 fois.
* « homme » apparaît 48 fois.
Les données obtenues sont donc plus pertinentes et nous donnent plus d'information sur l'histoire racontée dans le corpus. En effet, on peut par exemple déduire que l'« autobus » le « chapeau » ou encore le « bouton » sont des éléments centraux de l'histoire car ils apparaissent de nombreuses fois dans le corpus.

Cette méthode permet donc d'avoir une vue d'ensemble sur ce dont parlent les textes, mais le principal inconvénient est qu'il faille rentrer une liste de mots-outils de la langue française, sachant que celle-ci n'est pas fixée et peu plus ou moins varier selon les textes analysés.

== Méthode des TF-IDF ==
Cette méthode permet justement de gérer automatiquement les mots-outils d'un corpus, sans que l'utilisateur ait besoin de rentrer une liste au préalable.

=== Présentation de la méthode sur une quantité de données réduite ===

Dans cette partie, nous utiliserons les textes suivants, l'exemple portera sur le texte 3.

*Texte 1 :

<pre>
Rétrograde.

Tu devrais ajouter un bouton à ton pardessus, lui dit son ami. Je le rencontrai au milieu de la cour de Rome, après l'avoir quitté se précipitant avec avidité vers une place assise. Il venait de protester contre la poussée d'un autre voyageur, qui, disait-il, le bousculait chaque fois qu'il descendait quelqu'un. Ce jeune homme décharné était porteur d'un chapeau ridicule. Cela se passa sur la plate-forme d'un S complet ce midi-là.
</pre>

*Texte 2 :

<pre>
Distinguo.

Dans un autobus (qu'il ne faut pas prendre pour un autre obus), je vis (et pas avec mon vit) un personnage (qui ne perd son âge) coiffé d'un feutre mou bleu (et non de foutre blême), feutre cerné d'un fil tressé (et non de tril fessé). Il disposait (et non dix posait) d'un long cou (et pas d'un loup con). Comme la foule se bousculait (non que la boule se fousculât), un nouveau voyageur (non veau nouillageur) déplaça le susdit (et non suça ledit plat). Cestuy râla (et non cette huître hala), mais voyant une place libre (et non ployant une vache ivre) s'y précipita (et non si près s'y piqua).
Plus tard je l'aperçus (non pas gel à peine su) devant la gare Saint-Lazare (et non là ou l'hagard ceint le hasard) qui parlait avec un copain (il n'écopait pas d'un pralin) au sujet d'un bouton de son manteau (qu'il ne faut pas confondre avec le bout haut de son menton).
</pre>

*Texte 3 :

<pre>
Passé indéfini.

Je suis monté dans l'autobus de la porte Champerret. Il y avait beaucoup de monde, des jeunes, des vieux, des femmes, des militaires. J'ai payé ma place et puis j'ai regardé autour de moi. Ce n'était pas très intéressant. J'ai quand même fini par remarquer un jeune homme dont j'ai trouvé le cou trop long. J'ai examiné son chapeau et je me suis aperçu qu'au lieu d'un ruban il y avait un galon tressé. Chaque fois qu'un nouveau voyageur montait, ça faisait de la bousculade. Je n'ai rien dit, mais le jeune homme au long cou a tout de même interpellé son voisin. Je n'ai pas entendu ce qu'il lui a dit, mais ils se sont regardés d'un sale oeil. Alors, le jeune homme au long cou est allé s'asseoir précipitamment. En revenant de la porte Champerret, je suis passé devant la gare Saint-Lazare.
J'ai vu mon type qui discutait avec un copain. Celui-ci a désigné du doigt un bouton juste au-dessus de l'échancrure du pardessus. Puis l'autobus m'a emmené et je ne les ai plus vus. J'étais assis et je n'ai pensé à rien.
</pre>

==== Le TF ====

Le TF (Term-Frequency) d'un terme, autrement appelé la fréquence « brute » est précisément le nombre d’occurrences de ce terme dans un texte. Par abus de langage, on parle de « fréquence ». Comme cette méthode a déjà été vue précédemment, nous nous contenterons ici de calculer le TF pour des mots qui nous serviront d'exemple pour la suite et d'introduire une fonction qui permettra de calculer le TF d'un mot dans un texte.
Pour le texte 3, on a donc :
* Pour le mot « un », <math>TF = 7</math>
* Pour le mot « de », <math>TF = 7</math>
* Pour le mot « homme », <math>TF = 3</math>
* Pour le mot « autobus », <math>TF = 2</math>
* Pour le mot « pardessus », <math>TF = 1</math>
* Pour le mot « ruban », <math>TF = 1</math>
Nous retrouvons donc le même problème que précédemment où les mots-outils sont mis en avant.

Le code de la fonction qui permet de calculer le TF d'un mot dans un texte est disponible ci-dessous :

<pre>
def calcul_TF(fichier,mot):
"""
fichier : fichier texte que l'on va parcourir
mot : chaîne de caractères dont on souhaite compter le nombre d'apparitions
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
f = open(fichier, mode = "r")
ligne = f.readline()
Freq = ligne.count(mot)
f.close()
return Freq
</pre>

==== L'IDF ====

Pour palier au problème que pose le TF, nous introduisons l'IDF. En effet, avec la méthode des TF tous les termes qui apparaissent dans un document avec la même fréquence auront la même importance. Or, les termes qui se trouvent dans peu de documents permettent de mieux différencier ces derniers des textes dans lesquels ils se trouvent en nombre élevé. Ces termes ont donc un pouvoir de discrimination plus grand que celui des termes apparaissant dans beaucoup de documents. L'IDF (inverse document frequency) est une mesure de l'importance du terme dans l'ensemble du corpus. La formule de l'idf est la suivante :

<math>idf_{t}=\ln{\frac{N}{df_{t}}} </math>
* où <math>N</math> est le nombre total de documents dans le corpus
* et <math>df_{t}</math> le nombre de documents où le terme <math>t</math> apparaît (on doit avoir <math>df_{t} \ne 0 </math>)

On cherchera donc d'abord à créer une fonction qui permette de calculer le df d'un mot dans un corpus de textes. Cette fonction prend en argument un dossier de fichiers textes (le corpus de documents) et un mot pour lequel on souhaite calculer le df. Elle renvoie le df de ce mot, c'est-à-dire le nombre de fichiers où ce mot apparaît.

<pre>
def calcul_df(dossier,mot):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre le df
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
nombre_doc = 0
for c in liste_fichiers :
f = open(c, mode = "r")
texte = f.readline()
if mot in texte :
nombre_doc = nombre_doc + 1
f.close()
return nombre_doc
</pre>

La fonction qui permet de calculer l'idf d'un terme est donc définie simplement de la manière suivante :
<pre>
def calcul_idf(dossier,mot,nombre_docs):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre l'idf
nombre_docs : entier représentant le nombre de documents du corpus
"""
return log(nombre_docs / (calcul_df(dossier,mot)))
</pre>

En utilisant ces fonctions, on peut donc avoir l'idf des mots du texte 3 pour lesquels nous avons calculé le tf précédemment (dans l'exemple, le nombre total de documents est de 3) :
* Pour le mot « un », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « de », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « homme », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « autobus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « pardessus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « ruban », <math>idf=\ln{\frac{3}{1}} \approx 1,099</math>

==== Le TF-IDF ====

Le TF-idf s'obtient en multipliant les deux valeurs obtenues :

<math>TFidf_{t} = TF_{t} \times idf_{t} </math>
où <math>t</math> est le terme pour lequel on calcule le TF-idf.

Pour l'exemple précédent (texte 3), on a donc :
* Pour le mot « un », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « de », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « homme », <math>TFidf = 3 \times 0,405 = 1,215</math>
* Pour le mot « autobus », <math>TFidf = 2 \times 0,405 = 0,81</math>
* Pour le mot « pardessus », <math>TFidf = 1 \times 0,405 = 0,405</math>
* Pour le mot « ruban », <math>TFidf = 1 \times 1,099 = 1,099</math>

On obtient donc les mots par ordre de pertinence : homme, autobus, pardessus, un, de. Cela a permis de supprimer les mots-outils qui se trouvaient dans les 3 documents et de faire ressortir d'autres mots importants.

Le mot « homme » à quant à lui le TF-idf le plus élevé, car il apparaît 3 fois dans le texte 3 et apparaît uniquement dans 2 textes sur 3 du corpus.

Le mot « ruban » a un TF-idf plus élevé que les mots « autobus » et « pardessus » alors qu'il n’apparaît qu'une seule fois dans le texte 3, mais c'est parce qu'il n’apparaît que dans le texte 3, ce qui montre bien que le TF-idf permet de mettre en avant les spécificités de chaque texte.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonction qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Nous allons commencer par écrire une fonction qui permette de calculer l'intégralité des TF de chaque mot texte par texte. Pour cela, nous aurons besoin des fonction stocke_mots_dossier(dossier) et calcul_TF(fichier,mot) vues précédemment. Cette fonction devra prendre en argument un dossier de fichiers textes (le corpus de textes) et renverra une matrice rectangulaire qui contient sur chaque ligne le TF de chaque mot du corpus pour un texte donné. Le matrice devra donc avoir 100 lignes et 3774 colonnes et sera donc de la forme suivante :

<math> \begin{pmatrix} TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ ... & ... & ... & ... & ... \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \end{pmatrix} </math>

La première ligne représentant le 1er texte, la deuxième le 2ème, etc...

<pre>
def tf_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Création de la matrice rectangulaire
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice rectangulaire
for i in range (len(liste_fichiers)) :
fichier = liste_fichiers[i]
for j in range (len(liste_mots)) :
mot = liste_mots[j]
TF = calcul_TF(fichier,mot)
mat[i][j] = TF
return mat
</pre>

La matrice totale étant plutôt grande, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes :

<math> \begin{pmatrix} 5 & 1 & 3 & 1 & 10 & ... \\ 4 & 0 & 2 & 0 & 5 & ... \\ 4 & 0 & 8 & 0 & 9 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Il est également nécessaire de construire une fonction qui permette d'avoir l'idf de chaque mot dans le corpus. Nous utiliserons donc les fonctions stocke_mots_dossier(dossier) et calcul_idf(dossier,mot,nombre_docs). Cette fonction a pour paramètre un dossier de fichiers textes (le corpus de textes) et renvoie un tableau qui contient l'idf de chaque mot apparaissant dans le corpus (le corpus contenant 3774 mots différents, la longueur de ce tableau est de 3774).

<pre>
def idf_par_mot(dossier):
""""
dossier : dossier de fichiers textes (corpus complet)
"""

os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier) #3774
T = [0]*len(liste_mots)
for i in range (len(T)):
mot = liste_mots[i]
idf = calcul_idf(dossier,mot,nombre_docs=100)
T[i] = idf
return T
</pre>

Voici un aperçu du résultat obtenu pour les premiers mots ("le", "texte", "de", "base", "un", "voyageur", "attend", "bus"). Les résultats sont arrondis au centième:

<math> \begin{pmatrix} 0.22 & 4.61 & 0.13 & 4.61 & 0.12 & 2.04 & 4.61 & 3.00 & ... \end{pmatrix} </math>

Maintenant que nous avons la matrice des TF et le tableau des idf de chaque mot, nous pouvons créer une fonction qui calculera le TF-idf de chaque mot. Celle-ci prendra en argument un dossier contenant des fichiers textes (le corpus de textes) et renverra une matrice qui contiendra le Tfidf de chaque mot pour chaque texte et qui sera de la même taille (100x3774) et de la même forme que celle des TF.

<pre>
def matrice_TFidf(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Initialisation de la matrice finale
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice finale
matrice_TF = tf_par_texte(dossier)
tableau_idf = idf_par_mot(dossier)
for i in range (len(matrice_TF)):
for j in range (len(matrice_TF[i])):
mat[i][j] = ((matrice_TF[i][j])*(tableau_idf[j]))
return mat
</pre>

La matrice finale étant trop grande pour apparaître ici, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes. Les résultats sont arrondis au centième :

<math> \begin{pmatrix} 1.12 & 4.61 & 0.38 & 4.61 & 1.17 & ... \\ 0.89 & 0.00 & 0.26 & 0.00 & 0.58 & ... \\ 0.89 & 0.00 & 1.02 & 0.00 & 0.105 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Les résultats n'étant pas facilement visibles sous forme de matrice, on peut maintenant créer une procédure qui permettra de mieux les visualiser. Cette procédure prend en argument le corpus de textes et renvoie les 10 TF-idf les plus élevés de chaque texte du corpus.

<pre>
def Top10_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""
os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier)
matrice = matrice_TFidf(dossier)
for i in range (len(matrice)):
print("Texte {:03}".format(i+1))
for j in range (10):
liste_TFidf = matrice[i]
TFidf_max = max(liste_TFidf)
position = liste_TFidf.index(TFidf_max)
mot = liste_mots[position]
print("{:02}. Mot : {:30} TFidf = {:10}".format(j+1,mot,str(TFidf_max)))
matrice[i][position] = 0
print("\n \n")
</pre>

La liste étant relativement longue, elle sera disponible en annexe et les résultats de cette procédure pour quelques textes seront exploités dans la partie suivante.

=== Exemples qui permettent de souligner les spécificités de certaines textes du corpus ===

La liste des 10 TF-idf les plus élevés de chaque texte du corpus permet de mettre en avant les spécificités des différents textes.

En effet, pour le texte 098, on obtient la liste suivante :

<pre>
Texte 098
01. Mot : heu TFidf = 13.815510557964275
02. Mot : oh TFidf = 13.815510557964275
03. Mot : eh TFidf = 10.519673691959945
04. Mot : peuh TFidf = 7.824046010856292
05. Mot : ah TFidf = 7.013115794639964
06. Mot : tiens TFidf = 5.318520073865556
07. Mot : interjections TFidf = 4.605170185988092
08. Mot : psst TFidf = 4.605170185988092
09. Mot : hum TFidf = 4.605170185988092
10. Mot : ouf TFidf = 4.605170185988092
</pre>

Grâce à cette liste, on peut supposer que ce texte est écrit uniquement à l'aide d'« interjections », mot qui apparaît d'ailleurs à la 7ème place. Cela peut donc donner une idée de comment le texte est écrit sans même avoir à le lire. En effet, si on lit le texte 98, on peut vérifier que nos suppositions sont vraies.

<pre>
Interjections.
Psst ! heu ! ah ! oh ! hum ! ah ! ouf ! eh ! tiens ! oh ! peuh ! pouah ! ouïe ! ou ! aïe ! eh ! hein ! heu ! pfuitt !
Tiens ! eh ! peuh ! oh ! heu ! bon !
</pre>

Autre exemple, si on choisit le texte 045, on obtient la liste suivante :

<pre>
Texte 045
01. Mot : scène TFidf = 23.472138032568875
02. Mot : premier TFidf = 14.026231589279927
03. Mot : acte TFidf = 13.815510557964275
04. Mot : drelin TFidf = 13.815510557964275
05. Mot : voyageur TFidf = 12.241324971159328
06. Mot : ii TFidf = 11.736069016284437
07. Mot : monnaie TFidf = 9.210340371976184
08. Mot : i TFidf = 8.987196820661973
09. Mot : second TFidf = 7.824046010856292
10. Mot : comédie TFidf = 7.824046010856292
</pre>

Nous remarquons plusieurs mots comment "scène", "acte", "ii", "premier" qui se rapportent au vocabulaire utilisé dans les pièces de théâtre. Si on regarde le texte correspondant à cette liste, on peut voir que son titre est "comédie", qui apparaît dans la liste à la 10ème position et qu'il est effectivement écrit sous la forme d'une pièce de théâtre :

<pre>
Comédie.
Acte premier
Scène I
(Sur la plate-forme arrière d'un autobus S, un jour, vers midi.)
Le Receveur. -la monnaie, s'iou plaît. (Des voyageurs lui passent la monnaie.)
Scène II
(L'autobus s'arrête.)
Le Receveur. - laissons descendre. Priorités ? Une priorité ! C'est complet. Drelin, drelin, drelin.
Acte second
Scène I
(Même décor.)
Premier Voyageur (Jeune, long cou, une tresse autour du chapeau).
- On dirait, monsieur, que vous le faites exprès de me marcher sur les pieds chaque fois qu'il passe des
gens. Second Voyageur (hausse les épaules)
Scène II
(Un troisième voyageur descend.)
Premier Voyageur (s'adressant au public) : Chouette ! une place libre ! J'y cours. (Il se précipite dessus et
l'occupe.)
Acte troisième
Scène I
(La Cour de Rome.)
Un Jeune Élégant (au premier voyageur, maintenant piéton). -l'échancrure de ton pardessus est trop
large. Tu devrais la fermer un peu en faisant remonter le bouton du haut.
Scène II
(À bord d'un autobus S passant devant la cour de Rome.)
Quatrième Voyageur. -Tiens, le type qui se trouvait tout à l'heure avec moi dans l'autobus et qui
s'engueulait avec un bonhomme. Curieuse rencontre. J'en ferai une comédie en trois actes et en prose.
</pre>

La méthode des TF-idf permet donc bien de mettre en avant les différences qu'il peut y avoir entre les textes.

== Conclusion ==
Ici a été présentée la méthode des TF-idf car elle est puissante et que c'est une technique fondamentale de la fouille de données, mais il existe de nombreuses autres méthodes qui peuvent permettent d'arriver à des résultats différents selon les caractéristiques que l'on souhaite mettre en avant. Il existe par exemple des variantes du TF-idf qui permettent de mieux gérer les cas où les textes du corpus ont des tailles extrêmement différentes les uns des autres ou encore les techniques de LDA qui permettent d'extraire automatiquement les thématiques d'un corpus afin de construire des regroupements par thème.

== Annexes ==

== Sources ==

Fouille de données textuelles à partir des "Exercices de style" de R. Queneau

2018-05-18T21:45:40Z

Bouvier :

La '''fouille de données''', également appelée forage de données, analyse de données ou encore data mining, consiste en l'extraction d'information à partir d'une quantité importante de données. Pour cela, on utilise un ensemble d'algorithmes issus de différentes disciplines scientifiques comme les statistiques ou l'informatique par exemple. Le but de ces algorithmes est de permettre, en fonction de différents critères, d'extraire un maximum de connaissances d'une grande quantité de données. L'analyse de données est très utilisée dans le monde professionnel dans des domaines variés tels que la détection de fraudes, la gestion des relations avec les clients, l'optimisation des sites web ou encore l'analyse de la consommation. Elle a pour but de souligner les relations entre les données (points communs, différences...) afin d'en tirer seulement les informations les plus intéressantes. Les résultats de l'utilisation des algorithmes d'analyse de données sont souvent sous forme de représentation graphique qui permet de mettre en évidence les informations.

L'analyse de données textuelles est une spécialisation de la fouille de données et repose sur les même principes, seulement elle utilise des algorithmes spécialisés ayant pour but d'obtenir de l'information à partir d'un texte ou d'un corpus de textes.

A travers un corpus de textes, nous expliquerons notamment les techniques de TF/IDF permettant d'extraire les mots significatifs du corpus. Toutes les fonctions et procédures dont nous aurons besoin ici seront écrites en Python.

== Présentation du corpus de textes traité ==

Ici, nous présenterons différentes techniques de fouille de données textuelles à partir de l'ouvrage « Exercices de style » de Raymond Queneau. Ce livre, publié en 1947, raconte 99 fois la même histoire de manière différente à chaque fois. Cet ouvrage est un exemple d'une contrainte littéraire utilisée en tant que moteur créatif et est un des premiers textes du mouvement Oulipo dont Raymond Queneau sera l'un des membres les plus importants. Le mouvement Oulipo (Ouvroir de littérature potentielle) est un groupe de littéraire et mathématiciens qui se définissent comme des « rats qui construisent eux-mêmes le labyrinthe dont ils se proposent de sortir. » Les membres de l'Oulipo réfléchissait autour de la notion de « contrainte » afin d'écrire de nouveaux ouvrages ayant pour but d'encourager la création.

L'histoire de base du texte de Raymond Queneau se résume en quelques lignes :

''« Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »''

== Traitement préliminaire du corpus de textes ==

=== Gestion de la ponctuation, des majuscules et des sauts de lignes ===

Pour être exploité, le corpus de texte doit d'abord être traité au préalable, afin de permettre une utilisation simplifiée des algorithmes d'analyse de données. En effet, des éléments comme la ponctuation, les sauts de ligne ou encore les majuscules/minuscules peuvent compliquer l'utilisation des algorithmes s'ils ne sont pas traités en amont. Il est donc nécessaire de créer une procédure permettant de gérer ces éléments. Celle-ci devra gérer les aspects suivants : le remplacement de toutes les majuscules du texte par des minuscules, ainsi que le remplacement de la ponctuation et des sauts de ligne par le caractère « » (un espace). Elle prendra en argument un fichier texte que l'on souhaite modifier, ainsi qu'un numéro de fichier (afin de faciliter la gestion lorsque l'on possède un grand nombre de fichier). et écrira le texte modifié dans un nouveau fichier nommé « modif{:03}.txt".format(i) ». Vous pouvez trouver ci-dessous le code en Python d'une telle procédure :

<pre>
def modification_texte(fichier_in,i):
"""
fichier_in : nom du fichier à modifier
i : numéro du fichier
"""

ponctuation = [",",";",":",".","?","!","«","»","(",")","\"","…","'","-","’"]
f_in = open(fichier_in, mode = "r")
f_out = open(("modif{:03}.txt".format(i)), mode = "w")
ligne = "initialisation"
while (ligne != "") : #Tant que la fin du fichier n'est pas atteinte.
ligne = f_in.readline()
ligne = ligne.lower()
for c in ligne :
if (c in ponctuation) or (c == "\n") :
f_out.write(" ")
else :
f_out.write(c)
f_in.close()
f_out.close()
</pre>

On peut également créer une procédure qui prend en argument un dossier de fichiers à modifier et qui exécute la procédure présentée ci-dessus sur tous les fichiers de ce dossier (cela permet de gérer l'intégralité du corpus de textes).

<pre>
def modification_texte_dossier(dossier_in):
"""
dossier_in : dossier de fichiers à modifier.
"""
import os
os.chdir(dossier_in)
liste_fichiers = os.listdir(dossier_in)
for i in range (len(liste_fichiers)):
modification_texte(liste_fichiers[i],i+1)
</pre>

Pour les toutes les fonctions décrites ci-dessous, on utilisera les textes modifiés (sans ponctuation, sans majuscules et sans sauts de ligne).

=== Création de fonctions utiles pour la fouille de données textuelles ===

Nous allons avoir besoin de créer quelques fonctions de base, très utiles pour l'utilisation des algorithmes d'analyse de données textuelles.

Il est donc nécessaire de créer une fonction qui permet de compter le nombre de mots total du corpus de texte, afin de savoir quelle quantité de données il faudra gérer. La fonction suivante permet de compter le nombre de mots d'un fichier. Elle prend en paramètre un fichier texte et renvoie le nombre de mots contenus dans ce fichier.

<pre>
def compte_mots(fichier):
"""
fichier : fichier texte sur lequel on doit compter le nombre de mots qu'il contient
"""
f = open(fichier, mode = "r")
mots = []
ligne = f.readline()
ligne2 = ligne.split()
mots = mots + ligne2
f.close()
return len(mots)
</pre>

Il faut donc maintenant créer une fonction qui parcourt l'intégralité du corpus afin de connaître le nombre de mots total que contient celui-ci. Cette fonction prend en paramètre un dossier de fichiers textes (le corpus) et renvoie le nombre total de mots contenus dans les fichiers textes de ce dossier.

<pre>
def compte_mots_dossier(dossier):
"""
dossier : dossier de fichier texte (corpus de textes complet)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
total = 0
for i in range (len(liste_fichiers)):
total = total + compte_mots(liste_fichiers[i])
return total
</pre>

En utilisant cette fonction, on peut savoir que le corpus traité contient 14755 mots.

Il est également nécessaire de créer une fonction qui stocke tous les mots du corpus dans un tableau (chaque mot n'apparaît qu'une seule fois dans le tableau). On crée donc d'abord une fonction qui stocke tous les mots d'un fichier. Celle-ci prendra en argument un fichier texte et renverra un tableau contenant chaque mot du fichier texte (pas de doublons dans le tableau).

<pre>
def stocke_mots_fichier(fichier):
"""
fichier texte duquel on souhaite tirer une liste de mots
"""
tab = []
f = open(fichier, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
if not (c in tab) :
tab.append(c)
f.close()
return tab
</pre>

Comme précédemment, on a donc maintenant besoin d'une fonction qui puisse parcourir l'intégralité du corpus de texte. Celle-ci prend en paramètre un dossier de fichiers (le corpus de textes) et renvoie un tableau contenant tous les mots du corpus, chaque mot n’apparaissant qu'une seule fois.

<pre>
def stocke_mots_dossier(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes complet)
"""
tab = []
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
for f in liste_fichiers:
tab_fichier = stocke_mots_fichier(f)
for c in tab_fichier :
if not (c in tab):
tab.append(c)
return tab
</pre>

Nous avons donc maintenant l'intégralité des mots du corpus stockés dans un tableau. En utilisant la commande len(stocke_mots_dossier(dossier)), on obtient que le corpus contient 3774 mots différents les uns des autres.

== Première approche : comptage du nombre d'apparition de chaque mot dans le corpus ==

=== Présentation de la méthode sur 1 texte ===

La première méthode à laquelle on pense pour tirer de l'information d'un grand nombre de données textuelles est de regarder le nombre de fois que chaque mot apparaît dans le corpus. Prenons un exemple sur le texte suivant :

<pre>
« Le texte de base.

Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »
</pre>

Dans ce texte, les termes qui apparaissent le plus souvent sont :
* « un » apparaît 10 fois.
* « le » apparaît 5 fois.
* « de » apparaît 3 fois.
* « il» apparaît 3 fois.
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.

Les informations obtenues ne sont donc pas très intéressantes car elle ne permettent pas de dégager les mots spécifiques à ce texte. En effet, avec cette méthode, on obtiendra principalement les mots outils de la langue française, qui n'ont pas spécialement grand intérêt du fait qu'ils sont présents dans la quasi-totalité des textes et que nous cherchons à définir les mots spécifiques à un texte. Ce que nous pouvons faire pour palier à ce problème est de définir manuellement une liste de mots-outils qui ne seront pas pris en compte dans le comptage des mots. Le problème de cette liste est qu'elle doit être définie à la main par l'utilisateur.

Si l'on néglige la présence de ces mots-outils dans le texte, voici la liste des termes qui apparaissent le plus souvent :
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.
* « voyageur » apparaît 2 fois.

Les autres mots du texte sont des mots-outils où n'apparaissent qu'une seule fois : il n'est donc pas intéressant de les retenir. Nous obtenons donc une liste de mots spécifiques à ce texte qui permet de dégager quelques informations à propos de ce dernier : on sait qu'il parle d'un « homme » et d'un « voyageur » et on peut supposer qu'au moins l'un des deux est qualifié de « jeune ».

Nous avons donc pu tirer une information plus concise du texte à partir de l'intégralité des mots qui le compose.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Il est donc nécessaire d'avoir une fonction qui calcule le nombre d’occurrence de chaque mot dans le corpus. Cette fonction prendra en paramètre un dossier de fichiers textes (le corpus de textes complet) et renverra un dictionnaire avec comme clés les mots contenus dans les fichiers et comme valeurs le nombre de fois où apparaît le mot associé dans le corpus.

<pre>
def occurrence_mots(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
occurrences = {}
for t in liste_fichiers :
f = open(t, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
occurrences[c] = occurrences.get(c,0)+1
f.close()
return occurrences
</pre>

Il est maintenant nécessaire d'afficher les mots dont l'occurrence est la plus élevée. Pour cela nous aurons besoin d'une fonction qui prend en paramètre le corpus de textes et un entier n et qui renvoie la liste des n mots apparaissant le plus dans le corpus (donc affichés selon l'ordre décroissant des occurrences).

<pre>
def affiche_occurence_décroissant(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : nombre de mots que l'on souhaite afficher
"""
dico = occurence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
for i in range (0,min(n,len(tab))):
print("Mot {:03} : '{:30} fréquence : {:03}".format(i+1,tab[i][0] + "\'",tab[i][1]))
</pre>

Grâce à cette fonction nous obtenons que les mots qui apparaissent le plus souvent dans le corpus sont :
* « un » apparaît 575 fois.
* « de » apparaît 457 fois.
* « la » apparaît 294 fois.
* « et » apparaît 275 fois.
* « il » apparaît 274 fois.
* ...

Comme sur l'exemple avec un seul texte, ce sont les mots-outils de la langue française qui apparaissent le plus dans ce corpus (ils sont même davantage mis en avant car le corpus de texte étant plus long, les mots-outils sont encore plus utilisés), ce qui ne nous apporte pas grand chose comme information sur les spécificités du corpus.

Il est donc nécessaire de créer une fonction similaire à la précédente, qui permette de gérer les mots-outils. Celle-ci doit avoir pour argument un dossier contenant les textes du corpus ainsi qu'un entier n, comme la précédente. Elle renverra la liste des n mots qui apparaissent le plus dans le corpus, sans les mots-outils (la liste de ceux-ci était entrée manuellement) et sans les mots de taille égale à 1 caractère que l'on considère comme non pertinents.

<pre>
def affichage_occurrence_décroissant2(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : entier représentant le nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
i = 0
numero_mot = 1
while (numero_mot <= n) and (i < len(tab)) :
if (((tab[i][0]) not in mots_outils) and (len(tab[i][0]) > 1)) :
print("Mot {:03} : '{:30} fréquence : {:03}".format(numero_mot,tab[i][0] + "\'",tab[i][1]))
numero_mot = numero_mot + 1
i = i+1
</pre>

Si l'on exécute cette fonction, voici la liste des termes qui apparaissent le plus souvent dans le corpus :
* « autobus » apparaît 93 fois.
* « chapeau » apparaît 69 fois.
* « long » apparaît 66 fois.
* « cou » apparaît 66 fois.
* « devant » apparaît 64 fois.
* « bouton » apparaît 58 fois.
* « jeune » apparaît 52 fois.
* « tard » apparaît 51 fois.
* « place » apparaît 51 fois.
* « homme » apparaît 48 fois.
Les données obtenues sont donc plus pertinentes et nous donnent plus d'information sur l'histoire racontée dans le corpus. En effet, on peut par exemple déduire que l'« autobus » le « chapeau » ou encore le « bouton » sont des éléments centraux de l'histoire car ils apparaissent de nombreuses fois dans le corpus.

Cette méthode permet donc d'avoir une vue d'ensemble sur ce dont parlent les textes, mais le principal inconvénient est qu'il faille rentrer une liste de mots-outils de la langue française, sachant que celle-ci n'est pas fixée et peu plus ou moins varier selon les textes analysés.

== Méthode des TF-IDF ==
Cette méthode permet justement de gérer automatiquement les mots-outils d'un corpus, sans que l'utilisateur ait besoin de rentrer une liste au préalable.

=== Présentation de la méthode sur une quantité de données réduite ===

Dans cette partie, nous utiliserons les textes suivants, l'exemple portera sur le texte 3.

*Texte 1 :

<pre>
Rétrograde.

Tu devrais ajouter un bouton à ton pardessus, lui dit son ami. Je le rencontrai au milieu de la cour de Rome, après l'avoir quitté se précipitant avec avidité vers une place assise. Il venait de protester contre la poussée d'un autre voyageur, qui, disait-il, le bousculait chaque fois qu'il descendait quelqu'un. Ce jeune homme décharné était porteur d'un chapeau ridicule. Cela se passa sur la plate-forme d'un S complet ce midi-là.
</pre>

*Texte 2 :

<pre>
Distinguo.

Dans un autobus (qu'il ne faut pas prendre pour un autre obus), je vis (et pas avec mon vit) un personnage (qui ne perd son âge) coiffé d'un feutre mou bleu (et non de foutre blême), feutre cerné d'un fil tressé (et non de tril fessé). Il disposait (et non dix posait) d'un long cou (et pas d'un loup con). Comme la foule se bousculait (non que la boule se fousculât), un nouveau voyageur (non veau nouillageur) déplaça le susdit (et non suça ledit plat). Cestuy râla (et non cette huître hala), mais voyant une place libre (et non ployant une vache ivre) s'y précipita (et non si près s'y piqua).
Plus tard je l'aperçus (non pas gel à peine su) devant la gare Saint-Lazare (et non là ou l'hagard ceint le hasard) qui parlait avec un copain (il n'écopait pas d'un pralin) au sujet d'un bouton de son manteau (qu'il ne faut pas confondre avec le bout haut de son menton).
</pre>

*Texte 3 :

<pre>
Passé indéfini.

Je suis monté dans l'autobus de la porte Champerret. Il y avait beaucoup de monde, des jeunes, des vieux, des femmes, des militaires. J'ai payé ma place et puis j'ai regardé autour de moi. Ce n'était pas très intéressant. J'ai quand même fini par remarquer un jeune homme dont j'ai trouvé le cou trop long. J'ai examiné son chapeau et je me suis aperçu qu'au lieu d'un ruban il y avait un galon tressé. Chaque fois qu'un nouveau voyageur montait, ça faisait de la bousculade. Je n'ai rien dit, mais le jeune homme au long cou a tout de même interpellé son voisin. Je n'ai pas entendu ce qu'il lui a dit, mais ils se sont regardés d'un sale oeil. Alors, le jeune homme au long cou est allé s'asseoir précipitamment. En revenant de la porte Champerret, je suis passé devant la gare Saint-Lazare.
J'ai vu mon type qui discutait avec un copain. Celui-ci a désigné du doigt un bouton juste au-dessus de l'échancrure du pardessus. Puis l'autobus m'a emmené et je ne les ai plus vus. J'étais assis et je n'ai pensé à rien.
</pre>

==== Le TF ====

Le TF (Term-Frequency) d'un terme, autrement appelé la fréquence « brute » est précisément le nombre d’occurrences de ce terme dans un texte. Par abus de langage, on parle de « fréquence ». Comme cette méthode a déjà été vue précédemment, nous nous contenterons ici de calculer le TF pour des mots qui nous serviront d'exemple pour la suite et d'introduire une fonction qui permettra de calculer le TF d'un mot dans un texte.
Pour le texte 3, on a donc :
* Pour le mot « un », <math>TF = 7</math>
* Pour le mot « de », <math>TF = 7</math>
* Pour le mot « homme », <math>TF = 3</math>
* Pour le mot « autobus », <math>TF = 2</math>
* Pour le mot « pardessus », <math>TF = 1</math>
* Pour le mot « ruban », <math>TF = 1</math>
Nous retrouvons donc le même problème que précédemment où les mots-outils sont mis en avant.

Le code de la fonction qui permet de calculer le TF d'un mot dans un texte est disponible ci-dessous :

<pre>
def calcul_TF(fichier,mot):
"""
fichier : fichier texte que l'on va parcourir
mot : chaîne de caractères dont on souhaite compter le nombre d'apparitions
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
f = open(fichier, mode = "r")
ligne = f.readline()
Freq = ligne.count(mot)
f.close()
return Freq
</pre>

==== L'IDF ====

Pour palier au problème que pose le TF, nous introduisons l'IDF. En effet, avec la méthode des TF tous les termes qui apparaissent dans un document avec la même fréquence auront la même importance. Or, les termes qui se trouvent dans peu de documents permettent de mieux différencier ces derniers des textes dans lesquels ils se trouvent en nombre élevé. Ces termes ont donc un pouvoir de discrimination plus grand que celui des termes apparaissant dans beaucoup de documents. L'IDF (inverse document frequency) est une mesure de l'importance du terme dans l'ensemble du corpus. La formule de l'idf est la suivante :

<math>idf_{t}=\ln{\frac{N}{df_{t}}} </math>
* où <math>N</math> est le nombre total de documents dans le corpus
* et <math>df_{t}</math> le nombre de documents où le terme <math>t</math> apparaît (on doit avoir <math>df_{t} \ne 0 </math>)

On cherchera donc d'abord à créer une fonction qui permette de calculer le df d'un mot dans un corpus de textes. Cette fonction prend en argument un dossier de fichiers textes (le corpus de documents) et un mot pour lequel on souhaite calculer le df. Elle renvoie le df de ce mot, c'est-à-dire le nombre de fichiers où ce mot apparaît.

<pre>
def calcul_df(dossier,mot):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre le df
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
nombre_doc = 0
for c in liste_fichiers :
f = open(c, mode = "r")
texte = f.readline()
if mot in texte :
nombre_doc = nombre_doc + 1
f.close()
return nombre_doc
</pre>

La fonction qui permet de calculer l'idf d'un terme est donc définie simplement de la manière suivante :
<pre>
def calcul_idf(dossier,mot,nombre_docs):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre l'idf
nombre_docs : entier représentant le nombre de documents du corpus
"""
return log(nombre_docs / (calcul_df(dossier,mot)))
</pre>

En utilisant ces fonctions, on peut donc avoir l'idf des mots du texte 3 pour lesquels nous avons calculé le tf précédemment :
* Pour le mot « un », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « de », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « homme », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « autobus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « pardessus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « ruban », <math>idf=\ln{\frac{3}{1}} \approx 1,099</math>

==== Le TF-IDF ====

Le TF-idf s'obtient en multipliant les deux valeurs obtenues :

<math>TFidf_{t} = TF_{t} \times idf_{t} </math>
où <math>t</math> est le terme pour lequel on calcule le TF-idf.

Pour l'exemple précédent (texte 3), on a donc :
* Pour le mot « un », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « de », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « homme », <math>TFidf = 3 \times 0,405 = 1,215</math>
* Pour le mot « autobus », <math>TFidf = 2 \times 0,405 = 0,81</math>
* Pour le mot « pardessus », <math>TFidf = 1 \times 0,405 = 0,405</math>
* Pour le mot « ruban », <math>TFidf = 1 \times 1,099 = 1,099</math>

On obtient donc les mots par ordre de pertinence : homme, autobus, pardessus, un, de. Cela a permis de supprimer les mots-outils qui se trouvaient dans les 3 documents et de faire ressortir d'autres mots importants.

Le mot « homme » à quant à lui le TF-idf le plus élevé, car il apparaît 3 fois dans le texte 3 et apparaît uniquement dans 2 textes sur 3 du corpus.

Le mot « ruban » a un TF-idf plus élevé que les mots « autobus » et « pardessus » alors qu'il n’apparaît qu'une seule fois dans le texte 3, mais c'est parce qu'il n’apparaît que dans le texte 3, ce qui montre bien que le TF-idf permet de mettre en avant les spécificités de chaque texte.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonction qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Nous allons commencer par écrire une fonction qui permette de calculer l'intégralité des TF de chaque mot texte par texte. Pour cela, nous aurons besoin des fonction stocke_mots_dossier(dossier) et calcul_TF(fichier,mot) vues précédemment. Cette fonction devra prendre en argument un dossier de fichiers textes (le corpus de textes) et renverra une matrice rectangulaire qui contient sur chaque ligne le TF de chaque mot du corpus pour un texte donné. Le matrice devra donc avoir 100 lignes et 3774 colonnes et sera donc de la forme suivante :

<math> \begin{pmatrix} TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \\ ... & ... & ... & ... & ... \\ TF mot1 & TF mot2 & TF mot3 & ... & TF mot 3774 \end{pmatrix} </math>

La première ligne représentant le 1er texte, la deuxième le 2ème, etc...

<pre>
def tf_par_texte(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Création de la matrice rectangulaire
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice rectangulaire
for i in range (len(liste_fichiers)) :
fichier = liste_fichiers[i]
for j in range (len(liste_mots)) :
mot = liste_mots[j]
TF = calcul_TF(fichier,mot)
mat[i][j] = TF
return mat
</pre>

La matrice totale étant plutôt grande, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes :

<math> \begin{pmatrix} 5 & 1 & 3 & 1 & 10 & ... \\ 4 & 0 & 2 & 0 & 5 & ... \\ 4 & 0 & 8 & 0 & 9 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

Il est également nécessaire de construire une fonction qui permette d'avoir l'idf de chaque mot dans le corpus. Nous utiliserons donc les fonctions stocke_mots_dossier(dossier) et calcul_idf(dossier,mot,nombre_docs). Cette fonction a pour paramètre un dossier de fichiers textes (le corpus de textes) et renvoie un tableau qui contient l'idf de chaque mot apparaissant dans le corpus (le corpus contenant 3774 mots différents, la longueur de ce tableau est de 3774).

<pre>
def idf_par_mot(dossier):
""""
dossier : dossier de fichiers textes (corpus complet)
"""

os.chdir(dossier)
liste_mots = stocke_mots_dossier(dossier) #3774
T = [0]*len(liste_mots)
for i in range (len(T)):
mot = liste_mots[i]
idf = calcul_idf(dossier,mot,nombre_docs=100)
T[i] = idf
return T
</pre>

Voici un aperçu du résultat obtenu pour les premiers mots ("le", "texte", "de", "base", "un", "voyageur", "attend", "bus"). Les résultats sont arrondis au centième:

<math> \begin{pmatrix} 0.22 & 4.61 & 0.13 & 4.61 & 0.12 & 2.04 & 4.61 & 3.00 & ... \end{pmatrix} </math>

Maintenant que nous avons la matrice des TF et le tableau des idf de chaque mot, nous pouvons créer une fonction qui calculera le TF-idf de chaque mot. Celle-ci prendra en argument un dossier contenant des fichiers textes (le corpus de textes) et renverra une matrice qui contiendra le Tfidf de chaque mot pour chaque texte et qui sera de la même taille (100x3774) et de la même forme que celle des TF.

<pre>
def matrice_TFidf(dossier):
"""
dossier : dossier de fichiers textes (corpus complet)
"""

#Initialisation
os.chdir(dossier)
liste_fichiers = os.listdir(dossier) #len = 100
liste_mots = stocke_mots_dossier(dossier) #len = 3774

#Initialisation de la matrice finale
mat = []
for i in range (len(liste_fichiers)) :
mat.append([0]*len(liste_mots))

#Remplissage de la matrice finale
matrice_TF = tf_par_texte(dossier)
tableau_idf = idf_par_mot(dossier)
for i in range (len(matrice_TF)):
for j in range (len(matrice_TF[i])):
mat[i][j] = ((matrice_TF[i][j])*(tableau_idf[j]))
return mat
</pre>

La matrice finale étant trop grande pour apparaître ici, voici un aperçu des résultats de la fonction pour les 5 premiers mots ("le", "texte", "de", "base", "un") et les 3 premiers textes. Les résultats sont arrondis au centième :

<math> \begin{pmatrix} 1.12 & 4.61 & 0.38 & 4.61 & 1.17 & ... \\ 0.89 & 0.00 & 0.26 & 0.00 & 0.58 & ... \\ 0.89 & 0.00 & 1.02 & 0.00 & 0.105 & ... \\ ... & ... & ... & ... & ... & ... \end{pmatrix} </math>

=== Exemples qui permettent de souligner les spécificités de certaines textes du corpus ===

== Conclusion ==

== Annexes ==

== Sources ==

Fouille de données textuelles à partir des "Exercices de style" de R. Queneau

2018-05-18T14:43:21Z

Bouvier : Création du plan et de toutes les parties jusqu'à "4.1 Présentation de la méthode sur une quantité de données réduite" incluse

La '''fouille de données''', également appelée forage de données, analyse de données ou encore data mining, consiste en l'extraction d'information à partir d'une quantité importante de données. Pour cela, on utilise un ensemble d'algorithmes issus de différentes disciplines scientifiques comme les statistiques ou l'informatique par exemple. Le but de ces algorithmes est de permettre, en fonction de différents critères, d'extraire un maximum de connaissances d'une grande quantité de données. L'analyse de données est très utilisée dans le monde professionnel dans des domaines variés tels que la détection de fraudes, la gestion des relations avec les clients, l'optimisation des sites web ou encore l'analyse de la consommation. Elle a pour but de souligner les relations entre les données (points communs, différences...) afin d'en tirer seulement les informations les plus intéressantes. Les résultats de l'utilisation des algorithmes d'analyse de données sont souvent sous forme de représentation graphique qui permet de mettre en évidence les informations.

L'analyse de données textuelles est une spécialisation de la fouille de données et repose sur les même principes, seulement elle utilise des algorithmes spécialisés ayant pour but d'obtenir de l'information à partir d'un texte ou d'un corpus de textes.

A travers un corpus de textes, nous expliquerons notamment les techniques de TF/IDF permettant d'extraire les mots significatifs du corpus. Toutes les fonctions et procédures dont nous aurons besoin ici seront écrites en Python.

== Présentation du corpus de textes traité ==

Ici, nous présenterons différentes techniques de fouille de données textuelles à partir de l'ouvrage « Exercices de style » de Raymond Queneau. Ce livre, publié en 1947, raconte 99 fois la même histoire de manière différente à chaque fois. Cet ouvrage est un exemple d'une contrainte littéraire utilisée en tant que moteur créatif et est un des premiers textes du mouvement Oulipo dont Raymond Queneau sera l'un des membres les plus importants. Le mouvement Oulipo (Ouvroir de littérature potentielle) est un groupe de littéraire et mathématiciens qui se définissent comme des « rats qui construisent eux-mêmes le labyrinthe dont ils se proposent de sortir. » Les membres de l'Oulipo réfléchissait autour de la notion de « contrainte » afin d'écrire de nouveaux ouvrages ayant pour but d'encourager la création.

L'histoire de base du texte de Raymond Queneau se résume en quelques lignes :

''« Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »''

== Traitement préliminaire du corpus de textes ==

=== Gestion de la ponctuation, des majuscules et des sauts de lignes ===

Pour être exploité, le corpus de texte doit d'abord être traité au préalable, afin de permettre une utilisation simplifiée des algorithmes d'analyse de données. En effet, des éléments comme la ponctuation, les sauts de ligne ou encore les majuscules/minuscules peuvent compliquer l'utilisation des algorithmes s'ils ne sont pas traités en amont. Il est donc nécessaire de créer une procédure permettant de gérer ces éléments. Celle-ci devra gérer les aspects suivants : le remplacement de toutes les majuscules du texte par des minuscules, ainsi que le remplacement de la ponctuation et des sauts de ligne par le caractère « » (un espace). Elle prendra en argument un fichier texte que l'on souhaite modifier, ainsi qu'un numéro de fichier (afin de faciliter la gestion lorsque l'on possède un grand nombre de fichier). et écrira le texte modifié dans un nouveau fichier nommé « modif{:03}.txt".format(i) ». Vous pouvez trouver ci-dessous le code en Python d'une telle procédure :

<pre>
def modification_texte(fichier_in,i):
"""
fichier_in : nom du fichier à modifier
i : numéro du fichier
"""

ponctuation = [",",";",":",".","?","!","«","»","(",")","\"","…","'","-","’"]
f_in = open(fichier_in, mode = "r")
f_out = open(("modif{:03}.txt".format(i)), mode = "w")
ligne = "initialisation"
while (ligne != "") : #Tant que la fin du fichier n'est pas atteinte.
ligne = f_in.readline()
ligne = ligne.lower()
for c in ligne :
if (c in ponctuation) or (c == "\n") :
f_out.write(" ")
else :
f_out.write(c)
f_in.close()
f_out.close()
</pre>

On peut également créer une procédure qui prend en argument un dossier de fichiers à modifier et qui exécute la procédure présentée ci-dessus sur tous les fichiers de ce dossier (cela permet de gérer l'intégralité du corpus de textes).

<pre>
def modification_texte_dossier(dossier_in):
"""
dossier_in : dossier de fichiers à modifier.
"""
import os
os.chdir(dossier_in)
liste_fichiers = os.listdir(dossier_in)
for i in range (len(liste_fichiers)):
modification_texte(liste_fichiers[i],i+1)
</pre>

Pour les toutes les fonctions décrites ci-dessous, on utilisera les textes modifiés (sans ponctuation, sans majuscules et sans sauts de ligne).

=== Création de fonctions utiles pour la fouille de données textuelles ===

Nous allons avoir besoin de créer quelques fonctions de base, très utiles pour l'utilisation des algorithmes d'analyse de données textuelles.

Il est donc nécessaire de créer une fonction qui permet de compter le nombre de mots total du corpus de texte, afin de savoir quelle quantité de données il faudra gérer. La fonction suivante permet de compter le nombre de mots d'un fichier. Elle prend en paramètre un fichier texte et renvoie le nombre de mots contenus dans ce fichier.

<pre>
def compte_mots(fichier):
"""
fichier : fichier texte sur lequel on doit compter le nombre de mots qu'il contient
"""
f = open(fichier, mode = "r")
mots = []
ligne = f.readline()
ligne2 = ligne.split()
mots = mots + ligne2
f.close()
return len(mots)
</pre>

Il faut donc maintenant créer une fonction qui parcourt l'intégralité du corpus afin de connaître le nombre de mots total que contient celui-ci. Cette fonction prend en paramètre un dossier de fichiers textes (le corpus) et renvoie le nombre total de mots contenus dans les fichiers textes de ce dossier.

<pre>
def compte_mots_dossier(dossier):
"""
dossier : dossier de fichier texte (corpus de textes complet)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
total = 0
for i in range (len(liste_fichiers)):
total = total + compte_mots(liste_fichiers[i])
return total
</pre>

En utilisant cette fonction, on peut savoir que le corpus traité contient 14755 mots.

Il est également nécessaire de créer une fonction qui stocke tous les mots du corpus dans un tableau (chaque mot n'apparaît qu'une seule fois dans le tableau). On crée donc d'abord une fonction qui stocke tous les mots d'un fichier. Celle-ci prendra en argument un fichier texte et renverra un tableau contenant chaque mot du fichier texte (pas de doublons dans le tableau).

<pre>
def stocke_mots_fichier(fichier):
"""
fichier texte duquel on souhaite tirer une liste de mots
"""
tab = []
f = open(fichier, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
if not (c in tab) :
tab.append(c)
f.close()
return tab
</pre>

Comme précédemment, on a donc maintenant besoin d'une fonction qui puisse parcourir l'intégralité du corpus de texte. Celle-ci prend en paramètre un dossier de fichiers (le corpus de textes) et renvoie un tableau contenant tous les mots du corpus, chaque mot n’apparaissant qu'une seule fois.

<pre>
def stocke_mots_dossier(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes complet)
"""
tab = []
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
for f in liste_fichiers:
tab_fichier = stocke_mots_fichier(f)
for c in tab_fichier :
if not (c in tab):
tab.append(c)
return tab
</pre>

Nous avons donc maintenant l'intégralité des mots du corpus stockés dans un tableau. En utilisant la commande len(stocke_mots_dossier(dossier)), on obtient que le corpus contient 3774 mots différents les uns des autres.

== Première approche : comptage du nombre d'apparition de chaque mot dans le corpus ==

=== Présentation de la méthode sur 1 texte ===

La première méthode à laquelle on pense pour tirer de l'information d'un grand nombre de données textuelles est de regarder le nombre de fois que chaque mot apparaît dans le corpus. Prenons un exemple sur le texte suivant :

<pre>
« Le texte de base.

Un voyageur attend le bus, il remarque un jeune homme au long cou qui porte un chapeau bizarre, entouré d'un galon tressé. Le jeune homme se dispute avec un passager qui lui reproche de lui marcher sur les pieds chaque fois que quelqu'un monte ou descend. Puis il va s'asseoir sur un siège inoccupé. Un quart d'heure plus tard le voyageur revoit le jeune homme devant la gare Saint-Lazare. Il discute avec un ami à propos d'un bouton de pardessus. »
</pre>

Dans ce texte, les termes qui apparaissent le plus souvent sont :
* « un » apparaît 10 fois.
* « le » apparaît 5 fois.
* « de » apparaît 3 fois.
* « il» apparaît 3 fois.
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.

Les informations obtenues ne sont donc pas très intéressantes car elle ne permettent pas de dégager les mots spécifiques à ce texte. En effet, avec cette méthode, on obtiendra principalement les mots outils de la langue française, qui n'ont pas spécialement grand intérêt du fait qu'ils sont présents dans la quasi-totalité des textes et que nous cherchons à définir les mots spécifiques à un texte. Ce que nous pouvons faire pour palier à ce problème est de définir manuellement une liste de mots-outils qui ne seront pas pris en compte dans le comptage des mots. Le problème de cette liste est qu'elle doit être définie à la main par l'utilisateur.

Si l'on néglige la présence de ces mots-outils dans le texte, voici la liste des termes qui apparaissent le plus souvent :
* « jeune » apparaît 3 fois.
* « homme » apparaît 3 fois.
* « voyageur » apparaît 2 fois.

Les autres mots du texte sont des mots-outils où n'apparaissent qu'une seule fois : il n'est donc pas intéressant de les retenir. Nous obtenons donc une liste de mots spécifiques à ce texte qui permet de dégager quelques informations à propos de ce dernier : on sait qu'il parle d'un « homme » et d'un « voyageur » et on peut supposer qu'au moins l'un des deux est qualifié de « jeune ».

Nous avons donc pu tirer une information plus concise du texte à partir de l'intégralité des mots qui le compose.

=== Utilisation de la méthode sur le corpus de textes ===

Nous allons maintenant créer des fonctions qui permettent d'appliquer la méthode vue précédemment sur l'intégralité du corpus de textes. Il est donc nécessaire d'avoir une fonction qui calcule le nombre d’occurrence de chaque mot dans le corpus. Cette fonction prendra en paramètre un dossier de fichiers textes (le corpus de textes complet) et renverra un dictionnaire avec comme clés les mots contenus dans les fichiers et comme valeurs le nombre de fois où apparaît le mot associé dans le corpus.

<pre>
def occurrence_mots(dossier):
"""
dossier : dossier de fichiers textes (corpus de textes)
"""
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
occurrences = {}
for t in liste_fichiers :
f = open(t, mode = "r")
ligne = f.readline()
ligne2 = ligne.split()
for c in ligne2 :
occurrences[c] = occurrences.get(c,0)+1
f.close()
return occurrences
</pre>

Il est maintenant nécessaire d'afficher les mots dont l'occurrence est la plus élevée. Pour cela nous aurons besoin d'une fonction qui prend en paramètre le corpus de textes et un entier n et qui renvoie la liste des n mots apparaissant le plus dans le corpus (donc affichés selon l'ordre décroissant des occurrences).

<pre>
def affiche_occurence_décroissant(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : nombre de mots que l'on souhaite afficher
"""
dico = occurence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
for i in range (0,min(n,len(tab))):
print("Mot {:03} : '{:30} fréquence : {:03}".format(i+1,tab[i][0] + "\'",tab[i][1]))
</pre>

Grâce à cette fonction nous obtenons que les mots qui apparaissent le plus souvent dans le corpus sont :
* « un » apparaît 575 fois.
* « de » apparaît 457 fois.
* « la » apparaît 294 fois.
* « et » apparaît 275 fois.
* « il » apparaît 274 fois.
* ...

Comme sur l'exemple avec un seul texte, ce sont les mots-outils de la langue française qui apparaissent le plus dans ce corpus (ils sont même davantage mis en avant car le corpus de texte étant plus long, les mots-outils sont encore plus utilisés), ce qui ne nous apporte pas grand chose comme information sur les spécificités du corpus.

Il est donc nécessaire de créer une fonction similaire à la précédente, qui permette de gérer les mots-outils. Celle-ci doit avoir pour argument un dossier contenant les textes du corpus ainsi qu'un entier n, comme la précédente. Elle renverra la liste des n mots qui apparaissent le plus dans le corpus, sans les mots-outils (la liste de ceux-ci était entrée manuellement) et sans les mots de taille égale à 1 caractère que l'on considère comme non pertinents.

<pre>
def affichage_occurrence_décroissant2(dossier,n):
"""
dossier : dossier de fichiers textes (corpus complet)
n : entier représentant le nombre de mots que l'on souhaite afficher
"""
dico = occurrence_mots(dossier)
tab = (sorted(dico.items(), key=lambda t: t[1], reverse=True))
i = 0
numero_mot = 1
while (numero_mot <= n) and (i < len(tab)) :
if (((tab[i][0]) not in mots_outils) and (len(tab[i][0]) > 1)) :
print("Mot {:03} : '{:30} fréquence : {:03}".format(numero_mot,tab[i][0] + "\'",tab[i][1]))
numero_mot = numero_mot + 1
i = i+1
</pre>

Si l'on exécute cette fonction, voici la liste des termes qui apparaissent le plus souvent dans le corpus :
* « autobus » apparaît 93 fois.
* « chapeau » apparaît 69 fois.
* « long » apparaît 66 fois.
* « cou » apparaît 66 fois.
* « devant » apparaît 64 fois.
* « bouton » apparaît 58 fois.
* « jeune » apparaît 52 fois.
* « tard » apparaît 51 fois.
* « place » apparaît 51 fois.
* « homme » apparaît 48 fois.
Les données obtenues sont donc plus pertinentes et nous donnent plus d'information sur l'histoire racontée dans le corpus. En effet, on peut par exemple déduire que l'« autobus » le « chapeau » ou encore le « bouton » sont des éléments centraux de l'histoire car ils apparaissent de nombreuses fois dans le corpus.

Cette méthode permet donc d'avoir une vue d'ensemble sur ce dont parlent les textes, mais le principal inconvénient est qu'il faille rentrer une liste de mots-outils de la langue française, sachant que celle-ci n'est pas fixée et peu plus ou moins varier selon les textes analysés.

== Méthode des TF-IDF ==
Cette méthode permet justement de gérer automatiquement les mots-outils d'un corpus, sans que l'utilisateur ait besoin de rentrer une liste au préalable.

=== Présentation de la méthode sur une quantité de données réduite ===

Dans cette partie, nous utiliserons les textes suivants, l'exemple portera sur le texte 3.

*Texte 1 :

<pre>
Rétrograde.

Tu devrais ajouter un bouton à ton pardessus, lui dit son ami. Je le rencontrai au milieu de la cour de Rome, après l'avoir quitté se précipitant avec avidité vers une place assise. Il venait de protester contre la poussée d'un autre voyageur, qui, disait-il, le bousculait chaque fois qu'il descendait quelqu'un. Ce jeune homme décharné était porteur d'un chapeau ridicule. Cela se passa sur la plate-forme d'un S complet ce midi-là.
</pre>

*Texte 2 :

<pre>
Distinguo.

Dans un autobus (qu'il ne faut pas prendre pour un autre obus), je vis (et pas avec mon vit) un personnage (qui ne perd son âge) coiffé d'un feutre mou bleu (et non de foutre blême), feutre cerné d'un fil tressé (et non de tril fessé). Il disposait (et non dix posait) d'un long cou (et pas d'un loup con). Comme la foule se bousculait (non que la boule se fousculât), un nouveau voyageur (non veau nouillageur) déplaça le susdit (et non suça ledit plat). Cestuy râla (et non cette huître hala), mais voyant une place libre (et non ployant une vache ivre) s'y précipita (et non si près s'y piqua).
Plus tard je l'aperçus (non pas gel à peine su) devant la gare Saint-Lazare (et non là ou l'hagard ceint le hasard) qui parlait avec un copain (il n'écopait pas d'un pralin) au sujet d'un bouton de son manteau (qu'il ne faut pas confondre avec le bout haut de son menton).
</pre>

*Texte 3 :

<pre>
Passé indéfini.

Je suis monté dans l'autobus de la porte Champerret. Il y avait beaucoup de monde, des jeunes, des vieux, des femmes, des militaires. J'ai payé ma place et puis j'ai regardé autour de moi. Ce n'était pas très intéressant. J'ai quand même fini par remarquer un jeune homme dont j'ai trouvé le cou trop long. J'ai examiné son chapeau et je me suis aperçu qu'au lieu d'un ruban il y avait un galon tressé. Chaque fois qu'un nouveau voyageur montait, ça faisait de la bousculade. Je n'ai rien dit, mais le jeune homme au long cou a tout de même interpellé son voisin. Je n'ai pas entendu ce qu'il lui a dit, mais ils se sont regardés d'un sale oeil. Alors, le jeune homme au long cou est allé s'asseoir précipitamment. En revenant de la porte Champerret, je suis passé devant la gare Saint-Lazare.
J'ai vu mon type qui discutait avec un copain. Celui-ci a désigné du doigt un bouton juste au-dessus de l'échancrure du pardessus. Puis l'autobus m'a emmené et je ne les ai plus vus. J'étais assis et je n'ai pensé à rien.
</pre>

==== Le TF ====

Le TF (Term-Frequency) d'un terme, autrement appelé la fréquence « brute » est précisément le nombre d’occurrences de ce terme dans un texte. Par abus de langage, on parle de « fréquence ». Comme cette méthode a déjà été vue précédemment, nous nous contenterons ici de calculer le TF pour des mots qui nous serviront d'exemple pour la suite et d'introduire une fonction qui permettra de calculer le TF d'un mot dans un texte.
Pour le texte 3, on a donc :
* Pour le mot « un », <math>TF = 7</math>
* Pour le mot « de », <math>TF = 7</math>
* Pour le mot « homme », <math>TF = 3</math>
* Pour le mot « autobus », <math>TF = 2</math>
* Pour le mot « pardessus », <math>TF = 1</math>
* Pour le mot « ruban », <math>TF = 1</math>
Nous retrouvons donc le même problème que précédemment où les mots-outils sont mis en avant.

Le code de la fonction qui permet de calculer le TF d'un mot dans un texte est disponible ci-dessous :

<pre>
def calcul_TF(fichier,mot):
"""
fichier : fichier texte que l'on va parcourir
mot : chaîne de caractères dont on souhaite compter le nombre d'apparitions
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
f = open(fichier, mode = "r")
ligne = f.readline()
Freq = ligne.count(mot)
f.close()
return Freq
</pre>

==== L'IDF ====

Pour palier au problème que pose le TF, nous introduisons l'IDF. En effet, avec la méthode des TF tous les termes qui apparaissent dans un document avec la même fréquence auront la même importance. Or, les termes qui se trouvent dans peu de documents permettent de mieux différencier ces derniers des textes dans lesquels ils se trouvent en nombre élevé. Ces termes ont donc un pouvoir de discrimination plus grand que celui des termes apparaissant dans beaucoup de documents. L'IDF (inverse document frequency) est une mesure de l'importance du terme dans l'ensemble du corpus. La formule de l'idf est la suivante :

<math>idf_{t}=\ln{\frac{N}{df_{t}}} </math>
* où <math>N</math> est le nombre total de documents dans le corpus
* et <math>df_{t}</math> le nombre de documents où le terme <math>t</math> apparaît (on doit avoir <math>df_{t} \ne 0 </math>)

On cherchera donc d'abord à créer une fonction qui permette de calculer le df d'un mot dans un corpus de textes. Cette fonction prend en argument un dossier de fichiers textes (le corpus de documents) et un mot pour lequel on souhaite calculer le df. Elle renvoie le df de ce mot, c'est-à-dire le nombre de fichiers où ce mot apparaît.

<pre>
def calcul_df(dossier,mot):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre le df
"""
mot = mot.lower()
mot = mot.strip()
mot = " " + mot + " "
os.chdir(dossier)
liste_fichiers = os.listdir(dossier)
nombre_doc = 0
for c in liste_fichiers :
f = open(c, mode = "r")
texte = f.readline()
if mot in texte :
nombre_doc = nombre_doc + 1
f.close()
return nombre_doc
</pre>

La fonction qui permet de calculer l'idf d'un terme est donc définie simplement de la manière suivante :
<pre>
def calcul_idf(dossier,mot,nombre_docs):
"""
dossier : dossier de fichiers textes (corpus de documents)
mot : mot dont on souhaite connaitre l'idf
nombre_docs : entier représentant le nombre de documents du corpus
"""
return log(nombre_docs / (calcul_df(dossier,mot)))
</pre>

En utilisant ces fonctions, on peut donc avoir l'idf des mots du texte 3 pour lesquels nous avons calculé le tf précédemment :
* Pour le mot « un », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « de », <math>idf=\ln{\frac{3}{3}}=0</math>
* Pour le mot « homme », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « autobus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « pardessus », <math>idf=\ln{\frac{3}{2}} \approx 0,405</math>
* Pour le mot « ruban », <math>idf=\ln{\frac{3}{1}} \approx 1,099</math>

==== Le TF-IDF ====

Le TF-idf s'obtient en multipliant les deux valeurs obtenues :

<math>TFidf_{t} = TF_{t} \times idf_{t} </math>
où <math>t</math> est le terme pour lequel on calcule le TF-idf.

Pour l'exemple précédent (texte 3), on a donc :
* Pour le mot « un », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « de », <math>TFidf = 7 \times 0 = 0</math>
* Pour le mot « homme », <math>TFidf = 3 \times 0,405 = 1,215</math>
* Pour le mot « autobus », <math>TFidf = 2 \times 0,405 = 0,81</math>
* Pour le mot « pardessus », <math>TFidf = 1 \times 0,405 = 0,405</math>
* Pour le mot « ruban », <math>TFidf = 1 \times 1,099 = 1,099</math>

On obtient donc les mots par ordre de pertinence : homme, autobus, pardessus, un, de. Cela a permis de supprimer les mots-outils qui se trouvaient dans les 3 documents et de faire ressortir d'autres mots importants.

Le mot « homme » à quant à lui le TF-idf le plus élevé, car il apparaît 3 fois dans le texte 3 et apparaît uniquement dans 2 textes sur 3 du corpus.

Le mot « ruban » a un TF-idf plus élevé que les mots « autobus » et « pardessus » alors qu'il n’apparaît qu'une seule fois dans le texte 3, mais c'est parce qu'il n’apparaît que dans le texte 3, ce qui montre bien que le TF-idf permet de mettre en avant les spécificités de chaque texte.

=== Utilisation de la méthode sur le corpus de textes ===

=== Exemples qui permettent de souligner les spécificités de certaines textes du corpus ===

== Conclusion ==

== Annexes ==

== Sources ==