> 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 open source de Google DeepMind **multimodal** modèle, construit sur [Gemma 4](/docs/fr/modeles/gemma-4.md) l'architecture MoE. Avec la prise en charge de **fenêtre de contexte de 256K**, **140+ langues**, DiffusionGemma est conçu pour **la génération de texte à grande vitesse** à partir d'entrées texte, vidéo et image. DiffusionGemma peut s'exécuter localement sur **18 Go de RAM**et [d’ajustement fin](#fine-tune-diffusiongemma) est désormais pris en charge via [Unsloth](https://github.com/unslothai/unsloth).
Au lieu d'un décodage standard jeton par jeton, DiffusionGemma utilise **la génération par diffusion** pour produire les sorties en parallèle et les affiner progressivement jusqu'à une réponse finale - à l'image des modèles de diffusion pour les 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)
Exécuter DiffusionGemmaAjuster finement DiffusionGemma
{% hint style="success" %}
**12 juin :** Vous pouvez désormais 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 convient à 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 à faible latence sur petits lots.
Contrairement aux modèles Gemma 4 standard, DiffusionGemma nécessite un runtime d'inférence adapté à la diffusion. Les réglages autorégressifs tels que `temperature`, `top_p`et `top_k` seuls ne suffisent pas pour reproduire le comportement recommandé sans l'échantillonneur de diffusion requis.
### Configuration matérielle requise
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 doit au moins dépasser la taille du modèle quantifié que vous téléchargez. Sinon, vous pouvez quand même l'exécuter avec un déchargement partiel vers la RAM/le disque, mais la génération sera plus lente. Vous aurez également besoin de plus de calculs, selon la fenêtre de contexte utilisée.
{% endhint %}
## Tutoriels pour exécuter DiffusionGemma
Il est préférable d'utiliser au moins une précision 4 bits, donc nous utiliserons le quant 4 bits `Q4_K_M` qui nécessite 18 Go de RAM. **GGUF :** [diffusiongemma-26B-A4B-it-GGUF](https://huggingface.co/unsloth/diffusiongemma-26B-A4B-it-GGUF)
🦥 Guide d’Unsloth Studio🦙 Guide Llama.cpp
### 🦥 Guide d’Unsloth Studio
{% hint style="success" %}
Vous pouvez désormais 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
* [**Auto-réparation** appel 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](https://unsloth.ai/docs/desktop#feature-deep-dive) réglage des paramètres (temp, top-p, etc.)
* Inférence CPU + GPU rapide via llama.cpp
* [Entraîner des LLM](/docs/fr/nouveau/studio.md#no-code-training) 2x plus rapide avec 70 % de VRAM en moins
{% endcolumn %}
{% column %}
{% 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
Au premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter.
Ensuite, allez dans l’onglet [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 le quant 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, cependant vous pouvez toujours les modifier manuellement. Vous pouvez aussi 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 d’Unsloth Studio](/docs/fr/nouveau/studio/chat.md).
{% endstep %}
{% endstepper %}
### 🦙 Guide Llama.cpp
Pour ce tutoriel, nous utiliserons le quant 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 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 souhaitez 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
# compilation 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 restent bloqués, voir : [Débogage de Hugging Face Hub et XET](/docs/fr/notions-de-base/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
Ensuite, exécutez 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 :
Et si vous tapez une question comme "Créez un jeu Flappy Bird", vous verrez les étapes :
Ensuite, vous verrez le résultat :
Vous pouvez aussi continuer la conversation !
Modifiez `-n 2048` comme nombre de jetons que vous souhaitez 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 :
Et nous obtenons :
Tous les paramètres de llama.cpp utilisant la branche :
* `-n, --n-predict N` - jetons cibles ; dérive `--diffusion-blocks` et augmente `-ub` / `-b` / `-c`.
* `-ngl 99` - décharge toutes les couches sur le GPU (`-ngl 0` pour CPU uniquement).
* `-cnv` - mode conversation multi-tour.
* `--diffusion-visual` - vue en direct du débruitage du canevas.
* L'échantillonneur à borne d'entropie est activé par défaut (`--diffusion-eb auto`). Réglez-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 du prompt (auto = activé pour un seul GPU).
## Ajuster finement DiffusionGemma
Vous pouvez désormais 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 d'abord mal sur les tâches de Sudoku, mais après entraînement sur un ensemble de données ciblé, il apprend à résoudre réellement le Sudoku et résout correctement chaque exemple.
Vous pouvez utiliser notre notebook Colab (A100) pour ajuster finement DiffusionGemma avec :
{% embed url="" %}
## 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 | Calendrier de température | `linear_decay` |
| Température | Température de départ | `0.8` |
| Température | Température de fin | `0.4` |
| Entropie | Borne 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** les 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 à plus faible entropie dont la borne d'information mutuelle reste : `entropy_bound = 0.1`. Les jetons non sélectionnés doivent être entièrement rebruités avant la prochaine étape de débruitage.
### Mode réflexion
DiffusionGemma prend en charge le mode de pensée à la Gemma 4. Pour l'activer, ajoutez le jeton de pensée au début du prompt système :
```
<|think|>
```
Lorsque le mode de pensée est activé, le modèle peut émettre un canal de raisonnement interne suivi de la réponse finale :
```
<|channel>thought
[raisonnement interne]
[réponse finale]
```
Pour désactiver le mode de pensée, retirez le `<|think|>` jeton du prompt système. Lorsque le mode de pensée est désactivé, le modèle peut quand même émettre un canal de pensée vide :
```
<|channel>thought
[réponse finale]
```
Pour les conversations à plusieurs tours, ne **rend** incluez pas les pensées cachées précédentes dans l'historique de conversation. N'incluez que la réponse finale de l'assistant avant le prochain tour utilisateur.
## Bonnes pratiques pour DiffusionGemma
### Invitations multimodales
DiffusionGemma prend en charge des entrées multimodales entrelacées, notamment 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 invites multimodales, placez le contenu image ou trame 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 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'images |
| 560 | OCR, graphiques, captures d'écran d'interface |
| 1120 | Documents denses, petit texte, extraction détaillée |
Pour les entrées de type vidéo, DiffusionGemma peut traiter jusqu'à **60 secondes** lorsqu'il est échantillonné à **1 image par seconde**.
### Notes sur l'échantillonnage
DiffusionGemma n'est pas un modèle classique uniquement next-token. 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 à peu près 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 le canevas de manière itérative.
4. Les jetons confiants sont sélectionnés et conservés.
5. Les jetons incertains sont rebruités puis raffinés à nouveau.
6. Une fois le canevas terminé, il est ajouté au contexte.
7. Le modèle continue avec le canevas suivant.
Cette approche bloc-autoregressive permet à DiffusionGemma de générer de nombreux jetons en moins de passes de calcul qu'un modèle autorégressif standard.
## Benchmarks
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 contexte long | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| -------------------------------- | ---------------------: | --------------: |
| Moyenne MRCR v2 8 aiguilles 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 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/fr/modeles/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)