Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Clustering: Ryhmittely automaattisesti

Oppitunti 18 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Miksi klusterointi?
  3. K-Means upotuksille
  4. Oikean klusterimäärän löytäminen
  5. HDBSCAN: Klusterointi ilman K:ta
  6. Klustereiden automaattinen nimeäminen
  7. Täydellinen klusterointiputki
  8. Keskeiset asiat

Tavoitteet

  • Ryhmittele tekstit teeman perusteella ilman ennalta määriteltyjä luokkia
  • Käytä K-Means- ja HDBSCAN-algoritmeja upotuksille (embeddings)
  • Nimeä klusterit automaattisesti

Miksi klusterointi?

Luokittelutunnilla oletimme, että tiedät jo olemassa olevat kategoriat. Klusterointi ratkaisee päinvastaisen tilanteen, joka on myös yleisin tutkiessa aineistoa: kukaan ei tiedä, mitä se sisältää. Haet kahdeksantuhatta vapaata vastausta tyytyväisyyskyselystä tai kuuden kuukauden asiakastukipyyntöjä, ja ensimmäinen kysymys ei ole “kuinka monta bugia”, vaan “mistä ihmiset oikeastaan puhuvat”. Klusterointi löytää teemaryhmät kertomatta sille etukäteen mitään.

Kolme käyttötapausta nousevat jatkuvasti esiin: tuhansien asiakaspalautteiden analysointi hallitsevien mallien erottamiseksi, toistuvien aiheiden tunnistaminen tukipyyntöissä tietokannan rakentamiseksi sekä tuntemattoman dokumenttiaineiston tutkiminen ennen indeksointitavan päättämistä.

K-Means upotuksille

K-Means on ensisijainen algoritmi: annat sille ryhmien määrän, se asettaa kyseisen määrän keskipisteitä ja siirtää iteratiivisesti jokaista keskipistettä kohti niiden pisteiden keskiarvoa, jotka se houkuttelee. Kun sitä sovelletaan upotuksiin sanapussin sijaan, se ryhmittelee merkityksen perusteella: “sovellus kaatuu käynnistyksessä” ja “ei voi kirjautua sisään eilisestä lähtien” päätyvät samaan ryhmään, vaikka niillä ei olisi yhteisiä sanoja.

Alla oleva esimerkkiaineisto sisältää tarkoituksellisesti neljä perhettä – bugit, ominaisuuspyynnöt, kysymykset ja kehumiset – jotta voit visuaalisesti varmistaa syntyvän ryhmittelyn. Asetus random_state=42 takaa, että saat samat klusterit ajosta toiseen, mikä on välttämätöntä aina, kun tarvitset kahden konfiguraation vertailua.

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

Oikean klusterimäärän löytäminen

Kun käytössä on kaksitoista valmisteltua lausetta, neljän valitseminen oli ilmeistä. Kahdeksantuhannen vapaan vastauksen kohdalla kukaan ei tiedä oikeaa arvoa. Kaksi mittaria auttaa arvaamaan sen. Inertia, eli ryhmien sisäinen jäljellä oleva hajonta, pienenee mekaanisesti klustereita lisättäessä: etsit “kyynärpääkohtaa”, pistettä, jonka jälkeen luku ei enää laske merkittävästi. Siluettipisteet ovat ratkaisevampia, koska ne mittaavat jotain muuta: kuinka paljon lähempänä jokainen piste on omaa ryhmäänsä verrattuna lähimpään naapuriryhmään. Toisin kuin inertia, siluettipisteillä on maksimi, ja tuo maksimi osoittaa suoraan ehdokasarvon.

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: Klusterointi ilman K:ta

K-Means kärsii rakenteellisesta viasta todellisissa data-aineistoissa: sen on pakko liittää jokainen piste johonkin klusteriin. Eristynyt vapaa vastaus, joka ei muistuta mitään muuta, kiinnitetään väkisin vähiten etäiseen ryhmään, jossa se saastuttaa tulkintaa. HDBSCAN ajattelee tiheyden kautta ja hyväksyy kieltäytymisen: se määrittää ryhmien määrän itse ja sijoittaa eristyneet pisteet erilliseen kategoriaan, jonka tunniste on -1.

Nämä poikkeavat havainnot eivät ole roskaa. Pyyntöaineistossa ne ovat usein harvinaisia incidentskejä, aiheen ulkopuolisia pyyntöjä tai heikkoja signaaleja – juuri niitä, jotka ansaitsevat ihmisen tarkastelun. Alla oleva koodi näyttää ne erikseen sen sijaan, että hylkäisi ne.

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

Klustereiden automaattinen nimeäminen

Klusterointialgoritmi antaa sinulle numeroita. “Klusteri 2” ei kuulu raporttiin tai kojetauluun. Vaihe, joka tekee tuloksesta käyttökelpoisen, koostuu tusinan edustavan jäsenen lähettämisestä kielimallille (LLM) ja pyytämisestä sille lyhyen nimen: “Yhteysongelmat”, “Integraatiopyynnöt”, “Laskutuskysymykset”. Rajoittaminen kymmeneen esimerkkiin hallitsee kustannuksia, lämpötilan asettaminen nollaan varmistaa, että sama klusteri saa aina saman nimen, ja silmukka ohittaa tunnisteen -1, koska poikkeavilla havainnoilla ei määritelmällisesti ole yhteistä teemaa.

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

Täydellinen klusterointiputki

Kolme vaihetta – upotus, klusterointi, nimeäminen – yhdistyvät luontevasti yhdeksi luokaksi. Parametri methode hyväksyy arvon "auto", joka delegoi ryhmämäärän valinnan HDBSCAN:lle, tai numeerisen arvon merkkijonona, kun haluat pakottaa K:n K-Meansille. Palautettu sanakirja sisältää tunnisteet, luettavat nimet ja kaksi laskuria, jotka kertovat välittömästi, kannattaako tulosta käyttää: n_outliers, joka on lähellä kokonaismäärää, tarkoittaa, että aineistostasi puuttuu tiheä rakenne, ja sinun pitäisi palata K-Meansiin.

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)

Keskeiset asiat

  • Käytä K-Meansia, kun tiedät klusterien määrän
  • Käytä HDBSCAN:ia ryhmien ja poikkeavien havaintojen automaattiseen havaitsemiseen
  • Siluettipisteet auttavat valitsemaan oikean K:n
  • Kielimalli (LLM) nimeää löydetyt klusterit automaattisesti
  • Upotukset tekevät klusteroinnista semanttista, eivät vain leksikaalista