> 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/tutorials/diffusiongemma.md).
# DiffusionGemma
DiffusionGemma **26B-A4B** ist Google DeepMinds neues offenes **multimodales** 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 ausgelegt für **schnelle Textgenerierung** für Text-, Video- und Bildeingaben. DiffusionGemma kann lokal ausgeführt werden auf **18 GB RAM**, und [Fine-Tuning-](#fine-tune-diffusiongemma) wird jetzt unterstützt über [Unsloth](https://github.com/unslothai/unsloth).
Anstatt der standardmäßigen Token-für-Token-Dekodierung verwendet DiffusionGemma **Diffusionsgenerierung** um Ausgaben parallel zu erzeugen und sie schrittweise zu einer endgültigen Antwort zu verfeinern – ähnlich wie Diffusionsbildmodelle, aber für Text. Führen Sie das Modell über [Unsloth Studio](/docs/de/neu/studio.md) oder llama.cpp aus. Auf einer RTX 6000 kann DiffusionGemma erreichen **2000+ Tokens/s**. **GGUF:** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)
DiffusionGemma ausführenDiffusionGemma feinabstimmen
{% hint style="success" %}
**12. Jun:** Sie können DiffusionGemma jetzt über [Unsloth Studio](#unsloth-studio-guide) ✨ mit 1,8-fach schnellerer Inferenz!
{% endhint %}
### Anleitung zur Nutzung
DiffusionGemma ist für Nutzer gedacht, die schnellere Generierung als bei Standardmodellen benötigen. Es eignet sich für schnelle lokale Inferenz, Dokumentenanalyse mit langem Kontext, Bild-/Videoverständnis, OCR und Dokumentenparsing, Codegenerierung, Tool-Nutzung, agentische Workflows und latenzarme Inferenz mit kleinen Batches.
Im Gegensatz zu Standard-Gemma-4-Modellen benötigt DiffusionGemma eine diffusionsbewusste Inferenz-Runtime. Autoregressive Einstellungen wie `Temperatur`, `top_p`, und `top_k` allein reichen nicht aus, um das empfohlene Verhalten ohne den erforderlichen Diffusions-Sampler zu reproduzieren.
### Hardwareanforderungen
Es ist in der Regel 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 Hardwareanforderungen für DiffusionGemma Inference GGUF** (Einheiten = Gesamtspeicher: RAM + VRAM oder Unified Memory).
| 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 verfügbarer Gesamtspeicher mindestens größer sein als die Größe des quantisierten Modells, das Sie herunterladen. Wenn dies nicht der Fall ist, können Sie es immer noch mit partiellem RAM-/Festplatten-Offload ausführen, aber die Generierung wird langsamer sein. Je nach dem von Ihnen verwendeten Kontextfenster benötigen Sie außerdem mehr Rechenleistung.
{% endhint %}
## DiffusionGemma-Tutorials ausführen
Es ist am besten, mindestens 4-Bit-Präzision zu verwenden, daher nutzen wir die 4-Bit- `Q4_K_M` Quantisierung, die 18 GB RAM benötigt. **GGUF:** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)
🦥 Unsloth-Studio-Anleitung🦙 llama.cpp-Anleitung
### 🦥 Unsloth-Studio-Anleitung
{% hint style="success" %}
Sie können DiffusionGemma jetzt über [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 ausgeführt und trainiert werden in [Unsloth Studio](/docs/de/neu/studio.md), unserer neuen Open-Source-Weboberfläche für lokale KI. Unsloth Studio ermöglicht es Ihnen, Modelle lokal auszuführen auf **MacOS**, **Windows**, Linux und:
{% columns %}
{% column %}
* Suchen, herunterladen, [GGUFs ausführen](/docs/de/neu/studio.md#run-models-locally) und Safetensor-Modelle
* [**Selbstheilendes** Tool-Calling](/docs/de/neu/studio.md#execute-code--heal-tool-calling) + **Websuche**
* [**Code-Ausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash)
* [Automatische Inferenz](https://unsloth.ai/docs/desktop#feature-deep-dive) Parameter-Tuning (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) Reiter und suchen Sie in der Suchleiste nach DiffusionGemma und laden Sie das gewünschte Modell und die gewünschte Quantisierung herunter.
{% endstep %}
{% step %}
#### DiffusionGemma ausführen
Die Inferenzparameter sollten bei 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.
Weitere Informationen finden Sie in unserem [Unsloth Studio Inferenzleitfaden](/docs/de/neu/studio/chat.md).
{% endstep %}
{% endstepper %}
### 🦙 llama.cpp-Anleitung
Für dieses Tutorial verwenden wir die dynamische 4-Bit- `Q4_K_M` Quantisierung, die 18 GB RAM benötigt und [llama.cpp](https://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 [**GitHub hier**](https://github.com/ggml-org/llama.cpp/pull/24423). Du kannst auch die Build-Anweisungen unten befolgen. Ändere `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` , wenn du keine GPU hast oder nur CPU-Inferenz möchtest. **Für Apple-Mac-/Metal-Geräte**, setze `-DGGML_CUDA=OFF` 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 (lassen Sie -DGGML_CUDA=ON für einen reinen CPU-Build weg)
cmake -B build -DGGML_CUDA=ON
cmake --build build -j --config Release --target llama-diffusion-cli
cd ..
```
{% endstep %}
{% step %}
Laden Sie das Modell über (nach der Installation von `pip install huggingface_hub`). Sie können `Q4_K_M` oder andere quantisierte Versionen wie `Q8_0` . Wenn 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
Führen Sie dann das Folgende 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 "Erstelle ein Flappy-Bird-Spiel" eingeben, werden Sie Schritte sehen:
Danach sehen Sie die Ausgabe:
Sie können auch weiter mit ihm dialogisieren!
Ändere `-n 2048` als die Anzahl der Tokens, die Sie vorhersagen möchten, also erzeugen mehr längere Antworten.
### Live-Visualisierung der Diffusion
Um Diffusion tatsächlich live zu sehen, verwenden Sie das Folgende – aktivieren Sie insbesondere `--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-Tokens; leitet `--diffusion-blocks` und wächst `-ub` / `-b` / `-c`.
* `-ngl 99` - alle Schichten auf die GPU auslagern (`-ngl 0` für CPU-only).
* `-cnv` - Modus für Mehrturn-Konversationen.
* `--diffusion-visual` - Live-Ansicht der Canvas-Entrauschung.
* 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}` - KV-Cache für Prompt-Präfix (auto = ein bei einer einzelnen GPU).
## DiffusionGemma feinabstimmen
Sie können DiffusionGemma jetzt direkt mit trainieren und feinabstimmen [**Unsloth**](#unsloth-studio-guide). In unserem Beispiel demonstrieren wir die Auswirkungen domänenspezifischen Trainings, indem wir das Modell auf Sudoku feinabstimmen. Das Basismodell 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 fest. Verwenden Sie das Folgende bei Bedarf:
| Kategorie | Einstellung | Wert |
| ----------------- | ------------------------------ | --------------------------- |
| Sampling | Methode | `diffusion_sampling` |
| Sampling | Sampler | `entropy_bounded_denoising` |
| Sampling | Maximale Entrauschungsschritte | `48` |
| Temperatur | Temperaturverlauf | `linear_decay` |
| Temperatur | Temperaturstart | `0.8` |
| Temperatur | Temperaturende | `0.4` |
| Entropie | Entropie-Grenze | `0.1` |
| Adaptives Stoppen | Adaptives Stoppen aktiviert | `true` |
| Adaptives Stoppen | Entropieschwelle | `0.005` |
| Canvas | Canvas-Länge | `256` |
**Auslösebedingungen für adaptives Stoppen**
Adaptives Stoppen sollte nur ausgelöst werden, wenn **beide** die Bedingungen erfüllt sind:
| Bedingung | Erforderlicher Wert |
| ----------------------------------------------------------------------------------------- | ------------------- |
| Durchschnittliche Canvas-Entropie | `< 0.005` |
| Tokens mit der höchsten Wahrscheinlichkeit sind für 2 aufeinanderfolgende Schritte stabil | `true` |
Bei jedem Entrauschungsschritt sollte der Sampler die Tokens mit der niedrigsten Entropie auswählen, deren gegenseitige Informationsgrenze weiterhin: `entropy_bound = 0.1`. Nicht ausgewählte Tokens sollten vor dem nächsten Entrauschungsschritt vollständig erneut verrauscht werden.
### Denkmodus
DiffusionGemma unterstützt den Denkmodus im Stil von Gemma 4. Um Denken zu aktivieren, fügen Sie das Denk-Token am Anfang des Systemprompts hinzu:
```
<|think|>
```
Wenn Denken aktiviert ist, kann das Modell einen internen Denkkanal ausgeben, gefolgt von der endgültigen Antwort:
```
<|channel>thought
[interne Begründung]
[endgültige Antwort]
```
Um Denken zu deaktivieren, entfernen Sie das `<|think|>` Token aus dem Systemprompt. Wenn Denken deaktiviert ist, kann das Modell dennoch einen leeren Denkkanal ausgeben:
```
<|channel>thought
[endgültige Antwort]
```
Für Mehrturn-Konversationen fügen Sie **nicht** frühere verborgene Gedanken nicht in den Konversationsverlauf ein. Fügen Sie nur die endgültige Assistentenantwort vor dem nächsten Nutzerzug ein.
## Best Practices für DiffusionGemma
### Multimodales Prompting
DiffusionGemma unterstützt verschachtelte multimodale Eingaben, einschließlich Text und Bildern. Video kann als Sequenzen von Bildframes verarbeitet werden.
Für beste Ergebnisse mit 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 das Parsen von Dokumenten, OCR, Diagrammverständnis, UI-Verständnis oder kleine Textextraktion verwenden Sie ein höheres Budget für visuelle Tokens.
Unterstützte Budgets für visuelle Tokens:
| Budget für visuelle Tokens | Am besten für |
| -------------------------- | ------------------------------------------------------- |
| 70 | Schnelle Klassifizierung, einfache Bildunterschriften |
| 140 | Leichte visuelle QA |
| 280 | Allgemeines Bildverständnis |
| 560 | OCR, Diagramme, UI-Screenshots |
| 1120 | Dichte Dokumente, kleiner Text, detaillierte Extraktion |
Für videoartige Eingaben kann DiffusionGemma bis zu **60 Sekunden** bei einer Abtastrate von **1 Frame pro Sekunde**.
### Hinweise zur Abtastung
DiffusionGemma ist kein normales Modell, das nur das nächste Token vorhersagt. Es erzeugt einen Block von Tokens, genannt ein **Leinwand**, indem verrauschte Token-Vorhersagen wiederholt verfeinert werden.
1. Der Encoder verarbeitet den Prompt und erstellt einen Kontext-Cache.
2. Der Decoder erhält eine Generierungs-Canvas mit 256 Tokens.
3. Der Diffusionssampler entrauscht die Canvas iterativ.
4. Tokens mit hoher Sicherheit werden ausgewählt und beibehalten.
5. Unsichere Tokens werden erneut verrauscht und weiter verfeinert.
6. Sobald die Canvas vollständig ist, wird sie dem Kontext angehängt.
7. Das Modell fährt mit der nächsten Canvas fort.
Dieser blockautoregressive Ansatz ermöglicht es DiffusionGemma, viele Tokens in weniger Forward-Pässen zu erzeugen als ein standardmäßiges autoregressives Modell.
## Benchmarks
DiffusionGemma ist für 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-Nadel 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/tutorials/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)