> 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 (MoE 26B, 4B actifs) Déployez Gemma 4 (MoE 26B, 4B actifs) de Google sur Clore.ai — le modèle à poids ouverts publié en avril 2026 qui a grimpé jusqu'à {% hint style="info" %} **Statut (avril 2026) :** Gemma 4 a été publié le **2 avril 2026** par Google comme la prochaine génération de la famille open-weight Gemma. Deux variantes sont proposées : un **modèle dense 31B** (`google/gemma-4-31b-it`) et un **26B MoE avec \~4B de paramètres actifs** (`google/gemma-4-26b-it`). Les deux sont publiés sous les **conditions d'utilisation 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'Arena LMSYS (les rapports du fournisseur indiquent **#3 au classement général à la sortie** , dépassant plusieurs modèles fermés en factualité et en suivi d'instructions). Le chiffre phare est la variante MoE : **26B de paramètres au total, \~4B actifs par token** , ce qui vous offre un suivi d'instructions proche de la frontière pour le coût d'inférence d'un petit modèle dense. Pour les utilisateurs de Clore.ai, l'essentiel est simple — le 26B MoE fonctionne confortablement sur un seul **RTX 4090 (24 Go)** avec FP8 ou quantification 4 bits (\~10 tok/s) et atteint un débit de niveau production sur un seul **H100 80 Go** (\~40+ tok/s), mettant un suivi d'instructions de qualité Gemma à portée pour environ \~1,04 $/h sur la place de marché. La variante dense 31B est la plus capable mais aussi la plus coûteuse, nécessitant 2× RTX 4090 ou 1× H100 pour être servie. ## Caractéristiques 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 de repli dense (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** — Q\&R 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** — couverture multilingue complète reprise de Gemma 3, plus une suite d'évaluation non anglophone é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 le déploiement * **Outils de premier ordre** — pris en charge nativement dans vLLM, SGLang, Ollama et Hugging Face Transformers ## Choisissez votre variante | Variante | Paramètres totaux | Actif | Contexte | Quant. 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 (tout) | 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 un seul GPU, choisissez **Gemma 4 26B MoE sur FP8**. Vous obtenez la qualité Arena en tête d'affiche à \~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 du serveur | Composant | 26B MoE (4 bits, 4090) | 26B MoE (FP8, H100) | 31B Dense (BF16, H100) | | ----------- | ---------------------------------- | ------------------- | ---------------------- | | VRAM GPU | 24GB | 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.8+ | 12.8+ | 12.8+ | | Pilote | 550+ | 555+ | 555+ | Prévoyez environ 20 % de marge VRAM supplémentaire au-dessus de l'empreinte statique des poids pour couvrir le cache KV sur de longs contextes. Le réglage `--gpu-memory-utilization 0.90` dans vLLM est une bonne valeur par défaut. *** ## Déploiement rapide sur CLORE.AI Le chemin le plus rapide : louez un seul GPU, récupérez l'image standard `vllm/vllm-openai` et servez le modèle avec une API compatible OpenAI. Ci-dessous se trouve la configuration 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" %} **Verrouillage de licence :** Les modèles Gemma sur Hugging Face nécessitent d'accepter les conditions de Google une fois par compte. Visitez la page du modèle dans un navigateur, cliquez sur "Acknowledge license", puis exportez `HF_TOKEN` afin 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 l'expérimentation sur machine portable, Ollama encapsule les builds communautaires GGUF. Attendez-vous à ce que les quantifiés 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 du modèle et les 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 via 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 soigneux."}, {"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 checklist 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, # Convient au MoE sur une seule carte de 24 Go ) messages = [ {"role": "user", "content": "Refactorez cette fonction Python pour la rendre plus lisible :\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 utilise 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, une 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 des opérations plus simples. * **Parallélisme tensoriel pour 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 à peu près l'empreinte du cache KV. * **Parallélisme d'experts pour le MoE.** Sur des configurations multi-GPU pour le 26B MoE, le `--enable-expert-parallel` de vLLM peut offrir un gain de débit significatif à des tailles de batch plus élevées. C'est surdimensionné pour un seul GPU. * **Préremplissage par morceaux pour les longs contextes.** Lorsque vous dépassez 32K, ajoutez `--enable-chunked-prefill` à vLLM. Cela maintient une latence de préremplissage gérable et évite les blocages sur le chemin de décodage. * **Préchargez les poids.** Pour les locations éphémères Clore, montez un volume persistant à `/root/.cache/huggingface` afin que les exécutions suivantes évitent le téléchargement de 50 à 60 Go. * **Choisissez le bon backend de service.** vLLM est le choix par défaut sûr. SGLang gagne souvent sur Hopper pour les charges à forte concurrence ; voir le [guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) pour la 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 Arena 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 à la sortie | \~#5 à la sortie | rapporté par le fournisseur | | Suivi d'instructions (IFEval) | le fournisseur rapporte des gains importants par rapport à Gemma 3 | le fournisseur rapporte des gains importants 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 bien 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 avec [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 affûté. *** ## Dépannage | Problème | Solution | | ----------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `OutOfMemoryError` charger le 26B MoE sur 24 Go | Passez à FP8 (`--quantization fp8`) ou 4 bits (`load_in_4bit=True` dans Transformers). Réduisez `--max-model-len` à 16384 pour diminuer le cache KV. | | `OutOfMemoryError` charger le 31B Dense sur H100 | Le BF16 à un contexte de 32K est juste à la limite sur 80 Go. Réduisez `--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 qui a l'autorisation `lecture` . | | Première réponse très lente | 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 d'échauffement factice 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 `system`+`user` les chaînes manuellement. Définissez `temperature=0.7` et `top_p=0.95` pour un usage général. | | Sortie d'outil / JSON peu fiable | Utilisez `--guided-decoding-backend` de vLLM ou transmettez un schéma JSON via `response_format`. Le modèle suit bien les contraintes, mais les invites non structurées dériveront quand 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 parseurs de configuration les plus récents. | *** ## 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 un modèle de classe 109B/17B-actifs avec un contexte vedette de 10M — idéal lorsque vous devez lui envoyer d'énormes entrées. 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 la qualité par paramètre, Gemma 4 gagne. Pour une longueur de contexte absurde, Llama 4 Scout gagne. **De combien de VRAM a besoin Gemma 4 26B MoE ?** * 4-bit GGUF / GPTQ : tient dans **24GB** (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 commercialement ?** 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 — il est open-weight sous 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'un parc GPU sérieux. Utilisez Gemma 4 26B MoE lorsque vous voulez un fort suivi d'instructions sur un **seul GPU** et que vous vous souciez des [bare metal](https://clore.ai/bare-metal) locations sur Clore. Gemma 4 est le candidat « meilleur modèle qui tient 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 version phare de Gemma 4 est textuelle uniquement et optimisée pour les instructions (`*-it`). Google a historiquement suivi les versions textuelles avec des variantes vision PaliGemma — surveillez [huggingface.co/google](https://huggingface.co/google) pour les mises à jour. Pour un modèle ouvert 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 vers les tests locaux avec des builds GGUF * [Llama 4](/guides/guides_v2-fr/modeles-de-langage/llama4.md) — 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 classe frontier pour le codage (744B/40B-actifs) quand la classe de taille de Gemma ne suffit pas * [Qwen3.5](/guides/guides_v2-fr/modeles-de-langage/qwen35.md) — dense 35B Apache-2.0, l'autre option forte sur un seul GPU * [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) * [conditions d'utilisation 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/gemma4.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.