> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/gemma4.md). # Gemma 4 (26B MoE, 4B actifs) {% hint style="info" %} **Statut (avril 2026) :** Gemma 4 a été publié le **2 avril 2026** par Google comme la nouvelle génération de la famille Gemma à poids ouverts. Deux variantes sont disponibles : un modèle **dense 31B** (`google/gemma-4-31b-it`) et un **MoE 26B avec \~4B de paramètres actifs** (`google/gemma-4-26b-it`). Les deux sont publiés sous les conditions d'utilisation standard de **Gemma** sur [huggingface.co/google/gemma-4-26b-it](https://huggingface.co/google/gemma-4-26b-it) et [huggingface.co/google/gemma-4-31b-it](https://huggingface.co/google/gemma-4-31b-it). {% endhint %} Gemma 4 est la première entrée MoE de Google dans la lignée Gemma et la première version Gemma à atteindre le sommet de l'Arène LMSYS (rapports du fournisseur **#3 au classement général au lancement**, devançant plusieurs modèles fermés sur la factualité et le suivi d'instructions). Le chiffre principal est la variante MoE : **26B de paramètres au total, \~4B actifs par token**, ce qui vous donne un suivi d'instructions proche de la frontière pour un coût d'inférence équivalent à celui d'un petit modèle dense. Pour les utilisateurs de Clore.ai, l'essentiel est simple — le MoE 26B fonctionne confortablement sur une seule **RTX 4090 (24 Go)** avec une quantification FP8 ou 4 bits (\~10 tok/s) et atteint un débit de niveau production sur une seule **H100 80 Go** (\~40+ tok/s), mettant le suivi d'instructions de qualité Gemma à portée pour environ 0,5 à 2 $/jour sur la place de marché. La variante dense 31B est la plus capable mais aussi la plus coûteuse, et nécessite 2× RTX 4090 ou 1× H100 pour le service. ## Fonctionnalités clés * **Architecture MoE (variante 26B)** — 26B de paramètres au total, \~4B activés par token ; payez un coût d'inférence de classe 4B pour une qualité de classe 26B * **Solution dense de repli (variante 31B)** — pour les équipes qui préfèrent la prévisibilité et la maturité des outils de l'inférence dense * **Fenêtre de contexte de 128K** — questions-réponses sur de longs documents, RAG sur des bases de code de taille moyenne, boucles d'agents multi-tours * **Fort suivi d'instructions** — Gemma 4 est explicitement optimisé pour l'utilisation d'outils, la sortie structurée et le respect fidèle des contraintes * **Multilingue** — la couverture multilingue complète de Gemma 3 est conservée, avec en plus une suite de benchmarks non anglophones élargie * **Poids ouverts, conditions Gemma** — gratuit pour la plupart des usages commerciaux ; consultez la [Politique d'utilisation interdite de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) avant la mise en production * **Outils de première classe** — pris en charge nativement dans vLLM, SGLang, Ollama et Hugging Face Transformers ## Choisissez votre variante | Variante | Paramètres totaux | Actifs | Contexte | Quantification recommandée | GPU Clore recommandé | | ---------------------------------------- | ----------------- | -------------- | -------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------ | | **Gemma 4 26B MoE** (`gemma-4-26b-it`) | 26B | \~4B par token | 128K | FP8 ou GPTQ 4 bits | 1× [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (24 Go, quantifié) | | **Gemma 4 31B Dense** (`gemma-4-31b-it`) | 31B | 31B (tous) | 128K | FP8 ou BF16 | 1× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (80 Go, BF16) | {% hint style="success" %} **Choix pratique :** Pour 90 % des déploiements sur GPU unique, optez pour **Gemma 4 26B MoE en FP8**. Vous obtenez la qualité d'Arène mise en avant à \~10–15 tok/s sur une 4090 et \~40+ tok/s sur une H100, sans le coût de latence de l'inférence dense 31B. {% endhint %} *** ## Exigences serveur | Composant | 26B MoE (4 bits, 4090) | 26B MoE (FP8, H100) | 31B Dense (BF16, H100) | | ----------- | ---------------------------------- | ------------------- | ---------------------- | | VRAM GPU | 24 Go | 80 Go | 80 Go | | RAM système | 32 Go | 64 Go | 64 Go | | Disque | 60 Go NVMe | 80 Go NVMe | 90 Go NVMe | | Réseau | 100 Mbps pour le téléchargement HF | 1 Gbps recommandé | 1 Gbps recommandé | | CUDA | 12.1+ | 12.4+ | 12.4+ | | Pilote | 550+ | 555+ | 555+ | Prévoyez environ 20 % de marge VRAM supplémentaire par rapport à l'empreinte statique des poids pour couvrir le cache KV à longs contextes. Régler `--gpu-memory-utilization 0.90` dans vLLM est un bon réglage par défaut. *** ## Déploiement rapide sur CLORE.AI La voie la plus rapide : louer un seul GPU, récupérer l'image standard `vllm/vllm-openai` et servir le modèle avec une API compatible OpenAI. Ci-dessous se trouve la structure docker-compose utilisée par le reste de ces guides — ajustez le nom du modèle et la taille du parallélisme tensoriel selon la variante choisie ci-dessus. ### Option A — Gemma 4 26B MoE sur un seul GPU (vLLM, FP8) ```yaml version : "3.8" services : vllm : image : vllm/vllm-openai:latest ports : - "8000:8000" environment : - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN} volumes : - hf_cache:/root/.cache/huggingface command : > --model google/gemma-4-26b-it --quantization fp8 --max-model-len 32768 --gpu-memory-utilization 0.90 --served-model-name gemma-4-26b --trust-remote-code deploy : resources : reservations : devices : - driver: nvidia count: 1 capabilities: [gpu] shm_size: "8gb" volumes : hf_cache : ``` ```bash # Démarrez-le HF_TOKEN=hf_xxx docker compose up -d # Suivez les logs pendant le téléchargement des poids docker compose logs -f vllm ``` {% hint style="info" %} **Contrôle de licence :** Les modèles Gemma sur Hugging Face nécessitent l'acceptation des conditions de Google une fois par compte. Ouvrez la page du modèle dans un navigateur, cliquez sur « Acknowledge license », puis exportez `HF_TOKEN` pour que le conteneur puisse récupérer les poids. {% endhint %} ### Option B — Gemma 4 31B Dense sur H100 (vLLM, BF16) ```bash docker run --gpus all -p 8000:8000 \ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \ --dtype bfloat16 \ --max-model-len 32768 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### Option C — Gemma 4 31B Dense sur 2× RTX 4090 (FP8, parallélisme tensoriel) ```bash docker run --gpus all -p 8000:8000 \ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \ --quantization fp8 \ --tensor-parallel-size 2 \ --max-model-len 16384 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### Option D — Test local rapide avec Ollama Pour des expérimentations au niveau d'un ordinateur portable, Ollama enveloppe les builds communautaires GGUF. Attendez-vous à ce que les quantifications arrivent quelques jours après la sortie officielle. ```bash # Une fois qu'un GGUF communautaire est publié ollama pull gemma4:26b-moe-q4_k_m ollama run gemma4:26b-moe-q4_k_m # API compatible OpenAI sur :11434 curl http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma4:26b-moe-q4_k_m", "messages": [{"role":"user","content":"Résume l'approche de routage MoE en deux phrases."}] }' ``` Voir le [guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) pour la configuration générale, la gestion des modèles et des conseils de persistance. *** ## Exemples d'utilisation Le conteneur vLLM expose une API compatible OpenAI sur `:8000`. Tout ce qui parle le schéma chat-completions d'OpenAI fonctionne directement. ### Complétion de chat avec Curl ```bash curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma-4-26b", "messages": [ {"role": "system", "content": "Vous êtes un rédacteur technique minutieux."}, {"role": "user", "content": "Expliquez le routage MoE en trois phrases sans utiliser d'analogies."} ], "max_tokens": 512, "temperature": 0.7 }' ``` ### Python (client OpenAI) ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") resp = client.chat.completions.create( model="gemma-4-26b", messages=[ {"role": "system", "content": "Vous répondez en texte brut, sans markdown."}, {"role": "user", "content": "Donnez-moi une liste de contrôle de revue de code en 5 points pour un gestionnaire HTTP Go."}, ], temperature=0.7, max_tokens=1024, ) print(resp.choices[0].message.content) ``` ### Réponses en streaming ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") stream = client.chat.completions.create( model="gemma-4-26b", messages=[{"role": "user", "content": "Écrivez un haïku sur l'inférence distribuée."}], stream=True, max_tokens=128, ) for chunk in stream: delta = chunk.choices[0].delta.content if delta: print(delta, end="", flush=True) print() ``` ### Hugging Face Transformers (utilisation hors ligne) ```python import torch from transformers import AutoModelForCausalLM, AutoTokenizer model_name = "google/gemma-4-26b-it" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", load_in_4bit=True, # Adapte le MoE sur une seule carte de 24 Go ) messages = [ {"role": "user", "content": "Refactorisez cette fonction Python pour améliorer sa lisibilité :\n\ndef f(x): return [i for i in x if i%2==0 and i>10]"}, ] input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device) output = model.generate(input_ids, max_new_tokens=512, do_sample=True, temperature=0.7) print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True)) ``` *** ## Conseils de performance * **Utilisez FP8 sur Hopper.** Sur H100, le checkpoint FP8 consomme environ deux fois moins de mémoire que BF16, sans perte de qualité mesurable pour les tâches de suivi d'instructions. Passez `--quantization fp8` à vLLM. * **Utilisez GPTQ 4 bits sur Ada (RTX 4090).** Pour la variante MoE sur une seule 4090, un build communautaire GPTQ 4 bits est le meilleur compromis pratique — attendez-vous à \~10–15 tok/s. Les builds GGUF Q4\_K\_M d'Ollama offrent une qualité similaire avec une exploitation plus simple. * **Parallélisme tensoriel pour le 31B Dense.** Sur 2× RTX 4090, passez `--tensor-parallel-size 2`. Limitez le contexte à ce dont vous avez réellement besoin (`--max-model-len 16384`) — chaque doublement du contexte double approximativement l'empreinte du cache KV. * **Parallélisme expert pour le MoE.** Sur des configurations multi-GPU pour le MoE 26B, `--enable-expert-parallel` de vLLM peut offrir un gain de débit significatif à des tailles de lot plus élevées. C'est excessif pour un seul GPU. * **Préremplissage par blocs pour les longs contextes.** Lorsque vous dépassez 32K, ajoutez `--enable-chunked-prefill` à vLLM. Cela maintient une latence de préremplissage raisonnable et évite les blocages sur le chemin de décodage. * **Pré-téléchargez les poids.** Pour les locations Clore éphémères, montez un volume persistant sur `/root/.cache/huggingface` afin que les exécutions suivantes ignorent le téléchargement de 50 à 60 Go. * **Choisissez le bon backend de service.** vLLM est le choix par défaut sûr. SGLang l'emporte souvent sur Hopper pour les charges à forte concurrence ; voir le [guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) pour une comparaison plus large. *** ## Benchmarks {% hint style="warning" %} **Chiffres publiés par le fournisseur — vérification indépendante en attente.** Les chiffres ci-dessous proviennent des supports de lancement de Google du 2 avril 2026. Les reproductions indépendantes sur des évaluations privées continuent d'arriver. Considérez le classement de l'Arène et les scores de factualité comme indicatifs, non absolus. {% endhint %} | Benchmark | Gemma 4 26B MoE | Gemma 4 31B Dense | Référence | | --------------------------------- | ------------------------------------------------------------------------ | --------------------------------------------------------------------- | --------------------------- | | LMSYS Arena (global) | #3 au lancement | \~#5 au lancement | rapporté par le fournisseur | | Suivi d'instructions (IFEval) | le fournisseur rapporte de fortes améliorations par rapport à Gemma 3 | le fournisseur rapporte de fortes améliorations par rapport à Gemma 3 | rapporté par le fournisseur | | Factualité (SimpleQA / similaire) | bat plusieurs modèles fermés selon Google | comparable | rapporté par le fournisseur | | Multilingue (Global-MMLU) | le fournisseur rapporte une parité avec des modèles beaucoup plus grands | meilleur score Gemma à ce jour | rapporté par le fournisseur | L'argument de positionnement de Gemma 4 est « plus utile par paramètre actif », pas « roi brut de HumanEval ». Si vous avez besoin de génération de code pure, comparez-le à [GLM-5.1](/guides/guides_v2-fr/modeles-de-langage/glm-5-1.md) (codage de pointe) ou [Qwen3.5](/guides/guides_v2-fr/modeles-de-langage/qwen35.md) (meilleur dense de classe 35B). Si vous avez besoin de boucles agentiques à long horizon, GLM-5.1 reste l'outil le plus incisif. *** ## Dépannage | Problème | Solution | | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `OutOfMemoryError` chargement du MoE 26B sur 24 Go | Passez à FP8 (`--quantization fp8`) ou 4 bits (`load_in_4bit=True` dans Transformers). Réduisez `--max-model-len` à 16384 pour réduire le cache KV. | | `OutOfMemoryError` chargement du 31B Dense sur H100 | BF16 à un contexte de 32K est juste à la limite sur 80 Go. Baissez `--max-model-len` à 16384 ou passez à FP8. | | Le téléchargement Hugging Face échoue avec 403 | Vous n'avez pas accepté la licence Gemma sur la page du modèle. Ouvrez l'URL dans un navigateur, acceptez les conditions, puis relancez le téléchargement avec un jeton ayant la portée `read` . | | Premier token très lent | Chargement à froid des poids (\~30–60 s à la première requête) plus préremplissage sur les entrées longues. Exécutez une requête fictive de préchauffage après le démarrage du serveur. Ajoutez `--enable-chunked-prefill` pour les charges à long contexte. | | Sortie brouillée / boucles de répétition | Vérifiez le modèle de chat — `tokenizer.apply_chat_template` est requis ; ne concaténez pas manuellement les chaînes `system`+`user` . Définissez `temperature=0.7` et `top_p=0.95` pour un usage général. | | Sortie d'outil / JSON peu fiable | Utilisez le `--guided-decoding-backend` de vLLM ou passez un schéma JSON via `response_format`. Le modèle suit bien les contraintes, mais les invites non structurées dériveront tout de même. | | `quantification non prise en charge` erreur dans vLLM | Mettez à jour vers une version de vLLM publiée après avril 2026 (`pip install -U vllm --pre`). L'architecture Gemma 4 nécessite les derniers parseurs de configuration. | *** ## FAQ **Gemma 4 vs Llama 4 ?** Des formes différentes pour des tâches différentes. [Llama 4 Scout](/guides/guides_v2-fr/modeles-de-langage/llama4.md) est en 109B/17B actifs avec un contexte vedette de 10M — excellent lorsque vous devez envoyer d'énormes entrées au modèle. Gemma 4 26B MoE est beaucoup plus petit en paramètres totaux (26B contre 109B), active moins de paramètres par token (4B contre 17B) et est davantage optimisé pour le suivi d'instructions et la factualité. Pour des budgets VRAM serrés et un meilleur rapport qualité/par paramètre, Gemma 4 gagne. Pour une longueur de contexte absurde, Llama 4 Scout gagne. **Quelle VRAM pour Gemma 4 26B MoE ?** * GGUF / GPTQ 4 bits : tient dans **24 Go** (une seule RTX 4090), \~10–15 tok/s. * FP8 : confortable sur **40 Go**, rapide sur **80 Go** (H100) à \~40+ tok/s. * BF16 complet : \~55 Go de poids plus le cache KV — prévoyez une **80 Go** carte. **Puis-je utiliser Gemma 4 à des fins commerciales ?** Oui, sous les conditions d'utilisation standard de Gemma. Consultez la [Politique d'utilisation interdite de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) avant le déploiement — il existe des restrictions concernant certains cas d'utilisation (tromperie, génération de CSAM, activité illégale), et vous devez transmettre les mentions de licence en aval à vos utilisateurs. Ce n'est pas un modèle Apache 2.0 / MIT — c'est un modèle à poids ouverts régi par une politique d'utilisation. Si vous avez besoin d'une licence totalement sans restriction, [Qwen3.5](/guides/guides_v2-fr/modeles-de-langage/qwen35.md) (Apache 2.0) ou [GLM-5.1](/guides/guides_v2-fr/modeles-de-langage/glm-5-1.md) (MIT) sont des alternatives. **Gemma 4 vs DeepSeek-V4 ?** [DeepSeek-V4](/guides/guides_v2-fr/modeles-de-langage/deepseek-v4.md) est dans une autre catégorie de poids — \~1T de paramètres, multimodal, contexte de 1M. Utilisez DeepSeek-V4 lorsque vous avez besoin de capacité brute et d'une importante infrastructure GPU. Utilisez Gemma 4 26B MoE lorsque vous voulez un bon suivi d'instructions sur un **seul GPU** et que vous visez des locations à environ 1 à 2 $/jour sur Clore. Gemma 4 est le candidat « meilleur modèle tenant sur une 4090 » ; DeepSeek-V4 est le candidat « je paierai pour 8× H200 ». **Gemma 4 prend-il en charge la vision / les entrées multimodales ?** La sortie phare de Gemma 4 est un modèle texte uniquement affiné pour les instructions (`*-it`). Google a historiquement suivi les sorties texte avec des variantes vision PaliGemma — surveillez [huggingface.co/google](https://huggingface.co/google) pour les mises à jour. Pour un modèle open source capable de traiter des images aujourd'hui, regardez [Kimi K2.5](/guides/guides_v2-fr/modeles-de-langage/kimi-k2.md) ou [Llama 4 Scout](/guides/guides_v2-fr/modeles-de-langage/llama4.md). *** ## Guides associés * [vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — backend de service de production utilisé dans ce guide * [Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — chemin le plus rapide pour des tests locaux avec des builds GGUF * [Llama 4](/guides/guides_v2-fr/modeles-de-langage/llama4.md) — l'alternative MoE de Meta avec un contexte de 10M * [GLM-5.1](/guides/guides_v2-fr/modeles-de-langage/glm-5-1.md) — MoE de codage de classe frontière (744B/40B actifs) quand la taille de Gemma ne suffit pas * [Qwen3.5](/guides/guides_v2-fr/modeles-de-langage/qwen35.md) — dense 35B sous Apache 2.0, l'autre bonne option sur GPU unique * [Gemma 3](/guides/guides_v2-fr/modeles-de-langage/gemma3.md) — la génération précédente, base de comparaison utile pour la migration ### Liens * [Gemma 4 26B MoE sur Hugging Face](https://huggingface.co/google/gemma-4-26b-it) * [Gemma 4 31B Dense sur Hugging Face](https://huggingface.co/google/gemma-4-31b-it) * [Gemma](https://ai.google.dev/gemma/terms) * [Politique d'utilisation interdite de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) * [Documentation vLLM](https://docs.vllm.ai) * [dépôt SGLang](https://github.com/sgl-project/sglang) --- # 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: ``` GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/gemma4.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.