Fine-Tuning et PEFT

L'Essentiel

Ce qu’il faut retenir :

1. Quoi : Le Fine-Tuning est l’entraînement “partie 2” d’un modèle pour le spécialiser (ex: apprendre le Code des Assurances). PEFT (Parameter-Efficient Fine-Tuning) est la version moderne et économique qui ne modifie que 1% du modèle.
2. Pourquoi : Entraîner un modèle de A à Z coûte des millions. Le spécialiser coûte quelques centaines d’euros.
3. Comment : En utilisant LoRA (Low-Rank Adaptation), on ajoute de minuscules modules “additifs” au cerveau du modèle sans toucher aux connaissances d’origine.

Ce que vous saurez dans 3 minutes

• La différence critique entre Full Fine-Tuning (Lourd, Risqué) et PEFT (Léger, Sûr).
• Pourquoi LoRA est devenu le standard de facto de l’industrie.
• Combien ça coûte réellement d’adapter un modèle comme Llama 3 à vos données.

---

1. Comprendre

L’Analogie de l’Étudiant et du Stage

• Pre-Training (Modèle de Fondation) : C’est l’étudiant qui sort de 5 ans d’université. Il a une culture générale immense, il sait lire, écrire, raisonner. (Coût : Millions €).
• Fine-Tuning (Spécialisation) : C’est le stage de 6 mois dans une banque. Il apprend le jargon spécifique, les procédures internes et le ton de l’entreprise. (Coût : Milliers €).

Full Fine-Tuning vs PEFT

Avant 2021, pour spécialiser un modèle, on faisait du Full Fine-Tuning : on mettait à jour tous les neurones (100%).

• Problème 1 (Coût) : Il faut une armée de GPU (HBM saturée).
• Problème 2 (Oubli) : En apprenant la banque, le modèle oublie parfois comment écrire de la poésie (“Catastrophic Forgetting”).

Le PEFT (Parameter-Efficient Fine-Tuning) change la donne. On gèle le modèle (0 modification). On ajoute juste des petites couches “sandwich” par-dessus. On n’entraîne que ces couches ajoutées (< 1% des paramètres).

Focus sur LoRA (Low-Rank Adaptation)

LoRA est la star du PEFT. L’idée mathématique est géniale : les changements nécessaires pour spécialiser un modèle sont “de rang faible” (Low Rank). On peut les compresser dans deux minuscules matrices $A$ et $B$ dont le produit $A \times B$ approxime le changement voulu.

$$W_{finetuned} = W_{base} + (A \times B)$$

---

2. Appliquer

Implémentation avec Hugging Face peft

C’est le standard industriel pour adapter Llama 3, Mistral, ou Gemma.

Code Python (LoRA)

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, TaskType

# 1. Charger le modèle (gelé par défaut si load_in_4bit)
model_id = "meta-llama/Meta-Llama-3-8B"
model = AutoModelForCausalLM.from_pretrained(model_id, load_in_4bit=True)

# 2. Définir la config LoRA
peft_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    r=16,            # Le "Rang". Plus c'est haut, plus c'est intelligent (et lourd). Standard: 8, 16, 32.
    lora_alpha=32,   # Facteur d'échelle. Standard: 2x le rang.
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj"] # On cible les modules d'Attention
)

# 3. Créer le modèle PEFT
model = get_peft_model(model, peft_config)

# Preuve de l'efficacité
model.print_trainable_parameters()
# Output: "trainable params: 4,194,304 || all params: 7,000,000,000 || trainable%: 0.06%"
# -> On entraîne seulement 0.06% du modèle !

Business Case : Coûts

Comparatif réel pour adapter un modèle 70B (ex: Llama-3-70B) sur un corpus juridique.

Méthode	GPU Requis	Temps	Coût Est. (Cloud)	Stockage Résultat
Full FT	8x A100 (80GB)	48h	~1 500 €	140 GB (Nouveau Modèle)
LoRA (PEFT)	1x A100 (80GB)	12h	~50 €	200 MB (Fichier Adapter)

QLoRA : Encore plus loin

QLoRA (Quantized LoRA) combine la quantization 4-bit avec LoRA. Cela permet de fine-tuner un modèle massif (70B) sur une seule carte graphique grand public (RTX 4090) ou un petit GPU cloud (T4). C’est la démocratisation totale.

---

3. Aller plus loin

Quand PEFT ne suffit pas

PEFT est excellent pour :

• Le style (parler comme un pirate).
• Le format (sortir du JSON valide).
• Une base de connaissance légère.

PEFT est moins bon pour :

• Apprendre une langue totalement inconnue (ex: Sumérien ancien).
• Ingérer massivement des faits (mieux vaut utiliser le RAG pour ça).

Architecture Modulaire

L’avenir est aux modèles Multi-LoRA. Vous avez un modèle de base (Llama 3) et vous chargez dynamiquement des “cartouches” (Adapters) selon le besoin :

• L’utilisateur demande du code ? → Charge adapter_python.safetensors
• L’utilisateur demande une recette ? → Charge adapter_cuisine.safetensors

C’est extrêmement efficace car la base reste en mémoire (RAM), on change juste les petits deltas (quelques Mo).

---

Questions Fréquentes

Fine-Tuning ou RAG ?

C’est LE débat classique.

• RAG : Pour donner des connaissances factuelles à jour (ex: Stock, News). C’est comme ouvrir un livre.
• Fine-Tuning : Pour donner un savoir-faire ou un comportement (ex: Parler poliment, raisonner en SQL). C’est comme suivre une formation. Souvent, on combine les deux.

Est-ce que je peux fusionner mon LoRA avec le modèle ?

Oui ! C’est l’opération de “Merge”. merged_model = base_model + adapter. Une fois fusionné, le modèle n’est pas plus lent que l’original. Zéro latence ajoutée.

---

Notions Liées (Spider Web)

• Base : LLM
• Technique Concurrente : RAG
• Optimisation : Quantization

Ressources Externes

• Hugging Face : PEFT Library Documentation
• Papier LoRA : LoRA: Low-Rank Adaptation of Large Language Models