Grozdjenje: samodejno združevanje
Na tej strani
Cilji
- Združi besedila po temah brez vnaprej določenih oznak
- Uporabi K-sredine (K-Means) in HDBSCAN na vgradnjah (embeddings)
- Samodejno poimenuj grozde
Zakaj grozdjenje?
Lekcija o razvrščanju je predpostavljala, da že poznaš obstoječe kategorije. Grozdjenje obravnava nasprotno situacijo, ki je pri raziskovanju korpusov tudi najpogostejša: nihče ne ve, kaj korpus vsebuje. Pridobiš osem tisoč dobesednih odgovorov iz ankete o zadovoljstvu ali šest mesecev podporih zahtevkov, prvo vprašanje pa ni „koliko napak”, temveč „o čem ljudje dejansko govorijo”. Grozdjenje odkrije tematske skupine, ne da bi mu karkoli vnaprej povedal.
Trije primeri uporabe se pojavljajo stalno: analiza tisočev odzivov strank za izluščitev prevladujočih vzorcev, prepoznavanje ponavljajočih se tem v podporih zahtevkih za polnjenje baze znanja in raziskovanje neznanega korpusa dokumentov pred odločitvijo, kako ga indeksirati.
K-sredine (K-Means) na vgradnjah
K-sredine so algoritem po izbiri: določiš število skupin, algoritem postavi toliko središč in iterativno premika vsako središče proti povprečju točk, ki jih privlači. Ko ga uporabiš na vgradnjah namesto na vreči besed, združuje po pomenu: „aplikacija se ob zagonu sesuje” in „od včeraj se ne morem prijaviti” končata skupaj, čeprav si ne delita nobene besede.
Spodnji primer korpusa namerno vsebuje štiri družine – napake, zahteve po funkcijah, vprašanja in pohvale – tako da lahko vizualno preveriš nastalo združevanje. Nastavitev random_state=42 zagotavlja, da boš pri vsakem zagonu dobil enake grozde, kar je bistveno, kadar moraš primerjati dve konfiguraciji.
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]}")
Iskanje pravilnega števila grozdov
Pri dvanajstih pripravljenih stavkih je bila izbira štirih očitna. Pri osmih tisoč dobesednih odgovorih nihče ne pozna prave vrednosti. Dve metrike ti pomagata ugibati. Inercija, kar pomeni preostalo razpršenost znotraj skupin, se mehansko zmanjšuje, ko dodajaš grozde: iščeš „komolec”, točko, po kateri vrednost ne pada več bistveno. Silhuetni rezultat je bolj odločilen, ker meri nekaj drugega: kako much bližje je vsaka točka svoji skupini v primerjavi z najbližjo sosednjo skupino. Za razliko od inercije ima maksimum in ta maksimum neposredno kaže na kandidatno vrednost.
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: Grozdjenje brez K
K-sredine trpijo zaradi strukturne napake pri podatkih iz resničnega sveta: vsaki točki morajo dodeliti grozd. Osamljen dobesedni odgovor, ki ne spominja na nič drugega, se prisilno pripne najmanj oddaljeni skupini, kjer onesnaži interpretacijo. HDBSCAN razmišlja v smislu gostote in sprejme odgovor „ne”: sam določi število skupin in osamljene točke postavi v ločeno kategorijo z oznako -1.
Te osamelce ni treba zavreči. V korpusu zahtevkov so to pogosto redki incidenti, zahteve izven obsega ali šibki signali – ravno tisto, kar zasluži človeški pregled. Spodnja koda jih prikaže ločeno, namesto da bi jih zavrgla.
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]}")
Samodejno poimenovanje grozdov
Algoritem za grozdjenje ti vrne številke. „Grozda 2” ne spada v poročilo ali nadzorno ploščo. Korak, ki rezultat naredi uporaben, je predložitev ducat reprezentativnih članov velikemu jezikovnemu modelu (LLM) in zahteva po kratkem imenu: „Težave s prijavo”, „Zahteve za integracijo”, „Vprašanja o zaračunavanju”. Omejitev na deset primerov nadzoruje stroške, nastavitev temperature na nič zagotavlja, da isti grozd vedno dobi isto ime, zanka pa ignorira oznako -1, saj osamelci po definiciji nimajo skupne teme.
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]}")
Celoten cevovod za grozdjenje
Trije koraki – vgradnja, grozdjenje, poimenovanje – se naravno združijo v enem samem razredu. Parameter methode sprejme "auto", kar izbiro števila skupin prepusti HDBSCAN-u, ali številsko vrednost, podano kot niz, ko želiš vsiliti K za K-sredine. Vrnjeni slovar vsebuje oznake, berljiva imena in dva števca, ki takoj pokažeta, ali je rezultat vreden uporabe: n_outliers, ki je blizu skupnemu številu, pomeni, da tvoj korpus nima goste strukture, in bi se moral vrniti h K-sredinam.
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)
Ključne ugotovitve
- Uporabi K-sredine, ko poznaš število grozdov
- Uporabi HDBSCAN za samodejno zaznavanje skupin in osamelcev
- Silhuetni rezultat pomaga izbrati pravi K
- Veliki jezikovni model samodejno poimenuje odkrite grozde
- Vgradnje omogočajo semantično grozdjenje, ne le leksikalnega