Was sind Vektor-Embeddings?
Sie verstehen, wie neuronale Netze Text auf einen dichten Vektor im hochdimensionalen Raum abbilden, warum semantisch ähnliche Texte benachbarte Vektoren erzeugen und was die Kosinusähnlichkeit misst.
Was sind Vektor-Embeddings? ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Die Bedeutung hinter Zahlen
Ein Vektor-Embedding ist eine Liste von Zahlen (ein Vektor), die die Bedeutung eines Textabschnitts repräsentiert. Anstatt Wörter als rohe Zeichenketten zu speichern, lernen neuronale Netze, semantische Bedeutung in dichten numerischen Arrays zu kodieren. Zwei Texte mit ähnlicher Bedeutung erzeugen Vektoren, die in diesem hochdimensionalen Raum nahe beieinanderliegen.
Hochdimensionaler Vektorraum
Moderne Embeddings haben typischerweise 768 bis 3072 Dimensionen. Jede Dimension erfasst ein latentes Bedeutungsmerkmal — Themen, Stimmung, Stil und Beziehungen — ohne explizit programmiert worden zu sein. Das Ergebnis ist ein reichhaltiger geometrischer Raum, in dem semantische Beziehungen als messbare Distanzen sichtbar werden.
Beispielsweise erzeugt text-embedding-3-small Vektoren mit 1536 Dimensionen, während text-embedding-3-large Vektoren mit 3072 Dimensionen erzeugt.
Wie neuronale Netze Embeddings lernen
Embedding-Modelle werden anhand riesiger Textkorpora trainiert, um fehlende Wörter vorherzusagen (Masked Language Modeling) oder semantisch ähnliche von unähnlichen Paaren zu unterscheiden. Während des Trainings passt das Netzwerk Millionen von Gewichten an, bis sich ähnliche Texte im erlernten Vektorraum auf natürliche Weise zu Clustern zusammenfinden.
Deshalb werden Embeddings als dichte Repräsentationen bezeichnet — jede Dimension enthält Informationen, anders als bei dünn besetzten One-Hot-Kodierungen, bei denen die meisten Werte null sind.
Kosinusähnlichkeit: Nähe messen
Kosinusähnlichkeit misst den Winkel zwischen zwei Vektoren und liefert einen Wert zwischen -1 und 1. Ein Wert von 1 bedeutet, dass die Vektoren exakt in dieselbe Richtung zeigen (identische Bedeutung), 0 bedeutet orthogonal (ohne Bezug), und -1 bedeutet entgegengesetzte Richtungen.
Für Texte wird sie der euklidischen Distanz vorgezogen, weil sie die Vektorlänge ignoriert und sich ausschließlich auf die Richtung konzentriert. Dadurch ist sie gegenüber Unterschieden in der Textlänge robust.
import numpy as np
def cosine_similarity(vec_a, vec_b):
dot_product = np.dot(vec_a, vec_b)
norm_a = np.linalg.norm(vec_a)
norm_b = np.linalg.norm(vec_b)
return dot_product / (norm_a * norm_b)
# Example with tiny 3D vectors
v1 = np.array([0.8, 0.2, 0.5])
v2 = np.array([0.9, 0.1, 0.4])
print(cosine_similarity(v1, v2)) # Close to 1.0Warum semantische Ähnlichkeit wichtig ist
Die herkömmliche Schlüsselwortsuche versagt, wenn Benutzer paraphrasieren: Bei der Suche nach Automobil werden Dokumente über Autos nicht gefunden. Vektor-Embeddings lösen dieses Problem, weil semantisch gleichbedeutende Texte unabhängig von den exakt verwendeten Wörtern auf nahe beieinanderliegende Vektoren abgebildet werden.
Dadurch wird semantische Suche ermöglicht, bei der Sie das relevanteste Ergebnis anhand der Bedeutung statt anhand der Wortübereinstimmung finden — eine grundlegende Funktion für RAG-Systeme.
Der Embedding-Vektor als Visualisierung
Stellen Sie sich vor, Sie würden Sätze auf einer zweidimensionalen Karte darstellen (als vereinfachte Analogie). Sätze über maschinelles Lernen bilden in einem Bereich ein Cluster, Sätze über Kochen in einem anderen und Sätze über Sport ein drittes. Vektor-Embeddings erzeugen diese Karte in Tausenden von Dimensionen.
Berühmte Beziehungen wie king - man + woman ≈ queen sind in diesem Raum echte arithmetische Operationen — Vektoroperationen kodieren semantische Analogien.
Ein einfaches Embedding erzeugen
Die OpenAI-Embeddings-API akzeptiert Text und gibt eine Liste von Gleitkommazahlen zurück. Mit einem einzigen API-Aufruf können Sie einen Satz oder einen ganzen Absatz in ein Embedding umwandeln. Der zurückgegebene Vektor hat unabhängig von der Eingabelänge eine feste Dimension.
Wichtig: Längere Eingaben erzeugen keine größeren Vektoren — sie erzeugen weiterhin einen Vektor fester Größe. Bei sehr langen Texten können jedoch feine Details verloren gehen, weil das Modell alles in diesen festen Raum komprimiert.
from openai import OpenAI
client = OpenAI() # uses OPENAI_API_KEY from environment
response = client.embeddings.create(
model='text-embedding-3-small',
input='Vector embeddings capture semantic meaning.'
)
embedding = response.data[0].embedding
print(f'Dimensions: {len(embedding)}') # 1536
print(f'First 5 values: {embedding[:5]}')Mehrere Texte gleichzeitig in Embeddings umwandeln
Sie können mehrere Zeichenketten in einem einzigen API-Aufruf in Embeddings umwandeln, indem Sie dem Parameter input eine Liste übergeben. Das ist wesentlich effizienter, als für jeden Text eine einzelne Anfrage zu stellen, weil dadurch Netzwerk-Roundtrips reduziert werden und die API die Berechnung stapelweise ausführen kann.
Die Antwort enthält für jede Eingabe ein Embedding-Objekt in derselben Reihenfolge, sodass Sie diese mit Ihren ursprünglichen Texten zusammenführen können.
from openai import OpenAI
client = OpenAI()
texts = [
'Python is a programming language.',
'Snakes are reptiles.',
'Machine learning requires data.'
]
response = client.embeddings.create(
model='text-embedding-3-small',
input=texts
)
for text, result in zip(texts, response.data):
print(f'{text[:30]}... -> {len(result.embedding)}D vector')Skalarprodukt und Kosinusähnlichkeit im Vergleich
Wenn Ihre Embeddings L2-normalisiert sind (Einheitsvektoren mit der Länge 1), entspricht das Skalarprodukt der Kosinusähnlichkeit. Die Embedding-Modelle von OpenAI geben normalisierte Vektoren zurück, sodass Sie beide Metriken verwenden können — das Skalarprodukt ist etwas schneller zu berechnen.
Wenn Sie jedoch Embeddings aus verschiedenen Modellen oder Quellen kombinieren, die möglicherweise nicht normalisiert sind, berechnen Sie immer explizit die Kosinusähnlichkeit, um irreführende Ergebnisse zu vermeiden.
import numpy as np
def normalize(vec):
return vec / np.linalg.norm(vec)
v1 = normalize(np.array([3.0, 4.0, 0.0]))
v2 = normalize(np.array([4.0, 3.0, 0.0]))
# For unit vectors: dot product == cosine similarity
dot = np.dot(v1, v2)
print(f'Dot product: {dot:.4f}') # same as cosine simEmbeddings und One-Hot-Kodierung
One-Hot-Kodierung repräsentiert jedes Wort als Vektor mit genau einer 1 und ansonsten nur 0. Ein Vokabular mit 50.000 Wörtern erzeugt Vektoren mit 50.000 Dimensionen, die fast ausschließlich aus Nullen bestehen — äußerst ineffizient.
Dichte Embeddings verwenden 768 bis 3072 Dimensionen, aber jede Dimension enthält echte Informationen. Der Raum ist 10- bis 20-mal kleiner und erfasst dennoch wesentlich mehr Feinheiten, darunter Synonyme, Analogien und kompositionale Bedeutung, die bei der One-Hot-Kodierung vollständig verloren gehen.
Häufige Anwendungsfälle für Embeddings
Neben der semantischen Suche ermöglichen Embeddings viele praktische Anwendungen:
- Semantische Suche — Dokumente anhand ihrer Bedeutung statt anhand von Schlüsselwörtern finden
- Empfehlungssysteme — Elemente empfehlen, die denen ähneln, die der Benutzer mochte
- Clustering — Dokumente automatisch nach Themen gruppieren
- Klassifizierung — Embeddings einem linearen Klassifikator zuführen
- Duplikaterkennung — nahezu doppelte Inhalte erkennen
Alle RAG-Systeme sind auf Embeddings angewiesen, um Benutzeranfragen den relevanten Dokumentabschnitten zuzuordnen.
Schnelltest
Testen Sie Ihr Verständnis der AI-Engineering-Konzepte aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Vektor-Embeddings kodieren semantische Bedeutung als dichte numerische Arrays, Kosinusähnlichkeit misst semantische Nähe durch den Vergleich von Vektorrichtungen, und die Embedding-API von OpenAI wandelt Text in einem einzigen Aufruf in Vektoren fester Größe um. Als Nächstes sehen wir uns an, wie Sie Embeddings mit den OpenAI-Modellen praktisch erzeugen und vergleichen.
Häufig gestellte Fragen
Ist die Lektion „Was sind Vektor-Embeddings?“ kostenlos?
Ja — der vollständige Text von „Was sind Vektor-Embeddings?“ 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 „Was sind Vektor-Embeddings?“?
Sie verstehen, wie neuronale Netze Text auf einen dichten Vektor im hochdimensionalen Raum abbilden, warum semantisch ähnliche Texte benachbarte Vektoren erzeugen und was die Kosinusähnlichkeit misst. 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 1 von 4.
Wie lange dauert die Lektion „Was sind Vektor-Embeddings?“?
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