PEFT documentation
RandLora: Ajuste fino eficiente en parámetros de rango completo de modelos grandes
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
< 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 = 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 predeterminado32) — 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 es0. - 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 esTrue. - 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 esFalse. - 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 alternativassparse, pero es probable que disminuya el rendimiento como resultado. Úselas con cuidado. El valor predeterminado esFalse. - 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 coeficienterandlora_alphaes 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 coeficienterandlora_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 utilizaConv1D, que almacena los pesos como (fan_in, fan_out), por lo que este valor debe establecerse enTrue. - 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 silayers_to_transformes diferente deNoney 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.
RandLoraModel
clase peft.RandLoraModel
< 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 (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 toFalse) — 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:
- model (PreTrainedModel) — El modelo que se va a adaptar.
- peft_config (RandLoraConfig): La configuración del modelo RandLora.