Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Klasteriranje: Automatsko grupiranje

Lekcija 18 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Zašto klasteriranje?
  3. K-Means na ugradnjama
  4. Pronalaženje ispravnog broja klastera
  5. HDBSCAN: Klasteriranje bez K
  6. Automatsko imenovanje klastera
  7. Potpuni pipeline klasteriranja
  8. Ključne točke

Ciljevi

  • Grupiraj tekstove po temama bez unaprijed definiranih oznaka
  • Koristi K-Means i HDBSCAN na ugradnjama (embeddings)
  • Automatski imenuj klastere

Zašto klasteriranje?

Lekcija o klasifikaciji pretpostavljala je da već znaš koje kategorije postoje. Klasteriranje rješava suprotnu situaciju, koja je također najčešća pri istraživanju korpusa: nitko ne zna što on sadrži. Dohvatiš osam tisuća verbatima iz ankete zadovoljstva ili šest mjeseci podršnih tiketa, a prvo pitanje nije „koliko ima bugova“, već „o čemu ljudi zapravo govore“. Klasteriranje otkriva tematske skupine bez ikakvih unaprijed zadanih uputa.

Tri slučaja uporabe stalno se pojavljuju: analiza tisuća povratnih informacija kupaca za izdvajanje dominantnih uzoraka, identificiranje ponavljajućih tema u podršnim tiketima za popunjavanje baze znanja i istraživanje nepoznatog korpusa dokumenata prije odluke kako ga indeksirati.

K-Means na ugradnjama

K-Means je algoritam koji se najčešće koristi: zadaš mu broj skupina, on postavi toliko središta i iterativno pomiče svako središte prema prosjeku točaka koje privlači. Primijenjen na ugradnje umjesto na vreću riječi (bag of words), grupira po značenju: „aplikacija se ruši pri pokretanju“ i „ne mogu se prijaviti od jučer“ završe zajedno iako nemaju zajedničkih riječi.

Donji primjer korpusa namjerno sadrži četiri obitelji – bugove, zahtjeve za funkcije, pitanja i pohvale – kako bi mogao vizualno provjeriti rezultirajuće grupiranje. Postavka random_state=42 jamči da ćeš dobiti iste klastere iz pokreta u pokret, što je ključno kad god trebaš usporediti dvije konfiguracije.

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

Pronalaženje ispravnog broja klastera

S dvanaest pripremljenih rečenica, odabir broja četiri bio je očigledan. S osam tisuća verbatima, nitko ne zna ispravnu vrijednost. Dvije metrike pomažu ti da pogodiš. Inercija, odnosno preostala disperzija unutar skupina, mehanički se smanjuje kako dodaješ klastere: tražiš „lakat“, točku nakon koje pad više nije značajan. Siluetni skor (silhouette score) odlučniji je jer mjeri nešto drugo: koliko je svaka točka bliža vlastitoj skupini nego najbližoj susjednoj skupini. Za razliku od inercije, on ima maksimum, a taj maksimum izravno ukazuje na kandidata za vrijednost.

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: Klasteriranje bez K

K-Means pati od strukturnog nedostatka na podacima iz stvarnog svijeta: mora dodijeliti svaku točku nekom klasteru. Izolirani verbatim koji ne nalikuje ničemu drugome prisilno se zakači za najmanje udaljenu skupinu, gdje onečišćuje interpretaciju. HDBSCAN rasuđuje u smislu gustoće i prihvaća reći „ne“: sam određuje broj skupina i izolirane točke smješta u zasebnu kategoriju označenu s -1.

Te outlier vrijednosti nisu smeće. U korpusu tiketa to su često rijetki incidenti, zahtjevi izvan opsega ili slabi signali – upravo ono što zaslužuje ljudski pregled. Donji kod prikazuje ih odvojeno umjesto da ih odbacuje.

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

Automatsko imenovanje klastera

Algoritam klasteriranja daje ti brojeve. „Klaster 2“ nema što tražiti u izvješću ili na nadzornoj ploči. Korak koji rezultat čini upotrebljivim sastoji se u slanju desetak reprezentativnih članova LLM-u i traženju kratkog imena: „Problemi s prijavom“, „Zahtjevi za integraciju“, „Pitanja o naplati“. Ograničavanje na deset primjeraka kontrolira trošak, postavljanje temperature na nulu osigurava da isti klaster uvijek dobije isto ime, a petlja ignorira oznaku -1 jer outlieri, po definiciji, nemaju zajedničku temu.

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

Potpuni pipeline klasteriranja

Tri koraka – ugradnja, klasteriranje, imenovanje – prirodno se spajaju u jednu klasu. Parametar methode prihvaća "auto", što delegira odabir broja skupina na HDBSCAN, ili numeričku vrijednost proslijeđenu kao niz znakova kada želiš nametnuti K za K-Means. Vraćeni rječnik sadrži oznake, čitljiva imena i dva brojača koji ti odmah govore vrijedi li rezultat koristiti: n_outliers blizak ukupnom broju znači da tvom korpusu nedostaje gusta struktura i trebao bi se vratiti na 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)

Ključne točke

  • Koristi K-Means kada znaš broj klastera
  • Koristi HDBSCAN za automatsko otkrivanje skupina i outliera
  • Siluetni skor pomaže u odabiru ispravnog K
  • LLM automatski imenuje otkrivene klastere
  • Ugradnje čine klasteriranje semantičkim, a ne samo leksičkim