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'à

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 et huggingface.co/google/gemma-4-31b-it.

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 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 (24 Go, quantifié)
Gemma 4 31B Dense (gemma-4-31b-it)	31B	31B (tout)	128K	FP8 ou BF16	1× H100 (80 Go, BF16)

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.

---

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)

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:

# 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

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.

Option B — Gemma 4 31B Dense sur H100 (vLLM, BF16)

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)

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.

# 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 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

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)

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

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)

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 pour la comparaison plus large.

---

Benchmarks

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.

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 (codage de pointe) ou Qwen3.5 (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 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 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 (Apache 2.0) ou GLM-5.1 (MIT) sont des alternatives.

Gemma 4 vs DeepSeek-V4 ? DeepSeek-V4 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 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 pour les mises à jour. Pour un modèle ouvert capable de traiter des images aujourd'hui, regardez Kimi K2.5 ou Llama 4 Scout.

---

Guides associés

• vLLM — backend de service de production utilisé dans ce guide

• Ollama — chemin le plus rapide vers les tests locaux avec des builds GGUF

• Llama 4 — alternative MoE de Meta avec un contexte de 10M

• GLM-5.1 — MoE de classe frontier pour le codage (744B/40B-actifs) quand la classe de taille de Gemma ne suffit pas

• Qwen3.5 — dense 35B Apache-2.0, l'autre option forte sur un seul GPU

• Gemma 3 — la génération précédente, base de comparaison utile pour la migration

Liens

• Gemma 4 26B MoE sur Hugging Face

• Gemma 4 31B Dense sur Hugging Face

• conditions d'utilisation Gemma

• Politique d'utilisation interdite de Gemma

• documentation vLLM

• dépôt SGLang