VeRA: Vector-based Random Matrix Adaptation

VeRA é uma técnica de ajuste fino eficiente em parâmetros, semelhante ao LoRA, mas que requer ainda menos parâmetros extras, prometendo desempenho semelhante ou até superior. Dessa forma, é particularmente útil quando o orçamento de parâmetros é muito limitado, por exemplo, ao escalar para modelos muito grandes. A redução no número de parâmetros treináveis é alcançada compartilhando as mesmas matrizes de baixo posto entre todas as camadas e treinando apenas dois vetores adicionais por camada.

Como o VeRA funciona

LoRA atualiza um modelo base congelado aprendendo duas pequenas matrizes de baixo posto para cada camada adaptada. O posto é a dimensão interna dessas matrizes e controla a capacidade do adaptador. No LoRA, aumentar r ou adaptar mais camadas aumenta rapidamente o número de parâmetros treináveis, pois cada camada adaptada aprende seu próprio par de matrizes de baixo posto.

VeRA mantém a mesma ideia de adaptação de baixo rank, mas altera quais parâmetros são treinados. Em vez de aprender matrizes de baixo rank separadas para cada camada, o VeRA usa um par de matrizes de baixo rank congeladas e inicializadas aleatoriamente, A e B, que é compartilhado entre as camadas. Cada camada adaptada aprende apenas dois vetores de escala, vera_lambda_d e vera_lambda_b, que reescalam as matrizes compartilhadas para produzir uma atualização específica da camada. Como vera_lambda_d tem tamanho r, a contagem de parâmetros treináveis do VeRA ainda aumenta com r e com o número de camadas adaptadas. No entanto, esse crescimento é muito mais lento do que o do LoRA, pois as grandes matrizes A e B são compartilhadas e congeladas, em vez de serem aprendidas separadamente para cada camada.

É por isso que o VeRA pode usar menos parâmetros treináveis do que o LoRA. Na contagem simplificada de parâmetros do artigo, o LoRA escala com 2 * L_tuned * d_model * r, onde L_tuned é o número de camadas adaptadas, d_model é a dimensão do modelo e r é o rank. O VeRA escala com L_tuned * (d_model + r) porque as grandes matrizes de baixo rank são compartilhadas e congeladas, enquanto apenas os vetores menores por camada são treinados.

Ao salvar os parâmetros do adaptador, é 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).

Para lidar com diferentes formas das camadas adaptadas, o VeRA inicializa as matrizes compartilhadas A e B com o maior tamanho necessário para cada dimensão. Durante a passagem direta, 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.

Atualmente, o VeRA possui a seguinte restrição:

• Apenas camadas nn.Linear são suportadas.

O resumo do artigo é:

A adaptação de baixo posto (LoRA) é um método popular que reduz o número de parâmetros treináveis ao fazer o ajuste fino de grandes modelos de linguagem, mas ainda enfrenta desafios agudos de armazenamento ao escalar para modelos ainda maiores ou ao implantar inúmeros modelos adaptados por usuário ou por tarefa. Neste trabalho, apresentamos a Adaptação de Matriz Aleatória Baseada em Vetores (VeRA), que reduz significativamente o número de parâmetros treináveis em comparação com o LoRA, mas mantém o mesmo desempenho. Ela alcança isso usando um único par de matrizes de baixo posto compartilhado entre todas as camadas e aprendendo pequenos vetores de escala no lugar. Demonstramos sua eficácia nos benchmarks GLUE e E2E, em tarefas de classificação de imagens, e mostramos sua aplicação no ajuste fino por instruções de modelos de linguagem de 7B e 13B.

Quando usar o VeRA

VeRA é uma boa escolha quando:

• Você deseja minimizar o número de parâmetros treináveis mantendo um desempenho comparável ao do LoRA.
• Você precisa armazenar ou implantar muitos adaptadores específicos para tarefas, onde checkpoints de adaptadores menores reduzem os requisitos de armazenamento.
• Você está ajustando finamente modelos de linguagem muito grandes sob orçamentos rígidos de memória ou parâmetros.

Quando não usar o VeRA

VeRA pode não ser a melhor escolha quando:

• Você precisa de matrizes de baixo posto independentes para cada camada adaptada, o que oferece maior flexibilidade nos parâmetros do adaptador aprendidos.
• Seu modelo requer a adaptação de tipos de módulos diferentes de nn.Linear, pois o VeRA atualmente suporta apenas camadas lineares.
• Seu modelo contém camadas lineares adaptadas com dimensões de entrada e saída amplamente diferentes. Como o VeRA compartilha um único par de matrizes de projeção entre todas as camadas adaptadas, essas matrizes devem ser dimensionadas para o maior formato. Modelos com grande variação nos formatos das camadas (por exemplo, camadas de projeção para cima e para baixo em transformers) podem, portanto, exigir o superdimensionamento das matrizes de projeção compartilhadas, reduzindo parte da vantagem de eficiência de parâmetros do VeRA.

Visão geral do benchmark

API

VeRAConfig

VeRAModel

>>> from transformers import AutoModelForCausalLM
>>> from peft import VeraConfig, get_peft_model

>>> base_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m")
>>> config = VeraConfig(r=128)
>>> model = get_peft_model(base_model, config)