Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Clustering: Groepering automatiseren

Les 18 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Waarom clustering?
  3. K-Means op embeddings
  4. Het juiste aantal clusters vinden
  5. HDBSCAN: Clustering zonder K
  6. Clusters automatisch een naam geven
  7. Volledige clustering-pipeline
  8. Belangrijkste punten

Doelstellingen

  • Teksten groeperen op thema zonder vooraf gedefinieerde labels
  • K-Means en HDBSCAN toepassen op embeddings
  • Clusters automatisch een naam geven

Waarom clustering?

De les over classificatie ging ervan uit dat u al wist welke categorieën bestonden. Clustering pakt de tegenovergestelde situatie aan, wat ook de meest voorkomende situatie is bij het verkennen van een corpus: niemand weet wat het bevat. U haalt achtduizend verbatims op uit een tevredenheidsenquête, of zes maanden aan supporttickets, en de eerste vraag is niet “hoeveel bugs”, maar “waar hebben mensen het eigenlijk over?”. Clustering ontdekt thematische groepen zonder dat er vooraf iets wordt verteld.

Drie use cases komen voortdurend terug: het analyseren van duizenden items met klantfeedback om dominante patronen te extraheren, het identificeren van terugkerende onderwerpen in supporttickets om een kennisbank te vullen, en het verkennen van een onbekend documentcorpus voordat u besluit hoe u het indexeert.

K-Means op embeddings

K-Means is het standaardalgoritme: u geeft het een aantal groepen op, het plaatst evenveel centra en verplaatst elk centrum iteratief naar het gemiddelde van de punten die het aantrekt. Toegepast op embeddings in plaats van op een bag-of-words, groepeert het op betekenis: “de app crasht bij het opstarten” en “kan sinds gisteren niet inloggen” belanden samen, ook al delen ze geen woorden.

Het onderstaande voorbeeldcorpus bevat bewust vier families—bugs, functieverzoeken, vragen en complimenten—zodat u de resulterende groepering visueel kunt verifiëren. De instelling random_state=42 garandeert dat u bij elke uitvoering dezelfde clusters krijgt, wat essentieel is wanneer u twee configuraties met elkaar wilt vergelijken.

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]}")

Het juiste aantal clusters vinden

Met twaalf voorbereide zinnen was het kiezen van vier voor de hand liggend. Bij achtduizend verbatims weet niemand de juiste waarde. Twee metrieken helpen u een schatting te maken. Inertie, oftewel de resterende spreiding binnen groepen, neemt mechanisch af naarmate u clusters toevoegt: u zoekt naar de “elleboog”, het punt waarboven deze niet meer significant daalt. De silhouetscore is beslissender omdat deze iets anders meet: hoe dichter elk punt bij zijn eigen groep staat dan bij de dichtstbijzijnde buurgroep. In tegenstelling tot inertie heeft deze een maximum, en dat maximum wijst direct op een kandidaat-waarde.

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 zonder K

K-Means lijdt aan een structureel gebrek bij data uit de praktijk: het moet elk punt aan een cluster toewijzen. Een geïsoleerde verbatim die op niets anders lijkt, wordt dwangmatig aan de minst verre groep gekoppeld, waar deze de interpretatie verstoort. HDBSCAN redeneert in termen van dichtheid en accepteert “nee” te zeggen: het bepaalt zelf het aantal groepen en plaatst geïsoleerde punten in een aparte categorie gelabeld als -1.

Deze outliers zijn geen afval. In een ticketcorpus zijn het vaak zeldzame incidenten, verzoeken buiten de scope, of zwakke signalen—precies wat menselijke review verdient. De onderstaande code toont ze apart in plaats van ze weg te gooien.

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]}")

Clusters automatisch een naam geven

Een clustering-algoritme geeft u nummers. “Cluster 2” hoort niet thuis in een rapport of dashboard. De stap die het resultaat bruikbaar maakt, bestaat uit het voorleggen van een dozijn representatieve leden aan de LLM en het vragen om een korte naam: “Verbindingsproblemen”, “Integratieverzoeken”, “Facturatievragen”. Beperken tot tien voorbeelden houdt de kosten onder controle, het instellen van de temperatuur op nul zorgt ervoor dat hetzelfde cluster altijd dezelfde naam krijgt, en de lus negeert het label -1 aangezien outliers per definitie geen gemeenschappelijk thema hebben.

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]}")

Volledige clustering-pipeline

De drie stappen—embedding, clustering, naamgeving—komen natuurlijk samen in één klasse. De parameter methode accepteert "auto", wat de keuze van het aantal groepen overlaat aan HDBSCAN, of een numerieke waarde doorgegeven als string wanneer u een K wilt opleggen aan K-Means. Het teruggegeven woordenboek bevat de labels, leesbare namen en twee tellers die u direct vertellen of het resultaat de moeite waard is: een n_outliers dicht bij het totaal betekent dat uw corpus geen dichte structuur heeft, en u moet terugschakelen naar 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)

Belangrijkste punten

  • Gebruik K-Means wanneer u het aantal clusters kent
  • Gebruik HDBSCAN om groepen en outliers automatisch te detecteren
  • De silhouetscore helpt bij het kiezen van de juiste K
  • Een LLM geeft ontdekte clusters automatisch een naam
  • Embeddings maken clustering semantisch, niet alleen lexicaal