> 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

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

```bash
# 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

```bash
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

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

## Configuration de 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 les configurations à petit budget
vllm serve google/gemma-3-4b-it \
  --max-model-len 32768
```

## Transformers de HuggingFace

### 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 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)

```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 ? 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

```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 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](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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.