RandLora : fine-tuning efficace en paramètres de rang complet de grands modèles

RandLora est une technique de fine-tuning efficace en paramètres, similaire à LoRA et VeRA, mais qui effectue des mises à jour de rang complet pour améliorer les performances. RandLora peut s’avérer particulièrement utile lors de l’adaptation de grands modèles à des tâches difficiles nécessitant des mises à jour complexes, tout en préservant l’efficacité en paramètres de LoRA. La mise à jour de rang complet de RandLora est obtenue par un échelonnement linéaire de bases aléatoires. Les bases aléatoires sont un ensemble de plusieurs matrices de faible rang telles que la somme de leurs rangs est supérieure ou égale au rang complet des matrices de paramètres. Les paramètres entraînables de RandLora sont deux matrices diagonales (vecteurs) qui sont multipliées par les bases aléatoires de faible rang situées à droite, de manière similaire à la mise à jour de VeRA. Pour maintenir une faible utilisation de la mémoire, RandLora utilise une fonction personnalisée qui empêche le stockage en mémoire de bases inutiles pour la rétropropagation.

RandLora présente une différence notable : contrairement aux autres algorithmes PEFT de type LoRA, augmenter les rangs de base aléatoires de RandLora augmente le nombre de paramètres entraînables. Étant donné que le produit du nombre de bases par le rang des bases est constant dans RandLora, réduire le rang augmente le nombre de bases aléatoires, et donc le nombre de bases diagonales entraînables spécifiques à chaque base.

Comme la réduction du rang des bases aléatoires de RandLora entraîne une augmentation de leur nombre, RandLora peut devenir plus lent à entraîner que LoRA pour des rangs très petits, où typiquement, des rangs inférieurs à 4 entraînent une augmentation importante du temps d’entraînement. Cela n’affecte pas l’inférence, car les adaptateurs RandLora peuvent être fusionnés dans les matrices de poids pré-entraînées.

RandLora prend en outre en charge l’entraînement avec des bases aléatoires ternaires creuses (ne contenant que -1, 0 et 1). Ces bases sont décrites dans Bingham et al. et Ping et al. et pourraient théoriquement être utilisées pour réduire les besoins en calcul en effectuant des agrégations au lieu de multiplications de matrices pour créer la mise à jour des poids. Ce n’est pas actuellement pris en charge. Bien que cela ne réduise pas actuellement le calcul, l’utilisation de bases aléatoires creuses dans RandLora peut réduire le surapprentissage dans certains cas. Pour les utilisateurs intéressés par l’utilisation de bases ternaires creuses, l’option sparse est recommandée par rapport à l’option very_sparse, qui peut réduire les performances.

De la même manière que pour VeRA, lors de l’enregistrement des paramètres de RandLora, 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 fournie par 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 versions futures de PyTorch. Si vous souhaitez assurer la reproductibilité, définissez save_projection=True (ce qui est la valeur par défaut).

Comme dans Vera et afin de gérer différentes formes de couches adaptées, RandLora initialise les matrices A et B partagées avec la taille maximale requise pour chaque dimension. Lors du passage avant, les sous-matrices A et B pour 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.

RandLora présente actuellement la contrainte suivante :

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

L'abstract de l'article est :

Low-Rank Adaptation (LoRA) et ses variantes ont montré des résultats impressionnants en réduisant le nombre de paramètres entraînables et les exigences en mémoire des grands réseaux transformers, tout en maintenant les performances de fine-tuning. La nature de rang faible de la mise à jour des poids limite toutefois intrinsèquement la puissance de représentation des modèles affinés, compromettant potentiellement les performances sur des tâches complexes. Cela soulève une question cruciale : lorsqu'un écart de performance est observé entre LoRA et le fine-tuning standard, est-il dû au nombre réduit de paramètres entraînables ou au défaut de rang ? Cet article vise à répondre à cette question en introduisant RandLora, une méthode efficace en paramètres qui effectue des mises à jour de rang complet à l'aide de combinaisons linéaires apprises de matrices aléatoires non entraînables de rang faible. Notre méthode limite le nombre de paramètres entraînables en restreignant l'optimisation aux matrices de mise à l'échelle diagonales appliquées aux matrices aléatoires fixes. Cela nous permet de surmonter efficacement les limitations de rang faible tout en maintenant l'efficacité en paramètres et en mémoire pendant l'entraînement. Grâce à des expérimentations approfondies sur des benchmarks de vision, de langage et de vision-langage, nous évaluons systématiquement les limites de LoRA et des méthodes de base aléatoire existantes. Nos résultats révèlent que les mises à jour de rang complet sont bénéfiques pour les tâches de vision et de langage individuellement, et encore plus pour les tâches de vision-langage, où RandLora réduit considérablement — et élimine parfois — l'écart de performance entre le fine-tuning standard et LoRA, démontrant son efficacité.

Aperçu des benchmarks

API

RandLoraConfig

RandLoraModel

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

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