curlora

Curlora: Mitigação de Tuneamento Fino e Catastrófico de Esquecimento Catastrófico de LLM estável

Muhammad Fawi

Código doi:

Pesquisa pré -impressão doi:

Visão geral

Este repositório contém o código para o artigo de pesquisa de Curlora, uma nova abordagem para os grandes modelos de linguagem (LLMS) que aproveitam a decomposição da matriz CUR no contexto da adaptação de baixo rank (LORA). Nosso método aborda dois desafios críticos no ajuste fino do LLM: mitigando o esquecimento catastrófico durante o aprendizado contínuo e reduzindo o número de parâmetros treináveis. Propomos uma modificação única ao processo de decomposição do CUR para permitir uma maneira mais eficiente e estável de adaptar o LLMS a novas tarefas sem comprometer o conhecimento existente. Demonstramos por meio de experimentos em vários conjuntos de dados que o Curlora supera o padrão LORA para atenuar o esquecimento catastrófico. Ele mantém a estabilidade e o desempenho do modelo nas tarefas, reduzindo significativamente o número de parâmetros treináveis. Nossos resultados mostram que a Curlora atinge a precisão superior e os escores de perplexidade em comparação com a LORA, particularmente em cenários com dados limitados.

Conteúdo

• CURLoRA.pdf : O artigo de pesquisa detalhando a abordagem de Curlora.
• code/ : Diretório que contém a implementação de Curlora e os experimentos.
  • code/curlora.py : contendo classes de curlora.
  • code/utils.py : funções auxiliares.
  • code/lora.py : Lora Classes.
  • code/curlora_experiment.ipynb : Curlora Experiment com Mistral 7b (ajuste fino no MRPC, SST-2 e Sentiment140).
  • code/curlora_experiment-gpt.ipynb : Experimento de Curlora com GPT2-Large (ajuste fino no MRPC, SST-2 e Sentiment140).
  • code/squad_gpt-curlora.ipynb : GPT2-Large fino para perguntas e respostas com curlora e sfttrainer no conjunto de dados do esquadrão.

Os mesmos cadernos estão disponíveis para Lora.

Início rápido

Primeiro, instalamos os requisitos

pip3 install -r code/requirements.txt

Todas as funções e classes Curlora Helper são definidas em código/curlora.py e code/utils.py .

Carregue o modelo e aplique curlora

 from transformers import AutoTokenizer , AutoModelForCausalLM
from utils import *

model_name = "gpt2-large"
model = AutoModelForCausalLM . from_pretrained ( model_name )
model . to ( "cuda" ) # this will make all existing layers in CUDA

# turning off grad for all layers
for param in model . parameters ():
    param . requires_grad = False


# replace original Q,K,V layers with CURLoRA (GPT2-Large specific)
# refer to utils.py for a more general way
for name , module in model . named_modules ():
    if isinstance ( module , type ( model . transformer . h [ 0 ]. attn )):
        # rank = 24, alpha = 1
        module . c_attn = LinearWithCURLoRA ( module . c_attn , 24 , 1 )


# now look at how many CURLoRA parameters to be trained
total_params = sum ( p . numel () for p in model . parameters () if p . requires_grad )
print ( f"Total trainable parameters after: { total_params :, } " )
# making sure CURLoRA layers are on CUDA as well
model . to ( "cuda" )

Agora você tem o modelo com as camadas de curlora aplicadas a camadas de atenção (chave, valor e consulta) que você pode usar para ajuste fino ou inferência normalmente.

Pode ser necessário saber como a camada é chamada para que você possa substituí -la corretamente. Por exemplo, Q, K, V em Mistral pode ser encontrado via:

 for name , module in model . named_children ():
    if any ( l in name for l in [ "q_proj" , "v_proj" , "k_proj" ]):
        setattr ( model , name , LinearWithCURLoRA ( module , rank , alpha ))

Observe:

1. Algumas variáveis ​​e valores são codificados em código/utils.py ou code/curlora.py como as camadas a serem aplicadas, classificação, alfa, dispositivo etc.
2. Trabalho em andamento (contribuições são bem -vindas) sobre a quantização de suporte (qcurlora), ou seja, até agora você carrega todo o modelo não quantizado.
3. No código/ diretório, existem notebooks para executar os experimentos de papel de pesquisa
4. Pode ser necessário usar uma taxa de aprendizado um pouco mais alta do que com a LORA para obter melhor precisão. A taxa de ensino superior não causará excesso de ajuste devido à "regularização implícita" explicada no artigo.

Licença

Este projeto está licenciado sob a licença do MIT - consulte o arquivo de licença para obter detalhes.

Citação

Se você achar útil a Curlora ou o código, considere citá -los.

Citação de código

1. Bibtext

 @software { Fawi_CURLoRA_Leveraging_CUR_2024 ,
  author       = { Fawi, Muhammad } ,
  title        = { {CURLoRA: Leveraging CUR Matrix Decomposition for 
                   Stable LLM Continual Fine-Tuning and Catastrophic
                   Forgetting Mitigation} } ,
  month        = jul,
  year         = 2024 ,
  publisher    = { Zenodo } ,
  version      = { v4.0.0 } ,
  doi          = { 10.5281/zenodo.12729738 } ,
  url          = { https://zenodo.org/doi/10.5281/zenodo.12729738 }
}

2. APA

 Fawi, M. (2024). CURLoRA: Leveraging CUR Matrix Decomposition for Stable LLM Continual Fine-Tuning and Catastrophic Forgetting Mitigation (v4.0.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.12729738

Citação de papel de pesquisa

1. Bibtext

 @misc { fawi_2024_12730055 ,
  author       = { Fawi, Muhammad } ,
  title        = { {CURLoRA: Leveraging CUR Matrix Decomposition for 
                   Stable LLM Continual Fine-Tuning and Catastrophic
                   Forgetting Mitigation} } ,
  month        = jul,
  year         = 2024 ,
  publisher    = { Zenodo } ,
  doi          = { 10.5281/zenodo.12730055 } ,
  url          = { https://doi.org/10.5281/zenodo.12730055 }
}

2. APA

 Fawi, M. (2024). CURLoRA: Leveraging CUR Matrix Decomposition for Stable LLM Continual Fine-Tuning and Catastrophic Forgetting Mitigation. Zenodo. https://doi.org/10.5281/zenodo.12730055

Contribuição e idéias serão muito apreciadas