Le fine-tuning apprend à un modèle ouvert votre format, votre ton ou votre domaine à partir de vos propres exemples. Avec QLoRA — le modèle de base chargé en 4 bits, plus de petits « adaptateurs » entraînables —, un modèle de 7 ou 8 milliards de paramètres comme Qwen2.5 7B, Llama 3.1 8B ou Mistral 7B tient sur une seule carte de 24 Go. Voici la recette complète sur une RTX 4090 ou une RTX 3090 louée.

Ce qu’il vous faut

  • Une carte de 24 Go. Une RTX 4090 coûte environ 0,49 $US de l’heure ici ; une RTX 3090, à environ 0,31 $US, est plus lente mais fait tourner le même script.
  • L’environnement PyTorch 2.4 + JupyterLab, choisi au paiement sur la place de marché.
  • Vos exemples au format JSON Lines — une conversation par ligne, dans le format de chat sur lequel la plupart des modèles sont entraînés :
{"messages": [{"role": "user", "content": "Résume ce ticket : ..."}, {"role": "assistant", "content": "..."}]}

Quelques centaines à quelques milliers de bons exemples suffisent souvent ; la qualité compte plus que la quantité.

1. Envoyer vos données

Placez train.jsonl dans /workspace : déposez-le dans le panneau Fichiers de la page de location, collez-y un lien pour que la machine le télécharge, ou copiez-le avec scp ou rsync, qui gèrent toutes les tailles — voir Se connecter en SSH à un GPU loué.

2. Installer les bibliothèques

Ouvrez JupyterLab depuis Accès web sur la page de location, ouvrez un terminal et lancez :

pip install transformers peft trl bitsandbytes datasets accelerate

3. Entraîner

Collez ceci dans un notebook et exécutez-le :

import torch
from datasets import load_dataset
from peft import LoraConfig
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from trl import SFTConfig, SFTTrainer

base = "Qwen/Qwen2.5-7B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
    base,
    quantization_config=BitsAndBytesConfig(
        load_in_4bit=True, bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.bfloat16),
    device_map="auto",
)
data = load_dataset("json", data_files="/workspace/train.jsonl", split="train")

trainer = SFTTrainer(
    model=model,
    train_dataset=data,
    peft_config=LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05,
                           target_modules="all-linear", task_type="CAUSAL_LM"),
    args=SFTConfig(output_dir="/workspace/run", num_train_epochs=2,
                   per_device_train_batch_size=2, gradient_accumulation_steps=8,
                   learning_rate=2e-4, bf16=True, logging_steps=10,
                   gradient_checkpointing=True),
)
trainer.train()
trainer.save_model("/workspace/my-adapter")

Le premier lancement télécharge le modèle de base, environ 15 Go. L’entraînement affiche ensuite sa perte (loss) toutes les dix étapes ; une perte qui baisse puis se stabilise, c’est ce que vous voulez.

Combien de temps, et combien ça coûte

Pour quelques milliers d’exemples de longueur ordinaire, comptez de moins d’une heure à quelques heures sur une RTX 4090, selon la longueur des exemples et le nombre d’époques ; une RTX 3090 prend plus de temps. Deux heures sur une RTX 4090 coûtent environ 2 × 0,49 $US. Si le temps manque, prolongez la location depuis sa page.

4. Garder l’adaptateur

/workspace/my-adapter ne contient que l’adaptateur — de quelques dizaines à quelques centaines de mégaoctets, pas un modèle entier. Téléchargez-le depuis le panneau Fichiers, copiez-le avec scp, ou enregistrez-le dans Mon Drive (2 Go qui restent sur votre compte) avant la fin de la location, car /workspace est alors supprimé. L’enregistrement automatique dans Mon Drive, sur la page de location, est un bon filet de sécurité.

Pour vous en servir, chargez le modèle de base et l’adaptateur avec PEFT (PeftModel.from_pretrained), fusionnez-les avec merge_and_unload(), ou servez l’adaptateur avec vLLM, qui sait charger directement les adaptateurs LoRA.

Des modèles plus gros

  • 13 à 14 milliards : QLoRA demande environ 18 à 24 Go, c’est juste sur une carte de 24 Go ; une RTX 6000 Ada ou une A6000 de 48 Go, pour environ 0,56 $US de l’heure, est confortable.
  • 70 milliards : QLoRA demande environ 48 à 80 Go ; une A100 80 Go coûte environ 1,05 $US de l’heure.
  • Plusieurs GPU : louez une machine à plusieurs cartes, ou un cluster — plusieurs machines louées ensemble, avec un réseau privé entre elles. Chaque machine connaît son rang : la même commande torchrun lance le travail sur toutes. Ce réseau passe par RentGPUPower : il convient pour coordonner le travail et échanger des volumes de données modérés, pas pour échanger des gradients à la vitesse d’un datacenter ; pour un gros entraînement, une machine à plusieurs cartes est plus rapide.

La mémoire nécessaire à chaque méthode est détaillée dans De combien de mémoire GPU (VRAM) ai-je besoin ?

Questions fréquentes

Puis-je plutôt fine-tuner Llama 3.1 8B ?

Oui : changez base. Les modèles Llama demandent d’accepter la licence de Meta sur Hugging Face et de vous connecter avec un jeton sur la machine ; utilisez un jeton en lecture seule et supprimez-le ensuite, comme sur tout ordinateur loué. Qwen2.5 se télécharge sans compte.

Et si la location se termine en plein entraînement ?

Prolongez-la depuis sa page avant la fin. Pour les longs entraînements, réglez save_steps dans SFTConfig pour enregistrer plus souvent des points de reprise dans /workspace/run, et copiez-les dans Mon Drive.

QLoRA vaut-il un fine-tuning complet ?

Pour le style et le format, il s’en approche souvent, pour une fraction de la mémoire. Un fine-tuning complet d’un modèle de 7 ou 8 milliards de paramètres demande environ 80 à 120 Go de mémoire GPU.

Une carte de 16 Go suffit-elle ?

Pour un modèle de 7 ou 8 milliards, QLoRA demande environ 10 à 16 Go : une carte de 16 Go peut suffire avec des exemples courts et une taille de lot de 1, mais 24 Go laissent de la marge. Les modèles de 1 à 3 milliards tiennent sur 12 Go.