Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Klaszterezés: Automatikus csoportosítás

18. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Miért szükséges a klaszterezés?
  3. K-Means beágyazásokon
  4. A megfelelő klaszterszám megtalálása
  5. HDBSCAN: Klaszterezés K nélkül
  6. Klaszterek automatikus elnevezése
  7. Teljes klaszterezési folyamat
  8. Főbb megállapítások

Célok

  • Szövegek tematikus csoportosítása előre definiált címkék nélkül
  • K-Means és HDBSCAN alkalmazása beágyazásokon (embeddings)
  • Klaszterek automatikus elnevezése

Miért szükséges a klaszterezés?

Az osztályozásról szóló leckében feltételeztük, hogy már ismered a létező kategóriákat. A klaszterezés az ellenkező helyzetet kezeli, ami a leggyakoribb egy korpusz felfedezésekor: senki sem tudja, mit tartalmaz. Kinyersz nyolcezer visszajelzést egy elégedettségi felmérésből, vagy hat hónapnyi ügyfélszolgálati jegyet, és az első kérdés nem az, hogy „hány hiba van“, hanem hogy „miről beszélnek valójában az emberek“. A klaszterezés tematikus csoportokat fedez fel anélkül, hogy előre bármit is mondanánk neki.

Három használati eset fordul elő folyamatosan: ezer számú ügyfélvisszajelzés elemzése a domináns minták kinyerésére, ismétlődő témák azonosítása az ügyfélszolgálati jegyekben egy tudásbázis feltöltéséhez, valamint egy ismeretlen dokumentumkorpusz feltárása, mielőtt eldöntenéd, hogyan indexeld azt.

K-Means beágyazásokon

A K-Means a legkézenfekvőbb algoritmus: megadsz neki egy csoportok számát, ő elhelyez ennyi központot, majd iteratívan mozgatja mindegyik központot az általa vonzott pontok átlaga felé. Ha beágyazásokra alkalmazzuk szótár helyett, akkor jelentés alapján csoportosít: „az alkalmazás induláskor összeomlik“ és „tegnap óta nem tudok bejelentkezni“ ugyanoda kerül, még akkor is, ha nincs közös szavuk.

Az alábbi példa-korpusz szándékosan négy családot tartalmaz – hibák, funkciókérések, kérdések és dicséretek –, így vizuálisan is ellenőrizheted a kapott csoportosítást. A random_state=42 beállítás garantálja, hogy futtatásról futtatásra ugyanazokat a klasztereket kapd, ami elengedhetetlen, amikor két konfigurációt kell összehasonlítanod.

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

A megfelelő klaszterszám megtalálása

Tizenkét előkészített mondat esetén nyilvánvaló volt a négyes választás. Nyolcezer visszajelzés esetén senki sem ismeri a helyes értéket. Két metrika segít a becslésben. A tehetetlenség (inertia), azaz a csoportokon belüli maradék szóródás, mechanikusan csökken, ahogy növeled a klaszterek számát: a „könyököt“ keresed, azt a pontot, amelyen túl már nem csökken jelentősen. A sziluett-pontszám (silhouette score) döntőbb, mert mást mér: azt, hogy mennyivel közelebb van minden pont a saját csoportjához, mint a legközelebbi szomszédos csoporthoz. A tehetetlenséggel ellentétben ennek van maximuma, és ez a maximum közvetlenül egy lehetséges értékre mutat.

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: Klaszterezés K nélkül

A K-Means-nek van egy strukturális hibája valós adatokon: minden pontot hozzá kell rendelnie egy klaszterhez. Egy elszigetelt visszajelzés, ami semmire sem hasonlít, erőszakkal a legkevésbé távoli csoporthoz kerül, ahol szennyezi az értelmezést. A HDBSCAN sűrűség alapján gondolkodik, és megengedi magának, hogy nemet mondjon: maga határozza meg a csoportok számát, az elszigetelt pontokat pedig egy külön, -1 címkével ellátott kategóriába helyezi.

Ezek a kiugró értékek (outliers) nem szemétek. Egy jegy-korpuszban gyakran ritka incidenseket, hatókörön kívüli kéréseket vagy gyenge jeleket jelentenek – pontosan azt, ami emberi áttekintést érdemel. Az alábbi kód külön jeleníti meg őket ahelyett, hogy eldobná őket.

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

Klaszterek automatikus elnevezése

A klaszterező algoritmus számokat ad. A „2-es klaszter“ nem való jelentésbe vagy irányítópultba. Az eredmény használhatóvá tételének lépése abból áll, hogy benyújtasz egy tucat reprezentatív elemet az LLM-nek, és kérsz tőle egy rövid nevet: „Bejelentkezési problémák“, „Integrációs kérések“, “Számlázási kérdések”. Tíz példára korlátozva kontrollálod a költséget, a hőmérséklet (temperature) nullára állítása biztosítja, hogy ugyanaz a klaszter mindig ugyanazt a nevet kapja, a ciklus pedig figyelmen kívül hagyja a -1 címkét, mivel a kiugró értékek definíció szerint nem rendelkeznek közös témával.

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

Teljes klaszterezési folyamat

A három lépés – beágyazás, klaszterezés, elnevezés – természetesen egyetlen osztályban egyesül. A methode paraméter elfogadja az "auto" értéket, ami a HDBSCAN-re bízza a csoportszám megválasztását, vagy egy számként átadott sztringet, ha rögzített K értéket akarsz kényszeríteni a K-Means-re. A visszatérő szótár tartalmazza a címkéket, az olvasható neveket és két számlálót, amelyek azonnal jelzik, hogy az eredmény használható-e: ha az n_outliers közel áll a teljes mennyiséghez, akkor a korpuszodnak nincs sűrű szerkezete, és vissza kell térned a K-Means-hez.

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)

Főbb megállapítások

  • Használj K-Means-t, ha ismered a klaszterek számát
  • Használj HDBSCAN-t a csoportok és a kiugró értékek automatikus észlelésére
  • A sziluett-pontszám segít a megfelelő K kiválasztásában
  • Egy LLM automatikusan elnevezi a felfedezett klasztereket
  • A beágyazások lehetővé teszik a szemantikus, nem csupán lexikális klaszterezést