LoRA Torch

Lora-Torch

Esta base de código reimplementa Lora: adaptação de baixo rank de modelos de linguagem grande (ICLR 2022) e é reconstruída com base no Loralib.

Características

As implementações de loratorch e loralib são muito diferentes. Tomamos o nn.Linear como um exemplo da seguinte maneira.

1. Para loralib , $ h = x w_0^ top + frac { alpha} {r} x (ba)^ top, $

onde $ x em mathbb {r}^{k times n} $ é a matriz de entrada, $ W_0 in mathbb {r}^{m times n} $ é a matriz de peso pré-treinada, $ r $ é a classificação de Lora predefinida, $ B in mathbb {r}^{m times r} $ e $ A em mathbb {r}^{r times n} $ são as matrizes de Lora, e $ alpha $ é um hiper-parâmetro.

2. Para loratorch , $ h = x (w_0 + frac { alpha} {r} ba)^ top. $

loralib calcula $ xw_0^ top $ e $ x (ba)^ top $ respectivamente e, em seguida, mescla os resultados. Enquanto loratorch mescla peso pré-treinado $ W_0 $ e seu peso Lora $ Ba $ e depois calcula os resultados simplesmente usando nn.Linear.forward() . Não há diferença entre loralib e loratorch nas camadas lineares. Mas em algumas camadas não lineares ou complexas, não temos certeza se essa camada satisfaz $ L (x, w_0)+l (x, ba) = l (x, w_0+ba) $ . Portanto, é difícil estender Lora a algumas camadas complexas usando loralib . Pelo contrário, a idéia de mesclar pesos primeiro em loratorch é mais geral e extensível. Você apenas chama merge_lora_param() em loratorch para mesclar pesos e depois ligar forward() na camada original para calcular os resultados. Com a ajuda do loratorch , você pode implementar facilmente a Lora em qualquer tipo de camada de torch.nn .

Camadas suportadas

	loralib	loratorch
nn.Linear	✓	✓	linear.ipynb
nn.Embedding	✓	✓	incorporação.ipynb
nn.Conv1d	✓	✓
nn.Conv2d	✓	✓
nn.Conv3d	✓	✓
nn.MultiheadAttention	✘	✓
MergedLinear	✓ (erro)	✓	MERGEDLINEAR.IPYNB
$ cdots $	difícil de estender	fácil de estender

Comparamos os resultados de loralib e loratorch em exemplos para demonstrar a correção da implementação em loratorch .

Início rápido

O uso de loratorch é o mesmo que loralib .

1. Instale loratorch .

   pip install git+https://github.com/Baijiong-Lin/LoRA-Torch
   # Alternatively for developers
   # git clone https://github.com/Baijiong-Lin/LoRA-Torch
   # cd LoRA-Torch
   # pip install -e .

2. Substitua as camadas onde você gostaria de usar o LORA usando loratorch .

    # ===== Before =====
   # layer = nn.Linear(in_features, out_features)
   
   # ===== After ======
   import loratorch as lora
   # Add a pair of low-rank adaptation matrices with rank r=16 and alpha=32
   layer = lora . Linear ( in_features , out_features , r = 16 , lora_alpha = 32 )

3. Marque apenas os parâmetros LORA como treináveis ​​antes do ciclo de treinamento.

    model = Model ()
   # (!!!) This sets requires_grad to False for all parameters without the string "lora_" in their names
   lora . mark_only_lora_as_trainable ( model )
   
   optimizer = torch . optim . SGD ( model . parameters (), lr = 0.1 )
   # Training loop
   for batch in dataloader :
       model . train ()
       # forward process
       loss = forward_fun ( model , batch )
       # backward process
       optimizer . zero_grad ()
       loss . backward ()
       optimizer . step ()
       # (!!!) reregister model param to ensure they are in model.state_dict() and model.parameters()
       # (!!!) Without this line, the performance does not be affected but you will find that some weights are missing in model.state_dict() and model.parameters()
       lora . register_model_param_after_backward ( model )

4. Save Lora Model (apenas as matrizes Lora serão salvas).

    # ===== Before =====
   # torch.save(model.state_dict(), checkpoint_path)
   # ===== After =====
   torch . save ( lora . lora_state_dict ( model ), checkpoint_path )

5. Carregar o modelo Lora (precisa carregar o modelo pré-treinado primeiro).

    # Load the pre-trained 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 )

Contribuinte

loratorch é desenvolvido e mantido por Baijiong Lin.

Contate-nos

Se você tiver alguma dúvida ou sugestão, não hesite em entrar em contato conosco levantando um problema ou enviando um email para [email protected] .

Agradecimentos

loratorch é fortemente baseado no loralib . Agradecemos a seus autores por sua maravilhosa e base de código de código aberto.

Citação

Se você achar loratorch útil para sua pesquisa ou desenvolvimento, cite o seguinte:

 @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 } ,
}

@software { lin2023loratorch ,
  author = { Baijiong Lin } ,
  title = { {LoRA-Torch}: {PyTorch} Reimplementation of {LoRA} } ,
  url = { https://github.com/Baijiong-Lin/LoRA-Torch } ,
  year = { 2023 }
}

Licença

loratorch é liberado sob a licença do MIT.