Klynging og visualisering av embeddinger
Bruk k-means-klynging på et sett med embeddinger, og visualiser dem i 2D med UMAP for å oppdage naturlige temagrupperinger i dataene.
Klynging og visualisering av embeddinger er en gratis leksjon i AI Engineering Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI Engineering Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.
Hvorfor gruppere embedding?
Når De har hundrevis eller tusenvis av dokumenter, ønsker De ofte å oppdage hvilke temaer som finnes uten å lese alt manuelt. Gruppering av embedding samler semantisk like dokumenter automatisk og synliggjør den naturlige strukturen i dataene Deres.
Vanlige bruksområder omfatter automatisk tagging av supportsaker, oppdagelse av innholdskategorier, funn av overflødige dokumenter og forståelse av hva brukerne oftest spør om.
Oversikt over K-means-klynging
K-means deler n datapunkter inn i k klynger ved iterativt å tilordne hvert punkt til det nærmeste sentrumspunktet og deretter beregne sentrumspunktene på nytt som gjennomsnittet av de tilordnede punktene. Algoritmen konvergerer når tilordningene slutter å endre seg.
For embedding finner k-means dokumenter som ligger nær hverandre i det høytdimensjonale embedding-rommet, og grupperer dem dermed etter semantisk likhet.
from sklearn.cluster import KMeans
import numpy as np
# corpus_embeddings: (n_docs, 1536) — pre-computed
corpus_embeddings = np.random.randn(200, 1536) # placeholder
kmeans = KMeans(n_clusters=5, random_state=42, n_init='auto')
kmeans.fit(corpus_embeddings)
labels = kmeans.labels_
print(f'Cluster assignments: {labels[:10]}')
print(f'Unique clusters: {set(labels)}')Velge riktig antall klynger
Det vanskeligste er å velge k, altså antallet klynger. Albue-metoden plotter inertia (summen av de kvadrerte avstandene til sentrumspunktene) for ulike k-verdier og ser etter punktet der flere klynger ikke lenger reduserer inertia betydelig.
Silhuettskåren måler hvor mye bedre et punkt passer i sin egen klynge enn i den nærmeste andre klyngen – skårer nærmere 1 er bedre. Prøv k-verdier fra 3 til 20, og velg den beste skåren.
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
import numpy as np
corpus_embeddings = np.random.randn(200, 50) # placeholder (50D for speed)
best_k, best_score = 2, -1
for k in range(2, 11):
km = KMeans(n_clusters=k, random_state=42, n_init='auto')
labels = km.fit_predict(corpus_embeddings)
score = silhouette_score(corpus_embeddings, labels, sample_size=100)
print(f'k={k}: silhouette={score:.3f}')
if score > best_score:
best_score, best_k = score, k
print(f'Best k: {best_k}')Navngi klynger med en LLM
Etter klyngingen kan De be en LLM om å generere en lesbar etikett for hver klynge ved å sende noen representative dokumenter fra klyngen til modellen. På denne måten blir rå klyngenumre automatisk omgjort til meningsfulle kategorinavn.
from openai import OpenAI
client = OpenAI()
def label_cluster(cluster_docs, n_examples=3):
examples = '\n'.join(f'- {d}' for d in cluster_docs[:n_examples])
prompt = f'Given these documents, provide a 3-word category label:\n{examples}\nLabel:'
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}],
max_tokens=20
)
return response.choices[0].message.content.strip()
# Example usage:
# cluster_0_docs = [documents[i] for i in range(len(documents)) if labels[i] == 0]
# print(label_cluster(cluster_0_docs))Dimensjonsreduksjon med UMAP
Vektorer med 1536 dimensjoner kan ikke plottes direkte. UMAP (Uniform Manifold Approximation and Projection) reduserer høytdimensjonale data til 2D eller 3D samtidig som strukturen i lokale nabolag bevares. I motsetning til PCA er UMAP ikke-lineær og langt bedre til å bevare klynger.
UMAP er standardvalget for visualisering av tekstembedding, fordi lignende dokumenter forblir nær hverandre i 2D-plottet.
import umap
import numpy as np
corpus_embeddings = np.random.randn(200, 1536) # placeholder
reducer = umap.UMAP(
n_components=2,
metric='cosine', # important for text embeddings
random_state=42
)
embeddings_2d = reducer.fit_transform(corpus_embeddings)
print(f'Reduced shape: {embeddings_2d.shape}') # (200, 2)Visualisere klynger med Matplotlib
Når De har 2D-koordinater fra UMAP og klyngeetiketter fra k-means, gjør et enkelt spredningsdiagram klyngestrukturen synlig. Farglegg hvert punkt etter klyngeetiketten, og legg til titlene på representative dokumenter som tekstannotasjoner for å gjøre diagrammet forståelig.
import matplotlib.pyplot as plt
import numpy as np
# Assume: embeddings_2d (n, 2), labels (n,), documents list
# Placeholder data:
np.random.seed(42)
embeddings_2d = np.random.randn(50, 2)
labels = np.random.randint(0, 5, 50)
fig, ax = plt.subplots(figsize=(10, 7))
scatter = ax.scatter(
embeddings_2d[:, 0],
embeddings_2d[:, 1],
c=labels,
cmap='tab10',
s=60,
alpha=0.8
)
plt.colorbar(scatter, label='Cluster')
ax.set_title('Document Embedding Clusters (UMAP)')
plt.tight_layout()
plt.savefig('/tmp/clusters.png', dpi=150)
print('Saved cluster plot')Viktige UMAP-parametere
Viktige UMAP-hyperparametere som påvirker kvaliteten på visualiseringen:
- n_neighbors (standard 15): større verdier fanger opp mer global struktur, mens mindre verdier viser lokale klynger
- min_dist (standard 0.1): hvor tett punktene samler seg; mindre verdi = tettere klynger, men mer overlapp mellom dem
- metric: bruk alltid
'cosine'for tekstembedding – euklidsk avstand er uegnet
Eksperimenter med n_neighbors mellom 5 og 50 for å finne visualiseringen som best viser strukturen i dataene Deres.
Hierarkisk klynging som alternativ
Hierarkisk agglomerativ klynging bygger et tre med nestede klynger uten at De må angi k på forhånd. De deler treet ved en valgt avstandsgrense for å få de endelige klyngene. Dette er nyttig når De ikke kjenner antallet naturlige temaer i dataene Deres.
from sklearn.cluster import AgglomerativeClustering
import numpy as np
corpus_embeddings = np.random.randn(100, 50) # placeholder
cluster = AgglomerativeClustering(
n_clusters=None,
distance_threshold=1.5,
metric='cosine',
linkage='average'
)
labels = cluster.fit_predict(corpus_embeddings)
n_clusters = len(set(labels))
print(f'Found {n_clusters} natural clusters')Finne uteliggere og nesten-duplikater
Embedding er også utmerket for å finne nesten-identiske dokumenter. Beregn parvis cosinuslikhet mellom alle dokumentene, og marker par med likhet over 0,95 som mulige duplikater. Dette er mer robust enn å sammenligne tekstendringer, fordi metoden også fanger opp duplikater som er omformulert.
import numpy as np
def find_near_duplicates(corpus_vecs, threshold=0.95):
# corpus_vecs assumed L2-normalized
sim_matrix = corpus_vecs @ corpus_vecs.T # (n, n)
duplicates = []
n = len(corpus_vecs)
for i in range(n):
for j in range(i + 1, n):
if sim_matrix[i, j] >= threshold:
duplicates.append((i, j, float(sim_matrix[i, j])))
return duplicates
# pairs = find_near_duplicates(corpus_embeddings)
# print(f'Found {len(pairs)} near-duplicate pairs')Praktisk arbeidsflyt for klynging
En reell arbeidsflyt for klynging følger disse trinnene i rekkefølge:
- Lag embedding av alle dokumenter med
text-embedding-3-small - Reduser eventuelt til 50D med UMAP før klyngingen (gjør k-means raskere)
- Bruk k-means til klynging, og prøv ulike k-verdier for å finne den beste silhuettskåren
- Gi hver klynge en etikett med en LLM ved hjelp av 5 representative dokumenter
- Visualiser UMAP-spredningsdiagrammet i 2D, fargelagt etter klynge
- Se gjennom uteliggere (punkter langt fra alle sentrumspunkter)
Begrensninger ved klynging
Klynging av embedding har viktige begrensninger De bør være oppmerksom på:
- K-means antar sfæriske klynger – avlange eller uregelmessig formede temagrupper kan bli delt feil
- Embedding komprimerer betydning – to dokumenter kan være semantisk nærliggende, men tilhøre ulike handlingsrettede kategorier
- Klyngeetiketter må verifiseres – hent alltid et utvalg dokumenter fra hver klynge for å kontrollere rimeligheten av LLM-etiketten
Bruk klynging som et verktøy for utforskning, ikke som et system for kategorisering basert på en fasit.
Rask kontroll
Test forståelsen Deres av konseptene innen AI Engineering fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen lærte De: k-means grupperer dokumenter etter semantisk nærhet i embedding-rommet, UMAP reduserer embedding-er med høy dimensjonalitet til 2D for visualisering ved hjelp av cosinusavstand, og silhuettskåren hjelper Dem med å velge riktig antall klynger uten merkede data. Nå går vi videre fra søk i minnet og utforsker vektordatabaser for produksjonsmiljøer.
Lær deg Python med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 30
- Leksjoner
- 120
Ofte stilte spørsmål
Er leksjonen «Klynging og visualisering av embeddinger» gratis?
Ja – hele teksten i «Klynging og visualisering av embeddinger» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI Engineering Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Klynging og visualisering av embeddinger»?
Bruk k-means-klynging på et sett med embeddinger, og visualiser dem i 2D med UMAP for å oppdage naturlige temagrupperinger i dataene. Du øver på AI Engineering Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med AI Engineering Academy?
Ingen tidligere erfaring er nødvendig. AI Engineering Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Klynging og visualisering av embeddinger»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne AI Engineering Academy-leksjonen?
Ja. Alle AI Engineering Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Hva er vektorembeddinger?
- Generere embeddinger med OpenAI
- Semantisk søk med NumPy
- Klynging og visualisering av embeddinger