LoRA : apprendre une correction plutôt que réécrire la matrice

Rang, nombre de paramètres et initialisation : dériver le mécanisme de LoRA avec un exemple numérique et ses limites.

Une matrice de $4096\times4096$ contient plus de seize millions de coefficients. Si l'on souhaite adapter un réseau à une tâche étroite, faut-il vraiment les ajuster tous ? LoRA part d'une hypothèse plus modeste : la correction utile peut parfois être décrite dans un espace de dimension bien plus faible que la matrice initiale.

Ce point est facile à manquer. LoRA ne prétend pas que toute la connaissance du modèle tient dans une petite matrice. Les poids préentraînés restent présents. On leur ajoute une correction paramétrée autrement, ce qui réduit les paramètres à entraîner et les états d'optimiseur associés.

Un détour par une matrice de rang un

Prenons un vecteur colonne $b$ et un vecteur ligne $a$ :

b=\begin{pmatrix}1\\2\\-1\end{pmatrix},\qquad a=\begin{pmatrix}3&0&4\end{pmatrix}

Leur produit extérieur donne :

ba= \begin{pmatrix} 3&0&4\\ 6&0&8\\ -3&0&-4 \end{pmatrix}

Toutes les colonnes sont des multiples de $b$ . Le rang vaut un. Neuf nombres ont été produits à partir de six, mais la matrice obtenue ne peut pas être quelconque. En particulier, deux colonnes non nulles ne peuvent pas pointer dans deux directions indépendantes. L'économie vient d'une contrainte sur les corrections représentables.

Cette contrainte peut être acceptable si les changements nécessaires sont fortement corrélés. Elle peut être trop forte dans le cas contraire. Augmenter le rang élargit l'espace des corrections, mais augmente aussi le nombre de paramètres et ne garantit pas une meilleure généralisation.

Le calcul de LoRA

Pour une couche $y=W_0x$ , LoRA gèle $W_0$ et apprend deux matrices $A$ et $B$ :

y=W_0x+\frac{\alpha}{r}BAx

Si $W_0$ a $d_{\mathrm{out}}$ lignes et $d_{\mathrm{in}}$ colonnes, alors $A$ a la forme $r\times d_{\mathrm{in}}$ et $B$ la forme $d_{\mathrm{out}}\times r$ . Le paramètre $r$ est le rang maximal de la correction ; $\alpha/r$ contrôle son échelle dans la formulation présentée par Hu et ses coauteurs.

Pour $d_{\mathrm{in}}=d_{\mathrm{out}}=4096$ et $r=8$ , on entraîne :

N_{\mathrm{LoRA}}=r(d_{\mathrm{in}}+d_{\mathrm{out}}) =65\,536

La matrice complète contient $16\,777\,216$ coefficients : le rapport vaut $256$ . C'est le gain sur les paramètres de cette couche, pas une division par 256 de toute la mémoire GPU. Le modèle gelé, les activations, les autres couches et les buffers doivent toujours être stockés selon l'implémentation.

Le chemin principal garde les poids préentraînés. La correction passe par un espace de dimension r. Les deux sorties sont additionnées.

Pourquoi ne pas tout initialiser à zéro ?

On souhaite généralement que l'adaptateur ne change pas la sortie au premier instant. Choisir $B=0$ et un petit $A$ aléatoire donne bien $BA=0$ . Mais choisir également $A=0$ est un piège : le gradient de chaque facteur dépend de l'autre.

Si $G$ est le gradient de la perte par rapport à $BA$ , en omettant le facteur d'échelle pour alléger l'écriture :

\frac{\partial L}{\partial B}=GA^\top,\qquad \frac{\partial L}{\partial A}=B^\top G

Avec les deux facteurs nuls, les deux gradients sont nuls. Avec seulement $B$ nul, celui de $B$ peut commencer à bouger grâce à $A$ . Puis celui de $A$ devient à son tour non nul. L'asymétrie de l'initialisation n'est donc pas décorative.

Un exemple qui permet de vérifier les dimensions

Voici une couche illustrative en NumPy. Elle ne fait pas d'entraînement ; elle vérifie que le calcul factorisé et la matrice fusionnée donnent la même sortie, à l'erreur d'arrondi près.

import numpy as np
 
rng = np.random.default_rng(7)
W = rng.normal(size=(12, 16))
A = rng.normal(size=(3, 16))
B = rng.normal(size=(12, 3))
x = rng.normal(size=16)
scale = 6 / 3
 
y_adapter = W @ x + scale * (B @ (A @ x))
y_merged = (W + scale * B @ A) @ x
assert np.allclose(y_adapter, y_merged)

Fusionner la correction peut supprimer le chemin supplémentaire à l'inférence dans ce cas linéaire. Les modèles quantifiés, les adaptateurs multiples et les contraintes de déploiement demandent toutefois une vérification spécifique des formats et de la précision.

Le rang ne choisit pas les données à notre place

Une évaluation sérieuse compare plusieurs rangs à budget et jeu de validation contrôlés. Il faut regarder la tâche visée, mais aussi la perte de capacités utiles ailleurs. Un jeu de validation constitué de quasi-doublons des exemples d'entraînement peut donner une impression de réussite indépendamment du rang choisi.

Le travail scientifique d'origine motive la méthode par une faible dimension intrinsèque de certaines adaptations et la teste sur plusieurs modèles. Ce n'est pas un théorème affirmant que toute tâche admet un rang huit. Pour un projet donné, la courbe de validation et le coût opérationnel tranchent. LoRA fournit une paramétrisation économique ; il ne remplace ni l'objectif d'apprentissage ni le protocole de mesure.