PEFT documentation

FourierFT : Fine-Tuning par transformation de Fourier discrète

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

FourierFT : Fine-Tuning par transformation de Fourier discrète

FourierFT est une technique de fine-tuning à efficacité paramétrique qui exploite la transformée de Fourier discrète pour compresser les poids ajustables du modèle. Cette méthode surpasse LoRA sur le benchmark GLUE et les tâches de classification ViT courantes en utilisant beaucoup moins de paramètres.

FourierFT présente actuellement les contraintes suivantes :

  • Seules les couches nn.Linear sont prises en charge.
  • Les couches quantifiées ne sont pas prises en charge.

Si ces contraintes ne conviennent pas à votre cas d’usage, envisagez plutôt d’autres méthodes.

Quand utiliser FourierFT plutôt que LoRA

LoRA représente une mise à jour de poids à l'aide de deux matrices de faible rang. FourierFT apprend plutôt des coefficients sélectionnés dans le domaine de Fourier et utilise une transformée de Fourier discrète inverse pour reconstruire la mise à jour.

FourierFT peut s’avérer utile lorsque la réduction du nombre de paramètres d’adaptateur entraînables ou de la taille de stockage de l’adaptateur est une priorité. Son paramètre n_frequency contrôle le nombre de coefficients appris pour chaque couche adaptée. Des valeurs plus élevées exigent généralement plus de mémoire GPU et peuvent améliorer la précision, de sorte que le réglage approprié dépend de la tâche et du modèle.

L’article FourierFT rapporte des résultats comparables ou supérieurs à ceux de LoRA dans ses expériences évaluées de compréhension du langage, de génération de texte, d’ajustement par instructions et de classification d’images, avec un nombre réduit de paramètres entraînables dans ces configurations. Ces résultats sont spécifiques à la tâche ; ils ne garantissent pas que FourierFT surpassera LoRA sur un autre modèle ou un autre jeu de données.

L'abstract de l'article est :

L’adaptation de faible rang (LoRA) a récemment suscité un vif intérêt pour l’ajustement fin des modèles de base. Elle réduit efficacement le nombre de paramètres entraînables en intégrant des matrices de faible rang A et B pour représenter la variation des poids, c’est-à-dire Delta W=BA. Malgré les progrès de LoRA, elle rencontre des défis de stockage lors du traitement d’adaptations de personnalisation étendues ou de modèles de base plus volumineux. Dans ce travail, nous visons à compresser davantage les paramètres entraînables en tirant parti de la forte expressivité de la transformée de Fourier. Plus précisément, nous introduisons FourierFT, qui traite Delta W comme une matrice dans le domaine spatial et n’apprend qu’une petite fraction de ses coefficients spectraux. À l’aide des coefficients spectraux entraînés, nous mettons en œuvre la transformée de Fourier discrète inverse pour récupérer Delta W. Empiriquement, notre méthode FourierFT montre des performances comparables ou supérieures à celles de LoRA avec moins de paramètres sur diverses tâches, y compris la compréhension du langage naturel, la génération de langage naturel, l’ajustement par instructions et la classification d’images. Par exemple, lors de l’ajustement par instructions sur le modèle LLaMA2-7B, FourierFT surpasse LoRA avec seulement 0,064M de paramètres entraînables, contre 33,5M pour LoRA.

Aperçu des benchmarks

API

FourierFTConfig

classe peft.FourierFTConfig

< >

( 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 = Falsen_frequency: int = 1000scaling: float = 150.0random_loc_seed: Optional[int] = 777fan_in_fan_out: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonebias: str = 'none'modules_to_save: Optional[list[str]] = Nonelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonen_frequency_pattern: Optional[dict] = <factory>init_weights: bool = False )

Paramètres

  • n_frequency (int) — Nombre de fréquences apprenables pour la transformée de Fourier discrète. ‘n_frequency’ est un entier strictement supérieur à 0 et inférieur ou égal à d^2 (en supposant que le poids W a des dimensions de d par d). De plus, il correspond au nombre de paramètres entraînables nécessaires pour mettre à jour chaque poids delta W. ‘n_frequency’ affecte les performances et l’efficacité de PEFT. Plus précisément, son impact sur la vitesse d’entraînement est faible, mais des valeurs plus élevées entraînent (généralement) des coûts de mémoire GPU plus importants et une meilleure précision. Avec les mêmes target_modules, le nombre de paramètres de LoRA est (2dr/n_frequency) fois supérieur à celui de FourierFT. Les exemples de configuration suivants concernant ‘n_frequency’ peuvent servir de référence aux utilisateurs. Pour les tâches de NLU avec le modèle RoBERTa-large, l’adoption de ‘n_frequency’ : 1000 permet d’obtenir des résultats quasi identiques à ceux de ‘r’ : 8 dans LoRA. Dans ce cas, le nombre de paramètres de LoRA est environ 16 fois supérieur à celui de FourierFT. Pour les tâches de classification d’images avec des modèles Vit-large, l’adoption de ‘n_frequency’ : 3000 permet d’obtenir des résultats quasi identiques à ceux de ‘r’ : 16 dans LoRA, où le nombre de paramètres de LoRA est environ 11 fois supérieur à celui de FourierFT.
  • scaling (float) — La valeur de mise à l’échelle pour la matrice delta W. Il s’agit d’un hyperparamètre important utilisé pour la mise à l’échelle, similaire au paramètre ‘lora_alpha’ de la méthode LoRA. ‘scaling’ peut être déterminé lors du processus de recherche d’hyperparamètres. Toutefois, si les utilisateurs souhaitent passer ce processus, ils peuvent se référer aux configurations des scénarios suivants. Ce paramètre peut être défini à 100.0 ou 150.0 pour les modèles RoBERTa-base et RoBERTa-large sur toutes les tâches NLU (GLUE). Ce paramètre peut être défini à 300.0 pour les modèles de la famille LLaMA pour tout l’instruction tuning. Ce paramètre peut être défini à 300.0 pour les modèles ViT-base et ViT-large sur toutes les tâches de classification d’images.
  • random_loc_seed (int) — Graine pour la localisation aléatoire des fréquences, c'est-à-dire la matrice d'entrée spectrale.
  • target_modules (Union[list[str],str]) — Liste de noms de modules ou expression régulière des noms de modules à remplacer par FourierFT. Par exemple, [‘q’, ‘v’] ou ‘.decoder.(SelfAttention|EncDecAttention).*(q|v)$‘. Seules les couches linéaires sont prises en charge.
  • exclude_modules (Optional[Union[List[str], str]]) — 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.
  • fan_in_fan_out (bool) — Définissez cette valeur sur True si la couche à remplacer stocke les poids sous la forme (fan_in, fan_out).
  • bias (str) — Type de biais pour FourierFT. Peut être ‘none’, ‘all’ ou ‘fourier_only’.
  • modules_to_save (list[str]) — Liste des modules, à l'exception des couches FourierFT, qui doivent être définis comme entraînables et sauvegardés dans le point de contrôle final. Par exemple, dans les tâches de Classification de Séquence ou de Classification de Jeton, la couche finale classifier/score est initialisée aléatoirement et doit donc être entraînable et sauvegardée.
  • layers_to_transform (Union[list[int],int]) — 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 entier unique est transmis, PEFT ne transformera que la couche située à cet index.
  • layers_pattern (Optional[Union[List[str], str]]) — Le nom du motif de couche, utilisé uniquement si layers_to_transform est différent de None et si le motif de couche ne figure pas dans les motifs de couches courants. Il doit cibler le nn.ModuleList du modèle, souvent appelé 'layers' ou 'h'.
  • n_frequency_pattern (dict) — La correspondance entre les noms de couches ou les expressions régulières et les valeurs de n_frequency qui diffèrent de la valeur par défaut spécifiée. Par exemple, {model.decoder.layers.0.encoder_attn.k_proj: 1000}.
  • init_weights (bool) — L’initialisation des poids de Fourier. Définissez cette valeur sur False (par défaut) si le spectre est initialisé avec une distribution normale standard. Définissez-la sur True si le spectre est initialisé avec des zéros.

Ceci est la classe de configuration destinée à stocker la configuration d'un FourierFTModel.

FourierFTModel

classe peft.FourierFTModel

< >

( 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 (FourierFTConfig) — La configuration du modèle FourierFT.
  • adapter_name (str) — Le nom de l'adaptateur, par défaut "default".
  • low_cpu_mem_usage (bool, optional, par défaut False) — Crée des poids d'adaptateurs vides sur l'appareil méta. Utile pour accélérer le processus de chargement.

Retourne

torch.nn.Module

Le modèle FourierFT.

Crée un modèle FourierFT à partir d'un modèle transformers pré-entraîné.

La méthode est décrite en détail dans https://huggingface.co/papers/2405.03003.

Attributs :

Update on GitHub