> 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/fr/modeles/diffusiongemma.md).

# DiffusionGemma - Comment l'exécuter localement

DiffusionGemma **26B-A4B** est le nouveau modèle ouvert de Google DeepMind **multimodal** modèle, construit sur l' [Gemma 4](/docs/fr/modeles/gemma-4.md) architecture MoE. Avec la prise en charge de **contexte de 256K**, **140+ langues**, DiffusionGemma est conçu pour **la génération de texte à grande vitesse** à travers des entrées texte, vidéo et image. DiffusionGemma peut s'exécuter localement sur **18 Go de RAM**et [affinage](#fine-tune-diffusiongemma) est désormais pris en charge via [Unsloth](https://github.com/unslothai/unsloth).

Au lieu du décodage standard jeton par jeton, DiffusionGemma utilise **la génération par diffusion** pour produire des sorties en parallèle et les affiner progressivement jusqu'à une réponse finale - similaire aux modèles de diffusion d'images, mais pour le texte. Exécutez le modèle via [Unsloth Studio](/docs/fr/nouveau/studio.md) ou llama.cpp. Sur une RTX 6000, DiffusionGemma peut atteindre **2000+ jetons/s**. **GGUF :** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)

<a href="/pages/19ae51ca6b5fe7e2042b990762f52fdc58830d34#run-diffusiongemma-tutorials" class="button primary">Exécuter DiffusionGemma</a><a href="/pages/19ae51ca6b5fe7e2042b990762f52fdc58830d34#fine-tune-diffusiongemma" class="button secondary">Ajuster finement DiffusionGemma</a>

{% hint style="success" %}
**12 juin :** Vous pouvez maintenant exécuter DiffusionGemma via [Unsloth Studio](#unsloth-studio-guide) ✨ avec une inférence 1,8x plus rapide !
{% endhint %}

### Guide d'utilisation

DiffusionGemma est conçu pour les utilisateurs qui ont besoin d'une génération plus rapide que les modèles standard. Il est adapté à l'inférence locale rapide, à l'analyse de documents à long contexte, à la compréhension d'images/vidéos, à l'OCR et à l'analyse de documents, à la génération de code, à l'utilisation d'outils, aux workflows agentiques et à l'inférence en petits lots à faible latence.

Contrairement aux modèles Gemma 4 standard, DiffusionGemma nécessite un runtime d'inférence conscient de la diffusion. Les paramètres auto-régressifs tels que `température`, `top_p`et `top_k` ne suffisent pas à reproduire le comportement recommandé sans l'échantillonneur de diffusion requis.

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

### Exigences matérielles

En général, il est préférable d'avoir au moins 18 Go de RAM pour exécuter le modèle en précision 4 bits. **GGUF :** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)

**Tableau : exigences matérielles recommandées pour l'inférence GGUF de DiffusionGemma** (unités = mémoire totale : RAM + VRAM, ou mémoire unifiée).

| 4 bits | 5 bits | 6 bits | 8 bits | BF16 / FP16 |
| ------ | ------ | ------ | ------ | ----------- |
| 18 Go  | 20 Go  | 24 Go  | 28 Go  | 52 Go       |

{% hint style="info" %}
En règle générale, votre mémoire totale disponible devrait au moins dépasser la taille du modèle quantifié que vous téléchargez. Si ce n'est pas le cas, vous pouvez quand même l'exécuter en utilisant un déchargement partiel sur la RAM/le disque, mais la génération sera plus lente. Vous aurez également besoin de plus de calcul, selon la fenêtre de contexte que vous utilisez.
{% endhint %}

## Tutoriels pour exécuter DiffusionGemma

Il est préférable d'utiliser au moins une précision 4 bits, nous utiliserons donc le 4 bits `Q4_K_M` quant qui nécessite 18 Go de RAM. **GGUF :** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)

<a href="/pages/19ae51ca6b5fe7e2042b990762f52fdc58830d34#unsloth-studio-guide" class="button primary">🦥 Guide Unsloth Studio</a><a href="/pages/19ae51ca6b5fe7e2042b990762f52fdc58830d34#llama.cpp-guide" class="button primary">🦙 Guide llama.cpp</a>

### 🦥 Guide Unsloth Studio

{% hint style="success" %}
Vous pouvez maintenant exécuter DiffusionGemma via [Unsloth Studio](#unsloth-studio-guide) ✨. Assurez-vous d'utiliser [`v0.1.463-beta`](https://github.com/unslothai/unsloth/tree/v0.1.462-beta) ou `2026.6.6`.
{% endhint %}

DiffusionGemma peut désormais être exécuté et entraîné dans [Unsloth Studio](/docs/fr/nouveau/studio.md), notre nouvelle interface web open source pour l'IA locale. Unsloth Studio vous permet d'exécuter des modèles localement sur **macOS**, **Windows**, Linux et :

{% columns %}
{% column %}

* Rechercher, télécharger, [exécuter des GGUF](/docs/fr/nouveau/studio.md#run-models-locally) et des modèles safetensor
* [**Appels d'outils auto-réparateurs** appels d'outils](/docs/fr/nouveau/studio.md#execute-code--heal-tool-calling) + **recherche web**
* [**Exécution de code**](/docs/fr/nouveau/studio.md#run-models-locally) (Python, Bash)
* [Inférence automatique](/docs/fr/nouveau/studio.md#model-arena) réglage des paramètres (temp, top-p, etc.)
* Inférence rapide CPU + GPU via llama.cpp
* [Entraîner des LLM](/docs/fr/nouveau/studio.md#no-code-training) 2x plus vite avec 70 % de VRAM en moins
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/608ef824be87e674df7b205a47c03ae2281fb5dc" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}

#### Installer Unsloth

Assurez-vous d'utiliser la dernière [`v0.1.463-beta`](https://github.com/unslothai/unsloth/tree/v0.1.462-beta) ou `2026.6.6`. Exécutez dans votre terminal :

**MacOS, Linux, WSL :**

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

**Windows PowerShell :**

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

{% endstep %}

{% step %}

#### Lancer Unsloth

**MacOS, Linux, WSL et Windows :**

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

Puis ouvrez `http://127.0.0.1:8888` (ou votre URL spécifique) dans votre navigateur.
{% endstep %}

{% step %}

#### Rechercher et télécharger DiffusionGemma

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter.

Puis allez dans l’ [Unsloth Chat](/docs/fr/nouveau/studio/chat.md) onglet et recherchez DiffusionGemma dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités.
{% endstep %}

{% step %}

#### Exécuter DiffusionGemma

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, mais vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur du contexte, le modèle de chat et d’autres paramètres.

Pour plus d'informations, vous pouvez consulter notre [guide d'inférence Unsloth Studio](/docs/fr/nouveau/studio/chat.md).

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

### 🦙 Guide llama.cpp

Pour ce tutoriel, nous utiliserons la quantification dynamique 4 bits `Q4_K_M` qui nécessite 18 Go de RAM et [llama.cpp](llama.cpphttps://github.com/ggml-org/llama.cpp) pour une inférence locale rapide, surtout si vous avez un CPU.

{% stepper %}
{% step %}
Obtenez la `llama.cpp` PR spécifique sur [**GitHub ici**](https://github.com/ggml-org/llama.cpp/pull/24423). Vous pouvez également suivre les instructions de compilation ci-dessous. Modifiez `-DGGML_CUDA=ON` à `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - la prise en charge de Metal est activée par défaut.

```bash
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
gh pr checkout 24423
# build avec CUDA (supprimez -DGGML_CUDA=ON pour une compilation CPU uniquement)
cmake -B build -DGGML_CUDA=ON
cmake --build build -j --config Release --target llama-diffusion-cli
cd ..
```

{% endstep %}

{% step %}
Téléchargez le modèle via (après avoir installé `pip install huggingface_hub`). Vous pouvez choisir `Q4_K_M` ou d’autres versions quantifiées comme `Q8_0` . Si les téléchargements se bloquent, voir : [Hugging Face Hub, débogage XET](/docs/fr/bases/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*" # Utilisez "*Q4_K_M*" pour un téléchargement plus petit de 16 Go
```

{% endstep %}
{% endstepper %}

### Discutez avec DiffusionGemma

Exécutez ensuite ce qui suit :

{% 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 %}

Vous verrez :

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

Et si vous tapez une question comme "Create a Flappy Bird Game", vous verrez les étapes :

<figure><img src="/files/39fdfa5a3d97aafd9aa3eb7f8b09edc32febf499" alt=""><figcaption></figcaption></figure>

Puis vous verrez ensuite la sortie :

<figure><img src="/files/2f29ca7452a2ff3581fac378d83dd77f2709c707" alt="" width="375"><figcaption></figcaption></figure>

Vous pouvez aussi continuer la conversation !

Changez `-n 2048` comme le nombre de jetons que vous voulez prédire, donc une valeur plus élevée produira des réponses plus longues.

### Visualisation en direct de la diffusion

Pour voir la diffusion en direct, utilisez ce qui suit — activez spécialement `--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
```

Vous verrez à nouveau :

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

Et nous obtenons :

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

Tous les paramètres pour llama.cpp en utilisant la branche :

* `-n, --n-predict N` - jetons cibles ; dérive `--diffusion-blocks` et croît `-ub` / `-b` / `-c`.
* `-ngl 99` - décharge toutes les couches sur le GPU (`-ngl 0` pour CPU uniquement).
* `-cnv` - mode de conversation multi-tours.
* `--diffusion-visual` - vue de débruitage du canevas en direct.
* L'échantillonneur Entropy-Bound est activé par défaut (`--diffusion-eb auto`). Ajustez-le avec `--diffusion-eb-max-steps` (par défaut 48), `--diffusion-eb-t-max` / `--diffusion-eb-t-min` (0.8 -> 0.4), `--diffusion-eb-entropy-bound` (0,1), et `--diffusion-eb-confidence` (0.005).
* `--diffusion-kv-cache {auto,on,off}` - cache KV du préfixe de prompt (auto = activé pour un seul GPU).

## Ajuster finement DiffusionGemma

Vous pouvez maintenant entraîner et ajuster finement DiffusionGemma directement avec [**Unsloth**](#unsloth-studio-guide). Dans notre exemple, nous démontrons l'impact d'un entraînement spécifique au domaine en ajustant finement le modèle sur le Sudoku. Le modèle de base performe initialement mal sur les tâches de Sudoku, mais après entraînement sur un ensemble de données ciblé, il apprend réellement à résoudre le sudoku et résout correctement chaque exemple.

Vous pouvez utiliser notre notebook Colab (A100) pour ajuster finement DiffusionGemma avec :

{% 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/99870d1547a7b8889131cd7e3e63f74d53013688" alt="" width="563"><figcaption></figcaption></figure></div>

## Paramètres recommandés

[Unsloth Studio](#unsloth-studio-guide) définit automatiquement les meilleurs paramètres d'inférence pour votre modèle. Utilisez ci-dessous si nécessaire :

| Catégorie       | Paramètre                             | Valeur                      |
| --------------- | ------------------------------------- | --------------------------- |
| Échantillonnage | Méthode                               | `diffusion_sampling`        |
| Échantillonnage | Échantillonneur                       | `entropy_bounded_denoising` |
| Échantillonnage | Nombre maximal d'étapes de débruitage | `48`                        |
| Température     | Programme de température              | `linear_decay`              |
| Température     | Température de départ                 | `0.8`                       |
| Température     | Température finale                    | `0.4`                       |
| Entropie        | Limite d'entropie                     | `0.1`                       |
| Arrêt adaptatif | Arrêt adaptatif activé                | `true`                      |
| Arrêt adaptatif | Seuil d'entropie                      | `0.005`                     |
| Canevas         | Longueur du canevas                   | `256`                       |

**Conditions de déclenchement de l'arrêt adaptatif**

L'arrêt adaptatif ne doit se déclencher que lorsque **les deux** conditions sont remplies :

| Condition                                                                             | Valeur requise |
| ------------------------------------------------------------------------------------- | -------------- |
| Entropie moyenne du canevas                                                           | `< 0.005`      |
| Les jetons à probabilité la plus élevée restent stables pendant 2 étapes consécutives | `true`         |

À chaque étape de débruitage, l'échantillonneur doit sélectionner les jetons à l'entropie la plus faible dont la borne d'information mutuelle reste : `limite_entropie = 0,1`. Les jetons non sélectionnés doivent être entièrement renoisés avant l'étape de débruitage suivante.

### Mode de réflexion

DiffusionGemma prend en charge le mode de réflexion à la manière de Gemma 4. Pour activer la réflexion, ajoutez le jeton de réflexion au début du prompt système :

```
<|think|>
```

Lorsque la réflexion est activée, le modèle peut émettre un canal de raisonnement interne suivi de la réponse finale :

```
<|channel>thought
[raisonnement interne]
<channel|>
[réponse finale]
```

Pour désactiver la réflexion, supprimez le `<|think|>` jeton du prompt système. Lorsque la réflexion est désactivée, le modèle peut néanmoins émettre un canal de pensée vide :

```
<|channel>thought
<channel|>
[réponse finale]
```

Pour les conversations à plusieurs tours, ne **pas** incluez pas les pensées cachées précédentes dans l'historique de la conversation. Incluez uniquement la réponse finale de l'assistant avant le prochain tour de l'utilisateur.

## Meilleures pratiques DiffusionGemma

### Prompting multimodal

DiffusionGemma prend en charge des entrées multimodales entrelacées, y compris du texte et des images. La vidéo peut être traitée comme des séquences d'images.

Pour de meilleurs résultats avec les prompts multimodaux, placez le contenu des images ou des images par frame avant les instructions textuelles. Exemple :

```
[image]
Décrivez le graphique et résumez la tendance principale.
```

Pour l'analyse de documents, l'OCR, la compréhension de graphiques, la compréhension d'interface utilisateur ou l'extraction de petits textes, utilisez un budget de jetons visuels plus élevé.

Budgets de jetons visuels pris en charge :

| Budget de jetons visuels | Idéal pour                                                |
| ------------------------ | --------------------------------------------------------- |
| 70                       | Classification rapide, légendage simple                   |
| 140                      | Questions-réponses visuelles légères                      |
| 280                      | Compréhension générale d'image                            |
| 560                      | OCR, graphiques, captures d'écran d'interface utilisateur |
| 1120                     | Documents denses, petits textes, extraction détaillée     |

Pour les entrées de type vidéo, DiffusionGemma peut traiter jusqu'à **60 secondes** lorsqu'échantillonné à **1 image par seconde**.

### Notes sur l'échantillonnage

DiffusionGemma n'est pas un modèle normal uniquement basé sur le prochain jeton. Il génère un bloc de jetons, appelé **canvas**, en affinant à plusieurs reprises des prédictions de jetons bruitées. Le processus de génération fonctionne approximativement comme suit :

1. L'encodeur traite le prompt et construit un cache de contexte.
2. Le décodeur reçoit un canevas de génération de 256 jetons.
3. L'échantillonneur de diffusion débruite itérativement le canevas.
4. Les jetons les plus sûrs sont sélectionnés et conservés.
5. Les jetons incertains sont renoisés et affinés à nouveau.
6. Une fois le canevas terminé, il est ajouté au contexte.
7. Le modèle continue avec le canevas suivant.

Cette approche auto-régressive par blocs permet à DiffusionGemma de générer de nombreux jetons en un nombre réduit de passes avant par rapport à un modèle auto-régressif standard.

## Tests de référence

DiffusionGemma est optimisé pour la vitesse et le raisonnement multimodal, bien que Gemma 4 standard soit plus performant sur les benchmarks de raisonnement conventionnels.

| Benchmark             | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| --------------------- | ---------------------: | --------------: |
| MMLU Pro              |                  77.6% |           82.6% |
| AIME 2026 sans outils |                  69.1% |           88.3% |
| LiveCodeBench v6      |                  69.1% |           77.1% |
| ELO Codeforces        |                   1429 |            1718 |
| GPQA Diamond          |                  73.2% |           82.3% |
| Moyenne Tau2          |                  56.2% |           68.2% |
| HLE sans outils       |                  11.0% |            8.7% |
| HLE avec recherche    |                  11.9% |           17.2% |
| BigBench Extra Hard   |                  47.6% |           64.8% |
| MMMLU                 |                  81.5% |           86.3% |

| Benchmark de long contexte     | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| ------------------------------ | ---------------------: | --------------: |
| Moyenne MRCR v2 8 needles 128K |                  32.0% |           44.1% |

**Benchmarks vision :**

| Benchmark vision                        | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| --------------------------------------- | ---------------------: | --------------: |
| MMMU Pro                                |                  54.3% |           73.8% |
| OmniDocBench 1.5, plus bas est meilleur |                  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/fr/modeles/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.