PEFT documentation

BEFT : Fine-tuning efficace par rapport au biais des modèles de langage dans des régimes à faible volume de données

PEFT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.21.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

BEFT : Fine-tuning efficace par rapport au biais des modèles de langage dans des régimes à faible volume de données

BEFT est un algorithme de fine-tuning efficace en termes de paramètres (PEFT) qui n’ajuste que les termes de biais ajoutés aux projections de valeur des modèles transformers pré-entraînés. BEFT démontre que le fine-tuning des termes de biais ajoutés aux projections de valeur des transformers pré-entraînés conduit généralement à de meilleures performances en aval dans les régimes à faible quantité de données que le fine-tuning des termes de biais ajoutés aux projections de requête/clé.

BEFT présente actuellement les compromis suivants :

Avantages :

BEFT nécessite beaucoup moins de paramètres que LoRA, tout en maintenant des performances compétitives ou supérieures sur les tâches dans les régimes à faible volume de données.

Inconvénients :

Dans les régimes à forte quantité de données, BEFT peut présenter une efficacité limitée par rapport à LoRA et à l’ajustement fin sur l’ensemble des paramètres.

Si votre cas d’usage relève du régime à forte quantité de données, envisagez d’autres méthodes PEFT telles que LoRA.

L'abstract de l'article est :

Le fine-tuning des termes de biais des grands modèles de langage (LLM) a le potentiel d'atteindre une efficacité paramétrique sans précédent tout en maintenant des performances compétitives, en particulier dans les régimes à faible quantité de données. Cependant, le lien entre le fine-tuning de différents termes de biais (c'est-à-dire b_q, b_k et b_v dans les projections de requête, de clé ou de valeur) et les performances en aval reste largement incertain à ce jour. Dans cet article, nous étudions le lien entre le fine-tuning de b_q, b_k et b_v et les performances de la tâche en aval. Notre résultat clé est que le fine-tuning direct de b_v conduit généralement à de meilleures performances en aval dans les régimes à faible quantité de données, par rapport à b_q et b_k. Nous évaluons largement cette propriété unique sur une large gamme de LLM couvrant des architectures uniquement encodeur et uniquement décodeur jusqu'à 6,7 milliards de paramètres (y compris des LLM sans biais). Nos résultats fournissent des preuves solides de l'efficacité du fine-tuning direct de b_v sur diverses tâches en aval.

Aperçu des benchmarks

API

BeftConfig

classe peft.BeftConfig

< 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]] = Noneinit_weights: bool = True )

Paramètres

target_modules (Optional[Union[List[str], str]]) — Les noms des modules auxquels appliquer l’adaptateur. Si ce paramètre est spécifié, seuls les modules portant les noms indiqués seront remplacés. En cas de chaîne de caractères, une correspondance par expression régulière est effectuée. En cas de liste de chaînes, une correspondance exacte est réalisée ou il est vérifié si le nom du module se termine par l’une des chaînes fournies. Si ce paramètre n’est pas spécifié, les modules sont choisis en fonction de l’architecture du modèle. Si l’architecture est inconnue, une erreur est levée — dans ce cas, vous devez spécifier manuellement les modules cibles.
modules_to_save (Optional[List[str]]) — Liste des modules, à l'exception des couches BEFT, à définir comme entraînables et à enregistrer dans le point de contrôle final.
init_weights (bool) — Indique s'il faut initialiser les vecteurs des couches BEFT, par défaut True. Il est déconseillé de définir cette valeur à False.

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

BeftModel

classe peft.BeftModel

< 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 à adapter.
config (BeftConfig) — La configuration du modèle (BEFT).
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 (BEFT).

Crée un Infused Adapter en n'ajustant finement que les termes de biais ajoutés aux projections de valeur d'un modèle transformers pré-entraîné, dans des régimes à faible volume de données d'entraînement (BEFT). La méthode est décrite en détail dans https://arxiv.org/abs/2509.15974

Exemple :

>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import BeftConfig, get_peft_model

>>> config = BeftConfig(
...     task_type="SEQ_2_SEQ_LM",
...     target_modules=["v"],
... )

>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> beft_model = get_peft_model(model, config)

Attributs :

model (PreTrainedModel) — Le modèle à adapter.
peft_config (BeftConfig) : La configuration du modèle (BEFT).

Update on GitHub

←Prompt tuning Réglage de LayerNorm→