PEFT documentation
OSF (Orthogonal Subspace Fine-tuning)
OSF (Orthogonal Subspace Fine-tuning)
El ajuste fino en subespacios ortogonales (OSF) es un método PEFT diseñado para el aprendizaje continuo que restringe las actualizaciones de parámetros para que sean ortogonales a las direcciones previamente importantes. Este enfoque permite el ajuste fino completo mientras previene el olvido catastrófico, sin necesidad de parámetros adicionales ni de almacenar gradientes anteriores.
El resumen del artículo es:
El aprendizaje continuo en modelos de lenguaje de gran escala (LLM) es propenso al olvido catastrófico, donde la adaptación a nuevas tareas degrada significativamente el rendimiento en las previamente aprendidas. Los métodos existentes suelen depender de actualizaciones de bajo rango y eficientes en parámetros que limitan la expresividad del modelo e introducen parámetros adicionales por tarea, lo que genera problemas de escalabilidad. Para abordar estas limitaciones, proponemos un enfoque novedoso de ajuste fino completo continuo que aprovecha la descomposición en valores singulares (SVD) adaptativa. Nuestro método identifica dinámicamente subespacios de parámetros de bajo rango específicos de cada tarea y restringe las actualizaciones para que sean ortogonales a las direcciones críticas asociadas con tareas anteriores, minimizando así eficazmente la interferencia sin sobrecarga de parámetros adicionales ni almacenamiento de gradientes de tareas previas. Evaluamos exhaustivamente nuestro enfoque en benchmarks estándar de aprendizaje continuo utilizando tanto modelos codificador-decodificador (T5-Large) como solo decodificador (LLaMA-2 7B), abarcando diversas tareas que incluyen clasificación, generación y razonamiento. Empíricamente, nuestro método logra resultados de última generación, con una precisión media hasta un 7% superior a líneas base recientes como O-LoRA, y notablemente mantiene las capacidades lingüísticas generales del modelo, la precisión en el seguimiento de instrucciones y la seguridad a lo largo del proceso de aprendizaje continuo, reduciendo el olvido a niveles casi insignificantes. Nuestro marco de SVD adaptativa equilibra eficazmente la plasticidad del modelo y la retención de conocimiento, proporcionando una solución práctica, con fundamento teórico y escalable computacionalmente para escenarios de aprendizaje continuo en modelos de lenguaje de gran escala.
Cómo funciona OSF
OSF descompone cada matriz de pesos en componentes de alto rango (congelados) y de bajo rango (entrenables) mediante SVD:
W = U_high * S_high * V_high^T + U_low * S_low * V_low^TDonde:
U_high, S_high, V_high: Preserva las direcciones importantes de tareas anteriores (congeladas)U_low, S_low, V_low: Permiten la adaptación a nuevas tareas (entrenables)
Durante el entrenamiento, los gradientes se proyectan para ser ortogonales al subespacio de alto rango, lo que garantiza que las actualizaciones no interfieran con el conocimiento aprendido previamente.
Uso básico
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import OSFConfig, get_peft_model
# Load base model
model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
# Configure OSF
config = OSFConfig(
target_modules=["q_proj", "v_proj"], # Target attention layers
effective_rank=8, # Default rank for decomposition
rank_pattern={"q_proj": 16} # Override rank for specific modules
)
# Apply OSF
model = get_peft_model(model, config)
# Train as usual
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
inputs = tokenizer("Hello world", return_tensors="pt", padding=True)
loss = model(**inputs, labels=inputs.input_ids).loss
loss.backward()
optimizer.step()
optimizer.zero_grad()Opciones de configuración
Módulos objetivo
Puedes especificar los módulos objetivo de varias formas:
# Specific module names
config = OSFConfig(target_modules=["q_proj", "k_proj", "v_proj", "o_proj"])
# All linear layers
config = OSFConfig(target_modules="all-linear")
# Model-specific defaults (automatically detected)
config = OSFConfig() # Uses model-appropriate defaultsConfiguración de rango efectivo
Controla los subespacios preservados/entrenables:
# Global preserved rank (applies to all target modules)
config = OSFConfig(effective_rank=16) # preserves top-16 singular directions; trains the rest
# Automatic preserved rank (50% of the smaller matrix dimension per target)
config = OSFConfig(effective_rank=None)
# Per-module preserved-rank overrides
config = OSFConfig(
effective_rank=8,
rank_pattern={
"q_proj": 16, # Higher rank for query projection
"gate_proj": 4 # Lower rank for gate projection
}
)
# Fractional preserved rank is supported (interpreted per-target as fraction * min_dim)
config = OSFConfig(effective_rank=0.8) # preserve 80% of min_dim; train remaining 20%
config = OSFConfig(rank_pattern={"q_proj": 0.5}) # preserve 50% on q_proj, others use global/defaultNota: el effective_rank de OSF es el rango conservado (congelado), no el rango entrenable. El rango entrenable es igual a min(weight.shape) - effective_rank. Esto difiere de la r de LoRA, que especifica directamente el rango entrenable.
Consejos de entrenamiento para el aprendizaje continuo
Aprendizaje secuencial de tareas
OSF está diseñado específicamente para tareas de aprendizaje secuenciales. Entre tareas, recalcule el SVD para que el subespacio preservado refleje los pesos más recientes. Una forma sencilla es volver a envolver el modelo base actualizado con OSF:
# Task 1: train on domain A with initial preserved subspace
r = 8 # initial effective rank to preserve
model = get_peft_model(base_model, OSFConfig(effective_rank=r))
train_task(model, task_1_data)
# Task 2: recompute SVD on updated weights and increase preserved subspace
base_model = model.unload() # unwrap base model without assuming internals
r += 4 # grow preserved subspace to include Task 1 knowledge
model = get_peft_model(base_model, OSFConfig(effective_rank=r))
train_task(model, task_2_data)
# Task 3: recompute again and expand preserved subspace further
base_model = model.unload()
r += 4
model = get_peft_model(base_model, OSFConfig(effective_rank=r))
train_task(model, task_3_data)Asignación de presupuesto para secuencias de tareas
Al entrenar en una secuencia conocida de n tareas, una estrategia eficaz es asignar progresivamente la capacidad del modelo para equilibrar el aprendizaje de nuevas tareas con la preservación del conocimiento previo:
- Tarea 1: Usar la capacidad completa (entrenar todo)
- Tarea 2: Congelar 1/n de la capacidad del modelo y entrenar la capacidad restante (n-1)/n
- Tarea 3: Congelar 2/n de la capacidad del modelo y entrenar la capacidad restante (n-2)/n
- Tarea n: Congelar (n-1)/n de la capacidad del modelo, usar 1/n de la capacidad para la tarea final
Este enfoque garantiza que cada tarea reciba una capacidad de aprendizaje adecuada, al tiempo que se preserva progresivamente más conocimiento de las tareas anteriores.
# Example: 4-task sequence with progressive budget allocation
n_tasks = 4
max_preserved_rank = 512 # Upper bound for preserved rank per target (heuristic)
for task_id in range(n_tasks):
# Freeze increases over time; trainable capacity shrinks
preserved_fraction = (task_id + 1) / n_tasks
preserved_rank = int(max_preserved_rank * preserved_fraction)
config = OSFConfig(
target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
effective_rank=preserved_rank,
)
print(
f"Task {task_id + 1}: Preserving rank {preserved_rank} "
f"({preserved_fraction:.1%} of max_preserved_rank - {max_preserved_rank} frozen); trainable rank = min_dim - preserved_rank"
)
model = get_peft_model(base_model, config)
train_task(model, task_data[task_id])Buenas prácticas
- Selección efectiva del rango: comience con
effective_rank=None(automáticamente establece el rango al 50 % de la dimensión de peso más pequeña por módulo objetivo) y ajústelo según la complejidad de la tarea - Tasa de aprendizaje: Utilice tasas de aprendizaje más pequeñas (1e-5 a 1e-4) en comparación con el ajuste fino estándar
- Importancia de la tarea: use
rank_patternpara asignar más capacidad a los módulos críticos - Arquitectura del modelo: OSF funciona mejor con arquitecturas de transformadores que tienen una separación clara entre la atención y el MLP
- Planificación de capacidad: Para secuencias de tareas conocidas, use la asignación progresiva de presupuesto (congelación de 1/n, 2/n, …, (n-1)/n) para equilibrar la plasticidad y la estabilidad
Consideraciones de memoria
OSF modifica los pesos in-place y no añade parámetros, lo que lo hace eficiente en memoria:
# Memory usage remains close to base model
print(f"Base model parameters: {base_model.num_parameters():,}")
print(f"OSF model parameters: {osf_model.num_parameters():,}") # Similar countUso avanzado
Módulos de destino personalizados
Para modelos con arquitecturas no estándar:
config = OSFConfig(
target_modules=["dense", "intermediate.dense"], # Custom layer names
effective_rank=12,
rank_pattern={"dense": 8, "intermediate.dense": 16}
)Integración con otros métodos
OSF puede combinarse con otras técnicas:
# Use with gradient checkpointing for memory efficiency
# note: use `model.gradient_checkpointing_enable()` for older Transformers versions
model.activation_checkpointing_enable()
# Apply weight decay selectively (regularizes low-rank factors to limit drift/overfitting in continual updates; keep small)
optimizer = torch.optim.AdamW([
{"params": [p for n, p in model.named_parameters() if "U_low" in n], "weight_decay": 0.01},
{"params": [p for n, p in model.named_parameters() if "S_low" in n], "weight_decay": 0.001},
{"params": [p for n, p in model.named_parameters() if "V_low" in n], "weight_decay": 0.01},
], lr=1e-4)Resumen de las pruebas de rendimiento
API
OSFConfig
clase peft.OSFConfig
< 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 = Falseeffective_rank: Optional[Union[int, float]] = Nonetarget_modules: Optional[Union[list[str], str]] = Nonerank_pattern: Optional[dict[str, Union[int, float]]] = Noneinit_weights: Optional[bool] = Truemodules_to_save: Optional[list[str]] = Nonetarget_svd_config: Optional[dict[str, int]] = None )
Parámetros
- effective_rank (int o float, opcional) —
Rango SVD conservado (subespacio “alto”). Las
effective_rankprimeras direcciones singulares se congelan y se conservan entre tareas; las dimensiones restantes forman el subespacio de bajo rango entrenable. Si es None, el valor predeterminado es el 50 % de la dimensión de peso más pequeña de cada módulo objetivo. Nota: Esto difiere de la r de LoRA (rango entrenable). En OSF, el rango entrenable es min(weight.shape) - effective_rank. - target_modules (Union[list[str], str], opcional) — Los nombres de los módulos a los que se aplicará OSF. Puede ser una lista de nombres de módulos o “all-linear”.
- rank_pattern (dict[str, int|float], opcional) — Un diccionario de patrones de expresiones regulares para sobrescribir effective_rank en módulos específicos. Los valores pueden ser enteros absolutos o fracciones en (0, 1], interpretadas como una fracción de la dimensión de la matriz más pequeña por objetivo.
Configuración para el ajuste fino en subespacios ortogonales (OSF).
OSFModel
clase peft.OSFModel
< source >( modelconfigadapter_namelow_cpu_mem_usage: bool = Falsestate_dict: dict[str, torch.Tensor] | None = None )
Un afinador mínimo que implementa el ajuste fino en subespacios ortogonales.
Funciones de utilidad
Descomposición de pesos
Realiza una SVD de weight y divídela en partes congeladas y entrenables.
Proyección del gradiente
Proyecte los gradientes de U_low y V_low para que sean ortogonales al espacio de alto rango.