PaCA: Adaptación de Conexión Parcial

PaCA (ICLR 2025) es un método PEFT que se centra en la velocidad de entrenamiento y la memoria de activación. Ajusta finamente r columnas de entrada seleccionadas aleatoriamente (“conexiones parciales”) de cada peso preentrenado objetivo. Los únicos parámetros entrenables son las actualizaciones de estas columnas; a diferencia de LoRA, PaCA no añade matrices adicionales de bajo rango.

Métodos como LoRA ejecutan una rama de bajo rango junto a cada capa preentrenada. La rama requiere pocos FLOPs, pero se ejecuta de forma secuencial con la capa preentrenada y conserva su propia copia de la activación de entrada para la pasada inversa. PaCA evita ambas cosas:

• Un GEMM por capa. Las columnas adaptadas se escriben en el peso preentrenado justo antes de su matmul y se restauran justo después, de modo que el paso hacia adelante y el paso hacia atrás ejecutan cada uno un único matmul, exactamente como la capa base congelada.
• Activaciones parciales. El gradiente de las columnas adaptadas solo depende de los r canales de entrada correspondientes, por lo que solo se guardan esos para la pasada inversa en lugar de la entrada completa.

En cuanto a los pesos resultantes, un adaptador PaCA es equivalente a un adaptador LoRA de rango r cuya matriz A es un selector de columnas fijo: W' = W + delta @ S, donde S selecciona las r columnas. Por lo tanto, se puede convertir en un adaptador LoRA de rango r sin pérdida mediante convert_to_lora(), por ejemplo, para servirlo con una pila de inferencia LoRA.

Cuándo usar PaCA:

• Desea una precisión a nivel de LoRA, pero con pasos de ajuste fino más rápidos y menor memoria de activación, por ejemplo, para ajustar secuencias más largas o lotes más grandes en la misma GPU.
• Desea un adaptador que se fusione exactamente en los pesos base (la actualización es una actualización de columna simple).

Restricciones actuales:

• Solo se admiten capas nn.Linear (incluidas las capas lineales cuantizadas).
• PaCA ejecuta el matmul en lugar de llamar al forward de la capa base, por lo que los hooks de forward registrados en la capa base no se invocan (se emite una advertencia). Registra los hooks en la capa PaCA.
• No se admiten lotes de adaptadores mixtos (argumento adapter_names).
• El entrenamiento con pesos fragmentados (FSDP, DeepSpeed ZeRO-3) aún no se ha probado.
• torch.compile es compatible: durante la compilación, el intercambio de columnas, el matmul y la restauración se ejecutan como operaciones personalizadas opacas (torch.ops.peft.paca_linear_forward/_backward), por lo que el compilador no copia los pesos base. Esto requiere torch.library.custom_op (PyTorch >= 2.4); de lo contrario, se traza la implementación eager.
• paca_alpha / r escala la actualización de la columna y, por lo tanto, actúa como un multiplicador de la tasa de aprendizaje efectiva.
• Para la inferencia, fusiona el adaptador (merge_and_unload()); el forward sin fusionar sigue intercambiando las columnas en cada llamada.

Uso

from transformers import AutoModelForCausalLM
from peft import PacaConfig, get_peft_model

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-3B")
config = PacaConfig(r=16, paca_alpha=16, target_modules="all-linear", random_seed=0)
model = get_peft_model(model, config)
model.print_trainable_parameters()

Por defecto, cada capa objetivo realiza el ajuste fino de r columnas seleccionadas aleatoriamente; en el artículo, esto rindió a la par que seleccionar las columnas por norma de peso o por gradientes acumulados. Para elegir las columnas usted mismo, por ejemplo para probar otra estrategia de selección o para usar un número diferente de columnas por capa, pase paca_indices_pattern. Sus claves son nombres de capas o expresiones regulares, como en rank_pattern de LoRA:

config = PacaConfig(
    r=16,
    paca_alpha=16,
    target_modules=["q_proj", "v_proj"],
    paca_indices_pattern={"layers.0.self_attn.q_proj": [0, 2, 4, 6], "layers.1.self_attn.v_proj": list(range(32))},
)

Las capas que coinciden con una clave ajustan las columnas dadas, mientras que todas las demás capas objetivo seleccionan r columnas aleatorias. La escala es paca_alpha / r con el r de la configuración en cada capa, por lo que paca_alpha significa lo mismo para todas las capas.

El resumen del artículo es:

Los algoritmos de ajuste fino eficiente en parámetros (PEFT) anteriores reducen el uso de memoria y los costos computacionales del ajuste fino de modelos de redes neuronales grandes al entrenar solo unos pocos parámetros de adaptador adicionales, en lugar de todo el modelo. Sin embargo, la reducción de costos computacionales debido a PEFT no se traduce necesariamente en una reducción del tiempo de entrenamiento; aunque los costos computacionales de las capas de adaptador son mucho menores que los de las capas preentrenadas, es bien sabido que esos dos tipos de capas se procesan secuencialmente en las GPU, lo que resulta en una sobrecarga de latencia significativa. LoRA y sus variantes evitan esta sobrecarga de latencia fusionando las matrices de adaptador de bajo rango con los pesos preentrenados durante la inferencia. Sin embargo, esas capas no pueden fusionarse durante el entrenamiento, ya que los pesos preentrenados deben permanecer congelados mientras las matrices de adaptador de bajo rango se actualizan continuamente a lo largo del entrenamiento. Además, LoRA y sus variantes no reducen la memoria de activaciones, ya que la primera matriz de adaptador de bajo rango aún requiere las activaciones de entrada a los pesos preentrenados para calcular los gradientes de los pesos. Para mitigar este problema, proponemos la Adaptación de Conexiones Parciales (PaCA), que ajusta finamente conexiones parciales seleccionadas aleatoriamente dentro de los pesos preentrenados en lugar de introducir capas de adaptador en el modelo. PaCA no solo mejora la velocidad de entrenamiento al eliminar la sobrecarga de tiempo debida al procesamiento secuencial de las capas de adaptador y preentrenadas, sino que también reduce la memoria de activaciones, ya que solo se necesitan almacenar activaciones parciales, en lugar de activaciones completas, para el cálculo de gradientes. En comparación con LoRA, PaCA reduce el tiempo de entrenamiento en un 22% y el uso total de memoria en un 16%, manteniendo una precisión comparable en diversos escenarios de ajuste fino, como el ajuste fino en el conjunto de datos MMLU y el ajuste de instrucciones en el conjunto de datos Oasst1. PaCA también puede combinarse con cuantización, lo que permite el ajuste fino de modelos grandes como LLaMA3.1-70B. Además, PaCA permite el entrenamiento con secuencias un 23% más largas y mejora el rendimiento en un 16% tanto en la GPU NVIDIA A100 como en la HPU INTEL Gaudi2 en comparación con LoRA.

Resumen de las pruebas de rendimiento

API

PacaConfig

PacaModel

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

>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = PacaConfig(r=16, paca_alpha=16, target_modules="all-linear")
>>> model = get_peft_model(base_model, config)