> 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/gemma-4.md).
# Gemma 4 - comment l'exécuter localement
Exécutez localement les nouveaux modèles Gemma 4 de Google, y compris E2B, E4B, 26B A4B et 31B.
Gemma 4 est la nouvelle famille de modèles ouverts de Google DeepMind, comprenant **12B**, **E2B**, **E4B**, **26B-A4B**et **31B.** Les modèles multimodaux à réflexion hybride prennent en charge plus de 140 langues, jusqu’à **fenêtre de contexte de 256K**, et disposent de variantes denses et MoE. Gemma 4 est sous licence Apache-2.0 et peut s’exécuter sur votre appareil local.
**Gemma-4-12B** est nouveau et offre une prise en charge unifiée du texte, de l’image et de l’audio. Il fonctionne sur **8 Go** de RAM (4 bits) ou 14 Go (8 bits). **Gemma-4-E2B** et **E4B** prend également en charge l’image et l’audio. Fonctionne sur **5 Go de RAM** (4 bits) ou 15 Go (16 bits complets) via des quantifications GGUF, MLX ou NVFP4.
Exécuter Gemma 4Fine-tuner Gemma 4Gemma 4 QATGemma 4 MTP
{% hint style="success" %}
**NOUVEAU :** [**Gemma 4 MTP est disponible**](/docs/fr/modeles/mtp.md)**! MTP permet une inférence 1,4 à 2,2× plus rapide sans perte de précision. Exécutez MTP directement dans** [**Unsloth Studio**](/docs/fr/modeles/mtp.md#unsloth-studio-mtp-guide)**.**
{% endhint %}
{% columns %}
{% column %}
**Gemma-4-26B-A4B** fonctionne sur **18 Go** (4 bits) ou 28 Go (8 bits). **Gemma-4-31B** nécessite **20 Go de RAM** (4 bits) ou 34 Go (8 bits).
Vous pouvez désormais exécuter tous les GGUFs, [MLX](#mlx-dynamic-quants) et fine-tuner Gemma 4 dans [Unsloth Studio](#unsloth-studio-guide) (voir à droite).
[**QAT** variantes](/docs/fr/modeles/gemma-4/qat.md) de Gemma 4 réduisent les besoins en mémoire d’environ 3× tout en préservant la qualité du modèle.
{% endcolumn %}
{% column %}
{% endcolumn %}
{% endcolumns %}
{% hint style="success" %}
**9 juin :** [Gemma 4 MTP](/docs/fr/modeles/mtp.md) est disponible.
**5 juin :** [Gemma 4 QAT](/docs/fr/modeles/gemma-4/qat.md) est sortie.
**2 juin :** Gemma 4 12B Unified est sorti.
**20 avril :** Nous avons réalisé [Benchmarks GGUF de Gemma 4](#unsloth-gguf-benchmarks) pour vous aider à choisir la meilleure quantification.
{% endhint %}
### Guide d’utilisation
Gemma 4 excelle en raisonnement, en codage, en utilisation d’outils, en workflows à long contexte et agentiques, ainsi que dans les tâches multimodales. Les variantes plus petites E2B et E4B sont conçues pour les téléphones et les ordinateurs portables, tandis que les modèles plus grands ciblent les systèmes CPU/VRAM de milieu à haut de gamme, comme les PC équipés de GPU NVIDIA RTX.
| Variante Gemma 4 | Détails | Le plus adapté |
| ---------------- | --------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| **E2B** |
| Petit modèle pour les ordinateurs portables et l’usage multimodal local rapide |
| **12B Unified** |
Dense (contexte 256K) Prise en charge : texte, image, audio
| Modèle intermédiaire pour les ordinateurs portables et l’usage multimodal local |
| **26B-A4B** |
MoE (contexte 256K) Prise en charge : texte, image
| Meilleur compromis vitesse / qualité pour un usage sur ordinateur |
| **31B** |
Dense (contexte 256K) Prise en charge : texte, image
| Meilleures performances à une inférence plus lente |
**Voir Gemma 4 :** [**Benchmarks de performance**](#official-gemma-benchmarks) **et** [**Benchmarks GGUF**](#unsloth-gguf-benchmarks)**.**
**Dois-je choisir 26B-A4B ou 31B ?**
* **26B-A4B** - équilibre vitesse et précision. Son architecture MoE le rend plus rapide que 31B, avec 4B de paramètres actifs. Choisissez-le si la RAM est limitée et si vous êtes prêt à échanger un peu de qualité contre la vitesse.
* **31B** - actuellement le modèle Gemma 4 le plus performant. Choisissez-le pour une qualité maximale si vous disposez de suffisamment de mémoire et pouvez accepter des vitesses légèrement plus lentes.
### Exigences matérielles
**Tableau : exigences matérielles recommandées pour l’inférence GGUF de Gemma 4** (unités = mémoire totale : RAM + VRAM, ou mémoire unifiée). Vous pouvez utiliser Gemma 4 sur macOS, les GPU NVIDIA RTX, etc.
| Variante Gemma 4 | 4 bits | 8 bits | BF16 / FP16 |
| ---------------- | -------: | -------: | ----------: |
| **E2B** | 4 Go | 5–8 Go | 10 Go |
| **E4B** | 5,5–6 Go | 9–12 Go | 16 Go |
| **12B Unified** | 7–8 Go | 13–14 Go | 25 Go |
| **26B A4B** | 16–18 Go | 28–30 Go | 52 Go |
| **31B** | 17–20 Go | 34–38 Go | 62 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. Si ce n’est pas le cas, llama.cpp peut quand même fonctionner 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 %}
### Paramètres recommandés
Il est recommandé d’utiliser les paramètres par défaut de Gemma 4 de Google :
* `température = 1.0`
* `top_p = 0.95`
* `top_k = 64`
{% hint style="info" %}
Le contexte max de Gemma 4 est de **128K** pour **E2B** / **E4B** et `262,144` pour **12B** / **26B A4B** / **31B**.
{% endhint %}
#### Mode réflexion
Par rapport aux anciens modèles de chat Gemma, Gemma 4 utilise les rôles standards **`système`**, **`assistant`**et **`utilisateur`** et ajoute un contrôle explicite de la réflexion.
**Comment activer la réflexion :**
Ajoutez le jeton **`<|think|>`** au **début du prompt système**.
{% columns %}
{% column %}
**Réflexion activée**
```
<|think|>
Vous êtes un assistant de codage minutieux. Expliquez clairement votre réponse.
```
{% endcolumn %}
{% column %}
**Réflexion désactivée**
```
Vous êtes un assistant de codage minutieux. Expliquez clairement votre réponse.
```
{% endcolumn %}
{% endcolumns %}
**Comportement de sortie :**
{% columns %}
{% column %}
Lorsque la réflexion est activée, le modèle affiche son canal de raisonnement interne avant la réponse finale.
```
<|channel>thought
[raisonnement interne]
[réponse finale]
```
{% endcolumn %}
{% column %}
Lorsque la réflexion est désactivée, les modèles plus grands peuvent quand même émettre un **bloc de pensée vide** avant la réponse finale.
```
<|channel>thought
[réponse finale]
```
{% endcolumn %}
{% endcolumns %}
**Par exemple, en utilisant "**Quelle est la capitale de la France ?":
{% code overflow="wrap" %}
```
<|turn>system\n<|think|>\n<|turn>user\nQuelle est la capitale de la France ?\n<|turn>model\n
```
{% endcode %}
**alors il affiche :**
{% code overflow="wrap" %}
```
<|channel>thought\nL'utilisateur demande quelle est la capitale de la France.\nLa capitale de la France est Paris.La capitale de la France est Paris.
```
{% endcode %}
**Règle de chat à plusieurs tours :**
Pour les conversations à plusieurs tours, **ne conservez que la réponse finale visible dans l’historique du chat**. Ne **rend** réinjectez pas les blocs de pensée précédents dans le tour suivant.
{% code overflow="wrap" %}
```
<|turn>user\nQuel est le résultat de 1+1 ?\n<|turn>model\n2\n<|turn>user\nQuel est le résultat de 1+1 ?\n<|turn>model\n2\n<|turn>user\nQuel est le résultat de 1+1 ?\n<|turn>model\n2\n<|turn>user\nQuel est le résultat de 1+1 ?\n<|turn>model\n2\n
```
{% endcode %}
**Comment désactiver la réflexion :**
Remarque `llama-cli` peut ne pas fonctionner de façon fiable, donc utilisez `llama-server` pour désactiver le raisonnement :
{% hint style="warning" %}
Pour [désactiver la réflexion / le raisonnement](#how-to-enable-or-disable-reasoning-and-thinking), utilisez `--chat-template-kwargs '{"enable_thinking":false}'`
Si vous êtes sur **Windows** PowerShell, utilisez : `--chat-template-kwargs "{\"enable_thinking\":false}"`
Utilisez indifféremment « true » et « false ».
{% endhint %}
## Tutoriels pour exécuter Gemma 4
Comme les GGUF Gemma 4 existent en plusieurs tailles, le point de départ recommandé pour les petits modèles est le 8 bits et pour les modèles plus grands, le [**Dynamic**](/docs/fr/notions-de-base/dynamic-3.0-ggufs.md) **4 bits**. [GGUF Gemma 4](https://huggingface.co/collections/unsloth/gemma-4) ou [MLX](#mlx-dynamic-quants) ou [NVFP4](#nvfp4-guide):
| [E2B](https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF) | [E4B](https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF) | [12b](https://huggingface.co/unsloth/gemma-4-12b-it-GGUF) | [26B-A4B](https://huggingface.co/unsloth/gemma-4-26B-A4B-it-GGUF) | [31B](https://huggingface.co/unsloth/gemma-4-31B-it-GGUF) |
| --------------------------------------------------------- | --------------------------------------------------------- | --------------------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------- |
🦥 Guide Unsloth Desktop🦙 Guide Llama.cppGuide NVFP4
{% columns %}
{% column %}
**Vous pouvez exécuter et entraîner Gemma 4 gratuitement avec une interface dans notre** [**Unsloth Studio**](/docs/fr/nouveau/studio.md)✨ **notebook :**
{% endcolumn %}
{% column %}
{% embed url="" %}
{% endcolumn %}
{% endcolumns %}
### 🦥 Guide Unsloth
Gemma 4 peut désormais être exécuté et affiné dans [Unsloth Desktop](/docs/fr/nouveau/studio.md), notre nouvelle interface de bureau 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
La façon la plus simple de commencer est de télécharger l' [application Unsloth Desktop](/docs/fr/desktop.md). Fonctionne sur [macOS](/docs/fr/commencer/install/mac.md), [Windows](/docs/fr/commencer/install/windows-installation.md)et [Linux](/docs/fr/commencer/install/linux.md).
Télécharger Unsloth
* :apple: [Télécharger pour macOS](https://unsloth.ai/download/mac)
* :windows: [Télécharger pour Windows](https://unsloth.ai/download/windows)
* :linux: [Télécharger pour Linux](https://unsloth.ai/download/linux)
Ou, si vous préférez installer manuellement :
**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.
**Lancez Unsloth en toute sécurité avec HTTPS et Cloudflare**
**NOUVEAU !** Unsloth propose désormais un moyen sécurisé de lancer Unsloth via HTTPS grâce à un tunnel Cloudflare gratuit. Utilisez ce qui suit (fonctionne sous Windows, Mac et Linux) :
```bash
unsloth studio --secure
```
{% endstep %}
{% step %}
#### Rechercher et télécharger Gemma 4
Lors du 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 Gemma 4 dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités. Unsloth prend en charge le dernier modèle Gemma-4-12B Unified.
{% endstep %}
{% step %}
#### Exécuter Gemma 4
Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, toutefois vous pouvez toujours les modifier manuellement. Vous pouvez aussi modifier la longueur du contexte, le gabarit de conversation et d’autres paramètres. Vous pouvez exécuter des fichiers GGUF et MLX.
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 guide, nous utiliserons le 4 bits dynamique pour les 12B, 26B-A4B et 31B, et le 8 bits pour E2B et E4B. Voir : [Collection GGUF Gemma 4](https://huggingface.co/collections/unsloth/gemma-4)
Pour ces tutoriels, nous utiliserons [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 dernière version `llama.cpp` **sur** [**GitHub ici**](https://github.com/ggml-org/llama.cpp). 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
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
-DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```
{% endstep %}
{% step %}
Si vous souhaitez utiliser `llama.cpp` pour charger directement les modèles, vous pouvez suivre les commandes ci-dessous, selon chaque modèle. `UD-Q4_K_XL` est le type de quantification. Vous pouvez également télécharger via Hugging Face (étape 3). C’est similaire à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` pour enregistrer dans un emplacement spécifique. Il n’est pas nécessaire de définir la longueur du contexte, car llama.cpp utilise automatiquement la quantité exacte requise.
{% hint style="warning" %}
Pour [désactiver la réflexion / le raisonnement](#how-to-enable-or-disable-reasoning-and-thinking), utilisez : `--chat-template-kwargs '{"enable_thinking":false}'`
**Windows** PowerShell : `--chat-template-kwargs "{\"enable_thinking\":false}"`
Utilisez '`true`' et '`false`' de manière interchangeable.
{% endhint %}
**12B :**
```bash
export LLAMA_CACHE="unsloth/gemma-4-12B-it-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/gemma-4-12b-it-GGUF:UD-Q4_K_XL \\
--temp 1.0 \
--top-p 0.95 \
--top-k 64
```
**26B-A4B :**
```bash
export LLAMA_CACHE="unsloth/gemma-4-26B-A4B-it-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \\
--temp 1.0 \
--top-p 0.95 \
--top-k 64
```
**31B :**
```bash
export LLAMA_CACHE="unsloth/gemma-4-31B-it-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/gemma-4-31B-it-GGUF:UD-Q4_K_XL \\
--temp 1.0 \
--top-p 0.95 \
--top-k 64
```
**E4B :**
```bash
export LLAMA_CACHE="unsloth/gemma-4-E4B-it-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/gemma-4-E4B-it-GGUF:Q8_0 \\
--temp 1.0 \
--top-p 0.95 \
--top-k 64
```
**E2B :**
```bash
export LLAMA_CACHE="unsloth/gemma-4-E2B-it-GGUF"
./llama.cpp/llama-cli \
-hf unsloth/gemma-4-E2B-it-GGUF:Q8_0 \\
--temp 1.0 \
--top-p 0.95 \
--top-k 64
```
{% endstep %}
{% step %}
Vous pouvez également télécharger le modèle manuellement via le code ci-dessous (après avoir installé `pip install huggingface_hub`). Vous pouvez choisir `UD-Q4_K_XL` ou d'autres versions quantifiées comme `Q8_0` . Si les téléchargements se bloquent, voir : [Débogage de Hugging Face Hub et XET](/docs/fr/notions-de-base/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)
```bash
hf download unsloth/gemma-4-26B-A4B-it-GGUF \\
--local-dir unsloth/gemma-4-26B-A4B-it-GGUF \\
--include "*mmproj-BF16*" \\
--include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour le Dynamic 2 bits
```
{% endstep %}
{% step %}
Puis exécutez le modèle en mode conversation (avec vision `mmproj-F16`):
{% code overflow="wrap" %}
```bash
./llama.cpp/llama-cli \
--model unsloth/gemma-4-26B-A4B-it-GGUF/gemma-4-26B-A4B-it-UD-Q4_K_XL.gguf \
--mmproj unsloth/gemma-4-26B-A4B-it-GGUF/mmproj-BF16.gguf \\
--temp 1.0 \
--top-p 0.95 \
--top-k 64
```
{% endcode %}
{% endstep %}
{% step %}
#### Déploiement Llama-server
Pour déployer Gemma-4 sur llama-server, utilisez :
```bash
./llama.cpp/llama-server \
--model unsloth/gemma-4-26B-A4B-it-GGUF/gemma-4-26B-A4B-it-UD-Q4_K_XL.gguf \
--mmproj unsloth/gemma-4-26B-A4B-it-GGUF/mmproj-BF16.gguf \\
--temp 1.0 \
--top-p 0.95 \
--top-k 64 \\
--alias "unsloth/gemma-4-26B-A4B-it-GGUF" \\
--port 8001 \
--chat-template-kwargs '{"enable_thinking":true}'
```
{% endstep %}
{% endstepper %}
### Quantifications dynamiques MLX
Nous avons également mis en ligne des quantifications dynamiques 4 bits et 8 bits comme premier essai pour les appareils macOS ! Les quantifications MLX prennent en charge **la vision.**
{% hint style="success" %}
Toutes les quantifications MLX fonctionnent désormais en[ Unsloth Studio](#unsloth-studio-guide)!
{% endhint %}
| Gemma 4 | MLX 4 bits | MLX 8 bits |
| ------- | --------------------------------------------------------------------- | ------------------------------------------------------------------ |
| 31B | [lien](https://huggingface.co/unsloth/gemma-4-31b-it-UD-MLX-4bit) | [lien](https://huggingface.co/unsloth/gemma-4-31b-it-MLX-8bit) |
| 26B-A4B | [lien](https://huggingface.co/unsloth/gemma-4-26b-a4b-it-UD-MLX-4bit) | [lien](https://huggingface.co/unsloth/gemma-4-26b-a4b-it-MLX-8bit) |
| E4B | [lien](https://huggingface.co/unsloth/gemma-4-E4B-it-UD-MLX-4bit) | [lien](https://huggingface.co/unsloth/gemma-4-E4B-it-MLX-8bit) |
| E2B | [lien](https://huggingface.co/unsloth/gemma-4-E2B-it-UD-MLX-4bit) | [lien](https://huggingface.co/unsloth/gemma-4-E2B-it-MLX-8bit) |
Pour les essayer, utilisez :
{% code overflow="wrap" %}
```bash
curl -fsSL https://raw.githubusercontent.com/unslothai/unsloth/refs/heads/main/scripts/install_gemma4_mlx.sh | sh
source ~/.unsloth/unsloth_gemma4_mlx/bin/activate
python -m mlx_vlm.chat --model unsloth/gemma-4-26b-a4b-it-UD-MLX-4bit
```
{% endcode %}
### **Guide NVFP4**
Nous avons mis en ligne [Dynamic NVFP4](/docs/fr/notions-de-base/nvfp4.md) des quantifications Gemma 4 pour une inférence 4 bits plus rapide sur les GPU NVIDIA Blackwell. Voici les exigences matérielles pour les modèles que vous pouvez utiliser, y compris Gemma 4. Voir aussi le gain global de vitesse que vous obtiendrez :
| Variante Gemma 4 | VRAM requise | Plus rapide que BF16 |
| ------------------------------------------------------------------ | -----------: | -------------------: |
| [E2B](https://huggingface.co/unsloth/gemma-4-E2B-it-NVFP4) | 7 Go | 1,12× plus rapide |
| [E4B](https://huggingface.co/unsloth/gemma-4-E4B-it-NVFP4) | 9 Go | 1,22× plus rapide |
| [12B Unified](https://huggingface.co/unsloth/gemma-4-12b-it-NVFP4) | 11 Go | 1,26× plus rapide |
| [26B A4B](https://huggingface.co/unsloth/gemma-4-26B-A4B-it-NVFP4) | 26 Go | 1,41× plus rapide |
| [31B](https://huggingface.co/unsloth/gemma-4-31B-it-NVFP4) | 32 Go | 1,45× plus rapide |
#### **Tutoriel vLLM :**
Pour exécuter les quantifications NVFP4, voir ci-dessous les commandes pour exécuter Gemma-4-26B-A4B en [vLLM](/docs/fr/notions-de-base/inference-and-deployment/vllm-guide.md) et [SGLang](/docs/fr/notions-de-base/inference-and-deployment/sglang-guide.md) (vous pouvez changer le nom du modèle en `gemma-4-31B-it-NVFP4` etc.) N’utilisez pas non plus de backend MoE - laissez vLLM le sélectionner - par exemple Marlin est 2,5× plus lent ! Voir [#marlin-vs-flashinfer-vs-cutlass-vs-cute-dsl](#marlin-vs-flashinfer-vs-cutlass-vs-cute-dsl "mention")Si vous avez un DGX Spark, voir [#dgx-spark-serving](#dgx-spark-serving "mention") vous devez utiliser `--moe-backend flashinfer_b12x` sinon vous obtiendrez une inférence beaucoup plus lente.
Pour installer vLLM dans un venv séparé :
{% code overflow="wrap" expandable="true" %}
```bash
uv venv unsloth-nvfp4-env --python 3.13
source unsloth-nvfp4-env/bin/activate
uv pip install "vllm>=0.25.0" "flashinfer-python>=0.6.13" "nvidia-cutlass-dsl>=4.5.2" \\
--torch-backend=auto
```
{% endcode %}
Puis, pour servir la variante MoE 26B :
```shell
vllm serve unsloth/gemma-4-26B-A4B-it-NVFP4
```
Modifiez `unsloth/gemma-4-26B-A4B-it-NVFP4` à n’importe quel [NVFP4](/docs/fr/notions-de-base/nvfp4.md#overview) nom de quantification !
Pour activer MTP / décodage spéculatif (décodage plus rapide mais débit quelque peu inférieur), utilisez :
```bash
vllm serve unsloth/gemma-4-26B-A4B-it-NVFP4
--speculative-config '{"method": "mtp", "num_speculative_tokens": 2}'
```
Si vous rencontrez des problèmes Torchcodec, assurez-vous de faire ce qui suit puis relancez vllm.
{% code overflow="wrap" expandable="true" %}
```bash
sudo apt-get update
sudo apt-get install -y ffmpeg
```
{% endcode %}
#### **DGX Spark avec quantifications NVFP4**
Pour s’assurer que DGX Spark possède les bons kernels (sinon vous obtiendrez **une inférence 2x PLUS LENTE**), vérifiez d’abord :
{% code overflow="wrap" expandable="true" %}
```bash
python -c \"
import torch; from vllm.utils.flashinfer import has_flashinfer_b12x_gemm as g, has_flashinfer_b12x_moe as m
cap = torch.cuda.get_device_capability(); print('cap', cap, '| b12x gemm', g(), '| b12x moe', m()); assert cap[0] == 12 and g() and m(), 'b12x indisponible : le service reviendrait à marlin W4A16'\"
```
{% endcode %}
qui ne devrait PAS produire d’erreur — si c’était le cas, veuillez mettre à jour vllm ou réinstaller via :
{% code overflow="wrap" expandable="true" %}
```bash
uv venv unsloth-nvfp4-env --python 3.13
source unsloth-nvfp4-env/bin/activate
uv pip install "vllm>=0.25.0" "flashinfer-python>=0.6.13" "nvidia-cutlass-dsl>=4.5.2" \\
--torch-backend=auto
```
{% endcode %}
Ensuite, pour servir dans vLLM pour DGX Spark :
{% code overflow="wrap" expandable="true" %}
```shellscript
export CUTE_DSL_ARCH=sm_121a
vllm serve unsloth/gemma-4-26B-A4B-it-NVFP4 --moe-backend flashinfer_b12x
```
{% endcode %}
Si vous rencontrez des problèmes Torchcodec, assurez-vous de faire ce qui suit puis relancez vllm.
{% code overflow="wrap" expandable="true" %}
```bash
sudo apt-get update
sudo apt-get install -y ffmpeg
```
{% endcode %}
#### **Tutoriel SGLang :**
```bash
python -m sglang.launch_server --model-path unsloth/gemma-4-31B-it-NVFP4 --speculative-algorithm NEXTN \\
--speculative-num-steps 3 --speculative-eagle-topk 1 --speculative-num-draft-tokens 4
```
### Guide Ollama
Ollama prend désormais bien en charge les GGUF d’Unsloth. Utilisez `curl -fsSL https://ollama.com/install.sh | sh` pour installer Ollama sur Linux ou `irm https://ollama.com/install.ps1 | iex` pour Windows.\
\
Pour utiliser un seul fichier de quantification (moins de 50 Go), utilisez :
{% code overflow="wrap" %}
```bash
ollama run hf.co/unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL
```
{% endcode %}
Pour plusieurs shards, comme les shards BF16 plus volumineux, faites :
{% code overflow="wrap" %}
```bash
pip install -U huggingface_hub
# Téléchargez mmproj et BF16 en 2 appels
hf download unsloth/gemma-4-26B-A4B-it-GGUF --include "BF16/*" \\
--local-dir gemma4
hf download unsloth/gemma-4-26B-A4B-it-GGUF --include "mmproj-BF16.gguf" \\
--local-dir gemma4
mv gemma4/mmproj-BF16.gguf gemma4/BF16/
echo "FROM ./gemma4/BF16" > Modelfile
ollama create unsloth-gemma4 -f Modelfile
ollama run unsloth-gemma4
```
{% endcode %}
{% hint style="info" %}
Si vous voyez `Erreur : 500 Erreur interne du serveur : impossible de charger le modèle` mettez à jour Ollama via `curl -fsSL https://ollama.com/install.sh | sh` ou utilisez celle de PowerShell.
{% endhint %}
## Bonnes pratiques Gemma 4
### Exemples d’invites
#### Invite de raisonnement simple
```
Système :
<|think|>
Vous êtes un assistant de raisonnement précis.
Utilisateur :
Un train part à 8 h 15 et arrive à 11 h 47. Quelle a été la durée du trajet ?
```
#### Invite OCR / document
Pour l’OCR, utilisez un **budget élevé de jetons visuels** comme **560** ou **1120**.
```
[image first]
Extrayez tout le texte de ce reçu. Retournez les éléments de ligne, le total, le commerçant et la date au format JSON.
```
#### Invite de comparaison multimodale
```
[image 1]
[image 2]
Comparez ces deux captures d’écran et dites-moi laquelle est la plus susceptible de dérouter un nouvel utilisateur.
```
#### Invite ASR audio
```
Transcrivez le segment vocal suivant en texte {LANGUAGE} dans la langue {LANGUAGE}.
Suivez ces instructions spécifiques pour formater la réponse :
* N’affichez que la transcription, sans aucun retour à la ligne.
* Lors de la transcription des nombres, écrivez les chiffres, c’est-à-dire écrivez 1.7 et non un point sept, et écrivez 3 au lieu de trois.
```
#### Invite de traduction audio
```
Transcrivez le segment vocal suivant en {SOURCE_LANGUAGE}, puis traduisez-le en {TARGET_LANGUAGE}. Lors du formatage de la réponse, affichez d’abord la transcription en {SOURCE_LANGUAGE}, puis un saut de ligne, puis la chaîne '{TARGET_LANGUAGE}: ', puis la traduction en {TARGET_LANGUAGE}.
```
### Paramètres multimodaux
Pour de meilleurs résultats avec les invites multimodales, placez d’abord le contenu multimodal :
* Placez **l’image et/ou l’audio avant le texte**.
* Pour la vidéo, passez d’abord une séquence d’images, puis l’instruction.
#### Limites audio et vidéo
* **Audio** est disponible sur **12B**, **E2B** et **E4B** uniquement.
* L’audio prend en charge un maximum de **30 secondes**.
* La vidéo prend en charge un maximum de **60 secondes** en supposant **1 image par seconde** de traitement.
#### Modèles d’invite audio
**Invite ASR**
```
Transcrivez le segment vocal suivant en texte {LANGUAGE} dans la langue {LANGUAGE}.
Suivez ces instructions spécifiques pour formater la réponse :
* N’affichez que la transcription, sans aucun retour à la ligne.
* Lors de la transcription des nombres, écrivez les chiffres, c’est-à-dire écrivez 1.7 et non un point sept, et écrivez 3 au lieu de trois.
```
**Invite de traduction vocale**
```
Transcrivez le segment vocal suivant en {SOURCE_LANGUAGE}, puis traduisez-le en {TARGET_LANGUAGE}.
Lors du formatage de la réponse, affichez d’abord la transcription en {SOURCE_LANGUAGE}, puis un saut de ligne, puis la chaîne '{TARGET_LANGUAGE}: ', puis la traduction en {TARGET_LANGUAGE}.
```
## 📊 Benchmarks
### Benchmarks GGUF d'Unsloth
Nous avons réalisé des benchmarks de divergence KL moyenne pour les GGUF Gemma 4 chez différents fournisseurs afin de vous aider à choisir la meilleure quantification (plus bas, mieux c’est).
* La divergence KL place tous les GGUF d’Unsloth sur la frontière de Pareto de l’état de l’art
* La KLD montre dans quelle mesure un modèle quantifié correspond à la distribution de sortie BF16 d’origine, indiquant la précision conservée.
---
# 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/gemma-4.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.
