PEFT documentation
AdaMSS
AdaMSS
AdaMSS (AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning) es un método de ajuste fino eficiente en parámetros que descompone las matrices de pesos mediante SVD y agrupa el espacio descompuesto en múltiples subespacios entrenables. Cada subespacio aprende actualizaciones independientes de bajo rango mientras los pesos originales permanecen congelados. AdaMSS también admite la Asignación Adaptativa de Subespacios (ASA), que poda dinámicamente los subespacios menos importantes durante el entrenamiento basándose en la información del gradiente.
El resumen del artículo es:
Proponemos AdaMSS, un enfoque adaptativo de múltiples subespacios para el ajuste fino eficiente en parámetros de modelos grandes. A diferencia de los métodos tradicionales de ajuste fino eficiente en parámetros que operan dentro de un único subespacio grande de los pesos de la red, AdaMSS aprovecha la segmentación de subespacios para obtener múltiples subespacios más pequeños y reduce de forma adaptativa el número de parámetros entrenables durante el entrenamiento, actualizando en última instancia solo aquellos asociados con un pequeño subconjunto de subespacios más relevantes para la tarea descendente objetivo. Al utilizar la representación de menor rango, AdaMSS logra una expresividad más compacta y un ajuste más fino de los parámetros del modelo. Los análisis teóricos demuestran que AdaMSS tiene una mejor garantía de generalización que LoRA, PiSSA y otros métodos basados en bajo rango de un solo subespacio. Experimentos extensos en tareas de clasificación de imágenes, comprensión del lenguaje natural y generación de lenguaje natural muestran que AdaMSS logra un rendimiento comparable al del ajuste fino completo y supera a otros métodos de ajuste fino eficiente en parámetros en la mayoría de los casos, todo ello requiriendo menos parámetros entrenables. Notablemente, en el modelo ViT-Large, AdaMSS logra una precisión media 4,7 % superior a la de LoRA en siete tareas, utilizando solo el 15,4 % de los parámetros entrenables. En RoBERTa-Large, AdaMSS supera a PiSSA en un 7 % de precisión media en seis tareas, mientras reduce el número de parámetros entrenables en aproximadamente un 94,4 %. Estos resultados demuestran la efectividad de AdaMSS en el ajuste fino eficiente en parámetros. El código de AdaMSS está disponible en https: //github.com/jzheng20/AdaMSS.
AdaMSS tiene actualmente las siguientes restricciones:
- Solo se admiten capas
nn.Linear. - Requiere scikit-learn para el paso de agrupamiento KMeans.
Si estas restricciones no se ajustan a su caso de uso, considere otros métodos.
Resumen de las pruebas de rendimiento
API
AdamssConfig
clase peft.AdamssConfig
< 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 = 100num_subspaces: int = 5subspace_rank: int = 1target_modules: Optional[Union[list[str], str]] = Noneinit_weights: Optional[Literal['orthogonal']] = 'orthogonal'modules_to_save: Optional[list[str]] = Nonelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Noneuse_asa: bool = Falseasa_target_subspaces: int = 50init_warmup: int = 50final_warmup: int = 1000mask_interval: int = 100asa_importance_beta: float = 0.85asa_uncertainty_beta: float = 0.85asa_schedule_exponent: float = 3.0use_dynamic_rank: bool = Falsesvd_threshold: float = 0.1random_seed: int = 0 )
Parámetros
- r (
int) — Rango total para la descomposición SVD (denotado como R en el artículo). Esto determina cuántos vectores singulares se utilizan para representar la matriz de pesos antes del agrupamiento. Valores más altos capturan más información de los pesos originales, pero requieren más cómputo y memoria. Valores más bajos proporcionan una regularización más fuerte. Los valores típicos van de 50 a 500. El valor predeterminado es 100. - num_subspaces (
int) — Número de subespacios (K) en los que agrupar el espacio descompuesto por SVD. Cada subespacio aprende actualizaciones de bajo rango independientes. Aumentar este valor permite una adaptación más detallada, pero aumenta el número de parámetros entrenables de forma proporcional. Al usar ASA (Adaptive Subspace Allocation), este parámetro determina el número inicial de subespacios antes del recorte. Los valores típicos van de 3 a 10. El valor predeterminado es 5. - subspace_rank (
int) — El rango (r_i) para cada subespacio entrenable. Esto controla la capacidad de cada subespacio para aprender adaptaciones. Valores más altos aumentan la expresividad, pero también aumentan los parámetros entrenables. El total de parámetros entrenables escala como O(num_subspaces subspace_rank (in_dim + out_dim) / num_subspaces). Para la mayoría de las tareas, los valores de 1 a 4 funcionan bien. El valor predeterminado es 1. - target_modules (
Optional[Union[list[str], str]]) — Los nombres de los módulos a los que se aplicará AdaMSS. Si se especifica, solo se adaptarán estos módulos. Puede ser una lista de nombres exactos de módulos o una expresión regular. Por ejemplo,['q_proj', 'v_proj']para las capas de atención, o'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'para coincidencias con expresiones regulares. - modules_to_save (
Optional[list[str]]) — Lista de módulos, aparte de las capas AdaMSS, que se configurarán como entrenables y se guardarán en el checkpoint final. Estos módulos se ajustarán por completo (no solo de bajo rango). Es obligatorio para cabezas inicializadas aleatoriamente comoclassifieroscoreen tareas de clasificación. - init_weights (
Literal["orthogonal"]) — Método de inicialización para los pesos entrenables de AdaMSS. Actualmente solo se admite “orthogonal”, que utiliza inicialización ortogonal para las matrices B (proyección de salida). Las matrices A se inicializan a cero para asegurar que el modelo comience desde los pesos preentrenados. Establezca None para omitir la inicialización al cargar desde un punto de control. El valor predeterminado es “orthogonal”. - layers_to_transform (
Optional[Union[list[int], int]]) — Índices de capas específicos a los que aplicar AdaMSS. Si se especifica, solo estas capas se adaptarán, lo cual es útil para experimentar con qué capas se benefician más de la adaptación. Puede ser un solo entero o una lista de enteros. - layers_pattern (
Optional[Union[list[str], str]]) — Patrón para coincidir con los nombres de capas cuando se especificalayers_to_transform. Se utiliza para extraer los índices de capas de los nombres de módulos que no siguen el patrón común. - use_asa (
bool) — Si se habilita la Adaptive Subspace Allocation (ASA). Cuando está habilitada, ASA recorta dinámicamente los subespacios menos importantes durante el entrenamiento en función de la información del gradiente, reduciendo el número efectivo de parámetros mientras mantiene el rendimiento. Requiere integración con un callback de entrenamiento. El valor predeterminado es False. - asa_target_subspaces (
int) — Número total objetivo de subespacios activos en todas las capas cuando ASA está habilitado. ASA recortará progresivamente los subespacios hasta alcanzar este objetivo. Valores más bajos resultan en un recorte más agresivo y en menos parámetros entrenables. Debe ser menor quenum_subspaces * num_target_modules. Los valores típicos van de 20 a 100 dependiendo del tamaño del modelo. El valor predeterminado es 50. Debe ser un entero positivo cuandouse_asa=True. - init_warmup (
int) — Número de pasos de entrenamiento a esperar antes de iniciar el recorte ASA. Durante el calentamiento, todos los subespacios permanecen activos para permitir que las puntuaciones de importancia se estabilicen. Valores más altos dan más tiempo para una estimación precisa de la importancia pero retrasan el recorte. Los valores típicos van de 50 a 200. El valor predeterminado es 50. Debe ser menor quefinal_warmupcuandouse_asa=True. - final_warmup (
int) — Paso de entrenamiento en el que ASA completa la poda y alcanzaasa_target_subspacessubespacios activos. La poda se distribuye entreinit_warmupyfinal_warmup. Debe configurarse en función de los pasos totales de entrenamiento; típicamente entre 1/3 y 1/2 de los pasos totales de entrenamiento. El valor predeterminado es 1000. Debe ser mayor queinit_warmupcuandouse_asa=True. - mask_interval (
int) — Número de pasos de entrenamiento entre actualizaciones de la máscara ASA. Valores más bajos permiten una adaptación más frecuente pero aumentan la sobrecarga. Valores más altos proporcionan estimaciones de importancia más estables entre actualizaciones. Los valores típicos van de 50 a 200. El valor predeterminado es 100. Debe ser un entero positivo cuandouse_asa=True. - asa_importance_beta (
float) — Coeficiente de media móvil exponencial (EMA) para suavizar las puntuaciones de importancia de subespacios. Valores más altos (cercanos a 1.0) otorgan más peso a la importancia histórica, proporcionando estabilidad. Valores más bajos hacen que la importancia sea más receptiva a los gradientes recientes. Los valores típicos van de 0.8 a 0.95. El valor predeterminado es 0.85. - asa_uncertainty_beta (
float) — Coeficiente EMA para suavizar las estimaciones de incertidumbre de importancia. Controla la velocidad a la que la incertidumbre se adapta a la varianza del gradiente. Al igual que asa_importance_beta, los valores más altos proporcionan estimaciones más estables. Los valores típicos van de 0.8 a 0.95. El valor predeterminado es 0.85. - asa_schedule_exponent (
float) — Exponente de la programación que controla la tasa de decaimiento desde los subespacios totales hastaasa_target_subspacesdurante el calentamiento de ASA. Los valores más altos resultan en un recorte inicial más rápido (reducción temprana más agresiva), mientras que los valores más bajos proporcionan un decaimiento más gradual, similar a una línea recta. La fórmula es: current_active_subspaces = asa_target_subspaces + (asa_total_subspaces - asa_target_subspaces) * (progress ** exponent). Los valores típicos van desde 1.0 (lineal) hasta 5.0 (agresivo). El valor predeterminado es 3.0. Debe ser un número positivo cuandouse_asa=True(un exponente cero o negativo degenera la programación en una operación permanente sin efecto o, una vez queprogressalcanza exactamente 0.0, lanza unZeroDivisionError). - use_dynamic_rank (
bool) — Si se deben determinar dinámicamente los rangos de los subespacios en función de las magnitudes de los valores singulares. Cuando es True, el rango de cada subespacio se determina contando los valores singulares que superan un umbral, lo que permite que diferentes subespacios tengan rangos efectivos distintos. Cuando es False, todos los subespacios utilizan elsubspace_rankfijo. El valor predeterminado es False. - svd_threshold (
float) — Proporción de umbral para la selección dinámica de rango, solo se utiliza cuandouse_dynamic_rank=True. Un valor singular se considera significativo si superathreshold * max_singular_value. Valores más altos resultan en rangos efectivos más bajos (truncamiento más agresivo). Los valores típicos van de 0.05 a 0.2. El valor predeterminado es 0.1 (10% del máximo).
Clase de configuración para el método Adamss (Adaptive Multi-Subspaces).
AdaMSS es un método de ajuste fino eficiente en parámetros que descompone las matrices de pesos mediante SVD y agrupa el espacio descompuesto en múltiples subespacios entrenables. Aprende actualizaciones de bajo rango dentro de estos subespacios mientras mantiene los pesos originales congelados.
AdamssModel
clase peft.AdamssModel
< source >( modelconfigadapter_namelow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict] = None ) → torch.nn.Module
Crea un modelo Adamss (Adaptive Multi-Subspaces) a partir de un modelo preentrenado.
El método descompone las matrices de pesos mediante SVD y agrupa el espacio descompuesto en múltiples subespacios entrenables para el ajuste fino eficiente en parámetros.
Ejemplo:
>>> from transformers import AutoModelForImageClassification
>>> from peft import AdamssConfig, get_peft_model
>>> config = AdamssConfig(
... r=500,
... num_subspaces=5,
... target_modules=["query", "value"],
... )
>>> model = AutoModelForImageClassification.from_pretrained("google/vit-base-patch16-224")
>>> adamss_model = get_peft_model(model, config)Atributos:
- model (
~torch.nn.Module) — El modelo que se va a adaptar. - peft_config (AdamssConfig): La configuración del modelo Adamss.
update_and_allocate
< source >( global_step: int )
Actualizar las puntuaciones de importancia y aplicar la enmascaración ASA (si está habilitada).
Este método debe llamarse en cada paso de entrenamiento después de loss.backward() y antes de optimizer.zero_grad() cuando ASA está habilitado. Internamente:
- Acumula las puntuaciones de importancia mediante EMA en cada paso durante el período de calentamiento.
- En los intervalos de enmascarado, aplica el enmascarado global top-K y restablece la importancia.
Este es el único punto de entrada para ASA: usar AdamssAsaCallback con el Trainer de HuggingFace simplemente delega en este método. Para bucles de entrenamiento personalizados, llame directamente a este método en lugar de usar el callback.