PEFT documentation
Lily: Adaptação Interconectada de Baixo Rango entre Camadas
Lily: Adaptação Interconectada de Baixo Rango entre Camadas
Lily é uma técnica de ajuste fino eficiente em parâmetros que introduz o compartilhamento de pesos entre camadas para as matrizes de adaptador. Em vez de aprender um par AB independente por camada, como no LoRA, o Lily usa adaptadores A compartilhados localmente (cada A é compartilhado entre um bloco de stride_A camadas consecutivas) e especialistas B compartilhados globalmente (um pequeno conjunto de num_B adaptadores B é compartilhado entre todas as camadas). Em cada passagem de frente, um roteador leve e dependente dos dados calcula uma combinação ponderada por softmax dos especialistas B para produzir o B efetivo para aquela camada e entrada.
Esse compartilhamento pode reduzir o número total de matrizes de adaptador de 2N (LoRA padrão) para N / stride_A + num_B, liberando o orçamento de parâmetros para usar um rank muito maior r — tipicamente 2×–4× do que você usaria no LoRA. Um rank maior e uma melhor interconectividade aumentam o rank efetivo da atualização de pesos ΔW = A × combined_B, resultando em um melhor desempenho de adaptação.
Como a combinação B é dependente dos dados (os pesos do roteador dependem das ativações de entrada em tempo de execução), merge e unmerge não são suportados. Se a mesclagem de pesos for necessária para sua implantação, considere outros métodos, como LoRA.
Atualmente, a Lily possui as seguintes restrições adicionais:
- Apenas camadas
nn.Linearsão suportadas. - Camadas quantizadas não são suportadas.
Se essas restrições não funcionarem para o seu caso de uso, considere outros métodos.
O resumo do artigo é:
A adaptação de baixo posto (LoRA) é um método amplamente utilizado de ajuste fino eficiente em parâmetros (PEFT) que aprende atualizações de pesos ΔW = AB para pesos pré-treinados W por meio de adaptadores de baixo posto A e B. Embora o LoRA garanta eficiência de hardware, suas atualizações de pesos de baixo posto limitam o desempenho da adaptação. Neste artigo, propomos a adaptação interconectada de baixo posto entre camadas (Lily), um novo método PEFT que introduz um framework interconectado com especialistas A compartilhados localmente e B compartilhados globalmente. Essa estrutura elimina pares AB redundantes por camada, permitindo ΔW de posto mais alto com o mesmo número ou menos parâmetros. Para aprimorar a expressividade, usamos roteadores dependentes de dados para determinar as interconexões A-B, impedindo que os especialistas B converjam para o mesmo comportamento e melhorando o poder representacional entre domínios. Experimentos em diferentes modalidades, arquiteturas e tamanhos de modelo demonstram o desempenho e a eficiência superiores da Lily.
Visão geral do benchmark
API
LilyConfig
classe peft.LilyConfig
< 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 = Falser: int = 32stride_A: int = 1num_B: int = 2scaling: float = 1.0target_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = Nonelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Noneinit_weights: bool = True )
Parâmetros
- r (
int) — O rank de Lily. Determina a dimensão oculta interna de cada adaptador e o rank da atualização de pesosA @ B. No Lily, como o número de adaptadores é tipicamente menor do que no LoRA, cada adaptador precisa carregar mais capacidade, portanto, recomenda-se usar umrmaior do que no LoRA — tipicamente2x,3xou4xo rank do LoRA que você usaria normalmente. O número total de parâmetros treináveis escala comr * (total_layers / stride_A + num_B), então aumentarrmantendostride_Agrande enum_Bpequeno é o compromisso recomendado. - stride_A (
int) — O número de camadas consecutivas que compartilham um único adaptador A. Por exemplo, sestride_A=4, a cada 4 camadas adjacentes compartilharem o mesmo adaptador A, resultando emtotal_layers / stride_Aadaptadores A distintos no total. O adaptador A comprime a entrada em uma representação de baixo posto de tamanhor.stride_Anão deve ser menor que- Valores sugeridos:
2,3ou4(ou seja, compartilhar a cada 2, 3 ou 4 camadas). Manterstride_Agrande (menos adaptadores A distintos) e aumentarrem vez disso leva a um melhor desempenho do que o compromisso oposto (pequenostride_A, pequenor). Definirstride_A=1significa que cada camada tem seu próprio adaptador A. OBSERVAÇÃO: o compartilhamento de A ocorre dentro de cada alvo (camadas com o mesmo sufixo de alvo). Por exemplo, se seus target_modules forem['q_proj', 'v_proj']e você definirstride_A=2, então a cada 2 camadas adjacentes de q_proj compartilharão um adaptador A, e a cada 2 camadas adjacentes de v_proj compartilharão outro adaptador A, mas as camadas de q_proj e v_proj não compartilharão adaptadores A entre si, pois têm sufixos diferentes.
- Valores sugeridos:
- num_B (
int) — O número de adaptadores B compartilhados. Diferentemente dos adaptadores A (que são agrupados por camada), todos os adaptadores B são compartilhados globalmente entre todas as camadas. Para cada passagem para frente, um roteador calcula uma combinação ponderada de todos osnum_Badaptadores B (usando pesos normalizados por softmax) para produzir um único adaptador B combinado, que então projeta a representação de baixo posto de volta para a dimensão original. Recomenda-se definirnum_Bpara uma ordem de grandeza semelhante à detotal_layers / stride_A. Valores sugeridos:total_layers / 2,total_layers / 3outotal_layers / 4. Assim como comstride_A, prefira umnum_Bmenor com umrmaior em vez de umnum_Bmaior com umrmenor. OBSERVAÇÃO: para treinar o roteador, são necessários pelo menos 2 adaptadores B (ou seja,num_B >= 2), pois o roteador aprende a calcular uma combinação ponderada dos adaptadores B. OBSERVAÇÃO: o compartilhamento de B ocorre dentro de cada alvo (camadas com o mesmo sufixo de alvo). Por exemplo, se seus target_modules forem['q_proj', 'v_proj']e você definirnum_B=4, haverá 4 adaptadores B compartilhados entre todas as camadas q_proj e outros 4 adaptadores B compartilhados entre todas as camadas v_proj, mas as camadas q_proj e v_proj não compartilharão adaptadores B entre si, pois possuem sufixos diferentes. - target_modules (
Union[List[str], str], opcional) — Os nomes dos módulos aos quais aplicar o Lily. Pode ser uma lista de strings com nomes de módulos (por exemplo,['q_proj', 'v_proj']) ou um padrão de expressão regular (por exemplo,'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'). Se não for especificado, o Lily será aplicado a todas as camadas lineares suportadas. - scaling (
float) — Um multiplicador escalar aplicado à saída combinada do adaptador (scaling * A @ combined_B) antes de adicioná-la à passada para frente do peso congelado. Diferente do LoRA, o Lily não usa uma formulação dealpha / r; em vez disso,scalingé um multiplicador direto. Esse design torna simples varrer valores em uma escala logarítmica (por exemplo,0.01,0.1,1.0,10.0). O valor ótimo depende da tarefa e deve ser tratado como um hiperparâmetro. Recomendamos começar com1.0. - modules_to_save (
List[str], opcional) — Lista de módulos, além das camadas Lily, que devem ser configurados como treináveis e salvos no checkpoint final. Por exemplo, em tarefas de Classificação de Sequência ou Classificação de Token, a camada finalclassifier/scoreé inicializada aleatoriamente e, portanto, precisa ser treinável e salva. - exclude_modules (
Union[List[str], str], opcional) — Os nomes dos módulos aos 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. - layers_to_transform (
Union[list[int], int], opcional) — Os índices das camadas a serem transformadas. Se este argumento for especificado, o PEFT transformará apenas os índices das camadas especificados dentro desta lista. Se um único inteiro for passado, o PEFT transformará apenas a camada neste índice. - layers_pattern (
Optional[Union[List[str], str]], opcional) — O nome do padrão de camadas, usado apenas selayers_to_transformfor diferente de None e se o padrão de camadas não estiver no padrão de camadas comum. Isso deve apontar para onn.ModuleListdo modelo, que frequentemente é chamado de'layers'ou'h'. - init_weights (
bool) — Se as pesos do adaptador Lily devem ser inicializados usando o esquema de inicialização padrão: as matrizes A são inicializadas com Kaiming uniform, e as matrizes B são inicializadas com zero, garantindo que a saída do adaptador seja zero no início do treinamento e não perturbe o modelo pré-treinado. É fortemente recomendado manter isso comoTrue, a menos que você tenha um motivo específico para alterá-lo.
Esta é a classe de configuração para armazenar a configuração de um LilyModel.
LilyModel
classe peft.LilyModel
< 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 a ser adaptado. - config (LilyConfig) — A configuração do modelo Lily.
- adapter_name (
str) — O nome do adaptador, padrão é"default".
Retorna
torch.nn.Module
O modelo PEFT da Lily.
Cria um modelo Low-Rank Interconnected Adaptation Across Layers (Lily) a partir de um modelo transformers pré-treinado.
O método é descrito em detalhes em https://arxiv.org/abs/2407.09946.
Atributos:
- model (PreTrainedModel) — O modelo a ser adaptado.
- peft_config (LilyConfig): A configuração do modelo Lily.