> 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 – Wie man lokal ausführt

DiffusionGemma **26B-A4B** ist Google DeepMinds neues offenes **multimodal** Modell, basierend auf der [Gemma 4](/docs/de/modelle/gemma-4.md) MoE-Architektur. Mit Unterstützung für **256K-Kontext**, **140+ Sprachen**, DiffusionGemma ist konzipiert für **Hochgeschwindigkeits-Textgenerierung** für Text-, Video- und Bildeingaben. DiffusionGemma kann lokal laufen 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 Diffusions-Bildmodelle, aber für Text. Führen Sie das Modell aus über [Unsloth Studio](/docs/de/neu/studio.md) oder llama.cpp. Auf einer RTX 6000 kann DiffusionGemma erreichen **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:** Sie können DiffusionGemma jetzt über [Unsloth Studio](#unsloth-studio-guide) ✨ mit 1,8x schnellerer Inferenz!
{% endhint %}

### Anleitung

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 Dokumentenanalyse, Codegenerierung, Tool-Nutzung, agentische Workflows und Inferenz mit geringer Latenz und kleinen Batches.

Im Gegensatz zu Standard-Gemma-4-Modellen benötigt DiffusionGemma eine diffusionbewusste Inferenzlaufzeit. 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

Es ist im Allgemeinen 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 insgesamt verfügbarer Speicher die Größe des heruntergeladenen quantisierten Modells mindestens übersteigen. Falls nicht, können Sie es dennoch mit teilweisem RAM-/Festplatten-Offload ausführen, aber die Generierung wird langsamer sein. Außerdem benötigen Sie je nach verwendetem Kontextfenster mehr Rechenleistung.
{% endhint %}

## DiffusionGemma-Tutorials ausführen

Am besten verwendet man mindestens 4-Bit-Präzision, 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)

<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" %}
Sie können DiffusionGemma jetzt über [Unsloth Studio](#unsloth-studio-guide) ✨. Stellen Sie sicher, dass Sie verwenden [`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-Web-UI für lokale KI. Mit Unsloth Studio können Sie Modelle lokal ausfü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**
* [**Codeausführung**](/docs/de/neu/studio.md#run-models-locally) (Python, Bash)
* [Automatische Inferenz](/docs/de/neu/studio.md#model-arena) Parameterabstimmung (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

Stellen Sie sicher, dass Sie die neueste [`v0.1.463-beta`](https://github.com/unslothai/unsloth/tree/v0.1.462-beta) oder `2026.6.6`. Führen Sie in Ihrem 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 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, du kannst sie jedoch weiterhin manuell ändern. Du kannst außerdem die Kontextlänge, die Chat-Vorlage und andere Einstellungen bearbeiten.

Für weitere Informationen können Sie unsere [Inferenzanleitung für Unsloth Studio](/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 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, insbesondere wenn Sie eine CPU haben.

{% stepper %}
{% step %}
Besorgen Sie sich den SPEZIFISCHEN `llama.cpp` PR auf [**GitHub hier**](https://github.com/ggml-org/llama.cpp/pull/24423). Sie können auch den untenstehenden Build-Anweisungen folgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen. **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 %}
Laden Sie das Modell über (nach der Installation von `pip install huggingface_hub`). Sie können wählen `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

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 sehen:

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

Und wenn Sie eine Frage wie "Erstelle ein Flappy-Bird-Spiel" eingeben, sehen Sie die Schritte:

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

Danach sehen Sie die Ausgabe:

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

Sie können auch weiter miteinander chatten!

Ändern Sie `-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 die Diffusion tatsächlich live zu sehen, verwenden Sie Folgendes – 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 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` und wächst `-ub` / `-b` / `-c`.
* `-ngl 99` - alle Schichten auf die GPU auslagern (`-ngl 0` für nur CPU).
* `-cnv` - Modus für mehrturnige Konversation.
* `--diffusion-visual` - Live-Ansicht der Canvas-Entrauschung.
* Der Entropy-Bound-Sampler ist standardmäßig aktiviert (`--diffusion-eb auto`). Feinabstimmen 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 des Prompt-Präfixes (auto = bei einer einzelnen GPU aktiviert).

## DiffusionGemma feinabstimmen

Sie können DiffusionGemma jetzt direkt trainieren und feinabstimmen 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 bei Sudoku-Aufgaben zunächst schlecht ab, aber nach dem Training auf einem gezielten Datensatz lernt es, Sudoku tatsächlich zu lösen, und löst jedes Beispiel korrekt.

Sie können 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) legt automatisch die besten Inferenz-Einstellungen für Ihr Modell fest. Verwenden Sie bei Bedarf Folgendes:

| Kategorie         | Einstellung                    | Wert                        |
| ----------------- | ------------------------------ | --------------------------- |
| Abtastung         | Methode                        | `diffusion_sampling`        |
| Abtastung         | Sampler                        | `entropy_bounded_denoising` |
| Abtastung         | Maximale Entrauschungsschritte | `48`                        |
| Temperatur        | Temperaturverlauf              | `linear_decay`              |
| 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`                       |

**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 sind für 2 aufeinanderfolgende Schritte stabil | `true`              |

Bei jedem Entrauschungsschritt sollte der Sampler die Tokens mit der niedrigsten Entropie auswählen, deren Grenze der gegenseitigen Information bleibt: `entropy_bound = 0.1`. Nicht ausgewählte Tokens sollten vor dem nächsten Entrauschungsschritt vollständig erneut entrauscht werden.

### Denkmodus

DiffusionGemma unterstützt den Denkmodus im Gemma-4-Stil. Um das Denken zu aktivieren, fügen Sie das Denk-Token am Anfang des Systemprompts hinzu:

```
<|think|>
```

Wenn das Denken aktiviert ist, kann das Modell einen internen Denkkanal gefolgt von der endgültigen Antwort ausgeben:

```
<|channel>thought
[internal reasoning]
<channel|>
[final answer]
```

Um das Denken zu deaktivieren, entfernen Sie das `<|think|>` Token aus dem Systemprompt. Wenn das Denken deaktiviert ist, kann das Modell dennoch einen leeren Denkkanal ausgeben:

```
<|channel>thought
<channel|>
[final answer]
```

Für mehrturnige Konversationen sollten Sie **nicht** die vorherigen verborgenen Gedanken nicht in den Gesprächsverlauf aufnehmen. Fügen Sie vor dem nächsten Benutzerdurchgang nur die endgültige Assistentenantwort ein.

## Best Practices für DiffusionGemma

### Multimodales Prompting

DiffusionGemma unterstützt abwechselnde 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:

```
[image]
Beschreiben Sie das Diagramm und fassen Sie den wichtigsten Trend zusammen.
```

Verwenden Sie für Dokumentanalyse, OCR, Diagrammverständnis, UI-Verständnis oder kleine Textextraktion ein höheres visuelles Token-Budget.

Unterstützte visuelle Token-Budgets:

| Visuelles Token-Budget | Am besten für                                              |
| ---------------------- | ---------------------------------------------------------- |
| 70                     | Schnelle Klassifizierung, einfache Bildbeschreibung        |
| 140                    | Leichtgewichtige visuelle Fragenbeantwortung               |
| 280                    | Allgemeines Bildverständnis                                |
| 560                    | OCR, Diagramme, UI-Screenshots                             |
| 1120                   | Dichte Dokumente, Kleingedrucktes, detaillierte Extraktion |

Für Eingaben im Videostil kann DiffusionGemma bis zu **60 Sekunden** verarbeitet werden bei einer Abtastrate von **1 Frame pro Sekunde**.

### Hinweise zur Abtastung

DiffusionGemma ist kein normales reines Next-Token-Modell. Es erzeugt einen Block von Tokens, genannt einen **Canvas**Canvas

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. Sichere Tokens 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 setzt mit der nächsten Canvas fort.

Dieser block-autoregressive Ansatz ermöglicht es DiffusionGemma, viele Tokens in weniger Vorwärtsdurchläufen als ein standardmäßiges autoregressives Modell zu erzeugen.

## Benchmarks

DiffusionGemma ist auf Geschwindigkeit und multimodales Schlussfolgern optimiert, obwohl 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 Schwer |                  47.6% |           64.8% |
| MMMLU                 |                  81.5% |           86.3% |

| Long-Context-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 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.