PEFT documentation
Tuners
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
< source >( 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 destrpara objetosPeftConfig. Também é possível passar um objeto PeftConfig e um novo adaptador será criado com o nome padrãoadapterou criar um novo dicionário com uma chaveadapter_namee um valor correspondente àquela configuração peft. - config (
dict[str, Any]) — O objeto de configuração do modelo, deve ser um dicionário de objetosstrparaAny. - 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 osconfig.target_modulesforam 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 oconfig.target_parametersfoi 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_modulesesteja 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
< source >( adapter_name: str )
Exclui um adaptador existente.
Desative todos os adaptadores no local.
Ao desativar todos os adaptadores, a saída do modelo corresponde à saída do modelo base.
Ativar todos os adaptadores no local
get_model_config
< source >( model: nn.Module )
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
< source >( 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 toFalse) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento. - state_dict (
dict, opcional, padrãoNone) — Se um state_dict for passado aqui, os adaptadores serão injetados com base nas entradas do state_dict. Isso pode ser útil quando ostarget_modulesexatos 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
< source >( 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. SeNone, todos os adaptadores ativos serão mesclados. Padrão:None. - safe_merge (
bool, opcional) — SeTrue, 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
< source >( 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
< source >( adapter_name: str | list[str]inference_mode: bool = False )
Defina o(s) adaptador(es) ativo(s).
set_requires_grad
< source >( adapter_names: str | Sequence[str]requires_grad: bool = True )
Ative ou desative os gradientes nos adaptador(es) especificados.
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.
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!
Este método desanexa todas as camadas de adaptador mescladas do modelo base.
BaseTunerLayer
classe peft.tuners.tuners_utils.BaseTunerLayer
< source >( )
Um mixin de camada de tuner que fornece os métodos e atributos comuns para todos os tuners.
delete_adapter
< source >( adapter_name: str )
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
< source >( enabled: bool )
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
< source >( adapter_name: str = '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.
Obter (recursivamente) a base_layer.
Isso é necessário para o caso em que a camada de tuner envolve outra camada de tuner.
Retorna o peso da camada base.
Isso cuida da possível desquantização do peso, caso ele esteja quantizado.
set_adapter
< source >( adapter_names: str | list[str]inference_mode: bool = 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.
Define o peso base da camada base para o novo tensor
Isso também funciona com pesos quantizados.
set_requires_grad
< source >( adapter_names: str | Sequence[str]requires_grad: bool = True )
Ative ou desative os gradientes nos adaptador(es) especificados.
set_training
< source >( adapter_names: str | Sequence[str]training: bool = True )
Ative ou desative o modo de treinamento nos módulos de adaptador fornecidos.
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.