> 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 exécuter localement 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 à raisonnement hybride prennent en charge plus de 140 langues, jusqu'à **contexte de 256K**, et existent en 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 un support unifié du texte, de l'image et de l'audio. Il fonctionne sur **8GB** de RAM (4 bits) ou 14GB (8 bits). **Gemma-4-E2B** et **E4B** prennent aussi en charge l'image et l'audio. Fonctionne sur **5GB RAM** (4 bits) ou 15GB (16 bits complets) via GGUF, MLX ou des quantifications NVFP4. Exécuter Gemma 4Ajuster finement Gemma 4Gemma 4 QATGemma 4 MTP {% hint style="success" %} **NOUVEAU :** [**Gemma 4 MTP est là**](/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 **18GB** (4 bits) ou 28GB (8 bits). **Gemma-4-31B** nécessite **20GB RAM** (4 bits) ou 34GB (8 bits). Vous pouvez désormais exécuter tous les GGUF, [MLX](#mlx-dynamic-quants) et ajuster finement 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 là. **5 juin :** [Gemma 4 QAT](/docs/fr/modeles/gemma-4/qat.md) est publié. **2 juin :** Gemma 4 12B Unified est publié. **20 avr. :** Nous avons réalisé [les benchmarks GGUF de Gemma 4](#unsloth-gguf-benchmarks) pour vous aider à choisir la meilleure quantification. {% endhint %} ### Guide d'utilisation Gemma 4 excelle en raisonnement, codage, usage d'outils, contexte long et workflows agentiques, ainsi que dans les tâches multimodales. Les variantes E2B et E4B plus petites sont conçues pour les téléphones et les ordinateurs portables, tandis que les modèles plus grands ciblent des systèmes CPU / VRAM de gamme moyenne à élevée, comme les PC équipés de GPU NVIDIA RTX. | Variante Gemma 4 | Détails | Cas d'usage idéal | | ---------------- | --------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | | **E2B** |

Dense + PLE (contexte 128K)
Prise en charge : texte, image, audio

| Pour l'inférence sur téléphone / périphérie, ASR, traduction vocale | | **E4B** |

Dense + PLE (contexte 128K)
Prise en charge : texte, image, audio

| Petit modèle pour ordinateurs portables et utilisation multimodale locale rapide | | **12B Unified** |

Dense (contexte 256K)
Prise en charge : texte, image, audio

| Modèle intermédiaire pour ordinateurs portables et utilisation multimodale locale | | **26B-A4B** |

MoE (contexte 256K)
Prise en charge : texte, image

| Meilleur compromis vitesse / qualité pour l'utilisation sur ordinateur | | **31B** |

Dense (contexte 256K)
Prise en charge : texte, image

| Meilleures performances, mais 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. Sa conception MoE le rend plus rapide que le 31B, avec 4B de paramètres actifs. Choisissez-le si la RAM est limitée et que vous êtes prêt à sacrifier un peu de qualité pour la vitesse. * **31B** - actuellement le modèle Gemma 4 le plus performant. Choisissez-le pour une qualité maximale si vous avez suffisamment de mémoire et pouvez accepter des vitesses légèrement plus lentes. ### Configuration matérielle requise **Tableau : Configuration matérielle recommandée 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-bit | 8-bit | 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 utilisée. {% endhint %} ### Paramètres recommandés Il est recommandé d'utiliser les paramètres par défaut de Gemma 4 de Google : * `temperature = 1.0` * `top_p = 0.95` * `top_k = 64` {% hint style="info" %} Le contexte maximal de Gemma 4 est de **128K** pour **E2B** / **E4B** et `262,144` pour **12B** / **26B A4B** / **31B**. {% endhint %} #### Mode de réflexion Par rapport aux anciens modèles de chat Gemma, Gemma 4 utilise les rôles standard **`system`**, **`assistant`**, et **`user`** 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 rigoureux. Expliquez clairement votre réponse. ``` {% endcolumn %} {% column %} **Réflexion désactivée** ``` Vous êtes un assistant de codage rigoureux. Expliquez clairement votre réponse. ``` {% endcolumn %} {% endcolumns %} **Comportement de sortie :** {% columns %} {% column %} Lorsque la réflexion est activée, le modèle produit 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 les plus grands peuvent tout de 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 produit :** {% code overflow="wrap" %} ``` <|channel>thought\nL'utilisateur demande la capitale de la France.\nLa capitale de la France est Paris.La capitale de la France est Paris. ``` {% endcode %} **Règle de chat multi-tour :** Pour les conversations à plusieurs tours, **ne conservez dans l'historique de chat que la réponse finale visible**. Ne **pas** réinjectez les blocs de pensée précédents dans le tour suivant. {% code overflow="wrap" %} ``` <|turn>user\nCombien font 1+1 ?\n<|turn>model\n2\n<|turn>user\nCombien font 1+1 ?\n<|turn>model\n2\n<|turn>user\nCombien font 1+1 ?\n<|turn>model\n2\n<|turn>user\nCombien font 1+1 ?\n<|turn>model\n2\n ``` {% endcode %} **Comment désactiver la réflexion :** Remarque `llama-cli` peut ne pas fonctionner de manière fiable, utilisez donc `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 sous **Windows** PowerShell, utilisez : `--chat-template-kwargs "{\"enable_thinking\":false}"` Utilisez « true » et « false » indifféremment. {% 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 grands modèles c'est [**Dynamic**](/docs/fr/bases/dynamic-3.0-ggufs.md) **4-bit**. [Gemma 4 GGUFs](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 utilisateur 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 ajusté finement 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 rapide CPU + GPU via llama.cpp * [Entraînez des LLM](/docs/fr/nouveau/studio.md#no-code-training) 2× plus rapide avec 70 % de VRAM en moins {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Installer Unsloth Le moyen le 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 l'URL spécifique dans votre navigateur. **Lancez Unsloth de manière sécurisée avec HTTPS et Cloudflare** **NOUVEAU !** Unsloth propose désormais un moyen sécurisé de lancer Unsloth en HTTPS via 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 Au premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter. Ensuite, allez dans l' [Unsloth Chat](/docs/fr/nouveau/studio/chat.md) onglet, recherchez Gemma 4 dans la barre de recherche et 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 doivent être définis automatiquement lors de l'utilisation d'Unsloth Studio ; cependant, vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur du contexte, le modèle de chat 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 Unsloth Studio](/docs/fr/nouveau/studio/chat.md).
{% endstep %} {% endstepper %} ### 🦙 Guide Llama.cpp Pour ce guide, nous utiliserons Dynamic 4 bits pour les 12B, 26B-A4B et 31B, et 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, en particulier si vous avez un CPU. {% stepper %} {% step %} Obtenez la dernière version de `llama.cpp` **sur** [**GitHub ici**](https://github.com/ggml-org/llama.cpp). 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 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` directement pour charger les modèles, vous pouvez suivre les commandes ci-dessous, selon le 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` à l'enregistrement 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`» indifféremment. {% 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épannage de Hugging Face Hub, XET](/docs/fr/bases/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 2 bits dynamique ``` {% endstep %} {% step %} Ensuite, 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 de 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 %} ### Quants dynamiques MLX Nous avons également mis en ligne des quants dynamiques 4 bits et 8 bits pour un premier essai sur appareil MacOS ! Les quants MLX prennent en charge **la vision.** {% hint style="success" %} Tous les quants MLX fonctionnent désormais dans[ 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 [NVFP4 dynamique](/docs/fr/bases/nvfp4.md) des quants Gemma 4 pour une inférence 4 bits plus rapide sur les GPU NVIDIA Blackwell. Ce sont les exigences matérielles pour les modèles que vous pouvez utiliser, y compris Gemma 4. Voyez aussi le gain de vitesse global 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 quants NVFP4, voir ci-dessous les commandes pour lancer Gemma-4-26B-A4B dans [vLLM](/docs/fr/bases/inference-and-deployment/vllm-guide.md) et [SGLang](/docs/fr/bases/inference-and-deployment/sglang-guide.md) (vous pouvez changer le nom du modèle en `gemma-4-31B-it-NVFP4` etc.) Ne sélectionnez 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 l’inférence sera 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 %} Ensuite, pour servir la variante MoE 26B : ```shell vllm serve unsloth/gemma-4-26B-A4B-it-NVFP4 ``` Modifiez `unsloth/gemma-4-26B-A4B-it-NVFP4` pour n’importe quel nom de quant [NVFP4](/docs/fr/bases/nvfp4.md#overview) disponible ! Pour activer MTP / le décodage spéculatif (décodage plus rapide mais débit un peu plus faible), utilisez : ```bash vllm serve unsloth/gemma-4-26B-A4B-it-NVFP4 --speculative-config '{"method": "mtp", "num_speculative_tokens": 2}' ``` Si vous avez des problèmes avec 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 des quants NVFP4** Pour garantir que DGX Spark dispose des bons noyaux (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 unavailable: serving would degrade to marlin W4A16'" ``` {% endcode %} ce qui ne devrait PAS produire d’erreur - si c’est le cas, mettez à jour vllm ou réinstallez 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 avez des problèmes avec 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 des shards BF16 plus volumineux, faites : {% code overflow="wrap" %} ```bash pip install -U huggingface_hub # Télécharger 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 Ollama à jour via `curl -fsSL https://ollama.com/install.sh | sh` ou utilisez la version PowerShell. {% endhint %} ## Bonnes pratiques pour Gemma 4 ### Exemples de prompts #### Prompt de raisonnement simple ``` Système : <|think|> Vous êtes un assistant de raisonnement précis. Utilisateur : Un train part à 8h15 et arrive à 11h47. Combien de temps a duré le trajet ? ``` #### Prompt OCR / document Pour l’OCR, utilisez un **budget élevé de jetons visuels** comme **560** ou **1120**. ``` [image d’abord] Extrayez tout le texte de ce reçu. Retournez les lignes d’articles, le total, le commerçant et la date au format JSON. ``` #### Prompt 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. ``` #### Prompt ASR audio ``` Transcrivez le segment vocal suivant en {LANGUAGE} en texte {LANGUAGE}. Suivez ces instructions spécifiques pour formater la réponse : * N’affichez que la transcription, sans 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. ``` #### Prompt 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 retour à la ligne, puis affichez la chaîne '{TARGET_LANGUAGE}: ', puis la traduction en {TARGET_LANGUAGE}. ``` ### Paramètres multimodaux Pour de meilleurs résultats avec les prompts multimodaux, placez le contenu multimodal en premier : * 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 * **L’audio** est disponible **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 de prompts audio **Prompt ASR** ``` Transcrivez le segment vocal suivant en {LANGUAGE} en texte {LANGUAGE}. Suivez ces instructions spécifiques pour formater la réponse : * N’affichez que la transcription, sans 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. ``` **Prompt 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 retour à la ligne, puis affichez la chaîne '{TARGET_LANGUAGE}: ', puis la traduction en {TARGET_LANGUAGE}. ``` ## 📊 Benchmarks ### Benchmarks Unsloth GGUF Nous avons réalisé des benchmarks de divergence moyenne KL pour les GGUF de Gemma 4 auprès de plusieurs fournisseurs afin de vous aider à choisir le meilleur quant (plus bas est mieux). * La divergence KL place tous les GGUF d’Unsloth sur la frontière de Pareto SOTA * La KLD montre dans quelle mesure un modèle quantifié correspond à la distribution de sortie BF16 d’origine, indiquant la précision conservée.

26B A4B - benchmarks KLD (plus bas est mieux)

### Benchmarks officiels de Gemma **Benchmarks texte/code** | Benchmark | Gemma 4 31B | Gemma 4 26B A4B | Gemma 4 12B Unified | Gemma 4 E4B | Gemma 4 E2B | Gemma 3 27B (sans réflexion) | | --------------------- | ----------- | --------------- | ------------------- | ----------- | ----------- | ---------------------------- | | MMLU Pro | 85.2% | 82.6% | 77.2% | 69.4% | 60.0% | 67.6% | | AIME 2026 sans outils | 89.2% | 88.3% | 77.5% | 42.5% | 37.5% | 20.8% | | LiveCodeBench v6 | 80.0% | 77.1% | 72.0% | 52.0% | 44.0% | 29.1% | | ELO Codeforces | 2150 | 1718 | 1659 | 940 | 633 | 110 | | GPQA Diamond | 84.3% | 82.3% | 78.8% | 58.6% | 43.4% | 42.4% | | Tau2 | 76.9% | 68.2% | 69.0% | 42.2% | 24.5% | 16.2% | | HLE sans outils | 19.5% | 8.7% | 5.2% | - | - | - | | HLE avec recherche | 26.5% | 17.2% | - | - | - | - | | BigBench Extra Hard | 74.4% | 64.8% | 53.0% | 33.1% | 21.9% | 19.3% | | MMMLU | 88.4% | 86.3% | 83.4% | 76.6% | 67.4% | 70.7% | **Benchmarks vision** | MMMU Pro | 76.9% | 73.8% | 69.1% | 52.6% | 44.2% | 49.7% | | ------------------------------------- | ----- | ----- | ----- | ----- | ----- | ----- | | OmniDocBench 1.5 (plus bas est mieux) | 0.131 | 0.149 | 0.164 | 0.181 | 0.290 | 0.365 | | MATH-Vision | 85.6% | 82.4% | 79.7% | 59.5% | 52.4% | 46.0% | | MedXPertQA MM | 61.3% | 58.1% | 48.7% | 28.7% | 23.5% | - | **Benchmarks audio** | CoVoST | - | - | 38.5\* | 35.54 | 33.47 | - | | ------------------------------- | ----- | ----- | ------------------ | ----- | ----- | ----- | | FLEURS (plus bas est mieux) | - | - | 0.069\* | 0.08 | 0.09 | - | | **Long contexte** | | | | | | | | MRCR v2 8 needle 128k (moyenne) | 66.4% | 44.1% | 43.4% | 25.4% | 19.1% | 13.5% |
--- # 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/gemma-4.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.