PEFT documentation
LoKr
LoKr
O produto de Kronecker de baixo posto (LoKr) é um método variante do LoRA que aproxima a grande matriz de pesos com duas matrizes de baixo posto e as combina por meio do produto de Kronecker. O LoKr também fornece uma terceira matriz de baixo posto opcional para oferecer um melhor controle durante o ajuste fino. Ao expressar a matriz de atualização de pesos como uma decomposição de um produto de Kronecker, criando uma matriz em blocos, o LoKr é capaz de preservar o posto da matriz de pesos original. O tamanho das matrizes menores é determinado pelo seu posto ou r. Outro benefício do produto de Kronecker é que ele pode ser vetorizado empilhando as colunas da matriz. Isso pode acelerar o processo, pois você evita a reconstrução completa de ∆W.
O resumo do artigo é:
Os modelos generativos de texto para imagem têm recebido enorme atenção por sua capacidade de produzir imagens de alta fidelidade a partir de prompts de texto. Dentre eles, o Stable Diffusion se destaca como um modelo open-source líder neste campo em rápido crescimento. No entanto, as complexidades do ajuste fino desses modelos apresentam múltiplos desafios, desde a integração de novas metodologias até a avaliação sistemática. Para abordar essas questões, este artigo apresenta o LyCORIS Lora beYond Conventional methods, Other Rank adaptation Implementations for Stable diffusion, uma biblioteca open-source que oferece uma ampla seleção de metodologias de ajuste fino para o Stable Diffusion. Além disso, apresentamos um framework abrangente para a avaliação sistemática de diversas técnicas de ajuste fino. Este framework emprega um conjunto diversificado de métricas e explora múltiplas facetas do ajuste fino, incluindo ajustes de hiperparâmetros e a avaliação com diferentes tipos de prompts em várias categorias de conceitos. Por meio dessa abordagem abrangente, nosso trabalho fornece insights essenciais sobre os efeitos sutis dos parâmetros de ajuste fino, preenchendo a lacuna entre a pesquisa de estado da arte e a aplicação prática.
Uso
from peft import LoKrConfig, get_peft_model
config = LoKrConfig(
r=16,
alpha=16,
target_modules=["query", "value"],
module_dropout=0.1,
modules_to_save=["classifier"],
)
model = get_peft_model(model, config)
model.print_healthcheck()Visão geral do benchmark
API
LoKrConfig
classe peft.LoKrConfig
< source >( 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 = Falsedecompose_both: bool = Falsedecompose_factor: int = -1rank_dropout_scale: bool = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Noneinit_weights: Union[bool, Literal['lycoris']] = 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 LoKr. - alpha (
int) — O parâmetro alpha para o escalonamento do LoKr. - 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 LoKr 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). - decompose_both (
bool) — Executa a decomposição de posto da matriz do produto de Kronecker à esquerda. - decompose_factor (
int) — Fator de decomposição do produto de Kronecker. - rank_dropout_scale (‘bool) —
Se o rank dropout deve ser escalado durante o treinamento, padrão é
False. - 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. Use “lycoris” para inicializar os pesos no estilo do repositório LYCORIS. PassarFalseé 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 selayers_to_transformfor diferente deNone. Isso deve apontar para onn.ModuleListdo 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 porr. 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 poralpha. 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.
Classe de configuração de LoKrModel.
LoKrModel
classe peft.LoKrModel
< source >( 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 (LoKrConfig) — A configuração do modelo LoKr.
- adapter_name (
str) — O nome do adaptador, padrão é"default". - low_cpu_mem_usage (
bool,optional, defaults toFalse) — Cria pesos de adaptador vazios no dispositivo meta. Útil para acelerar o processo de carregamento.
Retorna
torch.nn.Module
O modelo LoKr.
Cria um modelo de Produto de Kronecker de Baixo Rango a partir de um modelo pré-treinado. O método original é descrito parcialmente em https://huggingface.co/papers/2108.06098 e em https://huggingface.co/papers/2309.14859 A implementação atual faz uso extensivo de https://github.com/KohakuBlueleaf/LyCORIS/blob/eb460098187f752a5d66406d3affade6f0a07ece/lycoris/modules/lokr.py
Exemplo:
>>> from diffusers import StableDiffusionPipeline
>>> from peft import LoKrConfig, get_peft_model
>>> config_te = LoKrConfig(
... 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 = LoKrConfig(
... 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 (LoKrConfig): A configuração do modelo LoKr.