Gemma 3 en Python 2026 :
multimodal, 128K contexte, Ollama et fine-tuning

1. Pourquoi Gemma 3 change la donne

En mars 2025, Google DeepMind a publié Gemma 3 avec une promesse inhabituelle : un modèle 4B qui surpasse son propre modèle 27B de la génération précédente. Ce n'est pas un effet de benchmark cherry-picking — c'est le résultat d'une combinaison de trois innovations architecturales majeures appliquées simultanément : une attention hybride locale/globale qui démultiplie l'efficacité mémoire, une distillation depuis Gemini 2.0 qui transfère la capacité d'un modèle frontier vers des tailles inférieures, et un tokenizer Gemini à 262K tokens qui améliore drastiquement la gestion des langues non-latines et du code.

Pour le développeur Python, l'implication pratique est directe : un modèle multimodal (texte + images) de 4B paramètres, fonctionnant avec 4 Go de VRAM via Ollama, capable de traiter des contextes de 128 000 tokens — là où Gemma 2 s'arrêtait à 8 000. Si vous avez déjà eu besoin d'analyser un PDF complet, de coder sur une grande base de code ou d'extraire des informations d'une longue conversation, Gemma 3 est une rupture de niveau par rapport à la génération précédente à la même taille.

2. Architecture — hybrid attention et distillation Gemini

Gemma 3 est un transformer decoder-only avec Grouped-Query Attention (GQA). Ses différences architecturales par rapport à Gemma 2 sont substantielles.

Tokenizer Gemini 2.0 — Gemma 3 adopte le tokenizer de Gemini 2.0 (vocabulaire de 262 144 tokens, SentencePiece avec encodage byte-level). Vs le tokenizer de Gemma 2 (~256K tokens), l'impact principal est une meilleure compression des langues CJK (chinois, japonais, coréen), des langues à alphabet non-latin, et du code. Résultat : moins de tokens pour la même séquence dans ces langues, ce qui se traduit directement en contexte utile plus long et en inférence moins coûteuse.

Distillation depuis Gemini 2.0 — 1 à 3% des tokens d'entraînement sont utilisés pour une distillation de connaissance depuis un modèle Gemini 2.0. Cette technique, combinée au pré-entraînement massif (2T tokens pour le 1B, 14T pour le 27B), explique le saut de qualité par rapport à la taille de paramètres. Le 4B absorbe des capacités de raisonnement que son nombre de paramètres ne permettrait pas d'acquérir par pré-entraînement seul.

QK-norm à la place du soft-capping — Gemma 2 utilisait un logit soft-capping pour stabiliser l'entraînement. Gemma 3 le remplace par une normalisation QK (Query-Key normalization avec RMSNorm), ce qui donne un training plus stable à large batch size et permet d'allonger le contexte sans instabilité numérique.

Les dimensions architecturales exactes selon le rapport technique officiel :

3. La famille Gemma 3 — 1B à 27B

Cet article couvre les quatre tailles principales : 1B, 4B, 12B et 27B. Depuis la sortie initiale, des variantes plus petites comme 270M sont également disponibles dans l'écosystème Ollama pour des cas d'usage edge et embarqué.

4. Hybrid attention 5:1 — l'innovation clé

C'est l'innovation architecturale qui rend le contexte 128K viable sur GPU grand public. Comprendre pourquoi nécessite de revenir au problème fondamental de l'attention longue-distance.

Le coût quadratique de l'attention globale

L'attention standard de type "full global" calcule les relations entre tous les paires de tokens. Le coût est O(n²) en mémoire pour le KV-cache : doubler la longueur de séquence quadruple la mémoire d'attention. Pour 128K tokens avec attention purement globale sur le 27B, le KV-cache occuperait une fraction prohibitive de la VRAM.

Gemma 3 résout ce problème par une alternance structurée :

• Couches locales (5 sur 6) — fenêtre glissante de 1024 tokens. Chaque token n'attende qu'aux 1024 tokens précédents. Coût O(n) — la fenêtre est fixe, le KV-cache ne croît pas avec la longueur totale de la séquence.
• Couche globale (1 sur 6) — attention complète sur le contexte entier (jusqu'à 128K). C'est ici que les dépendances longue-distance sont capturées.

Ce ratio 5:1 réduit l'occupation du KV-cache de ~60% (modèle global-only) à moins de 15% de la VRAM totale — sans sacrifier la capacité à capturer les dépendances à distance, puisque les couches globales s'en chargent.

Le RoPE est configuré différemment selon le type de couche : base de fréquence 10k pour les couches locales (contexte court), 1M pour les couches globales (contexte long), avec un facteur de rescaling ×8 appliqué. Cette asymétrie permet au modèle d'utiliser efficacement ses embeddings positionnels sur les deux échelles de contexte.

5. Vision multimodale — SigLIP encoder

Les modèles Gemma 3 4B, 12B et 27B intègrent un encodeur visuel SigLIP de 400M paramètres, gelé pendant le fine-tuning du LLM. SigLIP (Sigmoid Loss for Language-Image Pre-Training, Zhai et al., 2023) utilise une fonction de perte sigmoid binaire plutôt que contrastive softmax, ce qui le rend plus stable et efficace à entraîner.

Pipeline de traitement d'images

Redimensionnement — toute image est redimensionnée à 896×896 pixels (résolution native de SigLIP dans la configuration Gemma 3).

Encodage — SigLIP produit un embedding par patch. Un pooling 4×4 réduit ensuite la représentation à 256 tokens image. Ces tokens sont concaténés avec les tokens texte dans la séquence d'entrée du LLM.

Pan & Scan pour la haute résolution — pour des images de résolution élevée ou de format très large/haut, Gemma 3 applique un mécanisme adaptatif : l'image originale est découpée en tuiles (chacune redimensionnée à 896×896), chaque tuile est encodée séparément, et les embeddings sont concaténés. Une représentation "thumbnail" de l'image complète est également encodée à 896×896 et ajoutée. Ce mécanisme permet de traiter des captures d'écran, des documents scannés et des images médicales sans perte excessive de détail.

Attention pour les images — contrairement à l'attention causale des tokens texte, les tokens image bénéficient d'une attention bidirectionnelle non-causale entre eux. Chaque token image peut attendre tous les autres tokens image (pas de masque causal), ce qui améliore la compréhension spatiale.

6. Installation Ollama

# Installer Ollama (Linux / macOS)
curl -fsSL https://ollama.com/install.sh | sh

# Télécharger un modèle Gemma 3
ollama pull gemma3:1b    # ~1.5 Go — texte-only, 32K
ollama pull gemma3:4b    # ~2.5 Go — multimodal, 128K (recommandé)
ollama pull gemma3:12b   # ~7 Go  — multimodal, 128K
ollama pull gemma3:27b   # ~16 Go — multimodal, 128K

# Tester en ligne de commande
ollama run gemma3:4b "Explique l'attention hybride en 3 phrases."

# Installer la librairie Python Ollama
pip install ollama

7. API Python — texte avec Ollama

import ollama

# Appel simple
response = ollama.chat(
    model="gemma3:4b",
    messages=[
        {"role": "user", "content": "Qu'est-ce que le Rotary Position Embedding ?"}
    ]
)
print(response.message.content)


# Conversation multi-tours avec contexte système
messages = [
    {
        "role": "system",
        "content": "Tu es un expert Python. Réponds en français, de façon concise."
    },
    {"role": "user", "content": "Explique les générateurs Python."},
]

response = ollama.chat(model="gemma3:4b", messages=messages)
messages.append({"role": "assistant", "content": response.message.content})
messages.append({"role": "user", "content": "Donne un exemple avec yield from."})

response = ollama.chat(model="gemma3:4b", messages=messages)
print(response.message.content)


# Streaming token par token
for chunk in ollama.chat(
    model="gemma3:4b",
    messages=[{"role": "user", "content": "Écris une fonction de tri rapide en Python."}],
    stream=True,
):
    print(chunk.message.content, end="", flush=True)


# API compatible OpenAI (port 11434)
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
resp = client.chat.completions.create(
    model="gemma3:4b",
    messages=[{"role": "user", "content": "Bonjour Gemma 3"}]
)
print(resp.choices[0].message.content)

8. API Python — images et multimodal

Gemma 3 4B, 12B et 27B acceptent des images via Ollama. Le modèle 1B est texte-only.

import ollama
import json

# Le SDK Python Ollama accepte directement un chemin de fichier
# (le SDK gère la conversion — le REST attend du base64)

# Décrire une image
response = ollama.chat(
    model="gemma3:4b",
    messages=[{
        "role": "user",
        "content": "Décris cette image en détail.",
        "images": ["screenshot.png"],   # chemin local, URL ou bytes
    }]
)
print(response.message.content)


# Extraire des données structurées depuis une image
response = ollama.chat(
    model="gemma3:12b",
    messages=[{
        "role": "user",
        "content": """Analyse ce tableau et retourne un JSON avec :
{
  "colonnes": [...],
  "lignes": [[...], ...],
  "total": ...
}
Retourne uniquement le JSON valide.""",
        "images": ["tableau.png"],
    }]
)
data = json.loads(response.message.content)


# Comparer deux images
response = ollama.chat(
    model="gemma3:12b",
    messages=[{
        "role": "user",
        "content": "Quelles sont les différences entre ces deux images ?",
        "images": ["before.png", "after.png"],
    }]
)


# Si tu passes par le REST API directement : base64 requis
import base64, requests
img_b64 = base64.b64encode(open("screenshot.png", "rb").read()).decode()
requests.post("http://localhost:11434/api/chat", json={
    "model": "gemma3:4b",
    "messages": [{"role": "user", "content": "Décris.", "images": [img_b64]}]
})

9. Hugging Face Transformers

Pour un contrôle plus fin hors Ollama — quantization personnalisée, fine-tuning, intégration dans un pipeline HF — utiliser Transformers directement. Deux classes différentes selon l'usage :

# --- Modèle texte-only (1B, ou 4B/12B/27B sans vision) ---
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_id = "google/gemma-3-4b-it"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,   # bfloat16 recommandé — qualité dégradée avec fp16
    device_map="auto",
    attn_implementation="sdpa",   # ou "flash_attention_2" si installé
)

messages = [
    {"role": "user", "content": "Explique la hybrid attention en 3 phrases."}
]
inputs = tokenizer.apply_chat_template(
    messages, return_tensors="pt", return_dict=True, add_generation_prompt=True
).to(model.device)

with torch.no_grad():
    output = model.generate(**inputs, max_new_tokens=256, do_sample=False)

response = tokenizer.decode(
    output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True
)
print(response)


# --- Modèle multimodal (4B / 12B / 27B avec vision) ---
from transformers import Gemma3ForConditionalGeneration, AutoProcessor
from PIL import Image

model_id = "google/gemma-3-4b-it"

processor = AutoProcessor.from_pretrained(model_id)
model = Gemma3ForConditionalGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

image = Image.open("diagram.png")

messages = [{
    "role": "user",
    "content": [
        {"type": "image", "image": image},
        {"type": "text", "text": "Décris ce diagramme et explique les relations entre les composants."},
    ]
}]

inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True,
    tokenize=True, return_dict=True, return_tensors="pt"
).to(model.device, dtype=torch.bfloat16)

with torch.no_grad():
    output = model.generate(**inputs, max_new_tokens=512)

response = processor.decode(
    output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True
)
print(response)

10. Contexte 128K — cas d'usage concrets

128 000 tokens correspondent approximativement à 100 000 mots — soit un roman entier, une base de code de taille moyenne, ou plusieurs heures de transcription. Pour les modèles 4B, 12B et 27B, ce contexte est natif (le 1B est limité à 32K).

import ollama
from pathlib import Path

# Analyser un fichier de code entier (~10 000 lignes)
code = Path("large_codebase.py").read_text()

response = ollama.chat(
    model="gemma3:12b",
    messages=[{
        "role": "user",
        "content": f"""Analyse ce code Python et identifie :
1. Les patterns architecturaux utilisés
2. Les potentiels problèmes de performance
3. Les dépendances circulaires éventuelles

Code :
{code}"""
    }],
    options={"num_ctx": 32768}  # Spécifier le contexte si > 8K tokens
)


# Q&A sur un long document (rapport annuel, contrat, documentation)
document = Path("rapport_annuel.txt").read_text()

messages = [
    {"role": "system", "content": "Tu es un assistant d'analyse documentaire. Réponds uniquement à partir du document fourni."},
    {"role": "user", "content": f"Document :\n\n{document}\n\nQuestion : Quel est le chiffre d'affaires 2024 et sa progression ?"},
]

response = ollama.chat(
    model="gemma3:4b",
    messages=messages,
    options={"num_ctx": 65536}
)

11. Fine-tuning avec Unsloth

Unsloth supporte Gemma 3 (1B, 4B, 12B, 27B) via ses modèles pré-optimisés sur le Hub. Le pipeline est identique à celui décrit dans notre guide Unsloth complet, avec quelques spécificités Gemma 3.

from unsloth import FastLanguageModel
from unsloth.chat_templates import get_chat_template

# Chargement — utiliser les modèles unsloth/ pour un chargement optimisé
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/gemma-3-4b-it",   # ou gemma-3-12b-it, gemma-3-27b-it
    max_seq_length=8192,
    dtype=None,              # auto-detect bfloat16
    load_in_4bit=True,
)

# Template de chat Gemma 3
tokenizer = get_chat_template(tokenizer, chat_template="gemma-3")

# Configuration LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
    random_state=42,
)

model.print_trainable_parameters()
# trainable params: ~84M / 4B total → ~2%


# Entraînement avec SFTTrainer (même pattern qu'avec Llama)
from trl import SFTTrainer
from transformers import TrainingArguments
from unsloth import is_bfloat16_supported

trainer = SFTTrainer(
    model=model,
    processing_class=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=8192,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        bf16=is_bfloat16_supported(),
        fp16=not is_bfloat16_supported(),
        optim="adamw_8bit",
        output_dir="gemma3-finetuned",
    ),
)
trainer.train()

# Export GGUF pour Ollama
model.save_pretrained_gguf("gemma3-gguf", tokenizer, quantization_method="q4_k_m")

12. VRAM par taille et configuration

Le fine-tuning du 27B en moins de 22 Go est rendu possible par Unsloth (gradient checkpointing async + quantization 4-bit NF4). Sans Unsloth, le même entraînement nécessiterait un A100 80 Go.

13. Benchmarks — chiffres officiels (Gemma 3 27B-IT)

Source : rapport technique Gemma 3, arXiv:2503.19786, mars 2025. Tous les scores concernent le modèle instruction-tuned 27B sauf mention contraire.

14. Gemma 3 vs Llama 3 vs Qwen2.5

Pour les applications multilingues : Gemma 3 est le choix évident avec 140+ langues et le tokenizer Gemini. Pour les applications avec contraintes de licence strictes : Llama 3 (Meta Llama License, plus permissive que Gemma sur certains usages, mais pas équivalente à Apache 2.0) ou Qwen2.5 (Apache 2.0 sur les variantes principales) laissent plus de latitude juridique. Pour le multimodal compact : Gemma 3 4B reste l'option la plus équilibrée sur le marché actuellement.

15. Licence — Gemma Terms of Use décryptée

Gemma 3 n'est pas sous Apache 2.0 — c'est une erreur courante. La licence applicable est les Gemma Terms of Use, propriétaires à Google. Voici ce qu'elles permettent et interdisent concrètement.

Autorisé — usage commercial (construire des produits, faire payer des utilisateurs, déployer en SaaS), modification du modèle, distribution des weights modifiés, déploiement sur cloud ou infrastructure propre.

Interdit — utiliser Gemma 3 pour distiller d'autres modèles (entraîner un modèle concurrent sur les outputs de Gemma 3), usage dans des services de conseil médical, juridique ou financier non supervisé (prohibited use policy), retrait des attributions Google.

Clause de révocation — Google se réserve le droit de révoquer l'accès à Gemma 3 si des violations des Terms of Use sont détectées. Cette clause, combinée à l'interdiction de distillation, distingue Gemma des licences comme Apache 2.0. D'autres licences (Meta Llama License incluse) contiennent aussi des conditions de terminaison en cas de violation — la différence réside dans le périmètre des restrictions et leur symétrie avec les droits accordés.

16. FAQ