> 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 - So führst du es lokal aus

DiffusionGemma **26B-A4B** ist Googles 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 auf **18 GB RAM** und [Fine-Tuning](#fine-tune-diffusiongemma) wird jetzt unterstützt über [Unsloth](https://github.com/unslothai/unsloth).

Statt standardmäßigem Token-für-Token-Decoding 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ühre das Modell über [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)

<a href="/pages/bcb4233a257ce2347848de7693d401efb89ba424#run-diffusiongemma-tutorials" class="button primary">DiffusionGemma ausführen</a><a href="/pages/bcb4233a257ce2347848de7693d401efb89ba424#fine-tune-diffusiongemma" class="button secondary">DiffusionGemma feinabstimmen</a>

{% hint style="success" %}
**12. Juni:** Du kannst DiffusionGemma jetzt über [Unsloth Studio](#unsloth-studio-guide) ✨ mit 1,8x schnellerer Inferenz!
{% endhint %}

### Nutzungsanleitung

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 standardmäßigen Gemma-4-Modellen benötigt DiffusionGemma eine Diffusions-Inferenzlaufzeit, die Diffusion berücksichtigt. Autoregressive Einstellungen wie `Temperatur`, `top_p` und `top_k` allein reichen nicht aus, um das empfohlene Verhalten ohne den erforderlichen Diffusionssampler zu reproduzieren.

<div data-with-frame="true"><figure><img src="/files/37d41a9986d4b1f503942b2654532cfdd5149728" alt="" width="563"><figcaption></figcaption></figure></div>

### 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 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 dein gesamter verfügbarer Speicher mindestens größer sein als die Größe des quantisierten Modells, das du herunterlädst. Wenn das nicht der Fall ist, kannst du es dennoch mit teilweisem RAM-/Festplatten-Offload ausführen, aber die Generierung wird langsamer sein. Je nach verwendetem Kontextfenster benötigst du außerdem mehr Rechenleistung.
{% endhint %}

## DiffusionGemma-Tutorials ausführen

Am besten verwendest du mindestens 4-Bit-Präzision, daher verwenden 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)

<a href="/pages/bcb4233a257ce2347848de7693d401efb89ba424#unsloth-studio-guide" class="button primary">🦥 Unsloth Studio-Anleitung</a><a href="/pages/bcb4233a257ce2347848de7693d401efb89ba424#llama.cpp-guide" class="button primary">🦙 Llama.cpp-Anleitung</a>

### 🦥 Unsloth Studio-Anleitung

{% hint style="success" %}
Du kannst DiffusionGemma jetzt über [Unsloth Studio](#unsloth-studio-guide) ✨. Stelle sicher, dass du [`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. Mit Unsloth Studio können Sie 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
* [**Selbstheilende** Tool-Aufrufe](/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) Parametertuning (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 %}

<div data-with-frame="true"><figure><img src="/files/37d41a9986d4b1f503942b2654532cfdd5149728" alt=""><figcaption></figcaption></figure></div>
{% 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 im 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 zur [Unsloth Chat](/docs/de/neu/studio/chat.md) Registerkarte und suche in der Suchleiste nach DiffusionGemma und lade dein gewünschtes 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 unserer [Unsloth-Studio-Inferenzanleitung](/docs/de/neu/studio/chat.md).

<div data-with-frame="true"><figure><img src="/files/37d41a9986d4b1f503942b2654532cfdd5149728" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

### 🦙 Llama.cpp-Anleitung

Für dieses Tutorial werden wir die dynamische 4-Bit- `Q4_K_M` Quantisierung verwenden, die 18 GB RAM benötigt und [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp) für schnelle lokale Inferenz verwenden, insbesondere wenn Sie eine CPU haben.

{% stepper %}
{% step %}
Den spezifischen `llama.cpp` Pull Request auf [**GitHub hier**](https://github.com/ggml-org/llama.cpp/pull/24423). Sie können auch den folgenden Build-Anweisungen folgen. Ä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 erstellen (lasse -DGGML_CUDA=ON weg für einen CPU-only-Build)
cmake -B build -DGGML_CUDA=ON
cmake --build build -j --config Release --target llama-diffusion-cli
cd ..
```

{% endstep %}

{% step %}
Laden Sie das Modell über herunter (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: [Debugging für Hugging Face Hub, XET](/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*" # Verwende "*Q4_K_M*" für einen kleineren 16-GB-Download
```

{% endstep %}
{% endstepper %}

### Mit DiffusionGemma chatten

Dann führe 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 %}

Du wirst Folgendes sehen:

<figure><img src="/files/c51f3e26aa2558ca4ad6ce44a319573b22aa3e05" alt=""><figcaption></figcaption></figure>

Und wenn du eine Frage wie "Erstelle ein Flappy-Bird-Spiel" eingibst, wirst du Schritte sehen:

<figure><img src="/files/f1d17c1e3be09b1308c07b2e8b3382b222233c99" alt=""><figcaption></figcaption></figure>

Danach wirst du die Ausgabe sehen:

<figure><img src="/files/9301b3f0e2f4fab4e75da6cbc9f0e482461b48f0" alt="" width="375"><figcaption></figcaption></figure>

Du kannst auch weiter miteinander sprechen!

Ändere `-n 2048` als die Anzahl der Token, die du vorhersagen möchtest, also führen höhere Werte zu längeren Antworten.

### Live-Visualisierung der Diffusion

Um die Diffusion live zu sehen, verwende das Folgende – aktiviere 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
```

Du wirst erneut Folgendes sehen:

<figure><img src="/files/7d64dfcb1983983085dd20a7eaa265854a5b463f" alt=""><figcaption></figcaption></figure>

Und wir erhalten:

<figure><img src="/files/32066567bf9a0a59723dc667f9d51765a8f5f163" alt="" width="563"><figcaption></figcaption></figure>

Alle Parameter für llama.cpp unter Verwendung des Branches:

* `-n, --n-predict N` - Ziel-Token; leitet `--diffusion-blocks` ab und wächst `-ub` / `-b` / `-c`.
* `-ngl 99` - alle Schichten auf die GPU auslagern (`-ngl 0` für nur CPU).
* `-cnv` - Modus für mehrstufige Konversation.
* `--diffusion-visual` - Live-Ansicht der Canvas-Entrauschung.
* Der Entropy-Bound-Sampler ist standardmäßig aktiviert (`--diffusion-eb auto`). Optimiere ihn 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

Du kannst 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 Basismodell schneidet anfangs bei Sudoku-Aufgaben schlecht ab, aber nach dem Training auf einem gezielten Datensatz lernt es, Sudoku tatsächlich zu lösen, und löst jedes Beispiel korrekt.

Du kannst unser Colab-Notebook (A100) verwenden, um DiffusionGemma mit Folgendem feinabzustimmen:

{% embed url="<https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/DiffusionGemma_(26B-A4B)-Sudoku.ipynb>" %}

<div data-with-frame="true"><figure><img src="/files/e69bbef1caf9b741e9b275ea004ae50eff8fbbfe" alt="" width="563"><figcaption></figcaption></figure></div>

## Empfohlene Einstellungen

[Unsloth Studio](#unsloth-studio-guide) setzt automatisch die besten Inferenz-Einstellungen für dein Modell. Verwende unten, falls erforderlich:

| Kategorie         | Einstellung                    | Wert                        |
| ----------------- | ------------------------------ | --------------------------- |
| Sampling          | Methode                        | `diffusion_sampling`        |
| Sampling          | Sampler                        | `entropy_bounded_denoising` |
| Sampling          | Maximale Entrauschungsschritte | `48`                        |
| Temperatur        | Temperaturplan                 | `linear_decay`              |
| Temperatur        | Temperaturstart                | `0.8`                       |
| Temperatur        | Temperaturende                 | `0.4`                       |
| Entropie          | Entropie-Grenzwert             | `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** Bedingungen erfüllt sind:

| Bedingung                                                                                    | Erforderlicher Wert |
| -------------------------------------------------------------------------------------------- | ------------------- |
| Durchschnittliche Canvas-Entropie                                                            | `< 0.005`           |
| Token mit der höchsten Wahrscheinlichkeit bleiben über 2 aufeinanderfolgende Schritte stabil | `true`              |

Bei jedem Entrauschungsschritt sollte der Sampler die Token mit der niedrigsten Entropie auswählen, deren gegenseitige Informationsgrenze weiterhin: `entropy_bound = 0.1`gilt. Nicht ausgewählte Token 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üge das Denk-Token am Anfang des System-Prompts hinzu:

```
<|think|>
```

Wenn Denken aktiviert ist, kann das Modell einen internen Begründungskanal ausgeben, gefolgt von der finalen Antwort:

```
<|channel>thought
[interne Begründung]
<channel|>
[finale Antwort]
```

Um Denken zu deaktivieren, entferne das `<|think|>` Token aus dem System-Prompt. Wenn Denken deaktiviert ist, kann das Modell dennoch einen leeren Gedankenkanal ausgeben:

```
<|channel>thought
<channel|>
[finale Antwort]
```

Bei mehrstufigen Konversationen **nicht** die zuvor verborgenen Gedanken in den Gesprächsverlauf aufnehmen. Nimm nur die finale Assistentenantwort vor dem nächsten Nutzerzugriff auf.

## 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 platziere Bild- oder Frame-Inhalte vor den Textanweisungen. Beispiel:

```
[Bild]
Beschreibe das Diagramm und fasse den wichtigsten Trend zusammen.
```

Für Dokumentenparsing, OCR, Diagrammverständnis, UI-Verständnis oder die Extraktion kleiner Textmengen verwende ein höheres Budget an visuellen Token.

Unterstützte Budgets für visuelle Token:

| Budget an visuellen Token | Am besten geeignet für                                  |
| ------------------------- | ------------------------------------------------------- |
| 70                        | Schnelle Klassifizierung, einfache Bildunterschriften   |
| 140                       | Leichtgewichtige visuelle QA                            |
| 280                       | Allgemeines Bildverständnis                             |
| 560                       | OCR, Diagramme, UI-Screenshots                          |
| 1120                      | Dichte Dokumente, kleiner Text, detaillierte Extraktion |

Für Eingaben im Video-Stil kann DiffusionGemma bis zu **60 Sekunden** verarbeiten, wenn es mit **1 Frame pro Sekunde**.

### Hinweise zum Sampling

DiffusionGemma ist kein normales Nur-Next-Token-Modell. Es erzeugt einen Token-Block, genannt **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. Token mit hoher Sicherheit werden ausgewählt und beibehalten.
5. Unsichere Token werden erneut verrauscht und weiter verfeinert.
6. Sobald die Canvas vollständig 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 mit weniger Vorwärtsdurchläufen zu erzeugen als ein standardmäßiges autoregressives Modell.

## Benchmarks

DiffusionGemma ist auf Geschwindigkeit und multimodales Schlussfolgern optimiert, obwohl standardmäßiges Gemma 4 bei konventionellen Reasoning-Benchmarks stärker ist.

| Benchmark                | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| ------------------------ | ---------------------: | --------------: |
| MMLU Pro                 |                  77.6% |           82.6% |
| AIME 2026 ohne Werkzeuge |                  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 Werkzeuge       |                  11.0% |            8.7% |
| HLE mit Suche            |                  11.9% |           17.2% |
| BigBench Extra Hard      |                  47.6% |           64.8% |
| MMMLU                    |                  81.5% |           86.3% |

| Benchmark für langen Kontext       | 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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://unsloth.ai/docs/de/modelle/diffusiongemma.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.