PEFT documentation
Super-Tuning
Super-Tuning
Super-Tuning est une méthode de fine-tuning creux qui fige les poids de base et n’entraîne qu’un support creux d’entrées scalaires sélectionnées par magnitude des poids. La définition de r alloue en outre un adaptateur de faible rang de type LoRA, composé de manière additive par-dessus le support creux (l’hybride « Supra » de l’article).
Le score par défaut est basé uniquement sur l’amplitude et ne requiert aucune donnée. L’ablation 8B du rapport indique que magnitude-topk obtient en moyenne 79,02 %, surpassant la saillance pondérée par Wanda à 78,66 %, tout en ne nécessitant aucune passe de calibration. Le score pondéré par les activations de type Wanda n’est pas proposé par cette implémentation.
Super-Tuning présente actuellement la contrainte suivante :
- Seules les couches
nn.Linearsont prises en charge.
L'abstract de l'article est :
Le fine-tuning de grands modèles de langage à l'aide de méthodes efficaces en termes de paramètres est devenu une pratique standard, mais les approches existantes comme LoRA restreignent le sous-espace entraînable à une décomposition de faible rang. Nous introduisons Super-Tuning, une approche de fine-tuning creux qui sélectionne à la place un petit support d'entrées scalaires individuelles de poids — un ensemble entraînable de rang non restreint à un budget de paramètres fixe. La sélection est guidée par des signaux de saillance inspirés de l'élagage : un score basé uniquement sur l'amplitude (style PaFi) ou un score pondéré par les activations (style Wanda). Nous montrons que, sur les fine-tunes de Llama-3.2-1B et Meta-Llama-3-8B évalués sur Math17K, Super-Tuning basé sur l'amplitude égale ou dépasse LoRA à des budgets de paramètres comparables, et qu'une variante hybride « Supra » — combinant un support creux avec un composant de faible rang — améliore encore la précision en aval.
Aperçu des benchmarks
Utilisation
Pure Super (notation par magnitude, sans données) :
from peft import SupertuningConfig, get_peft_model
config = SupertuningConfig(target_modules=["q_proj", "v_proj"], sparsity=0.99)
model = get_peft_model(base_model, config)Hybride Supra (prise en charge des structures creuses + LoRA composées de manière additive) :
config = SupertuningConfig(
target_modules=["q_proj", "v_proj"], sparsity=0.99,
r=8, lora_alpha=16, # lora_alpha defaults to 2 * r when omitted
)
model = get_peft_model(base_model, config)SupertuningConfig
classe peft.SupertuningConfig
< 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 = Falsetarget_modules: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = Nonesparsity: float = 0.99select_top: bool = Truer: Optional[int] = Nonelora_alpha: Optional[float] = Nonelora_dropout: float = 0.0init_weights: bool = Truesave_precomputed_indices: bool = True )
Paramètres
- target_modules (
Optional[Union[List[str], str]]) — Noms des modules auxquels appliquer l’adaptateur. Chaîne de caractères → correspondance par expression régulière ; liste → correspondance par suffixe ou exacte ; None → défaut de l’architecture du modèle. - modules_to_save (
Optional[List[str]]) — Modules situés en dehors des couches de Supertuning qui doivent également être entraînables et sauvegardés dans le point de contrôle final (par exemple, des têtes de classifieurs initialisés aléatoirement). - sparsity (
float) — Ratio de sparsité cible dans[0.0, 1.0).0.99= 1 % des entrées de poids sont entraînables. Valeur par défaut :0.99. - select_top (
bool) — Quelle extrémité de la note d’amplitude conserver comme support entraînable.Trueconserve les entrées de plus grande amplitude (Super / Supra de l’article) ;Falseconserve les plus petites (variantes-bottomde l’article). L’article indique que la meilleure direction dépend du modèle et de la tâche. Valeur par défaut :True. - r (
Optional[int]) — Rang LoRA pour l’hybride « Supra ». SiNone(par défaut), seul le support creux est entraînable (mode Super). Si défini sur un entier positif, alloue en outre les paramètres LoRAA([r, in_features]) etB([out_features, r]) dont la contribution est ajoutée au support creux lors du passage avant. - lora_alpha (
Optional[float]) — Facteur d'échelle LoRA pour le mode Supra. SiNoneet querest défini, la valeur par défaut est2 * r. Ignoré lorsquer is None. - lora_dropout (
float) — Probabilité de dropout LoRA pour le mode Supra. Valeur par défaut :0.0. Ignoré lorsquer is None. - init_weights (
bool) — LorsqueTrue(par défaut), lesvaluescreuses sont initialisées à zéro etBde LoRA est initialisé à zéro — l'adaptateur est une mise à jour identité à la construction. LorsqueFalse, les deux sont initialisés avec Kaiming-uniform (utilisé par les tests pour exercer un adaptateur non trivial).Ade LoRA utilise Kaiming-uniform dans les deux cas. - save_precomputed_indices (
bool) — Indique s'il faut enregistrer les indices de support creux dans le state dict. La valeur par défaut estTrue. DéfinissezFalsepour réduire la taille du checkpoint — les indices seront reconstruits de manière déterministe à partir des amplitudes des poids de base au moment du chargement. La reconstruction suppose que les poids du modèle de base sont identiques à ceux utilisés lors de l'entraînement ; un léger dérive numérique peut entraîner des différences dans la résolution des égalités lors du topk.
Classe de configuration pour SupertuningModel.
Super-Tuning (arXiv:2607.09287) fige les poids de base et n’entraîne qu’un support sparse d’entrées scalaires, sélectionnées par magnitude des poids. La configuration r alloue en outre un adaptateur de faible rang de type LoRA par-dessus le support sparse (l’hybride « Supra » de l’article).
La configuration par défaut (score par magnitude, r=None) reproduit la configuration à mécanisme unique la mieux rapportée dans l’article : sur
Meta-Llama-3-8B, magnitude-topk obtient une moyenne de 79,02 %, dépassant Wanda à 78,66 %, et ne nécessite aucune passe de calibration.
Le score pondéré par activation de type Wanda n’est pas proposé par cette implémentation.
Article : https://arxiv.org/abs/2607.09287
SupertuningModel
classe peft.SupertuningModel
< source >( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None ) → torch.nn.Module
Paramètres
- model (PreTrainedModel) — Le modèle de base à adapter.
- config (SupertuningConfig) — La configuration de Supertuning.
- adapter_name (
str) — Le nom de l'adaptateur. La valeur par défaut est"default". - low_cpu_mem_usage (
bool, facultatif) — Crée des poids d’adaptateurs vides sur le périphérique meta pour accélérer le chargement.
Retourne
torch.nn.Module
Le modèle enveloppé par Supertuning.
Super-Tuning tuner (arXiv:2607.09287).
Gèle les poids de base et n’entraîne qu’un support creux d’entrées scalaires sélectionnées par magnitude des poids (configuration à mécanisme unique la plus performante de l’article ; sans données). Lorsque config.r est défini, alloue en outre des paramètres LoRA A/B composés de manière additive avec le support creux — le hybride Supra de l’article.
Exemple (Super pur) :
>>> from transformers import AutoModelForCausalLM
>>> from peft import SupertuningConfig, get_peft_model
>>> base = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.2-1B")
>>> config = SupertuningConfig(target_modules=["q_proj", "v_proj"], sparsity=0.99)
>>> model = get_peft_model(base, config)Exemple (hybride Supra) :
>>> config = SupertuningConfig(
... target_modules=["q_proj", "v_proj"],
... sparsity=0.99,
... r=8,
... lora_alpha=16,
... )
>>> model = get_peft_model(base, config)Article : https://arxiv.org/abs/2607.09287