Zhlukovanie: Automatické zoskupovanie
Na tejto strane
Ciele
- Zoskupovať texty podľa témy bez vopred definovaných štítkov
- Použiť algoritmy K-Means a HDBSCAN na vektorové reprezentácie (embeddings)
- Automaticky pomenovávať zhluky
Prečo zhlukovanie?
Lekcia o klasifikácii predpokladala, že už vieš, aké kategórie existujú. Zhlukovanie rieši opačnú situáciu, ktorá je pri skúmaní korpusu najbežnejšia: nikto nevie, čo obsahuje. Získaš osemtisíc odpovedí z prieskumu spokojnosti alebo šesť mesiacov ticketov podpory a prvá otázka neznie „koľko je tam chýb“, ale „o čom ľudia vlastne hovoria“. Zhlukovanie objavuje tematické skupiny bez toho, aby mu bolo čokoľvek vopred povedané.
Tri prípady použitia sa objavujú neustále: analýza tisícok spätných väzieb od zákazníkov na extrakciu dominantných vzorcov, identifikácia opakujúcich sa tém v ticketoch podpory na naplnenie znalostnej bázy a preskúmanie neznámeho korpusu dokumentov pred rozhodnutím, ako ho indexovať.
K-Means na vektorových reprezentáciách
K-Means je algoritmus prvej voľby: zadáš mu počet skupín, on umiestni toľko stredov a iteratívne posúva každý stred smerom k priemeru bodov, ktoré priťahuje. Aplikované na vektorové reprezentácie namiesto bag-of-words zoskupuje podľa významu: „aplikácia padá pri štarte“ a „od včerajška sa nedá prihlásiť“ skončia spolu, hoci nezdieľajú žiadne slová.
Nižšie uvedený príkladový korpus zámerne obsahuje štyri rodiny – chyby, požiadavky na funkcie, otázky a pochvaly – aby si mohol vizuálne overiť výsledné zoskupenie. Nastavenie random_state=42 zaručuje, že získaš rovnaké zhluky z jedného spustenia na druhé, čo je nevyhnutné vždy, keď potrebuješ porovnať dve konfigurácie.
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]}")
Nájdenie správneho počtu zhlukov
Pri dvanástich pripravených vetách bola voľba štyroch zrejmá. Pri ôsmich tisíckach odpovedí nikto nepozná správnu hodnotu. Dve metriky ti pomôžu odhadnúť ju. Inercia, čo znamená zvyškový rozptyl within skupín, mechanicky klesá, keď pridávaš zhluky: hľadáš „lakeť“, bod, za ktorým už významne neklesá. Siluetové skóre je rozhodujúcejšie, pretože meria niečo iné: o koľko je každý bod bližšie k vlastnej skupine než k najbližšej susednej skupine. Na rozdiel od inercie má maximum a toto maximum priamo ukazuje na kandidátsku hodnotu.
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: Zhlukovanie bez K
K-Means trpí štrukturálnou chybou na reálnych dátach: musí priradiť každý bod do zhluku. Izolovaná odpoveď, ktorá sa ničomu nepodobá, sa násilne pripojí k najmenej vzdialenej skupine, kde kazí interpretáciu. HDBSCAN uvažuje v termínoch hustoty a vie povedať nie: sám určí počet skupín a izolované body umiestni do samostatnej kategórie označenej -1.
Tieto odľahlé hodnoty nie sú odpad. V korpuse ticketov sú to často zriedkavé incidenty, požiadavky mimo rozsahu alebo slabé signály – presne to, čo si zaslúži ľudskú kontrolu. Nižšie uvedený kód ich zobrazuje oddelene namiesto toho, aby ich zahadzoval.
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]}")
Automatické pomenovávanie zhlukov
Algoritmus zhlukovania ti dá čísla. „Zhluk 2“ nepatrí do správy ani do dashboardu. Krok, ktorý robí výsledok použiteľným, spočíva v odoslaní tucta reprezentatívnych členov do LLM a požiadaní o krátky názov: „Problémy s prihlásením“, „Požiadavky na integráciu“, „Otázky k fakturácii“. Obmedzenie na desať príkladov kontroluje náklady, nastavenie teploty na nulu zabezpečuje, že rovnaký zhluk vždy dostane rovnaký názov, a cyklus ignoruje štítok -1, keďže odľahlé hodnoty majú podľa definície spoločnú tému.
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]}")
Kompletný pipeline zhlukovania
Tri kroky – vektorizácia, zhlukovanie, pomenovanie – sa prirodzene spájajú do jednej triedy. Parameter methode prijíma hodnotu "auto", ktorá deleguje výber počtu skupín na HDBSCAN, alebo číselnú hodnotu predanú ako reťazec, keď chceš vnútiť K pre K-Means. Vrátaný slovník obsahuje štítky, čitateľné názvy a dva počítadlá, ktoré ti okamžite povedia, či výsledok stojí za použitie: n_outliers blízke celkovému počtu znamená, že tvoj korpus nemá hustú štruktúru a mal by si sa vrátiť ku 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)
Kľúčové poznatky
- Použi K-Means, keď poznáš počet zhlukov
- Použi HDBSCAN na automatickú detekciu skupín a odľahlých hodnôt
- Siluetové skóre pomáha vybrať správne K
- LLM automaticky pomenúva objavené zhluky
- Vektorové reprezentácie robia zhlukovanie sémantickým, nie len lexikálnym