Hugging Face's logo

Transformers documentation

PEFT

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.23.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

PEFT

O PeftAdapterMixin fornece funções da biblioteca PEFT para gerenciar adaptadores com o Transformers. Este mixin suporta todos os métodos PEFT que não envolvem aprendizado de prompt (LoRA, IA3, AdaLoRA, entre outros). Os métodos de prefix tuning (prompt tuning, prompt learning) não são suportados, pois não podem ser injetados em um módulo torch.

classe transformers.integrations.PeftAdapterMixin

< >

( )

Uma classe que contém todas as funções para carregar e usar pesos de adaptadores suportados na biblioteca PEFT. Para mais detalhes sobre adaptadores e sua injeção em um modelo baseado em transformer, consulte a documentação da biblioteca PEFT: https://huggingface.co/docs/peft/index

Os métodos PEFT atualmente suportados são todos métodos de aprendizado não baseados em prompts (LoRA, IA³, etc.). Outros modelos PEFT, como prompt tuning e prompt learning, estão fora do escopo, pois esses adaptadores não são “injetáveis” em um módulo torch. Para usar esses métodos, consulte o guia de uso da biblioteca PEFT.

Com este mixin, se a versão correta do PEFT estiver instalada (>= 0.20.0), é possível:

  • Carregue um adaptador armazenado em um caminho local ou em um repositório remoto do Hub e injete-o no modelo
  • Anexe novos adaptadores ao modelo e treine-os com o Trainer ou por conta própria.
  • Anexe vários adaptadores e ative/desative-os iterativamente
  • Ative / desative todos os adaptadores do modelo.
  • Obtenha o state_dict do adaptador ativo.

load_adapter

< >

( peft_model_id: str | None = Noneadapter_name: str | None = Nonepeft_config: dict[str, typing.Any] | None = Noneadapter_state_dict: dict[str, 'torch.Tensor'] | None = Nonelow_cpu_mem_usage: bool = Falseis_trainable: bool = Falsehotswap: typing.Union[bool, typing.Literal['auto']] = 'auto'local_files_only: bool = Falseadapter_kwargs: dict[str, typing.Any] | None = Noneload_config: typing.Optional[ForwardRef('LoadStateDictConfig')] = None**kwargs )

Parâmetros

  • peft_model_id (str, opcional) — O identificador do modelo a ser procurado no Hub, ou um caminho local para o arquivo de configuração do adaptador salvo e os pesos do adaptador.
  • adapter_name (str, opcional) — O nome do adaptador a ser usado. Se não for definido, será usado o nome “default”.
  • load_config (LoadStateDictConfig, opcional) — Uma configuração de carregamento para reutilizar ao obter os pesos do adaptador, normalmente a partir de from_pretrained.
  • kwargs (dict[str, Any], opcional) — Campos adicionais de LoadStateDictConfig passados como argumentos de palavra-chave.
  • peft_config (dict[str, Any], opcional) — A configuração do adaptador a ser adicionado. Os adaptadores suportados são todas as configurações de aprendizado não baseado em prompt (LoRA, IA³, etc.). Este argumento é utilizado quando os usuários passam diretamente dicionários de estado do PEFT.
  • adapter_state_dict (dict[str, torch.Tensor], opcional) — O state dict do adaptador a ser carregado. Este argumento é utilizado quando os usuários passam diretamente state dicts do PEFT.
  • low_cpu_mem_usage (bool, opcional, padrão False) — Reduz o uso de memória ao carregar o adaptador PEFT. Isso também deve acelerar o processo de carregamento.
  • is_trainable (bool, opcional, padrão False) — Indica se o adaptador deve ser treinável ou não. Se False, o adaptador será congelado e poderá ser usado apenas para inferência.
  • hotswap — ("auto" or bool, optional, defaults to "auto") Whether to substitute an existing (LoRA) adapter with the newly loaded adapter in-place. This means that, instead of loading an additional adapter, this will take the existing adapter weights and replace them with the weights of the new adapter. This can be faster and more memory efficient. However, the main advantage of hotswapping is that when the model is compiled with torch.compile, loading the new adapter does not require recompilation of the model. When using hotswapping, the passed adapter_name should be the name of an already loaded adapter.

    Se o novo adaptador e o adaptador antigo tiverem ranks e/ou alphas LoRA (ou seja, escalonamento) diferentes, você precisa chamar um método adicional antes de carregar o adaptador:

    model = AutoModel.from_pretrained(...)
max_rank = ...  # the highest rank among all LoRAs that you want to load
# call *before* compiling and loading the LoRA adapter
model.enable_peft_hotswap(target_rank=max_rank)
model.load_adapter(file_name_1, adapter_name="default")
# optionally compile the model now
model = torch.compile(model, ...)
output_1 = model(...)
# now you can hotswap the 2nd adapter, use the same name as for the 1st
# hotswap is activated by default since enable_peft_hotswap was called
model.load_adapter(file_name_2, adapter_name="default")
output_2 = model(...)

    Por padrão, o hotswap está desativado e requer a passagem de hotswap=True. Se você chamou enable_peft_hotswap primeiro, ele fica ativado. Ainda assim, você pode desativá-lo manualmente nesse caso passando hotswap=False.

    Observe que o hotswapping possui algumas limitações documentadas aqui: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

  • adapter_kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados ao método from_pretrained da configuração do adaptador e ao método find_adapter_config_file.

Carrega os pesos do adaptador de um arquivo ou de uma pasta remota no Hub. Se você não está familiarizado com adaptadores e métodos PEFT, convidamos você a ler mais sobre eles na documentação oficial do PEFT: https://huggingface.co/docs/peft

Exige que o PEFT esteja instalado como backend para carregar os pesos do adaptador.

add_adapter

< >

( adapter_configadapter_name: str | None = None )

Parâmetros

  • adapter_config (~peft.PeftConfig) — A configuração do adaptador a ser adicionado. Os adaptadores suportados são métodos de aprendizado sem prompt (LoRA, IA³, etc.).
  • adapter_name (str, opcional, padrão "default") — O nome do adaptador a ser adicionado. Se nenhum nome for fornecido, um nome padrão será atribuído ao adaptador.

Se você não está familiarizado com adaptadores e métodos PEFT, convidamos você a ler mais sobre eles na documentação oficial do PEFT: https://huggingface.co/docs/peft

Adiciona um novo adaptador ao modelo atual para fins de treinamento. Se nenhum nome de adaptador for fornecido, um nome padrão será atribuído ao adaptador, seguindo a convenção da biblioteca PEFT (no PEFT, usamos “default” como nome padrão do adaptador).

Observe que o adaptador recém-adicionado não é ativado automaticamente. Para ativá-lo, use model.set_adapter.

set_adapter

< >

( adapter_name: list[str] | str )

Parâmetros

  • adapter_name (Union[list[str], str]) — O nome do adaptador a ser definido. Também pode ser uma lista de strings para definir múltiplos adaptadores.

Se você não está familiarizado com adaptadores e métodos PEFT, convidamos você a ler mais sobre eles na documentação oficial do PEFT: https://huggingface.co/docs/peft

Define um adaptador específico, forçando o modelo a usar esse adaptador e desativando os outros adaptadores.

disable_adapters

< >

( )

Se você não está familiarizado com adaptadores e métodos PEFT, convidamos você a ler mais sobre eles na documentação oficial do PEFT: https://huggingface.co/docs/peft

Desative todos os adaptadores anexados ao modelo. Isso resulta na inferência usando apenas o modelo base.

enable_adapters

< >

( )

Se você não está familiarizado com adaptadores e métodos PEFT, convidamos você a ler mais sobre eles na documentação oficial do PEFT: https://huggingface.co/docs/peft

Ative os adaptadores que estão acoplados ao modelo.

enable_peft_hotswap

< >

( target_rank: int = 128check_compiled: typing.Literal['error', 'warn', 'ignore'] = 'error' )

Parâmetros

  • target_rank (int, opcional, padrão 128) — O maior rank entre todos os adaptadores que serão carregados.
  • check_compiled (str, opcional, padrão é "error") — Como lidar com o caso em que o modelo já está compilado, o que geralmente deve ser evitado. As opções são:
    • “error” (padrão): lança um erro
    • “warn”: emitir um aviso
    • “ignore”: não fazer nada

Permite a troca dinâmica de adaptadores PEFT com ranks diferentes ou, se o modelo estiver compilado, sem disparar a recompilação.

No momento, o hotswapping é suportado apenas para LoRA.

A chamada deste método é necessária apenas ao trocar adaptadores dinamicamente (hotswap) e se o modelo estiver compilado ou se os ranks dos adaptadores carregados forem diferentes. Se os ranks forem todos idênticos e o modelo não estiver compilado, a troca dinâmica de adaptadores funciona sem a necessidade de chamar este método primeiro.

active_adapters

< >

( )

Se você não está familiarizado com adaptadores e métodos PEFT, convidamos você a ler mais sobre eles na documentação oficial do PEFT: https://huggingface.co/docs/peft

Obtém os adaptadores ativos atuais do modelo. No caso de inferência com múltiplos adaptadores (combinação de vários adaptadores para inferência), retorna a lista de todos os adaptadores ativos para que os usuários possam tratá-los de forma adequada.

Para versões anteriores do PEFT (que não suportam inferência multi-adapter), module.active_adapter retornará uma única string.

get_adapter_state_dict

< >

( adapter_name: str | None = Nonestate_dict: dict | None = None )

Parâmetros

  • adapter_name (str, opcional) — O nome do adaptador do qual obter o state dict. Se nenhum nome for passado, o adaptador ativo será usado.
  • state_dict (dicionário aninhado de torch.Tensor, opcional) — O dicionário de estado do modelo. O valor padrão será self.state_dict(), mas pode ser utilizado quando forem necessárias precauções especiais ao recuperar o dicionário de estado de um modelo (como ao usar paralelismo de modelo).

Se você não está familiarizado com adaptadores e métodos PEFT, convidamos você a ler mais sobre eles na documentação oficial do PEFT: https://huggingface.co/docs/peft

Obtém o dicionário de estado do adaptador, que deve conter apenas os tensores de pesos do adaptador especificado por adapter_name. Se nenhum adapter_name for fornecido, o adaptador ativo será utilizado.

delete_adapter

< >

( adapter_names: list[str] | str )

Parâmetros

  • adapter_names (Union[list[str], str]) — O(s) nome(s) do(s) adaptador(es) a ser(em) excluído(s).

Exclua um adaptador PEFT do modelo subjacente.

Update on GitHub

←Saídas do modelo Pipelines→