AmeliorIA

tekio.org

PEFT (LoRA, QLoRA...)

Exemples annotésquestion → réponseModèle de basepoids gelésEntraînementmême boucle que le SFTAdaptateur LoRAmatrices A et B, ~1 %Serviceune base, N adaptateurs1234
  1. Les exemples passent par la même boucle d'entraînement que le fine-tuning supervisé.
  2. Le modèle de base est chargé puis gelé : en bf16 pour LoRA, en 4 bits (NF4) pour QLoRA.
  3. Seules les petites matrices ajoutées à chaque couche linéaire reçoivent les gradients.
  4. L'adaptateur, de quelques dizaines de Mo, est fusionné dans les poids ou chargé à chaud à côté d'autres adaptateurs.

Geler le modèle et n'entraîner qu'un petit module ajouté : 0,01 à 2 % des paramètres, pour une qualité proche du fine-tuning complet.

  • Identifiant : DATA03
  • Catégorie : DATA · Apprendre à partir de données
  • Regroupe : LoRA, QLoRA, DoRA, rsLoRA, PiSSA, LoHa, LoKr, IA³, prompt et prefix tuning
  • Modèles concernés : Tous (couches linéaires) ; variante : diffusion (DreamBooth-LoRA)
  • Calcul : 1 GPU (entraînement)
  • Temps : heures
  • Modèle : poids nécessaires
  • Données : exemples annotés
  • GPU local 12 Go (exemple de code) : ✅ ≤ 3B (LoRA), ≤ 8B (QLoRA)
  • Code : 03-peft/

Principe

Toutes ces méthodes suivent la même recette : mêmes données et même boucle que le SFT (DATA02). Seul change le petit module entraîné, d'où leur regroupement ici. On passe de l'une à l'autre avec --set peft.methode=....

Méthode Ce qui est entraîné Particularité
LoRA Deux petites matrices B·A de rang r ajoutées à chaque couche linéaire : W' = W + (α/r)·B·A Standard de fait. Adaptateur de quelques Mo, fusionnable dans les poids
QLoRA LoRA sur un modèle chargé en 4 bits (NF4) Divise la mémoire par ~4 : un 8B tient sur 12 Go, un 70B sur 1 GPU 80 Go
DoRA LoRA sur la direction des poids, plus une magnitude apprise séparément Souvent un peu meilleur que LoRA à rang égal, un peu plus lent
rsLoRA LoRA avec échelle α/√r Stable quand on monte le rang (64 à 256)
PiSSA LoRA initialisée sur les valeurs singulières principales de W Converge plus vite
LoHa / LoKr Produit de Hadamard ou de Kronecker au lieu de B·A Populaires en diffusion (LyCORIS)
IA³ Vecteurs qui multiplient les activations (clés, valeurs, FFN) ~0,01 % de paramètres, lr élevé
Prompt tuning Embeddings de « tokens virtuels » ajoutés au début du prompt Le plus léger. Efficace surtout sur les gros modèles
Prefix tuning Tokens virtuels injectés dans chaque couche (clés/valeurs) Plus expressif que le prompt tuning

Intérêts pratiques :

  • plusieurs adaptateurs pour un seul modèle de base, chargés à chaud (vLLM --enable-lora, TGI, LoRAX) ;
  • combinaison d'adaptateurs (EDIT08) ;
  • moins d'oubli que le fine-tuning complet (LoRA Learns Less and Forgets Less).

Modèles concernés

Type de modèle Exemples de modèles Applicable Remarques
LLM décodeur (toutes familles HF) Llama 3, Qwen2.5, Mistral 7B, Gemma 2 ✅ cas principal run.py. all-linear cible toutes les couches linéaires, quelle que soit l'architecture
LLM quantifié (bitsandbytes 4/8 bits, GPTQ, AWQ) Qwen2.5-7B-Instruct-AWQ, Llama-3.1-8B en NF4 ✅ QLoRA. Entraîner une LoRA sur un modèle GPTQ/AWQ est aussi possible
Encodeur / seq2seq / Whisper BERT, T5, Whisper ✅ Même API, task_type="SEQ_CLS", "SEQ_2_SEQ_LM"...
Vision / multimodal ViT, CLIP, Qwen2.5-VL, LLaVA ✅ Cibler les couches linéaires de la tour vision et/ou du LLM
Diffusion Stable Diffusion, SDXL, Flux ✅ très courant variantes/diffusion-lora : apprendre un sujet ou un style en quelques images
Tout nn.Module PyTorch personnalisé — ✅ PEFT accepte des modèles quelconques via target_modules
Modèle fermé via API GPT-4o, Claude, Gemini ⚠️ Certains fournisseurs font du LoRA côté serveur (fine-tuning « as a service »)

Quand l'utiliser

  • ✅ Par défaut dès qu'on veut fine-tuner : c'est moins cher, plus rapide et le résultat se déploie facilement.
  • ✅ QLoRA dès que le modèle en bf16 ne tient pas en mémoire.
  • ✅ Beaucoup de variantes spécialisées d'un même modèle (un adaptateur par client, par tâche).
  • ⚠️ Pour injecter beaucoup de connaissances nouvelles ou faire un gros changement de distribution, le fine-tuning complet reste supérieur. Une LoRA de rang élevé (128 à 256) sur toutes les couches s'en rapproche.

Pièges

  • lr : un lr de fine-tuning complet (1e-5) fait stagner la LoRA ; un lr de LoRA (2e-4) fait diverger le fine-tuning complet.
  • Modules ciblés : une LoRA sur l'attention seule est nettement moins bonne que all-linear.
  • QLoRA et fusion : ne pas fusionner dans le modèle 4 bits. Recharger la base en bf16, fusionner, puis requantifier si besoin.
  • Prompt et prefix tuning : faibles sur les petits modèles (< 1B). C'est attendu, pas un bug.
  • Prefix tuning et gradient checkpointing : incompatibles (le checkpointing retire le cache où sont injectés les préfixes). run.py le désactive pour prefix_tuning.
  • Diffusion : trop de pas donne un surapprentissage (toutes les images se ressemblent). Régulariser avec des « images de classe » (prior preservation).

Références

Dans le dépôt

Exemple, résultats mesurés et commandes : PEFT (LoRA, QLoRA...) : exemple de code.