Comment fine-tuner Gemma 4 avec LoRA (Étape par étape)

Gemma 4 est déjà impressionnant par défaut, mais que faire si vous avez besoin qu'il parle comme votre marque, suive votre format de sortie spécifique ou excelle dans un domaine de niche où les modèles généralistes trébuchent ? C'est là que le fine-tuning entre en jeu.

La bonne nouvelle : vous n'avez plus besoin d'un cluster d'A100. Avec LoRA et un outil appelé Unsloth, vous pouvez fine-tuner Gemma 4 sur un seul GPU en moins d'une heure. Passons en revue tout le processus.

Pourquoi fine-tuner ?

Avant d'investir de l'effort, assurez-vous que le fine-tuning est vraiment ce dont vous avez besoin. Voici un guide de décision rapide :

Si le prompt engineering et RAG ne suffisent pas, le fine-tuning est votre prochaine étape. Avant de plonger, essayez nos meilleurs prompts Gemma 4 — vous pourriez résoudre le problème avec un meilleur prompting seul. Pour un aperçu plus large de ce que Gemma 4 peut faire avant de commencer à le personnaliser, consultez notre guide des cas d'utilisation.

LoRA et QLoRA expliqués (simplement)

LoRA (Low-Rank Adaptation) ne modifie pas les poids du modèle original. Au lieu de cela, il entraîne un petit ensemble de poids d'adaptateur qui se placent au-dessus du modèle de base. Pensez-y comme mettre un objectif personnalisé sur un appareil photo plutôt que reconstruire l'appareil.

• Modèle de base : figé, intact
• Adaptateur : minuscule (généralement 1-5% de la taille du modèle de base)
• Résultat : qualité proche du fine-tuning complet à une fraction du coût

QLoRA va un cran plus loin — il charge le modèle de base sous forme quantifiée 4 bits, réduisant l'utilisation mémoire de moitié environ. Vous obtenez 90%+ de la qualité LoRA tout en tenant sur des GPU bien plus petits.

Configurer Unsloth

Unsloth est le moyen le plus rapide de fine-tuner Gemma 4 avec LoRA. Il patche le modèle pour un entraînement 2x plus rapide et 60% de moins d'utilisation mémoire par rapport à HuggingFace vanilla.

# Créer un environnement virtuel
python -m venv gemma4-finetune
source gemma4-finetune/bin/activate

# Installer Unsloth (inclut toutes les dépendances)
pip install unsloth

# Pour QLoRA sur les anciens GPU, installez aussi :
pip install bitsandbytes

Vérifiez votre configuration :

import torch
print(f"CUDA disponible : {torch.cuda.is_available()}")
print(f"GPU : {torch.cuda.get_device_name(0)}")
print(f"VRAM : {torch.cuda.get_device_properties(0).total_mem / 1e9:.1f} Go")

Préparer vos données d'entraînement

Vos données doivent être au format JSONL, chaque ligne contenant une conversation. Voici la structure attendue par Gemma 4 :

{"messages": [{"role": "user", "content": "Quelle est la politique de retour ?"}, {"role": "assistant", "content": "Notre politique de retour permet les retours dans les 30 jours suivant l'achat avec le reçu original."}]}
{"messages": [{"role": "user", "content": "Livrez-vous à l'international ?"}, {"role": "assistant", "content": "Oui, nous livrons dans 45 pays. La livraison prend 7-14 jours ouvrables."}]}
{"messages": [{"role": "system", "content": "Tu es un assistant de codage médical."}, {"role": "user", "content": "Code : Patient présente une bronchite aiguë"}, {"role": "assistant", "content": "CIM-10 : J20.9 - Bronchite aiguë, non précisée"}]}

Conseils de qualité des données :

• 500-1000 exemples est le point optimal pour la plupart des tâches
• Plus n'est pas toujours mieux — 500 exemples de haute qualité valent mieux que 5000 bâclés
• Incluez des cas limites et des exemples négatifs
• Gardez les réponses cohérentes en format et ton
• Validez votre JSONL avant l'entraînement :

import json

def validate_jsonl(filepath):
    valid = 0
    errors = 0
    with open(filepath, 'r') as f:
        for i, line in enumerate(f, 1):
            try:
                data = json.loads(line)
                assert "messages" in data, "Clé 'messages' manquante"
                assert len(data["messages"]) >= 2, "Au moins 2 messages nécessaires"
                valid += 1
            except (json.JSONDecodeError, AssertionError) as e:
                print(f"Ligne {i} : {e}")
                errors += 1
    print(f"\nValides : {valid}, Erreurs : {errors}")

validate_jsonl("training_data.jsonl")

Configuration de l'entraînement

Voici un script d'entraînement complet utilisant Unsloth :

from unsloth import FastLanguageModel
import torch

# Charger le modèle avec QLoRA (4 bits)
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="google/gemma-4-e4b",
    max_seq_length=4096,
    dtype=None,           # Détection auto
    load_in_4bit=True,    # QLoRA
)

# Ajouter les adaptateurs LoRA
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                  # Rang — plus élevé = plus de capacité, plus de VRAM
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha=16,
    lora_dropout=0,        # Optimisé par Unsloth — gardez à 0
    bias="none",
    use_gradient_checkpointing="unsloth",
)

# Charger les données d'entraînement
from datasets import load_dataset
dataset = load_dataset("json", data_files="training_data.jsonl", split="train")

# Arguments d'entraînement
from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    max_seq_length=4096,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        num_train_epochs=3,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        output_dir="outputs",
        optim="adamw_8bit",
        seed=42,
    ),
)

# Entraîner
trainer.train()

# Sauvegarder l'adaptateur LoRA
model.save_pretrained("gemma4-finetuned-lora")
tokenizer.save_pretrained("gemma4-finetuned-lora")

Paramètres clés à ajuster :

• r=16 : Rang LoRA. Commencez à 16, passez à 32 ou 64 si la qualité n'y est pas
• num_train_epochs=3 : Habituellement 2-5 suffit. Surveillez le surapprentissage
• learning_rate=2e-4 : La valeur par défaut fonctionne bien. Baissez à 1e-4 si l'entraînement est instable
• per_device_train_batch_size=2 : Augmentez si vous avez de la marge VRAM

Export vers GGUF

Une fois votre adaptateur entraîné, vous voulez probablement l'exécuter localement avec Ollama. Cela signifie convertir au format GGUF. Pour une analyse détaillée des options de quantification et de leurs compromis, voir notre guide GGUF.

# Fusionner l'adaptateur et exporter en GGUF (quantification Q4_K_M)
model.save_pretrained_gguf(
    "gemma4-finetuned-gguf",
    tokenizer,
    quantization_method="q4_k_m",
)

# Ou exporter à plusieurs niveaux de quantification
for method in ["q4_k_m", "q5_k_m", "q8_0"]:
    model.save_pretrained_gguf(
        f"gemma4-finetuned-{method}",
        tokenizer,
        quantization_method=method,
    )

Déploiement avec Ollama

Créez un Modelfile pour intégrer votre modèle fine-tuné dans Ollama :

# Modelfile
FROM ./gemma4-finetuned-gguf/gemma4-finetuned-q4_k_m.gguf

PARAMETER temperature 0.7
PARAMETER top_p 0.9

SYSTEM "Tu es un assistant serviable fine-tuné pour le support client."

Puis construisez et exécutez :

# Créer le modèle personnalisé
ollama create my-gemma4 -f Modelfile

# Le tester
ollama run my-gemma4 "Quelle est votre politique de retour ?"

# Vérifier qu'il est listé
ollama list

Votre modèle fine-tuné tourne maintenant exactement comme n'importe quel autre modèle Ollama. Vous pouvez l'utiliser avec l'API Ollama, construire des applications dessus ou le partager avec votre équipe.

Problèmes courants et solutions

Mémoire insuffisante pendant l'entraînement : Baissez per_device_train_batch_size à 1, activez gradient_checkpointing, ou passez à un modèle de base plus petit.

Le modèle produit du charabia après le fine-tuning : Vos données ont probablement des problèmes de formatage, ou vous avez entraîné trop longtemps. Réduisez les époques et validez votre JSONL.

L'export GGUF échoue : Assurez-vous d'avoir assez d'espace disque (3-5x la taille du modèle pendant la conversion) et que votre version d'Unsloth est à jour.

La perte d'entraînement ne diminue pas : Le taux d'apprentissage est peut-être trop bas. Essayez 5e-4. Vérifiez aussi que vos données ont vraiment les patterns que vous voulez que le modèle apprenne.

Prochaines étapes

• Explorez les tailles de modèle Gemma 4 pour choisir le meilleur modèle de base pour le fine-tuning
• Mettez en place un pipeline de déploiement approprié pour votre modèle fine-tuné
• Apprenez la sortie JSON structurée pour combiner fine-tuning et formats de sortie fiables
• Consultez les exigences matérielles pour planifier votre configuration d'entraînement