Accueil › Glossaire › Lemmatization

Lemmatization (Lemmatisation)

La lemmatisation est une technique de traitement du langage naturel (NLP) qui réduit chaque mot à sa forme de base (le « lemme »), c’est-à-dire la forme que vous trouveriez dans un dictionnaire, en tenant compte du contexte grammatical et de la catégorie du mot (nom, verbe, adjectif).

Contrairement au stemming qui coupe mécaniquement les suffixes, la lemmatisation produit toujours un mot valide. « running » devient « run », « better » devient « good », « mice » devient « mouse », « was » devient « be ». Le lemme conserve le sens du mot original, ce qui rend cette technique indispensable pour les applications où la compréhension linguistique compte : chatbots, analyse de sentiment, recherche sémantique, résumé automatique.

Comment fonctionne la lemmatisation

La lemmatisation opère en trois étapes distinctes. Premièrement, le texte est découpé en tokens (mots individuels) par le tokenizer. Deuxièmement, chaque token reçoit une étiquette grammaticale (POS tag) qui identifie sa catégorie : nom, verbe, adjectif, adverbe. Troisièmement, l’algorithme de lemmatisation utilise cette étiquette combinée à un dictionnaire lexical pour retrouver la forme de base correspondante.

Cette dépendance au POS tagging est cruciale. Sans lui, le mot « meeting » pourrait être lemmatisé en « meet » (verbe) alors qu’il s’agit d’un nom (« a meeting »). Le mot « saw » pourrait devenir « see » (verbe : j’ai vu) ou rester « saw » (nom : une scie). Sans contexte, impossible de choisir correctement.

Prenons la phrase « The striped bats are hanging on their feet for best ». Avec un lemmatiseur correctement configuré (POS tagging activé), le résultat est : « the strip bat be hang on their foot for good ». Notez que « bats » devient « bat » (nom), « are » devient « be » (verbe), « feet » devient « foot » (forme irrégulière correctement gérée) et « best » devient « good » (superlatif résolu).

Les trois techniques de lemmatisation

Lemmatisation par règles

L’approche la plus simple. Des règles prédéfinies transforment les suffixes connus : supprimer « -ed » pour le passé des verbes réguliers, supprimer « -s » pour le pluriel des noms. C’est rapide et interprétable, mais cette méthode échoue sur les formes irrégulières. « better » ne sera pas ramené à « good » car aucune règle de suppression de suffixe ne permet cette transformation.

Lemmatisation par dictionnaire

C’est l’approche utilisée par WordNet (via NLTK) et par les tables de lookup de spaCy. Chaque mot est recherché dans une base de données lexicale qui contient les correspondances entre formes fléchies et lemmes. WordNet, développé à l’Université de Princeton depuis les années 1980, contient environ 155 000 chaînes de caractères uniques réparties dans 117 000 synsets (groupes de synonymes), avec plus de 200 000 paires mot-sens. L’Open English WordNet, maintenu par la communauté, comptait 161 705 mots dans 120 630 synsets lors de sa mise à jour de 2024.

Cette approche gère les formes irrégulières (« went » → « go », « mice » → « mouse ») mais nécessite un dictionnaire exhaustif. Un mot absent du dictionnaire ne sera pas lemmatisé.

Lemmatisation par machine learning

L’approche la plus moderne et la plus flexible. Un modèle entraîné sur des corpus annotés prédit le lemme de chaque token. L’EditTreeLemmatizer de spaCy (introduit dans la v3.3) apprend les transformations forme-vers-lemme à partir de données d’entraînement en utilisant des « edit trees » (arbres d’édition). Il atteint des scores de précision supérieurs à 94 % sur la plupart des langues testées, et jusqu’à 97 % pour l’italien sur le corpus ISDT.

Depuis spaCy v3.3, le lemmatiseur entraînable (trainable_lemmatizer) est devenu le composant standard pour de nombreuses langues : danois, néerlandais, finnois, allemand, grec, italien, coréen, lituanien, norvégien, polonais, portugais, roumain et suédois.

WordNet : la base de données derrière NLTK

WordNet est bien plus qu’un simple dictionnaire. C’est une base de données lexicale qui organise les mots non pas par ordre alphabétique mais par sens. Les mots sont regroupés en synsets (synonym sets), chacun représentant un concept distinct. Le nom « car » possède cinq synsets dans WordNet, correspondant à cinq sens différents : automobile, wagon de chemin de fer, nacelle de dirigeable, cabine d’ascenseur et téléphérique.

Le WordNetLemmatizer de NLTK utilise cette structure pour la lemmatisation. Quand vous passez le mot « feet » avec le POS tag « nom », WordNet le résout en « foot ». Quand vous passez « better » avec le POS tag « adjectif », il le résout en « good ». Cette résolution repose sur les relations sémantiques encodées dans la base de données, notamment l’hyperonymie (relation « est un type de ») et l’hyponymie (relation inverse).

Pour le français, le WordNet libre du français (WOLF) est une ressource équivalente issue d’une traduction automatique du WordNet 3 anglais. Cependant, pour le NLP en français, les outils dédiés comme spaCy ou Stanza offrent de meilleurs résultats que les approches basées sur WOLF.

Implémentation en Python

NLTK avec WordNet

L’approche classique. WordNetLemmatizer est le lemmatiseur le plus enseigné, mais attention : sans POS tag explicite, il traite tout mot comme un nom par défaut, ce qui dégrade fortement les résultats.

import nltk
from nltk.stem import WordNetLemmatizer
from nltk.corpus import wordnet

nltk.download('wordnet')
nltk.download('omw-1.4')
nltk.download('averaged_perceptron_tagger')

lemmatizer = WordNetLemmatizer()

# Sans POS tag (défaut = nom) : résultats médiocres
print(lemmatizer.lemmatize("running"))  # 'running' (inchangé !)
print(lemmatizer.lemmatize("better"))   # 'better' (inchangé !)

# Avec POS tag : résultats corrects
print(lemmatizer.lemmatize("running", pos="v"))  # 'run'
print(lemmatizer.lemmatize("better", pos="a"))   # 'good'
print(lemmatizer.lemmatize("feet", pos="n"))      # 'foot'
print(lemmatizer.lemmatize("was", pos="v"))       # 'wa' (limitation)

Le problème est clair : sans POS tag, « running » reste « running ». Pour automatiser le POS tagging, vous devez créer une fonction de mapping entre les tags Penn Treebank (utilisés par NLTK) et les tags WordNet :

def get_wordnet_pos(word):
    """Mapper le POS tag NLTK vers le format WordNet"""
    tag = nltk.pos_tag([word])[0][1][0].upper()
    tag_dict = {
        "J": wordnet.ADJ,
        "N": wordnet.NOUN,
        "V": wordnet.VERB,
        "R": wordnet.ADV
    }
    return tag_dict.get(tag, wordnet.NOUN)

sentence = "The striped bats are hanging on their feet for best"
tokens = nltk.word_tokenize(sentence)
lemmas = [lemmatizer.lemmatize(w, get_wordnet_pos(w)) for w in tokens]
print(lemmas)
# ['The', 'strip', 'bat', 'be', 'hang', 'on', 'their', 'foot', 'for', 'best']

spaCy

spaCy est la solution recommandée pour la production. Le POS tagging est automatique (intégré au pipeline), la lemmatisation est contextuelle, et les performances sont nettement supérieures à NLTK.

import spacy

nlp = spacy.load("en_core_web_sm")
doc = nlp("The striped bats are hanging on their feet for best")

for token in doc:
    print(f"{token.text:12} → {token.lemma_:10} ({token.pos_})")

# The          → the        (DET)
# striped      → stripe     (VERB)
# bats         → bat        (NOUN)
# are          → be         (AUX)
# hanging      → hang       (VERB)
# on           → on         (ADP)
# their        → their      (PRON)
# feet         → foot       (NOUN)
# for          → for        (ADP)
# best         → good       (ADJ)

spaCy résout correctement « best » en « good », ce que NLTK échoue à faire même avec POS tagging. Le pipeline complet (tokenisation → POS tagging → lemmatisation) tourne en une seule passe, ce qui le rend bien plus pratique que l’approche NLTK en plusieurs étapes.

Depuis la v3.0, le lemmatiseur de spaCy est un composant de pipeline autonome (et non plus un processus caché dans le vocabulaire). Depuis la v3.3, de nombreux pipelines entraînés utilisent l’EditTreeLemmatizer, un lemmatiseur entraînable qui apprend les transformations à partir de corpus annotés.

Stanza (Stanford NLP)

Stanza est la librairie NLP de l’Université de Stanford. Elle offre des modèles entraînés sur les corpus Universal Dependencies pour plus de 70 langues, avec des performances souvent supérieures à spaCy sur les langues moins dotées.

import stanza

stanza.download('fr')
nlp = stanza.Pipeline('fr', processors='tokenize,mwt,pos,lemma')

doc = nlp("Les enfants couraient dans le jardin")
for sent in doc.sentences:
    for word in sent.words:
        print(f"{word.text:12} → {word.lemma}")

# Les          → le
# enfants      → enfant
# couraient    → courir
# dans         → dans
# le           → le
# jardin       → jardin

Stanza est particulièrement performant pour le français. Il gère correctement les conjugaisons complexes (« couraient » → « courir ») et les accords grammaticaux. Son inconvénient principal est sa vitesse, nettement inférieure à spaCy.

Lemmatisation en français

Le français pose des défis spécifiques à la lemmatisation. La morphologie verbale est riche (6 personnes × 8 temps courants × 3 groupes de conjugaison), les accords en genre et en nombre sont systématiques, et les formes irrégulières sont fréquentes (« suis », « es », « est », « sommes », « êtes », « sont » doivent tous converger vers « être »).

spaCy pour le français

spaCy propose des modèles français (fr_core_news_sm, fr_core_news_md, fr_core_news_lg) qui intègrent la lemmatisation. La qualité est correcte pour les cas standards, mais des erreurs persistent sur les formes ambiguës. Par exemple, « fait » dans « c’est un fait » devrait rester « fait » (nom) mais peut être incorrectement lemmatisé en « faire » (verbe) si le contexte est mal interprété.

import spacy

nlp = spacy.load("fr_core_news_sm")
doc = nlp("Les chats chassaient une souris dans le jardin")

for token in doc:
    print(f"{token.text:12} → {token.lemma_:10} ({token.pos_})")

# Les          → le         (DET)
# chats        → chat       (NOUN)
# chassaient   → chasser    (VERB)
# une          → un         (DET)
# souris       → souris     (NOUN)
# dans         → dans       (ADP)
# le           → le         (DET)
# jardin       → jardin     (NOUN)

Alternatives pour le français

Stanza offre des résultats souvent plus précis que spaCy pour le français, grâce à ses modèles entraînés sur les corpus Universal Dependencies. Le LEFFF (Lexique des Formes Fléchies du Français), accessible via le package spacy-lefff, fournit un lexique complémentaire pour améliorer la lemmatisation de spaCy. Pour des tâches nécessitant une compréhension contextuelle profonde, les modèles BERT français comme CamemBERT (développé par l’INRIA) et FlauBERT offrent une précision supérieure après fine-tuning, au prix de ressources computationnelles plus importantes.

Stemming vs lemmatisation : quand choisir quoi

La question revient constamment. Voici le cadre de décision.

Utilisez le stemming pour l’indexation de recherche à grande échelle (Elasticsearch, Solr), le traitement de très gros volumes où chaque milliseconde compte, et les index internes jamais exposés à l’utilisateur.

Utilisez la lemmatisation pour l’analyse de sentiment, les chatbots et assistants conversationnels, les systèmes de question-réponse, le résumé automatique, la désambiguïsation lexicale (word sense disambiguation), et tout cas où la validité linguistique du résultat importe.

Cas d’usage en production

Chatbots et assistants virtuels

La lemmatisation est essentielle pour comprendre les requêtes utilisateur. Si un utilisateur écrit « j’ai acheté des chaussures », le chatbot doit reconnaître que « acheté » correspond à « acheter » pour déclencher le bon flux conversationnel. Le stemming produirait « achet », inutilisable pour la correspondance avec un dictionnaire d’intentions.

Analyse de sentiment

La lemmatisation améliore la précision de l’analyse de sentiment en traitant « aimé », « aime », « aimant », « aimerait » comme des variantes de « aimer ». Cela réduit la dimensionnalité du vocabulaire tout en préservant le sens, ce que le stemming ne garantit pas (le stem « aim » est ambigu entre « aimer » et « aimant/aiguille »).

Recherche sémantique et RAG

Dans les systèmes de RAG (Retrieval-Augmented Generation), la lemmatisation prépare les documents avant l’indexation vectorielle. Les word embeddings bénéficient d’un vocabulaire normalisé : au lieu d’apprendre des représentations séparées pour « acheter », « acheté », « achèterait », le modèle travaille sur une seule forme canonique.

Text mining et topic modeling

Pour l’analyse thématique de corpus (LDA, NMF), la lemmatisation produit des topics plus interprétables. Un topic contenant « acheter, vendre, payer » est immédiatement compréhensible, contrairement à un topic stemmé contenant « achet, vendr, pay ».

Moteurs de recherche avancés

Elasticsearch utilise principalement le stemming pour l’indexation, mais la lemmatisation apporte une valeur ajoutée pour les recherches précises. Le filtre Hunspell d’Elasticsearch permet d’utiliser des dictionnaires Hunspell pour une lemmatisation basée sur dictionnaire, avec une qualité directement liée à celle du dictionnaire utilisé. Pour le français, le dictionnaire Hunspell français est bien maintenu et offre de bons résultats.

Limites et pièges de la lemmatisation

Coût computationnel

La lemmatisation est significativement plus lente que le stemming. Le POS tagging est lui-même une opération coûteuse, et la consultation du dictionnaire ajoute un overhead. Pour des corpus de milliards de documents, cette différence est critique. C’est pourquoi les moteurs de recherche massifs préfèrent le stemming pour l’indexation brute.

Dépendance au POS tagging

La qualité de la lemmatisation dépend directement de la qualité du POS tagging. Un POS tag incorrect produit un lemme incorrect. Avec NLTK, il faut gérer soi-même le mapping POS, ce qui est source d’erreurs. spaCy intègre le POS tagging dans son pipeline, mais des erreurs de tagging propagent des erreurs de lemmatisation.

Mots hors vocabulaire

Les lemmatiseurs par dictionnaire ne peuvent pas traiter les mots absents de leur base. Les néologismes, le jargon technique, les noms propres et les emprunts étrangers passent souvent entre les mailles. Les lemmatiseurs entraînables (EditTreeLemmatizer de spaCy) gèrent mieux ce cas car ils apprennent des patterns de transformation, mais ils ne sont pas infaillibles.

Domaines spécialisés

Le vocabulaire médical, juridique ou scientifique pose des problèmes récurrents. « diagnoses » devrait donner « diagnosis », « hypoglycemic » devrait donner « hypoglycemia ». Les lemmatiseurs généralistes échouent souvent sur ces termes. La solution consiste à enrichir les tables de lookup avec du vocabulaire domaine-spécifique, ou à utiliser des modèles spécialisés comme SciSpaCy pour le domaine biomédical.

Lemmatisation et LLM

Les grands modèles de langage utilisent des tokenizers par sous-mots (BPE, SentencePiece) qui découpent les mots en unités sub-lexicales. Cette approche capture implicitement les relations morphologiques : « running » est découpé en « runn » + « ing », ce qui permet au modèle d’associer les variantes sans lemmatisation explicite.

La lemmatisation reste cependant utile dans le preprocessing des données d’entraînement, la préparation des documents pour le RAG, l’analyse de fréquences de termes (pour identifier les thèmes d’un corpus), et les applications avec contraintes de ressources (edge computing, mobile) où un LLM complet n’est pas envisageable.

En résumé : les LLM n’ont pas rendu la lemmatisation obsolète. Ils ont simplement réduit son rôle de composant central à celui d’outil complémentaire dans des architectures plus larges.