Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Clustering: Grúpáil Uathoibríoch

Ceacht 18 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Cuspóirí
  2. Cén fáth clustering?
  3. K-Means ar leabaithe
  4. An líon ceart clastar a aimsiú
  5. HDBSCAN: Clustering gan K
  6. Ainmneacha a thabhairt ar chlastair go huathoibríoch
  7. Píblíne iomlán clustering
  8. Príomhphointí

Cuspóirí

  • Téacsanna a ghrúpáil de réir téama gan lipéid réamhshocraithe
  • K-Means agus HDBSCAN a úsáid ar leabaithe (embeddings)
  • Ainmneacha a thabhairt ar chlastair go huathoibríoch

Cén fáth clustering?

Ghlac an ceacht ar aicmiú leis go raibh a fhios agat cheana féin cé na catagóirí a bhí ann. Pléann clustering leis an staid mhalairt, rud atá coitianta freisin nuair a bhíonn tú ag iniúchadh corpais: níl a fhios ag aon duair céard atá ann. Faigheann tú ocht míle verbatim ó shuirbhé sástachta, nó sé mhí ticéad tacaíochta, agus ní hé “cé mhéad fabht” an chéad cheist ach “céard faoina bhfuil daoine ag caint i ndáiríre.” Fionnann clustering grúpaí téamacha gan aon eolas a bheith tugtha dó roimh ré.

Tagann trí chás úsáide chun cinn go minic: mílte aiseolais ó chustaiméirí a anailísiú chun patrúin cheannasacha a bhaint amach, ábhair athfhillteacha i dticéid tacaíochta a aithint chun bonn eolais a líonadh, agus corpus doiciméad anaithnid a iniúchadh sula gcinntear conas é a innéacsú.

K-Means ar leabaithe

Is é K-Means an t-algartam is fearr le haghaidh seo: tugann tú líon na ngrúpaí dó, cuireann sé an oiread sin lárionad ann, agus bogann sé gach lárionad ar bhealach iteráideach i dtreo mheán na bpointí a mheallann sé. Nuair a chuirtear i bhfeidhm é ar leabaithe seachas ar mhála focal, déanann sé grúpáil de réir brí: críochnaíonn “titim an aip ar thosaigh” agus “ní féidir logáil isteach ó inné” le chéile cé nach bhfuil aon fhocal coiteann acu.

Tá ceithre theaghlach go dánta sa chorpas sampla thíos—fabhtanna, iarratais ar ghnéithe, ceisteanna, agus moltaí—ionas gur féidir leat an grúpáil a fheiceáil go soiléir. Cinntíonn an socrú random_state=42 go bhfaighidh tú na clastair chéanna ó rith go rith, rud atá riachtanach gach uair a theastaíonn uait dhá chumraíocht a chur i gcomparáid.

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

An líon ceart clastar a aimsiú

Le dhá shé phráta ullmhaithe, bhí sé soiléir ceathrar a roghnú. Le hocht míle verbatim, níl a fhios ag aon duine an luach ceart. Cabhraíonn dhá mhéadracht leat tuairim a dhéanamh. Laghdaíonn an t-inertia, nó an scaipeadh iarmharach laistigh de ghrúpaí, go meicniúil de réir mar a chuireann tú clastair leis: tá tú ag lorg na “uillinne”, an pointe thar nach dtiteann sé go suntasach a thuilleadh. Tá an scór scáthchrutha (silhouette score) níos cinntí toisc go dtomhaiseann sé rud eile: cé chomh gar is atá gach pointe dá ghrúpa féin i gcomparáid leis an ngrúpa comharsanach is gaire. Murab ionann agus inertia, tá uasmhéid aige, agus léiríonn an t-uasmhéid sin luach iarrthóra go díreach.

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 gan K

Tá locht struchtúrach ar K-Means maidir le sonraí fíorshaol: caithfidh sé gach pointe a shannadh do chlastar. Críochnaíonn verbatim aonair nach bhfuil cosúil le haon rud eile ceangailte go héignitheach leis an ngrúpa is gaire, áit a thruaillíonn sé an léirmhíniú. Déanann HDBSCAN réasúnú i dtéarmaí dlúis agus glacann sé le “níl” a rá: cinneann sé líon na ngrúpaí é féin agus cuireann sé pointí aonair i gcatagóir ar leith ar a dtugtar -1.

Ní bruscar iad na heis-mhíreanna seo. I gcorpas ticéad, is minic gur teagmhais annamha, iarratais lasmuigh den scóip, nó comharthaí laga iad—go díreach an rud a thuilleann athbhreithniú daonna. Taispeánann an cód thíos iad ar leithligh seachas iad a chaitheamh amach.

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

Ainmneacha a thabhairt ar chlastair go huathoibríoch

Tugann algartam clustering uimhreacha duit. Ní bhaineann “Cluster 2” le tuarascáil ná le deasc oibre. Is é an chéim a dhéanann an toradh inúsáidte ná dosaen ball ionadaíoch a chur faoi bhráid an LLM agus ainm gairid a iarraidh air: “Fadhbanna Ceangail”, “Iarratais Comhtháthaithe”, “Ceisteanna Billeála.” Teorannú le deich sampla rialaíonn an costas, cinntíonn teocht nialasach go bhfaigheann an clastar céanna an t-ainm céanna i gcónaí, agus déanann an lúb neamhaird ar an lipéad -1 ós rud é, de réir sainmhínithe, nach bhfuil aon téama coiteann ag eis-mhíreanna.

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

Píblíne iomlán clustering

Tagann na trí chéim—leabú, clustering, ainmniú—le chéile go nádúrtha in aon rang amháin. Glacann an paraiméadar methode le "auto", a tharmligean roghnú líon na ngrúpaí chuig HDBSCAN, nó luach uimhriúil a ritear mar shreang nuair is mian leat K a fhorchur ar K-Means. Tá na lipéid, na hainmneacha inléite, agus dhá chuntair sa fhoclóir a thugtar ar ais a insíonn duit láithreach an fiú an toradh é a úsáid: ciallaíonn n_outliers atá gar don iomlán nach bhfuil struchtúr dlúth i do chorpas, agus ba chóir duit filleadh ar 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)

Príomhphointí

  • Úsáid K-Means nuair atá a fhios agat líon na gclastar
  • Úsáid HDBSCAN chun grúpaí agus eis-mhíreanna a bhrath go huathoibríoch
  • Cabhraíonn an scór scáthchrutha (silhouette score) leis an K ceart a roghnú
  • Ainmníonn LLM clastair a fionnadh go huathoibríoch
  • Déanann leabaithe (embeddings) clustering semantach, ní hamháin léacsach