Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Klasterizācija: automātiska grupēšana

Nodarbība 18 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Kāpēc klasterizācija?
  3. K-Means uz iegultnēm
  4. Pareizā kopu skaita atrašana
  5. HDBSCAN: Klasterizācija bez K
  6. Kopu automātiska nosaukšana
  7. Pilna klasterizācijas cauruļvads
  8. Galvenās atziņas

Mērķi

  • Grupēt tekstus pēc tēmas bez iepriekš definētām etiķetēm
  • Izmantot K-Means un HDBSCAN uz iegultnēm (embeddings)
  • Automātiski nosaukt kopas

Kāpēc klasterizācija?

Nodarbībā par klasifikāciju tika pieņemts, ka tu jau zini, kādas kategorijas pastāv. Klasterizācija risina pretēju situāciju, kas, pētot korpusu, ir visizplatītākā: neviens nezina, ko tas satur. Tu iegūsti astoņus tūkstošus verbatimu no apmierinātības aptaujas vai sešu mēnešu atbalsta biļešu arhīvu, un pirmais jautājums nav “cik ir kļūdu”, bet gan “par ko cilvēki faktiski runā”. Klasterizācija atklāj tematiskās grupas, iepriekš neko neparedzot.

Trīs lietojumi parādās pastāvīgi: tūkstošiem klientu atsauksmju analīze, lai izdalītu dominējošos modeļus; atkārtojošu tēmu noteikšana atbalsta biļetēs, lai papildinātu zināšanu bāzi; un nezināma dokumentu korpusa izpēte pirms lēmuma pieņemšanas par tā indeksēšanu.

K-Means uz iegultnēm

K-Means ir galvenais algoritms: tu norādi grupu skaitu, tas izvieto tikpat daudz centru un iteratīvi pārvieto katru centru uz to punktu vidējo vērtību, kurus tas piesaista. Pielietojot to iegultnēm, nevis vārdu maisam (bag of words), tas grupē pēc nozīmes: “lietotne crashē startējot” un “nevar pieslēgties kopš vakardienas” nonāk vienā grupā, lai gan tiem nav kopīgu vārdu.

Zemāk esošajā piemēra korpusā apzināti ir četras ģimenes — kļūdas, funkciju pieprasījumi, jautājumi un komplimenti —, lai tu vizuāli varētu pārbaudīt iegūto grupējumu. Iestatījums random_state=42 garantē, ka no viena gājiena uz otru iegūsi tās pašas kopas, kas ir būtiski, kad nepieciešams salīdzināt divas konfigurācijas.

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

Pareizā kopu skaita atrašana

Ar divpadsmit sagatavotiem teikumiem četru izvēle bija acīmredzama. Ar astoņiem tūkstošiem verbatimu neviens nezina pareizo vērtību. Divi rādītāji palīdz to uzminēt. Inerce, proti, atlikušā izkliede grupu ietvaros, mehāniski samazinās, palielinot kopu skaitu: tu meklē “elkoni” — punktu, aiz kura tā vairs būtiski nemazinās. Silueta rādītājs (silhouette score) ir izšķirošāks, jo tas mēra ko citu: cik daudz tuvāk katrs punkts atrodas savai grupai salīdzinājumā ar tuvāko kaimiņu grupu. Atšķirībā no inerces, tam ir maksimums, un šis maksimums tieši norāda uz kandidātvērtību.

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: Klasterizācija bez K

K-Means cieš no strukturāla trūkuma, strādājot ar reāliem datiem: tam ir jāpiešķir katrs punkts kādai kopai. Atsevišķs verbatims, kas neatgādina neko citu, tiek piespiedu kārtā pievienots vismazāk attālinātajai grupai, kur tas piesārņo interpretāciju. HDBSCAN domā blīvuma kategorijās un pieņem teikt “nē”: tas pats nosaka grupu skaitu un izvieto izolētus punktus atsevišķā kategorijā ar etiķeti -1.

Šīs novirzes (outliers) nav atkritumi. Biļešu korpusā tās bieži ir reti incidenti, ārpus darbības jomas esoši pieprasījumi vai vāji signāli — tieši tas, kas pelnījis cilvēka pārskatīšanu. Zemāk esošais kods tās parāda atsevišķi, nevis izmet.

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

Kopu automātiska nosaukšana

Klasterizācijas algoritms dod tev skaitļus. “Kopa 2” nepieder ne ziņojumam, ne informācijas panelim. Solis, kas padara rezultātu lietojamu, ir iesniegt LLM desmitiem reprezentatīvu dalībnieku un lūgt tam īsu nosaukumu: “Savienojuma problēmas”, “Integrācijas pieprasījumi”, “Rēķinu jautājumi”. Ierobežojums līdz desmit piemēriem kontrolē izmaksas, temperatūras iestatīšana uz nulli nodrošina, ka viena un tā pati kopa vienmēr saņem to pašu nosaukumu, un cikls ignorē etiķeti -1, jo novirzēm pēc definīcijas nav kopīgas tēmas.

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 klasterizācijas cauruļvads

Trīs soļi — iegulšana, klasterizācija, nosaukšana — dabiski apvienojas vienā klasē. Parametrs methode pieņem vērtību "auto", kas deleģē grupu skaita izvēli HDBSCAN, vai skaitlisku vērtību, kas padota kā virkne, ja vēlies uzspiest K vērtību K-Means algoritmam. Atgrieztā vārdnīca satur etiķetes, lasāmus nosaukumus un divus skaitītājus, kas uzreiz norāda, vai rezultāts ir izmantojams: n_outliers, kas tuvs kopējam skaitam, nozīmē, ka tavam korpusam trūkst blīvas struktūras, un tev vajadzētu atgriezties pie 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)

Galvenās atziņas

  • Izmanto K-Means, kad zini kopu skaitu
  • Izmanto HDBSCAN, lai automātiski noteiktu grupas un novirzes
  • Silueta rādītājs palīdz izvēlēties pareizo K
  • LLM automātiski nosauc atklātās kopas
  • Iegultnes padara klasterizāciju semantisku, ne tikai leksisku