PEFT documentation
AdaMSS
AdaMSS
AdaMSS (AdaMSS: Adaptive Multi-Subspace Approach for Parameter-Efficient Fine-Tuning) est une méthode de fine-tuning efficace en paramètres qui décompose les matrices de poids à l'aide de la SVD et regroupe l'espace décomposé en plusieurs sous-espaces entraînables. Chaque sous-espace apprend des mises à jour de faible rang indépendantes, tandis que les poids d'origine restent figés. AdaMSS prend également en charge l'allocation adaptative de sous-espaces (ASA), qui élimine dynamiquement les sous-espaces moins importants pendant l'entraînement en se basant sur les informations de gradient.
L'abstract de l'article est :
Nous proposons AdaMSS, une approche multi-sous-espaces adaptative pour l'ajustement fin efficace en paramètres de grands modèles. Contrairement aux méthodes traditionnelles d'ajustement fin efficace en paramètres qui opèrent au sein d'un grand sous-espace unique des poids du réseau, AdaMSS exploite la segmentation de sous-espaces pour obtenir plusieurs sous-espaces plus petits et réduit de manière adaptative le nombre de paramètres entraînables pendant l'entraînement, ne mettant finalement à jour que ceux associés à un petit sous-ensemble de sous-espaces les plus pertinents pour la tâche aval cible. En utilisant la représentation de plus faible rang, AdaMSS atteint une expressivité plus compacte et un ajustement plus fin des paramètres du modèle. Les analyses théoriques démontrent qu'AdaMSS offre de meilleures garanties de généralisation que LoRA, PiSSA et d'autres méthodes basées sur le bas rang à sous-espace unique. Des expériences étendues sur des tâches de classification d'images, de compréhension du langage naturel et de génération du langage naturel montrent qu'AdaMSS atteint des performances comparables à l'ajustement fin complet et surpasse d'autres méthodes d'ajustement fin efficace en paramètres dans la plupart des cas, tout en nécessitant moins de paramètres entraînables. Notamment, sur le modèle ViT-Large, AdaMSS atteint une précision moyenne supérieure de 4,7 % à celle de LoRA sur sept tâches, en n'utilisant que 15,4 % des paramètres entraînables. Sur RoBERTa-Large, AdaMSS surpasse PiSSA de 7 % en précision moyenne sur six tâches tout en réduisant le nombre de paramètres entraînables d'environ 94,4 %. Ces résultats démontrent l'efficacité d'AdaMSS dans l'ajustement fin efficace en paramètres. Le code d'AdaMSS est disponible à l'adresse https: //github.com/jzheng20/AdaMSS.
AdaMSS présente actuellement les contraintes suivantes :
- Seules les couches
nn.Linearsont prises en charge. - Nécessite scikit-learn pour l'étape de clustering KMeans.
Si ces contraintes ne conviennent pas à votre cas d’usage, envisagez plutôt d’autres méthodes.
Aperçu des benchmarks
API
AdamssConfig
classe 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 )
Paramètres
- r (
int) — Rang total pour la décomposition SVD (noté R dans l'article). Cette valeur détermine le nombre de vecteurs singuliers utilisés pour représenter la matrice de poids avant le regroupement. Des valeurs plus élevées capturent davantage d'informations des poids d'origine, mais nécessitent plus de calculs et de mémoire. Des valeurs plus basses offrent une régularisation plus forte. Les valeurs typiques vont de 50 à 500. La valeur par défaut est 100. - num_subspaces (
int) — Nombre de sous-espaces (K) dans lesquels regrouper l’espace décomposé par SVD. Chaque sous-espace apprend des mises à jour de rang faible indépendantes. Augmenter cette valeur permet une adaptation plus fine, mais augmente le nombre de paramètres entraînables de manière proportionnelle. Lors de l’utilisation d’ASA (Adaptive Subspace Allocation), cette valeur détermine le nombre initial de sous-espaces avant l’élagage. Les valeurs typiques vont de 3 à 10. La valeur par défaut est 5. - subspace_rank (
int) — Le rang (r_i) de chaque sous-espace entraînable. Ce paramètre contrôle la capacité de chaque sous-espace à apprendre des adaptations. Des valeurs plus élevées augmentent l'expressivité, mais aussi le nombre de paramètres entraînables. Le nombre total de paramètres entraînables évolue en O(num_subspaces subspace_rank (in_dim + out_dim) / num_subspaces). Pour la plupart des tâches, des valeurs comprises entre 1 et 4 fonctionnent bien. La valeur par défaut est 1. - target_modules (
Optional[Union[list[str], str]]) — Les noms des modules auxquels appliquer AdaMSS. Si spécifié, seuls ces modules seront adaptés. Peut être une liste de noms de modules exacts ou une expression régulière. Par exemple,['q_proj', 'v_proj']pour les couches d'attention, ou'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'pour la correspondance par expression régulière. - modules_to_save (
Optional[list[str]]) — Liste des modules, à l'exception des couches AdaMSS, à définir comme entraînables et à enregistrer dans le point de contrôle final. Ces modules seront entièrement affinés (et non seulement par rang faible). Requis pour les têtes initialisées aléatoirement commeclassifierouscoredans les tâches de classification. - init_weights (
Literal["orthogonal"]) — Méthode d'initialisation des poids entraînables d'AdaMSS. Actuellement, seule la valeur « orthogonal » est prise en charge, ce qui utilise une initialisation orthogonale pour les matrices B (projection de sortie). Les matrices A sont initialisées à zéro afin de garantir que le modèle démarre à partir des poids pré-entraînés. Définissez la valeur sur None pour ignorer l'initialisation lors du chargement depuis un point de contrôle. La valeur par défaut est « orthogonal ». - layers_to_transform (
Optional[Union[list[int], int]]) — Indices de couches spécifiques auxquels appliquer AdaMSS. Si spécifiés, seules ces couches seront adaptées, ce qui est utile pour expérimenter avec les couches qui bénéficient le plus de l'adaptation. Peut être un entier unique ou une liste d'entiers. - layers_pattern (
Optional[Union[list[str], str]]) — Motif à utiliser pour correspondre aux noms de couches lorsquelayers_to_transformest spécifié. Utilisé pour extraire les indices de couches à partir des noms de modules qui ne suivent pas le motif commun. - use_asa (
bool) — Indique s'il faut activer l'Adaptive Subspace Allocation (ASA). Lorsqu'elle est activée, l'ASA élimine dynamiquement les sous-espaces moins importants pendant l'entraînement en se basant sur les informations de gradient, réduisant ainsi le nombre effectif de paramètres tout en maintenant les performances. Nécessite une intégration avec un rappel d'entraînement. La valeur par défaut est False. - asa_target_subspaces (
int) — Nombre total cible de sous-espaces actifs sur toutes les couches lorsque ASA est activé. ASA élaguera progressivement les sous-espaces jusqu'à atteindre cette cible. Des valeurs plus faibles entraînent un élagage plus agressif et un nombre réduit de paramètres entraînables. Doit être inférieur ànum_subspaces * num_target_modules. Les valeurs typiques vont de 20 à 100 selon la taille du modèle. La valeur par défaut est 50. Doit être un entier positif lorsqueuse_asa=True. - init_warmup (
int) — Nombre d’étapes d’entraînement à attendre avant de démarrer la taille ASA. Pendant la phase de réchauffement, tous les sous-espaces restent actifs afin de permettre aux scores d’importance de se stabiliser. Des valeurs plus élevées laissent plus de temps pour une estimation précise de l’importance, mais retardent la taille. Les valeurs typiques vont de 50 à 200. La valeur par défaut est 50. Doit être inférieur àfinal_warmuplorsqueuse_asa=True. - final_warmup (
int) — Étape d'entraînement à laquelle ASA achève l'élagage et atteintasa_target_subspacessous-espaces actifs. L'élagage est réparti entreinit_warmupetfinal_warmup. Cette valeur doit être définie en fonction du nombre total d'étapes d'entraînement ; elle représente généralement 1/3 à 1/2 du nombre total d'étapes. La valeur par défaut est 1000. Elle doit être supérieure àinit_warmuplorsqueuse_asa=True. - mask_interval (
int) — Nombre d’étapes d’entraînement entre les mises à jour du masque ASA. Des valeurs plus faibles permettent une adaptation plus fréquente mais augmentent la surcharge. Des valeurs plus élevées fournissent des estimations d’importance plus stables entre les mises à jour. Les valeurs typiques vont de 50 à 200. La valeur par défaut est 100. Doit être un entier positif lorsqueuse_asa=True. - asa_importance_beta (
float) — Coefficient de moyenne mobile exponentielle (EMA) pour le lissage des scores d'importance des sous-espaces. Des valeurs plus élevées (proches de 1,0) accordent plus de poids à l'importance historique, offrant ainsi une meilleure stabilité. Des valeurs plus basses rendent l'importance plus réactive aux gradients récents. Les valeurs typiques se situent entre 0,8 et 0,95. La valeur par défaut est 0,85. - asa_uncertainty_beta (
float) — Coefficient EMA pour le lissage des estimations d'incertitude d'importance. Contrôle la vitesse à laquelle l'incertitude s'adapte à la variance du gradient. Similaire à asa_importance_beta, des valeurs plus élevées fournissent des estimations plus stables. Les valeurs typiques vont de 0,8 à 0,95. La valeur par défaut est 0,85. - asa_schedule_exponent (
float) — Exposant du planning qui contrôle le taux de décroissance depuis le nombre total de sous-espaces versasa_target_subspacespendant le warmup ASA. Des valeurs plus élevées entraînent un élagage initial plus rapide (réduction précoce plus agressive), tandis que des valeurs plus basses offrent une décroissance plus progressive, de type linéaire. La formule est : current_active_subspaces = asa_target_subspaces + (asa_total_subspaces - asa_target_subspaces) * (progress** exponent). Les valeurs typiques vont de 1.0 (linéaire) à 5.0 (agressif). La valeur par défaut est 3.0. Doit être un nombre positif lorsqueuse_asa=True(un exposant nul ou négatif dégrade soit le planning en un no-op permanent, soit, une fois queprogressatteint exactement 0.0, provoque uneZeroDivisionError). - use_dynamic_rank (
bool) — Indique s'il faut déterminer dynamiquement les rangs des sous-espaces en fonction des amplitudes des valeurs singulières. Si True, le rang de chaque sous-espace est déterminé en comptant les valeurs singulières supérieures à un seuil, ce qui permet à différents sous-espaces d'avoir des rangs effectifs différents. Si False, tous les sous-espaces utilisent lesubspace_rankfixe. La valeur par défaut est False. - svd_threshold (
float) — Ratio de seuil pour la sélection dynamique du rang, utilisé uniquement lorsqueuse_dynamic_rank=True. Une valeur singulière est considérée comme significative si elle dépassethreshold * max_singular_value. Des valeurs plus élevées entraînent des rangs effectifs plus faibles (troncature plus agressive). Les valeurs typiques vont de 0,05 à 0,2. La valeur par défaut est 0,1 (10 % du maximum).
Classe de configuration pour la méthode Adamss (Adaptive Multi-Subspaces).
AdaMSS est une méthode de fine-tuning efficace en termes de paramètres qui décompose les matrices de poids à l'aide de la SVD et regroupe l'espace décomposé en plusieurs sous-espaces entraînables. Elle apprend des mises à jour de faible rang au sein de ces sous-espaces tout en maintenant les poids d'origine figés.
AdamssModel
classe peft.AdamssModel
< source >( modelconfigadapter_namelow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict] = None ) → torch.nn.Module
Crée un modèle Adamss (Adaptive Multi-Subspaces) à partir d'un modèle pré-entraîné.
La méthode décompose les matrices de poids à l'aide de la SVD et regroupe l'espace décomposé en plusieurs sous-espaces entraînables pour un fine-tuning efficace en termes de paramètres.
Exemple :
>>> 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)Attributs :
- model (
~torch.nn.Module) — Le modèle à adapter. - peft_config (AdamssConfig) : La configuration du modèle Adamss.
update_and_allocate
< source >( global_step: int )
Mettre à jour les scores d'importance et appliquer le masquage ASA (si activé).
Cette méthode doit être appelée à chaque étape d'entraînement après loss.backward() et avant optimizer.zero_grad() lorsque l'ASA est activé. En interne, elle :
- Accumule les scores d'importance via EMA à chaque étape pendant la période de warmup.
- Aux intervalles de masquage, applique le masquage global top-K et réinitialise l'importance.
C'est le point d'entrée unique pour ASA – l'utilisation de AdamssAsaCallback avec le Trainer de HuggingFace délègue simplement à cette méthode. Pour les boucles d'entraînement personnalisées, appelez directement cette méthode plutôt que le callback.