# Gemma 3

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

## Principales caractéristiques

* **Frappe bien au-dessus de son poids**: le 27B bat des modèles de classe 405B sur les principaux benchmarks
* **Nativement multimodal**: Compréhension du texte, des images et de la vidéo intégrée
* **Fenêtre de contexte 128K**: Traitez de longs documents, des bases de code, des conversations
* **Quatre tailles**: 1B, 4B, 12B, 27B — quelque chose pour chaque budget GPU
* **Versions QAT**: Les variantes Quantization-Aware Training permettent au 27B de fonctionner sur des GPU grand public
* **Large prise en charge des 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      | 9 Go        | GPU économiques, tâches rapides    |
| Gemma 3 12B     | 12B        | 10Go      | 25 Go       | Qualité/vitesse équilibrée         |
| Gemma 3 27B     | 27B        | 18Go      | 54 Go       | Meilleure qualité, production      |
| Gemma 3 27B QAT | 27B        | 14GB      | —           | 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       | 24 Go            | 48 Go+             |
| RAM       | 16Go       | 32Go             | 64Go               |
| Disque    | 10Go       | 25 Go            | 55 Go              |
| CUDA      | 11.8+      | 11.8+            | 12.0+              |

**GPU recommandé par Clore.ai**: RTX 4090 24 Go (\~0,5–2 $/jour) pour le 27B quantifié — le point idéal

## Démarrage rapide avec Ollama

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

# Exécuter différentes tailles
ollama run gemma3:1b     # Tout petit — 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

```bash
ollama serve &

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

### Vision avec Ollama

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

## Configuration vLLM (Production)

```bash
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 des configurations économiques
vllm serve google/gemma-3-4b-it \
  --max-model-len 32768
```

## HuggingFace Transformers

### Génération de texte

```python
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 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)

```python
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 ? Dressez la liste de tous les éléments de l'interface utilisateur."}
    ]}
]

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 Docker

```bash
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 forts des benchmarks

| Benchmark          | Gemma 3 27B      | Llama 3.1 70B  | Llama 3.1 405B   |
| ------------------ | ---------------- | -------------- | ---------------- |
| LMArena ELO        | 1354             | 1298           | 1337             |
| MMLU               | 75.6             | 79.3           | 85.2             |
| HumanEval          | 72.0             | 72.6           | 80.5             |
| VRAM (Q4)          | 18Go             | 40Go           | 200 Go+          |
| **Coût sur Clore** | **0,5–2 $/jour** | **3–6 $/jour** | **12–24 $/jour** |

Le 27B offre une qualité conversationnelle de classe 405B à 1/10e du coût en VRAM.

## Conseils pour les utilisateurs de Clore.ai

* **Le 27B QAT est le point idéal**: Le Quantization-Aware Training signifie moins de perte de qualité qu'avec la quantification post-entraînement — exécutez-le sur une seule RTX 4090
* **La vision est gratuite**: Aucune configuration supplémentaire requise — Gemma 3 comprend les images nativement. Idéal pour l'analyse de documents, l'analyse de captures d'écran, la lecture de graphiques
* **Commencez par un contexte court**: Utilisez `--max-model-len 8192` initialement ; augmentez seulement si nécessaire pour économiser la VRAM
* **4B pour les exécutions économiques**: Si vous êtes sur RTX 3060/3070 (0,15–0,3 $/jour), le modèle 4B surpasse toujours les modèles 27B de la génération précédente
* **Authentification Google non requise**: Contrairement à certains modèles, Gemma 3 se télécharge sans restriction (acceptez simplement la licence sur HuggingFace)

## Dépannage

| Problème                             | Solution                                                                                         |
| ------------------------------------ | ------------------------------------------------------------------------------------------------ |
| `OutOfMemoryError` sur 27B           | Utilisez la version QAT ou réduisez `--max-model-len` à 4096                                     |
| 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, pas float32. Utilisez `--dtype bfloat16`                    |
| Le modèle produit des déchets        | Assurez-vous d'utiliser la `-it` variante (instruct-tuned), pas le modèle de base                |
| Erreur 403 lors du téléchargement    | Acceptez la licence Gemma sur <https://huggingface.co/google/gemma-3-27b-it>                     |

## Lectures complémentaires

* [Rapport technique Gemma 3](https://ai.google.dev/gemma)
* [Fiche modèle HuggingFace](https://huggingface.co/google/gemma-3-27b-it)
* [Bibliothèque Ollama](https://ollama.com/library/gemma3)
* [Google AI Studio](https://aistudio.google.com/) — essayez Gemma 3 en ligne avant de louer un GPU