> 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/diffusiongemma.md).
# DiffusionGemma - Lokal ausführen
DiffusionGemma **26B-A4B** ist Googles DeepMinds neues offenes **multimodal** Modell, aufgebaut auf der [Gemma 4](/docs/de/modelle/gemma-4.md) MoE-Architektur. Mit Unterstützung für **256K-Kontext**, **140+ Sprachen**, ist DiffusionGemma für **schnelle Textgenerierung** über Text-, Video- und Bildeingaben hinweg. DiffusionGemma kann lokal auf **18 GB RAM**, und [Fine-Tuning](#fine-tune-diffusiongemma) wird jetzt unterstützt über [Unsloth](https://github.com/unslothai/unsloth).
Anstelle des üblichen tokenweisen Decodings verwendet DiffusionGemma **Diffusionsgenerierung** um Ausgaben parallel zu erzeugen und sie schrittweise zu einer finalen Antwort zu verfeinern – ähnlich wie Diffusionsbildmodelle, aber für Text. Führen Sie das Modell via [Unsloth Studio](/docs/de/neu/studio.md) oder llama.cpp aus. Auf einer RTX 6000 kann DiffusionGemma **2000+ Token/s**. **GGUF:** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)
DiffusionGemma ausführenDiffusionGemma feinabstimmen
{% hint style="success" %}
**12. Juni:** Sie können DiffusionGemma jetzt via [Unsloth Studio](#unsloth-studio-guide) ✨ mit 1,8x schnellerer Inferenz!
{% endhint %}
### Nutzungsleitfaden
DiffusionGemma ist für Nutzer konzipiert, die schnellere Generierung als bei Standardmodellen benötigen. Es eignet sich für schnelle lokale Inferenz, Langkontext-Dokumentenanalyse, Bild-/Videoverständnis, OCR und Dokumentenparsing, Codegenerierung, Tool-Nutzung, agentische Workflows und Inferenz mit geringer Latenz bei kleinen Batches.
Anders als Standard-Gemma-4-Modelle erfordert DiffusionGemma eine diffusionsbewusste Inferenz-Laufzeitumgebung. Autoregressive Einstellungen wie `Temperatur`, `top_p`, und `top_k` allein reichen nicht aus, um das empfohlene Verhalten ohne den erforderlichen Diffusionssampler zu reproduzieren.
### Hardwareanforderungen
Im Allgemeinen ist es am besten, mindestens 18 GB RAM zu haben, um das Modell in 4-Bit-Präzision auszuführen. **GGUF:** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)
**Tabelle: Empfohlene Hardware-Anforderungen für DiffusionGemma Inference GGUF** (Einheiten = Gesamtspeicher: RAM + VRAM oder einheitlicher Speicher).
| 4-Bit | 5-Bit | 6-Bit | 8-Bit | BF16 / FP16 |
| ----- | ----- | ----- | ----- | ----------- |
| 18 GB | 20 GB | 24 GB | 28 GB | 52 GB |
{% hint style="info" %}
Als Faustregel sollte Ihr insgesamt verfügbarer Speicher mindestens die Größe des quantisierten Modells übersteigen, das Sie herunterladen. Falls nicht, können Sie es dennoch mit teilweisem RAM-/Datenträger-Offloading ausführen, aber die Generierung wird langsamer sein. Außerdem benötigen Sie je nach verwendetem Kontextfenster mehr Rechenleistung.
{% endhint %}
## Tutorials zum Ausführen von DiffusionGemma
Am besten mindestens 4-Bit-Präzision verwenden, daher verwenden wir das 4-Bit- `Q4_K_M` Quant, das 18 GB RAM benötigt. **GGUF:** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)
🦥 Unsloth Studio-Leitfaden🦙 Llama.cpp-Leitfaden
### 🦥 Unsloth Studio-Leitfaden
{% hint style="success" %}
Sie können DiffusionGemma jetzt via [Unsloth Studio](#unsloth-studio-guide) ✨. Stellen Sie sicher, dass Sie [`v0.1.463-beta`](https://github.com/unslothai/unsloth/tree/v0.1.462-beta) oder `2026.6.6`.
{% endhint %}
DiffusionGemma kann jetzt in [Unsloth Studio](/docs/de/neu/studio.md), unserer neuen Open-Source-Web-UI für lokale KI, ausgeführt und trainiert werden. Unsloth Studio ermöglicht es Ihnen, Modelle lokal auf **macOS**, **Windows**, Linux und:
{% columns %}
{% column %}
* Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle
* [**Selbstheilend** Tool-Aufrufe](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche**
* [**Codeausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash)
* [Automatische Inferenz](https://unsloth.ai/docs/desktop#feature-deep-dive) Abstimmung der Parameter (Temp., Top-p usw.)
* Schnelle CPU- + GPU-Inferenz über llama.cpp
* [LLMs trainieren](/docs/de/neu/studio.md#no-code-training) 2x schneller mit 70 % weniger VRAM
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% stepper %}
{% step %}
#### Unsloth installieren
Stelle sicher, dass du die neueste [`v0.1.463-beta`](https://github.com/unslothai/unsloth/tree/v0.1.462-beta) oder `2026.6.6`. Führe in deinem Terminal aus:
**macOS, Linux, WSL:**
```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```
**Windows PowerShell:**
```bash
irm https://unsloth.ai/install.ps1 | iex
```
{% endstep %}
{% step %}
#### Unsloth starten
**macOS, Linux, WSL und Windows:**
```bash
unsloth studio -H 0.0.0.0 -p 8888
```
Dann öffnen Sie `http://127.0.0.1:8888` (oder Ihre spezifische URL) in Ihrem Browser.
{% endstep %}
{% step %}
#### DiffusionGemma suchen und herunterladen
Beim ersten Start müssen Sie ein Passwort erstellen, um Ihr Konto zu sichern, und sich erneut anmelden.
Gehen Sie dann zum [Unsloth Chat](/docs/de/neu/studio/chat.md) Tab und suchen Sie in der Suchleiste nach DiffusionGemma und laden Sie Ihr gewünschtes Modell und Quant herunter.
{% endstep %}
{% step %}
#### DiffusionGemma ausführen
Die Inferenzparameter sollten bei der Verwendung von Unsloth Studio automatisch gesetzt werden, Sie können sie jedoch weiterhin manuell ändern. Sie können auch die Kontextlänge, das Chat-Template und andere Einstellungen bearbeiten.
Für weitere Informationen können Sie unseren [Inferenzleitfaden für Unsloth Studio](/docs/de/neu/studio/chat.md).
{% endstep %}
{% endstepper %}
### 🦙 Llama.cpp-Leitfaden
Für dieses Tutorial verwenden wir das dynamische 4-Bit- `Q4_K_M` Quant, das 18 GB RAM benötigt und [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp) für schnelle lokale Inferenz verwenden, besonders wenn Sie eine CPU haben.
{% stepper %}
{% step %}
Erhalte den spezifischen `llama.cpp` PR auf [**hier auf GitHub**](https://github.com/ggml-org/llama.cpp/pull/24423). Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. **Für Apple-Mac-/Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert.
```bash
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
gh pr checkout 24423
# mit CUDA bauen (für einen CPU-only-Build -DGGML_CUDA=ON weglassen)
cmake -B build -DGGML_CUDA=ON
cmake --build build -j --config Release --target llama-diffusion-cli
cd ..
```
{% endstep %}
{% step %}
Lade das Modell über (nach der Installation von `pip install huggingface_hub`). Sie können `Q4_K_M` oder andere quantisierte Versionen wie `Q8_0` . Falls Downloads hängen bleiben, siehe: [Hugging Face Hub, XET-Debugging](/docs/de/grundlagen/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)
```bash
pip install -U "huggingface_hub[cli]"
hf download unsloth/diffusiongemma-26B-A4B-it-GGUF \\
--local-dir unsloth/diffusiongemma-26B-A4B-it-GGUF \\
--include "*Q8_0*" # Verwenden Sie "*Q4_K_M*" für einen kleineren 16-GB-Download
```
{% endstep %}
{% endstepper %}
### Mit DiffusionGemma chatten
Dann führen Sie Folgendes aus:
{% code overflow="wrap" %}
```bash
./build/bin/llama-diffusion-cli \\
-m unsloth/diffusiongemma-26B-A4B-it-GGUF/diffusiongemma-26B-A4B-it-Q8_0.gguf \\
-ngl 99 -cnv -n 2048
```
{% endcode %}
Sie werden Folgendes sehen:
Und wenn Sie eine Frage wie „Create a Flappy Bird Game“ eingeben, sehen Sie die Schritte:
Danach sehen Sie die Ausgabe:
Sie können auch weiter chatten!
Ändere `-n 2048` als die Anzahl der Token, die Sie vorhersagen möchten, sodass mehr zu längeren Antworten führt.
### Live-Visualisierung der Diffusion
Um Diffusion live zu sehen, verwenden Sie das Folgende – aktivieren Sie speziell `--diffusion-visual`:
```bash
./build/bin/llama-diffusion-cli \\
-m unsloth/diffusiongemma-26B-A4B-it-GGUF/diffusiongemma-26B-A4B-it-Q8_0.gguf \\
-ngl 99 -cnv -n 2048 --diffusion-visual
```
Sie werden erneut sehen:
Und wir erhalten:
Alle Parameter für llama.cpp unter Verwendung des Branches:
* `-n, --n-predict N` - Ziel-Token; leitet `--diffusion-blocks` und wächst `-ub` / `-b` / `-c`.
* `-ngl 99` - alle Schichten auf die GPU auslagern (`-ngl 0` für nur CPU).
* `-cnv` - Mehrturn-Konversationsmodus.
* `--diffusion-visual` - Ansicht zur Live-Denoising-Canvas.
* Der Entropy-Bound-Sampler ist standardmäßig aktiviert (`--diffusion-eb auto`). Passen Sie ihn an mit `--diffusion-eb-max-steps` (Standard 48), `--diffusion-eb-t-max` / `--diffusion-eb-t-min` (0.8 -> 0.4), `--diffusion-eb-entropy-bound` (0,1) und `--diffusion-eb-confidence` (0.005).
* `--diffusion-kv-cache {auto,on,off}` - Prompt-Präfix-KV-Cache (auto = an für eine einzelne GPU).
## DiffusionGemma feinabstimmen
Sie können DiffusionGemma jetzt direkt mit [**Unsloth**](#unsloth-studio-guide). In unserem Beispiel zeigen wir die Auswirkungen domänenspezifischen Trainings, indem wir das Modell auf Sudoku feinabstimmen. Das Basis-Modell schneidet bei Sudoku-Aufgaben zunächst schlecht ab, aber nach dem Training auf einem gezielten Datensatz lernt es tatsächlich, Sudoku zu lösen, und löst jedes Beispiel korrekt.
Sie können unser Colab-Notebook (A100) verwenden, um DiffusionGemma mit Folgendem feinabzustimmen:
{% embed url="" %}
## Empfohlene Einstellungen
[Unsloth Studio](#unsloth-studio-guide) setzt automatisch die besten Inferenz-Einstellungen für Ihr Modell. Verwenden Sie unten bei Bedarf:
| Kategorie | Einstellung | Wert |
| ----------------- | --------------------------- | --------------------------- |
| Sampling | Methode | `Diffusions-Sampling` |
| Sampling | Sampler | `entropy_bounded_denoising` |
| Sampling | Maximale Denoising-Schritte | `48` |
| Temperatur | Temperaturverlauf | `linearer Abfall` |
| Temperatur | Temperaturstart | `0.8` |
| Temperatur | Temperaturende | `0.4` |
| Entropie | Entropiegrenze | `0.1` |
| Adaptives Stoppen | Adaptives Stoppen aktiviert | `true` |
| Adaptives Stoppen | Entropieschwelle | `0.005` |
| Canvas | Canvas-Länge | `256` |
**Bedingungen für adaptive Stoppauslösung**
Adaptives Stoppen sollte nur ausgelöst werden, wenn **beide** die Bedingungen erfüllt sind:
| Bedingung | Erforderlicher Wert |
| ---------------------------------------------------------------------------------- | ------------------- |
| Durchschnittliche Canvas-Entropie | `< 0.005` |
| Token mit höchster Wahrscheinlichkeit über 2 aufeinanderfolgenden Schritten stabil | `true` |
Bei jedem Denoising-Schritt sollte der Sampler die Token mit der niedrigsten Entropie auswählen, deren Grenze der gegenseitigen Information weiterhin ist: `entropy_bound = 0.1`. Nicht ausgewählte Token sollten vor dem nächsten Denoising-Schritt vollständig erneut verrauscht werden.
### Denkmodus
DiffusionGemma unterstützt den Denkmodus im Stil von Gemma 4. Um das Denken zu aktivieren, fügen Sie das Thinking-Token am Anfang des System-Prompts hinzu:
```
<|think|>
```
Wenn Denken aktiviert ist, kann das Modell einen internen Reasoning-Kanal ausgeben, gefolgt von der finalen Antwort:
```
<|channel>thought
[interne Schlussfolgerung]
[endgültige Antwort]
```
Um Denken zu deaktivieren, entfernen Sie das `<|think|>` Token aus dem System-Prompt. Wenn Denken deaktiviert ist, kann das Modell dennoch einen leeren Thought-Kanal ausgeben:
```
<|channel>thought
[endgültige Antwort]
```
Bei Mehrturn-Unterhaltungen, **nicht** fügen Sie frühere verborgene Gedanken nicht in den Gesprächsverlauf ein. Fügen Sie nur die endgültige Assistentenantwort vor dem nächsten Benutzerdurchlauf ein.
## Bewährte Verfahren für DiffusionGemma
### Multimodales Prompting
DiffusionGemma unterstützt verschachtelte multimodale Eingaben, einschließlich Text und Bilder. Video kann als Sequenzen von Einzelbild-Frames verarbeitet werden.
Für beste Ergebnisse bei multimodalen Prompts platzieren Sie Bild- oder Frame-Inhalte vor den Textanweisungen. Beispiel:
```
[Bild]
Beschreiben Sie das Diagramm und fassen Sie den wichtigsten Trend zusammen.
```
Für Dokumentenparsing, OCR, Diagrammverständnis, UI-Verständnis oder kleine Textextraktion verwenden Sie ein höheres Visual-Token-Budget.
Unterstützte visuelle Token-Budgets:
| Visuelles Token-Budget | Am besten für |
| ---------------------- | ------------------------------------------------------- |
| 70 | Schnelle Klassifikation, einfache Bildunterschriften |
| 140 | Leichtgewichtiges visuelles QA |
| 280 | Allgemeines Bildverständnis |
| 560 | OCR, Diagramme, UI-Screenshots |
| 1120 | Dichte Dokumente, kleiner Text, detaillierte Extraktion |
Für Video-artige Eingaben kann DiffusionGemma bis zu **60 Sekunden** verarbeiten, wenn mit **1 Frame pro Sekunde**.
### Hinweise zum Sampling
DiffusionGemma ist kein normales Nur-Nächstes-Token-Modell. Es erzeugt einen Block von Token, genannt einen **Canvas**, indem es verrauschte Token-Vorhersagen wiederholt verfeinert. Der Generierungsprozess funktioniert grob wie folgt:
1. Der Encoder verarbeitet den Prompt und baut einen Kontext-Cache auf.
2. Der Decoder erhält eine 256-Token-Generierungs-Canvas.
3. Der Diffusionssampler entrauscht die Canvas iterativ.
4. Vertrauenswürdige Token werden ausgewählt und beibehalten.
5. Unsichere Token werden erneut verrauscht und weiter verfeinert.
6. Sobald die Canvas fertig ist, wird sie an den Kontext angehängt.
7. Das Modell fährt mit der nächsten Canvas fort.
Dieser block-autoregressive Ansatz ermöglicht es DiffusionGemma, viele Token in weniger Forward-Pässen zu erzeugen als ein standardmäßiges autoregressives Modell.
## Benchmarks
DiffusionGemma ist auf Geschwindigkeit und multimodales Schlussfolgern optimiert, obwohl das Standard-Gemma-4 bei herkömmlichen Reasoning-Benchmarks stärker ist.
| Benchmark | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| -------------------- | ---------------------: | --------------: |
| MMLU Pro | 77.6% | 82.6% |
| AIME 2026 ohne Tools | 69.1% | 88.3% |
| LiveCodeBench v6 | 69.1% | 77.1% |
| Codeforces-ELO | 1429 | 1718 |
| GPQA Diamond | 73.2% | 82.3% |
| Tau2-Durchschnitt | 56.2% | 68.2% |
| HLE ohne Tools | 11.0% | 8.7% |
| HLE mit Suche | 11.9% | 17.2% |
| BigBench Extra Hard | 47.6% | 64.8% |
| MMMLU | 81.5% | 86.3% |
| Langkontext-Benchmark | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| ---------------------------------- | ---------------------: | --------------: |
| MRCR v2 8-Needle-128K-Durchschnitt | 32.0% | 44.1% |
**Vision-Benchmarks:**
| Vision-Benchmark | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| -------------------------------------- | ---------------------: | --------------: |
| MMMU Pro | 54.3% | 73.8% |
| OmniDocBench 1.5, niedriger ist besser | 0.319 | 0.149 |
| MATH-Vision | 70.5% | 82.4% |
| MedXPertQA MM | 49.0% | 58.1% |
---
# 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/diffusiongemma.md?ask=&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.
.gif?alt=media&token=2bc254a8-dbf9-4638-a5cb-8a7877d3c9fa)