PEFT documentation
AdaLoRA
AdaLoRA
AdaLoRA (Adaptive LoRA) est une méthode d’optimisation du nombre de paramètres entraînables à attribuer aux matrices de poids et aux couches. Contrairement à LoRA, qui répartit les paramètres uniformément entre tous les modules, AdaLoRA alloue davantage de paramètres aux matrices de poids et aux couches importantes, tandis que les moins importantes en reçoivent moins. Vous pouvez contrôler le rank moyen souhaité, ou r, des matrices, ainsi que les modules auxquels appliquer AdaLoRA via target_modules. D’autres paramètres importants à définir sont lora_alpha (facteur d’échelle) et modules_to_save (les modules, distincts des couches AdaLoRA, qui doivent être entraînés et sauvegardés). Tous ces paramètres, et d’autres encore, sont disponibles dans AdaLoraConfig.
L'abstract de l'article est :
Le fine-tuning de grands modèles de langage pré-entraînés sur des tâches en aval est devenu un paradigme important en NLP. Cependant, la pratique courante consiste à effectuer le fine-tuning de tous les paramètres d'un modèle pré-entraîné, ce qui devient prohibitif lorsqu'un grand nombre de tâches en aval sont présentes. Par conséquent, de nombreuses méthodes de fine-tuning ont été proposées pour apprendre des mises à jour incrémentales des poids pré-entraînés de manière efficace en termes de paramètres, par exemple des incréments de faible rang. Ces méthodes répartissent souvent uniformément le budget des mises à jour incrémentales entre toutes les matrices de poids pré-entraînées, et négligent l'importance variable des différents paramètres de poids. En conséquence, les performances de fine-tuning sont sous-optimales. Pour combler cette lacune, nous proposons AdaLoRA, qui alloue de manière adaptative le budget de paramètres entre les matrices de poids en fonction de leur score d'importance. En particulier, AdaLoRA paramètre les mises à jour incrémentales sous la forme d'une décomposition en valeurs singulières. Cette approche novatrice nous permet de supprimer efficacement les valeurs singulières des mises à jour peu importantes, ce qui revient essentiellement à réduire leur budget de paramètres tout en évitant des calculs exacts de SVD intensifs. Nous menons des expériences étendues avec plusieurs modèles pré-entraînés sur le traitement du langage naturel, la réponse aux questions et la génération de langage naturel pour valider l'efficacité d'AdaLoRA. Les résultats démontrent qu'AdaLoRA présente une amélioration notable par rapport aux méthodes de référence, en particulier dans les configurations à faible budget. Notre code est publiquement disponible à l'adresse https://github.com/QingruZhang/AdaLoRA.
AdaLoRA dispose d'une méthode update_and_allocate() qui doit être appelée à chaque étape d'entraînement pour mettre à jour le budget de paramètres et le masque, sinon l'étape d'adaptation n'est pas effectuée. Cela nécessite d'écrire une boucle d'entraînement personnalisée ou de sous-classer Trainer pour intégrer cette méthode. À titre d'exemple, consultez cette boucle d'entraînement personnalisée.
AdaLoRA gère le budget de paramètres introduit par LoRA en allouant davantage de paramètres - en d'autres termes, un rang plus élevé r - aux matrices de poids importantes, mieux adaptées à la tâche, et en élaguant celles qui le sont moins. Le rang est contrôlé par une méthode similaire à la décomposition en valeurs singulières (SVD). Le est paramétré avec deux matrices orthogonales et une matrice diagonale contenant les valeurs singulières. Cette méthode de paramétrage évite d'appliquer itérativement la SVD, qui est coûteuse en calcul. Sur la base de cette méthode, le rang de est ajusté en fonction d'un score d'importance. est divisé en triplets et chaque triplet est noté selon sa contribution aux performances du modèle. Les triplets avec des scores d'importance faibles sont élagués et ceux avec des scores élevés sont conservés pour le fine-tuning.
L’entraînement avec AdaLoRA comporte trois phases : la phase d’initialisation, la phase de budgétisation et la phase finale. Lors de la phase d’initialisation, aucune budgétisation n’est appliquée, les rangs ne sont donc pas modifiés. Pendant la phase de budgétisation, le processus décrit ci-dessus est appliqué et le rang est redistribué selon un budget, dans le but d’attribuer plus de rang aux adaptateurs plus importants et moins aux couches moins importantes. Une fois la phase finale atteinte, la budgétisation est terminée, les rangs sont redistribués, mais il est possible de poursuivre l’entraînement pendant un certain temps avec les rangs redistribués afin d’améliorer encore les performances.
Contributions bienvenues : Cette section nécessite des clarifications.
Il n'est pas clair comment l'importance est mesurée. Les explications sont également un peu redondantes et pourraient bénéficier d'une consolidation. Voir ici comment contribuer.
Aperçu des benchmarks
Utilisation
from peft import AdaLoraConfig, get_peft_model
config = AdaLoraConfig(
r=8,
init_r=12,
tinit=200,
tfinal=1000,
deltaT=10,
target_modules=["query", "value"],
modules_to_save=["classifier"],
)
model = get_peft_model(model, config)
model.print_healthcheck()
[... training code ...]
model.update_and_allocate(step_idx)API
AdaLoraConfig
classe peft.AdaLoraConfig
< source >( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falser: int = 8target_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonelora_alpha: int = 8lora_dropout: float = 0.0fan_in_fan_out: bool = Falsebias: Literal['none', 'all', 'lora_only'] = 'none'use_rslora: bool = Falsemodules_to_save: Optional[list[str]] = Noneinit_lora_weights: bool | Literal['gaussian', 'eva', 'olora', 'pissa', 'pissa_niter_[number of iters]', 'corda', 'astra', 'loftq', 'orthogonal', 'mica', 'nora'] = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonerank_pattern: dict | None = Nonealpha_pattern: Optional[dict] = <factory>megatron_config: Optional[dict] = Nonemegatron_core: Optional[str] = 'megatron.core'trainable_token_indices: Optional[Union[list[int], dict[str, list[int]]]] = Noneloftq_config: Union[LoftQConfig, dict] = <factory>eva_config: Optional[EvaConfig] = Nonecorda_config: Optional[CordaConfig] = Noneastra_config: Optional[AstraConfig] = Nonelora_ga_config: Optional[LoraGAConfig] = Noneuse_dora: bool = Falsevelora_config: Optional[Union[VeloraConfig, dict]] = Nonealora_invocation_tokens: Optional[list[int]] = Noneuse_qalora: bool = Falseqalora_group_size: int = 16monteclora_config: Optional[MontecloraConfig] = Nonelayer_replication: Optional[list[tuple[int, int]]] = Noneruntime_config: LoraRuntimeConfig = <factory>lora_bias: bool = Falsetarget_parameters: Optional[list[str]] = Noneuse_bdlora: Optional[BdLoraConfig] = Nonearrow_config: Optional[ArrowConfig] = Nonekasa_config: Optional[KasaConfig] = Noneensure_weight_tying: bool = Falsetarget_r: int = 8init_r: int = 12tinit: int = 0tfinal: int = 0deltaT: int = 1beta1: float = 0.85beta2: float = 0.85orth_reg_weight: float = 0.5total_step: int | None = None )
Paramètres
- target_r (
int) — Rang moyen cible de la matrice incrémentale. - init_r (
int) — Rang initial de chaque matrice incrémentale. - tinit (
int) — Nombre d'étapes de montée en température initiale du fine-tuning. - tfinal (
int) — Le nombre d'étapes de fine-tuning final. - deltaT (
int) — L'intervalle de temps entre deux allocations de budget. - beta1 (
float) — L'hyperparamètre de l'EMA pour le lissage de la sensibilité. - beta2 (
float) — L'hyperparamètre de l'EMA pour la quantification de l'incertitude. - orth_reg_weight (
float) — Le coefficient de régularisation orthogonale. - total_step (
int) — Le nombre total d'étapes d'entraînement qui doit être spécifié avant l'entraînement. - rank_pattern (
list) — Le rang alloué à chaque matrice de poids par RankAllocator.
Ceci est la classe de configuration destinée à stocker la configuration d'un AdaLoraModel.
AdaLoRA comporte trois phases définies par tinit, tfinal et total_step.
La phase initiale peut être comprise comme une étape de pré-entraînement des adaptateurs afin que, lors de la réduction de leur rang, il existe déjà certaines informations encodées qui peuvent être réduites, plutôt que des matrices aléatoires. Cette phase est définie en fournissant tinit.
Une fois la phase initiale terminée (tinit étapes sont passées) et que la phase finale n'a pas encore commencé, AdaLoRA réduit le budget de la rangée maximale autorisée pour chaque couche à chaque étape. C'est à ce moment que la réduction de la rangée a lieu. Ce processus se poursuit jusqu'à ce que total_step - tfinal étapes soient atteintes.
La dernière phase, qui commence une fois que total_step - tfinal étapes sont atteintes, ne modifie plus les rangs des couches, mais effectue un fine-tuning des couches de rang réduit issues de la phase précédente.
Un exemple concret : tinit vaut 10, tfinal vaut 20 et total_step vaut 100. Nous consacrons 10 étapes au pré-entraînement sans réduction de rang, car notre budget est constant (phase d’initialisation), puis 80 (100-20) étapes à la phase de réduction, où notre budget diminue à chaque étape, et enfin 20 étapes à l’étape finale d’ajustement fin sans réduction.
AdaLoraModel
classe peft.AdaLoraModel
< source >( modelconfigadapter_name**kwargs ) → torch.nn.Module
Paramètres
- model (transformers.PreTrainedModel) — Le modèle à adapter.
- config (AdaLoraConfig) — La configuration du modèle AdaLora.
- adapter_name (
str) — Le nom de l'adaptateur, par défaut"default". - low_cpu_mem_usage (
bool,optional, par défautFalse) — Crée des poids d'adaptateurs vides sur l'appareil méta. Utile pour accélérer le processus de chargement.
Retourne
torch.nn.Module
Le modèle AdaLora.
Crée un modèle AdaLoRA (LoRA adaptatif) à partir d'un modèle transformers pré-entraîné. Article : https://openreview.net/forum?id=lq62uWRJjiY
Exemple :
>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import AdaLoraConfig, get_peft_model
>>> config = AdaLoraConfig(
... peft_type="ADALORA",
... task_type="SEQ_2_SEQ_LM",
... init_r=12,
... lora_alpha=32,
... target_modules=["q", "v"],
... lora_dropout=0.01,
... total_step=1000,
... )
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> adalora_model = get_peft_model(model, config)Attributs :
- model (transformers.PreTrainedModel) — Le modèle à adapter.
- peft_config (AdaLoraConfig) : la configuration du modèle AdaLora.
Cette méthode n'est pas prise en charge pour AdaLoRA, utilisez LoRA à la place.
update_and_allocate
< source >( global_step )
Cette méthode met à jour le budget et le masque d'Adalora.
Cela doit être appelé à chaque étape d'entraînement, après loss.backward() et avant zero_grad().
tinit, tfinal et deltaT sont gérés dans la méthode.