Fine-tuning complet : LoRA, QLoRA, Spectrum et alignement

Le fine-tuning adapte un modèle pré-entraîné à une tâche spécifique. Grâce à LoRA et QLoRA, on entraîne aujourd’hui des modèles de plusieurs milliards de paramètres sur du matériel grand public — et même un Qwen3.6-27B dense tient sur un seul GPU en QLoRA.

Quand fine-tuner ?

Le fine-tuning n’est pas toujours la bonne réponse. Avant de lancer un entraînement, déroulez cet arbre de décision :

• Besoin d’accéder à des données spécifiques ? → privilégiez le RAG (Retrieval-Augmented Generation).
• Besoin d’un style ou d’un format de réponse particulier ? → essayez d’abord le prompt engineering ; si insuffisant, passez au fine-tuning.
• Besoin de connaissances absentes du modèle ? → factuelles : RAG ; comportementales : fine-tuning.
• Latence minimale critique ? → fine-tuning (évite d’injecter un long contexte RAG à chaque requête).

Full fine-tuning vs PEFT

Le full fine-tuning met à jour tous les paramètres : meilleure qualité, mais coût matériel énorme. Les méthodes PEFT (Parameter-Efficient Fine-Tuning) n’entraînent qu’une fraction des poids.

Méthode	Paramètres entraînés	VRAM (~7B)	Qualité
Full Fine-Tuning	100 %	~60 Go	★★★★★
LoRA	~0,1–1 %	~16 Go	★★★★
QLoRA	~0,1–1 %	~6–8 Go	★★★★
Spectrum	25–45 % (sélectif)	~24 Go	★★★★★

LoRA — Low-Rank Adaptation

LoRA ajoute de petites matrices « adaptateur » à côté des poids gelés. Au lieu de modifier W directement, on apprend ΔW = BA, où B et A sont de faible rang.

W' = W + ΔW = W + BA
avec A ∈ ℝ^(d×r), B ∈ ℝ^(r×k), r << min(d,k)

Paramètres clés

• rank (r) : dimension des matrices de faible rang. Plus élevé = plus expressif mais plus de paramètres. Typique : 8–64.
• alpha : facteur de scaling. Souvent alpha = rank ou alpha = 2 × rank.
• target_modules : couches à adapter (q_proj, v_proj, etc.). Recommandé : toutes les couches linéaires.
• dropout : régularisation. Typique : 0,05–0,1.

from peft import LoraConfig, get_peft_model

lora_config = LoraConfig(
    r=16,                    # Rang des matrices
    lora_alpha=32,           # Facteur de scaling
    target_modules=[         # Couches à adapter
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(base_model, lora_config)
print(f"Paramètres entraînables: {model.num_parameters(only_trainable=True):,}")

QLoRA — LoRA + quantification

QLoRA combine LoRA avec un modèle de base quantifié en 4-bit (NF4). La VRAM nécessaire chute drastiquement tout en gardant une qualité proche du full fine-tuning.

Innovations de QLoRA

• NF4 (NormalFloat 4-bit) : type de données optimisé pour les poids de réseaux de neurones.
• Double Quantization : quantifie aussi les constantes de quantification (−0,4 bit).
• Paged Optimizers : évitent les pics mémoire lors du backward pass.

from transformers import BitsAndBytesConfig
import torch

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",            # NormalFloat 4-bit
    bnb_4bit_use_double_quant=True,       # Double quantification
    bnb_4bit_compute_dtype=torch.bfloat16 # Calculs en BF16
)

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3.6-27B-Instruct",
    quantization_config=bnb_config,
    device_map="auto"
)

# Puis appliquer LoRA par-dessus
model = get_peft_model(model, lora_config)

LoRA ou QLoRA ? Si le modèle tient confortablement en mémoire, préférez LoRA : l’entraînement est ~33 % plus rapide. Si la VRAM est limitée, QLoRA économise ~33 % de mémoire au prix de ~39 % de temps en plus.

Spectrum — sélection intelligente des couches

Spectrum utilise la théorie des matrices aléatoires pour identifier les couches les plus « informatives » selon leur ratio signal/bruit (SNR), et n’entraîne que celles-ci.

1. Analyse SNR de chaque couche via la distribution de Marchenko-Pastur.
2. Catégorisation en groupes SNR élevé / faible.
3. Entraînement sélectif des couches à haut SNR (top 25–45 %).
4. Les couches gelées conservent les connaissances existantes (évite le catastrophic forgetting).

Résultats typiques (Spectrum-25) : −23 % de VRAM, −37 % de temps d’entraînement, qualité équivalente au full fine-tuning.

Préparation du dataset

La qualité du dataset prime sur la quantité : ~1000 exemples soignés suffisent souvent.

Format Alpaca (instruction-following)

Idéal pour les tâches question-réponse simples :

[
  {
    "instruction": "Traduis ce texte en anglais",
    "input": "Bonjour, comment allez-vous ?",
    "output": "Hello, how are you?"
  },
  {
    "instruction": "Résume ce paragraphe en une phrase",
    "input": "Les modèles de langage sont des réseaux...",
    "output": "Les LLM sont des IA générant du texte."
  }
]

Format ShareGPT (conversations)

Pour les chatbots multi-tours :

[
  {
    "conversations": [
      {"from": "human", "value": "Qu'est-ce que le machine learning ?"},
      {"from": "gpt", "value": "Le machine learning est une branche de l'IA..."},
      {"from": "human", "value": "Donne-moi un exemple concret."},
      {"from": "gpt", "value": "Un exemple classique est la détection de spam..."}
    ],
    "system": "Tu es un professeur expert en IA."
  }
]

Alignement : RLHF, DPO, ORPO

Après le SFT (Supervised Fine-Tuning), on peut aligner le modèle sur les préférences humaines.

RLHF (Reinforcement Learning from Human Feedback)

• Méthode originale de ChatGPT / InstructGPT.
• Entraîne un reward model sur les préférences, puis optimise le LLM via PPO contre ce modèle de récompense.
• Coûteux et instable, gourmand en ressources.

DPO (Direct Preference Optimization)

• Élimine le reward model explicite.
• Optimise directement sur les paires (chosen, rejected).
• Plus stable et plus simple que RLHF, mais nécessite un modèle de référence pendant l’entraînement.

ORPO (Odds Ratio Preference Optimization)

• Combine SFT et alignement en une seule étape.
• Pas de modèle de référence.
• Moins coûteux en mémoire et en FLOPs que DPO.
• Résultats compétitifs sur AlpacaEval et MT-Bench.

Méthode	Étapes	Modèle réf.	Coût	Stabilité
RLHF (PPO)	SFT → RM → PPO	Oui	★★★★★	★★
DPO	SFT → DPO	Oui	★★★	★★★★
ORPO	ORPO seul	Non	★★	★★★★

Workflow complet

1. Préparation des données : collecte, nettoyage, formatage (Alpaca / ShareGPT). Viser ~1000+ exemples de haute qualité.
2. Configuration de l’environnement : installation Unsloth / PEFT / TRL, vérification GPU, chargement du modèle en QLoRA.
3. Entraînement SFT : fine-tuning supervisé avec LoRA/QLoRA, monitoring W&B ou TensorBoard.
4. Alignement (optionnel) : DPO ou ORPO si vous disposez de données de préférence.
5. Merge & export : fusion des adaptateurs LoRA avec le modèle de base, export en GGUF pour le déploiement.
6. Évaluation & déploiement : tests sur benchmarks, import dans llama.cpp / Ollama / LM Studio, mise en production.

Outils de fine-tuning

• Unsloth : ~2× plus rapide, jusqu’à 70 % de VRAM en moins, notebooks prêts à l’emploi, export GGUF « UD- ».
• Axolotl : configuration YAML flexible, multi-GPU, nombreuses architectures.
• LLaMA-Factory : interface web, 100+ modèles, export GGUF intégré.
• Hugging Face TRL : bibliothèque officielle pour SFT, DPO, PPO, production-ready.

Chez SoberCloud, nos fine-tunings passent par Unsloth (QLoRA puis export GGUF « UD- »), que nous avons exécutés sur un Strix Halo (128 Gio de mémoire unifiée). Le modèle fusionné est ensuite servi en local. Pour un MoE comme Qwen3.6-35B-A3B (3B actifs par token), la même recette LoRA s’applique — on cible les couches d’attention et les experts partagés.

Pour aller plus loin

• Unsloth en profondeur
• Quantification avancée
• Décodage accéléré