Hugging Face's logo

PEFT documentation

Modelos

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).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Modelos

PeftModel é a classe de modelo base para especificar o modelo Transformer base e a configuração para aplicar um método PEFT. O PeftModel base contém métodos para carregar e salvar modelos do Hub.

PeftModel

classe peft.PeftModel

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'autocast_adapter_dtype: bool = Truelow_cpu_mem_usage: bool = False )

Parâmetros

  • model (torch.nn.Module) — O modelo base a ser adaptado, tipicamente um modelo do Transformers.
  • peft_config (PeftConfig) — A configuração do modelo Peft.
  • adapter_name (str, opcional) — O nome do adaptador, padrão é "default".
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte pesos de adaptadores usando float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas seletores de PEFT tuners. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.
  • low_cpu_mem_usage (bool, optional, padrão é False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento.

    > Não use low_cpu_mem_usage=True ao criar um novo adaptador PEFT para treinamento.

Modelo base que abrange vários métodos do Peft.

Atributos:

  • base_model (torch.nn.Module) — O modelo transformer base usado para o Peft.
  • peft_config (PeftConfig) — A configuração do modelo Peft.
  • modules_to_save (list de str) — A lista de nomes de submódulos a serem salvos ao salvar o modelo.
  • prompt_encoder (PromptEncoder) — O codificador de prompt usado para Peft, caso esteja usando PromptLearningConfig.
  • prompt_tokens (torch.Tensor) — Os tokens de prompt virtuais usados para Peft, caso esteja usando PromptLearningConfig.
  • transformer_backbone_name (str) — O nome do backbone de transformer no modelo base, caso esteja usando PromptLearningConfig.
  • word_embeddings (torch.nn.Embedding) — Os embeddings de palavras do backbone do transformer no modelo base, caso esteja usando PromptLearningConfig.

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parâmetros

  • adapter_name (str) — O nome do adaptador a ser adicionado.
  • peft_config (PeftConfig) — A configuração do adaptador a ser adicionado.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo ao carregar adaptadores salvos. Não use esta opção ao criar um novo adaptador PEFT para treinamento.
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte os pesos do adaptador de float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas alguns tuners PEFT. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Adicione um adaptador ao modelo com base na configuração passada.

Este adaptador não foi treinado. Para carregar um adaptador treinado, consulte PeftModel.load_adapter().

O nome do novo adaptador deve ser único.

O novo adaptador não é definido automaticamente como o adaptador ativo. Use PeftModel.set_adapter() para definir o adaptador ativo.

create_or_update_model_card

< >

( output_dir: str )

Atualize ou crie o cartão do modelo para incluir informações sobre peft:

  1. Adiciona a tag da biblioteca peft
  2. Adiciona a versão do peft
  3. Adiciona informações do modelo base
  4. Adiciona informações de quantização, caso tenha sido utilizada

delete_adapter

< >

( adapter_name: str )

Parâmetros

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

Exclui um adaptador existente.

disable_adapter

< >

( )

Gerenciador de contexto que desativa o módulo de adaptador. Use isso para executar inferência no modelo base.

Exemplo:

>>> with model.disable_adapter():
...     model(inputs)

forward

< >

( *args: Any**kwargs: Any )

Passada para frente do modelo.

from_pretrained

< >

( model: torch.nn.Modulemodel_id: Union[str, os.PathLike]adapter_name: str = 'default'is_trainable: bool = Falseconfig: Optional[PeftConfig] = Noneautocast_adapter_dtype: bool = Trueephemeral_gpu_offload: bool = Falselow_cpu_mem_usage: bool = Falsekey_mapping: Optional[dict[str, str]] = None**kwargs: Any )

Parâmetros

  • model (torch.nn.Module) — O modelo a ser adaptado. Para modelos do 🤗 Transformers, o modelo deve ser inicializado com o from_pretrained.
  • model_id (str ou os.PathLike) — O nome da configuração PEFT a ser usada. Pode ser:
    • Uma string, o model id de uma configuração PEFT hospedada em um repositório de modelos no Hugging Face Hub.
    • Um caminho para um diretório contendo um arquivo de configuração PEFT salvo usando o método save_pretrained (./my_peft_config_directory/).
  • adapter_name (str, opcional, padrão "default") — O nome do adaptador a ser carregado. Isso é útil para carregar múltiplos adaptadores.
  • is_trainable (bool, opcional, padrão False) — Se o adaptador deve ser treinável ou não. Se False, o adaptador será congelado e poderá ser usado apenas para inferência.
  • config (PeftConfig, opcional) — O objeto de configuração a ser usado no lugar de uma configuração carregada automaticamente. Este objeto de configuração é mutuamente exclusivo com model_id e kwargs. Isso é útil quando a configuração já foi carregada antes de chamar from_pretrained.
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte os pesos do adaptador de float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas alguns tuners PEFT. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.
  • ephemeral_gpu_offload (bool, opcional) — Se deve usar offloading efêmero de GPU para módulos parcialmente carregados. O padrão é False. Isso é útil quando partes do modelo e/ou componentes (como adaptadores) são mantidos na memória do CPU até que sejam necessários. Em vez de executar operações caras em pequenos dados, os dados são transferidos para a GPU sob demanda, as operações são executadas e os resultados são movidos de volta para a memória do CPU. Isso traz um pequeno overhead momentâneo de VRAM, mas oferece uma aceleração de ordens de grandeza em certos casos.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta antes de carregar os pesos salvos. Útil para acelerar o processo.
  • key_mapping (dict, opcional, padrão None) — Mapeamento extra de chaves do state_dict do PEFT aplicado antes de carregar o state_dict. Quando esse mapeamento é aplicado, o prefixo específico do PEFT "base_model.model" é removido antes e o nome do adaptador (por exemplo, "default") ainda não é inserido. Passe este argumento apenas se souber o que está fazendo.
  • kwargs — (optional): Argumentos de palavra-chave adicionais passados para a classe de configuração PEFT específica. Isso inclui torch_device (str, opcional): o dispositivo no qual o adaptador será carregado (encaminhado para load_adapter[PeftModel.load_adapter]); se None, o dispositivo será inferido.

Instancie um modelo PEFT a partir de um modelo pré-treinado e pesos PEFT carregados.

Observe que o model passado pode ser modificado in-place.

get_base_model

< >

( )

Retorna o modelo base.

get_layer_status

< >

( ) → listpeft.peft_model.TunerLayerStatus

Retorna

listpeft.peft_model.TunerLayerStatus

Uma lista de dataclasses, cada uma contendo o status da camada de adaptador correspondente.

Obtenha o status de cada camada de adaptador no modelo.

Este método retorna uma lista de instâncias da dataclass TunerLayerStatus, cada uma das quais contém os seguintes atributos:

  • name (str): O nome da camada de adaptador, por exemplo, model.encoder.block.0.layer.0.SelfAttention.q.
  • module_type (str): O tipo da camada de adaptador, por exemplo, lora.Linear.
  • enabled (bool): Se a camada de adaptador está habilitada.
  • active_adapters (list[str]): Os nomes dos adaptadores ativos, se houver, por exemplo, ["default"].
  • merged_adapters (list[str]): Os nomes dos adaptadores mesclados, se houver, por exemplo, ["default"].
  • available_adapters (list[str]): Os nomes dos adaptadores disponíveis, por exemplo, ["default"].
  • quantization_backend (str ou None): O nome do backend de quantização, por exemplo, "bnb 4bit", ou None se não estiver quantizado.

get_model_status

< >

( ) → peft.peft_model.TunerModelStatus

Retorna

peft.peft_model.TunerModelStatus

Uma dataclass contendo o status do modelo.

Obtenha o status dos tuners do modelo.

Este método retorna uma instância da dataclass TunerModelStatus, que contém os seguintes atributos:

  • base_model_type (str): O tipo do modelo base, por exemplo, T5Model.
  • adapter_model_type (str): O tipo do modelo de adaptador, por exemplo, LoraModel.
  • peft_types (dict[str, str]): O mapeamento de nome do adaptador para o tipo de adaptador, por exemplo, {"default": "LORA"}.
  • trainable_params (int): O número de parâmetros treináveis no modelo.
  • total_params (int): O número total de parâmetros no modelo.
  • num_adapter_layers (int): O número de camadas de adaptador no modelo.
  • enabled (bool, Literal["irregular"]): Indica se todas as camadas de adaptador estão habilitadas. Se algumas estiverem habilitadas e outras não, este valor será "irregular". Isso significa que seu modelo está em um estado inconsistente e pode não funcionar como esperado.
  • active_adapters (list[str], Literal["irregular"]): Os nomes dos adaptadores ativos. Se os adaptadores ativos não forem consistentes em todas as camadas, este valor será "irregular", o que significa que seu modelo está em um estado inconsistente e pode não funcionar como esperado.
  • merged_adapters (list[str], Literal["irregular"]): Os nomes dos adaptadores mesclados. Se os adaptadores mesclados não forem consistentes em todas as camadas, este valor será "irregular", o que significa que seu modelo está em um estado inconsistente e pode não funcionar como esperado.
  • available_adapters (list[str]): Os nomes dos adaptadores disponíveis, por exemplo, ["default"].
  • quantization_backend (str, None, Literal["irregular"]): O nome do backend de quantização, por exemplo, "bnb 4bit", ou None se não estiver quantizado. Se o backend não for consistente em todas as camadas, este valor será "irregular".

get_nb_trainable_parameters

< >

( )

Retorna o número de parâmetros treináveis e o número total de parâmetros no modelo.

get_prompt

< >

( batch_size: inttask_ids: Optional[torch.Tensor] = Nonemax_cache_len: Optional[int] = None )

Retorna os prompts virtuais a serem usados no Peft. Aplicável apenas ao usar um método de aprendizado de prompt.

get_prompt_embedding_to_save

< >

( adapter_name: str )

Retorna o embedding do prompt para salvar ao salvar o modelo. Aplicável apenas ao usar um método de aprendizado de prompt.

healthcheck

< >

( min_trainable_params: int = 1max_trainable_params_percent = 50 )

Parâmetros

  • min_trainable_params (int, opcional, default=1) — Número mínimo esperado de parâmetros. Se menos parâmetros forem encontrados, isso será reportado como um erro.
  • max_trainable_params_percent (int, opcional, default=50) — A porcentagem máxima de parâmetros que devem ser treináveis. Se mais parâmetros forem encontrados, isso é relatado como um aviso.

Verifique este modelo em busca de estados de adaptador suspeitos antes do treinamento.

Esta função resume as APIs de status do modelo e das camadas e inclui achados para estado de adaptador inconsistente, adaptadores mesclados e números implausíveis de parâmetros treináveis. Ela não valida o loop de treinamento, o otimizador ou o conjunto de dados. Um status será reportado como "irregular" se inconsistências forem encontradas no modelo, por exemplo, quando, para o mesmo adaptador, algumas camadas estão habilitadas e outras estão desabilitadas. Isso quase sempre significa que algo deu errado e que você deve verificar se não alterou acidentalmente alguns atributos no modelo incorretamente.

Se a verificação encontrou algo suspeito, isso será relatado no campo "findings". Uma lista "findings"" vazia significa que nenhum estado de adaptador suspeito foi detectado, e não que uma execução de treinamento está garantida a ter sucesso.

load_adapter

< >

( model_id: Union[str, os.PathLike]adapter_name: stris_trainable: bool = Falsetorch_device: Optional[str] = Noneautocast_adapter_dtype: bool = Trueephemeral_gpu_offload: bool = Falselow_cpu_mem_usage: bool = Falsekey_mapping: Optional[dict[str, str]] = None**kwargs: Any )

Parâmetros

  • model_id (str ou os.PathLike) — O nome da configuração PEFT a ser usada. Pode ser:
    • Uma string, o model id de uma configuração PEFT hospedada em um repositório de modelos no Hugging Face Hub.
    • Um caminho para um diretório contendo um arquivo de configuração PEFT salvo usando o método save_pretrained (./my_peft_config_directory/).
  • adapter_name (str) — O nome do adaptador a ser adicionado.
  • is_trainable (bool, opcional, padrão False) — Se o adaptador deve ser treinável ou não. Se False, o adaptador será congelado e poderá ser usado apenas para inferência.
  • torch_device (str, opcional, padrão None) — O dispositivo no qual o adaptador será carregado. Se None, o dispositivo será inferido.
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte os pesos do adaptador de float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas alguns tuners PEFT. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.
  • ephemeral_gpu_offload (bool, opcional, padrão False) — Se deve usar o offloading efêmero de GPU para módulos parcialmente carregados. O padrão é False.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta antes de carregar os pesos salvos. Útil para acelerar o processo.
  • key_mapping (dict, opcional, padrão None) — Mapeamento extra de chaves do state_dict do PEFT aplicado antes de carregar o state_dict. Quando esse mapeamento é aplicado, o prefixo específico do PEFT "base_model.model" é removido antes e o nome do adaptador (por exemplo, "default") ainda não é inserido. Passe este argumento apenas se souber o que está fazendo.
  • kwargs — (optional): Argumentos adicionais para modificar a forma como o adaptador é carregado, por exemplo, o token para o Hugging Face Hub.

Carregue um adaptador treinado no modelo.

O nome do novo adaptador deve ser único.

O novo adaptador não é definido automaticamente como o adaptador ativo. Use PeftModel.set_adapter() para definir o adaptador ativo.

prepare_model_for_gradient_checkpointing

< >

( model: PreTrainedModel )

Prepara o modelo para checkpointing de gradiente, se necessário

Observação: nas versões mais recentes do Transformers, isso é chamado de ‘activation checkpointing’.

print_healthcheck

< >

( sink = <built-in function print>min_trainable_params: int = 1max_trainable_params_percent = 50**kwargs )

Parâmetros

  • sink (callable, opcional, padrão=print) — Função que é chamada para imprimir a saída. Por padrão, apenas a função embutida print, mas também pode ser outra coisa, como logger.info.
  • min_trainable_params (int, opcional, default=1) — Número mínimo esperado de parâmetros. Se menos parâmetros forem encontrados, isso será reportado como um erro.
  • max_trainable_params_percent (int, opcional, default=50) — A porcentagem máxima de parâmetros que devem ser treináveis. Se mais parâmetros forem encontrados, isso é relatado como um aviso.
  • kwargs — Outros argumentos de palavra-chave são passados para format_healthcheck.

Imprima um relatório de verificação de saúde compacto e legível.

A saída resume o estado do seu modelo PEFT e inclui achados sobre estado de adaptador inconsistente, adaptadores mesclados e números implausíveis de parâmetros treináveis. Ela não valida o loop de treinamento, o otimizador ou o conjunto de dados. Um status será reportado como "irregular" se inconsistências forem encontradas no modelo, por exemplo, quando, para o mesmo adaptador, algumas camadas estão habilitadas e outras estão desabilitadas. Isso quase sempre significa que algo deu errado e que você deve verificar se não alterou acidentalmente alguns atributos no modelo incorretamente.

Se problemas foram detectados, eles serão exibidos na última seção, sob “findings”. Se nenhum problema foi detectado, isso não significa que uma execução de treinamento está garantida a ter sucesso.

print_trainable_parameters

< >

( )

Imprime o número de parâmetros treináveis no modelo.

Nota: print_trainable_parameters() usa get_nb_trainable_parameters(), que é diferente de num_parameters(only_trainable=True) do huggingface/transformers. get_nb_trainable_parameters() retorna (parâmetros treináveis, todos os parâmetros) do Modelo Peft, que inclui o modelo transformer de backbone modificado. Para técnicas como LoRA, o modelo transformer de backbone é modificado no local com os módulos LoRA. No entanto, para prompt tuning, o modelo transformer de backbone permanece inalterado. num_parameters(only_trainable=True) retorna o número de parâmetros treináveis do modelo transformer de backbone, o que pode ser diferente.

save_pretrained

< >

( save_directory: strsafe_serialization: bool = Trueselected_adapters: Optional[list[str]] = Nonesave_embedding_layers: Union[str, bool] = 'auto'is_main_process: bool = Truepath_initial_model_for_weight_conversion: Optional[str] = None**kwargs: Any )

Parâmetros

  • save_directory (str) — Diretório onde os arquivos de modelo do adaptador e de configuração serão salvos (será criado se não existir).
  • safe_serialization (bool, opcional) — Se os arquivos de adaptador devem ser salvos no formato safetensors, padrão é True.
  • selected_adapters (List[str], opcional) — Uma lista de adaptadores a serem salvos. Se None, o padrão será todos os adaptadores.
  • save_embedding_layers (Union[bool, str], opcional, padrão "auto") — Se True, salva as camadas de embedding além dos pesos do adaptador. Se auto, verifica as camadas de embedding comuns peft.utils.other.EMBEDDING_LAYER_NAMES em target_modules da configuração, quando disponível, e define automaticamente a flag booleana. Isso só funciona para modelos 🤗 transformers.
  • is_main_process (bool, opcional) — Indica se o processo que está chamando este método é o processo principal ou não. O valor padrão é True. O checkpoint não será salvo se não estiver no processo principal, o que é importante para configurações com múltiplos dispositivos (por exemplo, DDP).
  • path_initial_model_for_weight_conversion (str, opcional) — O caminho para o adaptador inicializado, obtido após a inicialização do modelo com PiSSA/CorDA/OLoRA e antes de executar qualquer treinamento. Quando path_initial_model_for_weight_conversion não é None, a diferença no adaptador antes e depois do fine-tuning é calculada. Essa diferença pode ser representada como os parâmetros de um adaptador LoRA padrão. Diferentemente do PiSSA e afins, o uso deste adaptador convertido não requer alterações no modelo base, permitindo convenientemente o uso de múltiplos adaptadores PiSSA/CorDA/OLoRA com adaptadores LoRA, bem como a ativação ou desativação de qualquer adaptador. Observe que essa conversão não é suportada se rslora for usado em combinação com rank_pattern ou alpha_pattern. Consulte peft.tuners.lora.LoraModel.subtract_mutated_init() para mais informações.
  • kwargs (argumentos de palavra-chave adicionais, opcional) — Argumentos de palavra-chave adicionais passados ao método push_to_hub.

Esta função salva o modelo de adaptador e os arquivos de configuração do adaptador em um diretório, para que ele possa ser recarregado usando o método de classe PeftModel.from_pretrained() e também utilizado pelo método PeftModel.push_to_hub().

set_adapter

< >

( adapter_name: strinference_mode: bool = False )

Parâmetros

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

Define o adaptador ativo.

Apenas um adaptador pode estar ativo por vez, pois nem todos os métodos PEFT suportam múltiplos adaptadores ativos. Para ativar múltiplos adaptadores em métodos compatíveis, use model.base_model.set_adapter(adapter_names).

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_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.

Observação: Não é suportado para métodos de aprendizado de prompt, como prompt tuning.

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.

PeftModelForSequenceClassification

Um PeftModel para tarefas de classificação de sequência.

classe peft.PeftModelForSequenceClassification

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parâmetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuração do Peft.
  • adapter_name (str, opcional) — O nome do adaptador, padrão é "default".
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte pesos de adaptadores usando float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas seletores de PEFT tuners. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Modelo Peft para tarefas de classificação de sequência.

Atributos:

  • config (PretrainedConfig) — O objeto de configuração do modelo base.
  • cls_layer_name (str) — O nome da camada de classificação.

Exemplo:

>>> from transformers import AutoModelForSequenceClassification
>>> from peft import PeftModelForSequenceClassification, get_peft_config

>>> config = {
...     "peft_type": "PREFIX_TUNING",
...     "task_type": "SEQ_CLS",
...     "inference_mode": False,
...     "num_virtual_tokens": 20,
...     "token_dim": 768,
...     "num_transformer_submodules": 1,
...     "num_attention_heads": 12,
...     "num_layers": 12,
...     "encoder_hidden_size": 768,
...     "prefix_projection": False,
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForSequenceClassification(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117

PeftModelForTokenClassification

Um PeftModel para tarefas de classificação de tokens.

classe peft.PeftModelForTokenClassification

< >

( model: torch.nn.Modulepeft_config: PeftConfig = Noneadapter_name: str = 'default'**kwargs )

Parâmetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuração do Peft.
  • adapter_name (str, opcional) — O nome do adaptador, padrão é "default".
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte pesos de adaptadores usando float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas seletores de PEFT tuners. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Modelo Peft para tarefas de classificação de tokens.

Atributos:

  • config (PretrainedConfig) — O objeto de configuração do modelo base.
  • cls_layer_name (str) — O nome da camada de classificação.

Exemplo:

>>> from transformers import AutoModelForTokenClassification
>>> from peft import PeftModelForTokenClassification, get_peft_config

>>> config = {
...     "peft_type": "PREFIX_TUNING",
...     "task_type": "TOKEN_CLS",
...     "inference_mode": False,
...     "num_virtual_tokens": 20,
...     "token_dim": 768,
...     "num_transformer_submodules": 1,
...     "num_attention_heads": 12,
...     "num_layers": 12,
...     "encoder_hidden_size": 768,
...     "prefix_projection": False,
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForTokenClassification.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForTokenClassification(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 370178 || all params: 108680450 || trainable%: 0.3406113979101117

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parâmetros

  • adapter_name (str) — O nome do adaptador a ser adicionado.
  • peft_config (PeftConfig) — A configuração do adaptador a ser adicionado.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo ao carregar adaptadores salvos. Não use esta opção ao criar um novo adaptador PEFT para treinamento.
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte os pesos do adaptador de float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas alguns tuners PEFT. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Adicione um adaptador ao modelo com base na configuração passada.

Este adaptador não foi treinado. Para carregar um adaptador treinado, consulte PeftModel.load_adapter().

O nome do novo adaptador deve ser único.

O novo adaptador não é definido automaticamente como o adaptador ativo. Use PeftModel.set_adapter() para definir o adaptador ativo.

PeftModelForCausalLM

Um PeftModel para modelagem de linguagem causal.

classe peft.PeftModelForCausalLM

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parâmetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuração do Peft.
  • adapter_name (str, opcional) — O nome do adaptador, padrão é "default".
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte pesos de adaptadores usando float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas seletores de PEFT tuners. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Modelo Peft para modelagem de linguagem causal.

Exemplo:

>>> from transformers import AutoModelForCausalLM
>>> from peft import PeftModelForCausalLM, get_peft_config

>>> config = {
...     "peft_type": "PREFIX_TUNING",
...     "task_type": "CAUSAL_LM",
...     "inference_mode": False,
...     "num_virtual_tokens": 20,
...     "token_dim": 1280,
...     "num_transformer_submodules": 1,
...     "num_attention_heads": 20,
...     "num_layers": 36,
...     "encoder_hidden_size": 1280,
...     "prefix_projection": False,
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForCausalLM.from_pretrained("gpt2-large")
>>> peft_model = PeftModelForCausalLM(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 1843200 || all params: 775873280 || trainable%: 0.23756456724479544

PeftModelForSeq2SeqLM

Um PeftModel para modelagem de linguagem sequencial.

Observação: isso gerará automaticamente os tokens de entrada do decodificador deslocando os tokens de entrada um passo para a direita usando shift_tokens_right() se você fornecer tokens de entrada, mas não fornecer explicitamente tokens de entrada do decodificador.

classe peft.PeftModelForSeq2SeqLM

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parâmetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuração do Peft.
  • adapter_name (str, opcional) — O nome do adaptador, padrão é "default".
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte pesos de adaptadores usando float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas seletores de PEFT tuners. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Modelo Peft para modelagem de linguagem sequencial-para-sequencial.

Exemplo:

>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import PeftModelForSeq2SeqLM, get_peft_config

>>> config = {
...     "peft_type": "LORA",
...     "task_type": "SEQ_2_SEQ_LM",
...     "inference_mode": False,
...     "r": 8,
...     "target_modules": ["q", "v"],
...     "lora_alpha": 32,
...     "lora_dropout": 0.1,
...     "fan_in_fan_out": False,
...     "bias": "none",
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> peft_model = PeftModelForSeq2SeqLM(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 884736 || all params: 223843584 || trainable%: 0.3952474242013566

PeftModelForQuestionAnswering

Um PeftModel para resposta a perguntas.

classe peft.PeftModelForQuestionAnswering

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parâmetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuração do Peft.
  • adapter_name (str, opcional) — O nome do adaptador, padrão é "default".
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte pesos de adaptadores usando float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas seletores de PEFT tuners. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Modelo Peft para resposta a perguntas extrativa.

Atributos:

  • config (PretrainedConfig) — O objeto de configuração do modelo base.
  • cls_layer_name (str) — O nome da camada de classificação.

Exemplo:

>>> from transformers import AutoModelForQuestionAnswering
>>> from peft import PeftModelForQuestionAnswering, get_peft_config

>>> config = {
...     "peft_type": "LORA",
...     "task_type": "QUESTION_ANS",
...     "inference_mode": False,
...     "r": 16,
...     "target_modules": ["query", "value"],
...     "lora_alpha": 32,
...     "lora_dropout": 0.05,
...     "fan_in_fan_out": False,
...     "bias": "none",
... }

>>> peft_config = get_peft_config(config)
>>> model = AutoModelForQuestionAnswering.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForQuestionAnswering(model, peft_config)
>>> peft_model.print_trainable_parameters()
trainable params: 592900 || all params: 108312580 || trainable%: 0.5473971721475013

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parâmetros

  • adapter_name (str) — O nome do adaptador a ser adicionado.
  • peft_config (PeftConfig) — A configuração do adaptador a ser adicionado.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo ao carregar adaptadores salvos. Não use esta opção ao criar um novo adaptador PEFT para treinamento.
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte os pesos do adaptador de float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas alguns tuners PEFT. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Adicione um adaptador ao modelo com base na configuração passada.

Este adaptador não foi treinado. Para carregar um adaptador treinado, consulte PeftModel.load_adapter().

O nome do novo adaptador deve ser único.

O novo adaptador não é definido automaticamente como o adaptador ativo. Use PeftModel.set_adapter() para definir o adaptador ativo.

PeftModelForFeatureExtraction

Um PeftModel para extrair recursos/embutidos de modelos transformer.

classe peft.PeftModelForFeatureExtraction

< >

( model: torch.nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'**kwargs )

Parâmetros

  • model (PreTrainedModel) — Modelo transformer base.
  • peft_config (PeftConfig) — Configuração do Peft.
  • adapter_name (str, opcional) — O nome do adaptador, padrão é "default".
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte pesos de adaptadores usando float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas seletores de PEFT tuners. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Modelo Peft para extrair recursos/embutidos de modelos transformer

Atributos:

  • config (PretrainedConfig) — O objeto de configuração do modelo base.

Exemplo:

>>> from transformers import AutoModel
>>> from peft import PeftModelForFeatureExtraction, get_peft_config

>>> config = {
...     "peft_type": "LORA",
...     "task_type": "FEATURE_EXTRACTION",
...     "inference_mode": False,
...     "r": 16,
...     "target_modules": ["query", "value"],
...     "lora_alpha": 32,
...     "lora_dropout": 0.05,
...     "fan_in_fan_out": False,
...     "bias": "none",
... }
>>> peft_config = get_peft_config(config)
>>> model = AutoModel.from_pretrained("bert-base-cased")
>>> peft_model = PeftModelForFeatureExtraction(model, peft_config)
>>> peft_model.print_trainable_parameters()

PeftMixedModel

Um PeftModel para misturar diferentes tipos de adaptador (por exemplo, LoRA e LoHa).

classe peft.PeftMixedModel

< >

( model: nn.Modulepeft_config: PeftConfigadapter_name: str = 'default' )

Parâmetros

  • model (torch.nn.Module) — O modelo a ser ajustado.
  • config (PeftConfig) — A configuração do modelo a ser ajustado. O tipo de adaptador deve ser compatível.
  • adapter_name (str, optional, defaults to "default") — O nome do primeiro adaptador.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento.

PeftMixedModel para carregar e misturar diferentes tipos de adaptadores para inferência.

Esta classe não suporta carregamento/salvamento e não deve ser inicializada diretamente. Em vez disso, use get_peft_model com o argumento mixed=True.

> Leia o guia Tipos de adaptador mistos para saber > mais sobre o uso de diferentes tipos de adaptador.

Exemplo:

>>> base_model = ...  # load the base model, e.g. from transformers
>>> peft_model = PeftMixedModel.from_pretrained(base_model, path_to_adapter1, "adapter1").eval()
>>> peft_model.load_adapter(path_to_adapter2, "adapter2")
>>> peft_model.set_adapter(["adapter1", "adapter2"])  # activate both adapters
>>> peft_model(data)  # forward pass using both adapters

add_adapter

< >

( adapter_name: strpeft_config: PeftConfiglow_cpu_mem_usage: bool = Falseautocast_adapter_dtype: bool = True )

Parâmetros

  • adapter_name (str) — O nome do adaptador a ser adicionado.
  • peft_config (PeftConfig) — A configuração do adaptador a ser adicionado.
  • low_cpu_mem_usage (bool, optional, padrão é False) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo ao carregar adaptadores salvos.

    > Não use low_cpu_mem_usage=True ao criar um novo adaptador PEFT para treinamento (o treinamento não foi testado > e é desencorajado para PeftMixedModel em geral).

  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte os pesos do adaptador de float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas alguns tuners PEFT. Se definido como False, os dtypes permanecerão os mesmos dos da camada correspondente.

Adicione um adaptador ao modelo com base na configuração passada.

Este adaptador não foi treinado. Para carregar um adaptador treinado, consulte PeftModel.load_adapter().

O nome do novo adaptador deve ser único.

O novo adaptador não é definido automaticamente como o adaptador ativo. Use PeftModel.set_adapter() para definir o adaptador ativo.

disable_adapter

< >

( )

Desativa o módulo de adaptador.

forward

< >

( *args: Any**kwargs: Any )

Passada para frente do modelo.

from_pretrained

< >

( model: nn.Modulemodel_id: str | os.PathLikeadapter_name: str = 'default'is_trainable: bool = Falseconfig: Optional[PeftConfig] = None**kwargs: Any )

Parâmetros

  • model (nn.Module) — O modelo a ser adaptado.
  • model_id (str ou os.PathLike) — O nome da configuração PEFT a ser usada. Pode ser:
    • Uma string, o model id de uma configuração PEFT hospedada em um repositório de modelos no Hugging Face Hub.
    • Um caminho para um diretório contendo um arquivo de configuração PEFT salvo usando o método save_pretrained (./my_peft_config_directory/).
  • adapter_name (str, opcional, padrão "default") — O nome do adaptador a ser carregado. Isso é útil para carregar múltiplos adaptadores.
  • is_trainable (bool, opcional, padrão False) — Se o adaptador deve ser treinável ou não. Se False, o adaptador será congelado e usado para inferência
  • config (PeftConfig, opcional) — O objeto de configuração a ser usado no lugar de uma configuração carregada automaticamente. Este objeto de configuração é mutuamente exclusivo com model_id e kwargs. Isso é útil quando a configuração já foi carregada antes de chamar from_pretrained.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta antes de carregar os pesos salvos. Útil para acelerar o processo.
  • kwargs — (optional): Additional keyword arguments passed along to the specific PEFT configuration class.

Instancie um modelo PEFT misto a partir de um modelo pré-treinado e pesos PEFT carregados.

Observe que o model passado pode ser modificado in-place.

generate

< >

( *args: Any**kwargs: Any )

Gerar a saída.

get_nb_trainable_parameters

< >

( )

Retorna o número de parâmetros treináveis e o número total de parâmetros no modelo.

load_adapter

< >

( model_id: stradapter_name: str*args: Any**kwargs: Any )

Parâmetros

  • adapter_name (str) — O nome do adaptador a ser adicionado.
  • peft_config (PeftConfig) — A configuração do adaptador a ser adicionado.
  • is_trainable (bool, opcional, padrão False) — Se o adaptador deve ser treinável ou não. Se False, o adaptador será congelado e poderá ser usado apenas para inferência.
  • torch_device (str, opcional, padrão None) — O dispositivo no qual o adaptador será carregado. Se None, o dispositivo será inferido.
  • autocast_adapter_dtype (bool, opcional, padrão True) — Se deve aplicar autocast ao dtype do adaptador. O padrão é True. Atualmente, isso apenas converte os pesos do adaptador de float16 e bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas alguns tuners PEFT.
  • ephemeral_gpu_offload (bool, opcional, padrão False) — Se deve usar o offloading efêmero de GPU para módulos parcialmente carregados. O padrão é False.
  • low_cpu_mem_usage (bool, optional, defaults to False) — Cria pesos de adaptador vazios no dispositivo meta antes de carregar os pesos salvos. Útil para acelerar o processo.
  • kwargs — (optional): Argumentos adicionais para modificar a forma como o adaptador é carregado, por exemplo, o token para o Hugging Face Hub.

Carregue um adaptador treinado no modelo.

O nome do novo adaptador deve ser único.

O novo adaptador não é definido automaticamente como o adaptador ativo. Use PeftModel.set_adapter() para definir o adaptador ativo.

merge_and_unload

< >

( *args: Any**kwargs: Any )

Parâmetros

  • progressbar (bool) — se deve exibir uma barra de progresso indicando o processo de descarregamento e mesclagem
  • 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.

print_trainable_parameters

< >

( )

Imprime o número de parâmetros treináveis no modelo.

Nota: print_trainable_parameters() usa get_nb_trainable_parameters(), que é diferente de num_parameters(only_trainable=True) do huggingface/transformers. get_nb_trainable_parameters() retorna (parâmetros treináveis, todos os parâmetros) do Modelo Peft, que inclui o modelo transformer de backbone modificado. Para técnicas como LoRA, o modelo transformer de backbone é modificado no local com os módulos LoRA. No entanto, para prompt tuning, o modelo transformer de backbone permanece inalterado. num_parameters(only_trainable=True) retorna o número de parâmetros treináveis do modelo transformer de backbone, o que pode ser diferente.

set_adapter

< >

( adapter_name: Union[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.

Define o(s) adaptador(es) ativo(s) para o modelo.

Observe que a ordem em que os adaptadores são aplicados durante a passagem para frente pode não ser a mesma da ordem em que são passados para esta função. Em vez disso, a ordem durante a passagem para frente é determinada pela ordem em que os adaptadores foram carregados no modelo. Os adaptadores ativos determinam apenas quais adaptadores estão ativos durante a passagem para frente, mas não a ordem em que são aplicados.

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.

descarregar

< >

( *args: Any**kwargs: Any )

Recupera o modelo base removendo todos os módulos de adaptador sem mesclá-los. Isso devolve o modelo base original.

Utilitários

peft.cast_mixed_precision_params

< >

( model: torch.nn.Moduledtype: torch.dtype )

Parâmetros

  • model (torch.nn.Module) — O modelo para o qual os parâmetros não treináveis devem ser convertidos.
  • dtype (torch.dtype) — O dtype para o qual os parâmetros não treináveis devem ser convertidos. O dtype pode ser torch.float16 ou

Converte todos os parâmetros não treináveis do modelo para o dtype especificado. O dtype pode ser torch.float16 ou torch.bfloat16, conforme o treinamento de precisão mista que você está executando. Os parâmetros treináveis são convertidos para precisão completa. Isso visa reduzir o uso de memória da GPU ao usar métodos PEFT, empregando dtype de meia precisão para os parâmetros não treináveis. Manter os parâmetros treináveis em precisão completa preserva a estabilidade do treinamento ao usar treinamento de precisão mista automática.

torch.bfloat16 conforme o treinamento de precisão mista que você está executando.

peft.get_peft_model

< >

( model: nn.Modulepeft_config: PeftConfigadapter_name: str = 'default'mixed: bool = Falseautocast_adapter_dtype: bool = Truerevision: Optional[str] = Nonelow_cpu_mem_usage: bool = False )

Parâmetros

  • model (torch.nn.Module) — Modelo a ser envolvido. Tipicamente, este é um modelo do Transformers, mas qualquer nn.Module pode funcionar, com a ressalva de que os recursos específicos de tarefa (peft_config.task_type) exigem que o modelo siga as convenções do Transformers.
  • peft_config (PeftConfig) — Objeto de configuração contendo os parâmetros do modelo Peft.
  • adapter_name (str, optional, defaults to "default") — O nome do adaptador a ser injetado. Se não for fornecido, o nome padrão do adaptador é utilizado (“default”).
  • mixed (bool, optional, padrão False) — Se permite misturar diferentes tipos de adaptador (compatíveis).
  • autocast_adapter_dtype (bool, opcional) — Se deve aplicar autocast ao dtype do adaptador. O valor padrão é True. No momento, isso apenas converte pesos de adaptadores usando float16 ou bfloat16 para float32, pois isso é geralmente necessário para um treinamento estável, e afeta apenas selecionados tuners PEFT.
  • revision (str, optional, padrão main) — A revisão do modelo base. Se não for definida, o modelo peft salvo carregará a revisão main do modelo base
  • low_cpu_mem_usage (bool, optional, defaults to False) — Create empty adapter weights on meta device. Useful to speed up the loading process. Leave this setting as False if you intend on training the model, unless the adapter weights will be replaced by different weights before training starts.

Retorna um objeto de modelo Peft a partir de um modelo e uma configuração, onde o modelo será modificado in-place.

peft.inject_adapter_in_model

< >

( peft_config: PeftConfigmodel: torch.nn.Moduleadapter_name: str = 'default'low_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Parâmetros

  • peft_config (PeftConfig) — Objeto de configuração contendo os parâmetros do modelo PEFT.
  • model (torch.nn.Module) — O modelo de entrada onde o adaptador será injetado.
  • adapter_name (str, optional, defaults to "default") — O nome do adaptador a ser injetado. Se não for fornecido, o nome padrão do adaptador é utilizado (“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.
  • 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.

Crie camadas PEFT e injete-as no modelo in-place.

Atualmente, a API não suporta métodos de aprendizado de prompt, prompt de adaptação ou tuners que mantêm o estado do adaptador compartilhado entre várias camadas de destino. Use get_peft_model() para o último caso.

Esta função é semelhante a get_peft_model(), mas não retorna uma instância de PeftModel. Em vez disso, retorna a instância original, modificada, do modelo passado.

peft.get_peft_model_state_dict

< >

( modelstate_dict = Noneadapter_name: str = 'default'unwrap_compiled: bool = Falsesave_embedding_layers: bool | Literal['auto'] = 'auto' )

Parâmetros

  • model (PeftModel) — O modelo Peft. Ao usar torch.nn.DistributedDataParallel, DeepSpeed ou FSDP, o modelo deve ser o modelo subjacente/desembrulhado (ou seja, model.module).
  • state_dict (dict, opcional, padrão None) — O state dict do modelo. Se não for fornecido, o state dict do modelo passado será utilizado.
  • adapter_name (str, opcional, padrão "default") — O nome do adaptador cujo state dict deve ser retornado.
  • unwrap_compiled (bool, opcional, padrão False) — Se deve desembrulhar o modelo caso torch.compile tenha sido usado.
  • save_embedding_layers (Union[bool, str], , opcional, padrão auto) — Se True, salva as camadas de embedding além dos pesos do adaptador. Se auto, verifica as camadas de embedding comuns peft.utils.other.EMBEDDING_LAYER_NAMES em target_modules da configuração, quando disponível. Com base nisso, define a flag booleana. Isso só funciona para modelos 🤗 transformers.

Obtenha o state dict do adaptador especificado do modelo PEFT.

Isso inclui apenas os parâmetros do PEFT, não os parâmetros do modelo base. Assim, o state_dict retornado é geralmente pequeno em comparação com o tamanho total do modelo. Para recuperar o state_dict completo, basta chamar model.state_dict().

Observe que o nome do adaptador é removido do state_dict, pois se trata apenas de um nome arbitrário que pode ser alterado ao carregar o adaptador. Portanto, por exemplo, se o nome do adaptador for 'default' e a chave original for 'model.q_proj.lora_A.default.weight', a chave retornada será 'model.q_proj.lora_A.weight'. Use esta função em conjunto com set_peft_model_state_dict() para lidar com o nome do adaptador ao carregar os pesos.

peft.prepare_model_for_kbit_training

< >

( modeluse_gradient_checkpointing = Trueactivation_checkpointing_kwargs = Noneauto_clear_cache = Truegradient_checkpointing_kwargs = None )

Parâmetros

  • model (transformers.PreTrainedModel) — O modelo carregado do transformers
  • use_gradient_checkpointing (bool, opcional, padrão True) — Se True, usa gradient checkpointing para economizar memória em detrimento de uma passagem reversa mais lenta.
  • activation_checkpointing_kwargs (dict, opcional, padrão None) — Argumentos de palavra-chave para passar à função de checkpointing de ativação. Consulte a documentação de torch.utils.checkpoint.checkpoint para mais detalhes sobre os argumentos que podem ser passados a esse método. Observe que isso está disponível apenas nas versões do transformers (> 4.34.1).
  • auto_clear_cache (bool, opcional, padrão True) — Se deve esvaziar o cache do acelerador após fazer o upcasting dos parâmetros para fp32. Isso libera a memória retida pelo alocador de cache, o que é especialmente útil em dispositivos que compartilham memória de host e acelerador. Defina como False para pular esta etapa.
  • gradient_checkpointing_kwargs (dict, opcional, padrão None) — Argumentos de palavra-chave para passar à função de checkpointing de ativação. Este argumento existe apenas para compatibilidade com versões anteriores e está obsoleto; use activation_checkpointing_kwargs em vez disso. Ele será removido na PEFT v1.2.

Observe que este método funciona apenas para modelos do transformers.

Este método encapsula todo o protocolo para preparar um modelo antes de executar um treinamento. Isso inclui: 1- Converter o layernorm para fp32 2- Fazer a camada de saída de embedding exigir grads 3- Adicionar o upcasting da lm head para fp32 4- Congelar as camadas do modelo base para garantir que elas não sejam atualizadas durante o treinamento

peft.get_layer_status

< >

( model: torch.nn.Module ) → listpeft.peft_model.TunerLayerStatus

Parâmetros

  • model ([Union[~PeftModel, ~transformers.PreTrainedModel, nn.Module]]) — O modelo do qual se deseja obter o status da camada de adaptador.

Retorna

listpeft.peft_model.TunerLayerStatus

Uma lista de dataclasses, cada uma contendo o status da camada de adaptador correspondente.

Obtenha o status de cada camada de adaptador no modelo.

Esta função retorna uma lista de instâncias da dataclass TunerLayerStatus, cada uma das quais contém os seguintes atributos:

  • name (str): O nome da camada de adaptador, por exemplo, model.encoder.block.0.layer.0.SelfAttention.q.
  • module_type (str): O tipo da camada de adaptador, por exemplo, lora.Linear.
  • enabled (bool): Se a camada de adaptador está habilitada.
  • active_adapters (list[str]): Os nomes dos adaptadores ativos, se houver, por exemplo, ["default"].
  • merged_adapters (list[str]): Os nomes dos adaptadores mesclados, se houver, por exemplo, ["default"].
  • requires_grad : dict[str, bool | Literal[“irregular”]] O status de requires_grad dos parâmetros para cada módulo de adaptador. Idealmente, ele deve ser True ou False. Se o status de requires_grad não for consistente entre todos os parâmetros, o valor será definido como "irregular".
  • available_adapters (list[str]): Os nomes dos adaptadores disponíveis, por exemplo, ["default"].
  • devices (dict[str, list[str]]): Os dispositivos onde os parâmetros do adaptador dado são armazenados, por exemplo, ["cuda","xpu"].
  • quantization_backend (str ou None): O nome do backend de quantização, por exemplo, "bnb 4bit", ou None se não estiver quantizado.

peft.get_model_status

< >

( model: torch.nn.Module ) → peft.peft_model.TunerModelStatus

Parâmetros

  • model ([Union[~PeftModel, ~transformers.PreTrainedModel, nn.Module]]) — O modelo do qual se deseja obter o status da camada de adaptador.

Retorna

peft.peft_model.TunerModelStatus

Uma dataclass contendo o status do modelo.

Obtenha o status dos tuners do modelo.

Esta função retorna uma instância da dataclass TunerModelStatus, que contém os seguintes atributos:

  • base_model_type (str): O tipo do modelo base, por exemplo, T5Model.
  • adapter_model_type (str): O tipo do modelo de adaptador, por exemplo, LoraModel.
  • peft_types (dict[str, str]): O mapeamento de nome do adaptador para o tipo de adaptador, por exemplo, {"default": "LORA"}.
  • trainable_params (int): O número de parâmetros treináveis no modelo.
  • total_params (int): O número total de parâmetros no modelo.
  • num_adapter_layers (int): O número de camadas de adaptador no modelo.
  • enabled (bool, Literal["irregular"]): Se todas as camadas de adaptador estão habilitadas. Se algumas estiverem habilitadas e outras não, este valor será "irregular". Isso significa que seu modelo está em um estado inconsistente e pode não funcionar como esperado.
  • active_adapters (list[str], Literal["irregular"]): Os nomes dos adaptadores ativos. Se os adaptadores ativos não forem consistentes em todas as camadas, este valor será "irregular", o que significa que seu modelo está em um estado inconsistente e pode não funcionar como esperado.
  • merged_adapters (list[str], Literal["irregular"]): Os nomes dos adaptadores mesclados. Se os adaptadores mesclados não forem consistentes em todas as camadas, este valor será "irregular", o que significa que seu modelo está em um estado inconsistente e pode não funcionar como esperado.
  • requires_grad (dict[str, bool | Literal["irregular"]]): Se, para o adaptador dado, todas as camadas do adaptador têm requires_grad definido como True ou False. Se houver uma mistura, isso será definido como "irregular", o que significa que seu modelo está em um estado inconsistente e pode não funcionar como esperado.
  • available_adapters (list[str]): Os nomes dos adaptadores disponíveis, por exemplo, ["default"].
  • devices (dict[str, list[str]]): Os dispositivos onde os parâmetros do adaptador dado são armazenados, por exemplo, ["cuda","xpu"].
  • quantization_backend (str, None, Literal["irregular"]): O nome do backend de quantização, por exemplo, "bnb 4bit", ou None se não estiver quantizado. Se o backend não for consistente em todas as camadas, este valor será "irregular".
Update on GitHub

←AutoPeftModel Tipos de PEFT→