Wilson Toussile1 2
ENSPY
1ENSPY, 2ESSFAR
May 25, 2025
Bienvenue dans ce tutoriel ! Notre objectif est de vous aider à comprendre l’Allocation Latente de Dirichlet (LDA), un outil puissant pour découvrir les “sujets” ou “thèmes” cachés dans de grandes collections de textes. Pas besoin d’être un expert en statistiques bayésiennes complexes ; nous allons aborder cela de manière intuitive.
À la fin de ce tutoriel, vous devriez :
Commençons !
Imaginez que vous avez une énorme pile d’articles de journaux, des milliers d’e-mails de clients, ou une collection de critiques de produits. Comment pourriez-vous rapidement savoir quels sont les sujets principaux abordés dans tous ces textes sans avoir à tout lire ? C’est là que LDA entre en jeu.
Définitions clés (version simple) :
Document : Un morceau de texte (un article, un commentaire, un chapitre de livre, etc.).
Mot : L’unité de base de nos textes.
Thème (ou “Topic” en anglais) : Une collection de mots qui apparaissent souvent ensemble et qui, ensemble, représentent une idée ou un sujet commun.
LDA est un algorithme qui nous aide à découvrir automatiquement ces thèmes à partir des documents eux-mêmes.
Pour comprendre LDA de façon intuitive, utilisons une analogie : celle de la cuisine !
Documents = Plats cuisinés
Thèmes = Catégories d’ingrédients / Types de cuisine
Mots = Ingrédients spécifiques
Comment LDA voit les choses avec cette analogie :
Chaque plat (document) est un mélange de types de cuisine (thèmes).
Chaque type de cuisine (thème) est caractérisé par des ingrédients (mots) typiques.
Le problème, c’est que dans la réalité, nous avons seulement les documents finis (les “plats cuisinés”). Nous ne connaissons pas à l’avance :
LDA fait le travail inverse, une sorte de “reverse engineering” :
À partir de la collection de documents que nous lui donnons, LDA essaie de deviner :
Pour utiliser LDA, voici ce que vous devez lui fournir et ce que vous obtenez en retour :
Entrée (Ce que vous donnez à LDA) :
Sortie (Ce que LDA vous donne) :
Une liste de \(K\) thèmes : Chaque thème est représenté comme une distribution de probabilités sur l’ensemble des mots du vocabulaire. En pratique, on regarde les mots ayant les plus fortes probabilités pour chaque thème pour comprendre de quoi parle ce thème.
Pour chaque document, sa “distribution de thèmes” : Une liste de proportions indiquant à quel point chaque thème est présent dans ce document.
Sans entrer dans les détails mathématiques, sachez qu’il existe souvent deux autres “réglages” principaux (souvent appelés alpha et beta ou eta) qui peuvent influencer les résultats de LDA :
Alpha (\(\alpha\)) – Diversité des thèmes par document :
Beta (\(\beta\)) ou Eta (\(\eta\)) – Spécificité des mots par thème :
Pour commencer, se concentrer sur le choix de \(K\) (le nombre de thèmes) est souvent le plus important. Les valeurs par défaut pour \(\alpha\) et \(\beta\) sont souvent un bon point de départ.
Vous vous demandez peut-être comment l’ordinateur arrive à deviner tout cela ? L’algorithme LDA est assez astucieux. Voici une idée très simplifiée de son fonctionnement (souvent par une méthode appelée “Échantillonnage de Gibbs”) :
Initialisation : Au début, l’algorithme assigne chaque mot de chaque document à l’un des \(K\) thèmes, de manière plus ou moins aléatoire. Les thèmes ne veulent donc pas dire grand-chose à ce stade.
Itérations (Répétitions) : L’algorithme va ensuite parcourir chaque mot dans chaque document, encore et encore. Pour chaque mot, il va se demander :
Mise à jour : Sur la base de ces calculs (probabilistes), l’algorithme réassigne le mot à un thème (qui peut être le même ou un nouveau).
Convergence : En répétant l’étape 2 et 3 de nombreuses fois, les assignations des mots aux thèmes deviennent de plus en plus stables et cohérentes. Les thèmes commencent à “émerger” comme des ensembles de mots qui apparaissent fréquemment ensemble, et les documents montrent des préférences claires pour certains thèmes.
Ce processus itératif permet à LDA de converger vers une solution où les thèmes sont distincts et où la composition thématique des documents est logique par rapport à leur contenu.
LDA est utilisé dans de nombreux domaines :
Passons à un petit exemple pratique pour voir LDA en action. Nous allons utiliser la bibliothèque scikit-learn en Python, qui propose une implémentation de LDA.
Prérequis : Assurez-vous d’avoir Python et scikit-learn installés. Si ce n’est pas le cas, vous pouvez les installer via pip :
Nous utiliserons aussi nltk pour une tokenisation basique, bien que pour des projets réels, un prétraitement plus poussé soit nécessaire.
a) Nos Données d’Exemple
Imaginons que nous ayons une petite collection de documents (phrases) :
# Nos documents d'exemple
documents = [
"Le soleil brille, les oiseaux chantent dans le ciel bleu.",
"Match de foot passionnant, l'équipe locale gagne le championnat.",
"Nouvelle recette de gâteau au chocolat, un délice pour le dessert.",
"Le temps est nuageux aujourd'hui, risque de pluie et d'orage.",
"Le joueur de tennis a remporté une victoire importante au tournoi.",
"Préparer une tarte aux pommes avec des fruits frais du marché."
]b) Prétraitement Simple des Textes
LDA fonctionne sur des données numériques. Nous devons donc transformer nos textes en une matrice de comptes de mots. CountVectorizer de scikit-learn est parfait pour cela. Il va :
import nltk
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.decomposition import LatentDirichletAllocation
import numpy as np
# Télécharger les ressources nécessaires pour NLTK (si c'est la première fois)
try:
nltk.data.find('tokenizers/punkt')
except nltk.downloader.DownloadError:
nltk.download('punkt')
try:
nltk.data.find('corpora/stopwords')
except nltk.downloader.DownloadError:
nltk.download('stopwords')
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
# Définir les stop words en français
stop_words_fr = list(stopwords.words('french'))
# Ajouter quelques mots courants ou non pertinents si besoin
stop_words_fr.extend(['le', 'la', 'les', 'un', 'une', 'des', 'et', 'de', 'du', 'pour', 'avec', 'dans', 'est', 'sont', 'fait', 'faire', 'plus', 'moins', 'tout', 'très', 'ça', 'cela', 'il', 'elle', 'ils', 'elles', 'on', 'je', 'tu', 'nous', 'vous', 'au', 'aux', 'ce', 'cet', 'cette', 'ces', 'mon', 'ma', 'mes', 'ton', 'ta', 'tes', 'son', 'sa', 'ses', 'notre', 'nos', 'votre', 'vos', 'leur', 'leurs', "l'", "d'", "s'", "qu'"])
# Fonction de tokenisation personnalisée pour CountVectorizer
def french_tokenizer(text):
words = word_tokenize(text.lower(), language='french')
return [word for word in words if word.isalpha() and word not in stop_words_fr]
# Créer le vectoriseur
# max_df=0.95 : ignore les mots qui apparaissent dans plus de 95% des documents (trop communs)
# min_df=1 : ignore les mots qui apparaissent dans moins de 1 document (nécessaire pour petits corpus, ajuster pour plus grands)
# ngram_range=(1,1) : on considère les mots individuellement (pas de bigrammes, etc.)
vectorizer = CountVectorizer(tokenizer=french_tokenizer, max_df=0.95, min_df=1, ngram_range=(1,1))
# Appliquer le vectoriseur à nos documents
X = vectorizer.fit_transform(documents)
# Afficher le vocabulaire créé
print("Vocabulaire (les mots que LDA va utiliser) :")
print(vectorizer.get_feature_names_out())
print(f"\nDimensions de notre matrice de mots : {X.shape}") # (nombre de documents, nombre de mots uniques)c) Application de LDA
Maintenant, appliquons LDA. Nous devons choisir le nombre de thèmes (\(K\)). Pour notre petit exemple, essayons avec \(K=2\) ou \(K=3\).
d) Interprétation des Résultats
def print_top_words(model, feature_names, n_top_words):
print(f"\n--- Thèmes découverts (avec {n_topics} thèmes) ---")
for topic_idx, topic in enumerate(model.components_):
message = f"Thème #{topic_idx}: "
message += " ".join([feature_names[i]
for i in topic.argsort()[:-n_top_words - 1:-1]])
print(message)
n_top_words = 5 # Nombre de mots clés à afficher par thème
feature_names = vectorizer.get_feature_names_out()
print_top_words(lda, feature_names, n_top_words)Regardez les listes de mots. Chaque liste représente un thème. Essayez de donner un nom ou une étiquette à chaque thème en fonction des mots qui le composent (par exemple, “Météo/Nature”, “Sport”, “Cuisine”). Avec seulement 6 phrases, les thèmes peuvent être un peu mélangés ou difficiles à interpréter clairement. Avec des centaines ou milliers de documents, les thèmes deviennent généralement beaucoup plus cohérents.
# Obtenir la distribution des thèmes pour chaque document
doc_topic_dist = lda.transform(X)
print("\n--- Distribution des thèmes par document ---")
for i, doc in enumerate(documents):
print(f"Document {i+1}: \"{doc[:50]}...\"")
topic_distribution_str = ", ".join([f"Thème {j}: {dist*100:.1f}%" for j, dist in enumerate(doc_topic_dist[i])])
print(f" Distribution: {topic_distribution_str}")
print(f" Thème principal: Thème #{np.argmax(doc_topic_dist[i])}")Pour chaque document, LDA nous donne des pourcentages indiquant son appartenance à chaque thème. Par exemple, un document pourrait être “70% Thème A, 30% Thème B”.
Avec si peu de données (6 phrases), les thèmes découverts par LDA peuvent ne pas être parfaits ou très distincts. LDA donne de bien meilleurs résultats avec des corpus plus volumineux. Cet exemple sert surtout à illustrer le mécanisme.
Félicitations ! Vous avez maintenant une compréhension intuitive de ce qu’est l’Allocation Latente de Dirichlet, comment elle fonctionne en théorie, et comment l’appliquer simplement en Python.
Exercise 1 (News Groups) Mettre en pratique l’Allocation Latente de Dirichlet (LDA) pour découvrir, analyser et interpréter les thèmes principaux présents dans un corpus de messages de groupes de discussion (newsgroups), en se concentrant sur des sujets liés à l’économie, la religion, la science et le sport.
Corpus
Nous utiliserons le dataset “20 Newsgroups”. Ce corpus contient environ 18 000 messages textuels (en anglais) postés sur 20 forums de discussion différents. Pour cet exercice, nous sélectionnerons des catégories qui se rapprochent le plus des thèmes demandés.
Tâches à Réaliser
1. Chargement des Données
Chargez le dataset “20 Newsgroups” en utilisant la fonction fetch_20newsgroups de sklearn.datasets. Sélectionnez les catégories suivantes pour correspondre au mieux aux thèmes ciblés :
misc.forsale (contient des discussions sur les ventes, les prix, ce qui se rapproche le plus d’aspects économiques dans ce dataset).soc.religion.christian (ou alt.atheism ou talk.religion.misc si vous préférez une autre perspective).sci.med (médecine) ou sci.space (espace) ou sci.electronics (électronique). Choisissez-en une ou deux.rec.sport.baseball ou rec.sport.hockey. Choisissez-en une.Veillez à retirer les en-têtes, pieds de page et citations pour nettoyer les données textuelles.
from sklearn.datasets import fetch_20newsgroups
# Choix des catégories pour l'exercice
# Note: 'misc.forsale' est utilisé comme proxy pour 'Économie'
categories_selection = [
'misc.forsale', # Proxy pour Économie
'soc.religion.christian', # Religion
'sci.med', # Science (Médecine)
'rec.sport.baseball' # Sport (Baseball)
]
# Alternative pour Science et Sport si vous voulez varier :
# 'sci.space'
# 'rec.sport.hockey'
print(f"Catégories sélectionnées : {categories_selection}")
# Chargement du sous-ensemble de données d'entraînement
# 'remove' permet de nettoyer un peu les textes
newsgroups_data = fetch_20newsgroups(
subset='train',
categories=categories_selection,
remove=('headers', 'footers', 'quotes'),
shuffle=True, # Mélanger les données
random_state=42 # Pour la reproductibilité
)
documents = newsgroups_data.data
# newsgroups_data.target contiendra les étiquettes numériques des catégories (utile pour vérification)
# newsgroups_data.target_names contiendra les noms des catégories chargées
print(f"{len(documents)} documents chargés.")
if documents:
print(f"Extrait du premier document : \n{documents[0][:200]}...")2. Prétraitement des Textes
Transformez les documents textuels en une matrice de comptes de mots (TF - Term Frequency) en utilisant CountVectorizer de scikit-learn. Lors de cette étape de vectorisation :
scikit-learn ou nltk.min_df, par exemple min_df=5 ou min_df=10). Cela aide à éliminer les mots très rares ou les erreurs de frappe.max_df, par exemple max_df=0.7 ou max_df=0.85). Cela aide à éliminer les mots trop communs qui n’apportent pas de distinction thématique.NLTK ou spaCy. Pour cet exercice, une tokenisation simple avec les filtres min_df et max_df est un bon point de départ.from sklearn.feature_extraction.text import CountVectorizer
# Configuration du CountVectorizer
vectorizer = CountVectorizer(
lowercase=True,
stop_words='english', # Utilisation de la liste de stop words anglais intégrée
min_df=5, # Ignorer les termes qui apparaissent dans moins de 5 documents
max_df=0.7, # Ignorer les termes qui apparaissent dans plus de 70% des documents
ngram_range=(1, 1) # Considérer uniquement les mots individuels (unigrammes)
)
# Appliquer le vectoriseur aux documents
X_tf = vectorizer.fit_transform(documents)
# Obtenir les noms des features (mots du vocabulaire)
feature_names = vectorizer.get_feature_names_out()
print(f"Dimensions de la matrice TF (Term Frequency) : {X_tf.shape}")
print(f"Nombre de mots uniques dans le vocabulaire : {len(feature_names)}")
if len(feature_names) > 0 and len(feature_names) < 20: # Affiche si le vocabulaire est petit
print(f"Quelques mots du vocabulaire : {feature_names[:20]}")
elif len(feature_names) >= 20 :
print(f"Quelques mots du vocabulaire : {feature_names[100:120]}") # Affiche un extrait3. Application de LDA
Instanciez et entraînez un modèle LatentDirichletAllocation de sklearn.decomposition sur la matrice de comptes de mots (X_tf).
n_components. Puisque nous avons ciblé 4 grandes catégories, un bon point de départ serait \(K=4\). Vous pouvez ensuite expérimenter avec des valeurs légèrement supérieures (par exemple, \(K=6\) ou \(K=8\)) pour voir si des sous-thèmes plus fins et pertinents émergent.random_state pour assurer la reproductibilité de vos résultats.learning_decay (souvent autour de 0.7) et max_iter peuvent être laissés à leurs valeurs par défaut pour commencer, ou ajustés si besoin.4. Analyse et Interprétation des Résultats
C’est l’étape la plus importante où vous donnez du sens aux sorties du modèle.
En vous basant sur les listes de mots clés obtenues, essayez d’attribuer une étiquette sémantique (un nom ou une courte description compréhensible) à chaque thème. Par exemple : “Thème #1 : Vente et Transactions Commerciales”, “Thème #2 : Débats sur la Foi Chrétienne”, etc. Comparez ces étiquettes aux catégories initiales que vous aviez ciblées.
X_tf pour obtenir leur distribution de probabilités sur les thèmes découverts (lda_model.transform(X_tf_sample)). Affichez le texte original (ou un extrait) de ces documents et leur composition thématique. Cette composition semble-t-elle cohérente avec le contenu réel du document ?n_components (le nombre de thèmes \(K\)), discutez brièvement de l’impact de ce choix.
Livrables Attendus
Un rapport (par exemple, ce document Quarto complété avec vos sorties et analyses) contenant :
Conseils
min_df, max_df) et le nombre de thèmes \(K\) pour améliorer la qualité et l’interprétabilité des résultats.
4 Comment LDA “Imagine” la Création d’un Document
LDA est ce qu’on appelle un “modèle génératif”. Cela signifie qu’il imagine une histoire (un processus) sur la façon dont les documents pourraient avoir été créés. Voici une version simplifiée de cette histoire :
Imaginez que vous voulez écrire un nouvel article (un document) :
Étape 1 : Choisir vos sujets (et leurs proportions).
Étape 2 : Écrire chaque mot, un par un.
LDA suppose que tous les documents que nous analysons ont été créés en suivant un processus similaire à celui-ci.