PEFT documentation
PVeRA : Adaptation probabiliste de matrices aléatoires basée sur des vecteurs
PVeRA : Adaptation probabiliste de matrices aléatoires basée sur des vecteurs
PVeRA est une technique de fine-tuning à faible coût paramétrique basée sur VeRA, appartenant à la famille des adaptateurs fondés sur LoRA. Elle conserve le budget paramétrique très faible de VeRA, mais améliore les performances en apprenant une distribution d'adaptations latentes. Cela permet également aux modèles adaptés avec PVeRA de générer des estimations d'intervalles de confiance de Monte Carlo, en échantillonnant à partir de la distribution apprise lors de l'inférence.
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 PveraConfig. 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 versions futures de PyTorch. Si vous souhaitez garantir 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, PVeRA 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.
PVeRA présente actuellement la contrainte suivante :
- Seules les couches
nn.Linearsont prises en charge. - La représentation latente n'est pas facilement accessible pour l'entraînement utilisant la divergence de KL.
L'abstract de l'article est :
Les grands modèles de fondation sont apparus au cours des dernières années et repoussent les limites de performance pour une variété de tâches. L’entraînement, voire le fine-tuning, de tels modèles exige d’immenses jeux de données et des ressources de calcul, souvent rares et coûteuses. Les méthodes d’adaptation offrent une solution computationnellement efficace pour surmonter ces limitations en permettant le fine-tuning de ces modèles sur de petites quantités de données et de puissance de calcul. Cela est réalisé en ajoutant de nouveaux modules entraînables à des squelettes figés, avec seulement une fraction des paramètres entraînables, et en ajustant uniquement ces modules sur de nouvelles tâches. Récemment, l’adaptateur VeRA a démontré son excellence dans les adaptations efficaces en paramètres en utilisant une paire de matrices aléatoires de faible rang figées, partagées entre toutes les couches. Dans cet article, nous proposons PVeRA, une version probabiliste de l’adaptateur VeRA, qui modifie les matrices de faible rang de VeRA de manière probabiliste. Cette modification permet naturellement de gérer les ambiguïtés inhérentes à l’entrée et autorise différentes configurations d’échantillonnage pendant l’entraînement et les tests. Une évaluation complète a été réalisée sur le benchmark VTAB-1k avec sept adaptateurs, PVeRA surpassant VeRA et les autres adaptateurs.
Aperçu des benchmarks
API
PveraConfig
classe peft.PveraConfig
< 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 = 256target_modules: Optional[Union[list[str], str]] = Noneprojection_prng_key: int = 0save_projection: bool = Truepvera_dropout: float = 0.0d_initial: float = 0.1fan_in_fan_out: bool = Falsebias: str = 'none'modules_to_save: Optional[list[str]] = Noneinit_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonesample_at_inference: bool = Falsegenerator_seed: Optional[int] = None )
Paramètres
- r (
int, facultatif, valeur par défaut256) — Dimension du paramètre PVeRA (« rank »). Choisissez ici des valeurs supérieures aux rangs LoRA, car PVeRA partage les paramètres entre les couches et utilise donc beaucoup moins de paramètres que LoRA. - target_modules (
Union[List[str], str]) — Les noms des modules auxquels appliquer PVeRA. Seules les couches linéaires sont prises en charge. Lors du passage d’une chaîne de caractères, une correspondance par expression régulière est effectuée. Si cette valeur est spécifiée comme ‘all-linear’, tous les modules linéaires/Conv1D sont sélectionnés. Si elle n’est pas spécifiée, les modules sont choisis en fonction de l’architecture du modèle. Si l’architecture est inconnue, une erreur est levée. - projection_prng_key (
int) — Clé d’initialisation du PRNG PvERA. Utilisée pour initialiser pvera_A et pvera_B pour de nouveaux modèles ou lors du chargement d’un point de contrôle qui ne contenait pas ces projections. Valeur par défaut :0. - save_projection (
bool) — Indique s'il faut enregistrer les projections pvera_A / pvera_B dans le state dict aux côtés des poids lambda_b / lambda_d par couche. Cela augmente la taille du checkpoint, mais garantit que le checkpoint peut être rechargé sur toutes les configurations système. La valeur par défaut estTrue. - pvera_dropout (
float) — Probabilité de dropout pour les couches PVeRA. - d_initial (
float, facultatif, valeur par défaut0.1) — Valeur initiale du vecteurpvera_lambda_dutilisée lors de l’initialisation des paramètres PVeRA. Des valeurs faibles (<=0.1) sont recommandées. - fan_in_fan_out (
bool) — Définissez cette valeur sur True si la couche à remplacer stocke les poids sous la forme (fan_in, fan_out). Par exemple, gpt-2 utiliseConv1Dqui stocke les poids sous la forme (fan_in, fan_out) et il convient donc de définir cette valeur surTrue. - bias (
str) — Type de biais pour PVeRA. Peut être ‘none’, ‘all’ ou ‘pvera_only’. Si ‘all’ ou ‘pvera_only’, les biais correspondants seront mis à jour pendant l’entraînement. Notez que cela signifie que, même en désactivant les adaptateurs, le modèle ne produira pas la même sortie que le modèle de base sans adaptation. - modules_to_save (
List[str]) — Liste des modules, à l'exception des couches PVeRA, à définir comme entraînables et à enregistrer dans le point de contrôle final. - init_weights (
bool) — Indique s'il faut initialiser les poids des couches PVeRA avec leur initialisation par défaut. Ne modifiez pas ce paramètre, sauf si vous savez exactement ce que vous faites. - layers_to_transform (
Union[List[int],int]) — Les index de couches à transformer. Si cet argument est spécifié, les transformations PVeRA sont appliquées aux index de couches indiqués dans cette liste. Si un seul entier est transmis, les transformations PVeRA sont appliquées à la couche située à cet index. - layers_pattern (
Optional[Union[List[str], str]]) — Le nom du motif de couche, utilisé uniquement silayers_to_transformest différent deNone. Il doit cibler lenn.ModuleListdu modèle, souvent appelé'layers'ou'h'. - sample_at_inference (
bool, par défautFalse) — Indique s'il faut échantillonner à partir de la distribution PVeRA apprise lors de l'inférence. Si False, la moyenne apprise est utilisée. - generator_seed (
int, par défaut None) — Graine aléatoire pour le générateur utilisé pour échantillonner à partir de la distribution apprise.
Ceci est la classe de configuration destinée à stocker la configuration d'un PveraModel.
Article : https://www.arxiv.org/abs/2512.07703.
PveraModel
classe peft.PveraModel
< source >( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None ) → torch.nn.Module
Paramètres
- model (PreTrainedModel) — Le modèle à adapter.
- config (PveraConfig) — La configuration du modèle PVeRA.
- 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 PVeRA.
Crée un modèle Probabilistic Vector-based Random Matrix Adaptation (PVeRA) à partir d'un modèle transformers pré-entraîné.
Exemple :
>>> from transformers import AutoModel
>>> from peft import PveraConfig, get_peft_model
>>> base_model = AutoModel.from_pretrained("facebook/dinov2-base")
>>> config = PveraConfig(r=128, sample_at_inference=False)
>>> model = get_peft_model(base_model, config)Attributs :
- model (PreTrainedModel) — Le modèle à adapter.
- peft_config (PveraConfig) : La configuration du modèle PVeRA.