Este repositório contém o código -fonte do pacote Python loralib e vários exemplos de como integrá -lo aos modelos Pytorch, como os de abraçar o rosto. Só apoiamos Pytorch por enquanto. Veja nosso artigo para uma descrição detalhada de Lora.
Lora: adaptação de baixo rank de grandes modelos de linguagem
Edward J. Hu*, Yelong Shen*, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, Weizhu Chen
Papel: https://arxiv.org/abs/2106.09685
Explicação de vídeos: https://www.youtube.com/watch?v=dhrotoncyze
ATUALIZAÇÃO 2/2023: Lora agora é suportada pela biblioteca de ajuste fina (PEFT) eficiente e eficiente em parâmetro, abraçando o rosto.
Lora reduz o número de parâmetros treináveis, aprendendo pares de matrizes de decomposição de classificação enquanto congelam os pesos originais. Isso reduz bastante o requisito de armazenamento para grandes modelos de linguagem adaptados a tarefas específicas e permite que a troca de tarefas eficiente durante a implantação, tudo sem introduzir latência de inferência. A Lora também supera vários outros métodos de adaptação, incluindo adaptador, ajuste de prefixo e ajuste fino.
Obtemos resultado comparável ou superior à finetening completa na referência de cola usando Roberta (Liu et al., 2019) Base e Large e Deberta (He et al., 2020) XXL 1.5b, enquanto apenas treinando e armazenamos uma fração dos parâmetros . Clique nos números abaixo para baixar os pontos de verificação Roberta e Deberta Lora.
| Roberta Base Afinar | Roberta Base Lora | Deberta xxl Afinar | Deberta xxl Lora | ||
|---|---|---|---|---|---|
| # de parâmetros treináveis. | 125m | 0,8m | 1.5b | 4,7m | |
| Mnli (m-acc/mm-acc) | 87.6 | 87,5 ± .3/86,9 ± .3 | 91.7/ 91.9 | 91,9 ± .1/ 91,9 ± .2 | |
| SST2 (ACC) | 94.8 | 95,1 ± .2 | 97.2 | 96,9 ± .2 | |
| MRPC (ACC) | 90.2 | 89,7 ± .7 | 92.0 | 92,6 ± .6 | |
| Cola (correr de Matthew) | 63.6 | 63,4 ± 1,2 | 72.0 | 72,4 ± 1,1 | |
| QNLI (ACC) | 92.8 | 93,3 ± .3 | 96.0 | 96,0 ± .1 | |
| QQP (ACC) | 91.9 | 90,8 ± .1 | 92.7 | 92,9 ± .1 | |
| RTE (ACC) | 78.7 | 86,6 ± .7 | 93.9 | 94,9 ± .4 | |
| STSB (Pearson/Spearman Corr) | 91.2 | 91,5 ± .2/ 91,3 ± .2 | 92.9 /92.6 | 93,0 ± 0,2/ 92,9 ± .3 | |
| Média | 86.40 | 87.24 | 91.06 | 91.32 |
NOTA: Você ainda precisa do ponto de verificação pré-treinado original de Hugging Face para usar os pontos de verificação Lora.
Os números de ajuste fino são retirados de Liu et al. (2019) e ele et al. (2020). Incluímos intervalos de confiança nos resultados de nossos experimentos. Siga as instruções em examples/NLU/ para reproduzir nossos resultados.
No GPT-2, Lora se compara favoravelmente aos métodos completos de Finetuning e outros métodos de ajuste eficientes, como adaptador (Houlsby et al., 2019) e ajuste de prefixo (Li e Liang, 2021). Avaliamos o Desafio E2E NLG, o DART e o WebNLG:
| Método | # de parâmetros treináveis | E2e (bleu) | Dardo (bleu) | Webnlg (bleu-u/s/a) | |
|---|---|---|---|---|---|
| GPT-2 M (Tune Fine) | 354.92m | 68.2 | 46.0 | 30.4 / 63.2 / 47.6 | |
| GPT-2 M (adaptador) | 0,37m | 66.3 | 42.4 | 45.1/54.5/50.2 | |
| GPT-2 M (prefixo) | 0,35m | 69.7 | 45.7 | 44.1/63.1/54.4 | |
| GPT-2 M (Lora) | 0,35m | 70,4 ± .1 | 47,1 ± .2 | 46,7 ± .4/ 62,1 ± .2/ 55,3 ± .2 | |
| GPT-2 L (Tune Fine) | 774.03m | 68.5 | 46.5 | 41.7 / 64.6 / 54.2 | |
| GPT-2 L (adaptador) | 0,88m | 69,1 ± .1 | 45,7 ± .1 | 49,8 ± 0,0/61,1 ± 0,0/56,0 ± .0 | |
| GPT-2 L (prefixo) | 0,77m | 70.3 | 46.5 | 47.0/64.2/56.4 | |
| GPT-2 L (Lora) | 0,77m | 70,4 ± .1 | 47,5 ± .1 | 48,4 ± .3/ 64,0 ± .3/ 57,0 ± .1 |
As linhas de base não-Lora, exceto o adaptador no GPT-2, são retiradas de Li e Liang (2021). Incluímos intervalos de confiança nos resultados de nossos experimentos.
Baixe os pontos de verificação GPT-2 Lora:
Siga as instruções em examples/NLG/ para reproduzir nosso resultado.
(A versão inicial deste repo foi arquivada na filial "Snapshot-9-15-2021")
Existem vários diretórios neste repo:
loralib , que precisa ser instalado para executar os exemplos que fornecemos;loralib no GPT-2, Roberta e Deberta V2 loralib é simplesmente pip install loralib
# Alternatively
# pip install git+https://github.com/microsoft/LoRAloralib . Somente apoiamos nn.Linear , nn.Embedding e nn.Conv2d por enquanto. Também apoiamos uma MergedLinear para casos em que um único nn.Linear representa mais de uma camada, como em algumas implementações da projeção de qkv de atenção (consulte Notas adicionais para mais). # ===== Before =====
# layer = nn.Linear(in_features, out_features)
# ===== After ======
import loralib as lora
# Add a pair of low-rank adaptation matrices with rank r=16
layer = lora . Linear ( in_features , out_features , r = 16 ) import loralib as lora
model = BigModel ()
# This sets requires_grad to False for all parameters without the string "lora_" in their names
lora . mark_only_lora_as_trainable ( model )
# Training loop
for batch in dataloader :
...state_dict que contém apenas parâmetros LORA. # ===== Before =====
# torch.save(model.state_dict(), checkpoint_path)
# ===== After =====
torch . save ( lora . lora_state_dict ( model ), checkpoint_path )load_state_dict , certifique -se de definir strict=False . # Load the pretrained checkpoint first
model . load_state_dict ( torch . load ( 'ckpt_pretrained.pt' ), strict = False )
# Then load the LoRA checkpoint
model . load_state_dict ( torch . load ( 'ckpt_lora.pt' ), strict = False ) Enquanto nos concentramos em uma configuração simples, mas de efeito, a saber apenas a projeção q e v em um transformador, em nossos exemplos, a Lora pode ser aplicada a quaisquer subconjuntos de pesos pré-treinados. Nós o encorajamos a explorar diferentes configurações, como adaptar a camada de incorporação, substituindo nn.Embedding por lora.Embedding e/ou adaptando as camadas MLP. É muito provável que a configuração ideal varia para diferentes arquiteturas e tarefas de modelos.
Alguma implementação do transformador usa um único nn.Linear para as matrizes de projeção para consulta, chave e valor. Se alguém deseja restringir a classificação das atualizações das matrizes individuais, deve dividi -la em três matrizes separadas ou usar lora.MergedLinear . Certifique -se de modificar o ponto de verificação de acordo se você optar por quebrar a camada.
# ===== Before =====
# qkv_proj = nn.Linear(d_model, 3*d_model)
# ===== After =====
# Break it up (remember to modify the pretrained checkpoint accordingly)
q_proj = lora . Linear ( d_model , d_model , r = 8 )
k_proj = nn . Linear ( d_model , d_model )
v_proj = lora . Linear ( d_model , d_model , r = 8 )
# Alternatively, use lora.MergedLinear (recommended)
qkv_proj = lora . MergedLinear ( d_model , 3 * d_model , r = 8 , enable_lora = [ True , False , True ])lora . Você pode marcar alguns preconceitos como treináveis passando "All" ou "Lora_only" para bias= ao chamar mark_only_lora_as_trainable . Lembre -se de passar o bias= argumento para lora_state_dict ao salvar um ponto de verificação. # ===== Before =====
# lora.mark_only_lora_as_trainable(model) # Not training any bias vectors
# ===== After =====
# Training all bias vectors associated with modules we apply LoRA to
lora . mark_only_lora_as_trainable ( model , bias = 'lora_only' )
# Alternatively, we can train *all* bias vectors in the model, including LayerNorm biases
lora . mark_only_lora_as_trainable ( model , bias = 'all' )
# When saving a checkpoint, use the same bias= ('all' or 'lora_only')
torch . save ( lora . lora_state_dict ( model , bias = 'all' ), checkpoint_path )model.eval() acionará a fusão dos parâmetros LORA com os correspondentes pré -treinados, o que elimina a latência adicional para passes avançados subsequentes. Chamar model.train() novamente desfazer a mesclagem. Isso pode ser desativado passando merge_weights=False to lora camadas. Entre em contato conosco ou publique um problema se tiver alguma dúvida.
Para perguntas relacionadas ao pacote loralib :
O exemplo GPT-2:
O exemplo de Roberta/Deberta:
Agradecemos em ordem alfabética Jianfeng Gao, Jade Huang, Jiayuan Huang, Lisa Xiang Li, Xiaodong Liu, Yabin Liu, Benjamin Van Durme, Luis Vargas, Haoran Wei, Peter Welinder e Greg Yang por fornecer um feedback valioso.
@inproceedings {
hu2022lora,
title = { Lo{RA}: Low-Rank Adaptation of Large Language Models } ,
author = { Edward J Hu and Yelong Shen and Phillip Wallis and Zeyuan Allen-Zhu and Yuanzhi Li and Shean Wang and Lu Wang and Weizhu Chen } ,
booktitle = { International Conference on Learning Representations } ,
year = { 2022 } ,
url = { https://openreview.net/forum?id=nZeVKeeFYf9 }
}Este projeto recebe contribuições e sugestões. A maioria das contribuições exige que você concorde com um Contrato de Licença de Colaborador (CLA) declarando que você tem o direito e, na verdade, concede -nos os direitos de usar sua contribuição. Para detalhes, visite https://cla.opensource.microsoft.com.
Quando você envia uma solicitação de tração, um BOT do CLA determina automaticamente se você precisa fornecer um CLA e decorar o PR adequadamente (por exemplo, verificação de status, comentar). Simplesmente siga as instruções fornecidas pelo bot. Você só precisará fazer isso uma vez em todos os repositórios usando nosso CLA.
Este projeto adotou o Código de Conduta Open Microsoft. Para obter mais informações, consulte o Código de Conduta Perguntas frequentes ou entre em contato com [email protected] com quaisquer perguntas ou comentários adicionais.
