VeRA : Adaptation de matrices aléatoires basée sur des vecteurs

VeRA est une technique de fine-tuning à efficacité paramétrique, similaire à LoRA, mais qui nécessite encore moins de paramètres supplémentaires tout en promettant des performances comparables, voire supérieures. Elle est donc particulièrement utile lorsque le budget de paramètres est très limité, par exemple lors du passage à l’échelle vers des modèles très volumineux. La réduction du nombre de paramètres entraînants est obtenue en partageant les mêmes matrices de faible rang entre toutes les couches, et en n’entraînant que deux vecteurs supplémentaires par couche.

Fonctionnement de VeRA

LoRA met à jour un modèle de base figé en apprenant deux petites matrices de faible rang pour chaque couche adaptée. Le rang est la dimension interne de ces matrices et il contrôle la capacité de l'adaptateur. Dans LoRA, augmenter r ou adapter davantage de couches augmente rapidement le nombre de paramètres entraînables, car chaque couche adaptée apprend sa propre paire de matrices de faible rang.

VeRA conserve la même idée d’adaptation de faible rang, mais modifie les paramètres entraînés. Au lieu d’apprendre des matrices de faible rang distinctes pour chaque couche, VeRA utilise une paire de matrices de faible rang figées, initialisées aléatoirement, A et B, partagée entre les couches. Chaque couche adaptée n’apprend que deux vecteurs d’échelle, vera_lambda_d et vera_lambda_b, qui rééchelonnent les matrices partagées pour produire une mise à jour spécifique à la couche. Étant donné que vera_lambda_d a une taille de r, le nombre de paramètres entraînables de VeRA augmente toujours avec r et avec le nombre de couches adaptées. Cependant, cette croissance est beaucoup plus lente que celle de LoRA, car les grandes matrices A et B sont partagées et figées, au lieu d’être apprises séparément pour chaque couche.

C'est pourquoi VeRA peut utiliser moins de paramètres entraînables que LoRA. Dans le comptage simplifié des paramètres du papier, LoRA est proportionnel à 2 * L_tuned * d_model * r, où L_tuned est le nombre de couches adaptées, d_model est la dimension du modèle, et r est le rang. VeRA est proportionnel à L_tuned * (d_model + r) car les grandes matrices de faible rang sont partagées et figées, tandis que seuls les vecteurs plus petits par couche sont entraînés.

Lors de l’enregistrement des paramètres de l’adaptateur, il est possible d’éviter de stocker les matrices de faible rang en définissant save_projection=False sur VeraConfig. Dans ce cas, ces matrices seront restaurées à partir de la graine aléatoire fixe de l’argument projection_prng_key. Cela réduit la taille du point de contrôle, mais nous ne pouvons pas garantir la reproductibilité sur tous les appareils ni pour toutes les futures versions de PyTorch. Si vous souhaitez assurer la reproductibilité, définissez save_projection=True (ce qui est la valeur par défaut).

Pour gérer les différentes formes des couches adaptées, VeRA initialise les matrices partagées A et B avec la taille maximale requise pour chaque dimension. Lors du passage avant, les sous-matrices A et B d'une couche donnée sont extraites de ces matrices partagées et utilisées comme décrit dans l'article. Par exemple, l'adaptation de deux couches linéaires de formes (100, 20) et (80, 50) créera des matrices A et B de formes (rank, 50) et (100, rank) respectivement. Ensuite, pour adapter une couche de forme (100, 20), des sous-matrices A et B de formes (rank, 20) et (100, rank) seront extraites.

VeRA présente actuellement la contrainte suivante :

• Seules les couches nn.Linear sont prises en charge.

L'abstract de l'article est :

L'adaptation de rang faible (LoRA) est une méthode populaire qui réduit le nombre de paramètres entraînables lors de l'ajustement fin des grands modèles de langage, mais elle rencontre toujours des défis de stockage aigus lors du passage à des modèles encore plus grands ou du déploiement de nombreux modèles adaptés par utilisateur ou par tâche. Dans ce travail, nous présentons l'adaptation de matrices aléatoires basée sur des vecteurs (VeRA), qui réduit considérablement le nombre de paramètres entraînables par rapport à LoRA, tout en maintenant les mêmes performances. Elle y parvient en utilisant une seule paire de matrices de rang faible partagée entre toutes les couches et en apprenant à la place de petits vecteurs d'échelle. Nous démontrons son efficacité sur les benchmarks GLUE et E2E, sur des tâches de classification d'images, et montrons son application dans l'ajustement par instructions de modèles de langage de 7B et 13B.

Quand utiliser VeRA

VeRA est un bon choix lorsque :

• Vous souhaitez minimiser le nombre de paramètres entraînables tout en maintenant des performances comparables à celles de LoRA.
• Vous devez stocker ou déployer de nombreux adaptateurs spécifiques à une tâche, où des points de contrôle d’adaptateurs plus petits réduisent les exigences de stockage.
• Vous effectuez l’ajustement fin de très grands modèles de langage dans des conditions de mémoire ou de paramètres strictement limitées.

Quand ne pas utiliser VeRA

VeRA peut ne pas être le meilleur choix lorsque :

• Vous avez besoin de matrices de rang faible indépendantes pour chaque couche adaptée, offrant une plus grande flexibilité dans les paramètres d'adaptateur appris.
• Votre modèle nécessite l’adaptation de types de modules autres que nn.Linear, car VeRA ne prend actuellement en charge que les couches linéaires.
• Votre modèle contient des couches linéaires adaptées dont les dimensions d’entrée et de sortie varient considérablement. Comme VeRA partage une seule paire de matrices de projection entre toutes les couches adaptées, ces matrices doivent être dimensionnées pour la plus grande forme. Les modèles présentant une grande variation des formes des couches (par exemple, les couches de projection ascendante et descendante d’un transformeur) peuvent donc nécessiter un surdimensionnement des matrices de projection partagées, ce qui réduit une partie de l’avantage de VeRA en termes d’efficacité paramétrique.

Aperçu des benchmarks

API

VeRAConfig

VeRAModel

>>> from transformers import AutoModelForCausalLM
>>> from peft import VeraConfig, get_peft_model

>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = VeraConfig(r=128)
>>> model = get_peft_model(base_model, config)