Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Shlukování: Automatické seskupování

Lekce 18 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Proč shlukovat?
  3. K-Means na vektorech
  4. Hledání správného počtu shluků
  5. HDBSCAN: Shlukování bez K
  6. Automatické pojmenování shluků
  7. Kompletní pipeline pro shlukování
  8. Klíčové poznatky

Cíle

  • Seskupit texty podle tématu bez předem daných štítků
  • Použít algoritmy K-Means a HDBSCAN na vektorech (embeddings)
  • Automaticky pojmenovat shluky

Proč shlukovat?

Lekce o klasifikaci předpokládala, že už víš, jaké kategorie existují. Shlukování řeší opačnou situaci, která je při průzkumu korpusu nejčastější: nikdo neví, co data obsahují. Získáš osm tisíc odpovědí ze spokojenostního dotazníku nebo půl roku ticketů na podporu a první otázka nezní „kolik je tam chyb“, ale „o čem lidé vlastně mluví“. Shlukování odhalí tematické skupiny, aniž bys mu cokoli předem řekl.

Tři případy použití se objevují stále dokola: analýza tisíců zpětných vazeb od zákazníků pro extrakci dominantních vzorců, identifikace opakujících se témat v tickech podpory pro naplnění znalostní báze a průzkum neznámého korpusu dokumentů před rozhodnutím, jak jej indexovat.

K-Means na vektorech

K-Means je algoritmus první volby: zadáš mu počet skupin, on umístí odpovídající počet středů a iterativně posouvá každý střed směrem k průměru bodů, které přitahuje. Aplikován na vektory místo pytle slov seskupuje podle významu: „aplikace padá při startu“ a „od včera se nelze přihlásit“ skončí spolu, přestože nemají žádná společná slova.

Níže uvedený ukázkový korpus záměrně obsahuje čtyři rodiny – chyby, požadavky na funkce, dotazy a pochvaly – abys mohl vizuálně ověřit výsledné seskupení. Nastavení random_state=42 zaručuje, že při každém spuštění dostaneš stejné shluky, což je zásadní, kdykoli potřebuješ porovnat dvě konfigurace.

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

Hledání správného počtu shluků

U dvanácti připravených vět bylo zvolení čísla čtyři zřejmé. U osmi tisíc odpovědí nikdo správnou hodnotu nezná. Pomohou ti dvě metriky. Inerce, tedy zbytkový rozptyl uvnitř skupin, mechanicky klesá s přidáváním shluků: hledáš „loket“, bod, za kterým už významně neklesá. Siluetové skóre je rozhodující, protože měří něco jiného: jak moc je každý bod blíže své vlastní skupině než té nejbližší sousední. Na rozdíl od inerce má maximum a toto maximum přímo ukazuje na kandidátní 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: Shlukování bez K

K-Means trpí strukturální vadou na reálných datech: musí přiřadit každý bod do nějakého shluku. Izolovaná odpověď, která se ničemu nepodobá, se násilně přilepí k nejméně vzdálené skupině, kde zkresluje interpretaci. HDBSCAN uvažuje v termínech hustoty a umí říct „ne“: sám určí počet skupin a izolované body umístí do samostatné kategorie označené -1.

Tyto odlehlé hodnoty nejsou odpad. V korpusu ticketů jsou to často vzácné incidenty, požadavky mimo rozsah nebo slabé signály – přesně to, co si zaslouží lidskou revizi. Níže uvedený kód je zobrazí odděleně, místo aby je zahodil.

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é pojmenování shluků

Algoritmus shlukování ti dá jen čísla. „Shluk 2“ nepatří do reportu ani na dashboard. Krok, který učiní výsledek použitelným, spočívá v předložení tuctu reprezentativních členů LLM a požádání o krátký název: „Problémy s připojením“, „Žádosti o integraci“, „Dotazy k fakturaci“. Omezení na deset příkladů kontroluje náklady, nastavení teploty na nulu zajišťuje, že stejný shluk dostane vždy stejné jméno, a smyčka ignoruje štítek -1, protože odlehlé hodnoty mají z definice žádné společné téma.

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 pro shlukování

Tři kroky – vektorizace, shlukování, pojmenování – přirozeně splývají do jedné třídy. Parametr methode přijímá hodnotu "auto", která deleguje volbu počtu skupin na HDBSCAN, nebo číselnou hodnotu předanou jako řetězec, když chceš vynutit K pro K-Means. Vrácený slovník obsahuje štítky, čitelné názvy a dva čítače, které ti okamžitě řeknou, zda je výsledek k užití: hodnota n_outliers blízká celkovému počtu znamená, že tvému korpusu chybí hustá struktura, a měl bys se vrátit ke 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)

Klíčové poznatky

  • Použij K-Means, když znáš počet shluků
  • Použij HDBSCAN pro automatickou detekci skupin a odlehlých hodnot
  • Siluetové skóre pomáhá vybrat správné K
  • LLM automaticky pojmenuje objevené shluky
  • Vektory umožňují sémantické shlukování, nejen lexikální