Salt la conținutul principal
Română— Alege o limbă
Meniu

Clustering: Grupare automată

Lecția 18 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. De ce clustering?
  3. K-Means pe embedding-uri
  4. Găsirea numărului corect de clustere
  5. HDBSCAN: Clustering fără K
  6. Denumirea automată a clusterelor
  7. Flux complet de clustering
  8. Puncte cheie

Obiective

  • Gruparea textelor pe teme fără etichete predefinite
  • Utilizarea K-Means și HDBSCAN pe embedding-uri
  • Denumirea automată a clusterelor

De ce clustering?

Lecția despre clasificare a presupus că știați deja ce categorii există. Clusteringul abordează situația opusă, care este, de asemenea, cea mai frecventă atunci când explorați un corpus: nimeni nu știe ce conține acesta. Recuperați opt mii de verbatimuri dintr-un sondaj de satisfacție sau șase luni de tichete de suport, iar prima întrebare nu este „câte erori sunt“, ci „despre ce vorbesc oamenii de fapt“. Clusteringul descoperă grupuri tematice fără a i se spune nimic în prealabil.

Trei cazuri de utilizare apar constant: analizarea a mii de feedback-uri de la clienți pentru a extrage modele dominante, identificarea subiectelor recurente în tichetele de suport pentru a popula o bază de cunoștințe și explorarea unui corpus de documente necunoscut înainte de a decide cum să îl indexați.

K-Means pe embedding-uri

K-Means este algoritmul preferat: îi oferiți un număr de grupuri, acesta plasează atâtea centre și mută iterativ fiecare centru spre media punctelor pe care le atrage. Aplicat pe embedding-uri în loc de o pungă de cuvinte (bag of words), acesta grupează după semnificație: „aplicația se blochează la pornire“ și „nu mă pot conecta de ieri“ ajung împreună, chiar dacă nu împărtășesc niciun cuvânt.

Corpusul exemplu de mai jos conține intenționat patru familii—erori, cereri de funcționalități, întrebări și complimente—pentru a putea verifica vizual gruparea rezultată. Setarea random_state=42 garantează că veți obține aceleași clustere de la o execuție la alta, lucru esențial ori de câte ori trebuie să comparați două configurații.

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

Găsirea numărului corect de clustere

Cu douăsprezece propoziții pregătite, alegerea lui patru a fost evidentă. Cu opt mii de verbatimuri, nimeni nu cunoaște valoarea corectă. Două metrici vă ajută să ghiciți. Inerția, adică dispersia reziduală în interiorul grupurilor, scade mecanic pe măsură ce adăugați clustere: căutați „cotul“, punctul dincolo de care aceasta nu mai scade semnificativ. Scorul siluetei este mai decisiv deoarece măsoară altceva: cât de mult este fiecare punct mai apropiat de propriul grup față de cel mai apropiat grup vecin. Spre deosebire de inerție, acesta are un maxim, iar acel maxim indică direct o valoare candidată.

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: Clustering fără K

K-Means suferă de un defect structural asupra datelor din lumea reală: trebuie să atribuie fiecare punct unui cluster. Un verbatim izolat care nu seamănă cu nimic altceva ajunge forțat atașat grupului cel mai puțin îndepărtat, unde poluează interpretarea. HDBSCAN raționează în termeni de densitate și acceptă să spună „nu“: determină singur numărul de grupuri și plasează punctele izolate într-o categorie separată etichetată -1.

Aceste valori aberante (outliers) nu sunt gunoi. Într-un corpus de tichete, acestea sunt adesea incidente rare, cereri în afara domeniului de aplicare sau semnale slabe—exact ceea ce merită o revizuire umană. Codul de mai jos le afișează separat în loc să le elimine.

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

Denumirea automată a clusterelor

Un algoritm de clustering vă oferă numere. „Clusterul 2“ nu își are locul într-un raport sau într-un tablou de bord. Pasul care face rezultatul utilizabil constă în submiterea a o duzină de membri reprezentativi către LLM și solicitarea unui nume scurt: „Probleme de conectare“, „Cereri de integrare“, „Întrebări despre facturare“. Limitarea la zece exemple controlează costul, setarea temperaturii la zero asigură că același cluster primește întotdeauna același nume, iar bucla ignoră eticheta -1 deoarece valorile aberante, prin definiție, nu au o temă comună.

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

Flux complet de clustering

Cei trei pași—embedding, clustering, denumire—se îmbină natural într-o singură clasă. Parametrul methode acceptă "auto", care deleagă alegerea numărului de grupuri către HDBSCAN, sau o valoare numerică transmisă ca șir de caractere atunci când doriți să impuneți un K pentru K-Means. Dicționarul returnat conține etichetele, numele lizibile și doi contori care vă spun imediat dacă rezultatul merită utilizat: un n_outliers apropiat de total înseamnă că corpusul dumneavoastră nu are o structură densă și ar trebui să reveniți la 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)

Puncte cheie

  • Utilizați K-Means atunci când cunoașteți numărul de clustere
  • Utilizați HDBSCAN pentru a detecta automat grupurile și valorile aberante
  • Scorul siluetei ajută la alegerea lui K corect
  • Un LLM denumește automat clusterele descoperite
  • Embedding-urile fac clusteringul semantic, nu doar lexical