Премини към основното съдържание
Български— Изберете език
Меню

Клъстериране: Автоматично групиране

Урок 18 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Защо клъстериране?
  3. K-Means върху ембединги
  4. Откриване на правилния брой клъстери
  5. HDBSCAN: Клъстериране без K
  6. Автоматично наименуване на клъстерите
  7. Пълен конвейер за клъстериране
  8. Ключови изводи

Цели

  • Групиране на текстове по тема без предварително дефинирани етикети
  • Използване на K-Means и HDBSCAN върху ембединги
  • Автоматично наименуване на клъстерите

Защо клъстериране?

Урокът за класификация предполагаше, че вече знаете съществуващите категории. Клъстерирането решава обратната ситуация, която също е най-честата при изследване на корпус: никой не знае какво съдържа той. Извличате осем хиляди вербатими от проучване за удовлетвореност или шест месеца тикети за поддръжка и първият въпрос не е „колко бъга има“, а „за какво всъщност говорят хората“. Клъстерирането открива тематични групи, без да му се предоставя никаква предварителна информация.

Три случая на употреба се срещат постоянно: анализ на хиляди отзиви от клиенти за извличане на доминиращи модели, идентифициране на повтарящи се теми в тикетите за поддръжка за попълване на база знания и изследване на неизвестен документен корпус преди вземане на решение как да се индексира.

K-Means върху ембединги

K-Means е алгоритъмът по подразбиране: задавате му брой групи, той поставя толкова на брой центрове и итеративно премества всеки център към средната стойност на точките, които привлича. Приложен върху ембединги, а не върху торба с думи (bag of words), той групира по смисъл: „приложението се срива при стартиране“ и „не мога да вляза от вчера“ се озовават заедно, въпреки че не споделят нито една дума.

Примерният корпус по-долу умишлено съдържа четири семейства – бъгове, заявки за функции, въпроси и похвали, – за да можете визуално да проверите полученото групиране. Настройката random_state=42 гарантира, че ще получите едни и същи клъстери от едно изпълнение до следващото, което е от съществено значение, когато трябва да сравнявате две конфигурации.

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

Откриване на правилния брой клъстери

При дванадесет подготвени изречения изборът на четири беше очевиден. При осем хиляди вербатима никой не знае правилната стойност. Две метрики Ви помагат да предположите. Инерцията, тоест остатъчната дисперсия в рамките на групите, механично намалява с добавянето на клъстери: търсите „лакътя“, точката, след която спадът вече не е значителен. Оценката по силуета (silhouette score) е по-решаваща, защото измерва нещо друго: колко по-близо е всяка точка до собствената си група в сравнение с най-близката съседна група. За разлика от инерцията, тя има максимум и този максимум директно посочва кандидат-стойност.

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: Клъстериране без K

K-Means страда от структурен дефект при реални данни: трябва да присвои всяка точка към клъстер. Изолиран вербатим, който не прилича на нищо друго, завършва насилствено прикрепен към най-малко отдалечената група, където замърсява интерпретацията. HDBSCAN разсъждава чрез плътност и приема да каже „не“: той сам определя броя на групите и поставя изолираните точки в отделна категория, етикетирана с -1.

Тези отклонения (outliers) не са боклук. В корпус от тикети те често са редки инциденти, заявки извън обхвата или слаби сигнали – точно това, което заслужава човешки преглед. Кодът по-долу ги показва отделно, вместо да ги изхвърля.

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

Автоматично наименуване на клъстерите

Алгоритъмът за клъстериране Ви дава числа. „Клъстер 2“ няма място в доклад или табло за управление. Стъпката, която прави резултата използваем, се състои в предоставянето на дузина представителни членове на LLM и молба за кратко име: „Проблеми с връзката“, „Заявки за интеграция“, „Въпроси за фактуриране“. Ограничаването до десет примера контролира разходите, задаването на температура нула гарантира, че един и същ клъстер винаги получава едно и също име, а цикълът игнорира етикета -1, тъй като отклоненията по дефиниция нямат обща тема.

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

Пълен конвейер за клъстериране

Трите стъпки – ембедиране, клъстериране, наименуване – естествено се обединяват в един единствен клас. Параметърът methode приема "auto", което делегира избора на брой групи на HDBSCAN, или числова стойност, предадена като низ, когато искате да наложите K на K-Means. Върнатият речник съдържа етикетите, четимите имена и два брояча, които веднага Ви казват дали резултатът си струва да се използва: n_outliers, близък до общия брой, означава, че Вашият корпус липсва плътна структура и трябва да се върнете към 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)

Ключови изводи

  • Използвайте K-Means, когато знаете броя на клъстерите
  • Използвайте HDBSCAN за автоматично откриване на групи и отклонения
  • Оценката по силуета помага за избора на правилното K
  • LLM автоматично наименува откритите клъстери
  • Ембеддингите правят клъстерирането семантично, а не просто лексикално