LoRA expliqué : le fine-tuning de modèles avec des milliards de paramètres sur ton ordinateur portable

Le fine-tuning d’un modèle avec un milliard de paramètres nécessite généralement de modifier des milliards de poids. C’est prohibitivement cher. LoRA (Low-Rank Adaptation) contourne cela en mettant à jour seulement une minuscule fraction du modèle tout en obtenant des résultats comparables.

L’insight est élégant : les mises à jour de poids durant le fine-tuning ont un rang faible. Tu n’as pas besoin de mettre à jour la matrice de poids complète. Tu dois seulement mettre à jour une approximation de rang faible de la mise à jour.

Comment LoRA fonctionne

Au lieu de fine-tuner la matrice de poids complète W, LoRA décompose la mise à jour comme un produit de deux matrices plus petites : ΔW = B × A.

Pour une matrice de poids de forme (d_out × d_in), LoRA introduit :

A : forme (r × d_in), où r est le rang (généralement 8-64)
B : forme (d_out × r)

Pendant la passe forward : output = W × input + (B × A) × input

Tu entraînes seulement A et B, gèle le W original. Le rang r est généralement beaucoup plus petit que d_in et d_out, donc le décompte des paramètres explose vers le bas.

Les chiffres

Pour un modèle 70B avec dimensions cachées 4k :

Fine-tuning complet : 70B paramètres entraînables
LoRA (rang 8) : 70B × (8 / 4000) ≈ 140M paramètres entraînables
LoRA (rang 64) : 70B × (64 / 4000) ≈ 1B paramètres entraînables

Tu entraînes 0,2% du modèle avec LoRA rang-8. Les économies en mémoire et calcul sont massives.

Rang : le principal compromis

Le rang de LoRA est le bouton de réglage. Rang plus élevé = plus d’expressivité mais plus de paramètres.

Rang 8 : Très bon marché, entraînement rapide. Fonctionne pour l’adaptation mineure de domaine. Fine-tuning d’instructions ou de styles spécifiques.

Rang 16-32 : Point doux pour la plupart des applications. Assez d’expressivité pour une adaptation significative sans coût excessif.

Rang 64+ : Approche le coût du fine-tuning complet. Utilise quand le rang mineur n’est pas assez expressif.

En pratique, le rang 16 fonctionne pour 80% des cas d’usage. Le rang 32 fonctionne pour 95%. Les rendements décroissants commencent rapidement.

Pourquoi cela fonctionne

L’hypothèse sous-jacente à LoRA est empiriquement validée : les mises à jour du fine-tuning ont un rang intrinsèque faible. Le modèle n’a pas besoin de changer beaucoup pour s’adapter à de nouveaux domaines ou tâches.

Cela a du sens. Le modèle pré-entraîné code déjà d’énormes quantités de connaissances. S’adapter à un nouveau domaine ne nécessite pas un rewiring en gros, juste des ajustements ciblés.

LoRA capture ces ajustements efficacement.

Implémentation pratique

Utiliser LoRA dans le code est trivial avec la bibliothèque peft :

from peft import LoraConfig, get_peft_model

config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=[“q_proj”, “v_proj”],
lora_dropout=0.05,
bias=”none”
)

model = get_peft_model(model, config)

Entraîne le modèle normalement. Seules les matrices A et B obtiennent les mises à jour. À l’inférence, fusionne les poids ou garde-les séparés pour changer facilement entre les adaptateurs.

L’avantage pratique

Un modèle 70B avec LoRA peut fine-tuner sur un GPU grand public. Le stockage est minimal (LoRA rang-8 pour 70B est ~140 Mo). Tu peux charger plusieurs adaptateurs et basculer entre eux à l’exécution.

Cela déverrouille un nouveau modèle de développement : modèles de base + de nombreux adaptateurs spécialisés. Pas besoin d’entraîner 10 modèles pleins différents. Entraîne 10 adaptateurs LoRA à la place, au coût 1%.

Laeka Research — laeka.org