> 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 Gemma 4 est la nouvelle famille de modèles ouverts de Google DeepMind, notamment **12B**, **E2B**, **E4B**, **26B-A4B**, et **31B.** Les modèles multimodaux à raisonnement hybride prennent en charge plus de 140 langues, jusqu’à **256K de contexte**, 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 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** prennent également en charge l’image et l’audio. Fonctionne sur **5 Go de RAM** (4 bits) ou 15 Go (16 bits complets) via les quantifications GGUF, MLX ou 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 fois 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 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 3x 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 ici. **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é [des benchmarks GGUF de Gemma 4](#unsloth-gguf-benchmarks) pour vous aider à choisir la meilleure quantification. {% endhint %} ### Guide d’utilisation Gemma 4 excelle dans le raisonnement, le codage, l’utilisation d’outils, les contextes longs et les 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 les systèmes CPU/VRAM de milieu à haut de gamme, comme les PC équipés de GPU NVIDIA RTX. | Variante Gemma 4 | Détails | Utilisation idéale | | ---------------- | --------------------------------------------------------------------------- | ------------------------------------------------------------------------- | | **E2B** |

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

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

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

| Petit modèle pour ordinateurs portables et usage multimodal local rapide | | **12B Unified** |

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

| Modèle intermédiaire pour ordinateurs portables et usage multimodal local | | **26B-A4B** |

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

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

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

| Meilleures performances avec 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. Sa conception 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 à 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 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, 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 devrait au moins dépasser la taille du modèle quantifié que vous téléchargez. Sinon, llama.cpp peut tout de 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 davantage 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 : * `temperature = 1.0` * `top_p = 0.95` * `top_k = 64` {% hint style="info" %} Le contexte maximal de Gemma 4 est **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 **`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 encore é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\nWhat is the capital of France?\n<|turn>model\n ``` {% endcode %} **alors il génère :** {% code overflow="wrap" %} ``` <|channel>thought\nThe user is asking for the capital of France.\nThe capital of France is Paris.The capital of France is Paris. ``` {% endcode %} **Règle pour les conversations à plusieurs tours :** Pour les conversations à plusieurs tours, **ne conserver que la réponse finale visible dans l’historique du chat**. Ne **pas** réinjectez les blocs de pensée précédents dans le tour suivant. {% code overflow="wrap" %} ``` <|turn>user\nWhat is 1+1?\n<|turn>model\n2\n<|turn>user\nWhat is 1+1?\n<|turn>model\n2\n<|turn>user\nWhat is 1+1?\n<|turn>model\n2\n<|turn>user\nWhat is 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, alors 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 sous **Windows** PowerShell, utilisez : `--chat-template-kwargs "{\"enable_thinking\":false}"` Utilisez indifféremment 'true' et 'false'. {% endhint %} ## Lancer les tutoriels 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 est [**Dynamique**](/docs/fr/bases/unsloth-dynamic-2.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 Studio🦙 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 Studio Gemma 4 peut désormais être exécuté et ajusté finement 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](/docs/fr/nouveau/studio.md#model-arena) réglage des paramètres (temp, top-p, etc.) * Inférence rapide CPU + GPU via llama.cpp * [Entraîner des LLM](/docs/fr/nouveau/studio.md#no-code-training) 2x plus rapide avec 70 % de VRAM en moins {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% stepper %} {% step %} #### Installer Unsloth 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. **Lancez Unsloth en toute sécurité avec HTTPS et Cloudflare** **NOUVEAU !** Unsloth fournit 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) 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 unifié Gemma-4-12B.
{% endstep %} {% step %} #### Exécuter Gemma 4 Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, mais vous pouvez toujours les modifier manuellement. Vous pouvez aussi modifier la longueur du contexte, le modèle de chat et d’autres paramètres. Vous pouvez exécuter des GGUF et des fichiers 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 Dynamic 4-bit pour 12B, 26B-A4B et 31B, et 8-bit 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. Remplacez `-DGGML_CUDA=ON` par `-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 aussi télécharger via Hugging Face (étape 3). C’est similaire à `ollama run` . Utilisez `export LLAMA_CACHE="folder"` pour forcer `llama.cpp` à 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`' 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, consultez : [Hugging Face Hub, débogage 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 Dynamic 2bit ``` {% 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 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 | 4-bit MLX | 8-bit MLX | | ------- | --------------------------------------------------------------------- | ------------------------------------------------------------------ | | 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 téléversé [NVFP4 dynamique](/docs/fr/bases/nvfp4.md) Les quants 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. Consultez aussi l’accélération globale 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 des 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 ex. 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 %} Puis pour servir la variante MoE 26B : ```shell vllm serve unsloth/gemma-4-26B-A4B-it-NVFP4 ``` Remplacez `unsloth/gemma-4-26B-A4B-it-NVFP4` par n'importe quel [quant NVFP4 disponible](/docs/fr/bases/nvfp4.md#overview) nom de quant ! Pour activer le MTP / décodage spéculatif (décodage plus rapide mais débit un peu moindre), 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 avec Torchcodec, assurez-vous d'effectuer les étapes ci-dessous, 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 vous assurer que DGX Spark dispose des bons noyaux (sinon vous obtiendrez **une inférence 2× 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 %} qui ne devrait PAS générer d'erreur - si c'est 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 %} Puis 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 avec Torchcodec, assurez-vous d'effectuer les étapes ci-dessous, 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 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 commandes 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 Internal Server Error : impossible de charger le modèle` mettez à jour Ollama via `curl -fsSL https://ollama.com/install.sh | sh` ou utilisez la commande Powershell. {% endhint %} ## Bonnes pratiques Gemma 4 ### Exemples de prompt #### Prompt 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. 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 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 de transcription audio ``` Transcrivez le segment vocal suivant en texte {LANGUAGE}. Suivez ces instructions précises pour formater la réponse : * Produisez uniquement la transcription, sans saut de ligne. * Lors de la transcription des nombres, écrivez les chiffres, c.-à-d. écrivez 1.7 et non one point seven, et écrivez 3 au lieu de three. ``` #### Prompt de traduction audio ``` Transcrivez le segment vocal suivant en {SOURCE_LANGUAGE}, puis traduisez-le en {TARGET_LANGUAGE}. Pour formater 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 prompts multimodaux, placez d'abord le contenu multimodal : * Placez **l'image et/ou l'audio avant le texte**. * Pour la vidéo, transmettez d'abord une séquence d'images, puis l'instruction. #### Limites audio et vidéo * **Audio** est disponible sur **12B**, **E2B** et **E4B** seulement. * 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 prompt audio **Prompt ASR** ``` Transcrivez le segment vocal suivant en texte {LANGUAGE}. Suivez ces instructions précises pour formater la réponse : * Produisez uniquement la transcription, sans saut de ligne. * Lors de la transcription des nombres, écrivez les chiffres, c.-à-d. écrivez 1.7 et non one point seven, et écrivez 3 au lieu de three. ``` **Prompt de traduction vocale** ``` Transcrivez le segment vocal suivant en {SOURCE_LANGUAGE}, puis traduisez-le en {TARGET_LANGUAGE}. Pour formater 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 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). * La divergence KL place tous les GGUF 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, ce qui indique l'exactitude conservée.

26B A4B - Benchmarks KLD (plus bas = mieux)

### Benchmarks officiels 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% | | Codeforces ELO | 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 = 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 = mieux) | - | - | 0.069\* | 0.08 | 0.09 | - | | **Contexte long** | | | | | | | | 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.