Clustering : regroupement automatique
På denna sida
Objectifs
- Regrouper des textes par thème sans étiquettes prédéfinies
- Utiliser K-Means et HDBSCAN sur des embeddings
- Nommer automatiquement les clusters
Pourquoi le clustering ?
La leçon sur la classification partait du principe que tu connaissais déjà les catégories existantes. Le clustering répond à la situation inverse, qui est aussi la plus courante lors de l’exploration d’un corpus : personne ne sait ce qu’il contient. Tu récupères huit mille verbatims d’une enquête de satisfaction, ou six mois de tickets de support, et la première question n’est pas « combien de bugs ? » mais « de quoi parlent vraiment les gens ? ». Le clustering découvre des groupes thématiques sans aucune indication préalable.
Trois cas d’usage reviennent constamment : analyser des milliers de retours clients pour en extraire les tendances dominantes, identifier les sujets récurrents dans les tickets de support pour alimenter une base de connaissances, et explorer un corpus de documents inconnu avant de décider comment l’indexer.
K-Means sur les embeddings
K-Means est l’algorithme de référence : tu lui donnes un nombre de groupes, il place autant de centroïdes, et déplace itérativement chaque centroïde vers la moyenne des points qu’il attire. Appliqué à des embeddings plutôt qu’à un sac de mots, il regroupe par sens : « l’application plante au démarrage » et « impossible de se connecter depuis hier » se retrouvent ensemble même s’ils ne partagent aucun mot.
Le corpus d’exemple ci-dessous contient volontairement quatre familles — bugs, demandes de fonctionnalités, questions et compliments — pour que tu puisses vérifier visuellement le regroupement obtenu. Le paramètre random_state=42 garantit que tu obtiendras les mêmes clusters d’une exécution à l’autre, ce qui est essentiel chaque fois que tu dois comparer deux configurations.
from openai import OpenAI
from sklearn.cluster import KMeans
import numpy as np
client = OpenAI()
# Example corpus
textes = [
"L'application crash au démarrage sur Android",
"Bug : impossible de se connecter depuis hier",
"Le bouton de validation ne fonctionne pas",
"Pourriez-vous ajouter un export Excel ?",
"Suggestion : un mode hors-ligne serait utile",
"Feature request : intégrer Slack",
"Comment changer mon adresse email ?",
"Où trouver ma facture de janvier ?",
"Quel est le prix de l'abonnement annuel ?",
"Votre produit est excellent, bravo !",
"Merci pour le support réactif",
"Je recommande vivement cette application",
]
# Generate embeddings
response = client.embeddings.create(
input=textes,
model="text-embedding-3-large"
)
embeddings = np.array(
[d.embedding for d in sorted(response.data, key=lambda x: x.index)]
)
# K-Means clustering
n_clusters = 4
kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
labels = kmeans.fit_predict(embeddings)
# Display clusters
for cluster_id in range(n_clusters):
print(f"\n--- Cluster {cluster_id} ---")
indices = [i for i, l in enumerate(labels) if l == cluster_id]
for idx in indices:
print(f" {textes[idx]}")
Trouver le bon nombre de clusters
Avec douze phrases préparées, choisir quatre était évident. Avec huit mille verbatims, personne ne connaît la bonne valeur. Deux métriques t’aident à l’estimer. L’inertie, c’est-à-dire la dispersion résiduelle au sein des groupes, diminue mécaniquement à mesure que tu ajoutes des clusters : tu cherches le « coude », le point au-delà duquel elle ne baisse plus significativement. Le score de silhouette est plus décisif car il mesure autre chose : à quel point chaque point est plus proche de son propre groupe que du groupe voisin le plus proche. Contrairement à l’inertie, il possède un maximum, et ce maximum indique directement une valeur candidate.
from sklearn.metrics import silhouette_score
import matplotlib.pyplot as plt
inertias = []
silhouettes = []
K_range = range(2, 10)
for k in K_range:
km = KMeans(n_clusters=k, random_state=42, n_init=10)
km.fit(embeddings)
inertias.append(km.inertia_)
silhouettes.append(silhouette_score(embeddings, km.labels_))
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
ax1.plot(K_range, inertias, "bo-")
ax1.set_xlabel("Number of clusters")
ax1.set_ylabel("Inertia")
ax1.set_title("Elbow method")
ax2.plot(K_range, silhouettes, "ro-")
ax2.set_xlabel("Number of clusters")
ax2.set_ylabel("Silhouette score")
ax2.set_title("Silhouette score")
plt.tight_layout()
plt.savefig("choix_k.png", dpi=150)
plt.show()
meilleur_k = K_range[np.argmax(silhouettes)]
print(f"Best k according to silhouette: {meilleur_k}")
HDBSCAN : le clustering sans K
K-Means souffre d’un défaut structurel sur des données réelles : il doit assigner chaque point à un cluster. Un verbatim isolé qui ne ressemble à rien d’autre se retrouve forcément rattaché au groupe le moins distant, où il pollue l’interprétation. HDBSCAN raisonne en termes de densité et accepte de dire non : il détermine lui-même le nombre de groupes et place les points isolés dans une catégorie séparée étiquetée -1.
Ces outliers ne sont pas des déchets. Dans un corpus de tickets, ce sont souvent des incidents rares, des demandes hors périmètre ou des signaux faibles — exactement ce qui mérite une revue humaine. Le code ci-dessous les affiche séparément plutôt que de les écarter.
import hdbscan
clusterer = hdbscan.HDBSCAN(
min_cluster_size=3,
min_samples=2,
metric="euclidean"
)
labels_hdbscan = clusterer.fit_predict(embeddings)
n_clusters = len(set(labels_hdbscan)) - (1 if -1 in labels_hdbscan else 0)
n_outliers = list(labels_hdbscan).count(-1)
print(f"Clusters found: {n_clusters}")
print(f"Outliers: {n_outliers}")
for cluster_id in range(n_clusters):
print(f"\n--- Cluster {cluster_id} ---")
indices = [i for i, l in enumerate(labels_hdbscan) if l == cluster_id]
for idx in indices:
print(f" {textes[idx]}")
if n_outliers > 0:
print("\n--- Outliers ---")
for i, l in enumerate(labels_hdbscan):
if l == -1:
print(f" {textes[i]}")
Nommer automatiquement les clusters
Un algorithme de clustering te donne des nombres. « Cluster 2 » n’a pas sa place dans un rapport ou un tableau de bord. L’étape qui rend le résultat exploitable consiste à soumettre une douzaine de membres représentatifs au LLM et à lui demander un nom court : « Problèmes de connexion », « Demandes d’intégration », « Questions de facturation ». Limiter à dix exemples maîtrise le coût, régler la température à zéro garantit que le même cluster reçoit toujours le même nom, et la boucle ignore l’étiquette -1 car les outliers, par définition, n’ont pas de thème commun.
def nommer_clusters(
textes: list[str],
labels: list[int]
) -> dict[int, str]:
"""Names each cluster using an LLM."""
noms = {}
clusters = set(l for l in labels if l >= 0)
for cluster_id in clusters:
exemples = [
textes[i] for i, l in enumerate(labels)
if l == cluster_id
][:10] # Max 10 examples
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Voici des textes regroupés dans un même cluster :\n\n"
+ "\n".join(f"- {e}" for e in exemples) +
f"\n\nDonne un nom court (2-4 mots) qui décrit "
f"le thème commun de ce groupe. "
f"Retourne uniquement le nom."
)
}],
temperature=0,
max_tokens=20
)
noms[cluster_id] = response.choices[0].message.content.strip()
return noms
# Usage
noms = nommer_clusters(textes, labels)
for cluster_id, nom in noms.items():
print(f"Cluster {cluster_id}: {nom}")
indices = [i for i, l in enumerate(labels) if l == cluster_id]
for idx in indices:
print(f" - {textes[idx]}")
Pipeline de clustering complet
Les trois étapes — embedding, clustering, nommage — s’assemblent naturellement dans une seule classe. Le paramètre methode accepte "auto", ce qui délègue le choix du nombre de groupes à HDBSCAN, ou une valeur numérique passée sous forme de chaîne lorsque tu veux imposer un K à K-Means. Le dictionnaire renvoyé contient les étiquettes, les noms lisibles et deux compteurs qui t’indiquent immédiatement si le résultat est exploitable : un n_outliers proche du total signifie que ton corpus manque de structure dense, et tu devrais revenir à K-Means.
class PipelineClustering:
def __init__(self, model: str = "text-embedding-3-large"):
self.client = OpenAI()
self.model = model
def analyser(self, textes: list[str], methode: str = "auto") -> dict:
"""Complete pipeline: embedding → clustering → naming."""
# 1. Embeddings
response = self.client.embeddings.create(
input=textes, model=self.model
)
embs = np.array([
d.embedding for d in sorted(response.data, key=lambda x: x.index)
])
# 2. Clustering
if methode == "auto":
clusterer = hdbscan.HDBSCAN(min_cluster_size=3)
labels = clusterer.fit_predict(embs)
else:
km = KMeans(n_clusters=int(methode), random_state=42)
labels = km.fit_predict(embs)
# 3. Name clusters
noms = nommer_clusters(textes, labels)
return {
"labels": labels.tolist(),
"noms": noms,
"n_clusters": len(set(l for l in labels if l >= 0)),
"n_outliers": list(labels).count(-1)
}
pipeline = PipelineClustering()
resultats = pipeline.analyser(textes)
Viktiga punkter
- Utilise K-Means lorsque tu connais le nombre de clusters
- Utilise HDBSCAN pour détecter automatiquement les groupes et les outliers
- Le score de silhouette aide à choisir le bon K
- Un LLM nomme automatiquement les clusters découverts
- Les embeddings rendent le clustering sémantique, et non plus seulement lexical