Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Klasterdamine: automaatne rühmitamine

Õppetund 18 / 22 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Eesmärgid
  2. Miks klasterdamine?
  3. K-Means manustel
  4. Õige klastrite arvu leidmine
  5. HDBSCAN: klasterdamine ilma K-ta
  6. Klastrite automaatne nimetamine
  7. Täielik klasterdamise torustik
  8. Peamised punktid

Eesmärgid

  • Rühmita tekstid teemade kaupa ilma eelnevalt määratletud siltideta
  • Kasuta manuste (embeddings) põhjal K-Means’i ja HDBSCAN-i
  • Nimeta klastrid automaatselt ümber

Miks klasterdamine?

Klassifitseerimise tund eeldas, et teadsid juba, millised kategooriad eksisteerivad. Klasterdamine lahendab vastupidist olukorda, mis on andmekogumi uurimisel ka kõige levinum: keegi ei tea, mida see sisaldab. Tood välja kaheksa tuhat rahulolu-uuringu vastust või kuue kuu tugipiletid ja esimene küsimus pole „mitu viga on“, vaid „millest inimesed tegelikult räägivad“. Klasterdamine avastab temaatilised rühmad ilma igasuguse eelteadmisteta.

Kolm kasutusjuhtu kerkivad pidevalt esile: tuhandete klienditagasisidete analüüsimine domineerivate mustrite eraldamiseks, korduvate teemade tuvastamine tugipiletites teadmistebaasi täitmiseks ja tundmatu dokumendikogumi uurimine enne selle indekseerimisviisi otsustamist.

K-Means manustel

K-Means on vaikimisi algoritm: annad sellele rühmade arvu, see paigutab sama palju keskmeid ja liigutab iteratiivselt iga keskust nende punktide keskmise poole, mida see ligi tõmbab. Rakendatuna manustele sõnekoti asemel rühmitab see tähenduse järgi: „rakendus jookseb käivitamisel kokku“ ja „ei saa eilsest saadik sisse logida“ satuvad kokku, kuigi neil pole ühtegi ühist sõna.

Allpool olev näidisandmekogu sisaldab tahtlikult nelja perekonda – vead, funktsioonisoovid, küsimused ja kiitused –, et saaksid visuaalselt kontrollida tekkinud rühmitust. Seadistus random_state=42 tagab, et saad ühest käivitusest teise samad klastrid, mis on hädavajalik iga kord, kui võrdled kahte konfiguratsiooni.

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

Õige klastrite arvu leidmine

Kaheteistkümne ettevalmistatud lause puhul oli nelja valimine ilmne. Kaheksa tuhande vastuse puhul ei tea keegi õiget väärtust. Kaks mõõdikut aitavad sul arvata. Inerts, ehk jääkhajuvus rühmade sees, väheneb mehaaniliselt, kui lisad klastreid: otsid „küünarnukki“, punkti, millest alates see enam oluliselt ei lange. Silueti skoor on otsustavam, sest see mõõdab midagi muud: kui palju lähemal on iga punkt oma rühmale võrreldes lähima naaberrühmaga. Erinevalt inertsist on sellel maksimum ja see maksimum osutab otseselt sobivale väärtusele.

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: klasterdamine ilma K-ta

K-Means’il on reaalsete andmete puhul struktuurne viga: see peab määrama iga punkti mõnda klastrisse. Eraldiseisev vastus, mis ei sarnane millegagi, kinnitatakse sunniviisiliselt kõige vähem kaugesse rühma, kus see moonutab tõlgendust. HDBSCAN mõtleb tiheduse kategooriates ja lubab öelda „ei“: see määrab ise rühmade arvu ja paigutab üksikud punktid eraldi kategooriasse sildiga -1.

Need hälbed pole prügi. Piletikogumis on need sageli haruldased intsidendid, teemavälised soovid või nõrgad signaalid – täpselt see, mis väärib inimlikku ülevaatust. Allpool olev kood kuvab need eraldi, mitte ei viska minna.

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

Klastrite automaatne nimetamine

Klasterdamise algoritm annab sulle numbreid. „Klaster 2“ ei sobi aruandesse ega armatuurlauale. Samm, mis muudab tulemuse kasutatavaks, koosneb tosinale esinduslikule liikmele LLM-ile esitamisest ja lühikese nime küsimisest: „Ühendusprobleemid“, „Integratsioonisoovid“, „Arveldusküsimused“. Piirdumine kümne näitega kontrollib kulusid, temperatuuri nulliks seadmine tagab, et sama klaster saab alati sama nime, ja tsükkel ignoreerib silti -1, kuna hälbetel pole definitsiooni järgi ühist teemat.

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

Täielik klasterdamise torustik

Kolm sammu – manustamine, klasterdamine, nimetamine – moodustavad loomulikult ühe klassi. Parameeter methode aktsepteerib väärtust "auto", mis delegeerib rühmade arvu valiku HDBSCAN-ile, või arvulist väärtust stringina, kui soovid K-Means’ile K peale suruda. Tagastatud sõnastik sisaldab silte, loetavaid nimesid ja kahte loendurit, mis annavad kohe teada, kas tulemus on kasutamist väärt: n_outliers, mis on lähedane koguarvule, tähendab, et sinu andmekogumil puudub tihe struktuur ja peaksid naasma K-Means’i juurde.

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)

Peamised punktid

  • Kasuta K-Means’i, kui tead klastrite arvu
  • Kasuta HDBSCAN-i rühmade ja hälbeautomaatseks tuvastamiseks
  • Silueti skoor aitab valida õiget K-d
  • LLM nimetab avastatud klastrid automaatselt ümber
  • Manustused muudavad klasterdamise semantiliseks, mitte ainult leksikaalseks