Przejdź do głównej treści
Polski— Wybierz język
Menu

Klasteryzacja: Automatyczne grupowanie

Lekcja 18 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Dlaczego klasteryzacja?
  3. K-Means na embeddingach
  4. Znalezienie właściwej liczby klastrów
  5. HDBSCAN: Klasteryzacja bez K
  6. Automatyczne nadawanie nazw klastrom
  7. Kompletny potok klasteryzacji
  8. Kluczowe wnioski

Cele

  • Grupowanie tekstów według tematów bez wcześniej zdefiniowanych etykiet
  • Wykorzystanie algorytmów K-Means i HDBSCAN na embeddingach
  • Automatyczne nadawanie nazw klastrom

Dlaczego klasteryzacja?

Lekcja o klasyfikacji zakładała, że już wiesz, jakie kategorie istnieją. Klasteryzacja rozwiązuje sytuację odwrotną, która jest również najczęstsza podczas eksploracji korpusu: nikt nie wie, co on zawiera. Pobierasz osiem tysięcy wypowiedzi z ankiety satysfakcji lub sześć miesięcy zgłoszeń do wsparcia technicznego, a pierwsze pytanie brzmi nie „ile jest błędów“, lecz „o czym ludzie właściwie mówią“. Klasteryzacja odkrywa grupy tematyczne bez żadnej wcześniejszej wiedzy.

Trzy przypadki użycia pojawiają się stale: analiza tysięcy opinii klientów w celu wyodrębnienia dominujących wzorców, identyfikacja powtarzających się tematów w zgłoszeniach wsparcia w celu uzupełnienia bazy wiedzy oraz eksploracja nieznanego korpusu dokumentów przed podjęciem decyzji o sposobie jego indeksowania.

K-Means na embeddingach

K-Means to algorytm pierwszego wyboru: podajesz mu liczbę grup, on umieszcza tyleż centrów i iteracyjnie przesuwa każde centrum w stronę średniej punktów, które przyciąga. Zastosowany do embeddingów, a nie worka słów, grupuje według znaczenia: „aplikacja crashuje przy starcie“ i „nie mogę się zalogować od wczoraj“ trafią do tej samej grupy, mimo że nie dzielą żadnych słów.

Poniższy przykładowy korpus celowo zawiera cztery rodziny – błędy, prośby o funkcje, pytania i pochwały – abyś mógł wizualnie zweryfikować wynikowe grupowanie. Ustawienie random_state=42 gwarantuje, że otrzymasz te same klastry przy każdym uruchomieniu, co jest niezbędne, gdy potrzebujesz porównać dwie konfiguracje.

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

Znalezienie właściwej liczby klastrów

Przy dwunastu przygotowanych zdaniach wybór liczby cztery był oczywisty. Przy ośmiu tysiącach wypowiedzi nikt nie zna właściwej wartości. Dwie metryki pomagają ją oszacować. Bezwładność, czyli pozostałe rozproszenie wewnątrz grup, mechanicznie maleje wraz z dodawaniem klastrów: szukasz „łokcia“, punktu, poza którym spadki nie są już istotne. Wynik sylwetkowy (silhouette score) jest bardziej rozstrzygający, ponieważ mierzy coś innego: jak bardzo każdy punkt jest bliżej swojej własnej grupy niż najbliższej sąsiedniej grupy. W przeciwieństwie do bezwładności, ma on maksimum, a to maksimum bezpośrednio wskazuje kandydującą wartość.

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

K-Means cierpi na strukturalną wadę w przypadku danych ze świata rzeczywistego: musi przypisać każdy punkt do klastra. Izolowana wypowiedź, która nie przypomina niczego innego, zostaje siłą przypięta do najmniej odległej grupy, gdzie zanieczyszcza interpretację. HDBSCAN rozumuje w kategoriach gęstości i potrafi powiedzieć „nie“: sam określa liczbę grup i umieszcza izolowane punkty w osobnej kategorii oznaczonej jako -1.

Te wartości odstające (outliers) nie są śmieciami. W korpusie zgłoszeń są to często rzadkie incydenty, prośby wykraczające poza zakres lub słabe sygnały – dokładnie to, co zasługuje na przegląd przez człowieka. Poniższy kod wyświetla je osobno, zamiast je odrzucać.

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

Automatyczne nadawanie nazw klastrom

Algorytm klasteryzacji daje Ci liczby. „Klaster 2“ nie pasuje do raportu ani dashboardu. Krok, który sprawia, że wynik jest użyteczny, polega na przesłaniu tuzina reprezentatywnych elementów do LLM i poproszeniu go o krótką nazwę: „Problemy z logowaniem“, „Prośby o integracje“, „Pytania dotyczące rozliczeń“. Ograniczenie do dziesięciu przykładów kontroluje koszty, ustawienie temperatury na zero zapewnia, że ten sam klaster zawsze otrzyma tę samą nazwę, a pętla ignoruje etykietę -1, ponieważ wartości odstające z definicji nie mają wspólnego tematu.

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

Kompletny potok klasteryzacji

Trzy kroki – embedding, klasteryzacja, nadawanie nazw – naturalnie łączą się w jedną klasę. Parametr methode akceptuje wartość "auto", która deleguje wybór liczby grup do HDBSCAN, lub wartość liczbową przekazaną jako ciąg znaków, gdy chcesz narzucić K dla K-Means. Zwracany słownik zawiera etykiety, czytelne nazwy oraz dwa liczniki, które natychmiast mówią Ci, czy wynik nadaje się do użycia: n_outliers bliskie całkowitej liczbie oznacza, że Twój korpus nie ma zwartej struktury i powinieneś wrócić do 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)

Kluczowe wnioski

  • Używaj K-Means, gdy znasz liczbę klastrów
  • Używaj HDBSCAN, aby automatycznie wykryć grupy i wartości odstające
  • Wynik sylwetkowy pomaga wybrać odpowiednie K
  • LLM automatycznie nadaje nazwy odkrytym klastrom
  • Embeddingi sprawiają, że klasteryzacja jest semantyczna, a nie tylko leksykalna