Hugging Face's logo

PEFT documentation

TinyLoRA: Aprender a razonar con 13 parámetros

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

TinyLoRA: Aprender a razonar con 13 parámetros

TinyLoRA es una técnica de ajuste fino extremadamente eficiente en parámetros que se basa en el enfoque LoRA-XS mediante el uso de la descomposición SVD de pesos congelados y la proyección de un vector entrenable diminuto a través de tensores aleatorios fijos. Cuando se combina con métodos de entrenamiento de aprendizaje por refuerzo (RL) como GRPO, TinyLoRA puede lograr un rendimiento competitivo con tan solo 1-13 parámetros entrenables.

La innovación clave de TinyLoRA es reemplazar la matriz de bajo rango entrenable R por una suma ponderada de matrices de proyección aleatorias fijas: R = Σᵢ vᵢ Pᵢ, donde v ∈ R^u es un vector entrenable diminuto de dimensión u y Pᵢ son matrices aleatorias fijas. Esto reduce drásticamente el número de parámetros entrenables manteniendo un rendimiento competitivo.

TinyLoRA admite la vinculación de pesos a través del parámetro weight_tying, una proporción entre 0.0 y 1.0 que controla cuántos módulos comparten el mismo vector entrenable v. Establecer weight_tying=0.0 (el valor predeterminado) significa que no hay compartición, mientras que weight_tying=1.0 implica una compartición completa entre todos los módulos objetivo, logrando una eficiencia extrema de parámetros con un único vector de u parámetros entrenables para todo el modelo.

Al guardar los parámetros del adaptador, es posible evitar el almacenamiento de las matrices de proyección aleatoria estableciendo save_projection=False en TinyLoraConfig. En ese caso, estas matrices se restaurarán en función de la semilla aleatoria fija del argumento projection_seed. 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).

TinyLoRA tiene actualmente las siguientes restricciones:

  • Solo se admiten las capas nn.Linear, nn.Embedding y transformers.pytorch_utils.Conv1D.

El resumen del artículo es:

Investigaciones recientes han demostrado que los modelos de lenguaje pueden aprender a razonar, a menudo mediante aprendizaje por refuerzo. Algunos trabajos incluso entrenan parametrizaciones de bajo rango para el razonamiento, pero el LoRA convencional no puede escalar por debajo de la dimensión del modelo. Cuestionamos si incluso el LoRA con rank=1 es necesario para aprender a razonar y proponemos TinyLoRA, un método para escalar adaptadores de bajo rango a tamaños tan pequeños como un solo parámetro. Dentro de nuestra nueva parametrización, somos capaces de entrenar el tamaño de 8B parámetros de Qwen2.5 hasta una precisión del 91% en GSM8K con solo 13 parámetros entrenados en bf16 (26 bytes en total). Descubrimos que esta tendencia se mantiene en general: somos capaces de recuperar el 90% de las mejoras de rendimiento mientras entrenamos 1000 veces menos parámetros en una serie de benchmarks más difíciles de aprendizaje para razonar, como AIME, AMC y MATH500. Notablemente, solo podemos lograr un rendimiento tan fuerte con RL: los modelos entrenados usando SFT requieren actualizaciones 100-1000 veces más grandes para alcanzar el mismo rendimiento.

Resumen de las pruebas de rendimiento

API

TinyLoraConfig

clase peft.TinyLoraConfig

< >

( 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 = 2u: int = 64weight_tying: float = 0.0projection_seed: int = 42save_projection: bool = Trueinit_v_bound: float = 0.02target_modules: Optional[Union[list[str], str]] = Nonetinylora_dropout: float = 0.0fan_in_fan_out: bool = Falsebias: str = 'none'modules_to_save: Optional[list[str]] = Noneinit_weights: Union[bool, str] = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = None )

Parámetros

  • r (int, opcional, valor predeterminado 2) — Rango SVD para la descomposición congelada U, Sigma, V. El paper recomienda r=2.
  • u (int, opcional, valor predeterminado 64) — Dimensión del vector entrenable por grupo. Esto controla la expresividad de la adaptación. Puede ser tan baja como 1-13 para una eficiencia extrema de parámetros.
  • weight_tying (float, opcional, valor predeterminado 0.0) — Grado de vinculación de pesos entre los módulos objetivo, expresado como una proporción entre 0.0 y 1.0. Controla cuántos módulos comparten el mismo vector v entrenable. 0.0 significa que no hay compartición (cada módulo tiene su propio v). 1.0 significa compartición total (todos los módulos comparten un único v). Los valores intermedios producen una compartición parcial.
  • projection_seed (int, opcional, valor predeterminado 42) — Semilla aleatoria para generar las matrices de proyección fijas P.
  • save_projection (bool, opcional, valor predeterminado True) — Si se deben guardar los tensores de proyección P en el state dict. Si es False, se regenerarán a partir de la semilla al cargar.
  • init_v_bound (float, opcional, valor predeterminado 0.02) — Límite de inicialización uniforme para el vector v entrenable. Los valores se inicializan en [-init_v_bound, init_v_bound].
  • target_modules (Union[List[str], str], opcional) — Los nombres de los módulos a los que se aplicará TinyLoRA. Puede ser una lista de nombres de módulos (p. ej. ['q_proj', 'v_proj']), un patrón de expresión regular (p. ej. '.*decoder.*(q|v)_proj$') o la palabra clave especial "all-linear" para dirigirse a todos los módulos lineales. Solo se admiten las capas nn.Linear, nn.Embedding y transformers.pytorch_utils.Conv1D.
  • tinylora_dropout (float, opcional, valor predeterminado 0.0) — La probabilidad de dropout para las capas de TinyLoRA.
  • fan_in_fan_out (bool, opcional, valor predeterminado False) — 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).
  • bias (str, opcional, valor predeterminado "none") — Tipo de sesgo para TinyLoRA. Puede ser ‘none’, ‘all’ o ‘tinylora_only’.
  • modules_to_save (List[str], opcional) — Lista de módulos, aparte de las capas TinyLoRA, que se configurarán como entrenables y se guardarán.
  • init_weights (bool | Literal["uniform"], opcional, valor predeterminado True) — Cómo inicializar el vector entrenable v. Si se pasa True (predeterminado), v se inicializa a ceros, lo que convierte al adaptador en una operación sin efecto (operación identidad). Si se pasa "uniform", v se inicializa con valores aleatorios uniformes en [-init_v_bound, init_v_bound]. Si se pasa False, v se deja sin inicializar (para casos de uso avanzados).
  • layers_to_transform (Union[List[int], int], opcional) — Los índices de las capas a transformar. Si se especifica, solo estas capas se adaptarán.
  • layers_pattern (Optional[Union[List[str], str]], opcional) — El nombre del patrón de capas, utilizado solo si layers_to_transform es diferente de None.

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

TinyLoRA es un método de ajuste fino extremadamente eficiente en parámetros basado en el artículo “Learning to Reason in 13 Parameters” (arXiv:2602.04118). Utiliza la descomposición SVD de pesos congelados y proyecta un vector entrenable diminuto a través de tensores aleatorios fijos.

Artículo: https://arxiv.org/abs/2602.04118

Ejemplo:

from peft import get_peft_model, TinyLoraConfig

config = TinyLoraConfig(
    r=2,  # SVD rank (paper recommends 2)
    u=64,  # Trainable vector dimension
    weight_tying=0.0,  # No weight tying (0.0 = none, 1.0 = full)
    target_modules=["q_proj", "v_proj"],
    projection_seed=42,
)
model = get_peft_model(base_model, config)

TinyLoraModel

clase peft.TinyLoraModel

< >

( modelconfigadapter_namelow_cpu_mem_usage = False**kwargs ) → torch.nn.Module

Parámetros

  • model (PreTrainedModel) — El modelo que se va a adaptar.
  • config (TinyLoraConfig) — La configuración del modelo TinyLoRA.
  • adapter_name (str) — El nombre del adaptador, por defecto es "default".
  • low_cpu_mem_usage (bool, opcional, valor predeterminado False) — Crea pesos de adaptador vacíos en el dispositivo meta. Útil para acelerar el proceso de carga.

Devuelve

torch.nn.Module

El modelo TinyLoRA.

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

TinyLoRA es un método de ajuste fino extremadamente eficiente en parámetros que utiliza la descomposición SVD de pesos congelados y proyecta un vector entrenable diminuto a través de tensores aleatorios fijos. Basado en el artículo “Learning to Reason in 13 Parameters” (arXiv:2602.04118).

Ejemplo:

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

>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = TinyLoraConfig(r=2, u=64, target_modules=["q_proj", "v_proj"])
>>> model = get_peft_model(base_model, config)

Atributos:

delete_adapter

< >

( adapter_name: str )

Eliminar un adaptador y limpiar los parámetros compartidos a nivel de modelo v.

Update on GitHub

←Super-Tuning UniLoRA→