PEFT documentation

LoHa

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

and get access to the augmented documentation experience

to get started

LoHa

Navigating Text-To-Image Customization: From LyCORIS Fine-Tuning to Model Evaluation

O produto de Hadamard de baixo posto (LoHa) é semelhante ao LoRA, exceto que aproxima a grande matriz de pesos com mais matrizes de baixo posto e as combina com o produto de Hadamard. Este método é ainda mais eficiente em termos de parâmetros que o LoRA e alcança desempenho comparável. O LoHa foi originalmente proposto para aprendizado federado (FedPara), mas funciona bem como um método PEFT de uso geral e é especialmente popular para ajuste fino de modelos de geração de imagens, como o Stable Diffusion.

Observação: LoHa faz parte da família de adaptadores LyCORIS. Seu parente próximo, LoKr, usa o produto de Kronecker em vez do produto de Hadamard.

O resumo do artigo é:

Neste trabalho, propomos uma parametrização eficiente em termos de comunicação, FedPara, para aprendizado federado (FL), a fim de superar as cargas associadas a uploads e downloads frequentes de modelos. Nosso método reparametriza os parâmetros de peso das camadas usando pesos de baixo posto seguidos pelo produto de Hadamard. Em comparação com a parametrização de baixo posto convencional, nosso método FedPara não é restrito a restrições de baixo posto e, portanto, possui uma capacidade muito maior. Essa propriedade permite alcançar desempenho comparável exigindo custos de comunicação de 3 a 10 vezes menores do que o modelo com as camadas originais, algo que não é alcançável pelos métodos tradicionais de baixo posto. A eficiência do nosso método pode ser ainda mais aprimorada ao ser combinado com outros otimizadores de FL eficientes. Além disso, estendemos nosso método para uma aplicação de FL personalizado, pFedPara, que separa os parâmetros em globais e locais. Mostramos que o pFedPara supera os métodos de FL personalizados concorrentes com mais de três vezes menos parâmetros.

A decomposição de baixo rank pode impactar o desempenho, pois as atualizações de pesos são limitadas ao espaço de baixo rank, o que pode restringir a expressividade de um modelo. No entanto, nem sempre é desejável usar um rank maior, pois isso aumenta o número de parâmetros treináveis. Para lidar com isso, o LoHa foi aplicado a modelos de difusão, nos quais a capacidade de gerar imagens diversas é uma consideração importante. O LoHa também deve funcionar com tipos gerais de modelos, mas o suporte para camadas de incorporação (embedding) ainda não está implementado no PEFT.

O LoHa usa o produto de Hadamard (produto elemento a elemento) em vez do produto de matrizes. ΔW\Delta W é representado por quatro matrizes menores em vez de duas - como no LoRA - e cada par dessas matrizes de baixo posto é combinado com o produto de Hadamard. Como resultado, ΔW\Delta W pode ter o mesmo número de parâmetros treináveis, mas com um posto e uma expressividade maiores.

Quando usar LoHa

LoHa é uma boa escolha quando:

  • Você está fazendo fine-tuning de modelos de geração de imagens (Stable Diffusion UNet ou text encoder), onde ele é mais amplamente utilizado.
  • Você deseja um rank efetivo maior do que o LoRA para o mesmo número de parâmetros treináveis, pois o produto de Hadamard de duas matrizes de baixo rank abrange um subespaço maior do que um único produto de baixo rank.
  • Você deseja combinar diferentes métodos PEFT no momento da inferência usando PeftMixedModel, por exemplo, LoHa junto com LoKr.

LoHa suporta camadas lineares e Conv2d. Para tarefas que também exigem adaptação da camada de incorporação, considere usar LoRA em vez disso.

Uso

from diffusers import StableDiffusionPipeline
from peft import LoHaConfig, get_peft_model

config_unet = LoHaConfig(
    r=8,
    alpha=8,
    target_modules=[
        "to_k",
        "to_q",
        "to_v",
        "to_out.0",
        "proj_in",
        "proj_out",
    ],
    rank_dropout=0.0,
    module_dropout=0.0,
    use_effective_conv2d=True,
)

pipeline = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
pipeline.unet = get_peft_model(pipeline.unet, config_unet)
pipeline.unet.print_healthcheck()

Visão geral do benchmark

API

LoHaConfig

classe peft.LoHaConfig

< >

( 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 = Falserank_pattern: Optional[dict] = <factory>alpha_pattern: Optional[dict] = <factory>r: int = 8alpha: int = 8rank_dropout: float = 0.0module_dropout: float = 0.0use_effective_conv2d: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Noneinit_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = None )

Parâmetros

  • r (int) — Rank do LoHa.
  • alpha (int) — O parâmetro alpha para o escalonamento LoHa.
  • rank_dropout (float) — A probabilidade de dropout para a dimensão de rank durante o treinamento.
  • module_dropout (float) — A probabilidade de dropout para desativar os módulos LoHa durante o treinamento.
  • use_effective_conv2d (bool) — Use a decomposição efetiva de parâmetros para Conv2d (e Conv1d) com ksize > 1 (“Proposition 3” do paper FedPara).
  • 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 especificado como ‘all-linear’, todos os módulos lineares/Conv1D serão selecionados, excluindo a camada de saída. 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.
  • exclude_modules (Optional[Union[List[str], str]]) — Os nomes dos módulos para os quais o adaptador não deve ser aplicado. 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.
  • init_weights (bool) — Se deve realizar a inicialização dos pesos do adaptador. O valor padrão é True; passar False é desencorajado.
  • layers_to_transform (Union[List[int], int]) — Os índices das camadas a serem transformadas. Se uma lista de inteiros for passada, o adaptador será aplicado aos índices das camadas especificados nessa lista. Se um único inteiro for passado, as transformações serão aplicadas à camada nesse índice.
  • layers_pattern (Optional[Union[List[str], str]]) — O nome do padrão de camadas, usado apenas se layers_to_transform for diferente de None. Isso deve apontar para o nn.ModuleList do modelo, que frequentemente é chamado de 'layers' ou 'h'.
  • rank_pattern (dict) — O mapeamento de nomes de camadas ou expressões regulares para ranks que são diferentes do rank padrão especificado por r. Por exemplo, {'^model.decoder.layers.0.encoder_attn.k_proj': 16}.
  • alpha_pattern (dict) — O mapeamento de nomes de camadas ou expressões regulares para alfas que são diferentes do alfa padrão especificado por alpha. Por exemplo, {'^model.decoder.layers.0.encoder_attn.k_proj': 16}.
  • modules_to_save (Optional[List[str]]) — Lista de módulos, além das camadas de adaptador, que devem ser configurados como treináveis e salvos no checkpoint final.

Esta é a classe de configuração para armazenar a configuração de um LoHaModel.

LoHaModel

classe peft.LoHaModel

< >

( 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 (torch.nn.Module) — O modelo ao qual as camadas do adaptador tuner serão anexadas.
  • config (LoHaConfig) — A configuração do modelo LoHa.
  • 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 LoHa.

Cria um modelo de Produto de Hadamard de Baixo Rango a partir de um modelo pré-treinado. O método é parcialmente descrito em https://huggingface.co/papers/2108.06098 A implementação atual se baseia fortemente em https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/loha.py

Exemplo:

>>> from diffusers import StableDiffusionPipeline
>>> from peft import LoHaConfig, get_peft_model

>>> config_te = LoHaConfig(
...     r=8,
...     alpha=32,
...     target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
...     rank_dropout=0.0,
...     module_dropout=0.0,
...     init_weights=True,
... )
>>> config_unet = LoHaConfig(
...     r=8,
...     alpha=32,
...     target_modules=[
...         "proj_in",
...         "proj_out",
...         "to_k",
...         "to_q",
...         "to_v",
...         "to_out.0",
...         "ff.net.0.proj",
...         "ff.net.2",
...     ],
...     rank_dropout=0.0,
...     module_dropout=0.0,
...     init_weights=True,
...     use_effective_conv2d=True,
... )

>>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
>>> model.text_encoder = get_peft_model(model.text_encoder, config_te)
>>> model.unet = get_peft_model(model.unet, config_unet)

Atributos:

  • model (~torch.nn.Module) — O modelo a ser adaptado.
  • peft_config (LoHaConfig): A configuração do modelo LoHa.
Update on GitHub