> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/gemma3.md).

# 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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/gemma3.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.