---
title: "Fine-tuning complet : LoRA, QLoRA, Spectrum et alignement"
description: "Guide pratique du fine-tuning de LLM en 2026 : quand fine-tuner,
  LoRA vs QLoRA, Spectrum, préparation de datasets et alignement DPO/ORPO."
date: 2026-06-01T00:00:00.000Z
dateModified: 2026-06-01T00:00:00.000Z
author:
  name: Antoine Michéa
  url: https://sobercloud.fr/
  sameAs:
    - https://altilink.eu/
tags:
  - fine-tuning
  - lora
  - unsloth
  - llm
section: Fine-tuning
canonical: https://sobercloud.fr/decouvertes/fine-tuning-complet/
---

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

```python
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.

```python
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 :

```json
[
  {
    "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 :

```json
[
  {
    "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](/decouvertes/unsloth-en-profondeur/)
- [Quantification avancée](/decouvertes/quantification-avancee/)
- [Décodage accéléré](/decouvertes/decodage-accelere/)