Chapitre 1 : Introduction à PEFT

Rendre le Fine-Tuning Accessible

Le Fine-Tuning Efficace en Paramètres (PEFT) est un ensemble de techniques qui permettent le fine-tuning de grands modèles de langage avec une fraction des ressources nécessaires pour un fine-tuning complet.

---

Le Problème que PEFT Résout

Défis du Fine-Tuning Complet

• Modèle 7B : Nécessite ~60-80GB de VRAM pour un fine-tuning complet
• Modèle 13B : Nécessite ~110-160GB de VRAM
• Modèle 70B : Nécessite ~600GB+ de VRAM

Cela exclut la plupart des praticiens du fine-tuning des modèles plus grands.

---

La Solution PEFT

Idée Clé

La plupart des connaissances du modèle se trouvent dans les poids pré-entraînés. Nous n'avons besoin de faire que de petits ajustements pour de nouvelles tâches.

Comment Ça Fonctionne

Au lieu de mettre à jour tous les paramètres :

# Fine-Tuning Complet (tous les paramètres)
for param in model.parameters():
    param.requires_grad = True  # Tout mettre à jour

# PEFT (seulement les adaptateurs)
for name, param in model.named_parameters():
    param.requires_grad = False  # Geler le modèle de base
    
# Ajouter un petit adaptateur entraînable
adapter = LoRAAdapter(rank=16)  # ~0.1% des paramètres

---

Avantages de PEFT

1. Réduction Dramatique de la Mémoire

Modèle	FT Complet	PEFT	Économies
7B	~80GB	~6-14GB	82-92%
13B	~160GB	~10-26GB	84-94%
70B	~600GB	~48-140GB	77-92%

2. Entraînement Plus Rapide

FT Complet : 100% des paramètres mis à jour par étape
PEFT : Moins de 1% des paramètres mis à jour par étape
→ Calcul de gradient plus rapide
→ Mises à jour de poids plus rapides
→ Bande passante mémoire réduite

3. Pas d'Oubli Catastrophique

# Modèle de base gelé = connaissances originales préservées
base_weights = model.get_base_weights()  # Jamais modifié
adapter_weights = model.get_adapter_weights()  # Seuls ceux-ci changent

4. Multiples Adaptateurs

# Un modèle de base, plusieurs adaptateurs pour différentes tâches
model.load_adapter("service-client")  # Tâche 1
model.load_adapter("génération-de-code")   # Tâche 2
model.load_adapter("résumé")     # Tâche 3
# Il suffit de changer d'adaptateur à l'exécution !

---

Concepts de Base

Paramètres Gelés

Paramètres qui ne reçoivent pas de mises à jour de gradient pendant l'entraînement.

# Geler un paramètre
param.requires_grad = False

# Vérifier les paramètres entraînables
for name, param in model.named_parameters():
    if param.requires_grad:
        print(f"Entraînable : {name}")

Paramètres Entraînables

Seul le petit ensemble de paramètres qui sont mis à jour pendant l'entraînement PEFT.

Adaptateurs

Modules supplémentaires ajoutés au modèle gelé qui contiennent les paramètres entraînables.

---

La Bibliothèque PEFT

La bibliothèque PEFT de Hugging Face fournit un accès unifié à toutes les principales méthodes PEFT :

from peft import (
    LoraConfig,
    PrefixTuningConfig,
    PromptTuningConfig,
    IA3Config,
    AdaLoraConfig,
    get_peft_model,
    PeftModel,
)

# Configurer PEFT
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
)

# Appliquer au modèle
model = get_peft_model(base_model, peft_config)

# Vérifier les paramètres entraînables
model.print_trainable_parameters()
# Sortie : trainable params: 4,194,304 || all params: 6,742,609,920 || trainable%: 0.0622

Fonctions Clés

Fonction	But
get_peft_model()	Envelopper le modèle de base avec PEFT
print_trainable_parameters()	Montrer le nombre entraînable
save_pretrained()	Sauvegarder uniquement l'adaptateur
merge_and_unload()	Fusionner l'adaptateur dans la base
load_adapter()	Charger un adaptateur sauvegardé

---

Comparaison des Paramètres

from transformers import AutoModelForCausalLM
from peft import LoraConfig, get_peft_model

# Charger le modèle de base
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")

# Compter les paramètres de base
total_params = sum(p.numel() for p in model.parameters())
print(f"Total parameters: {total_params:,}")  # ~8,000,000,000

# Appliquer LoRA
lora_config = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj", "v_proj"])
model = get_peft_model(model, lora_config)

# Compter les entraînables
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"Trainable: {trainable:,}")  # ~4,000,000
print(f"Percentage: {100 * trainable / total_params:.4f}%")  # ~0.05%

---

Avantages de Stockage

Sauvegarde Uniquement de l'Adaptateur

# Modèle complet : ~15GB (modèle 7B en fp16)
model.save_pretrained("./full-model")

# Adaptateur LoRA uniquement : ~10-50MB
model.save_pretrained("./lora-adapter", save_embedding_layers=False)

Multiples Adaptateurs = Stockage Minimal

Modèle de Base :     15GB (partagé)
Adaptateur A :      20MB (tâche 1)
Adaptateur B :      20MB (tâche 2)
Adaptateur C :      20MB (tâche 3)
Total :          15.06GB pour 3 modèles spécialisés

vs FT Complet :     45GB pour 3 modèles séparés

---

Exemple Rapide

Entraînement PEFT complet en moins de 50 lignes :

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer
from datasets import load_dataset

# Charger le modèle et le tokenizer
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer.pad_token = tokenizer.eos_token

# Configurer LoRA
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    task_type="CAUSAL_LM",
)

# Appliquer PEFT
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# Charger le jeu de données
dataset = load_dataset("databricks/dolly-15k", split="train[:1000]")

# Entraîner
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=512,
)
trainer.train()

# Sauvegarder l'adaptateur
model.save_pretrained("./my-lora-adapter")

---

Points Clés

✅ PEFT entraîne moins de 1% des paramètres tout en maintenant la qualité

✅ Économies de mémoire de 80-95% par rapport au fine-tuning complet

✅ Les poids du modèle de base restent gelés, empêchant l'oubli

✅ Plusieurs adaptateurs peuvent partager un modèle de base

✅ La bibliothèque PEFT offre un accès unifié à toutes les méthodes

✅ Les fichiers d'adaptateurs sont petits (~10-50MB) contre les modèles complets (~15GB+)

---

Prochaines Étapes

Continuez vers Chapitre 2 : PEFT vs Fine-Tuning Complet pour comprendre les compromis en détail.

---

Vérification Rapide

Avant de continuer, assurez-vous de pouvoir répondre :

1. Quel pourcentage de paramètres PEFT entraîne-t-il généralement ?
2. Pourquoi PEFT ne cause-t-il pas d'oubli catastrophique ?
3. Quelle est la fonction principale pour créer un modèle PEFT ?