PEFT documentation

RandLora: Ajuste fino eficiente en parámetros de rango completo de modelos grandes

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

RandLora: Ajuste fino eficiente en parámetros de rango completo de modelos grandes

RandLora es una técnica de ajuste fino eficiente en parámetros, similar a LoRA y VeRA, pero que realiza actualizaciones de rango completo para mejorar el rendimiento. RandLora puede ser especialmente útil al adaptar modelos grandes a tareas difíciles que requieren actualizaciones complejas, mientras se preserva la eficiencia en parámetros de LoRA. La actualización de rango completo de RandLora se logra mediante la escalado lineal de bases aleatorias. Las bases aleatorias son una colección de múltiples matrices de bajo rango, de modo que la suma de sus rangos sea mayor o igual al rango completo de las matrices de parámetros. Los parámetros entrenables de RandLora son dos matrices diagonales (vectores) que se multiplican con las bases aleatorias de bajo rango de la derecha, de manera similar a la actualización de VeRA. Para mantener un bajo uso de memoria, RandLora utiliza una función personalizada que impide almacenar en memoria bases innecesarias para la retropropagación.

RandLora presenta la diferencia notable de que, a diferencia de otros algoritmos PEFT similares a LoRA, aumentar los rangos base aleatorios de RandLora aumenta la cantidad de parámetros entrenables. Dado que el número de bases por rango de base es constante en RandLora, reducir el rango aumentará el número de bases aleatorias y, por lo tanto, el número de bases diagonales entrenables específicas de cada base.

Reducir el rango de las bases aleatorias de RandLora aumenta su número, por lo que RandLora puede ser más lento para entrenar que LoRA en rangos muy pequeños, donde típicamente los rangos inferiores a 4 resultan en un gran aumento del tiempo de entrenamiento. Esto no afecta la inferencia, ya que los adaptadores de RandLora pueden fusionarse en las matrices de pesos preentrenadas.

RandLora también admite el entrenamiento con bases aleatorias ternarias dispersas (que solo contienen -1, 0 y 1). Estas bases son las descritas en Bingham et al. y Ping et al. y, en teoría, podrían utilizarse para reducir las necesidades de cómputo al realizar agregaciones en lugar de multiplicaciones de matrices para crear la actualización de pesos. Esto no está soportado actualmente. Aunque no reduce el cómputo en la actualidad, el uso de bases aleatorias dispersas en RandLora puede reducir el sobreajuste en algunos casos. Para los usuarios interesados en usar bases ternarias dispersas, se recomienda la opción sparse sobre la opción very_sparse, que puede reducir el rendimiento.

De manera similar a VeRA, al guardar los parámetros de RandLora, es posible evitar el almacenamiento de las matrices de bajo rango estableciendo save_projection=False en VeraConfig. 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).

Al igual que en Vera y para manejar diferentes formas de las capas adaptadas, RandLora 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 para 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).

RandLora tiene actualmente la siguiente restricción:

  • Solo se admiten capas nn.Linear.

El resumen del artículo es:

Low-Rank Adaptation (LoRA) y sus variantes han mostrado resultados impresionantes en la reducción del número de parámetros entrenables y los requisitos de memoria de las grandes redes transformer, al tiempo que mantienen el rendimiento del fine-tuning. Sin embargo, la naturaleza de bajo rango de la actualización de pesos limita inherentemente el poder de representación de los modelos fine-tuned, lo que potencialmente compromete el rendimiento en tareas complejas. Esto plantea una pregunta crítica: cuando se observa una brecha de rendimiento entre LoRA y el fine-tuning estándar, ¿se debe al número reducido de parámetros entrenables o a la deficiencia de rango? Este artículo tiene como objetivo responder a esta pregunta introduciendo RandLora, un método eficiente en parámetros que realiza actualizaciones de rango completo utilizando combinaciones lineales aprendidas de matrices aleatorias de bajo rango y no entrenables. Nuestro método limita el número de parámetros entrenables al restringir la optimización a matrices de escalado diagonal aplicadas a las matrices aleatorias fijas. Esto nos permite superar eficazmente las limitaciones de bajo rango manteniendo la eficiencia en parámetros y memoria durante el entrenamiento. A través de experimentos extensos en benchmarks de visión, lenguaje y visión-lenguaje, evaluamos sistemáticamente las limitaciones de LoRA y los métodos de base aleatoria existentes. Nuestros hallazgos revelan que las actualizaciones de rango completo son beneficiosas para las tareas de visión y lenguaje por separado, y aún más para las tareas de visión-lenguaje, donde RandLora reduce significativamente---y a veces elimina---la brecha de rendimiento entre el fine-tuning estándar y LoRA, demostrando su eficacia.

Resumen de las pruebas de rendimiento

API

RandLoraConfig

clase peft.RandLoraConfig

< >

( 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 = 32target_modules: list[str] | str | None = Noneprojection_prng_key: int = 0save_projection: bool = Truesparse: bool = Falsevery_sparse: bool = Falserandlora_dropout: float = 0.0fan_in_fan_out: bool = Falserandlora_alpha: int = 640bias: str = 'none'modules_to_save: list[str] | None = Noneinit_weights: bool = Truelayers_to_transform: list[int] | int | None = Nonelayers_pattern: str | None = None )

Parámetros

  • r (int, opcional, valor predeterminado 32) — Dimensión del rango de la base aleatoria de RandLora. A diferencia de Lora, este parámetro es inversamente proporcional a la cantidad de parámetros entrenables, ya que reducirlo aumenta los parámetros entrenables.
  • target_modules (Union[list[str], str]) — Los nombres de los módulos a los que se aplicará RandLora. Solo se admiten capas lineales.
  • projection_prng_key (int) — Clave de inicialización del PRNG de RandLora. Se utiliza para inicializar basis_A y basis_B en modelos nuevos o al cargar un checkpoint que no incluyera estas proyecciones. El valor predeterminado es 0.
  • save_projection (bool) — Si se debe guardar la base aleatoria global basis_A / basis_B en el state dict junto con las matrices diagonales lambda / gamma por capa. Esto aumentará el tamaño del checkpoint, pero garantiza que podamos recargar el checkpoint en todas las configuraciones del sistema. El valor predeterminado es True.
  • sparse (bool) — Si se deben usar bases aleatorias dispersas, tal como se describe en el artículo RandLora. Las bases son bases ternarias dispersas (que solo contienen -1, 0 y 1) donde la probabilidad de atribución es 1/6 para -1 y 1, y 2/3 para 0. Estas matrices dispersas están destinadas a usarse en el futuro para un cálculo libre de matmul, ver https://huggingface.co/papers/2406.02528v1 La implementación actual es una demostración de concepto, donde la dispersión no se utiliza para mejorar la velocidad ni el uso de memoria. El uso de matrices dispersas generalmente no reduce el rendimiento y puede incluso ayudar a reducir el sobreajuste. El valor predeterminado es False.
  • very_sparse (bool) — Si se deben usar bases aleatorias muy dispersas, tal como se describe en el artículo RandLora. Las bases muy dispersas son bases ternarias dispersas (que solo contienen -1, 0 y 1) dadas una matriz con la dimensión más pequeña d, la probabilidad de atribución es 1/√D para -1 y 1 y 1- 2/√D para 0. El uso de estas matrices dispersas puede reducir además el sobreajuste en comparación con las alternativas sparse, pero es probable que disminuya el rendimiento como resultado. Úselas con cuidado. El valor predeterminado es False.
  • randlora_dropout (float) — La probabilidad de dropout para las capas RandLora.
  • randlora_alpha (float) — El coeficiente de escalado para las capas RandLora, que normalmente sería 20 veces el rango. Dado que el coeficiente randlora_alpha es grande por defecto, puede provocar inestabilidades numéricas, especialmente cuando las tasas de aprendizaje son altas. Si el entrenamiento es inestable, considere reducir la tasa de aprendizaje o el coeficiente randlora_alpha.
  • 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. Puede ser ‘none’, ‘all’ o ‘randlora_only’. Si es ‘all’ o ‘randlora_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 RandLora, 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 RandLora 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 RandLora a los índices de capa indicados en esta lista. Si se pasa un solo entero, se aplicarán las transformaciones de RandLora a la capa en ese índice.
  • layers_pattern (str) — El nombre del patrón de capas, utilizado solo si layers_to_transform es diferente de None y si el patrón de capas no está en el patrón de capas común.

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

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

RandLoraModel

clase peft.RandLoraModel

< >

( 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 (RandLoraConfig) — La configuración del modelo RandLora.
  • 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 RandLora.

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

Ejemplo:

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

>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = RandLoraConfig(r=32)
>>> model = get_peft_model(base_model, config)

Atributos:

Update on GitHub