Embeddings clustern und visualisieren
Sie wenden k-Means-Clustering auf eine Menge von Embeddings an und visualisieren diese mithilfe von UMAP in 2D, um natürliche Themengruppen in Ihren Daten zu erkennen.
Embeddings clustern und visualisieren ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum Embeddings clustern?
Wenn Sie Hunderte oder Tausende von Dokumenten haben, möchten Sie oft herausfinden, welche Themen vorkommen, ohne alles manuell lesen zu müssen. Das Clustering von Embeddings gruppiert semantisch ähnliche Dokumente automatisch und macht dadurch die natürliche Struktur Ihrer Daten sichtbar.
Häufige Anwendungsfälle sind die automatische Verschlagwortung von Support-Tickets, das Erkennen von Inhaltskategorien, das Auffinden redundanter Dokumente und das Verstehen der Themen, zu denen Benutzer am häufigsten Fragen stellen.
Überblick über K-Means-Clustering
K-Means unterteilt n Datenpunkte in k Cluster, indem es jeden Punkt iterativ dem nächstgelegenen Zentroiden zuweist und anschließend die Zentroiden als Mittelwert der zugewiesenen Punkte neu berechnet. Der Algorithmus konvergiert, wenn sich die Zuordnungen nicht mehr ändern.
Bei Embeddings findet K-Means Dokumente, die im hochdimensionalen Embedding-Raum nahe beieinanderliegen, und gruppiert sie dadurch effektiv nach semantischer Ähnlichkeit.
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)}')Die richtige Anzahl von Clustern wählen
Die Wahl von k, also der Anzahl der Cluster, ist der schwierigste Teil. Bei der Ellbogenmethode wird die Trägheit (die Summe der quadrierten Abstände zu den Zentroiden) für verschiedene k-Werte aufgetragen. Gesucht wird der Punkt, an dem zusätzliche Cluster die Trägheit nicht mehr deutlich verringern.
Der Silhouettenkoeffizient misst, wie viel besser ein Punkt zu seinem eigenen Cluster passt als zum nächstgelegenen anderen Cluster – Werte näher an 1 sind besser. Probieren Sie k-Werte von 3 bis 20 aus und wählen Sie den besten Wert.
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}')Cluster mit einem LLM beschriften
Nach dem Clustering können Sie ein LLM bitten, für jedes Cluster eine für Menschen verständliche Bezeichnung zu erzeugen, indem Sie dem Modell einige repräsentative Dokumente aus diesem Cluster übergeben. So werden aus bloßen Clusternummern automatisch aussagekräftige Kategorienamen.
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))Dimensionsreduktion mit UMAP
Vektoren mit 1536 Dimensionen können nicht direkt dargestellt werden. UMAP (Uniform Manifold Approximation and Projection) reduziert hochdimensionale Daten auf 2D oder 3D und bewahrt dabei die Struktur lokaler Nachbarschaften. Im Gegensatz zu PCA ist UMAP nichtlinear und bewahrt Cluster deutlich besser.
UMAP ist die Standardwahl für die Visualisierung von Text-Embeddings, weil ähnliche Dokumente in der 2D-Darstellung nahe beieinander bleiben.
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)Cluster mit Matplotlib visualisieren
Sobald Sie 2D-Koordinaten von UMAP und Clusterbezeichnungen von K-Means haben, macht ein einfaches Streudiagramm die Clusterstruktur sichtbar. Färben Sie jeden Punkt entsprechend seiner Clusterbezeichnung ein und fügen Sie die Titel repräsentativer Dokumente als Textannotationen hinzu, damit das Diagramm verständlich wird.
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')Wichtige UMAP-Parameter
Wichtige UMAP-Hyperparameter, die die Qualität der Visualisierung beeinflussen:
- n_neighbors (Standardwert 15): Größere Werte erfassen mehr globale Struktur, kleinere Werte machen lokale Cluster sichtbar
- min_dist (Standardwert 0,1): Gibt an, wie dicht die Punkte beieinanderliegen; kleinere Werte = dichtere Cluster, aber mehr Überschneidungen zwischen ihnen
- metric: Verwenden Sie für Text-Embeddings immer
'cosine'– die euklidische Distanz ist ungeeignet
Experimentieren Sie mit n_neighbors zwischen 5 und 50, um die Visualisierung zu finden, die die Struktur Ihrer Daten am besten sichtbar macht.
Alternative: hierarchisches Clustering
Hierarchisches agglomeratives Clustering erstellt einen Baum verschachtelter Cluster, ohne dass Sie k im Voraus festlegen müssen. Sie schneiden den Baum bei einem gewählten Distanzschwellenwert, um Ihre endgültigen Cluster zu erhalten. Das ist nützlich, wenn Sie die Anzahl der natürlichen Themen in Ihren Daten nicht kennen.
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')Ausreißer und nahezu identische Dokumente finden
Embeddings eignen sich auch hervorragend zum Auffinden von nahezu identischen Dokumenten. Berechnen Sie die paarweise Kosinusähnlichkeit zwischen allen Dokumenten und markieren Sie Paare mit einer Ähnlichkeit über 0,95 als mögliche Duplikate. Das ist robuster als ein Textvergleich, weil auch umformulierte Duplikate erkannt werden.
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')Praktischer Clustering-Workflow
Ein echter Clustering-Workflow umfasst die folgenden Schritte in dieser Reihenfolge:
- Alle Dokumente mit
text-embedding-3-smalleinbetten - Optional vor dem Clustering mit UMAP auf 50D reduzieren (beschleunigt k-means)
- Mit k-means clustern und verschiedene k-Werte testen, um den besten Silhouettenkoeffizienten zu finden
- Jeden Cluster mithilfe eines LLM und 5 repräsentativer Dokumente beschriften
- Das 2D-UMAP-Streudiagramm anzeigen und nach Clustern einfärben
- Ausreißer überprüfen (Punkte, die weit von jedem Zentroiden entfernt liegen)
Einschränkungen des Clusterings
Beim Clustering von Embeddings müssen Sie einige wichtige Einschränkungen beachten:
- k-means setzt kugelförmige Cluster voraus – längliche oder unregelmäßig geformte Themengruppen werden möglicherweise falsch aufgeteilt
- Embeddings komprimieren Bedeutung – zwei Dokumente können semantisch nahe beieinanderliegen, aber zu unterschiedlichen, praktisch relevanten Kategorien gehören
- Clusterbezeichnungen müssen überprüft werden – wählen Sie immer Stichproben von Dokumenten aus jedem Cluster aus, um die vom LLM generierte Bezeichnung auf Plausibilität zu prüfen
Verwenden Sie Clustering als Werkzeug zur Exploration, nicht als Kategorisierungssystem mit Anspruch auf Ground Truth.
Schnelltest
Testen Sie Ihr Verständnis der Konzepte des AI Engineering aus dieser Lektion.
Lektionszusammenfassung
In dieser Lektion haben Sie gelernt: k-means gruppiert Dokumente anhand ihrer semantischen Nähe im Embedding-Raum, UMAP reduziert hochdimensionale Embeddings mithilfe der Kosinusdistanz zur Visualisierung auf 2D und der Silhouettenkoeffizient hilft Ihnen, die richtige Anzahl von Clustern ohne gelabelte Daten auszuwählen. Als Nächstes gehen wir über die Suche im Arbeitsspeicher hinaus und sehen uns Vector-Datenbanken für den Produktiveinsatz an.
Häufig gestellte Fragen
Ist die Lektion „Embeddings clustern und visualisieren“ kostenlos?
Ja — der vollständige Text von „Embeddings clustern und visualisieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Embeddings clustern und visualisieren“?
Sie wenden k-Means-Clustering auf eine Menge von Embeddings an und visualisieren diese mithilfe von UMAP in 2D, um natürliche Themengruppen in Ihren Daten zu erkennen. Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Embeddings clustern und visualisieren“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Was sind Vektor-Embeddings?
- Embeddings mit OpenAI erzeugen
- Semantische Suche mit NumPy
- Embeddings clustern und visualisieren