Gemma 3

Exécutez les modèles multimodaux Gemma 3 de Google sur Clore.ai — surpassent Llama-405B en étant 15 fois plus petits

Gemma 3, sorti en mars 2025 par Google DeepMind, repose sur la même technologie que Gemini 2.0. Son exploit marquant : le modèle 27B bat Llama 3.1 405B sur les benchmarks LMArena — un modèle 15 fois plus grand. Il est multimodal nativement (texte + images + vidéo), prend en charge 128K de contexte et fonctionne sur une seule RTX 4090 avec quantification.

Caractéristiques clés

• Surpasse largement sa catégorie: le modèle 27B bat des modèles de classe 405B sur les principaux benchmarks

• Multimodal nativement: compréhension intégrée du texte, de l'image et de la vidéo

• Fenêtre de contexte de 128K: traiter de longs documents, des bases de code, des conversations

• Quatre tailles: 1B, 4B, 12B, 27B — de quoi couvrir tous les budgets GPU

• Versions QAT: les variantes Quantization-Aware Training permettent au 27B de fonctionner sur des GPU grand public

• Large compatibilité avec les frameworks: Ollama, vLLM, Transformers, Keras, JAX, PyTorch

Variantes de modèle

Modèle	Paramètres	VRAM (Q4)	VRAM (FP16)	Idéal pour
Gemma 3 1B	1B	1,5 Go	3 Go	Edge, mobile, tests
Gemma 3 4B	4B	4 Go	9GB	GPU à petit budget, tâches rapides
Gemma 3 12B	12B	10GB	25 Go	Qualité/vitesse équilibrées
Gemma 3 27B	27B	18 Go	54 Go	Meilleure qualité, production
Gemma 3 27B QAT	27B	14 Go	—	Optimisé pour les GPU grand public

Exigences

Composant	Gemma 3 4B	Gemma 3 27B (Q4)	Gemma 3 27B (FP16)
GPU	RTX 3060	RTX 4090	2× RTX 4090 / A100
VRAM	6 Go	24GB	48 Go+
RAM	16 Go	32 Go	64 Go
Disque	10GB	25 Go	55 Go
CUDA	12.8+	12.8+	12.8+

GPU Clore.ai recommandé: RTX 4090 24 Go (0,14–0,42 $/h) pour un 27B quantifié — le point idéal

Démarrage rapide avec Ollama

# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Exécuter différentes tailles
ollama run gemma3:1b     # Minuscule — 1,5 Go de VRAM
ollama run gemma3:4b     # Petit — 4 Go de VRAM
ollama run gemma3:12b    # Moyen — 10 Go de VRAM
ollama run gemma3:27b    # Grand — 18-20 Go de VRAM (quantifié)

# Version QAT (quantification optimisée)
ollama run gemma3:27b-qat

Serveur API Ollama

ollama serve &

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma3:27b",
    "messages": [{"role": "user", "content": "Comparez REST et GraphQL pour une nouvelle API"}]
  }'

Vision avec Ollama

# Analyser une image
ollama run gemma3:27b "Décrivez cette image en détail" --images ./photo.jpg

Configuration de vLLM (production)

pip install vllm

# Servir le modèle 27B
vllm serve google/gemma-3-27b-it \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90

# Servir avec un contexte plus long sur 2 GPU
vllm serve google/gemma-3-27b-it \
  --tensor-parallel-size 2 \
  --max-model-len 65536

# Servir le 4B pour les configurations à petit budget
vllm serve google/gemma-3-4b-it \
  --max-model-len 32768

Transformers de HuggingFace

Génération de texte

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "google/gemma-3-27b-it"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True  # Tient sur un GPU de 24 Go
)

messages = [
    {"role": "user", "content": "Écrivez une classe Python pour un arbre binaire de recherche avec les méthodes insert, search et delete"}
]

input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(input_ids, max_new_tokens=2048, temperature=0.7, do_sample=True)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))

Vision (compréhension d'image)

import torch
from transformers import AutoProcessor, Gemma3ForConditionalGeneration
from PIL import Image

model_name = "google/gemma-3-27b-it"
processor = AutoProcessor.from_pretrained(model_name)
model = Gemma3ForConditionalGeneration.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# Charger l’image
image = Image.open("screenshot.png")

messages = [
    {"role": "user", "content": [
        {"type": "image", "image": image},
        {"type": "text", "text": "Que montre cette capture d'écran ? Listez tous les éléments de l'interface."}
    ]}
]

inputs = processor.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(**inputs, max_new_tokens=1024)
print(processor.decode(output[0], skip_special_tokens=True))

Démarrage rapide avec Docker

docker run --gpus all -p 8000:8000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  vllm/vllm-openai:latest \
  --model google/gemma-3-27b-it \
  --max-model-len 8192

Points saillants des benchmarks

Benchmark	Gemma 3 27B	Llama 3.1 70B	Llama 3.1 405B
ELO LMArena	1354	1298	1337
MMLU	75.6	79.3	85.2
HumanEval	72.0	72.6	80.5
VRAM (Q4)	18 Go	40 Go	200 Go+
Coût sur Clore	0,14–0,42 $/h (1× 4090)	0,28–0,84 $/h (2× 4090)	pas sur la place de marché

Le 27B offre une qualité conversationnelle de classe 405B pour un coût en VRAM 10 fois inférieur.

Conseils pour les utilisateurs de Clore.ai

• Le 27B QAT est le point idéal: la Quantization-Aware Training signifie moins de perte de qualité qu'une quantification post-entraînement — faites-le fonctionner sur une seule RTX 4090

• La vision est gratuite: aucune configuration supplémentaire n'est nécessaire — Gemma 3 comprend les images nativement. Idéal pour l'analyse de documents, l'analyse de captures d'écran, la lecture de graphiques

• Commencez avec un contexte court: Utilisez --max-model-len 8192 au départ ; augmentez seulement si nécessaire pour économiser de la VRAM

• 4B pour les exécutions à petit budget: si vous êtes sur une RTX 3060/3070 (0,03–0,07 $/h), le modèle 4B surpasse encore les modèles 27B de la génération précédente

• Pas besoin d'authentification Google: contrairement à certains modèles, Gemma 3 se télécharge sans restriction (il suffit d'accepter la licence sur HuggingFace)

Dépannage

Problème	Solution
OutOfMemoryError sur le 27B	Utilisez la version QAT ou réduisez --max-model-len à 4096
La vision ne fonctionne pas dans Ollama	Mettez Ollama à jour vers la dernière version : curl -fsSL https://ollama.com/install.sh | sh
Vitesse de génération lente	Vérifiez que vous utilisez bfloat16, et non float32. Utilisez --dtype bfloat16
Le modèle produit des résultats incohérents	Assurez-vous d'utiliser la -it (optimisée pour l'instruction), et non le modèle de base
Erreur 403 au téléchargement	Acceptez la licence Gemma à l'adresse https://huggingface.co/google/gemma-3-27b-it

Pour aller plus loin

• Rapport technique Gemma 3

• Fiche modèle HuggingFace

• Bibliothèque Ollama

• Google AI Studio — essayez Gemma 3 en ligne avant de louer un GPU