Chapitre 3 : Aperçu des méthodes PEFT
Explication de toutes les principales méthodes de paramètre efficace
Ce chapitre fournit un aperçu complet de toutes les principales méthodes PEFT, vous aidant à choisir la bonne pour votre cas d'utilisation.
Taxonomie des méthodes PEFT
1. LoRA (Adaptation de faible rang)
Comment ça fonctionne
LoRA ajoute des matrices de décomposition de faible rang entraînables aux côtés des poids gelés.
Original: h = Wx
LoRA: h = Wx + BAx
Où :
- W est gelé (d × d)
- B est entraînable (d × r)
- A est entraînable (r × d)
- r est beaucoup plus petit que d (faible rang, par exemple, 8-64)
Représentation visuelle
Configuration
from peft import LoraConfig
lora_config = LoraConfig(
r=16, # Rang (capacité)
lora_alpha=32, # Facteur de mise à l'échelle
target_modules=[ # Où appliquer
"q_proj",
"k_proj",
"v_proj",
"o_proj",
"gate_proj",
"up_proj",
"down_proj",
],
lora_dropout=0.05, # Régularisation
bias="none", # Ne pas entraîner les biais
task_type="CAUSAL_LM",
)
Avantages et inconvénients
| Avantages | Inconvénients |
|---|---|
| Très efficace | Nécessite un ajustement des hyperparamètres |
| Bien compris | Sélection du rang importante |
| Largement pris en charge | Petit surcoût d'inférence |
| Peut être fusionné | — |
2. QLoRA (LoRA quantifié)
Comment ça fonctionne
Combine la quantification en 4 bits avec LoRA pour une efficacité extrême.
1. Charger le modèle de base en 4 bits (format NF4)
2. Ajouter des adaptateurs LoRA en fp16/bf16
3. Entraîner uniquement les paramètres LoRA
4. Les gradients traversent les poids déquantifiés
Configuration
from transformers import BitsAndBytesConfig
from peft import LoraConfig
# Configuration de quantification
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True, # Économies supplémentaires
)
# Charger le modèle quantifié
model = AutoModelForCausalLM.from_pretrained(
model_name,
quantization_config=bnb_config,
)
# Appliquer LoRA par-dessus
lora_config = LoraConfig(r=16, lora_alpha=32, ...)
model = get_peft_model(model, lora_config)
Comparaison de la mémoire
| Modèle | LoRA | QLoRA | Économies |
|---|---|---|---|
| 7B | ~14GB | ~6GB | 57% |
| 13B | ~26GB | ~10GB | 62% |
| 70B | ~140GB | ~48GB | 66% |
3. Prefix Tuning
Comment ça fonctionne
Ajoute des "jetons virtuels" entraînables en tant que préfixes aux états de clé et de valeur dans les couches d'attention.
Attention normale : Attention(Q, K, V)
Prefix tuning : Attention(Q, [P_K; K], [P_V; V])
Où P_K, P_V sont des préfixes d'embeddings appris
Configuration
from peft import PrefixTuningConfig
prefix_config = PrefixTuningConfig(
task_type="CAUSAL_LM",
num_virtual_tokens=20, # Nombre de jetons de préfixe
prefix_projection=True, # Utiliser MLP pour projeter
)
Cas d'utilisation
- Conditionnement spécifique à la tâche
- Lorsque vous ne pouvez pas modifier les poids du modèle
- Optimisation continue du prompt
4. Prompt Tuning
Comment ça fonctionne
Apprend des embeddings continus préfixés à la séquence d'entrée.
Normal : embed("Qu'est-ce que l'IA ?")
Prompt Tuning : [prompts appris] + embed("Qu'est-ce que l'IA ?")
Configuration
from peft import PromptTuningConfig
prompt_config = PromptTuningConfig(
task_type="CAUSAL_LM",
num_virtual_tokens=8,
prompt_tuning_init="TEXT", # Initialiser à partir du texte
prompt_tuning_init_text="Classifiez ce qui suit :",
)
Caractéristiques
- Moins de paramètres entraînables
- Fonctionne bien pour la classification
- Moins flexible que LoRA
- Aucune modification des internes du modèle
5. IA3 (Adaptateur infusé par l'inhibition et l'amplification des activations internes)
Comment ça fonctionne
Apprend à redimensionner les activations plutôt qu'à ajouter de nouveaux poids.
Original : h = activation(Wx)
IA3 : h = activation(W(l_v ⊙ x)) * l_k
Où l_v, l_k sont des vecteurs de mise à l'échelle appris
Configuration
from peft import IA3Config
ia3_config = IA3Config(
task_type="CAUSAL_LM",
target_modules=["k_proj", "v_proj", "down_proj"],
feedforward_modules=["down_proj"],
)
Caractéristiques
- Encore moins de paramètres que LoRA
- Surcoût computationnel minimal
- Bon pour certaines tâches, moins polyvalent
- Adoption en phase de recherche
6. AdaLoRA (LoRA adaptatif)
Comment ça fonctionne
Alloue dynamiquement le rang à différentes matrices de poids en fonction de l'importance.
Au lieu de : rang fixe r pour toutes les couches
AdaLoRA : rang_i basé sur le score d'importance
Couches importantes → rang plus élevé
Moins important → rang plus bas
Configuration
from peft import AdaLoraConfig
adalora_config = AdaLoraConfig(
init_r=12, # Rang initial
target_r=4, # Rang moyen cible
tinit=200, # Étapes de réchauffement
tfinal=1000, # Quand arrêter l'adaptation
deltaT=10, # Fréquence de mise à jour
beta1=0.85,
beta2=0.85,
)
Quand l'utiliser
- Lorsque vous n'êtes pas sûr de la sélection du rang
- Pour une allocation optimale des paramètres
- Lorsque vous êtes prêt à échanger la complexité pour l'efficacité
Comparaison des méthodes
Paramètres et mémoire
| Méthode | Paramètres | Mémoire | Qualité |
|---|---|---|---|
| LoRA | ~0.1-1% | Faible | ⭐⭐⭐⭐⭐ |
| QLoRA | ~0.1-1% | Très faible | ⭐⭐⭐⭐ |
| Préfixe | ~0.1% | Très faible | ⭐⭐⭐ |
| Prompt | ~0.01% | Très faible | ⭐⭐⭐ |
| IA3 | ~0.01% | Très faible | ⭐⭐⭐ |
| AdaLoRA | Variable | Faible | ⭐⭐⭐⭐ |
Recommandations d'utilisation
| Cas d'utilisation | Méthode recommandée |
|---|---|
| Ajustement général | LoRA |
| Mémoire limitée | QLoRA |
| Tâches similaires multiples | Prompt Tuning |
| Conditionnement de la tâche | Prefix Tuning |
| Paramètres minimaux | IA3 |
| Efficacité optimale | AdaLoRA |
Combinaison de méthodes
LoRA + Quantification
# Combinaison la plus courante
bnb_config = BitsAndBytesConfig(load_in_4bit=True, ...)
model = load_model(quantization_config=bnb_config)
model = get_peft_model(model, lora_config)
Multiples adaptateurs LoRA
# Entraîner différents adaptateurs
model.add_adapter("task_a", lora_config_a)
model.add_adapter("task_b", lora_config_b)
# Basculer entre eux
model.set_adapter("task_a")
# ou
model.set_adapter("task_b")
Choisir la bonne méthode
Points clés à retenir
✅ LoRA est la méthode PEFT la plus polyvalente et la plus utilisée
✅ QLoRA ajoute la quantification pour une efficacité mémoire extrême
✅ Le tuning de prompt/préfixe fonctionne sans modifier les poids du modèle
✅ IA3 offre des paramètres minimaux mais moins de flexibilité
✅ Choisissez en fonction des contraintes de mémoire et des exigences de qualité
✅ Les méthodes peuvent être combinées (par exemple, QLoRA = Quantification + LoRA)
Prochaines étapes
Testez vos connaissances avec le Quiz du Module 3, puis plongez profondément dans LoRA dans Module 4 : Exploration approfondie de LoRA.
Vérification rapide
Avant de continuer, assurez-vous de pouvoir répondre :
- Quelle est la principale différence entre LoRA et QLoRA ?
- Comment fonctionne conceptuellement le Prefix Tuning ?
- Quelle méthode PEFT utilise le moins de paramètres ?