Klasterizavimas: automatinis grupavimas
Šiame puslapyje
Tikslai
- Sugrupuoti tekstus pagal temą be iš anksto nustatytų etikečių
- Taikyti K-Means ir HDBSCAN algoritmams su įterpimais (embeddings)
- Automatiškai suteikti pavadinimus klasteriams
Kodėl verta klasterizuoti?
Klasifikavimo pamokoje darėme prielaidą, kad jau žinai, kokios kategorijos egzistuoja. Klasterizavimas sprendžia priešingą situaciją, kuri tyrinėjant tekstų korpusą yra pati dažniausia: niekas nežino, ką jame rasite. Gaunate aštuonis tūkstančius atsakymų iš pasitenkinimo apklausos arba šešių mėnesių techninės pagalbos bilietų, ir pirmasis klausimas yra ne „kiek klaidų?“, o „apie ką iš tikrųjų kalba žmonės?“. Klasterizavimas atranda temines grupes nieko iš anksto nežinodamas.
Nuolat iškyla trys naudojimo atvejai: tūkstančių klientų atsiliepimų analizė dominuojantiems dėsningumams išgauti, pasikartojančių temų nustatymas techninės pagalbos bilietuose žinių bazės kūrimui ir nežinomo dokumentų korpuso tyrinėjimas prieš nusprendžiant, kaip jį indeksuoti.
K-Means su įterpimais
K-Means yra pagrindinis algoritmas: nurodai grupių skaičių, jis patalpina tiek centrų ir iteratyviai perkelia kiekvieną centrą link taškų, kuriuos pritraukia, vidurkio. Taikomas įterpimams, o ne žodžių maišui, jis grupuoja pagal prasmę: „programėlė stringa paleidžiant“ ir „negaliu prisijungti nuo vakar“ atsiduria kartu, nors neturi bendrų žodžių.
Toliau pateiktame pavyzdiniame korpuse tyčia yra keturios šeimos – klaidos, funkcijų pageidavimai, klausimai ir pagyrimai – kad galėtum vizualiai patikrinti gautą grupavimą. Nustatymas random_state=42 garantuoja, kad gausi tuos pačius klasterius nuo vieno paleidimo iki kito, o tai būtina, kai reikia palyginti dvi konfigūracijas.
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]}")
Tinkamo klasterių skaičiaus radimas
Turint dvylika paruoštų sakinių, pasirinkti keturis buvo akivaizdu. Turint aštuonis tūkstančius atsakymų, niekas nežino teisingos reikšmės. Dvi metrikos padeda tai atspėti. Inercija, tai yra liekamasis sklaida grupėse, mechaniškai mažėja didinant klasterių skaičių: ieškai „alkūnės“ – taško, už kurio ji nebekrenta reikšmingai. Silueto balas (silhouette score) yra dar svarbesnis, nes matuoja ką kita: kiek kiekvienas taškas yra arčiau savo grupės nei artimiausios kaimyninės grupės. Skirtingai nei inercija, jis turi maksimumą, ir tas maksimumas tiesiogiai nurodo kandidato reikšmę.
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: klasterizavimas be K
K-Means turi struktūrinį trūkumą dirbant su realiais duomenimis: jis privalo priskirti kiekvieną tašką kuriam nors klasteriui. Izoliuotas atsakymas, kuris niekam nepanašus, yra jėga priverstinai prijungiamas prie mažiausiai nutolusios grupės, kur jis teršia interpretaciją. HDBSCAN mąsto tankio sąvokomis ir leidžia pasakyti „ne“: jis pats nustato grupių skaičių ir izoliuotus taškus patalpina į atskirą kategoriją, pažymėtą -1.
Šios išimtys nėra šiukšlės. Bilietų korpuse tai dažnai būna reti incidentai, už ribų esantys prašymai arba silpni signalai – būtent tai, kas nusipelno žmogaus peržiūros. Toliau pateiktas kodas jas rodo atskirai, o ne išmeta.
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]}")
Automatinis klasterių pavadinimų suteikimas
Klasterizavimo algoritmas tau suteikia skaičius. „2-asis klasteris“ netinka nei ataskaitai, nei informaciniam skydeliui. Žingsnis, kuris paverčia rezultatą panaudojamu, yra pateikti dešimtį reprezentatyvių narių didžiajam kalbos modeliui (LLM) ir paprašyti trumpo pavadinimo: „Prisijungimo problemos“, „Integracijos prašymai“, „Sąskaitų klausimai“. Apribojimas iki dešimties pavyzdžių kontroliuoja kainą, temperatūros nustatymas į nulį užtikrina, kad tas pats klasteris visada gaus tą patį pavadinimą, o ciklas ignoruoja -1 etiketę, nes išimtys pagal apibrėžimą neturi bendros temos.
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]}")
Pilna klasterizavimo grandinė
Trys žingsniai – įterpimas, klasterizavimas, pavadinimų suteikimas – natūraliai susijungia į vieną klasę. Parametras methode priima reikšmę "auto", kuri perduoda grupių skaičiaus pasirinkimą HDBSCAN, arba skaitinę reikšmę, perduodamą kaip eilutė, kai nori priverstinai nustatyti K reikšmę K-Means algoritmui. Grąžinamas žodynas turi etikečių, skaitomų pavadinimų ir du skaitiklius, kurie iškart parodo, ar rezultatas vertas naudojimo: n_outliers, artimas bendram skaičiui, reiškia, kad tavo korpusui trūksta tankios struktūros, ir turėtum grįžti prie 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)
Svarbiausi punktai
- Naudok K-Means, kai žinai klasterių skaičių
- Naudok HDBSCAN automatiniam grupių ir išimčių aptikimui
- Silueto balas padeda pasirinkti tinkamą K
- Didysis kalbos modelis (LLM) automatiškai suteikia pavadinimus atrastiems klasteriams
- Įterpimai (embeddings) daro klasterizavimą semantiniu, o ne tik leksiniu