Chapitre 3 : Paysage du Fine-Tuning
Aperçu des méthodes, outils et exigences
Le paysage du fine-tuning a évolué rapidement, offrant de multiples approches adaptées à différents besoins et ressources. Ce chapitre fournit un aperçu complet pour vous aider à naviguer parmi vos options.
Aperçu des méthodes de Fine-Tuning
Comparaison des méthodes
| Méthode | Paramètres Entraînés | Utilisation de la Mémoire | Qualité | Idéal Pour |
|---|---|---|---|---|
| Full Fine-Tuning | 100% | Très élevée | La plus élevée | Personnalisation maximale |
| LoRA | ~0.1-1% | Moyenne | Élevée | Fine-tuning général |
| QLoRA | ~0.1-1% | Faible | Élevée | GPUs grand public |
| Prefix Tuning | ~0.1% | Faible | Bonne | Tâches spécifiques |
| IA3 | ~0.01% | Très faible | Bonne | Changements minimaux |
Full Fine-Tuning
Ce que c'est
Mise à jour de tous les paramètres du modèle pendant l'entraînement.
Avantages
- Flexibilité et personnalisation maximales
- Peut obtenir les meilleurs résultats pour des tâches complexes
- Contrôle total sur le comportement du modèle
Inconvénients
- Nécessite une mémoire GPU significative (un modèle de 7B nécessite ~28GB+ pour l'entraînement)
- Risque accru d'oubli catastrophique
- Coûteux en termes de calcul
Quand l'utiliser
- Lorsque vous disposez de ressources de calcul suffisantes
- Pour des applications critiques nécessitant une qualité maximale
- Lorsque les méthodes PEFT n'atteignent pas les résultats souhaités
# Full fine-tuning example
from transformers import Trainer, TrainingArguments
training_args = TrainingArguments(
output_dir="./results",
num_train_epochs=3,
per_device_train_batch_size=4,
gradient_accumulation_steps=4,
fp16=True, # Mixed precision to save memory
)
trainer = Trainer(
model=model, # All parameters trainable
args=training_args,
train_dataset=dataset,
)
LoRA (Low-Rank Adaptation)
Ce que c'est
Ajout de petites matrices entraînables aux poids gelés du modèle.
Comment ça fonctionne
Original: W (gelé)
LoRA: W + BA (où B et A sont de petites matrices entraînables)
Paramètres clés
- Rang (r) : Dimensionnalité des matrices de faible rang (par exemple, 8, 16, 32)
- Alpha : Facteur de mise à l'échelle pour les contributions LoRA
- Modules cibles : Couches auxquelles appliquer LoRA (q_proj, v_proj, etc.)
Avantages
- Réduction de mémoire de plus de 90%
- Entraînement rapide
- L'adaptateur peut être échangé ou fusionné
- Pas de perte de qualité pour la plupart des tâches
Inconvénients
- Légèrement inférieur au plafond du full fine-tuning
- Nécessite un ajustement des hyperparamètres (rang, alpha)
from peft import LoraConfig, get_peft_model
lora_config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["q_proj", "v_proj"],
lora_dropout=0.05,
task_type="CAUSAL_LM",
)
model = get_peft_model(base_model, lora_config)
QLoRA (Quantized LoRA)
Ce que c'est
Combinaison de la quantification en 4 bits avec LoRA pour une efficacité mémoire extrême.
Comment ça fonctionne
- Charger le modèle de base en précision 4 bits
- Ajouter des adaptateurs LoRA en précision plus élevée
- Entraîner uniquement les paramètres LoRA
Comparaison de la mémoire
| Taille du modèle | Full FT | LoRA | QLoRA |
|---|---|---|---|
| 7B | ~28GB | ~14GB | ~6GB |
| 13B | ~52GB | ~26GB | ~10GB |
| 70B | ~280GB | ~140GB | ~48GB |
Avantages
- Entraîner des modèles de 70B sur des GPUs grand public
- Perte de qualité minimale par rapport à LoRA
- Très rentable
Inconvénients
- Entraînement légèrement plus lent
- Nécessite la bibliothèque bitsandbytes
- Quelques artefacts de quantification possibles
from transformers import BitsAndBytesConfig
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
)
model = AutoModelForCausalLM.from_pretrained(
"model_name",
quantization_config=bnb_config,
)
Méthodes d'alignement
RLHF (Reinforcement Learning from Human Feedback)
- Entraîne un modèle de récompense à partir des préférences humaines
- Utilise RL (PPO) pour optimiser le modèle de langage
- Complexe mais puissant
DPO (Direct Preference Optimization)
- Simplifie RLHF en supprimant le modèle de récompense
- Optimise directement sur les paires de préférences
- Beaucoup plus simple à implémenter
ORPO (Odds Ratio Preference Optimization)
- Combine SFT et alignement en une seule étape
- Encore plus simple que DPO
- Nouveaux résultats prometteurs
# DPO example with TRL
from trl import DPOTrainer
trainer = DPOTrainer(
model=model,
ref_model=reference_model,
train_dataset=preference_dataset,
beta=0.1, # KL penalty weight
)
Écosystème d'outils
Pile Hugging Face
| Outil | Objectif |
|---|---|
| transformers | Chargement de modèles, tokenisation, entraînement |
| peft | Fine-tuning efficace en paramètres |
| trl | Entraîneurs SFT, DPO, RLHF |
| datasets | Chargement et traitement de jeux de données |
| accelerate | Entraînement distribué |
| bitsandbytes | Quantification |
Cadres alternatifs
| Outil | Force | Cas d'utilisation |
|---|---|---|
| Axolotl | Configuration facile | Expériences rapides |
| LLaMA-Factory | Interface unifiée | Méthodes multiples |
| Unsloth | 2x vitesse, moins de mémoire | Itération rapide |
Exigences de calcul
Directives de mémoire GPU
Mémoire nécessaire ≈ (Paramètres du modèle × Octets de précision × Multiplicateur)
Où Multiplicateur :
- Inférence : 1x
- Entraînement LoRA : 2-3x
- Full Fine-Tuning : 4-6x
GPUs recommandés
| Budget | GPU | VRAM | Idéal Pour |
|---|---|---|---|
| Gratuit | Colab T4 | 15GB | QLoRA sur 7B |
| $ | RTX 3090/4090 | 24GB | QLoRA sur 13B |
| $$ | A100-40GB | 40GB | LoRA sur 70B |
| $$$ | A100-80GB | 80GB | Full FT sur 13B |
| $$$$ | H100 | 80GB | Full FT sur 70B |
Estimations du temps d'entraînement
| Modèle | Méthode | GPU | Temps pour 1K exemples |
|---|---|---|---|
| 7B | QLoRA | A100-40GB | ~30 min |
| 7B | LoRA | A100-40GB | ~20 min |
| 7B | Full FT | A100-80GB | ~45 min |
| 70B | QLoRA | A100-80GB | ~3 heures |
Choisir votre chemin
Matrice de décision
Recommandations par scénario
| Scénario | Méthode recommandée |
|---|---|
| Apprentissage/Expérimentation | QLoRA sur Colab |
| Production (sensible aux coûts) | QLoRA sur GPU infonuagique |
| Production (qualité critique) | LoRA ou Full FT |
| Recherche | Full FT avec checkpoints |
| Itération rapide | Unsloth + QLoRA |
Le cours à venir
Dans les modules suivants, nous explorerons en profondeur chaque méthode :
| Module | Focus |
|---|---|
| Module 2 | Détails du Full Fine-Tuning |
| Module 3 | Concepts PEFT |
| Module 4 | Exploration approfondie de LoRA |
| Module 5 | QLoRA et quantification |
| Module 6 | Préparation des données |
| Module 7 | Entraînement avec Hugging Face |
| Module 8 | Techniques avancées (DPO, ORPO) |
| Module 9 | Évaluation et fusion |
| Module 10 | Déploiement en production |
Points clés à retenir
✅ Plusieurs méthodes de fine-tuning existent pour différents niveaux de ressources
✅ Les méthodes PEFT (LoRA, QLoRA) rendent le fine-tuning accessible sur du matériel grand public
✅ L'écosystème Hugging Face fournit tous les outils nécessaires
✅ Le choix de la méthode dépend du budget de calcul et des exigences de qualité
✅ Commencez avec QLoRA pour l'apprentissage, évoluez selon les besoins
Prochaines étapes
Testez vos connaissances avec le Quiz du Module 1, puis continuez vers Module 2 : Full Fine-Tuning.
Vérification rapide
Avant de continuer, assurez-vous de pouvoir répondre :
- Quelle est la principale différence entre LoRA et QLoRA ?
- Combien de mémoire auriez-vous besoin pour QLoRA un modèle de 7B ?
- Quelle est la différence entre DPO et RLHF ?