> 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 exécuter localement
DiffusionGemma **26B-A4B** est le nouveau modèle ouvert de **multimodal** de Google DeepMind, construit sur [Gemma 4](/docs/fr/modeles/gemma-4.md) l’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** à partir d’entrées texte, vidéo et image. DiffusionGemma peut s’exécuter localement sur **18 Go de RAM**, et [ajustement fin](#fine-tune-diffusiongemma) est désormais pris en charge via [Unsloth](https://github.com/unslothai/unsloth).
Au lieu du décodage standard token par token, DiffusionGemma utilise **la génération par diffusion** pour produire les sorties en parallèle et les affiner progressivement jusqu’à obtenir une réponse finale - de manière similaire aux modèles d’images par diffusion, 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 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 en petits lots à faible latence.
Contrairement aux modèles Gemma 4 standard, DiffusionGemma nécessite un moteur d’inférence compatible avec la diffusion. Les réglages autorégressifs tels que `température`, `top_p`, et `top_k` seuls ne suffisent pas pour reproduire le comportement recommandé sans l’échantillonneur de diffusion requis.
### Exigences matérielles
Il est généralement 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, la 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 vers 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 `Q4_K_M` quantifié, 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é en [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 rapide sur CPU + GPU 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 le dernier [`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.
Puis 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 la quantification souhaités.
{% endstep %}
{% step %}
#### Exécuter DiffusionGemma
Les paramètres d'inférence doivent être définis automatiquement lors de l'utilisation d'Unsloth Studio ; toutefois, vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur de contexte, le gabarit de conversation 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).
{% endstep %}
{% endstepper %}
### 🦙 Guide Llama.cpp
Pour ce tutoriel, nous allons utiliser 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 le PR SPÉCIFIQUE `llama.cpp` sur [**GitHub ici**](https://github.com/ggml-org/llama.cpp/pull/24423). Vous pouvez également suivre les instructions de compilation ci-dessous. Remplacez `-DGGML_CUDA=ON` par `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez simplement une inférence sur 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épannage de Hugging Face Hub, 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
Puis 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ée un jeu Flappy Bird », vous verrez des étapes :
Puis ensuite, vous verrez la sortie :
Vous pouvez aussi poursuivre la conversation !
Modifiez `-n 2048` comme nombre de jetons que vous souhaitez prédire, donc un nombre plus élevé 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 en 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 vers le GPU (`-ngl 0` pour CPU uniquement).
* `-cnv` - mode de conversation multi-tours.
* `--diffusion-visual` - vue en direct du débruitage de la toile.
* 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 du prompt (auto = activé sur un seul GPU).
## Ajuster DiffusionGemma
Vous pouvez désormais entraîner et ajuster DiffusionGemma directement avec [**Unsloth**](#unsloth-studio-guide). Dans notre exemple, nous démontrons l’impact d’un entraînement spécifique à un domaine en ajustant le modèle sur Sudoku. Le modèle de base performe d’abord mal sur les tâches Sudoku, mais après un entraînement sur un jeu de données ciblé, il apprend à réellement résoudre le sudoku et résout correctement tous les exemples.
Vous pouvez utiliser notre notebook Colab (A100) pour ajuster 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 ce qui suit 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 | Planification de la 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` |
| Toile | Longueur de la toile | `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 de la toile | `< 0.005` |
| Les jetons à probabilité la plus élevée sont 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 complètement redébruité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]
[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 tout de même émettre un canal de pensée vide :
```
<|channel>thought
[réponse finale]
```
Pour les conversations multi-tours, **ne** pas inclure les pensées cachées précédentes dans l’historique de la conversation. N’incluez que la réponse finale de l’assistant avant le tour utilisateur suivant.
## Bonnes pratiques pour DiffusionGemma
### Prompt multimodal
DiffusionGemma prend en charge des entrées multimodales entremêlé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 image ou image par image avant les instructions textuelles. Exemple :
```
[image]
Décrivez le graphique et résumez la tendance clé.
```
Pour l’analyse de documents, l’OCR, la compréhension de graphiques, la compréhension d’interface ou l’extraction de petit texte, 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’elles sont échantillonnées à **1 image par seconde**.
### Notes sur l’échantillonnage
DiffusionGemma n’est pas un modèle normal ne prédisant que le jeton suivant. Il génère un bloc de jetons, appelé **toile**, en affinant de manière répétée 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 une toile de génération de 256 jetons.
3. L’échantillonneur de diffusion débruite la toile de manière itérative.
4. Les jetons les plus confiants sont sélectionnés et conservés.
5. Les jetons incertains sont redébruités et affinés à nouveau.
6. Une fois la toile terminée, elle est ajoutée au contexte.
7. Le modèle continue avec la toile suivante.
Cette approche bloc-autoregressive permet à DiffusionGemma de générer de nombreux jetons en moins de passes avant 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 à long contexte | DiffusionGemma 26B-A4B | Gemma 4 26B-A4B |
| ------------------------------ | ---------------------: | --------------: |
| moyenne MRCR v2 8 needles 128K | 32.0% | 44.1% |
**Benchmarks de vision :**
| Benchmark de 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=&goal=
```
`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.