Natural Language Processing (NLP) - Fondements et applications

Auteur: Mohamed CHINY Durée necessaire pour le cours de Natural Language Processing (NLP) - Fondements et applications Niveau recommandé pour le cours de Natural Language Processing (NLP) - Fondements et applications Supports vidéo non disponibles pour ce cours Exercices de renforcement non disponibles pour ce cours Quiz disponible pour ce cours

Leçon 10: Extraction n-grammes pour enrichir la représentation du langage

Toutes les leçons

Extraction n‑grammes: comprendre les séquences de mots

Les n-grammes: la clé des dépendances locales

Les n‑grammes sont des séquences de n unités consécutives extraites d’un texte après la tokenisation.

Lorsqu’on prend un seul mot à la fois, on parle d’unigramme(exemple: "chat", "chien"...). Si l’on considère deux mots successifs, on obtient des bigrammes (exemple: "petit chat", "chien paresseux"...). Avec trois mots, ce sont des trigrammes (exemple: "le petit chat"...). Cette approche peut être étendue à des séquences plus longues, selon les besoins.

L’utilité des n‑grammes réside dans leur capacité à capturer le contexte local et les cooccurrences entre mots. Par exemple, un unigramme ne donne qu’une information isolée, tandis qu’un bigramme ou trigramme permet de comprendre comment les mots s’enchaînent dans une phrase.

A titre d'exemple, dans une phrase comme "le chien paresseux", l’extraction des trigrammes ("le", "chien", "paresseux") révèle une cooccurrence de trois mots qui décrit une entité complète. Ces cooccurrences permettent de capturer des relations locales entre tokens plutôt que de traiter les tokens isolés.

L'approche des n-grammes est particulièrement précieuse pour des tâches comme la modélisation du langage, la détection de collocations ou encore l’amélioration des systèmes de recherche et de traduction automatique.

En pratique, les n‑grammes servent à enrichir la représentation du texte lors du préprocessing. Ils permettent de construire des modèles statistiques simples (comme les modèles de Markov) ou d’alimenter des algorithmes plus complexes. Leur force est de fournir une vision intermédiaire, c'est à dire plus riche que des mots isolés, mais moins lourde que l’analyse syntaxique complète.
Il existe aussi des approches plus avancées comme l’analyse de dépendance syntaxique. Celle‑ci ne se limite pas à la succession des mots mais elle identifie les relations grammaticales (sujet, verbe, complément...) et construit un graphe de dépendances.

Exemple pratique de l'impémentaion des n-grammes

Nous allons voir comment utiliser NLTK pour générer des n‑grammes à partir d’un texte.

Je propose ce code:
import nltk
from nltk.tokenize import word_tokenize
from nltk.util import ngrams
texte = "Hello everyone. How are you?"
tokens = word_tokenize(texte)
unigramme = list(ngrams(tokens, 1))
print(unigramme)
bigramme = list(ngrams(tokens, 2))
print(bigramme)
On commence par importer les fonctions nécessaires: word_tokenize pour découper la phrase en tokens (mots et ponctuation) et ngrams pour créer des séquences de longueur n.
Nous avons utilisé une tokenisation simple (découpage en mots et ponctuation) pour générer des n‑grammes. On pourrait toutefois utiliser les méthode de tokenisation avancées comme BPE ou WordPiece, mais le principe reste le même, c'est à dire transformer le texte brut en tokens, puis construire des représentations comme les n‑grammes pour capturer les relations entre ces unités.
Le texte "Hello everyone. How are you?" est ensuite transformée en une liste de tokens:

tokens = word_tokenize(texte)
L’appel ngrams(tokens, 1) produit les unigrammes, c’est‑à‑dire chaque mot pris individuellement, tandis que ngrams(tokens, 2) génère les bigrammes, soit toutes les paires de mots consécutifs.
La fonction ngrams() de NLTK ne renvoie pas directement une liste, mais un itérateur (un générateur) qui produit les n‑grammes un par un. C’est une manière efficace de gérer la mémoire, surtout pour de grands corpus, car les n‑grammes ne sont pas tous stockés en même temps. En utilisant list(ngrams(tokens, 1)), on force l’évaluation complète de l’itérateur et on transforme le résultat en une liste Python.
L'exécution du code produit ce résultat:
[('Hello',), ('everyone',), ('.',), ('How',), ('are',), ('you',), ('?',)]

[('Hello', 'everyone'), ('everyone', '.'), ('.', 'How'), ('How', 'are'), ('are', 'you'), ('you', '?')]
Les tuples représentent les séquences générées: chaque unigramme est un tuple contenant un seul mot, tandis que chaque bigramme est un tuple regroupant deux mots consécutifs, ce qui permet de mettre en évidence leurs associations et les cooccurrences locales dans le texte.