Préparation et Prétraitement des Données Textuelles

Apprenez à collecter, nettoyer et structurer les données textuelles brutes pour les préparer à l’analyse, incluant la tokenisation, le filtrage et la représentation en sac de mots ou TF-IDF.
Prétraitement
Corpus
Tokenisation
Normalisation
TF-IDF
Authors
Affiliation

Wilson Toussile1 2

ENSPY

1ENSPY, 2ESSFAR

Published

May 22, 2025

1 L’Importance du Prétraitement

Avant de pouvoir extraire des informations significatives d’un ensemble de documents textuels, appelé corpus (noté \(\mathcal{D}_n=\left\{d_i\right\}_{i=1}^n\)), il est impératif de le préparer. Le texte brut est souvent “bruyant” : il contient des majuscules inutiles, de la ponctuation, des mots courants peu informatifs, des variations morphologiques, etc. Le prétraitement du texte (ou text preprocessing) vise à nettoyer, normaliser et structurer ces données pour les rendre exploitables par les algorithmes d’analyse. Sans cette étape, les analyses risquent d’être faussées ou de produire des résultats de mauvaise qualité.

2 Collecte et Constitution de Corpus

Bien que ce chapitre se concentre sur le prétraitement, rappelons brièvement que la première étape est la collecte des données. Votre corpus \(\mathcal{D}_n\) peut provenir de diverses sources : * Pages web (via web scraping) * Publications sur les réseaux sociaux (tweets, posts Facebook) * Avis clients * Livres numérisés (ex: Project Gutenberg) * Articles de presse, articles scientifiques * Bases de données internes d’une entreprise (emails, rapports)

La qualité et la pertinence du corpus initial sont fondamentales pour la suite du projet.

3 Étapes Clés du Prétraitement du Texte

3.1 Normalisation du Texte

La normalisation vise à ramener le texte à une forme plus standard et cohérente.

  • Conversion en Minuscules (Case Folding) : Uniformise la casse pour que des mots comme “Texte”, “texte” et “TEXTE” soient traités comme identiques.
    • Avant : “Le Text Mining est INTÉRESSANT.”
    • Après : “le text mining est intéressant.”
  • Suppression de la Ponctuation : Élimine les signes de ponctuation (virgules, points, points d’exclamation, etc.) qui peuvent ne pas être utiles pour certaines analyses (comme le sac de mots).
    • Avant : “Incroyable ! C’est vrai ?”
    • Après : “Incroyable Cest vrai” (souvent combiné avec la tokenisation)
  • Suppression des Nombres : Selon le contexte, les nombres peuvent être supprimés s’ils n’apportent pas d’information pertinente pour l’analyse visée.
    • Avant : “Commande passée le 15 mai 2025 pour 3 articles.”
    • Après (si pertinent) : “Commande passée le mai pour articles.”
  • Gestion des Caractères Spéciaux et Encodages : Assurer un encodage uniforme (généralement UTF-8) et supprimer ou remplacer les caractères spéciaux non pertinents (symboles, emojis si non désirés).
    • Avant : “Texte avec © et d’étranges symboles •¿•”
    • Après : “Texte avec et detranges symboles”
  • Suppression des Accents (Diacritics Removal) : Optionnel, mais parfois utilisé pour simplifier le texte, surtout si le corpus est bruité.
    • Avant : “L’élève étudie sa leçon.”
    • Après : “L’eleve etudie sa lecon.”

Example 1 (Code Python pour un nettoyage de base)  

Code 
import re
import unicodedata

def cleanText(text):
    """
        cleanText(text)

    Nettoyer un texte.
    """
    # Conversion en minuscules
    text = text.lower()

    # Remplacer ' par espace
    text = text.replace("'", " ")

    # Suppression des accents
    text = ''.join(c for c in unicodedata.normalize('NFD', text) if unicodedata.category(c) != 'Mn')

    # Suppression de la ponctuation et des nombres (exemple simple)
    text = re.sub(r'[^a-z\s]', '', text) # Garde lettres et espaces
    return text
Code 
original_text = "L'élève étudie sa 5ème leçon, c'est GÉNIAL !"
cleaned_text = cleanText(original_text)
print(f"Original: {original_text}")
print(f"Nettoyé : {cleaned_text}")
# Output:
# Original: L'élève étudie sa 5ème leçon, c'est GÉNIAL !
# Nettoyé : leleve etudie sa eme lecon cest genial
Original: L'élève étudie sa 5ème leçon, c'est GÉNIAL !
Nettoyé : l eleve etudie sa eme lecon c est genial
Note

Ce code est un exemple simplifié. Des bibliothèques comme NLTK ou spaCy offrent des outils plus robustes.

3.2 Tokenisation

La tokenisation consiste à segmenter le texte en unités de base, appelées tokens. Ces tokens sont généralement des mots, mais peuvent aussi être des phrases ou des n-grammes (séquences de n mots).

Analogie : Pensez à la tokenisation comme au fait de découper une phrase en briques LEGO — chaque mot (ou parfois groupe de mots) devient une pièce distincte pour l’analyse.

Example 2 (Tokenisation par mots)  

* *Phrase* : "Le text mining est fascinant."
* *Tokens* : `["Le", "text", "mining", "est", "fascinant", "."]` (avant suppression ponctuation)
* *Tokens* : `["le", "text", "mining", "est", "fascinant"]` (après normalisation et suppression ponctuation)
Note

Des bibliothèques comme NLTK, spaCy, sklearn.feature_extraction.text et gensim fournissent des implémentations robustes de tokenizers sous (Python). Et sous R, le package tidytextfournit des implémentations de tokenizers performants.

3.3 Filtrage des Mots-Vides (Stop Words)

Les mots-vides sont des mots très fréquents qui apportent peu de signification sémantique pour de nombreuses tâches (ex: “le”, “la”, “les”, “de”, “un”, “est”, “sont”). Les supprimer permet de réduire la dimensionnalité des données et de se concentrer sur les mots porteurs de sens.

Example 3 (Suppression des mots-vides)  

  • Phrase tokenisée : ["le", "text", "mining", "est", "fascinant"]
  • Liste de mots-vides (français, exemple) : ["le", "la", "les", "de", "est", ...]
  • Après filtrage : ["text", "mining", "fascinant"]

Chaque langue a sa propre liste de mots-vides, et il est parfois nécessaire d’adapter cette liste au contexte spécifique du corpus.

3.4 Racisation (Stemming) et Lemmatisation

Ces techniques visent à réduire les mots à leur forme de base ou racine, afin de regrouper différentes formes flexionnelles d’un même mot.

  • Racisation (Stemming) : Processus algorithmique (souvent basé sur des règles heuristiques) qui coupe les suffixes des mots pour obtenir une “racine” (stem). C’est une méthode plus agressive et rapide, mais la racine obtenue n’est pas toujours un mot existant.
    • Exemples :
      • “mange”, “mangeons”, “mangeront” → “mang”
      • “running”, “runs”, “ran” → “run” (pour l’anglais avec Porter Stemmer)
      • “intéressant”, “intéressée” → “intéress”
  • Lemmatisation : Processus plus sophistiqué qui utilise des dictionnaires (lexiques) et une analyse morphologique pour ramener un mot à sa forme canonique ou lemme (la forme que l’on trouverait dans un dictionnaire). Le résultat est toujours un mot valide.
    • Exemples :
      • “mange”, “mangeons”, “mangeront” → “manger”
      • “running”, “runs”, “ran” → “run”
      • “intéressant”, “intéressée” → “intéressant”
      • “better” → “good” (pour l’anglais avec WordNet)

Différence clé : La lemmatisation est sémantiquement plus correcte mais plus lente et nécessite des ressources linguistiques (lexiques). Le stemming est plus rapide mais peut être moins précis. Le choix dépend de l’application.

4 Représentation Structurée du Texte

Une fois le texte nettoyé et normalisé, l’étape suivante consiste à le transformer en une représentation numérique structurée que les algorithmes d’apprentissage automatique peuvent comprendre et traiter. Cette transformation est cruciale car les machines opèrent sur des nombres, pas directement sur des chaînes de caractères.

4.1 Modèles Vectoriels Dispersés (Sparse Vector Models)

Ces modèles représentent généralement les documents comme des vecteurs dans un espace de grande dimension (la taille du vocabulaire), où la plupart des valeurs sont nulles.

Modèle Sac de Mots (Bag-of-Words - BoW)

Le modèle “sac de mots” est l’une des approches les plus fondamentales et intuitives. * Principe : Chaque document est représenté comme un ensemble non ordonné de ses mots (ou tokens), sans tenir compte de la grammaire ni de l’ordre des mots, mais en conservant leur fréquence. * Exemple : * Document 1 (après prétraitement) : ["chat", "mange", "souris"] * Représentation BoW (fréquences) si le vocabulaire est {"chat", "mange", "souris", "observe"} : {"chat": 1, "mange": 1, "souris": 1, "observe": 0}

  • Extension avec les N-grammes de Mots : Pour capturer un peu de contexte local et des expressions multi-mots, on peut étendre le BoW à des N-grammes, qui sont des séquences de N tokens consécutifs.
    • Exemple avec des bigrammes (N=2) pour “le chat mange la souris”:
      • Tokens unigrammes: ["le", "chat", "mange", "la", "souris"]
      • Tokens bigrammes: ["le chat", "chat mange", "mange la", "la souris"] Un document peut alors être représenté par un “sac de N-grammes”. Cela augmente la taille du vocabulaire mais peut améliorer la performance pour certaines tâches.
  • N-grammes de Caractères : Alternativement, on peut décomposer les mots ou le texte en séquences de N caractères.
    • Exemple pour le mot “texte” avec des trigrammes (N=3) : ["tex", "ext", "xte"] Cette approche est robuste aux fautes de frappe et aux variations morphologiques et peut être utile pour des tâches comme l’identification de la langue ou la détection de spam.

Matrice Document-Terme (Document-Term Matrix - DTM)

La DTM est une concrétisation du modèle sac de mots (ou sac de N-grammes) sous forme de tableau : * Chaque ligne représente un document \(d_i\) du corpus \(\mathcal{D}_n\). * Chaque colonne représente un terme (unigramme, N-gramme de mots, ou N-gramme de caractères) \(t_j\) unique du vocabulaire global. * Chaque cellule \((i, j)\) contient la valeur du terme \(t_j\) dans le document \(d_i\).

Cette valeur peut être : * Comptages Bruts (Raw Counts) : Le nombre d’occurrences du terme dans le document. * Fréquences Binaires (Presence/Absence) : 1 si le terme est présent, 0 sinon. Utile lorsque la simple présence d’un mot est plus informative que sa fréquence (Žižka et al., 2020, p. 109). * Fréquence du Terme (TF - Term Frequency) : Souvent normalisée pour tenir compte de la longueur variable des documents. \(TF(t, d) = (\text{nombre d'occurrences de } t \text{ dans } d) / (\text{nombre total de termes dans } d)\). * Pondération TF-IDF (Term Frequency-Inverse Document Frequency) : \(TFIDF(t, d, D) = TF(t, d) \times IDF(t, D)\). Elle valorise les termes fréquents dans un document mais rares dans l’ensemble du corpus, les considérant comme plus discriminants.

Exemple de DTM avec comptages bruts (basé sur l’exemple BoW précédent) :

Document chat mange souris observe
Doc 1 1 1 1 0
Doc 2 1 0 1 1

Les DTM issues de grands corpus sont typiquement très larges (beaucoup de colonnes/termes) et creuses (la majorité des cellules contiennent des zéros).

4.2 Introduction aux Modèles Vectoriels Denses (Dense Vector Models - Embeddings)

Bien qu’efficaces pour de nombreuses tâches, les modèles vectoriels dispersés (comme BoW/TF-IDF) présentent des limitations : * Ils ne capturent pas la similarité sémantique entre les mots (ex: “voiture” et “automobile” sont aussi distants que “voiture” et “banane” dans l’espace vectoriel si ce sont des termes distincts). * La haute dimensionnalité peut entraîner des problèmes de performance et le “fléau de la dimensionnalité”. * La perte de l’ordre des mots (sauf partiellement avec les N-grammes) ignore la syntaxe.

Pour pallier ces inconvénients, les représentations vectorielles denses, aussi appelées plongements (embeddings), ont été développées.

  • Principe Général : L’idée est de représenter chaque mot (Word Embedding) ou chaque document (Document Embedding) par un vecteur dense de nombres réels dans un espace de plus faible dimension (par exemple, 50 à 300 dimensions au lieu de dizaines de milliers). Dans cet espace, la distance et la direction entre les vecteurs encodent des relations sémantiques.
    • Ainsi, des mots sémantiquement similaires (ex: “content”, “joyeux”) auront des vecteurs proches.
  • Aperçu des Techniques (seront détaillées dans un chapitre ultérieur) :
    • Plongements de Mots (Word Embeddings) : Des algorithmes comme Word2Vec, GloVe, et FastText apprennent ces représentations vectorielles denses pour les mots à partir de grands corpus. Ils se basent sur l’hypothèse distributionnelle : “un mot est caractérisé par la compagnie qu’il tient”.
    • Plongements de Documents (Document Embeddings) : On peut obtenir des vecteurs denses pour des documents entiers, par exemple en faisant la moyenne des embeddings des mots qu’ils contiennent, ou en utilisant des modèles spécifiques comme Doc2Vec ou des architectures plus avancées basées sur les transformateurs (ex: BERT).

L’utilisation de ces représentations denses permet souvent d’améliorer significativement les performances des modèles d’apprentissage automatique sur des tâches textuelles complexes, car elles intègrent une compréhension plus fine de la sémantique du langage. Nous reviendrons en détail sur la création et l’utilisation de ces embeddings dans le chapitre dédié à l’apprentissage approfondi pour le texte.

4.3 Conclusion de la Section

Le passage du texte brut à une représentation structurée est une étape fondamentale. Le choix entre un modèle dispersé (comme TF-IDF sur des unigrammes ou N-grammes) et l’introduction de modèles denses (embeddings) dépendra de la tâche, de la taille du corpus, des ressources disponibles et de la nécessité de capturer des nuances sémantiques fines. Souvent, une exploration commence avec des modèles plus simples avant de passer à des représentations plus complexes si nécessaire.

5 Conclusion du chapitre

La préparation et le prétraitement des données textuelles sont des étapes fondamentales et souvent itératives du text mining. Les choix effectués ici (quels mots-vides supprimer, utiliser le stemming ou la lemmatisation, type de pondération) peuvent avoir un impact significatif sur les résultats finaux. Il est crucial de bien comprendre son corpus et les objectifs de son analyse pour appliquer les techniques de prétraitement les plus adaptées.

6 Exercices

Exercise 1 (Nettoyage et Préparation d’un Mini-Corpus) Objectif : Appliquer les étapes clés du prétraitement à un petit ensemble de phrases pour les préparer à une analyse ultérieure.

Données (Mini-Corpus) :

Voici trois phrases que vous utiliserez comme corpus initial :

phrase_1 = "L'analyse de textes est une compétence TRÈS utile en 2024 !"
phrase_2 = "Les ordinateurs comprennent mieux les mots après un bon nettoyage."
phrase_3 = "Apprendre, explorer, analyser : voilà les clés du succès en Text Mining."

Tâches à réaliser :

Pour chaque phrase du mini-corpus, et ensuite pour le corpus combiné :

  1. Normalisation Initiale :
    • Convertissez tout le texte en minuscules.
    • Supprimez la ponctuation.
    • Supprimez les nombres (si vous le jugez pertinent pour une analyse de mots).
    • (Optionnel) Supprimez les accents.
  2. Tokenisation :
    • Segmentez chaque phrase normalisée en une liste de mots (tokens).
  3. Filtrage des Mots-Vides :
    • Utilisez une liste de mots-vides standards pour le français (par exemple, celle de NLTK ou stopwords-iso en R).
    • Supprimez ces mots-vides de vos listes de tokens.
    • Affichez les tokens restants pour chaque phrase.
  4. Racisation ou Lemmatisation (Choisissez-en une ou essayez les deux) :
    • Racisation (Stemming) : Appliquez un stemmer français (par exemple, FrenchStemmer de NLTK ou SnowballC en R) aux tokens filtrés. Affichez les racines obtenues.
    • Lemmatisation : Si vous utilisez une bibliothèque comme spaCy (Python) qui le permet facilement pour le français, ou si vous avez accès à un lemmatiseur français en R, appliquez la lemmatisation aux tokens filtrés. Affichez les lemmes obtenus.
      • Note : La lemmatisation en français peut être plus complexe à mettre en place avec des outils basiques que le stemming.
  5. Affichage des Résultats :
    • Pour chaque phrase, montrez le résultat après chaque étape majeure (normalisation, tokenisation, filtrage, racisation/lemmatisation).
  6. (Bonus) Création d’un Vocabulaire et d’une Représentation Simple :
    • Après avoir traité toutes les phrases et obtenu les tokens finaux (par exemple, après lemmatisation ou racisation et filtrage des mots-vides), combinez tous ces tokens pour former un vocabulaire unique pour votre mini-corpus.
    • Pour chaque phrase originale, représentez-la sous forme d’un “sac de mots” simple en comptant la fréquence des termes du vocabulaire (après prétraitement) qu’elle contient.

Outils Suggérés :

  • Python :
    • re (pour les expressions régulières de base)
    • unicodedata (pour la gestion des accents)
    • nltk.tokenize.word_tokenize
    • nltk.corpus.stopwords
    • nltk.stem.snowball.FrenchStemmer
    • spacy (pour une tokenisation, lemmatisation et suppression de mots-vides plus avancées si installé avec le modèle français)
    • collections.Counter (pour le comptage de mots)
  • R :
    • stringr (pour la manipulation de chaînes)
    • tm ou tidytext (pour la tokenisation, la suppression des mots-vides)
    • SnowballC (pour le stemming, fonction wordStem)
    • stopwords (package pour les listes de mots-vides)

Questions pour Réflexion :

  • Quelles différences observez-vous entre les résultats du stemming et de la lemmatisation (si vous avez pu faire les deux) ?
  • Certains mots-vides importants pour le sens ont-ils été supprimés ? Auriez-vous dû personnaliser votre liste de mots-vides ?
  • Comment la suppression des nombres ou des accents a-t-elle affecté vos tokens ? Était-ce toujours souhaitable ?
  • Quel impact ces étapes de prétraitement pourraient-elles avoir sur une analyse de sentiments ou une classification de textes ?