Guide Complet : Les Modèles Gemma 4 de Google DeepMind
avril 2026 · 19 min de lecture
Publié le 2 avril 2026 — Gemma 4 est la quatrième génération de modèles ouverts de Google DeepMind, construite à partir de la même recherche que Gemini 3. Sous licence Apache 2.0, elle représente un bond majeur en termes de capacités par paramètre.
Table des matières
- Vue d'ensemble
- La famille de modèles
- Architecture technique
- Capacités multimodales
- Benchmarks et performances
- Configuration et déploiement local
- Configuration via Ollama
- Configuration via Hugging Face Transformers
- Configuration via vLLM (production)
- Configuration sur Apple Silicon (MLX)
- Déploiement dans le navigateur (WebGPU)
- Fine-tuning avec Unsloth + LoRA
- Gestion du mode de réflexion (Thinking)
- Configuration du token budget visuel
- Comparaison avec Gemma 3
- Ressources et liens utiles
1. Vue d'ensemble
Gemma 4 est la réponse de Google DeepMind à la demande croissante de modèles ouverts performants. Elle se distingue par :
- Licence Apache 2.0 : utilisation commerciale libre, sans restrictions à la Gemma license précédente
- Intelligence par paramètre record : le modèle 31B se classe 3ème parmi tous les modèles ouverts sur Arena AI, et le 26B MoE 6ème
- Multimodalité native : texte, image, vidéo et audio (selon la taille)
- Raisonnement avancé : mode "thinking" configurable sur tous les modèles
- Agents autonomes : support natif du function calling pour les workflows agentiques
- Déploiement universel : du téléphone mobile au cluster de serveurs
La famille Gemma 4 a été téléchargée plus de 400 millions de fois depuis le lancement de Gemma 1, avec plus de 100 000 variantes créées par la communauté.
2. La famille de modèles
Gemma 4 se décline en quatre tailles, chacune disponible en version base et instruction-tuned (-it).
| Modèle | Paramètres effectifs | Paramètres totaux | Fenêtre contexte | Cas d'usage |
|---|---|---|---|---|
| Gemma 4 E2B | 2,3 B | 5,1 B (embeddings inclus) | 128K tokens | On-device, mobile, Raspberry Pi |
| Gemma 4 E4B | 4,5 B | 8 B (embeddings inclus) | 128K tokens | Edge computing, laptop |
| Gemma 4 26B A4B | 3,8 B actifs | 26 B total (MoE) | 256K tokens | Workstation, GPU consommateur |
| Gemma 4 31B | 31 B | 31 B (Dense) | 256K tokens | Serveur, H100, fine-tuning |
Détail par modèle
Gemma 4 E2B & E4B — Modèles Edge
Le E signifie Effective (paramètres effectifs). Ces modèles utilisent les Per-Layer Embeddings (PLE) : une table d'embeddings parallèle grande mais utilisée uniquement pour des lookups rapides, ce qui réduit drastiquement la charge d'inférence.
- Optimisés pour fonctionner entièrement hors-ligne
- Audio natif supporté (encoder USM-style, jusqu'à 30 secondes)
- RAM requise : ~12 Go (E4B) / ~8 Go (E2B)
- Compatible : téléphones Android, Raspberry Pi, NVIDIA Jetson Orin Nano
Gemma 4 26B A4B — Mixture of Experts
Le A signifie Active : seuls 3,8 milliards de paramètres s'activent à chaque forward pass, malgré les 26 B totaux.
- Vitesse d'inférence proche d'un modèle 4B
- Qualité proche d'un modèle 25B+
- Idéal pour les workstations avec GPU consommateur
- RAM requise : ~24 Go / 17 Go de stockage
Gemma 4 31B Dense — Le Flagship
Le modèle dense classique, sans MoE.
- Meilleure qualité brute de la famille
- Architecture plus simple, idéale pour le fine-tuning
- Poids non-quantifiés en bfloat16 sur un seul GPU H100 80 Go
- Versions quantifiées disponibles pour GPU grand public
3. Architecture technique
Innovations architecturales clés
Attention alternée locale/globale
Gemma 4 utilise une alternance de couches d'attention :
- Sliding-window (locale) : fenêtre de 512 tokens (petits modèles) ou 1024 tokens (grands modèles) — rapide et économique
- Full-context (globale) : attention complète sur toute la séquence — précise mais coûteuse
Cette combinaison optimise à la fois la vitesse et la capacité de compréhension sur de longs contextes.
Dual RoPE (Rotary Position Embedding)
- RoPE standard pour les couches à sliding-window
- Proportional RoPE (P-RoPE) pour les couches globales, permettant une meilleure généralisation sur de longues séquences
Per-Layer Embeddings (PLE)
Une seconde table d'embeddings qui injecte un petit signal résiduel dans chaque couche du décodeur. Cela améliore la représentation sémantique sans surcoût d'inférence significatif.
Shared KV Cache
Les N dernières couches réutilisent les états clé-valeur (KV) des couches précédentes, éliminant les projections KV redondantes. Résultat : moins de mémoire utilisée, inférence plus rapide.
Architecture MoE (pour le 26B)
Input Token Embedding
↓
Router (sélectionne les experts)
↓
[Expert 1] [Expert 2] [Expert 3] ... [Expert N]
↓
Seulement K experts activés (K << N)
↓
Sortie pondérée
Les FFNN (feedforward networks) et les MoE ne sont jamais mélangés dans un même modèle : chaque variante Gemma 4 utilise l'un ou l'autre dans toutes ses couches.
Vocabulaire et langues
- 262 144 tokens dans le vocabulaire (vocabulaire partagé entre toutes les tailles)
- 140+ langues supportées
Encodeur visuel
- Positions 2D apprises avec RoPE multidimensionnel
- Support des rapports d'aspect variables (plus besoin de recadrer les images)
- Token budget configurable : 70, 140, 280, 560, 1120 tokens par image
4. Capacités multimodales
| Capacité | E2B | E4B | 26B MoE | 31B Dense |
|---|---|---|---|---|
| Texte | ✅ | ✅ | ✅ | ✅ |
| Images (variable aspect) | ✅ | ✅ | ✅ | ✅ |
| Vidéo | ✅ | ✅ | ✅ | ✅ |
| Audio (jusqu'à 30s) | ✅ | ✅ | ❌ | ❌ |
| Function Calling | ✅ | ✅ | ✅ | ✅ |
| Mode Thinking | ✅ | ✅ | ✅ | ✅ |
Important : Si votre application nécessite la reconnaissance vocale, seuls les modèles E2B et E4B supportent l'audio nativement dans cette famille.
5. Benchmarks et performances
Classements Arena AI (avril 2026)
| Modèle | Rang (open models) | Score estimé |
|---|---|---|
| Gemma 4 31B | 🥉 3ème | 1452 |
| Gemma 4 26B MoE | 6ème | 1441 |
Les deux modèles dépassent des modèles jusqu'à 20x leur taille sur ce benchmark.
Benchmarks spécifiques
| Benchmark | Gemma 4 31B | Gemma 4 26B MoE | Gemma 3 27B |
|---|---|---|---|
| AIME 2026 (mathématiques) | 89,2% | 88,3% | 20,8% |
| LiveCodeBench v6 (code) | 80,0% | 77,1% | 29,1% |
| GPQA Diamond (raisonnement scientifique) | 85,7% | 79,2% | 42,4% |
| τ²-bench Retail (agentic tool use) | 86,4% | 85,5% | 6,6% |
| Codeforces ELO | 2150 | — | 110 |
Le bond de performances entre Gemma 3 et Gemma 4 est exceptionnel, notamment sur le raisonnement mathématique (+4x) et les workflows agentiques (+13x).
6. Configuration et déploiement local
Prérequis matériels recommandés
| Modèle | RAM minimum | GPU recommandé | Stockage |
|---|---|---|---|
| E2B | 8 Go RAM | CPU / NPU mobile | ~4 Go |
| E4B | 12 Go RAM | GPU mobile / iGPU | ~6 Go |
| 26B MoE (quantifié Q4) | 24 Go RAM | RTX 3090 / 4090 | ~17 Go |
| 31B Dense (quantifié Q4) | 32 Go RAM | RTX 4090 / A6000 | ~20 Go |
| 31B Dense (bfloat16) | 80 Go VRAM | NVIDIA H100 80 Go | ~62 Go |
7. Configuration via Ollama
Ollama est la méthode la plus simple pour démarrer localement.
Installation
# Linux / macOS
curl -fsSL https://ollama.com/install.sh | sh
# Windows : télécharger l'installeur sur https://ollama.com
Télécharger et lancer un modèle
# Modèle 31B Dense (le plus puissant)
ollama pull gemma4:31b
ollama run gemma4:31b
# Modèle 26B MoE — meilleur ratio qualité/vitesse
ollama pull gemma4:26b
ollama run gemma4:26b
# Version quantifiée Q4 du 26B MoE (GPU consommateur)
ollama run gemma4:26b-moe-q4_K_M
# Modèle Edge 4B (CPU ou GPU bas de gamme)
ollama pull gemma4:4b
ollama run gemma4:4b
Configurer via Modelfile
# Modelfile — personnalisation du modèle
FROM gemma4:26b
# Activer le mode de réflexion
SYSTEM "<|think|>Tu es un assistant expert en analyse de données. Prends le temps de réfléchir avant de répondre."
# Paramètres de génération
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 65536
PARAMETER repeat_penalty 1.1
# Créer le modèle personnalisé
ollama create mon-gemma4 -f Modelfile
# Le lancer
ollama run mon-gemma4
Exposer une API compatible OpenAI
# Ollama expose automatiquement une API sur le port 11434
# Compatible avec les clients OpenAI
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "gemma4:26b",
"messages": [
{"role": "system", "content": "Tu es un assistant utile."},
{"role": "user", "content": "Explique les réseaux de neurones en 3 phrases."}
],
"temperature": 0.7
}'
8. Configuration via Hugging Face Transformers
Installation
pip install transformers accelerate torch pillow
Inférence texte simple
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
model_id = "google/gemma-4-31B-it" # ou gemma-4-E4B-it, gemma-4-26B-A4B-it
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype=torch.bfloat16,
device_map="auto",
)
messages = [
{"role": "system", "content": "Tu es un assistant expert."},
{"role": "user", "content": "Qu'est-ce que la mixture of experts ?"},
]
input_ids = tokenizer.apply_chat_template(
messages,
return_tensors="pt",
return_dict=True,
).to(model.device)
output = model.generate(
**input_ids,
max_new_tokens=512,
temperature=0.7,
do_sample=True,
)
print(tokenizer.decode(output[0], skip_special_tokens=True))
Inférence multimodale (image + texte)
from transformers import AutoProcessor, AutoModelForMultimodalLM
from PIL import Image
import torch
model_id = "google/gemma-4-31B-it"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(
model_id,
torch_dtype=torch.bfloat16,
device_map="auto",
)
image = Image.open("mon_image.jpg")
messages = [
{
"role": "user",
"content": [
{"type": "image", "image": image},
{"type": "text", "text": "Décris cette image en détail."}
]
}
]
inputs = processor.apply_chat_template(
messages,
add_generation_prompt=True,
tokenize=True,
return_tensors="pt",
).to(model.device)
output = model.generate(**inputs, max_new_tokens=300)
print(processor.decode(output[0], skip_special_tokens=True))
Chargement quantifié (économie de VRAM)
from transformers import BitsAndBytesConfig
# Quantification en 4-bit
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_quant_type="nf4",
bnb_4bit_use_double_quant=True,
)
model = AutoModelForCausalLM.from_pretrained(
"google/gemma-4-31B-it",
quantization_config=quantization_config,
device_map="auto",
)
9. Configuration via vLLM (production)
vLLM est recommandé pour les déploiements en production nécessitant un haut débit.
Installation
pip install vllm
Lancer un serveur OpenAI-compatible
# Pour le modèle 31B Dense
python -m vllm.entrypoints.openai.api_server \
--model google/gemma-4-31B-it \
--dtype bfloat16 \
--max-model-len 131072 \
--served-model-name gemma4-31b \
--gpu-memory-utilization 0.95
# Pour le modèle 26B MoE (activer expert parallelism)
python -m vllm.entrypoints.openai.api_server \
--model google/gemma-4-26B-A4B-it \
--dtype bfloat16 \
--max-model-len 262144 \
--enable-expert-parallel \
--served-model-name gemma4-moe
Appel Python
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="not-needed" # vLLM ne requiert pas de clé
)
response = client.chat.completions.create(
model="gemma4-31b",
messages=[
{"role": "system", "content": "Tu es un assistant expert."},
{"role": "user", "content": "Analyse les tendances du marché IA en 2026."}
],
temperature=0.7,
max_tokens=1024,
)
print(response.choices[0].message.content)
10. Configuration sur Apple Silicon (MLX)
MLX est le framework optimisé d'Apple pour ses puces M-series.
Installation
pip install mlx-vlm
Inférence
from mlx_vlm import load, generate
from mlx_vlm.prompt_utils import apply_chat_template
from mlx_vlm.utils import load_config
# Charger le modèle (téléchargement automatique depuis HuggingFace)
model, processor = load("google/gemma-4-31B-it")
config = load_config("google/gemma-4-31B-it")
prompt = apply_chat_template(
processor,
config,
"Explique le principe de la mixture of experts.",
num_images=0
)
output = generate(model, processor, prompt, max_tokens=500, verbose=True)
print(output)
Optimisation TurboQuant (MLX)
# TurboQuant réduit la mémoire active de ~4x avec une perte de qualité minimale
mlx_lm.convert \
--hf-path google/gemma-4-31B-it \
--mlx-path gemma4-31b-mlx-4bit \
-q \
--q-bits 4
11. Déploiement dans le navigateur (WebGPU)
Gemma 4 peut tourner entièrement dans le navigateur via WebGPU avec transformers.js.
<!DOCTYPE html>
<html>
<head>
<script type="module">
import { pipeline } from 'https://cdn.jsdelivr.net/npm/@huggingface/transformers';
const generator = await pipeline(
'text-generation',
'google/gemma-4-E2B-it', // Modèle edge pour le navigateur
{ device: 'webgpu' }
);
const result = await generator(
"Explique le machine learning en 2 phrases.",
{ max_new_tokens: 100 }
);
console.log(result[0].generated_text);
</script>
</head>
<body>
<p>Gemma 4 dans le navigateur via WebGPU !</p>
</body>
</html>
12. Fine-tuning avec Unsloth + LoRA
Unsloth permet de fine-tuner Gemma 4 avec une consommation mémoire réduite de 60-80%.
Installation
pip install unsloth trl datasets
Script de fine-tuning complet
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset
import torch
# Chargement du modèle en 4-bit
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="google/gemma-4-E4B-it", # ou gemma-4-26B-A4B-it
max_seq_length=131072,
dtype=torch.bfloat16,
load_in_4bit=True,
)
# Configuration LoRA
model = FastLanguageModel.get_peft_model(
model,
r=16, # Rang LoRA (8-64 selon la tâche)
lora_alpha=16, # Scaling factor (= r pour commencer)
lora_dropout=0, # 0 = pas de dropout (recommandé)
bias="none",
target_modules=[
"q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"
],
use_gradient_checkpointing="unsloth",
random_state=42,
)
# Chargement du dataset
dataset = load_dataset("votre_dataset", split="train")
# Format de conversation Gemma 4
def formatter(sample):
return tokenizer.apply_chat_template(
[
{"role": "system", "content": "Tu es un expert."},
{"role": "user", "content": sample["question"]},
{"role": "assistant", "content": sample["answer"]},
],
tokenize=False,
)
# Entraînement
trainer = SFTTrainer(
model=model,
tokenizer=tokenizer,
train_dataset=dataset,
formatting_func=formatter,
args=TrainingArguments(
output_dir="./gemma4-finetuned",
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
num_train_epochs=3,
learning_rate=2e-4,
fp16=False,
bf16=True,
logging_steps=10,
save_steps=500,
warmup_ratio=0.03,
lr_scheduler_type="cosine",
),
)
trainer.train()
# Sauvegarder en GGUF pour Ollama/llama.cpp
model.save_pretrained_gguf(
"gemma4-finetuned-gguf",
tokenizer,
quantization_method="q4_k_m"
)
13. Gestion du mode de réflexion (Thinking)
Gemma 4 introduit un mode thinking configurable qui permet au modèle de raisonner étape par étape avant de répondre.
Activer le thinking
# Ajouter le token <|think|> au début du system prompt
messages = [
{
"role": "system",
"content": "<|think|>Tu es un expert en mathématiques. Résous les problèmes pas à pas."
},
{
"role": "user",
"content": "Quelle est la dérivée de f(x) = x³ * ln(x) ?"
}
]
Désactiver le thinking
# Ne pas inclure <|think|> — réponses directes et rapides
messages = [
{
"role": "system",
"content": "Tu es un assistant concis. Réponds en une phrase maximum."
},
{
"role": "user",
"content": "Quelle est la capitale de la France ?"
}
]
Règle pratique
| Cas d'usage | Thinking | Justification |
|---|---|---|
| Mathématiques, raisonnement logique | ✅ | Bénéfice maximal |
| Code complexe / débogage | ✅ | Analyse plus profonde |
| Q&A simple, chatbot | ❌ | Réponses plus rapides |
| Classification, extraction | ❌ | Inutile, coûteux |
| Agents multi-étapes | ✅ | Meilleure planification |
14. Configuration du token budget visuel
Le token budget contrôle combien de tokens sont utilisés pour représenter une image. Plus le budget est élevé, plus le détail visuel est préservé — au coût d'une inférence plus lente.
Valeurs disponibles : 70, 140, 280, 560, 1120
# Dans le message, configurer le token budget
messages = [
{
"role": "user",
"content": [
{
"type": "image",
"image": image,
"image_token_budget": 560 # Choisir selon le cas d'usage
},
{"type": "text", "text": "Décris cette image."}
]
}
]
Guide de sélection du budget
| Token budget | Cas d'usage recommandé |
|---|---|
| 70 | Classification rapide, thumbnails |
| 140 | Vidéo (traitement de nombreuses frames) |
| 280 | Captioning, Q&A visuel simple |
| 560 | OCR, analyse de documents |
| 1120 | Détection fine, analyse médicale, cartes détaillées |
15. Comparaison avec Gemma 3
| Caractéristique | Gemma 3 | Gemma 4 |
|---|---|---|
| Taille maximale | 27B | 31B Dense + 26B MoE |
| Fenêtre contexte max | 128K | 256K |
| Licence | Gemma License (restrictive) | Apache 2.0 |
| Audio natif | ❌ | ✅ (E2B, E4B) |
| Mode Thinking | ❌ | ✅ |
| Function Calling | Limité | ✅ Natif |
| Format system role | Propriétaire | Standard (system/user/assistant) |
| AIME 2026 (27B) | 20,8% | 89,2% (31B) |
| Agentic tool use | 6,6% | 86,4% |
Quand rester sur Gemma 3 ?
- Vos pipelines existants sont optimisés pour les tailles 1B/4B classiques
- Vous n'avez pas besoin du contexte étendu (> 128K)
- Compatibilité avec des outils spécifiques à Gemma 3
Quand migrer vers Gemma 4 ?
- Vous avez besoin de raisonnement avancé ou d'agents
- Votre application nécessite l'audio natif
- Vous voulez la licence Apache 2.0 pour usage commercial sans restrictions
- Vous ciblez du contexte long (128K-256K tokens)
16. Ressources et liens utiles
Téléchargements
- Hugging Face : huggingface.co/google — Tous les checkpoints (base + IT)
- Kaggle : Accès aux poids via Google Kaggle
- Ollama :
ollama pull gemma4:31b
Outils compatibles (support day-one)
| Outil | Usage |
|---|---|
| Hugging Face Transformers | Inférence Python complète |
| TRL | Fine-tuning supervisé |
| vLLM | Serveur haute performance |
| llama.cpp | Inférence CPU/GPU universelle |
| MLX | Apple Silicon optimisé |
| Ollama | Déploiement local simplifié |
| LM Studio | Interface graphique locale |
| Unsloth | Fine-tuning efficace |
| NVIDIA NIM / NeMo | Déploiement enterprise NVIDIA |
| Google AI Studio | Cloud, 31B et 26B disponibles |
| Vertex AI | Déploiement Google Cloud |
| transformers.js | Navigateur (WebGPU) |
Plateformes cloud
- Google AI Studio : accès immédiat aux modèles 31B et 26B MoE
- Google AI Edge Gallery : accès aux modèles E2B et E4B
- Vertex AI : déploiement enterprise avec conformité réglementaire
- NVIDIA NIM : inférence optimisée sur GPU NVIDIA
Pour aller plus loin
- Blog officiel : blog.google/gemma-4
- Page DeepMind : deepmind.google/models/gemma/gemma-4
- Blog Hugging Face : huggingface.co/blog/gemma4
- Documentation Ollama : ollama.com/library/gemma4
- Wiki communautaire : gemma4.wiki
Guide rédigé le 4 avril 2026 — basé sur les sources officielles Google DeepMind, Hugging Face et la documentation technique Gemma 4.