PEFT documentation
PVeRA: Adaptación de matrices aleatorias basada en vectores probabilísticos
PVeRA: Adaptación de matrices aleatorias basada en vectores probabilísticos
PVeRA es una técnica de ajuste fino eficiente en parámetros basada en VeRA, dentro de la familia de adaptadores basados en LoRA. Mantiene el presupuesto de parámetros muy bajo de VeRA, pero aumenta el rendimiento al aprender una distribución de adaptaciones latentes. Esto también permite que los modelos adaptados con PVeRA generen estimaciones de intervalos de confianza de Monte Carlo, muestreando de la distribución aprendida durante la inferencia.
Al guardar los parámetros del adaptador, es posible evitar el almacenamiento de las matrices de bajo rango estableciendo save_projection=False en PveraConfig. En ese caso, estas matrices se restaurarán en función de la semilla aleatoria fija del argumento projection_prng_key. Esto reduce el tamaño del checkpoint, pero no podemos garantizar la reproducibilidad en todos los dispositivos ni en todas las versiones futuras de PyTorch. Si deseas asegurar la reproducibilidad, establece save_projection=True (que es el valor predeterminado).
Para manejar diferentes formas de las capas adaptadas, PVeRA inicializa las matrices compartidas A y B con el tamaño máximo requerido para cada dimensión. Durante la pasada hacia adelante, las submatrices A y B de una capa dada se extraen de estas matrices compartidas y se utilizan tal como se describe en el artículo. Por ejemplo, adaptar dos capas lineales de formas (100, 20) y (80, 50) creará matrices A y B de formas (rank, 50) y (100, rank) respectivamente. Luego, para adaptar una capa de forma (100, 20), se extraerán submatrices A y B de formas (rank, 20) y (100, rank).
PVeRA tiene actualmente la siguiente restricción:
- Solo se admiten capas
nn.Linear. - La representación latente no es fácilmente accesible para el entrenamiento usando la divergencia de KL.
El resumen del artículo es:
Los grandes modelos de base han surgido en los últimos años y están impulsando los límites de rendimiento para una variedad de tareas. Entrenar o incluso ajustar dichos modelos exige conjuntos de datos y recursos computacionales enormes, que a menudo son escasos y costosos. Los métodos de adaptación ofrecen una solución computacionalmente eficiente para abordar estas limitaciones al permitir que dichos modelos se ajusten con pequeñas cantidades de datos y potencia de cálculo. Esto se logra añadiendo nuevos módulos entrenables a esqueletos congelados con solo una fracción de los parámetros entrenables y ajustando únicamente estos módulos en tareas novedosas. Recientemente, se demostró que el adaptador VeRA destaca en las adaptaciones eficientes en parámetros al utilizar un par de matrices aleatorias de bajo rango congeladas y compartidas entre todas las capas. En este artículo, proponemos PVeRA, una versión probabilística del adaptador VeRA, que modifica las matrices de bajo rango de VeRA de manera probabilística. Esta modificación permite de forma natural manejar las ambigüedades inherentes en la entrada y permite diferentes configuraciones de muestreo durante el entrenamiento y la prueba. Se realizó una evaluación exhaustiva en el benchmark VTAB-1k y siete adaptadores, con PVeRA superando a VeRA y a otros adaptadores.
Resumen de las pruebas de rendimiento
API
PveraConfig
clase 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 )
Parámetros
- r (
int, opcional, valor predeterminado256) — Dimensión del parámetro de PVeRA (“rank”). Elija valores más altos que los rangos de LoRA aquí, ya que PVeRA comparte parámetros entre capas y, por lo tanto, utiliza muchos menos parámetros que LoRA. - target_modules (
Union[List[str], str]) — Los nombres de los módulos a los que se aplicará PVeRA. Solo se admiten capas lineales. Al pasar una cadena de caracteres, se realizará una coincidencia con una expresión regular. Si se especifica como ‘all-linear’, se seleccionan todos los módulos lineales/Conv1D. Si no se especifica, los módulos se elegirán según la arquitectura del modelo. Si la arquitectura no es conocida, se generará un error. - projection_prng_key (
int) — Clave de inicialización del PRNG de PVeRA. Se utiliza para inicializar pvera_A y pvera_B en modelos nuevos o al cargar un punto de control que no incluyera estas proyecciones. El valor predeterminado es0. - save_projection (
bool) — Si se deben guardar las proyecciones pvera_A / pvera_B en el state dict junto con los pesos lambda_b / lambda_d por capa. Esto aumentará el tamaño del checkpoint, pero garantiza que podamos recargar el checkpoint en todas las configuraciones de sistema. El valor predeterminado esTrue. - pvera_dropout (
float) — La probabilidad de dropout para las capas PVeRA. - d_initial (
float, opcional, valor predeterminado0.1) — Valor inicial para el vectorpvera_lambda_dutilizado al inicializar los parámetros de PVeRA. Se recomiendan valores pequeños (<=0.1). - fan_in_fan_out (
bool) — Establezca este valor en True si la capa que se va a reemplazar almacena los pesos como (fan_in, fan_out). Por ejemplo, gpt-2 utilizaConv1D, que almacena los pesos como (fan_in, fan_out), por lo que este valor debe establecerse enTrue. - bias (
str) — Tipo de sesgo para PVeRA. Puede ser ‘none’, ‘all’ o ‘pvera_only’. Si es ‘all’ o ‘pvera_only’, los sesgos correspondientes se actualizarán durante el entrenamiento. Tenga en cuenta que esto significa que, incluso al deshabilitar los adaptadores, el modelo no producirá la misma salida que habría producido el modelo base sin adaptación. - modules_to_save (
List[str]) — Lista de módulos, aparte de las capas PVeRA, que se configurarán como entrenables y se guardarán en el punto de control final. - init_weights (
bool) — Si se deben inicializar los pesos de las capas PVeRA con su inicialización predeterminada. No cambies esta configuración, a menos que sepas exactamente lo que estás haciendo. - layers_to_transform (
Union[List[int],int]) — Los índices de las capas a transformar. Si se especifica este argumento, se aplicarán las transformaciones de PVeRA a los índices de capa indicados en esta lista. Si se pasa un solo entero, se aplicarán las transformaciones de PVeRA a la capa en ese índice. - layers_pattern (
Optional[Union[List[str], str]]) — El nombre del patrón de capas, utilizado solo silayers_to_transformes diferente deNone. Esto debe apuntar alnn.ModuleListdel modelo, que a menudo se llama'layers'o'h'. - sample_at_inference (
bool, por defectoFalse) — Si se muestrea de la distribución PVeRA aprendida durante la inferencia. Si es False, se utiliza la media aprendida. - generator_seed (
int, por defecto None) — Semilla aleatoria para el generador utilizado para muestrear de la distribución aprendida.
Esta es la clase de configuración para almacenar la configuración de un PveraModel.
Artículo: https://www.arxiv.org/abs/2512.07703.
PveraModel
clase 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
Parámetros
- model (PreTrainedModel) — El modelo que se va a adaptar.
- config (PveraConfig) — La configuración del modelo PVeRA.
- adapter_name (
str) — El nombre del adaptador, por defecto es"default". - low_cpu_mem_usage (
bool,optional, defaults toFalse) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.
Devuelve
torch.nn.Module
El modelo PVeRA.
Crea un modelo de Adaptación de Matrices Aleatorias Basada en Vectores Probabilísticos (PVeRA) a partir de un modelo de transformers preentrenado.
Ejemplo:
>>> 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)Atributos:
- model (PreTrainedModel) — El modelo que se va a adaptar.
- peft_config (PveraConfig): La configuración del modelo PVeRA.