Hugging Face's logo

PEFT documentation

VB-LoRA: Ajuste fino extremadamente eficiente de parámetros con bancos de vectores

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.21.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

VB-LoRA: Ajuste fino extremadamente eficiente de parámetros con bancos de vectores

Resumen

VB-LoRA es una técnica de ajuste fino eficiente en parámetros que extiende LoRA al aprender un esquema de compartición de parámetros de gran granularidad a nivel de subvector, logrando una eficiencia de parámetros significativamente mayor. Esto hace que VB-LoRA sea especialmente útil en escenarios donde los costos de almacenamiento y transmisión son críticos. Funciona descomponiendo matrices de bajo rango, de diferentes capas y módulos como K, Q, V y FFN, en subvectores, que luego se comparten globalmente a través de un banco de vectores.

El resumen del artículo es:

A medida que aumenta la adopción de modelos de lenguaje de gran escala y crece la necesidad de personalizar modelos por usuario o por tarea, los métodos de ajuste fino eficiente en parámetros (PEFT), como la adaptación de bajo rango (LoRA) y sus variantes, incurren en costos significativos de almacenamiento y transmisión. Para reducir aún más los parámetros almacenados, introducimos un paradigma de “dividir y compartir” que rompe las barreras de la descomposición de bajo rango a través de las dimensiones de las matrices, los módulos y las capas, compartiendo parámetros globalmente mediante un banco de vectores. Como una instancia de este paradigma aplicada a LoRA, nuestro VB-LoRA propuesto compone todas las matrices de bajo rango de LoRA a partir de un banco de vectores compartido con un módulo de mezcla top-k diferenciable. VB-LoRA logra una eficiencia extrema en parámetros manteniendo un rendimiento comparable o superior al de los métodos PEFT más avanzados. Experimentos extensos demuestran la efectividad de VB-LoRA en tareas de comprensión del lenguaje natural, generación del lenguaje natural y ajuste fino por instrucciones. Al ajustar el modelo Llama2-13B, VB-LoRA solo utiliza el 0,4 % de los parámetros almacenados de LoRA, y aun así obtiene resultados superiores.

Consejos de uso

  • VB-LoRA utiliza un módulo sparse top-k para aprender el mecanismo de compartición. Al guardar los parámetros del adaptador, puede guardar solo los pesos top-k y sus índices estableciendo save_only_topk_weights = True en VBLoRAConfig, o guardar todos los logits entrenables estableciéndolo en False. Habilitar save_only_topk_weights = True reduce significativamente el espacio de almacenamiento; por ejemplo, en Llama2-7B, el tamaño del archivo de almacenamiento disminuye de 308MB a 2.5MB. Tenga en cuenta que los modelos guardados con save_only_topk_weights = True están destinados únicamente a la fusión o la inferencia y no pueden usarse para reanudar el entrenamiento.

  • VB-LoRA tiene dos conjuntos de parámetros de entrenamiento: parámetros del banco de vectores y parámetros de logits. En la práctica, encontramos que los parámetros de logits requieren una tasa de aprendizaje más alta, mientras que los parámetros del banco de vectores requieren una tasa de aprendizaje más baja. Al usar el optimizador AdamW, las tasas de aprendizaje típicas son 0.01 para los logits y 0.001 para los parámetros del banco de vectores.

Resumen de las pruebas de rendimiento

API

VBLoRAConfig

clase peft.VBLoRAConfig

< >

( 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 = 4num_vectors: int = 256vector_length: int = 256topk: int = 2target_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonesave_only_topk_weights: bool = Falsevblora_dropout: float = 0.0fan_in_fan_out: bool = Falsebias: str = 'none'modules_to_save: Optional[list[str]] = Noneinit_vector_bank_bound: float = 0.02init_logits_std: float = 0.1layers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = None )

Parámetros

  • r (int) — El rango de las matrices incrementales.
  • num_vectors (int) — Número de vectores en el banco de vectores. Use valores más altos cuando el tamaño del modelo aumente.
  • vector_length (int) — La longitud de los vectores en el banco de vectores. La longitud de los vectores debe ser divisible por la dimensión oculta del modelo.
  • topk (int) — El valor de K para la selección top-K. Un valor de K mayor aumenta el tamaño del modelo guardado. En la práctica, establecer K=2 suele ofrecer el mejor rendimiento y eficiencia de parámetros. Para más detalles, consulte la discusión en el artículo.
  • target_modules (Union[List[str], str]) — Los nombres de los módulos a los que se aplicará el adaptador. Si se especifica, solo se reemplazarán los módulos con los nombres indicados. Al pasar una cadena de caracteres, se realizará una coincidencia mediante expresión regular. Al pasar una lista de cadenas de caracteres, se realizará una coincidencia exacta o se comprobará si el nombre del módulo termina con alguna de las cadenas pasadas. Si se especifica como ‘all-linear’, se seleccionarán todos los módulos lineales/Conv1D, excluyendo la capa de salida. 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; en este caso, debe especificar los módulos objetivo manualmente.
  • exclude_modules (Optional[Union[List[str], str]]) — Los nombres de los módulos a los que no se aplicará el adaptador. Al pasar una cadena de caracteres, se realizará una coincidencia mediante expresión regular. Al pasar una lista de cadenas de caracteres, se realizará una coincidencia exacta o se comprobará si el nombre del módulo termina con alguna de las cadenas de caracteres pasadas.
  • save_only_topk_weights (bool) — Si se deben guardar solo los pesos topk. Establecer save_only_topk_weights = True reduce significativamente el espacio de almacenamiento. Sin embargo, los modelos guardados en este modo solo pueden usarse para fusionar o inferencia, no para reanudar el entrenamiento.
  • vblora_dropout (float) — La probabilidad de dropout para las capas de VBLoRA.
  • 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 utiliza Conv1D, que almacena los pesos como (fan_in, fan_out), por lo que este valor debe establecerse en True.
  • bias (str) — Tipo de sesgo para VBLoRA. Puede ser ‘none’, ‘all’ o ‘vblora_only’. Si es ‘all’ o ‘vblora_only’, los sesgos correspondientes se actualizarán durante el entrenamiento. Tenga en cuenta que esto significa que, incluso al desactivar 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 VBLoRA, que se configurarán como entrenables y se guardarán en el punto de control final.
  • init_vector_bank_bound (float) — El banco de vectores se inicializa con una distribución uniforme entre -init_vector_bank_bound e init_vector_bank_bound. Evite inicializar el banco de vectores con todos ceros para prevenir gradientes nulos. Un valor pequeño, como 0.02, suele ser efectivo. Inicializar con un valor grande puede causar inestabilidad en el entrenamiento.
  • init_logits_std (float) — Los logits se inicializan con una distribución normal con una desviación estándar de init_logits_std. El valor predeterminado es 0.1.
  • layers_to_transform (Union[List[int],int]) — Los índices de las capas a transformar. Si se pasa una lista de enteros, se aplicará el adaptador a los índices de capa especificados en esta lista. Si se pasa un solo entero, se aplicarán las transformaciones a la capa en este índice.
  • layers_pattern (Optional[Union[List[str], str]]) — El nombre del patrón de capas, utilizado solo si layers_to_transform es diferente de None. Esto debe apuntar al nn.ModuleList del modelo, que a menudo se llama 'layers' o 'h'.

Esta es la clase de configuración para almacenar la configuración de un VBLoRAModel.

Artículo: https://huggingface.co/papers/2405.15179

VBLoRAModel

clase peft.VBLoRAModel

< >

( 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 (VBLoRAConfig) — La configuración del modelo VBLoRA.
  • adapter_name (str) — El nombre del adaptador, por defecto es "default".
  • low_cpu_mem_usage (bool, optional, defaults to False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.

Devuelve

torch.nn.Module

El modelo VBLoRA.

Crea un modelo VBLoRA a partir de un modelo de transformers preentrenado.

El método se describe en detalle en https://huggingface.co/papers/2405.15179.

Ejemplo:

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

>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = VBLoRAConfig(
...     task_type="SEQ_CLS",
...     r=4,
...     target_modules=["fc1", "fc2", "k_proj", "out_proj", "q_proj", "v_proj"],
...     num_vectors=60,
...     vector_length=256,
...     save_only_topk_weights=True,
... )
>>> model = get_peft_model(base_model, config)

Atributos:

get_nb_savable_parameters

< >

( adapter = 'default' )

Devuelve el número de parámetros VB-LoRA guardables y otros parámetros guardables.

print_savable_parameters

< >

( )

Imprime el número de parámetros VB-LoRA guardables y el total de parámetros guardables.

Update on GitHub

←UniLoRA VeRA→