Google Gemma 4 QAT : Faites tourner une IA frontière en local en 2026

Le 6 juin 2026, Google DeepMind a publié des checkpoints entraînés avec la Quantization-Aware Training (QAT) pour toute la famille Gemma 4. Le résultat : un modèle multimodal de 26 milliards de paramètres qui tient dans 15 Go de RAM, et un modèle 2B qui démarre sur un Raspberry Pi 5. L'IA locale vient de franchir un cap décisif.

Qu'est-ce que le QAT et pourquoi surpasse-t-il la quantification classique ?

La quantification post-entraînement (PTQ) compresse un modèle déjà entraîné en arrondissant ses poids vers des formats moins précis. Rapide à appliquer, elle introduit des erreurs d'arrondi qui se propagent à travers les couches et dégradent souvent la précision de 5 à 15 % sur les benchmarks de raisonnement.

La Quantization-Aware Training (QAT) adopte l'approche inverse : elle simule la quantification pendant l'entraînement, forçant le modèle à apprendre des poids qui tolèrent nativement l'arithmétique INT4. Le modèle n'a jamais vu de valeurs flottantes qui seraient ensuite brutalement arrondies — il a été entraîné sous ces contraintes dès le départ.

Résultat concret pour Gemma 4 : le variant 26B-A4B QAT obtient 82,6 % sur MMLU Pro, 88,3 % sur AIME 2026 et 77,1 % sur LiveCodeBench — des scores quasi identiques à la référence FP16 — tout en tournant dans environ 15 Go de VRAM.

Comparez avec une conversion INT4 naïve du même modèle : 70,2 % de précision contre 85,6 % avec les GGUFs dynamiques d'Unsloth construits à partir des checkpoints QAT de Google. Cet écart de 15 points, c'est le prix à payer pour avoir sauté le QAT.

Variantes de modèles et besoins en matériel

Google a publié des checkpoints QAT pour quatre tailles de modèles :

En format de quantification mobile, le E2B descend sous 1 Go — suffisamment compact pour être embarqué dans une application Android sans streaming depuis un serveur.

Option de déploiement 1 : Ollama (le plus rapide à démarrer)

Ollama gère le téléchargement du modèle, la conversion de format et une API locale en une seule commande :

# Installer Ollama
brew install ollama          # macOS
curl -fsSL https://ollama.com/install.sh | sh   # Linux
 
# Télécharger un modèle QAT
ollama pull gemma4:e4b-it-qat
ollama pull gemma4:26b-it-qat
 
# Lancer en mode interactif
ollama run gemma4:26b-it-qat "Résume les avantages du QAT en deux phrases."
 
# Vérifier que l'API REST est active
curl http://localhost:11434/api/tags

Ollama expose un endpoint compatible OpenAI sur localhost:11434/v1 — le code existant utilisant le SDK OpenAI fonctionne avec un simple changement d'URL de base.

Option de déploiement 2 : llama.cpp (contrôle maximal)

Pour un contrôle fin sur le sampling, le format de quantification et la projection multimodale, utilisez llama.cpp avec les GGUFs dynamiques d'Unsloth :

# Chat interactif
./llama.cpp/llama-cli \
  -hf unsloth/gemma-4-26B-A4B-it-qat-GGUF:UD-Q4_K_XL \
  --temp 1.0 --top-p 0.95 --top-k 64
 
# Serveur local avec support vision
./llama.cpp/llama-server \
  --model gemma-4-26B-A4B-it-qat-UD-Q4_K_XL.gguf \
  --mmproj mmproj-BF16.gguf \
  --temp 1.0 --top-p 0.95 --top-k 64 \
  --port 8001 \
  --chat-template-kwargs '{"enable_thinking":true}'

Utilisez toujours le variant UD-Q4_K_XL d'Unsloth plutôt que les GGUFs Q4_0 bruts — le format dynamique préserve la précision sur les couches dont les valeurs extrêmes seraient agressivement arrondies en INT4 standard.

Option de déploiement 3 : vLLM (serveurs de production)

Pour les équipes qui exposent Gemma 4 en tant qu'endpoint API interne :

vllm serve google/gemma-4-31B-it-qat-w4a16-ct \
  --max-model-len 32768 \
  --port 8000

Plafonnez --max-model-len à votre usage réel. La fenêtre de contexte complète de 256K réserve un KV cache volumineux qui réduit la concurrence — sur un GPU 24 Go, 32K est un point de départ raisonnable pour les scénarios multi-utilisateurs.

Option de déploiement 4 : LiteRT-LM (Android et edge)

Pour les déploiements mobiles et edge, le runtime LiteRT-LM de Google gère les noyaux basse précision de manière transparente :

1. Exportez le modèle E2B au schéma de quantification mobile via la bibliothèque ai-edge-torch.
2. Intégrez le fichier .task dans le répertoire assets de votre application Android.
3. Le runtime détecte automatiquement la disponibilité d'un NPU (Qualcomm, MediaTek, Google Tensor) et y route l'inférence.

Le modèle E2B tourne environ deux fois plus vite que son équivalent FP16 sur les NPU mobiles, avec 40 à 50 % de mémoire en moins.

Apple Silicon (MLX)

Sur les Mac équipés de puces de la gamme M, utilisez le backend MLX pour une inférence optimisée en mémoire unifiée :

pip install mlx-lm
mlx_lm.generate \
  --model mlx-community/gemma-4-26B-A4B-it-qat-4bit \
  --prompt "Explique la quantification de noyaux en un paragraphe."

L'architecture en mémoire unifiée signifie que le GPU et le CPU partagent le même pool de RAM physique — un MacBook Pro M3 16 Go peut faire tourner le modèle 26B sans swap.

Conseils essentiels pour les développeurs

Les paramètres de sampling comptent. Google a ajusté les checkpoints QAT avec temperature 1.0, top_p 0.95, top_k 64. Modifier ces réglages — notamment vers un décodage greedy — peut affecter la qualité des sorties de manière inattendue.

Évitez les GGUFs Q4_0 bruts. Une conversion INT4 naïve perd jusqu'à 15 points de précision sur les tâches de raisonnement. Le format UD-Q4_K_XL d'Unsloth applique des tailles de groupes de quantification dynamiques aux couches problématiques, récupérant cet écart.

Le budget de contexte est additif. Les chiffres VRAM indiqués couvrent uniquement les poids. Chaque tranche de 1K tokens de contexte ajoute du KV cache par-dessus — planifiez en conséquence sur les machines 16 Go avec le modèle 26B.

Le format vLLM diffère du format llama.cpp. Pour vLLM/SGLang, utilisez les checkpoints w4a16-ct (compressed-tensors) depuis l'organisation Google sur Hugging Face. Pour llama.cpp/Ollama, utilisez les variants GGUF d'Unsloth. Ces formats ne sont pas interchangeables.

Pourquoi l'IA locale est importante en 2026

L'économie de l'inférence est en train de basculer. À grande échelle, les coûts d'API par token s'accumulent rapidement : un produit effectuant 10 millions d'appels API par jour à 0,003 $ pour 1 000 tokens dépense environ 30 000 $ par mois en inférence seule. Faire tourner Gemma 4 26B en local supprime intégralement ce poste de coût.

Pour les développeurs MENA qui construisent des produits manipulant des données sensibles — dossiers financiers, synthèses médicales, documents juridiques — l'inférence locale élimine aussi la question du transfert transfrontalier de données. Vos données ne quittent jamais votre infrastructure.

Conclusion

Google Gemma 4 QAT est la mise à niveau d'inférence locale la plus significative de 2026. Un modèle multimodal de 26 milliards de paramètres tient désormais sur le même laptop développeur 16 Go qui peinait avec des modèles 7B il y a deux ans, sans sacrifier la précision. Que vous choisissiez Ollama pour l'itération rapide, llama.cpp pour le contrôle en production, vLLM pour les API d'équipe, ou LiteRT-LM pour le mobile — le chemin vers une IA sans coût par token est désormais tracé.

Les checkpoints QAT sont disponibles sur Hugging Face sous l'organisation Google DeepMind. Les GGUFs dynamiques d'Unsloth constituent le point de départ recommandé pour les déploiements llama.cpp.