PEFT documentation
PEANuT : Adaptation efficace des paramètres avec des ajusteurs neuronaux sensibles aux poids
PEANuT : Adaptation efficace des paramètres avec des ajusteurs neuronaux sensibles aux poids
PEANuT est une technique de fine-tuning efficace en termes de paramètres qui introduit des « neural tweakers » sensibles aux poids afin de générer des mises à jour d’adaptateurs à partir des poids pré-entraînés gelés eux-mêmes. Plutôt que d’apprendre une mise à jour de faible rang purement linéaire comme dans LoRA, PEANuT conditionne la transformation de l’adaptateur sur le poids de base, ce qui rend la règle de mise à jour plus expressive tout en maintenant le nombre de paramètres entraînables faible.
PEANuT utilise une projection d'entrée A, une projection de sortie B et des paires optionnelles d'encodeur/décodeur résiduel intermédiaires avec des activations non linéaires. Cela permet de modéliser des motifs de mise à jour plus complexes que les adaptateurs linéaires agnostiques des poids, tout en restant dans le cadre de PEFT.
PEANuT présente actuellement les compromis suivants :
Avantages :
- Expressivité théorique supérieure par rapport aux mises à jour de faible rang linéaires.
- Des performances supérieures à celles de LoRA sur une variété de tâches, à budget comparable.
- Fonctionne très bien dans des régimes à très faible nombre de paramètres, par exemple autour de
0.2Mparamètres entraînables.
Inconvénients :
- Utilisation de la mémoire plus élevée que LoRA, car
ΔWest explicitement construit avant d'être appliqué. - Entraînement et inférence plus lents que LoRA, et les couches intermédiaires plus profondes augmentent encore la surcharge.
- La non-linéarité peut nécessiter un réglage plus minutieux des hyperparamètres, en particulier le taux d'apprentissage et les paramètres d'optimisation associés.
Si ces compromis ne conviennent pas à votre cas d’usage, envisagez d’autres méthodes PEFT telles que LoRA.
L'abstract de l'article est :
Le fine-tuning de grands modèles de fond pré-entraînés offre souvent d'excellentes performances en aval, mais il est prohibitivement coûteux lorsqu'il met à jour tous les paramètres. Les méthodes de fine-tuning efficace en termes de paramètres (PEFT), telles que LoRA, atténuent ce problème en introduisant des modules de mise à jour légers, mais elles s'appuient généralement sur des approximations linéaires agnostiques des poids, ce qui limite leur expressivité. Dans ce travail, nous proposons PEANuT, un nouveau cadre PEFT qui introduit des « neural tweakers » sensibles aux poids, des modules neuronaux compacts qui génèrent des mises à jour adaptées à la tâche, conditionnées par les poids pré-entraînés figés. PEANuT offre une manière flexible et efficace de capturer des motifs de mise à jour complexes sans entraînement complet du modèle. Nous montrons théoriquement que PEANuT atteint une expressivité équivalente ou supérieure à celle des méthodes PEFT linéaires existantes, avec un nombre comparable ou inférieur de paramètres. Des expériences exhaustives sur quatre benchmarks avec plus de vingt jeux de données démontrent que PEANuT surpasse systématiquement des baselines solides à la fois sur des tâches de NLP et de vision, tout en maintenant une surcharge computationnelle faible.
Aperçu des benchmarks
API
PeanutConfig
classe peft.PeanutConfig
< 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 = 32depth: int = 0act_fn: str = 'relu'scaling: float = 1.0target_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = Nonelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Noneinit_weights: bool = True )
Paramètres
- r (
int) — Rang PEANuT. Il s’agit de la dimension cachée utilisée par les adaptateurs. De même que pour le rang LoRA, une valeur plus élevée deraugmente la capacité des adaptateurs et le nombre de paramètres entraînables. - depth (
int) — Nombre de couches cachées d'adaptateurs par côté encodeur/décodeur dans PEANuT. La projection d'entréeAet la projection de sortieBsont toujours présentes en plus de ces couches cachées. Par conséquent,depthdoit être un entier non négatif.depth=0:A,B.depth=1:A, un encodeur, un décodeur,B.depth=2:A, deux encodeurs, deux décodeurs,B.depth=3:A, trois encodeurs, trois décodeurs,B, etc.
- act_fn (
str) — Fonction d'activation non linéaire appliquée dans le réseau PEANuT. Cela correspond ànon_lineardans l'implémentation PyTorch de base. La valeur par défaut est"relu". Toute clé d'activation disponible danstransformers.activations.ACT2FNest prise en charge et peut donner de meilleurs résultats sur différentes tâches. - scaling (
float) — Un multiplicateur scalaire appliqué à la sortie de PEANuT avant de l'ajouter à la sortie de la couche de base figée. La contribution finale de l'adaptateur estscaling * (x @ delta_w). - target_modules (
Union[List[str], str], facultatif) — Les noms des modules auxquels appliquer PEANuT. Peut être une liste de chaînes de caractères de noms de modules (par ex.['q_proj', 'v_proj']) ou un motif regex. - modules_to_save (
List[str], facultatif) — Liste des modules, à l'exception des couches PEANuT, à définir comme entraînables et à enregistrer dans le point de contrôle final. - exclude_modules (
Union[List[str], str], facultatif) — Les noms des modules auxquels l’adaptateur ne doit pas être appliqué. Si une chaîne de caractères est transmise, une correspondance par expression régulière est effectuée. Si une liste de chaînes de caractères est transmise, une correspondance exacte est effectuée ou il est vérifié si le nom du module se termine par l’une des chaînes transmises. - layers_to_transform (
Union[list[int], int], facultatif) — Les index des couches à transformer. Si cet argument est spécifié, PEFT ne transformera que les index de couches indiqués dans cette liste. Si un seul entier est transmis, PEFT ne transformera que la couche située à cet index. - layers_pattern (
Optional[Union[List[str], str]], facultatif) — Le nom du motif de couche, utilisé uniquement silayers_to_transformn'est pas None et si le motif de couche ne figure pas dans le motif de couches commun. - init_weights (
bool) — Indique s'il faut initialiser les poids de l'adaptateur PEANuT en utilisant le schéma d'initialisation par défaut :- Si
True: tous les poids, à l'exception deB, sont initialisés avec Kaiming uniform, etBest initialisé à zéro. - Si
False: tous les poids (y comprisB) sont initialisés avec Kaiming uniforme.
Initialiser
Bà zéro permet à l'adaptateur de démarrer comme une opération nulle exacte. - Si
Ceci est la classe de configuration destinée à stocker la configuration d'un PeanutModel.
Notes :
PEANuT utilise un chemin de poids conscient, où le poids delta est conditionné par le poids de base. L'adaptateur A
est appliqué sur la dimension de sortie du poids de base, de sorte que A a la forme (out_dim -> r) plutôt que la forme habituelle (in_dim -> r) utilisée par les méthodes de type LoRA.
PeanutModel
classe peft.PeanutModel
< 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 (
torch.nn.Module) — Le modèle à adapter. - config (PeanutConfig) — La configuration du modèle PEANuT.
- adapter_name (
str) — Le nom de l'adaptateur, par défaut"default".
Retourne
torch.nn.Module
Le modèle PEFT PEANuT.
Crée un modèle PEANuT à partir d'un modèle transformers pré-entraîné.
La méthode est décrite en détail dans https://arxiv.org/abs/2410.01870.
Attributs :
- model (PreTrainedModel) — Le modèle à adapter.
- peft_config (PeanutConfig) : La configuration du modèle PEANuT.