Einbettungen mit Sentence Transformers generieren

Auf ai.google.dev ansehen In Google Colab ausführen In Kaggle ausführen In Vertex AI öffnen Quelle auf GitHub ansehen

EmbeddingGemma ist ein einfaches, offenes Embedding-Modell, das für schnelles, hochwertiges Abrufen auf Alltagsgeräten wie Smartphones entwickelt wurde. Mit nur 308 Millionen Parametern ist es effizient genug, um fortschrittliche KI-Techniken wie Retrieval-Augmented Generation (RAG) direkt auf Ihrem lokalen Computer auszuführen, ohne dass eine Internetverbindung erforderlich ist.

Einrichtung

Führen Sie die folgenden Schritte aus, bevor Sie mit dieser Anleitung beginnen:

  • Sie erhalten Zugriff auf Gemma, indem Sie sich bei Hugging Face anmelden und für ein Gemma-Modell Lizenz bestätigen auswählen.
  • Generieren Sie ein Hugging Face-Zugriffstoken und verwenden Sie es, um sich über Colab anzumelden.

Dieses Notebook kann entweder auf der CPU oder der GPU ausgeführt werden.

Python-Pakete installieren

Installieren Sie die Bibliotheken, die zum Ausführen des EmbeddingGemma-Modells und zum Generieren von Einbettungen erforderlich sind. Sentence Transformers ist ein Python-Framework für Text- und Bildeinbettungen. Weitere Informationen finden Sie in der Dokumentation zu Sentence Transformers.

pip install -U sentence-transformers git+https://github.com/huggingface/transformers@v4.56.0-Embedding-Gemma-preview

Nachdem Sie die Lizenz akzeptiert haben, benötigen Sie ein gültiges Hugging Face-Token, um auf das Modell zuzugreifen.

# Login into Hugging Face Hub
from huggingface_hub import login
login()

Modell laden

Verwenden Sie die sentence-transformers-Bibliotheken, um eine Instanz einer Modellklasse mit EmbeddingGemma zu erstellen.

import torch
from sentence_transformers import SentenceTransformer

device = "cuda" if torch.cuda.is_available() else "cpu"

model_id = "google/embeddinggemma-300M"
model = SentenceTransformer(model_id).to(device=device)

print(f"Device: {model.device}")
print(model)
print("Total number of parameters in the model:", sum([p.numel() for _, p in model.named_parameters()]))

Device: cuda:0
SentenceTransformer(
  (0): Transformer({'max_seq_length': 2048, 'do_lower_case': False, 'architecture': 'Gemma3TextModel'})
  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
  (2): Dense({'in_features': 768, 'out_features': 3072, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
  (3): Dense({'in_features': 3072, 'out_features': 768, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
  (4): Normalize()
)
Total number of parameters in the model: 307581696

Einbettung wird generiert

Eine Einbettung ist eine numerische Darstellung von Text, z. B. einem Wort oder Satz, die seine semantische Bedeutung erfasst. Im Grunde ist es eine Liste von Zahlen (ein Vektor), die es Computern ermöglicht, die Beziehungen und den Kontext von Wörtern zu verstehen.

Sehen wir uns an, wie EmbeddingGemma drei verschiedene Wörter verarbeiten würde ["apple", "banana", "car"].

EmbeddingGemma wurde mit riesigen Textmengen trainiert und hat die Beziehungen zwischen Wörtern und Konzepten gelernt.

words = ["apple", "banana", "car"]

# Calculate embeddings by calling model.encode()
embeddings = model.encode(words)

print(embeddings)
for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1} (shape): {embedding.shape}")

[[-0.18476306  0.00167681  0.03773484 ... -0.07996225 -0.02348064
   0.00976741]
 [-0.21189538 -0.02657359  0.02513712 ... -0.08042689 -0.01999852
   0.00512146]
 [-0.18924113 -0.02551468  0.04486253 ... -0.06377774 -0.03699806
   0.03973572]]
Embedding 1: (768,)
Embedding 2: (768,)
Embedding 3: (768,)

Das Modell gibt für jeden Satz einen numerischen Vektor aus. Die tatsächlichen Vektoren sind sehr lang (768), aber zur Vereinfachung werden sie mit einigen wenigen Dimensionen dargestellt.

Der Schlüssel sind nicht die einzelnen Zahlen selbst, sondern der Abstand zwischen den Vektoren. Wenn wir diese Vektoren in einem mehrdimensionalen Raum darstellen würden, lägen die Vektoren für apple und banana sehr nahe beieinander. Der Vektor für car wäre weit von den beiden anderen entfernt.

Ähnlichkeit ermitteln

In diesem Abschnitt verwenden wir Einbettungen, um zu ermitteln, wie semantisch ähnlich verschiedene Sätze sind. Hier sehen Sie Beispiele mit hohen, mittleren und niedrigen Ähnlichkeitswerten.

  • Hohe Ähnlichkeit:

    • Satz A: „Der Koch hat ein köstliches Gericht für die Gäste zubereitet.“
    • Satz B: „Ein leckeres Abendessen wurde vom Koch für die Besucher zubereitet.“
    • Begründung: Beide Sätze beschreiben dasselbe Ereignis mit unterschiedlichen Wörtern und grammatischen Strukturen (Aktiv vs. Passiv). Sie vermitteln dieselbe Kernbedeutung.

  • Mittlere Ähnlichkeit:

    • Satz A: „Sie ist eine Expertin für maschinelles Lernen.“
    • Satz B: „Er hat ein großes Interesse an künstlicher Intelligenz.“
    • Begründung: Die Sätze sind miteinander verbunden, da maschinelles Lernen ein Teilgebiet der künstlichen Intelligenz ist. Es geht jedoch um unterschiedliche Personen mit unterschiedlichem Engagement (Experte vs. Interessent).

  • Geringe Ähnlichkeit:

    • Satz A: „Das Wetter in Tokio ist heute sonnig.“
    • Satz B: „Ich muss für die Woche Lebensmittel kaufen.“
    • Begründung: Die beiden Sätze beziehen sich auf völlig unterschiedliche Themen und haben keine semantische Überschneidung.
# The sentences to encode
sentence_high = [
    "The chef prepared a delicious meal for the guests.",
    "A tasty dinner was cooked by the chef for the visitors."
]
sentence_medium = [
    "She is an expert in machine learning.",
    "He has a deep interest in artificial intelligence."
]
sentence_low = [
    "The weather in Tokyo is sunny today.",
    "I need to buy groceries for the week."
]

for sentence in [sentence_high, sentence_medium, sentence_low]:
  print("🙋‍♂️")
  print(sentence)
  embeddings = model.encode(sentence)
  similarities = model.similarity(embeddings[0], embeddings[1])
  print("`-> 🤖 score: ", similarities.numpy()[0][0])

🙋‍♂️
['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']
`-> 🤖 score:  0.8002148
🙋‍♂️
['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']
`-> 🤖 score:  0.45417833
🙋‍♂️
['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']
`-> 🤖 score:  0.22262995

Prompts mit EmbeddingGemma verwenden

Um die besten Einbettungen mit EmbeddingGemma zu generieren, sollten Sie dem Eingabetext einen „Anleitungsprompt“ oder eine „Aufgabe“ voranstellen. Mit diesen Prompts werden die Einbettungen für bestimmte Aufgaben wie den Dokumentabruf oder die Beantwortung von Fragen optimiert. Außerdem helfen sie dem Modell, zwischen verschiedenen Eingabetypen wie einer Suchanfrage und einem Dokument zu unterscheiden.

Prompts anwenden

Sie haben drei Möglichkeiten, einen Prompt während der Inferenz anzuwenden.

  1. Argument prompt verwenden
    Übergeben Sie den vollständigen Prompt-String direkt an die Methode encode. So haben Sie die genaue Kontrolle.

    embeddings = model.encode(
    sentence,
    prompt="task: sentence similarity | query: "
)

  2. Argument prompt_name verwenden
    Wählen Sie einen vordefinierten Prompt anhand des Namens aus. Diese Prompts werden aus der Konfiguration des Modells oder während der Initialisierung geladen.

    embeddings = model.encode(sentence, prompt_name="STS")

  3. Standard-Prompt verwenden
    Wenn Sie weder prompt noch prompt_name angeben, wird automatisch der als default_prompt_name festgelegte Prompt verwendet. Wenn kein Standard-Prompt festgelegt ist, wird kein Prompt angewendet.

    embeddings = model.encode(sentence)

print("Available tasks:")
for name, prefix in model.prompts.items():
  print(f" {name}: \"{prefix}\"")
print("-"*80)

for sentence in [sentence_high, sentence_medium, sentence_low]:
  print("🙋‍♂️")
  print(sentence)
  embeddings = model.encode(sentence, prompt_name="STS")
  similarities = model.similarity(embeddings[0], embeddings[1])
  print("`-> 🤖 score: ", similarities.numpy()[0][0])

Available tasks:
 query: "task: search result | query: "
 document: "title: none | text: "
 BitextMining: "task: search result | query: "
 Clustering: "task: clustering | query: "
 Classification: "task: classification | query: "
 InstructionRetrieval: "task: code retrieval | query: "
 MultilabelClassification: "task: classification | query: "
 PairClassification: "task: sentence similarity | query: "
 Reranking: "task: search result | query: "
 Retrieval: "task: search result | query: "
 Retrieval-query: "task: search result | query: "
 Retrieval-document: "title: none | text: "
 STS: "task: sentence similarity | query: "
 Summarization: "task: summarization | query: "
--------------------------------------------------------------------------------
🙋‍♂️
['The chef prepared a delicious meal for the guests.', 'A tasty dinner was cooked by the chef for the visitors.']
`-> 🤖 score:  0.9363755
🙋‍♂️
['She is an expert in machine learning.', 'He has a deep interest in artificial intelligence.']
`-> 🤖 score:  0.6425841
🙋‍♂️
['The weather in Tokyo is sunny today.', 'I need to buy groceries for the week.']
`-> 🤖 score:  0.38587403

Anwendungsfall: Retrieval-Augmented Generation (RAG)

Verwenden Sie für RAG-Systeme die folgenden prompt_name-Werte, um spezielle Einbettungen für Ihre Anfragen und Dokumente zu erstellen:

  • Für Anfragen:Verwenden Sie prompt_name="Retrieval-query".

    query_embedding = model.encode(
    "How do I use prompts with this model?",
    prompt_name="Retrieval-query"
)

  • Für Dokumente:Verwenden Sie prompt_name="Retrieval-document". Um die Dokument-Embeddings weiter zu verbessern, können Sie auch einen Titel angeben, indem Sie das Argument prompt direkt verwenden:

    • Mit Titel:
    doc_embedding = model.encode(
    "The document text...",
    prompt="title: Using Prompts in RAG | text: "
)
    • Ohne Titel:
    doc_embedding = model.encode(
    "The document text...",
    prompt="title: none | text: "
)

Weiterführende Literatur

Klassifizierung

Bei der Klassifizierung wird einem Textabschnitt eine oder mehrere vordefinierte Kategorien oder Labels zugewiesen. Sie ist eine der grundlegendsten Aufgaben im Bereich Natural Language Processing (NLP).

Eine praktische Anwendung der Textklassifizierung ist das Weiterleiten von Kundensupporttickets. Bei diesem Prozess werden Kundenanfragen automatisch an die richtige Abteilung weitergeleitet, was Zeit spart und den manuellen Aufwand reduziert.

labels = ["Billing Issue", "Technical Support", "Sales Inquiry"]

sentence = [
  "Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password.",
  "I would like to inquire about your enterprise plan pricing and features for a team of 50 people.",
]

# Calculate embeddings by calling model.encode()
label_embeddings = model.encode(labels, prompt_name="Classification")
embeddings = model.encode(sentence, prompt_name="Classification")

# Calculate the embedding similarities
similarities = model.similarity(embeddings, label_embeddings)
print(similarities)

idx = similarities.argmax(1)
print(idx)

for example in sentence:
  print("🙋‍♂️", example, "-> 🤖", labels[idx[sentence.index(example)]])

tensor([[0.4673, 0.5145, 0.3604],
        [0.4191, 0.5010, 0.5966]])
tensor([1, 2])
🙋‍♂️ Excuse me, the app freezes on the login screen. It won't work even when I try to reset my password. -> 🤖 Technical Support
🙋‍♂️ I would like to inquire about your enterprise plan pricing and features for a team of 50 people. -> 🤖 Sales Inquiry

Matryoshka Representation Learning (MRL)

EmbeddingGemma nutzt MRL, um mehrere Einbettungsgrößen aus einem Modell bereitzustellen. Diese intelligente Trainingsmethode erstellt eine einzelne, hochwertige Einbettung, bei der die wichtigsten Informationen am Anfang des Vektors konzentriert sind.

Das bedeutet, dass Sie eine kleinere, aber dennoch sehr nützliche Einbettung erhalten können, indem Sie einfach die ersten N Dimensionen der vollständigen Einbettung verwenden. Kleinere, gekürzte Einbettungen sind deutlich günstiger zu speichern und schneller zu verarbeiten. Diese Effizienz geht jedoch auf Kosten der potenziell geringeren Qualität der Einbettungen. Mit MRL können Sie das optimale Gleichgewicht zwischen Geschwindigkeit und Genauigkeit für die spezifischen Anforderungen Ihrer Anwendung wählen.

Wir verwenden drei Wörter ["apple", "banana", "car"] und erstellen vereinfachte Einbettungen, um zu sehen, wie MRL funktioniert.

def check_word_similarities():
  # Calculate the embedding similarities
  print("similarity function: ", model.similarity_fn_name)
  similarities = model.similarity(embeddings[0], embeddings[1:])
  print(similarities)

  for idx, word in enumerate(words[1:]):
    print("🙋‍♂️ apple vs.", word, "-> 🤖 score: ", similarities.numpy()[0][idx])

# Calculate embeddings by calling model.encode()
embeddings = model.encode(words, prompt_name="STS")

check_word_similarities()

similarity function:  cosine
tensor([[0.7510, 0.6685]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.75102395
🙋‍♂️ apple vs. car -> 🤖 score:  0.6684626

Für eine schnellere Anwendung benötigen Sie jetzt kein neues Modell mehr. Kürzen Sie die vollständigen Einbettungen einfach auf die ersten 512 Dimensionen. Für optimale Ergebnisse empfiehlt es sich außerdem, normalize_embeddings=True festzulegen, wodurch die Vektoren auf eine Einheitslänge von 1 skaliert werden.

embeddings = model.encode(words, truncate_dim=512, normalize_embeddings=True)

for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1}: {embedding.shape}")

print("-"*80)
check_word_similarities()

Embedding 1: (512,)
Embedding 2: (512,)
Embedding 3: (512,)
--------------------------------------------------------------------------------
similarity function:  cosine
tensor([[0.7674, 0.7041]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.767427
🙋‍♂️ apple vs. car -> 🤖 score:  0.7040509

In Umgebungen mit extrem eingeschränkten Ressourcen können Sie die Einbettungen auf nur 256 Dimensionen verkürzen. Sie können für Ähnlichkeitsberechnungen auch das effizientere Punktprodukt anstelle der Standard-Kosinus-Ähnlichkeit verwenden.

model = SentenceTransformer(model_id, truncate_dim=256, similarity_fn_name="dot").to(device=device)
embeddings = model.encode(words, prompt_name="STS", normalize_embeddings=True)

for idx, embedding in enumerate(embeddings):
  print(f"Embedding {idx+1}: {embedding.shape}")

print("-"*80)
check_word_similarities()

Embedding 1: (256,)
Embedding 2: (256,)
Embedding 3: (256,)
--------------------------------------------------------------------------------
similarity function:  dot
tensor([[0.7855, 0.7382]])
🙋‍♂️ apple vs. banana -> 🤖 score:  0.7854644
🙋‍♂️ apple vs. car -> 🤖 score:  0.7382126

Zusammenfassung und nächste Schritte

Sie können jetzt hochwertige Texteinbettungen mit EmbeddingGemma und der Sentence Transformers-Bibliothek generieren. Wenden Sie diese Fähigkeiten an, um leistungsstarke Funktionen wie semantische Ähnlichkeit, Textklassifizierung und RAG-Systeme (Retrieval Augmented Generation) zu entwickeln, und erkunden Sie, was mit Gemma-Modellen alles möglich ist.

Lesen Sie als Nächstes die folgenden Dokumente: