Retour à la bibliothèque
arXiv 2021ICLR 2022Adaptation des modèlesNotes de lecture

LoRA

Un LLM pour un dix-millième

Article original

LoRA: Low-Rank Adaptation of Large Language Models

Auteurs de l’article

Edward J. Hu · Yelong Shen · Phillip Wallis …

Afficher les 8 auteurs

Edward J. Hu · Yelong Shen · Phillip Wallis · Zeyuan Allen-Zhu · Yuanzhi Li · Shean Wang · Lu Wang · Weizhu Chen

Publication
ICLR 2022Conférence
Premier dépôt sur arXiv
arXiv:2106.09685
Citer cet article · BibTeX

La référence correspond à la version liée et cite les auteurs de l’article original.

@misc{modeltuninglora2021,
  title = {{LoRA: Low-Rank Adaptation of Large Language Models}},
  author = {Edward J. Hu and Yelong Shen and Phillip Wallis and Zeyuan Allen-Zhu and Yuanzhi Li and Shean Wang and Lu Wang and Weizhu Chen},
  year = {2021},
  eprint = {2106.09685},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2106.09685}
}
Sur cette page

Il faut bien l’admettre : la plupart d’entre nous ne peuvent pas entraîner un LLM.

Le monde est vaste, mais on compte sur les doigts d’une main les entreprises capables de faire évoluer ces modèles.

Les chercheurs veulent pourtant utiliser ces immenses modèles pour résoudre toutes sortes de problèmes. Trouver une façon efficace de les ajuster est donc devenu essentiel.

Définir le problème

Si vous vouliez aujourd’hui ajuster le modèle entier, les étapes ressembleraient à ceci :

  1. Initialiser le modèle avec ses poids préentraînés Φ0\Phi_0.

  2. Les mettre à jour par optimisation du gradient pour obtenir Φ0+ΔΦ\Phi_0 + \Delta \Phi en maximisant l’objectif du modèle de langage conditionnel :

    max⁡Φ∑(x,y)∈Z∑t=1∣y∣log⁡PΦ(yt∣x,y<t)\max_\Phi \sum_{(x,y) \in Z} \sum_{t=1}^{|y|} \log P_\Phi(y_t | x, y_{<t})

Chaque tâche en aval doit apprendre son propre ensemble de paramètres ΔΦ\Delta \Phi, dont la taille ∣ΔΦ∣|\Delta \Phi| égale celle des paramètres du modèle initial ∣Φ0∣|\Phi_0|. Sur un grand modèle tel que GPT-3, ∣Φ0∣|\Phi_0| compte environ 175 milliards de paramètres (175B). Stocker et déployer plusieurs modèles ajustés devient très difficile.

Dans les travaux antérieurs, l’approche principale était l’Adapter. Nous avons justement lu un article à son sujet :

Mais la recherche ne s’arrête pas là. Voici quelques autres études ; nous y reviendrons peut-être :

Ces méthodes gardent toutefois des limites dans les grands systèmes de production sensibles à la latence : elles ajoutent toujours des paramètres et peuvent perturber un modèle déployé pour profiter du calcul parallèle. Le tableau ci-dessous montre une nette augmentation de la latence quand on ajoute un Adapter à GPT-2 :

Élaguer des couches ou entraîner plusieurs tâches ensemble peut réduire cette latence sans effacer entièrement le surcoût des Adapters. Leur conception limite la dimension du goulot afin de garder moins de 1 % des paramètres du modèle initial.

En théorie, cela ne devrait pas demander beaucoup d’opérations (FLOPs), non ?

Et pourtant, ça ne suffit pas.

Les grands réseaux comptent beaucoup sur le calcul parallèle du matériel pour maintenir une faible latence. L’Adapter doit, lui, être traité de façon séquentielle : à l’inférence en ligne, où le lot contient généralement un seul exemple, cela augmente nettement la latence.

Et si l’on essayait Prefix-Tuning ?

Prefix-Tuning représente une autre stratégie d’adaptation, mais son efficacité en fonction du nombre de paramètres n’évolue pas de façon monotone pendant l’optimisation, ce qui la complique. Il faut aussi réserver une partie de la longueur de séquence au préfixe, laissant moins de place à la tâche en aval.

Cela semble encore pire.

Pour résoudre ces problèmes, les auteurs proposent une factorisation de faible rang : encoder l’incrément de paramètres propre à la tâche ΔΦ\Delta \Phi dans un ensemble plus petit Θ\Theta, tel que

∣Θ∣≪∣Φ0∣|\Theta| \ll |\Phi_0|

L’objectif devient d’optimiser cet ensemble réduit Θ\Theta :

max⁡Θ∑(x,y)∈Z∑t=1∣y∣log⁡PΦ0+ΔΦ(Θ)(yt∣x,y<t)\max_\Theta \sum_{(x,y) \in Z} \sum_{t=1}^{|y|} \log P_{\Phi_0 + \Delta \Phi(\Theta)}(y_t | x, y_{<t})

Résoudre le problème

Avant de regarder la méthode, revenons aux mathématiques du lycée.

Rang, rang plein et rang faible

En mathématiques, une matrice (Matrix) est un tableau de nombres. Par exemple :

A=[123456789]\mathbf{A} = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix}

Les matrices jouent un rôle important dans le traitement des données et le calcul. Leur rang (Rank) est l’une de leurs propriétés essentielles.

  1. Qu’est-ce que le rang (Rank) ?

    Le rang exprime l’indépendance des vecteurs lignes ou colonnes d’une matrice.

    L’indépendance signifie qu’une ligne ou une colonne ne peut pas s’écrire comme combinaison linéaire des autres. Si certaines lignes ou colonnes résultent des autres, elles ne sont pas indépendantes. Autrement dit, le rang nous dit combien de morceaux d’« information indépendante utile » contient la matrice.

    Si AA est une matrice de taille m×nm \times n, avec mm lignes et nn colonnes, son rang est le nombre maximal de lignes ou colonnes indépendantes. Il ne peut dépasser ni le nombre de lignes mm ni celui de colonnes nn :

    rank(A)≤min⁡(m,n)\text{rank}(A) \leq \min(m, n)

  1. Matrice de rang plein (Full-rank)

    Une matrice est de rang plein si son rang égale le plus petit de ses nombres de lignes et de colonnes, soit rank(A)=min⁡(m,n)\text{rank}(A) = \min(m, n).

    Les vecteurs du groupe le moins nombreux, lignes ou colonnes, sont alors tous linéairement indépendants, comme ici :

    I=[1001]\mathbf{I} = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}

    Cette matrice de taille 2×22 \times 2 a deux vecteurs lignes indépendants. Son rang est donc 2, égal à min⁡(2,2)\min(2, 2) : elle est de rang plein. Chaque ligne ou colonne apporte une information nouvelle que l’on ne peut former avec les autres.


  1. Matrice de faible rang (Low-rank)

    Une matrice est de faible rang si son rang est inférieur à son nombre de lignes ou de colonnes. Certaines lignes ou colonnes peuvent alors se former par combinaison des autres : elles contiennent des informations redondantes. La matrice peut être grande sans contenir autant d’informations utiles.

    Prenons par exemple :

    B=[1224]\mathbf{B} = \begin{bmatrix} 1 & 2 \\ 2 & 4 \end{bmatrix}

    La deuxième ligne vaut deux fois la première ; les deux ne sont pas indépendantes. Le rang est donc 1, pas 2. C’est une matrice de faible rang. On peut l’approcher ou la décrire à l’aide de matrices plus petites.

À quoi sert une matrice de faible rang ?

Dans bien des applications, nous travaillons avec d’immenses matrices qui peuvent contenir beaucoup d’informations redondantes. Une matrice de faible rang permet alors d’approcher la matrice de départ pour :

  1. Réduire le coût de calcul : des opérations sur les facteurs de faible rang peuvent demander moins de calcul et accélérer l’algorithme.
  2. Réduire le stockage : conserver ces facteurs peut demander moins de mémoire, ce qui aide sur les grands jeux de données.
  3. Réduire la dimension des données : projeter des données de grande dimension vers un espace plus petit tout en conservant l’information principale, comme dans la PCA.
  4. Limiter les degrés de liberté appris : une contrainte de faible rang peut parfois réduire le surajustement.

L’exemple le plus familier est la décomposition en valeurs singulières (SVD). Elle sépare une matrice en plusieurs autres ; si l’on ne garde que les premières valeurs singulières et leurs vecteurs, on obtient une approximation de faible rang. C’est utile, entre autres, pour compresser des images et dans les systèmes de recommandation.

Factorisation de faible rang : LoRA

Les couches denses (Dense Layer) des réseaux neuronaux multiplient des matrices dont les poids sont généralement de rang plein. Une étude antérieure indiquait que les modèles de langage préentraînés ont une faible « dimension intrinsèque (Intrinsic Dimension) » : même projetés aléatoirement dans un sous-espace plus petit, ils peuvent encore apprendre efficacement.

Les auteurs supposent donc que les mises à jour des poids pendant l’adaptation ont elles aussi un « faible rang intrinsèque » (Low Intrinsic Rank). Pour une matrice de poids préentraînée W0∈Rd×kW_0 \in \mathbb{R}^{d \times k}, ils expriment la mise à jour par une factorisation de faible rang :

W0+ΔW=W0+BAW_0 + \Delta W = W_0 + BA

où B∈Rd×rB \in \mathbb{R}^{d \times r}, A∈Rr×kA \in \mathbb{R}^{r \times k} et le rang r≪min⁡(d,k)r \ll \min(d, k).

Pendant l’entraînement, la matrice de poids préentraînée W0W_0 est gelée et ne change pas. AA et BB sont les paramètres entraînables. Leur produit et le poids initial sont appliqués au vecteur d’entrée xx, puis leurs résultats sont additionnés terme à terme :

h=W0x+ΔWx=W0x+BAxh = W_0 x + \Delta W x = W_0 x + BA x

AA est initialisée par une distribution gaussienne aléatoire et BB par des zéros. Au début de l’entraînement, ΔW=BA\Delta W = BA vaut donc zéro.

Pour stabiliser l’apprentissage, ΔWx\Delta W x est mis à l’échelle sous la forme αr⋅ΔWx\frac{\alpha}{r} \cdot \Delta W x, où α\alpha est une constante choisie séparément de rr. Avec l’optimiseur Adam, changer α\alpha revient approximativement à changer le taux d’apprentissage. Les auteurs le fixent à la première valeur de rr testée et ne le réajustent pas quand ils changent le rang.

Si l’on applique LoRA à toutes les matrices de poids, que l’on entraîne aussi les biais et que l’on élève le rang rr jusqu’à celui des matrices initiales, sa capacité d’expression peut se rapprocher de celle d’un ajustement complet. L’entraînement, le résultat et l’ajustement limité à certaines matrices d’attention demandent des évaluations distinctes.

LoRA dans le Transformer

LoRA peut s’appliquer à toute matrice de poids d’un réseau neuronal. Dans le Transformer, elle vise surtout celles du module d’auto-attention :

  • Quatre matrices : WqW_q, WkW_k, WvW_v, WoW_o.
  • Chacune mesure dmodel×dmodeld_{model} \times d_{model}, même si sa sortie est souvent répartie entre plusieurs têtes d’attention.

Dans cet article, les auteurs n’adaptent que les poids d’attention et gèlent le module MLP pour réduire le nombre de paramètres.

Cela présente plusieurs avantages :

  • Moins de mémoire et de stockage sur un grand Transformer tel que GPT-3 175B :
    • Dans la configuration d’entraînement GPT-3 175B avec Adam de l’article, la VRAM passe de 1,2 To à 350 Go si r≪dmodelr \ll d_{model}.
    • Avec r=4r = 4 et en n’ajustant que les projections de requête et de valeur, les checkpoints passent de 350 Go à 35 Mo, soit environ 10 000 fois moins.
  • Moins de GPU et moins de goulots d’étranglement d’E/S : le besoin réduit en mémoire permet de s’entraîner avec moins de GPU.
  • Changement rapide de tâche : il suffit d’échanger les poids LoRA, sans recharger le modèle entier.
  • Entraînement plus rapide : comparé à l’ajustement complet, l’article annonce environ 25 % de temps en moins pour GPT-3 175B ; une note donne un débit de 32,5→43,1 tokens/s par V100.

Il reste un inconvénient : si l’on fusionne AA et BB dans WW pour éliminer la latence à l’inférence, il devient difficile de mélanger dans un lot des entrées destinées à différentes tâches. Si la latence importe moins, on peut laisser les poids séparés et choisir dynamiquement le module LoRA adapté pour chaque lot.

Discussion

Méthodes de référence

Les auteurs expérimentent sur RoBERTa, DeBERTa, GPT-2 et GPT-3. Voici les méthodes retenues comme références :

  1. Ajustement (Fine-Tuning, FT)

    • Ajustement complet : initialisation avec les poids et biais préentraînés, puis mise à jour de tous les paramètres par gradient.
    • Ajustement des dernières couches (FTTop2) : seuls les paramètres des deux dernières couches de GPT-2 sont mis à jour (Li et Liang, 2021).
    • Ajustement des biais (BitFit) : seuls les vecteurs de biais sont entraînés ; tous les autres paramètres restent gelés (Zaken et al., 2021).

  1. Ajustement des plongements de prompt (Prefix-Embedding Tuning, PreEmbed)

    Des tokens spéciaux sont ajoutés avant ou après l’entrée de la tâche ; leurs plongements lexicaux sont entraînables.

    • Stratégies :
      • Préfixe (Prefix) : ajout de tokens spéciaux avant l’entrée de la tâche.
      • Infixe (Infix) : ajout de tokens spéciaux après l’entrée de la tâche.
    • Nombre de paramètres : ∣Θ∣=dmodel×(lp+li)|\Theta| = d_{model} \times (l_p + l_i) où lpl_p et lil_i sont respectivement les nombres de tokens préfixes et infixes.

  1. Ajustement par couche du prompt (Prefix-Layer Tuning, PreLayer)

    Au lieu de n’ajuster que les plongements, on apprend les activations correspondantes dans chaque couche du Transformer.

    • Nombre de paramètres : ∣Θ∣=L×dmodel×(lp+li)|\Theta| = L \times d_{model} \times (l_p + l_i) où LL est le nombre de couches du Transformer.

  1. Ajustement d’Adapters (Adapter Tuning)

    • AdapterH : conception initiale (Houlsby et al., 2019), avec un Adapter après le module d’auto-attention et un autre après le MLP, chacun avant sa connexion résiduelle.
    • AdapterL : application seulement après le module MLP et après LayerNorm (Lin et al., 2020).
    • AdapterP : proche d’AdapterL (Pfeiffer et al., 2021).
    • AdapterD : suppression d’une partie des Adapters pour gagner en efficacité (Rücklé et al., 2020).
    • Nombre de paramètres : ∣Θ∣=L^Adpt×(2×dmodel×r+r+dmodel)+2×L^LN×dmodel|\Theta| = \hat{L}_{Adpt} \times (2 \times d_{model} \times r + r + d_{model}) + 2 \times \hat{L}_{LN} \times d_{model} où L^Adpt\hat{L}_{Adpt} est le nombre d’Adapters et L^LN\hat{L}_{LN} celui des couches LayerNorm entraînables.

  1. Adaptation LoRA (LoRA Tuning)

    Des matrices factorisées de faible rang s’ajoutent à la matrice de poids initiale pour la mettre à jour, en calcul parallèle avec elle. Dans la plupart des expériences, LoRA ne s’applique qu’à la matrice de requête WqW_q et à la matrice de valeur WvW_v.

    • Nombre de paramètres :

      ∣Θ∣=2×L^LoRA×dmodel×r|\Theta| = 2 \times \hat{L}_{LoRA} \times d_{model} \times r

      où L^LoRA\hat{L}_{LoRA} est le nombre de matrices auxquelles LoRA est appliqué et rr le rang.

Comparaison avec d’autres méthodes d’ajustement

Les auteurs prennent dans HuggingFace RoBERTa Base (125M) et RoBERTa Large (355M) pour leurs essais.

Pour comparer équitablement avec la référence Adapter, deux réglages sont harmonisés :

  1. Même taille de lot et même longueur de séquence : toutes les tâches utilisent la même taille de lot et des séquences de longueur 128, comme dans la référence Adapter.
  2. Initialisation du modèle : pour MRPC, RTE et STS-B, les modèles partent des poids préentraînés, plutôt que d’un modèle déjà adapté à MNLI comme dans la référence d’ajustement complet.

Le tableau ci-dessus montre que LoRA approche l’ajustement complet sur RoBERTa Base et Large, tout en faisant mieux que les Adapters et d’autres méthodes efficaces sur la plupart des tâches.

DeBERTa, une variante plus récente de BERT entraînée à plus grande échelle, est très compétitive sur GLUE et SuperGLUE. Les auteurs testent aussi LoRA sur DeBERTa ; la dernière partie du tableau donne ses résultats. Dans la plupart des cas, LoRA y dépasse l’ajustement complet.

Ajuster GPT-3

Enfin, voici l’ajustement de GPT-3 !

Dans les réglages WikiSQL, MultiNLI-matched et SAMSum du tableau, LoRA fait globalement mieux que les Adapters et les autres méthodes d’adaptation efficace. Il obtient aussi des résultats comparables ou supérieurs à l’ajustement complet.

Par ailleurs, augmenter le nombre de paramètres entraînables n’améliore pas toujours les résultats de façon monotone, comme le montre la figure suivante :

Avec plus de 256 tokens spéciaux, les performances de Prefix-embedding tuning baissent nettement. Pour Prefix-layer tuning, la baisse apparaît au-delà de 32 tokens. Trop de tokens spéciaux pourraient éloigner la distribution des entrées de celle des données de préentraînement.

Sur quelles matrices de poids du Transformer appliquer LoRA ?

Avec un budget de paramètres limité, quels types de matrices faut-il adapter pour obtenir les meilleurs résultats en aval ?

Les auteurs expérimentent sur GPT-3 175B avec un budget de 18 millions de paramètres, soit environ 35 Mo en FP16. Sur les 96 couches, adapter un seul type de poids d’attention permet un rang r=8r = 8 ; en adapter deux impose r=4r = 4.

Les chiffres du tableau sont les précisions de validation sur WikiSQL et MultiNLI :

  • Adapter seulement ΔWq\Delta W_q ou ΔWk\Delta W_k : les performances baissent nettement.
  • Adapter à la fois WqW_q et WvW_v : les résultats globaux sont meilleurs. Sur WikiSQL, cette configuration et celle qui adapte les quatre matrices atteignent toutes deux 73,7 %. Sur MultiNLI, l’adaptation des quatre matrices mène avec 91,7 %.

Sur ces deux tâches et avec ce budget, même r=4r = 4 permet à ΔW\Delta W de saisir assez d’informations. Adapter davantage de types de matrices avec un rang plus petit est donc plus efficace que n’en adapter qu’un seul avec un rang plus grand.

Quel est le meilleur rang rr pour LoRA ?

Sur les validations WikiSQL et MultiNLI de la figure, LoRA obtient des résultats proches dès un très petit rang rr, surtout en adaptant {Wq,Wv}\{W_q, W_v\}.

Dans cette comparaison, augmenter rr ne relève guère la précision. Les auteurs analysent alors les sous-espaces pour voir si un rang plus grand couvre réellement davantage de directions utiles.

Analyse de la similarité des sous-espaces

Les auteurs veulent comparer les sous-espaces obtenus avec des valeurs de rr différentes, ainsi qu’avec des graines aléatoires différentes. Ils appliquent une décomposition en valeurs singulières (SVD) aux matrices pour obtenir les matrices de vecteurs singuliers droits :

UAr=8etUAr=64U_{A_{r=8}} \quad \text{et} \quad U_{A_{r=64}}

La question est : dans quelle mesure le sous-espace de UAr=8U_{A_{r=8}} formé par ses ii premiers vecteurs singuliers est-il contenu dans celui de UAr=64U_{A_{r=64}} formé par ses jj premiers vecteurs ?

Pour mesurer cette similarité, ils utilisent une similarité normalisée de sous-espaces fondée sur la distance de Grassmann :

ϕ(Ar=8,Ar=64,i,j)=∥(UAr=8i)⊤UAr=64j∥F2min⁡(i,j)∈[0,1]\phi(A_{r=8}, A_{r=64}, i, j) = \frac{\left\| \left(U_{A_{r=8}}^{i}\right)^\top U_{A_{r=64}}^{j} \right\|_F^2}{\min(i, j)} \in [0, 1]

Ici, UAr=8iU_{A_{r=8}}^{i} désigne, dans UAr=8U_{A_{r=8}}, les colonnes des ii premiers vecteurs singuliers.

La figure donne les résultats :

Les directions des premiers vecteurs singuliers se recouvrent fortement entre Ar=8A_{r=8} et Ar=64A_{r=64}, tandis que les autres se recouvrent moins. Globalement, Ar=8A_{r=8} et Ar=64A_{r=64} partagent un sous-espace à une dimension pour ΔWv\Delta W_v (ou ΔWq\Delta W_q), avec une similarité ϕ>0.5\phi > 0.5.

Cela pourrait expliquer pourquoi même un rang r=1r = 1 fonctionne assez bien sur ces tâches en aval : l’information utile pourrait se concentrer dans les premiers vecteurs singuliers.


Rassemblons enfin quelques idées avancées par les auteurs :

  1. Une adaptation de faible rang peut suffire : dans les tâches testées ici, même avec un rang rr très petit, LoRA approche l’ajustement complet.
  2. Adapter plus de matrices peut aider davantage qu’augmenter le rang : dans les tâches et avec le budget du tableau 5, adapter davantage de types de matrices, par exemple WqW_q et WvW_v ensemble, peut améliorer les résultats malgré un rang plus petit.

Conclusion

Comparé aux autres méthodes d’ajustement, LoRA nous donne vraiment beaucoup !

Il réduit considérablement le nombre de paramètres entraînables, 10 000 fois !, tout en gardant les performances du modèle :

  • Nous pouvons enfin, nous aussi, ajuster un LLM !

En 2021, ajuster les LLM à la portée de tous n’est plus seulement un rêve ; c’est devenu réalisable. Les grands modèles peuvent ainsi servir dans davantage d’applications et exprimer leurs atouts dans de nouveaux contextes.

La prochaine décennie promet d’être animée. Nous pouvons attendre avec impatience les prochaines recherches !