PEFT documentation
RandLora: ajuste fino eficiente em parâmetros de rank completo de modelos grandes
RandLora: ajuste fino eficiente em parâmetros de rank completo de modelos grandes
RandLora é uma técnica de ajuste fino eficiente em parâmetros, semelhante a LoRA e VeRA, mas que realiza atualizações de rank completo para melhorar o desempenho. O RandLora pode ser particularmente útil ao adaptar modelos grandes a tarefas difíceis que exigem atualizações complexas, preservando a eficiência de parâmetros do LoRA. A atualização de rank completo do RandLora é obtida por meio da escala linear de bases aleatórias. As bases aleatórias são um conjunto de múltiplas matrizes de baixo rank, de modo que a soma de seus ranks seja maior ou igual ao rank completo das matrizes de parâmetros. Os parâmetros treináveis do RandLora são duas matrizes diagonais (vetores) que são multiplicadas pelas bases aleatórias de baixo rank do lado direito, de maneira semelhante à atualização do VeRA. Para manter o uso de memória baixo, o RandLora utiliza uma função personalizada que impede o armazenamento de bases desnecessárias na memória para a retropropagação.
RandLora apresenta a diferença notável de que, ao contrário de outros algoritmos PEFT semelhantes ao LoRA, aumentar os ranks base aleatórios do RandLora aumenta a quantidade de parâmetros treináveis. Como o número de bases x rank das bases é constante no RandLora, reduzir o rank aumentará o número de bases aleatórias, e, portanto, o número de bases diagonais treináveis específicas de cada base.
Como a redução do rank das bases aleatórias do RandLora aumenta o número delas, o RandLora pode ficar mais lento para treinar do que o LoRA em ranks muito pequenos, onde, tipicamente, ranks abaixo de 4 resultam em um grande aumento no tempo de treinamento. Isso não afeta a inferência, pois os adaptadores do RandLora podem ser mesclados nas matrizes de pesos pré-treinadas.
RandLora também suporta treinamento com bases aleatórias esparsas e ternárias (contendo apenas -1, 0 e 1). Essas bases são descritas em Bingham et al. e Ping et al. e poderiam, teoricamente, ser usadas para reduzir a necessidade de computação ao realizar agregações em vez de multiplicações de matrizes para criar a atualização de pesos. Isso não é suportado no momento. Embora não reduza a computação atualmente, o uso de bases aleatórias esparsas no RandLora pode reduzir o overfitting em alguns casos. Para usuários interessados em usar bases ternárias esparsas, a opção sparse é recomendada em vez da opção very_sparse, que pode reduzir o desempenho.
De forma semelhante ao VeRA, ao salvar os parâmetros do RandLora, é possível evitar o armazenamento das matrizes de baixo rank definindo save_projection=False no VeraConfig. Nesse caso, essas matrizes serão restauradas com base na semente aleatória fixa do argumento projection_prng_key. Isso reduz o tamanho do checkpoint, mas não podemos garantir a reprodutibilidade em todos os dispositivos e para todas as versões futuras do PyTorch. Se você deseja garantir a reprodutibilidade, defina save_projection=True (que é o padrão).
Assim como em Vera e para lidar com diferentes formas de camadas adaptadas, o RandLora inicializa as matrizes compartilhadas A e B com o maior tamanho necessário para cada dimensão. Durante a passagem para frente, as submatrizes A e B para uma camada dada são extraídas dessas matrizes compartilhadas e usadas conforme descrito no artigo. Por exemplo, adaptar duas camadas lineares de formas (100, 20) e (80, 50) criará matrizes A e B de formas (rank, 50) e (100, rank), respectivamente. Em seguida, para adaptar uma camada de forma (100, 20), submatrizes A e B de formas (rank, 20) e (100, rank) serão extraídas.
O RandLora atualmente possui a seguinte restrição:
- Apenas camadas
nn.Linearsão suportadas.
O resumo do artigo é:
A Low-Rank Adaptation (LoRA) e suas variantes demonstraram resultados impressionantes na redução do número de parâmetros treináveis e dos requisitos de memória de grandes redes transformer, mantendo ao mesmo tempo o desempenho do fine-tuning. No entanto, a natureza de baixo rank da atualização de pesos limita inerentemente o poder de representação dos modelos ajustados, o que pode potencialmente comprometer o desempenho em tarefas complexas. Isso levanta uma questão crítica: quando uma diferença de desempenho entre a LoRA e o fine-tuning padrão é observada, ela se deve ao número reduzido de parâmetros treináveis ou à deficiência de rank? Este artigo visa responder a essa questão ao introduzir o RandLora, um método eficiente em parâmetros que realiza atualizações de rank completo usando combinações lineares aprendidas de matrizes aleatórias de baixo rank, não treináveis. Nosso método limita o número de parâmetros treináveis ao restringir a otimização a matrizes de escala diagonal aplicadas às matrizes aleatórias fixas. Isso nos permite superar efetivamente as limitações de baixo rank, mantendo a eficiência em parâmetros e memória durante o treinamento. Por meio de experimentos extensos em benchmarks de visão, linguagem e visão-linguagem, avaliamos sistematicamente as limitações da LoRA e dos métodos de base aleatória existentes. Nossas descobertas revelam que as atualizações de rank completo são benéficas individualmente para tarefas de visão e linguagem, e ainda mais para tarefas de visão-linguagem, onde o RandLora reduz significativamente — e às vezes elimina — a diferença de desempenho entre o fine-tuning padrão e a LoRA, demonstrando sua eficácia.
Visão geral do benchmark
API
RandLoraConfig
classe peft.RandLoraConfig
< 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 = 32target_modules: list[str] | str | None = Noneprojection_prng_key: int = 0save_projection: bool = Truesparse: bool = Falsevery_sparse: bool = Falserandlora_dropout: float = 0.0fan_in_fan_out: bool = Falserandlora_alpha: int = 640bias: str = 'none'modules_to_save: list[str] | None = Noneinit_weights: bool = Truelayers_to_transform: list[int] | int | None = Nonelayers_pattern: str | None = None )
Parâmetros
- r (
int, opcional, padrão32) — Dimensão do rank da base aleatória do RandLora. Diferentemente do Lora, este parâmetro é inversamente proporcional à quantidade de parâmetros treináveis, pois reduzi-lo aumenta os parâmetros treináveis. - target_modules (
Union[list[str], str]) — Os nomes dos módulos aos quais aplicar o RandLora. Somente camadas lineares são suportadas. - projection_prng_key (
int) — Chave de inicialização do PRNG do RandLora. Usada para inicializar basis_A e basis_B para novos modelos ou ao carregar um checkpoint que não incluía essas projeções. O valor padrão é0. - save_projection (
bool) — Se deve salvar a base aleatória global basis_A / basis_B no state dict junto com as matrizes diagonais lambda / gamma por camada. Isso aumentará o tamanho do checkpoint, mas garantirá que possamos recarregar o checkpoint em todas as configurações de sistema. O valor padrão éTrue. - sparse (
bool) — Se deve usar bases aleatórias esparsas, conforme descrito no paper RandLora. As bases são bases ternárias esparsas (contendo apenas -1, 0 e 1), onde a probabilidade de atribuição é 1/6 para -1 e 1, e 2/3 para 0. Essas matrizes esparsas têm como objetivo ser usadas para computação sem matmul no futuro, veja https://huggingface.co/papers/2406.02528v1 A implementação atual é uma prova de conceito, na qual a esparsidade não é utilizada para melhorar a velocidade ou o uso de memória. O uso de matrizes esparsas geralmente não reduz o desempenho e pode até ajudar a reduzir o overfitting. O valor padrão éFalse. - very_sparse (
bool) — Se deve usar bases aleatórias altamente esparsas, conforme descrito no paper RandLora. As bases muito esparsas são bases ternárias esparsas (contendo apenas -1, 0 e 1) dadas uma matriz com a menor dimensão d, a probabilidade de atribuição é 1/√D para -1 e 1 e 1- 2/√D para 0. O uso dessas matrizes esparsas pode reduzir ainda mais o overfitting em relação às alternativassparse, mas provavelmente diminuirá o desempenho como resultado. Use com cuidado. O padrão éFalse. - randlora_dropout (
float) — A probabilidade de dropout para as camadas RandLora. - randlora_alpha (
float) — O coeficiente de escala para as camadas RandLora, que normalmente deve ser 20 vezes o rank. Como o coeficienterandlora_alphaé grande por padrão, isso pode levar a instabilidades numéricas, especialmente quando as taxas de aprendizado são altas. Se o treinamento for instável, considere reduzir a taxa de aprendizado ou o coeficienterandlora_alpha. - fan_in_fan_out (
bool) — Defina como True se a camada a ser substituída armazenar os pesos como (fan_in, fan_out). Por exemplo, o gpt-2 usaConv1D, que armazena os pesos como (fan_in, fan_out), e portanto este parâmetro deve ser definido comoTrue. - bias (
str) — Tipo de viés. Pode ser ‘none’, ‘all’ ou ‘randlora_only’. Se for ‘all’ ou ‘randlora_only’, os vieses correspondentes serão atualizados durante o treinamento. Tenha em mente que isso significa que, mesmo ao desativar os adaptadores, o modelo não produzirá a mesma saída que o modelo base teria sem adaptação. - modules_to_save (
list[str]) — lista de módulos, além das camadas RandLora, que devem ser configurados como treináveis e salvos no checkpoint final. - init_weights (
bool) — Se as camadas RandLora devem ter seus pesos inicializados com a inicialização padrão. Não altere esta configuração, a menos que saiba exatamente o que está fazendo. - layers_to_transform (
Union[list[int],int]) — Os índices das camadas a serem transformadas. Se este argumento for especificado, as transformações RandLora serão aplicadas aos índices das camadas especificados nesta lista. Se um único inteiro for passado, as transformações RandLora serão aplicadas à camada neste índice. - layers_pattern (
str) — O nome do padrão de camada, usado apenas selayers_to_transformfor diferente deNonee se o padrão de camada não estiver no padrão de camadas comum.
Esta é a classe de configuração para armazenar a configuração de um RandLoraModel.
RandLoraModel
classe peft.RandLoraModel
< 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 (PreTrainedModel) — O modelo a ser adaptado.
- config (RandLoraConfig) — A configuração do modelo RandLora.
- 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 RandLora.
Cria um modelo RandLoRA a partir de um modelo transformers pré-treinado.
Exemplo:
>>> from transformers import AutoModelForCausalLM
>>> from peft import RandLoraConfig, get_peft_model
>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = RandLoraConfig(r=32)
>>> model = get_peft_model(base_model, config)Atributos:
- model (PreTrainedModel) — O modelo a ser adaptado.
- peft_config (RandLoraConfig): A configuração do modelo RandLora.