> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/embeddinggemma-2.md).

# EmbeddingGemma 2 - Lokal ausführen

Führen Sie EmbeddingGemma 2 lokal aus und feinabstimmen Sie das Modell mit Unsloth.

**EmbeddingGemma 2** ist Googles neues Einbettungsmodell für Text, Code, Bilder, Video und Audio. Das Modell hat **740 Mio. Parameter**, und kombiniert ein **270M** Parameter **text** Modell mit modularen **Vision (170M)** und **Audio (300M)** Encodern. Es unterstützt eine Apache-2.0-Lizenz, **100+ Sprachen** und ein **8K-Kontextfenster** für Aufgaben wie semantische Suche, RAG und Klassifikation. Nur für Text und Code kannst du das kleinere **270M-Textmodell**.

Du kannst EmbeddingGemma 2 lokal ausführen über unseren **GGUFs** mit [**Unsloth Desktop**](#use-embeddinggemma-2-in-unsloth-desktop) oder sogar **das Modell feinabstimmen** über Unsloth. [**embeddinggemma-2-GGUF**](https://huggingface.co/unsloth/embeddinggemma-2-GGUF)

<a href="/docs/de/modelle/embeddinggemma-2.md#use-embeddinggemma-2-in-unsloth-desktop" class="button primary">Anleitung zum Ausführen von EmbeddingGemma 2</a><a href="/docs/de/modelle/embeddinggemma-2.md#fine-tune-embeddinggemma-2-with-unsloth" class="button secondary">Anleitung zum Fine-Tuning</a>

### ⚙️ Gebrauchsanleitung

| Funktion               | EmbeddingGemma 2                                                                                                      |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------- |
| Parameter              | <p>insgesamt 740M (du kannst auswählen, welche du verwenden möchtest):</p><p>270M Text + 170M Vision + 300M Audio</p> |
| Eingaben               | Text, Code, Bilder, Video, Audio und gemischte Eingaben                                                               |
| Kontextlänge           | 8.192 Tokens, gemeinsam für alle Eingaben                                                                             |
| Einbettungsdimensionen | 768, 512, 256 oder 128                                                                                                |

#### Empfohlene Einstellungen

* **Präzision:** BF16 auf unterstützter Hardware, sonst FP32.
* **Dimensionen:** Beginne mit **768**. Verwenden Sie **512 oder 256** um den Vektorspeicher zu reduzieren; bewerte **128** für Text-Workloads.
* **Normalisierung:** L2-normalisiere Vektoren, auch nachdem du sie gekürzt hast.
* **Prompts:** Verwende einen Such-Prompt für Anfragen und eine Dokumentenformatierung für den Inhalt, den du indexierst.

{% hint style="warning" %}
**Verwende kein FP16.** EmbeddingGemma 2 kann in FP16 NaN-Werte oder verschlechterte Embeddings erzeugen. Verwende BF16 oder FP32, einschließlich eines kompatiblen Compute-Dtypes beim Laden quantisierter Gewichte.
{% endhint %}

### Anleitung zum Ausführen von EmbeddingGemma 2

<a href="/docs/de/modelle/embeddinggemma-2.md#use-embeddinggemma-2-in-unsloth-desktop" class="button primary">Unsloth-Desktop-Tutorial</a><a href="/pages/ff1465ef25eb18adf9dfda37fefb6bfeb1d9b16c#run-embeddinggemma-2-ggufs-in-llama.cpp" class="button secondary">Llama.cpp-Tutorial</a>

#### 🦥 Verwende EmbeddingGemma 2 in Unsloth Desktop

Verwende EmbeddingGemma 2, um deine Dokumente lokal zu indexieren und zu durchsuchen auf **macOS, Windows und Linux**.

{% stepper %}
{% step %}

#### Unsloth installieren

Der einfachste Einstieg ist das Herunterladen der [Unsloth-Desktop-App](/docs/de/desktop.md). Funktioniert auf [macOS](/docs/de/loslegen/install/mac.md), [Windows](/docs/de/loslegen/install/windows-installation.md), und [Linux](/docs/de/loslegen/install/linux.md).

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Unsloth herunterladen</a>

* <i class="fa-apple">:apple:</i> [Für macOS herunterladen](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Für Windows herunterladen](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Für Linux herunterladen](https://unsloth.ai/download/linux)

Oder, wenn du lieber manuell installieren möchtest:

macOS, Linux, WSL:

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

Windows PowerShell:

```bash
irm https://unsloth.ai/install.ps1 | iex
```

{% endstep %}

{% step %}

#### Durchsuche das Einbettungsmodell

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FA5YLVJdX7p1jXPhQ7MMr%2Fimage.png?alt=media&amp;token=b32b20b1-3c65-4c0e-b561-93f66eb30e60" alt="" width="563"><figcaption></figcaption></figure></div>

In **Einstellungen**, öffne **Allgemein** und scrolle zu **Dokumente & RAG**. Wähle **EmbeddingGemma 2** aus dem **Einbettungsmodell** -Dropdown, dann klicke **Herunterladen** falls nötig.

Du kannst bei Bedarf auch unseren GGUF-Upload verwenden.
{% endstep %}

{% step %}

#### Füge deine Dokumente hinzu

<div data-with-frame="true"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fo3Mu42tY5xZ9XtitMgSq%2Fimage.png?alt=media&amp;token=823216c4-1d79-432e-b428-dacc76497fc7" alt="" width="563"><figcaption></figcaption></figure></div>

Öffne einen Chat, klicke **+**, und aktiviere **Mit Dateien chatten**. Klicke dann **Dateien zum Chat hinzufügen mit** und wähle deine Dokumente aus.

Unsloth verwendet dein ausgewähltes Einbettungsmodell, um die Dokumente durchsuchbar zu machen.

{% hint style="info" %}
Das Ändern des Einbettungsmodells betrifft nur neu indexierte Dokumente. Lade vorhandene Dokumente erneut hoch, um das neue Modell zu verwenden.
{% endhint %}
{% endstep %}
{% endstepper %}

Für weitere Möglichkeiten, EmbeddingGemma 2 mit Unsloth auszuführen, folge den **Python** oder **GGUF** Anleitungen unten.

### 📓 Probiere unsere Notebooks aus

Führe EmbeddingGemma 2 in Google Colab mit unseren Schritt-für-Schritt-Notebooks aus und trainiere es.

| Notebook                                                                                                                                          | Was du tun kannst                                                                   |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| [Multimodale Suche](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29-Multimodal_Search.ipynb) | Probiere die Suche über Text, Bilder, Video und Audio aus.                          |
| [Text-Finetuning](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29.ipynb)                     | Finetune Text-Embeddings für deine Daten.                                           |
| [Bild-Text-Finetuning](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29-Image_Text.ipynb)     | Trainiere mit Bildern und Bildunterschriften und vergleiche dann die Abrufqualität. |
| [Audio-Finetuning](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29-Audio.ipynb)              | Trainiere mit Audio und Bildunterschriften und vergleiche dann die Abrufqualität.   |

#### 🦙 Führe EmbeddingGemma 2 GGUFs in llama.cpp aus

Führe EmbeddingGemma 2 lokal aus mit [Unsloth GGUFs](https://huggingface.co/unsloth/embeddinggemma-2-GGUF). Verwende einen llama.cpp-Build, der [EmbeddingGemma-2-Unterstützung](https://github.com/ggml-org/llama.cpp/pull/30054)enthält; die folgenden Befehle erstellen den neuesten Quellcode für Text- und Code-Embeddings.

{% stepper %}
{% step %}
**llama.cpp erstellen und dein GGUF herunterladen**

Installiere Git, CMake und einen C++-Compiler, und führe dann diese Befehle in einem neuen Arbeitsverzeichnis aus. Sie erstellen die neueste llama.cpp-Quelle und laden Unsloths 176 MB großes UD-Q4\_K\_XL-GGUF herunter:

```bash
git clone https://github.com/ggml-org/llama.cpp.git
cmake -S llama.cpp -B llama.cpp/build -DCMAKE_BUILD_TYPE=Release
cmake --build llama.cpp/build --config Release -j 8 --target llama-server

pip install -U huggingface_hub

hf download unsloth/embeddinggemma-2-GGUF embeddinggemma-2-UD-Q4_K_XL.gguf \\
  --local-dir embeddinggemma2-gguf
```

{% endstep %}

{% step %}
**Embeddings-Server starten**

Dieses Beispiel stellt **Text- und Code-Embeddings** bereit, beginnend mit einem 2.048-Token-Kontext:

```bash
./llama.cpp/build/bin/llama-server \\
  --model "embeddinggemma2-gguf/embeddinggemma-2-UD-Q4_K_XL.gguf" \\
  --alias embeddinggemma2 \\
  --embeddings \\
  --pooling mean \\
  --ctx-size 2048 \\
  --batch-size 2048 \\
  --ubatch-size 2048 \\
  --parallel 1 \\
  --host 127.0.0.1 \\
  --port 8080
```

Für Eingaben mit mehr als 2.048 Tokens erhöhe `--ctx-size`, `--batch-size` und `--ubatch-size` zusammen, bis zu `8192`. Jede Eingabe muss in eine einzige physische Batch passen.
{% endstep %}

{% step %}
**Embeddings anfordern**

Füge die Aufgabenpräfixe selbst hinzu, wenn du die API aufrufst:

```bash
curl http://127.0.0.1:8080/v1/embeddings \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "embeddinggemma2",
    "input": [
      "task: search result | query: Wie setze ich mein Passwort zurück?",
      "title: none | text: Wähle „Passwort vergessen“, um einen Zurücksetzungslink zu erhalten."
    ],
    "encoding_format": "float"
  }'
```

Der Embeddings-Endpunkt gibt normalisierte Vektoren zurück. Prüfe, dass jeder Vektor 768 endliche Werte hat, bevor du deinen Index erstellst.
{% endstep %}
{% endstepper %}

{% hint style="info" %}
Verwende ein GGUF und eine Laufzeit, die EmbeddingGemma 2s gelernte Embedding-Projektion beibehält. Für Bilder, Video oder Audio verwende eine Laufzeit mit expliziter Unterstützung für diese Encoder und deren Prozessordateien. Der obige Befehl deckt Text-Embeddings ab.
{% endhint %}

### 🛠️ Fine-tune EmbeddingGemma 2 mit Unsloth

Finetuning kann die Suche für deine Dokumente, deinen Code und deine Terminologie verbessern. Trainiere mit Paaren aus Fragen und relevanten Dokumenten und vergleiche dann Suchergebnisse vor und nach dem Training.

Führe EmbeddingGemma 2 in Google Colab mit unseren kostenlosen Schritt-für-Schritt-Notebooks aus und trainiere es.

| Notebook                                                                                                                                          | Was du tun kannst                                                                   |
| ------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
| [Multimodale Suche](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29-Multimodal_Search.ipynb) | Probiere die Suche über Text, Bilder, Video und Audio aus.                          |
| [Text-Finetuning](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29.ipynb)                     | Finetune Text-Embeddings für deine Daten.                                           |
| [Bild-Text-Finetuning](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29-Image_Text.ipynb)     | Trainiere mit Bildern und Bildunterschriften und vergleiche dann die Abrufqualität. |
| [Audio-Finetuning](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/EmbeddingGemma2_%28300M%29-Audio.ipynb)              | Trainiere mit Audio und Bildunterschriften und vergleiche dann die Abrufqualität.   |

#### Modell vorbereiten

Speichere das Textmodell aus dem Python-Beispiel:

```python
text_model.save_pretrained("embeddinggemma2-text")
```

Starte eine frische Python-Sitzung und importiere zuerst Unsloth. Lade das gespeicherte Modell in 4-Bit und füge LoRA-Adapter für das Training hinzu:

```python
from unsloth import FastSentenceTransformer
import torch

model = FastSentenceTransformer.from_pretrained(
    model_name = "embeddinggemma2-text",
    max_seq_length = 1024,
    dtype = torch.bfloat16,
    load_in_4bit = True,
    load_in_16bit = False,
    full_finetuning = False,
)

model = FastSentenceTransformer.get_peft_model(
    model,
    r = 16,
    target_modules = [
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha = 32,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = "unsloth",
    random_state = 3407,
    task_type = "FEATURE_EXTRACTION",
)
```

#### Trainieren und evaluieren

Folge unserem [Leitfaden zum Einbetten-Finetuning](https://unsloth.ai/docs/basics/embedding-finetuning) um deinen Datensatz vorzubereiten und `SentenceTransformerTrainer`.

* Wende die Präfixe für Anfrage und Dokument nur einmal an, wie im Python-Suchbeispiel.
* Beginne mit `MultipleNegativesRankingLoss` und einem Batch-Sampler, der Duplikate vermeidet.
* Setzen Sie `bf16=True` und `fp16=False`.
* Teste die Suchqualität mit Anfragen, die du vom Training ausgeschlossen hast.

Das **EmbeddingGemma-300M-Notebook** deckt das frühere Modell ab. Verwende es als Workflow-Referenz.

#### Speichere deine Adapter

Speichere nach dem Training die LoRA-Adapter:

```python
model.save_pretrained("embeddinggemma2-lora")
```

Siehe den verlinkten Leitfaden zum Zusammenführen von Adaptern zu einem eigenständigen Modell. Das Training auf Bildern, Video oder Audio erfordert einen separaten Workflow.

### 🚀 Führe EmbeddingGemma 2 in Python aus

Dieses Beispiel durchsucht drei Dokumente und ordnet sie danach, wie gut sie zu deiner Frage passen. Es lädt nur das Textmodell, um Speicher zu sparen.

Installiere SentenceTransformers und Transformers mit EmbeddingGemma-2-Unterstützung:

```bash
pip install -U sentence-transformers transformers
```

Das Beispiel wählt automatisch dein Gerät und eine unterstützte Präzision aus.

```python
import torch
from sentence_transformers import SentenceTransformer

device = "cuda" if torch.cuda.is_available() else "cpu"
dtype = (
    torch.bfloat16
    if device == "cuda" and torch.cuda.is_bf16_supported()
    else torch.float32
)

text_model = SentenceTransformer(
    "unsloth/embeddinggemma-2",
    device = device,
    model_kwargs = {"torch_dtype": dtype},
    config_kwargs = {"vision_config": None, "audio_config": None},
)

Wie setze ich mein Passwort zurück?
[
    "Wähle auf der Anmeldeseite „Passwort vergessen“, um einen Zurücksetzungslink zu erhalten.",
    "Aktualisiere deine Rechnungsdaten auf der Seite mit den Kontoeinstellungen.",
    "Aktiviere die Zwei-Faktor-Authentifizierung, um dein Konto zu schützen.",
]
embedding_dim

query_embedding = text_model.encode(
    [query],
    prompt_name = "SearchQuery",
    truncate_dim = embedding_dim,
    normalize_embeddings = True,
)
document_embeddings = text_model.encode(
    documents,
    prompt_name = "Document",
    truncate_dim = embedding_dim,
    normalize_embeddings = True,
)

scores = text_model.similarity(query_embedding, document_embeddings)[0]
for idx in scores.argsort(descending = True).tolist():
    print(f"{scores[idx].item():.4f} | {documents[idx]}")
```

Höhere Werte bedeuten eine bessere Übereinstimmung. Ersetze die Frage und die Dokumente durch deine eigenen Inhalte.

#### Passe deine Embeddings an

**Speicherplatz sparen:** Setzen Sie `embedding_dim` zu **256** um ein Drittel des Embedding-Speichers zu verwenden, mit etwas Verlust bei der Suchgenauigkeit. Verwende für Anfragen und Dokumente dieselbe Dimension.

**Wähle einen Prompt:** Das Beispiel verwendet `SearchQuery` für die Frage und `Document` für durchsuchbare Inhalte. Für Code-Suchen verwende `CodeRetrieval` für die Anfrage. Um zwei Texte auf Ähnlichkeit zu vergleichen, verwende `SentenceSimilarity` für beide.

### 🖼️ Bette Bilder, Video und Audio ein

Kombiniere Text und Medien zu einem durchsuchbaren Element. Dieses Beispiel erstellt eine einzelne Einbettung für eine Produktbeschreibung, zwei Fotos und ein Video.

Führe es nach dem obigen Setup aus und ersetze die Dateinamen durch deine eigenen Dateien. Deine Installation benötigt außerdem die Bild- und Video-Abhängigkeiten des Modellprozessors.

```python
multimodal_model = SentenceTransformer(
    "unsloth/embeddinggemma-2",
    device = device,
    model_kwargs = {"torch_dtype": dtype},
    config_kwargs = {"audio_config": None},
)

listing_embedding = multimodal_model.encode(
    {
        "text": "Trailrunning-Schuhe. <|image|> Mesh-Obermaterial. <|image|> Grip-Test: <|video|>",
        "image": ["shoe.jpg", "mesh.jpg"],
        "video": "demo.mp4",
    },
    prompt = "",
    normalize_embeddings = True,
)
```

Ersetze die Dateinamen durch deine eigenen Bilder und dein eigenes Video und behalte dabei die Platzhalter in derselben Reihenfolge. Das Modell kombiniert sie zu einer einzigen Einbettung, die du mit Text durchsuchen kannst.

{% hint style="info" %}
Audio ist deaktiviert, um Speicher zu sparen. Um es einzuschließen, entferne `config_kwargs` und füge ein `Audio` Eingabe mit einem `<|audio|>` Platzhalter hinzu. Verwende Mono-Audio mit 16 kHz.
{% endhint %}

Text und Medien teilen sich das **8K-Kontextlimit**. Bilder, Video und Audio benötigen keine Aufgabenpräfixe.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/modelle/embeddinggemma-2.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
