AdaLoRA

AdaLoRA (Adaptive LoRA) é um método para otimizar o número de parâmetros treináveis a serem atribuídos a matrizes de pesos e camadas. Diferente do LoRA, que distribui os parâmetros uniformemente entre todos os módulos, o AdaLoRA destina mais parâmetros às matrizes de pesos e camadas mais importantes, enquanto as menos importantes recebem menos. Você pode controlar a rank média desejada ou r das matrizes, bem como os módulos aos quais o AdaLoRA será aplicado, por meio de target_modules. Outros parâmetros importantes a definir são lora_alpha (fator de escala) e modules_to_save (os módulos, além das camadas do AdaLoRA, que devem ser treinados e salvos). Todos esses parâmetros — e mais — estão disponíveis no AdaLoraConfig.

O resumo do artigo é:

Fine-tuning de grandes modelos de linguagem pré-treinados em tarefas downstream tornou-se um paradigma importante em PLN. No entanto, a prática comum é fazer fine-tuning de todos os parâmetros de um modelo pré-treinado, o que se torna proibitivo quando há um grande número de tarefas downstream. Portanto, muitos métodos de fine-tuning foram propostos para aprender atualizações incrementais dos pesos pré-treinados de forma eficiente em parâmetros, por exemplo, incrementos de baixo rank. Esses métodos frequentemente distribuem uniformemente o orçamento de atualizações incrementais entre todas as matrizes de pesos pré-treinadas, ignorando a importância variável de diferentes parâmetros de peso. Como consequência, o desempenho do fine-tuning é subótimo. Para preencher essa lacuna, propomos o AdaLoRA, que aloca adaptativamente o orçamento de parâmetros entre as matrizes de pesos de acordo com sua pontuação de importância. Em particular, o AdaLoRA parametriza as atualizações incrementais na forma de decomposição em valores singulares. Essa abordagem inovadora nos permite podar efetivamente os valores singulares de atualizações não importantes, o que é essencialmente reduzir seu orçamento de parâmetros, mas contornar cálculos intensivos de SVD exato. Realizamos extensos experimentos com vários modelos pré-treinados em processamento de linguagem natural, question answering e geração de linguagem natural para validar a eficácia do AdaLoRA. Os resultados demonstram que o AdaLoRA apresenta melhorias notáveis em relação às baselines, especialmente em configurações de baixo orçamento. Nosso código está publicamente disponível em https://github.com/QingruZhang/AdaLoRA.

O AdaLoRA possui um método update_and_allocate() que deve ser chamado em cada etapa de treinamento para atualizar o orçamento de parâmetros e a máscara; caso contrário, a etapa de adaptação não é executada. Isso exige a criação de um loop de treinamento personalizado ou a subclassificação do Trainer para incorporar esse método. Como exemplo, veja este loop de treinamento personalizado.

O AdaLoRA gerencia o orçamento de parâmetros introduzido pelo LoRA alocando mais parâmetros — em outras palavras, um rank mais alto r - para matrizes de pesos importantes que se adaptam melhor a uma tarefa e eliminando as menos importantes. O rank é controlado por um método semelhante à decomposição em valores singulares (SVD). O $\Delta W$ é parametrizado com duas matrizes ortogonais e uma matriz diagonal que contém os valores singulares. Este método de parametrização evita a aplicação iterativa da SVD, que é computacionalmente cara. Com base neste método, o rank de $\Delta W$ é ajustado de acordo com uma pontuação de importância. $\Delta W$ é dividido em trios e cada trio é pontuado de acordo com sua contribuição para o desempenho do modelo. Trios com pontuações de importância baixas são eliminados e trios com pontuações de importância altas são mantidos para o ajuste fino.

O treinamento com AdaLoRA tem três fases: a fase de inicialização, a fase de alocação de orçamento e a fase final. Na fase inicial, nenhuma alocação de orçamento é aplicada, portanto, os ranks não são alterados. Durante a fase de alocação de orçamento, o processo descrito acima é aplicado e o rank é redistribuído de acordo com um orçamento, com o objetivo de dar mais rank a adaptadores mais importantes e menos a camadas menos importantes. Ao atingir a fase final, a alocação de orçamento termina, os ranks são redistribuídos, mas podemos continuar treinando por um tempo com os ranks redistribuídos para melhorar ainda mais o desempenho.

Contribuições são bem-vindas: Esta seção precisa de esclarecimentos.

Não está claro como a importância é medida. As explicações também são um pouco redundantes e poderiam se beneficiar de uma consolidação. Veja aqui como contribuir.

Visão geral do benchmark

Uso

from peft import AdaLoraConfig, get_peft_model

config = AdaLoraConfig(
    r=8,
    init_r=12,
    tinit=200,
    tfinal=1000,
    deltaT=10,
    target_modules=["query", "value"],
    modules_to_save=["classifier"],
)
model = get_peft_model(model, config)
model.print_healthcheck()

[... training code ...]

model.update_and_allocate(step_idx)

API

AdaLoraConfig

AdaLoraModel

>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import AdaLoraConfig, get_peft_model

>>> config = AdaLoraConfig(
...     peft_type="ADALORA",
...     task_type="SEQ_2_SEQ_LM",
...     init_r=12,
...     lora_alpha=32,
...     target_modules=["q", "v"],
...     lora_dropout=0.01,
...     total_step=1000,
... )
>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> adalora_model = get_peft_model(model, config)

>>> loss = model(**input).loss
>>> loss.backward()
>>> optimizer.step()
>>> model.base_model.update_and_allocate(i_step)
>>> optimizer.zero_grad()