PEFT documentation

Tuners

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Tuners

Um tuner (ou adaptador) é um módulo que pode ser conectado a um torch.nn.Module. A classe base BaseTuner para outros tuners fornece métodos e atributos compartilhados para preparar uma configuração de adaptador e substituir um módulo de destino pelo módulo de adaptador. BaseTunerLayer é uma classe base para camadas de adaptador. Ela oferece métodos e atributos para gerenciar adaptadores, como ativar e desativar adaptadores.

BaseTuner

classe peft.tuners.tuners_utils.BaseTuner

< >

( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Parâmetros

  • model (torch.nn.Module) — O modelo ao qual as camadas do adaptador tuner serão anexadas.
  • forward (Callable) — O método forward do modelo.
  • peft_config (Union[PeftConfig, dict[str, PeftConfig]]) — O objeto de configuração do adaptador, deve ser um dicionário de str para objetos PeftConfig. Também é possível passar um objeto PeftConfig e um novo adaptador será criado com o nome padrão adapter ou criar um novo dicionário com uma chave adapter_name e um valor correspondente àquela configuração peft.
  • config (dict[str, Any]) — O objeto de configuração do modelo, deve ser um dicionário de objetos str para Any.
  • targeted_module_names (list[str]) — A lista de nomes de módulos que foram efetivamente adaptados. Pode ser útil para inspecionar, caso você queira verificar rapidamente se os config.target_modules foram especificados corretamente.
  • targeted_parameter_names (list[str]) — A lista de nomes de parâmetros que foram efetivamente adaptados. Pode ser útil para inspecionar, caso você queira verificar rapidamente se o config.target_parameters foi especificado corretamente.
  • prefix (str) — Prefixo único específico do método PEFT. Por exemplo, "lora_" para LoRA.

Um modelo de tuner base que fornece os métodos e atributos comuns para todos os tuners que podem ser injetados em um torch.nn.Module

Para adicionar uma nova classe Tuner, é necessário sobrescrever os seguintes métodos:

  • _prepare_adapter_config: Um método privado para preparar a configuração do adaptador, por exemplo, caso o campo target_modules esteja ausente.
  • _create_and_replace: Um método privado para criar e substituir o módulo de destino pelo módulo de adaptador.
  • _check_target_module_exists: Um método auxiliar privado para verificar se o nome da chave do módulo passado corresponde a um dos módulos de destino no adapter_config.

A maneira mais fácil é verificar o que é feito na classe peft.tuners.lora.LoraModel.

delete_adapter

< >

( adapter_name: str )

Parâmetros

  • adapter_name (str) — Nome do adaptador a ser excluído.

Exclui um adaptador existente.

disable_adapter_layers

< >

( )

Desative todos os adaptadores no local.

Ao desativar todos os adaptadores, a saída do modelo corresponde à saída do modelo base.

enable_adapter_layers

< >

( )

Ativar todos os adaptadores no local

get_model_config

< >

( model: nn.Module )

Parâmetros

  • model (nn.Module) — Modelo do qual obter a configuração.
  • default (dict|None, opcional) —: O que retornar se o modelo não tiver um atributo de configuração.

Este método obtém a configuração de um modelo em forma de dicionário. Se o modelo não tiver o atributo config, este método retorna uma configuração padrão.

inject_adapter

< >

( model: nn.Moduleadapter_name: strautocast_adapter_dtype: bool = Truelow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Parâmetros

  • model (nn.Module) — O modelo a ser ajustado.
  • adapter_name (str) — O nome do adaptador.
  • autocast_adapter_dtype (bool, opcional) — Se deve aplicar autocast ao dtype do adaptador. O valor padrão é True.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento.
  • state_dict (dict, opcional, padrão None) — Se um state_dict for passado aqui, os adaptadores serão injetados com base nas entradas do state_dict. Isso pode ser útil quando os target_modules exatos do método PEFT são desconhecidos, por exemplo, porque o checkpoint foi criado sem metadados. Observe que os valores do state_dict não são usados, apenas as chaves são usadas para determinar as camadas corretas que devem ser adaptadas.

Cria camadas de adaptador e substitui os módulos de destino pelas camadas de adaptador. Este método é chamado internamente por peft.mapping.get_peft_model quando uma classe de adaptador que não é de ajuste de prompt é passada.

A configuração PEFT correspondente é obtida diretamente do atributo peft_config da classe BaseTuner.

merge_adapter

< >

( adapter_names: Optional[list[str]] = Nonesafe_merge: bool = False )

Parâmetros

  • adapter_names (list[str], opcional) — A lista de nomes de adaptadores que devem ser mesclados. Se None, todos os adaptadores ativos serão mesclados. Padrão: None.
  • safe_merge (bool, opcional) — Se True, a operação de mesclagem será executada em uma cópia dos pesos originais e verificará a presença de NaNs antes de mesclar os pesos. Isso é útil se você deseja verificar se a operação de mesclagem produzirá NaNs. O valor padrão é False.

Este método mescla as camadas do adaptador no modelo base.

A fusão de adaptadores pode resultar em uma aceleração da passagem direta. Uma cópia dos pesos do adaptador ainda é mantida na memória, o que é necessário para desfazer a fusão dos adaptadores. Para fundir os pesos do adaptador sem mantê-los na memória, chame merge_and_unload.

Uma vez que uma camada tenha mesclado os pesos do adaptador, sua passagem direta usa apenas esses pesos. Portanto, se adapter_names não cobrir todos os adaptadores ativos, os adaptadores ativos restantes não são aplicados silenciosamente, mesmo que ainda sejam relatados como ativos. Mescle todos os adaptadores ativos ou chame unmerge_adapter primeiro. Observe que esse comportamento está planejado para mudar na versão 1.0.

merge_and_unload

< >

( progressbar: bool = Falsesafe_merge: bool = Falseadapter_names: Optional[list[str]] = None )

Parâmetros

  • progressbar (bool) — se deve exibir uma barra de progresso indicando o processo de descarregamento e mesclagem (padrão: False).
  • safe_merge (bool) — se deve ativar a verificação de mesclagem segura para verificar se há algum potencial Nan nos pesos do adaptador.
  • adapter_names (List[str], opcional) — A lista de nomes de adaptadores que devem ser mesclados. Se for None, todos os adaptadores ativos serão mesclados. O padrão é None.

Este método mescla as camadas do adaptador no modelo base.

Isso é necessário se alguém quiser usar o modelo base como um modelo independente. O modelo retornado possui a mesma arquitetura que o modelo base original.

É importante atribuir o modelo retornado a uma variável e usá-lo, pois esta não é uma operação in-place!

Exemplo:

>>> from transformers import AutoModelForCausalLM
>>> from peft import PeftModel

>>> model_id = ...
>>> base_model = AutoModelForCausalLM.from_pretrained(model_id)
>>> peft_model_id = ...
>>> model = PeftModel.from_pretrained(base_model, peft_model_id)
>>> merged_model = model.merge_and_unload()

set_adapter

< >

( adapter_name: str | list[str]inference_mode: bool = False )

Parâmetros

  • adapter_name (str, list[str]) — O(s) nome(s) do(s) adaptador(es) a ser(em) definido(s) como ativo(s)
  • inference_mode (bool, opcional) — Se o adaptador ativado deve ser congelado (ou seja, requires_grad=False). O padrão é False.

Defina o(s) adaptador(es) ativo(s).

set_requires_grad

< >

( adapter_names: str | Sequence[str]requires_grad: bool = True )

Parâmetros

  • adapter_names (str ou Sequence[str]) — O nome do(s) adaptador(es) cujos gradientes devem ser habilitados/desabilitados.
  • requires_grad (bool, opcional) — Se deve ser habilitado (True, padrão) ou desabilitado (False).

Ative ou desative os gradientes nos adaptador(es) especificados.

supports_lora_conversion

< >

( adapter_name: str = 'default' )

Se é possível converter o adaptador deste modelo para LoRA.

Normalmente, isso funciona se o método PEFT for aditivo, ou seja, W’ = W_base + delta_weight.

descarregar

< >

( )

Retorne o modelo base removendo todos os módulos PEFT.

É importante atribuir o modelo retornado a uma variável e usá-lo, pois esta não é uma operação in-place!

unmerge_adapter

< >

( )

Este método desanexa todas as camadas de adaptador mescladas do modelo base.

BaseTunerLayer

classe peft.tuners.tuners_utils.BaseTunerLayer

< >

( )

Parâmetros

  • is_pluggable (bool, opcional) — Se a camada de adaptador pode ser conectada a qualquer módulo do PyTorch
  • active_adapters (Union[Liststr, str], opcional) — O nome do adaptador ativo.

Um mixin de camada de tuner que fornece os métodos e atributos comuns para todos os tuners.

delete_adapter

< >

( adapter_name: str )

Parâmetros

  • adapter_name (str) — O nome do adaptador a ser excluído

Excluir um adaptador da camada

Isso deve ser chamado em todas as camadas de adaptador, caso contrário, obteremos um estado inconsistente.

Este método também definirá um novo adaptador ativo se o adaptador excluído fosse um adaptador ativo. É importante que o novo adaptador seja escolhido de forma determinística, para que o mesmo adaptador seja escolhido em todas as camadas.

enable_adapters

< >

( enabled: bool )

Parâmetros

  • enabled (bool) — True para habilitar adaptadores, False para desabilitar adaptadores

Alterne a ativação e a desativação dos adaptadores

Cuida de definir a flag requires_grad para os pesos do adaptador.

get_additive_delta

< >

( adapter_name: str = 'default' )

Parâmetros

  • adapter_name (str) — O nome do adaptador. O padrão é "default".

Retorna o delta aditivo de peso W’ - W para o adaptador dado, onde W é o peso base e W’ é o peso após a fusão do adaptador no peso base. Isso significa que o peso fundido pode ser reconstruído via base_weight + module.get_additive_delta(adapter_name).

Para métodos PEFT aditivos (por exemplo, LoRA, LoKr, LoHa), isso é equivalente a get_delta_weight. Para métodos multiplicativos (por exemplo, OFT, BOFT), este método constrói o peso efetivo W’ e subtrai o peso base W.

Chamar este método enquanto qualquer adaptador estiver mesclado gera um ValueError, pois a mesclagem modifica o peso base, o que faria o valor de retorno depender dos adaptadores atualmente mesclados. Desfaça a mesclagem dos adaptadores primeiro.

O tensor retornado tem o dtype dos pesos da camada do adaptador (por exemplo, lora_A para LoRA), e não o dtype do peso da camada base. Este é o dtype que o adaptador LoRA convertido usará.

O resultado é usado por convert_to_lora para realizar uma aproximação baseada em SVD do adaptador como um adaptador LoRA.

Por padrão, isso levanta um NotImplementedError. Os métodos PEFT que suportam isso devem sobrescrever o método _get_additive_delta para retornar o delta aditivo.

get_base_layer

< >

( )

Obter (recursivamente) a base_layer.

Isso é necessário para o caso em que a camada de tuner envolve outra camada de tuner.

get_base_weight

< >

( )

Retorna o peso da camada base.

Isso cuida da possível desquantização do peso, caso ele esteja quantizado.

set_adapter

< >

( adapter_names: str | list[str]inference_mode: bool = False )

Parâmetros

  • adapter_names (str ou list[str]) — O(s) nome(s) do(s) adaptador(es) a ser(em) definido(s) como ativo(s).
  • inference_mode (bool, opcional) — Se o adaptador ativado deve ser congelado (ou seja, requires_grad=False). O padrão é False.

Defina o(s) adaptador(es) ativo(s).

Além disso, esta função definirá o adaptador especificado como treinável (ou seja, requires_grad=True), a menos que inference_mode seja True.

set_base_weight

< >

( weight_data: torch.Tensor )

Define o peso base da camada base para o novo tensor

Isso também funciona com pesos quantizados.

set_requires_grad

< >

( adapter_names: str | Sequence[str]requires_grad: bool = True )

Parâmetros

  • adapter_names (str ou Sequence[str]) — O nome do(s) adaptador(es) cujos gradientes devem ser habilitados/desabilitados.
  • requires_grad (bool, opcional) — Se deve ser habilitado (True, padrão) ou desabilitado (False).

Ative ou desative os gradientes nos adaptador(es) especificados.

set_training

< >

( adapter_names: str | Sequence[str]training: bool = True )

Parâmetros

  • adapter_names (str ou Sequence[str]) — O nome do(s) adaptador(es) cujo modo de treinamento deve ser atualizado.
  • training (bool, opcional) — Se deve ativar (True, padrão) ou desativar (False) o modo de treinamento.

Ative ou desative o modo de treinamento nos módulos de adaptador fornecidos.

supports_lora_conversion

< >

( adapter_name: str = 'default' )

Se é possível converter esse tipo de camada para LoRA.

Normalmente, isso funciona se o método PEFT for aditivo, ou seja, W’ = W_base + delta_weight.

Update on GitHub