# PVeRA : Adaptation probabiliste de matrices aléatoires basée sur des vecteurs

[PVeRA](https://huggingface.co/papers/2512.07703) 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.Linear` sont 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

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=PVERA" frameborder="0" width="850" height="1000"
>

# API

## PveraConfig[[peft.PveraConfig]]

#### peft.PveraConfig[[peft.PveraConfig]]

```python
peft.PveraConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, r: int = 256, target_modules: Optional[Union[list[str], str]] = None, projection_prng_key: int = 0, save_projection: bool = True, pvera_dropout: float = 0.0, d_initial: float = 0.1, fan_in_fan_out: bool = False, bias: str = 'none', modules_to_save: Optional[list[str]] = None, init_weights: bool = True, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, sample_at_inference: bool = False, generator_seed: Optional[int] = None)
```

[Source](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/pvera/config.py#L25)

**Paramètres :**

r (`int`, *facultatif*, valeur par défaut `256`) : 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 sera 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 seront choisis en fonction de l'architecture du modèle. Si l'architecture est inconnue, une erreur sera 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 augmentera la taille du checkpoint, mais garantira que nous pouvons recharger le checkpoint sur toutes les configurations système. La valeur par défaut est `True`.

pvera_dropout (`float`) : Probabilité de dropout pour les couches PVeRA.

d_initial (`float`, *facultatif*, valeur par défaut `0.1`) : valeur initiale du vecteur `pvera_lambda_d` utilisé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 utilise `Conv1D`, qui stocke les poids sous la forme (fan_in, fan_out), et il convient donc de définir cette valeur sur `True`.

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 entier unique 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 si `layers_to_transform` est différent de `None`. Il doit cibler le `nn.ModuleList` du modèle, souvent appelé `'layers'` ou `'h'`.

sample_at_inference (`bool`, par défaut `False`) : 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](/docs/peft/v0.22.0/fr/package_reference/pvera#peft.PveraModel).

Article : https://www.arxiv.org/abs/2512.07703.

## PveraModel[[peft.PveraModel]]

#### peft.PveraModel[[peft.PveraModel]]

```python
peft.PveraModel(model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str, low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

[Source](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/pvera/model.py#L35)

**Paramètres :**

model ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel)) : Le modèle à adapter.

config ([PveraConfig](/docs/peft/v0.22.0/fr/package_reference/pvera#peft.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éfaut `False`) : Crée des poids d'adaptateur 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 :

```py
>>> 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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel)) -- Le modèle à adapter.
- **peft_config** ([PveraConfig](/docs/peft/v0.22.0/fr/package_reference/pvera#peft.PveraConfig)) : La configuration du modèle PVeRA.

