Januar 12, 2026
Machine Learning

Embeddings

Ein Embedding ist eine Darstellung von Daten — z. B. Wörtern, Sätzen, Bildern oder Produkten — in Form eines Vektors (also einer Liste von Zahlen). Embeddings dienen also ganz allgemein dazu Daten in numerische Vektoren umzuwandeln. Diese Vektoren repräsentieren die Bedeutung der Daten in einem kontinuierlichen Raum, so dass ähnliche Datenpunkte nahe beieinander liegen.

Ziel: Daten, die ähnliche Bedeutung haben, sollen auch ähnliche Vektoren haben.

Unter anderem werden Embeddings insbesondere für Arbeit mit Texten verwendet. Semantisch ähnliche Texte haben dann auch ähnliche Vektoren. Ein sehr populäres Modell ist das von Google entwickelte Word2Vec, das im Jahr 2013 erschienen ist.

Erklärung von Embeddings

Beispiel

In diesem (sehr vereinfachten) Beispiel liegen Hund und Katze näher beieinander als Hund und Auto – und genau das ist der Sinn von Embeddings: Sie übersetzen semantische Ähnlichkeit in numerische Nähe.

WortEmbedding (vereinfacht)
Hund[0.9, 0.1, 0.2]
Katze[0.8, 0.2, 0.3]
Auto[-0.3, 0.7, 0.9]

Embeddings erstellen

Das Herzstück sind Embedding-Modelle – also neuronale Netze, die lernen, Eingabedaten in sinnvolle Vektoren zu übersetzen. Das klassische Beispiel aus der Sprachverarbeitung ist Word2Vec. Um dieses Modell zu erstellen beginnt man mit großen Textmengen (z. B. Wikipedia, Bücher oder Webseiten).

Beispielsatz: „Der Hund jagt die Katze.“

Die Kernidee von Word2Vec ist, dass Wörter mit ähnlichem Kontext auch eine ähnliche Bedeutung haben. Das Modell lernt also, aus dem Kontext eines Wortes das Zielwort vorherzusagen (oder umgekehrt).

Dabei gibt es zwei Varianten:

  • CBOW (Continuous Bag of Words): Kontext → Wort
  • Skip-Gram: Wort → Kontext

Beispiel (Skip-Gram):
Input: „Hund“
Ziel: „Der“, „jagt“, „die“, „Katze“

Das Modell wird also so trainiert, dass der Vektor von Hund nützlich ist, um die benachbarten Wörter vorherzusagen.

Das neuronale Netz lernt zwei Matrizen:

  • Eingabematrix (Embedding-Matrix)
  • Ausgabematrix

Während des Trainings wird die Eingabematrix so angepasst, dass Wörter mit ähnlichen Kontexten ähnliche Spalten in dieser Matrix bekommen.

Training von Embeddings

Hier anhand des Word2Vec Skip-Gram Modells.

Dazu werden die Eingabedaten in Paare von Eingabewort und Kontextwort zerlegt. Bei einem Fenster +/-2 erhält man folgende Paare:

Eingabe (Input)Ziel (Output)
HundDer
Hundjagt
Hunddie
HundKatze

Das Modell besteht aus zwei Gewichtsmatrizen:

  1. Eingabematrix W1 (Vokabulargröße x Embedding Dimension) -> Jede Zeile entält den Embedding Vektor eines Wortes
  2. Ausgabematrix W2 (Embedding Dimension x Vokabulargröße) -> Dient zur Vorhersage des Zielwortes

Das Eingabewort wird als One-Hot-Vektor dargestellt bspw. „Hund“ = [0,1,0,0,0]

Dieser Vektor wird mit der Eingabematrix W1 multipliziert und daraus ergibt sich der Embedding-Vektor für das Eingabewort:

\(h = W^T_1 \cdot x\)

Dann wird dieser Vektor mit W2 multipliziert um die Vorhersagewahrscheinlichkeiten für alle Wörter im Vokabular zu erzeugen:

\(\hat y = softmax(W^T_2 \cdot h)\)

Das Ergebnis ist ein Vektor, der ausdrückt, wie wahrscheinlich jedes Wort als Kontextwort gilt.

Nach dem Training ist die Eingabematrix W1 das eigentliche Embedding-Modell. Jede Zeile entspricht dann dem Vektor eines Wortes.

Moderne Modelle

Word2Vec behandelt jedes Wort isoliert.
Neuere Modelle wie BERT, GPT oder OpenAI Embeddings gehen weiter:

  • Sie nutzen Transformer-Netzwerke, die auf die gesamte Satzstruktur schauen.
  • Das Ziel ist nicht mehr nur Kontextvorhersage, sondern z. B. Masked Language Modeling:
    Ein Wort wird verdeckt, und das Modell muss es anhand des Kontexts erraten.
  • Dadurch entstehen kontextabhängige Embeddings:
    Das Wort „Bank“ in „Geld abheben“ bekommt einen anderen Vektor als in „am Flussufer sitzen“.

Sparse Embeddings

Ein Sparse Embedding ist eine Variante von Embeddings bei denen der Vektor, der hauptsächlich aus Nullen besteht. Nur wenige Dimensionen enthalten tatsächlich Werte.

Beispiel:
  • Dense Embedding: [0.12, 0.33, -0.08, 0.41, 0.27, ...]
  • Sparse Embedding: [0, 0, 0.91, 0, 0, 0, 0.78, 0, ...]
Vorteile:
  1. Interpretierbarkeit: Jede Dimension kann für ein klar erkennbares Konzept stehen.
  2. Effizienz bei Suche & Speicherung: Sparse Vektoren können komprimiert gespeichert und extrem schnell durchsucht werden ( bspw. für große Vektordatenbanken)
  3. Skalierbarkeit: skalieren besser bei vielen Dokumenten, da Indexstrukturen genutzt werden können

Anwendung von Embeddings

Erstellung eigener einfacher Embeddings mit Word2Vec

Zunächst müssen wir die Python Pakete gensim und nltk installieren:

pip install gensim nltk

Dann müssen wir noch die entsprechenden Pakete von NLTK downloaden:

from nltk.tokenize import word_tokenize
import nltk

nltk.download('punkt')
nltk.download('punkt_tab')

Nun erstellen wir einen Beispieltext den wir mit nltk in Tokens teilen:

# Beispieltexte
texts = [
    "Die Katze schläft auf der Couch.",
    "Der Hund bellt laut im Garten.",
    "Das Auto fährt schnell auf der Autobahn.",
    "Die Vögel singen ein Lied im Wald.",
    "Python ist eine großartige Programmiersprache."
]

# Tokenisierung (in Wörter zerlegen)
tokenized_texts = [word_tokenize(text.lower()) for text in texts]
print(tokenized_texts)

Das Word2Vec Modell können wir dann mit Gensim trainieren:

from gensim.models import Word2Vec

# Trainiere das Word2Vec-Modell
model = Word2Vec(
    sentences=tokenized_texts,  # Unsere tokenisierten Texte
    vector_size=50,             # Länge der Embedding-Vektoren
    window=3,                   # Kontextfenster (Anzahl der benachbarten Wörter)
    min_count=1,                # Minimale Häufigkeit eines Wortes
    workers=4,                  # Anzahl der CPU-Kerne
    sg=1                        # Skip-Gram-Algorithmus (1 = Skip-Gram, 0 = CBOW)
)

# Speichere das Modell, falls nötig
model.save("simple_embedding_model.model")

Embeddings anzeigen lassen:

# Beispiel: Vektor für das Wort "katze"
word = "katze"
if word in model.wv:  # Überprüfen, ob das Wort im Vokabular ist
    print(f"Embedding für '{word}':\n{model.wv[word]}")
else:
    print(f"'{word}' ist nicht im Vokabular.")

Ähnlichkeiten ermitteln:

# Ähnlichkeit zwischen zwei Wörtern
similarity = model.wv.similarity("katze", "hund")
print(f"Ähnlichkeit zwischen 'katze' und 'hund': {similarity:.2f}")

# Ähnliche Wörter finden
similar_words = model.wv.most_similar("katze", topn=3)
print(f"Ähnliche Wörter zu 'katze': {similar_words}")

Vortrainierte Embeddings verwenden

Huggingface

Eine Vielzahl an vortrainierten Modellen für Embeddings finden sich auf Huggingface. In diesem Beispiel verwenden wir das Modell all-MiniLM-L6-v2 das auf der MiniLM-Architektur (Miniature Language Model) basiert. Es ist eine kleinere und effizientere Versino von BERT (Bidirectional Encoder Representations from Transformers). Dadurch das es weniger Parameter und Schichten verwendet ist es leicht und schnell auf einfachen Rechnern anwendbar.

all-MiniLM-L6-v2 hat 6 Encoder Schichten und 364-dimensionale Embeddings-Vektor. D.h. jede Eingabe wird auf einen Vektor mit 384 Zahlen reduziert. Es ist speziell für semantische Ähnlichkeiten trainiert.

Verwendung in Python:

from sentence_transformers import SentenceTransformer, util

# Lade ein vortrainiertes Modell (z. B. 'all-MiniLM-L6-v2')
model = SentenceTransformer('all-MiniLM-L6-v2')

# Beispiel-Daten
documents = [
    "Ich liebe es, in den Alpen zu wandern.",
    "Python ist eine großartige Programmiersprache.",
    "Kaffee ist mein Lieblingsgetränk.",
    "Das Wetter in Italien ist fantastisch."
]

# Generiere Embeddings für die Dokumente
document_embeddings = model.encode(documents, convert_to_tensor=True)

# Suchanfrage
query = "Was ist eine gute Programmiersprache?"
query_embedding = model.encode(query, convert_to_tensor=True)

# Berechne die Ähnlichkeit
similarities = util.cos_sim(query_embedding, document_embeddings)

# Finde das ähnlichste Dokument
best_match_index = similarities.argmax().item()
print(f"Beste Übereinstimmung: {documents[best_match_index]}")

Vertex AI

Zunächst in der Google Cloud Shell anmelden:

gcloud auth login

Zunächst ist es notwendig die entsprechenden Pakete zu Vertex AI:

pip install vertexai

Bibliotheken importieren:

# Importiere Vertex AI-Bibliothek
import vertexai
from vertexai.language_models import TextEmbeddingModel
import numpy as np

Projekt konfigurieren:

# Vertex AI-Konfiguration
PROJECT_ID = "vertex2025"
REGION = "us-central1"
MODEL_ID = "text-embedding-005"

Embeddings laden:

# Lade das Embedding-Modell
model = TextEmbeddingModel.from_pretrained(MODEL_ID)

Beispieldaten

# Beispiel-Daten
documents = [
    "Ich liebe es, in den Alpen zu wandern.",
    "Python ist eine großartige Programmiersprache.",
    "Kaffee ist mein Lieblingsgetränk.",
    "Das Wetter in Italien ist fantastisch."
]

Embeddings generieren:

# Embeddings generieren
embeddings = []
for doc in documents:
    response = model.get_embeddings([doc])
    embeddings.append(response[0].values)

Suchanfrage:

# Suchanfrage
query = "Was ist eine gute Programmiersprache?"
query_response = model.get_embeddings([query])  # Ohne 'content='
query_embedding = query_response[0].values

Berechnung der Ähnlichkeit mit Numpy:

# Berechne die Ähnlichkeit
def cosine_similarity(vec1, vec2):
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

Ergebnis ausgeben:

similarities = [cosine_similarity(query_embedding, emb) for emb in embeddings]
best_match_index = np.argmax(similarities)
print(f"Beste Übereinstimmung: {documents[best_match_index]}")

One-Shot Classifier

Mit nur wenigen Anpassungen im Code, kann man mit Embeddings auch einen One-Shot Classifier bauen. One-Shot Classifier können Texte zu Klassen zuordnen, auch wenn es für diese Klasse nur ein Beispiel gibt. Basis sind vortrainerte Embeddings, wodurch für die Klassifizierung lediglich die Ähnlichkeit der EIngabe zum bekannten Beispiel pro Klasse ermittelt wird.

Anpassungen im Code: Kategorien mit Beispielen festlegen:

# Beispiele für jede Klasse
categories = {
    "Sport": "Fußball ist ein spannender Sport.",
    "Technologie": "Künstliche Intelligenz verändert die Welt.",
    "Essen": "Pizza ist ein beliebtes italienisches Gericht."
}

Embeddings für jede Kategorie generieren:

# Generiere Embeddings für die Kategorien
category_embeddings = {}
for category, example in categories.items():
    response = model.get_embeddings([example])
    category_embeddings[category] = response[0].values

Optional könnte man auch mehrere Beispiele pro Kategorie liefern. 

music_examples  = ["Musik ist irgendwas mit Noten.", "Um Musik zu spielen benötigt man ein Instrument."]
category_embeddings["Musik"] = np.mean([model.get_embeddings([ex])[0].values for ex in music_examples], axis=0)

Neue Eingabe:

query = "Roboter und KI werden die Zukunft dominieren."

Embeddings für die Eingabe erstellen:

# Generiere Embedding für die Eingabe
query_response = model.get_embeddings([query])
query_embedding = query_response[0].values

Ähnlichkeiten berechnen zu jeder Kategorie:

similarities = {
    category: cosine_similarity(query_embedding, embedding)
    for category, embedding in category_embeddings.items()
}

Optional: Filter der nur Ähnlichkeiten über einem bestimmten Wert ausgibt.

if max(similarities.values()) < 0.7:
    print("Keine ausreichende Ähnlichkeit zu einer Kategorie.")

Kategorie mit bester Übereinstimmung ausgeben:

# Finde die beste Übereinstimmung
best_category = max(similarities, key=similarities.get)
print(f"Die Eingabe gehört zur Kategorie: {best_category}")

Weiterführende Links

Mikolov et al. (2013) – Word2Vec Paper (Google)

Devlin et al. (2018) – BERT: Pre-training of Deep Bidirectional Transformers

OpenAI Embeddings Dokumentation

Sentence Transformers Paper (Reimers & Gurevych, 2019)

The Illustrated Word2Vec (Jay Alammar)

Das könnte dich auch interessieren

Metriken zur Modellbewertung

Konfidenzintervalle

Explainable A.I. – SHAP