Clustering: Gruppering automatisk
På denne side
Mål
- Gruppér tekster efter tema uden foruddefinerede labels
- Brug K-Means og HDBSCAN på embeddings
- Navngiv clusters automatisk
Hvorfor clustering?
Lektionen om klassificering antog, at du allerede vidste, hvilke kategorier der eksisterede. Clustering håndterer den modsatte situation, hvilket også er den mest almindelige, når man udforsker et korpus: ingen ved, hvad det indeholder. Du henter otte tusinde verbatims fra en tilfredshedsundersøgelse eller seks måneders supporttickets, og det første spørgsmål er ikke “hvor mange bugs”, men “hvad taler folk egentlig om?”. Clustering opdager tematiske grupper uden at få noget at vide på forhånd.
Tre use cases dukker konstant op: analyse af tusindvis af kundetilbagemeldinger for at udtrække dominerende mønstre, identificering af tilbagevendende emner i supporttickets for at opbygge en vidensbase og udforskning af et ukendt dokumentkorpus, før man beslutter, hvordan det skal indekseres.
K-Means på embeddings
K-Means er go-to-algoritmen: du angiver et antal grupper, den placerer lige så mange centre og flytter iterativt hvert centrum mod gennemsnittet af de punkter, det tiltrækker. Anvendt på embeddings i stedet for en pose ord (bag of words) grupperer den efter betydning: “appen crascher ved opstart” og “kan ikke logge ind siden i går” havner sammen, selvom de ikke deler nogen ord.
Eksempelkorpset nedenfor indeholder bevidst fire familier—bugs, funktionsønsker, spørgsmål og komplimenter—så du visuelt kan verificere den resulterende gruppering. Indstillingen random_state=42 garanterer, at du får de samme clusters fra kørsel til kørsel, hvilket er afgørende, når du skal sammenligne to konfigurationer.
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]}")
At finde det rette antal clusters
Med tolv forberedte sætninger var valget af fire indlysende. Med otte tusinde verbatims ved ingen det rigtige tal. To metrikker hjælper dig med at gætte. Inerti, altså den resterende spredning inden for grupper, falder mekanisk, efterhånden som du tilføjer clusters: du leder efter “albuen”, punktet hvorefter den ikke længere falder væsentligt. Silhouette-scoren er mere afgørende, fordi den måler noget andet: hvor meget tættere hvert punkt er på sin egen gruppe sammenlignet med den nærmeste nabogruppe. I modsætning til inerti har den et maksimum, og dette maksimum peger direkte på en kandidatværdi.
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: Clustering uden K
K-Means lider af en strukturel fejl på virkelige data: den skal tildele ethvert punkt til et cluster. En isoleret verbatim, der ikke ligner noget andet, ender tvangsmæssigt knyttet til den mindst fjerne gruppe, hvor den forurener fortolkningen. HDBSCAN ræsonnerer ud fra tæthed og accepterer at sige nej: den bestemmer selv antallet af grupper og placerer isolerede punkter i en separat kategori mærket -1.
Disse outliers er ikke affald. I et ticket-korpus er de ofte sjældne hændelser, anmodninger uden for scope eller svage signaler—netop det, der fortjener menneskelig gennemgang. Koden nedenfor viser dem separat i stedet for at kassere dem.
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]}")
Automatisk navngivning af clusters
En clustering-algoritme giver dig tal. “Cluster 2” hører ikke hjemme i en rapport eller et dashboard. Det trin, der gør resultatet brugbart, består i at indsende et dusin repræsentative medlemmer til LLM’en og bede den om et kort navn: “Problemer med forbindelse”, “Anmodninger om integration”, “Spørgsmål om fakturering”. Begrænsning til ti eksempler holder omkostningerne nede, indstilling af temperaturen til nul sikrer, at det samme cluster altid får det samme navn, og løkken ignorerer label -1, da outliers per definition ikke har noget fælles tema.
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]}")
Komplet clustering-pipeline
De tre trin—embedding, clustering, navngivning—føjes naturligt sammen i en enkelt klasse. Parameteren methode accepterer "auto", hvilket delegerer valget af gruppeantal til HDBSCAN, eller en numerisk værdi sendt som streng, når du ønsker at påtvinge et K til K-Means. Den returnerede ordbog indeholder labels, læsbare navne og to tællere, der straks fortæller dig, om resultatet er værd at bruge: en n_outliers tæt på totalen betyder, at dit korpus mangler tæt struktur, og du bør skifte tilbage til 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)
Vigtige pointer
- Brug K-Means, når du kender antallet af clusters
- Brug HDBSCAN til automatisk at opdage grupper og outliers
- Silhouette-scoren hjælper med at vælge det rigtige K
- En LLM navngiver automatisk de opdagede clusters
- Embeddings gør clustering semantisk, ikke blot leksikalsk