Nettoyage & tokenisation de texte en Python

Mise à jour : 30/07/2025

Quand on récupère du texte d’un site web, d’un PDF ou d’un formulaire, il est souvent “sale” : il contient des symboles bizarres, des balises HTML, des majuscules inutiles, etc. Avant de l’utiliser dans un assistant IA, on doit le nettoyer, un peu comme on nettoie une base de données avant analyse.

Pourquoi nettoyer le texte ?

Les modèles de langage, aussi puissants soient-ils, ne sont pas magiques. Leur performance dépend directement de la qualité du texte qu’on leur fournit. Plus un texte est propre, structuré, cohérent, plus le modèle pourra en extraire du sens, répondre avec pertinence, ou générer des textes corrects.

Imagine un assistant IA qui lit ce texte :

"APPRENDS-moi À... tokenISER le <texte> 🧠 123€ !"

Si tu ne le nettoies pas, le modèle va :

s’embrouiller sur les majuscules,
mal couper les mots,
se perdre dans les symboles.

Résultat : des réponses moins bonnes, voire absurdes.

Donc le nettoyage de texte, aussi appelé text cleaning, est la première étape dans tout pipeline de traitement de données linguistiques. Il sert à éliminer les éléments inutiles, incohérents ou nuisibles à l’interprétation automatique.

Les enjeux du nettoyage

Réduire la variabilité lexicale : “Apprentissage”, “apprentissage”, “apprentissage.” ou “Apprentissage !” sont différents pour un modèle naïf, mais désignent le même mot.
Supprimer le bruit : retours à la ligne, majuscules aléatoires, ponctuation inutile, emojis, balises HTML.
Préparer la tokenisation : découper proprement les phrases et les mots suppose un texte déjà uniforme.
Accélérer les traitements : moins de tokens = moins de coût mémoire et calculatoire.
Faciliter l’analyse statistique ou sémantique : moins de parasites = meilleurs vecteurs = meilleures inférences.

Typologie des bruits courants

Voici ce qu’on trouve fréquemment dans un texte brut extrait d’un formulaire, d’une base de données ou d’un fichier PDF :

Ponctuation redondante : !!!, ..., ???
Caractères spéciaux : \n, \t, \u200b, « », “”, ’, …
Abréviations et contractions : “j’suis”, “t’as”, “c’est”
Majuscules incohérentes
Emojis ou caractères non latins
Stopwords : “le”, “la”, “de”, “et”, “en”, “un”… (peu informatifs)

Exemples de transformation :

import re
import string
from unidecode import unidecode

texte_bruite = "  <p>EXEMPLE!!! de texte à nettoyer... 123 € <br>\n\tAvec des MAJUSCULES, des chiffres, des symboles €, et des caractères invisibles\u200b. 😃</p>  "

texte = re.sub(r"<.*?>", "", texte_bruite)
texte = re.sub(r"[\u200b\u200c\u200d]", "", texte)
texte = texte.lower().strip()
texte = texte.translate(str.maketrans("", "", string.punctuation))
texte = unidecode(texte)
texte = re.sub(r"\d+", "", texte)
texte = re.sub(r"€|euro|\$", "euro", texte)
texte = re.sub(r"\s+", " ", texte)

print(texte)
exemple de texte à nettoyer euro avec des majuscules des chiffres des symboles euro et des caractères invisibles 😃

Ce exemple de code illustre un pipeline complet de nettoyage, étape par étape, sur un texte très bruité. Nous allons maintenant détailler chaque étape pour comprendre comment mettre en place un tel traitement.

Manipulation de chaînes en Python

Avant d’utiliser des bibliothèques spécialisées comme nltk ou spacy, il est essentiel de maîtriser les outils natifs de Python pour manipuler les chaînes de caractères. Cela te permettra de construire un pipeline de traitement léger, rapide, et parfaitement adapté à ton besoin.

Fonctions de base

Les chaînes de caractères sont comme des phrases sur une feuille de papier : tu peux les découper, effacer certains mots, ou changer leur casse. Python te donne des outils simples pour les manipuler, comme une paire de ciseaux ou une gomme.

Voici les méthodes les plus couramment utilisées :

.lower() : convertit tous les caractères en minuscules
.strip() : supprime les espaces en début et fin de chaîne
.replace(old, new) : remplace une sous-chaîne
.split(delim) : découpe la chaîne en liste selon un délimiteur (par défaut : espace)
.join() : concatène une liste en chaîne
.startswith(), .endswith() : test de début ou fin de chaîne

Exemple :

texte = "  Bonjour, Monde !   "
nettoye = texte.strip().lower().replace(",", "")
print(nettoye)
"bonjour monde !"

Ce code illustre comment nettoyer un texte en supprimant les espaces superflus, en mettant tout en minuscules, et en retirant la virgule.

Gestion des accents et caractères spéciaux

Certains traitements nécessitent d’uniformiser les caractères accentués ou non-latins. Utilise pour cela la bibliothèque unidecode :

pip install unidecode

from unidecode import unidecode
texte = "Éducation numérique : ça évolue vite !"
print(unidecode(texte))
"Education numerique : ca evolue vite !"

Gestion des sauts de ligne, tabulations, espaces multiples

Le texte brut contient souvent des caractères invisibles qui perturbent le découpage :

texte = "Ceci est un texte\navec des\tretours à la ligne et\tdes tabulations."
texte = texte.replace("\n", " ").replace("\t", " ")

Ce code remplace les retours à la ligne et les tabulations par des espaces simples, rendant le texte plus homogène.

Suppression de ponctuation et caractères spéciaux

Une fois le texte mis en minuscules et débarrassé des espaces superflus, une étape suivante peut consister à supprimer la ponctuation et les caractères non pertinents. Ces éléments n’apportent souvent aucune valeur aux modèles de langage, et perturbent la tokenisation.

Python fournit une liste des signes de ponctuation dans le module string :

import string

print(string.punctuation)
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

Tu peux l’utiliser avec str.translate() pour supprimer la ponctuation :

texte = "Bonjour, comment ça va ?"
texte_sans_ponct = texte.translate(str.maketrans("", "", string.punctuation))
print(texte_sans_ponct)
'Bonjour comment ça va'

Supprimer d’autres caractères parasites

Certains symboles invisibles, balises HTML ou caractères spéciaux échappent aux filtres classiques. Il faut les détecter explicitement :

texte = "Texte avec balise <br> et caractères \u200b étranges"
texte = re.sub(r"<.*?>", "", texte)          # Supprime les balises HTML
texte = re.sub(r"[\u200b\u200c\u200d]", "", texte)  # Supprime les caractères invisibles

Ici, on utilise des expressions régulières pour cibler les balises HTML et les caractères invisibles Unicode. Cela permet de nettoyer le texte de manière plus fine.

Remplacer les chiffres ou symboles spécifiques

Parfois, on souhaite filtrer ou remplacer certains éléments précis (chiffres, symboles monétaires, hashtags…) :

texte = re.sub(r"\d+", "", texte)     # Supprime les chiffres
texte = re.sub(r"€|\$", "euro", texte)  # Remplace les symboles monétaires

Nettoyage progressif

Un bon nettoyage se fait par étapes, en documentant chaque transformation. Exemple :

def nettoyer_texte(txt):
    txt = txt.lower().strip() # Met en minuscules et supprime les espaces
    txt = re.sub(r"<.*?>", "", txt)  # Supprime les balises HTML
    txt = re.sub(r"[^\w\s]", "", txt) # Supprime la ponctuation
    txt = re.sub(r"\s+", " ", txt) # Remplace les espaces multiples par un seul
    return txt

texte = "   Voilà !! Un EXEMPLE de texte.    "
print(nettoyer_texte(texte))
voilà un exemple de texte

Maintenant que ton texte est propre, place à la segmentation : découper en phrases, puis en mots.

Segmentation en phrases et en mots (tokenisation)

La tokenisation consiste à découper un texte en unités minimales de traitement, appelées tokens. Ces unités peuvent être des mots, des sous-mots (subwords), ou même des caractères, selon le niveau de traitement choisi. C’est une étape importante pour tout modèle de langage : chaque token sera converti en vecteur, puis analysé par le LLM.

Qu’est-ce qu’un token ?

Un token, c’est un petit morceau de texte que le modèle comprend. Imagine que tu veux expliquer une recette à un robot qui ne comprend que morceau par morceau :

“mélange les œufs” → [“mélange”, “les”, “œufs”]

C’est la découpe en tokens qui permet à l’IA de “lire” ton texte.

Types de découpage

Segmentation en phrases : utile pour le résumé, l’analyse syntaxique, la traduction.
Segmentation en mots (tokenisation) : essentielle pour les modèles de langage, la recherche ou le RAG.

On peut commencer par une approche basique avec les méthodes de chaîne de caractères :

texte = "Voici un exemple de texte propre"
mots = texte.split()
print(mots)
['Voici', 'un', 'exemple', 'de', 'texte', 'propre']

Une méthode simple, mais limitée, car elle ne gère pas la ponctuation ou les caractères spéciaux. On peut aussi découper par phrases en découpant sur les ponctuations :

import re
texte = "Bonjour. Comment vas-tu ? Voici un test !"
phrases = re.split(r"[.?!]\s*", texte)
print(phrases)
['Bonjour', 'Comment vas-tu', 'Voici un test']

Méthodes rapides mais limitées : elles ne gèrent pas les abréviations (“Dr.”), les points décimaux (“3.14”), ou la ponctuation mal formatée.

Pour des segmentations plus robustes, on peut utiliser des bibliothèques spécialisées comme nltk ou spaCy.

`nltk` : segmentation fiable, linguistiquement correcte

nltk (Natural Language Toolkit) est une bibliothèque Python historique pour le traitement automatique des langues. Elle contient des outils simples et robustes pour :

segmenter en phrases ou mots,
filtrer les stopwords,
lemmatiser ou étiqueter grammaticalement.

Pour l’utiliser, installe-la avec :

pip install nltk

Une fois installée, tu peux l’utiliser pour segmenter du texte :

import nltk
nltk.download('punkt')
nltk.download('punkt_tab')
from nltk.tokenize import sent_tokenize, word_tokenize

texte = "Bonjour. Ceci est un test. Le chatbot fonctionne !"
print(sent_tokenize(texte))
['Bonjour.', 'Ceci est un test.', 'Le chatbot fonctionne !']
print(word_tokenize(texte))
['Bonjour', '.', 'Ceci', 'est', 'un', 'test', '.', 'Le', 'chatbot', 'fonctionne', '!']

nltk sait détecter les ponctuations isolées, les contractions, et gère mieux les textes typographiques complexes.

`spaCy` : segmentation avancée, pensée pour la performance

spaCy ↗ est une bibliothèque moderne de NLP, conçue pour la vitesse, la précision, et la production. Elle propose :

segmentation,
reconnaissance d’entités,
POS tagging,
lemmatisation,
parsing syntaxique.

Elle est souvent utilisée pour les projets orientés production ou IA avancée.

Pour l’utiliser, installe-la avec :

pip install spacy
python -m spacy download fr_core_news_sm

La seconde ligne télécharge le modèle linguistique français.

Pour l’utiliser, voici un exemple :

import spacy
nlp = spacy.load("fr_core_news_sm")

doc = nlp("Bonjour. Voici un test. Cet assistant fonctionne-t-il ?")

print([sent.text for sent in doc.sents])
['Bonjour.', 'Voici un test.', 'Cet assistant fonctionne-t-il ?']

print([token.text for token in doc])
['Bonjour', '.', 'Voici', 'un', 'test', '.', 'Cet', 'assistant', 'fonctionne', '-', 't', '-', 'il', '?']

spaCy découpe les phrases avec grande précision et tient compte des règles grammaticales du français.

Aperçu des tokenizers LLM

Les modèles de langage modernes utilisent un découpeur (tokenizer) spécial, souvent appelé SentencePiece. Il transforme un texte en blocs très fins de sens : pas seulement des mots, mais des morceaux de mots, des préfixes, des suffixes… Cela permet de mieux gérer les fautes, les mots rares ou les mélanges de langues.

Parmi les tokenizers les plus utilisés, on trouve :

Hugging Face Transformers : pour les modèles pré-entraînés
SentencePiece : pour les modèles Google et Mistral
Byte-Pair Encoding (BPE) : pour les modèles OpenAI
WordPiece : pour les modèles BERT
Unigram : pour les modèles T5
FastText : pour les modèles Facebook

Exemple avec SentencePiece, un tokenizer populaire pour les LLM.

Installons d’abord la bibliothèque :

pip install sentencepiece

Téléchargeons un modèle pré-entraîné ou entraînons le nôtre :

wget https://huggingface.co/camembert-base/resolve/main/sentencepiece.bpe.model -O camembert.model

Puis utilise le tokenizer :

import sentencepiece as spm
import re
import html
import unicodedata
from bs4 import BeautifulSoup

# Télécharge un modèle pré-entraîné ou entraîne le tien (ici, exemple avec un modèle universel)
sp = spm.SentencePieceProcessor(model_file='camembert.model')

def nettoyer_texte(texte):
    # Supprimer le HTML
    texte = BeautifulSoup(texte, "html.parser").get_text()
    # Décoder les entités HTML
    texte = html.unescape(texte)
    # Remplacer les symboles monétaires par des mots
    texte = texte.replace("€", " euros ")
    # Supprimer les caractères invisibles et de contrôle
    texte = ''.join(c for c in texte if not unicodedata.category(c).startswith(('C',)))
    # Supprimer les emojis avec une expression régulière
    texte = re.sub(r'[\U0001F600-\U0001F64F]', '', texte)
    # Réduire les ponctuations répétées (ex: "!!!" → ".")
    texte = re.sub(r'[!?.]{2,}', '.', texte)
    # Supprimer les symboles indésirables (garder ponctuation standard)
    texte = re.sub(r'[^\w\s.,!?àâçéèêëîïôûùüÿñæœ-]', '', texte)
    # Normaliser les espaces
    texte = re.sub(r'\s+', ' ', texte).strip()
    return texte

# Exemple de texte tokenisé
texte = "<p>EXEMPLE!!! de texte à nettoyer... 123 € <br>\n\tAvec des MAJUSCULES, des chiffres, des symboles €, et des caractères invisibles\u200b. 😃</p>"
texte_nettoye = nettoyer_texte(texte).lower()
print(texte_nettoye)
tokens = sp.encode(texte_nettoye, out_type=str)

print(tokens)
['▁exemple', '!!!', '▁de', '▁texte', '▁à', '▁nettoyer', '...', '▁123', '▁€', '▁avec', '▁des', '▁majuscule', 's', ',', '▁des', '▁chiffres', ',', '▁des', '▁symboles', '▁€', ',', '▁et', '▁des', '▁caractères', '▁invisible', 's', '.']

Notre fonction nettoyer_texte supprime les balises HTML, les entités, les caractères invisibles, les emojis, et normalise la ponctuation. Elle ne fonctionne qu’avec ce texte précis, il faudra l’adapter à vos cas d’usage.

Conclusion

Vous aurez compris, le nettoyage et la compréhension de la tokenisation de textes sont des étapes importantes pour préparer les données avant de les utiliser dans des modèles de langage ou des systèmes de recherche. En appliquant des techniques de prétraitement, vous pourrez améliorer la qualité des entrées fournies aux modèles, ce qui se traduit par de meilleures performances et une compréhension plus fine du contenu.

Grâce à ce nettoyage, votre texte passe de “brouillon illisible” à “page claire et structurée”, prête à être comprise par une intelligence artificielle. C’est la première étape vers un assistant fiable.

Prochaines étapes

Maintenant que vous avez compris comment nettoyer du texte et ce qu’est la tokenisation, vous pouvez passer à la suite du programme avec la découverte des LLM avec Hugging Face, où vous apprendrez à utiliser des modèles pré-entraînés pour répondre à des questions, résumer du texte, ou même générer du contenu.