PEFT documentation

BEFT: Ajuste fino de modelos de linguagem eficiente em viés em cenários com poucos dados

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: Ajuste fino de modelos de linguagem eficiente em viés em cenários com poucos dados

BEFT é um algoritmo de ajuste fino eficiente em parâmetros (PEFT) que ajusta apenas os termos de viés adicionados às projeções de valor de modelos transformer pré-treinados. O BEFT demonstra que o ajuste fino dos termos de viés adicionados às projeções de valor de transformers pré-treinados geralmente leva a um desempenho superior em tarefas downstream em cenários com poucos dados, em comparação com o ajuste fino dos termos de viés adicionados às projeções de consulta/chave.

Atualmente, o BEFT apresenta as seguintes compensações:

Vantagens:

O BEFT requer muito menos parâmetros do que o LoRA, mantendo um desempenho competitivo ou superior em tarefas em cenários com poucos dados.

Desvantagens:

Em regimes com grandes volumes de dados, o BEFT pode apresentar eficácia limitada em comparação com o LoRA e o ajuste fino de parâmetros completos.

Se o seu caso de uso pertence ao regime de alto volume de dados, considere outros métodos de PEFT, como LoRA.

O resumo do artigo é:

O ajuste fino dos termos de viés de modelos de linguagem de grande escala (LLMs) tem o potencial de alcançar uma eficiência de parâmetros sem precedentes, mantendo um desempenho competitivo, particularmente em cenários com poucos dados. No entanto, a relação entre o ajuste fino de diferentes termos de viés (ou seja, b_q, b_k e b_v nas projeções de query, key ou value) e o desempenho em tarefas downstream permanece em grande parte não esclarecida até o momento. Neste artigo, investigamos a relação entre o ajuste fino de b_q, b_k e b_v e o desempenho da tarefa downstream. Nossa principal descoberta é que o ajuste fino direto de b_v geralmente leva a um desempenho superior em tarefas downstream em cenários com poucos dados, em comparação com b_q e b_k. Avaliamos extensivamente essa propriedade única em uma ampla variedade de LLMs, abrangendo arquiteturas apenas de codificador e apenas de decodificador, com até 6,7 bilhões de parâmetros (incluindo LLMs sem viés). Nossos resultados fornecem evidências fortes para a eficácia do ajuste fino direto de b_v em diversas tarefas downstream.

Visão geral do benchmark

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 )

Parâmetros

target_modules (Optional[Union[List[str], str]]) — Os nomes dos módulos aos quais o adaptador será aplicado. Se especificado, apenas os módulos com os nomes indicados serão substituídos. Ao passar uma string, será realizada uma correspondência por expressão regular. Ao passar uma lista de strings, será realizada uma correspondência exata ou será verificado se o nome do módulo termina com qualquer uma das strings passadas. Se não for especificado, os módulos serão escolhidos de acordo com a arquitetura do modelo. Se a arquitetura não for conhecida, um erro será lançado — nesse caso, você deve especificar os módulos de destino manualmente.
modules_to_save (Optional[List[str]]) — Lista de módulos, além das camadas BEFT, que devem ser configurados como treináveis e salvos no checkpoint final.
init_weights (bool) — Se os vetores nas camadas BEFT devem ser inicializados, padrão é True. Definir isso como False é desaconselhado.

Esta é a classe de configuração para armazenar a configuração de um 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

Parâmetros

model (PreTrainedModel) — O modelo a ser adaptado.
config (BeftConfig) — A configuração do modelo (BEFT).
adapter_name (str) — O nome do adaptador, padrão é "default".
low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento.

Retorna

torch.nn.Module

O modelo (BEFT).

Cria um Infused Adapter ajustando finamente apenas os termos de viés adicionados às projeções de valor de um modelo de transformers pré-treinado em regimes com poucos dados de treinamento (BEFT). O método é descrito em detalhes em https://arxiv.org/abs/2509.15974

Exemplo:

>>> 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)

Atributos:

model (PreTrainedModel) — O modelo a ser adaptado.
peft_config (BeftConfig): A configuração do modelo (BEFT).

Update on GitHub

←Prompt tuning Ajuste do LayerNorm→