LoRA Torch

Lora-torch

Esta base de código reimplementa lora: adaptación de bajo rango de modelos de idiomas grandes (ICLR 2022) y se reconstruye en función de Loralib.

Características

Las implementaciones de loratorch y loralib son muy diferentes. Tomamos el nn.Linear como ejemplo de la siguiente manera.

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

dónde $ x in mathbb {r}^{k times n} $ es la matriz de entrada, $ W_0 in mathbb {r}^{m times n} $ es la matriz de peso previamente entrenada, $ R $ es el rango de lora predefinido, $ B in mathbb {r}^{m times r} $ y $ A in mathbb {r}^{r times n} $ son las matrices Lora, y $ alfa $ es un hiper-parámetro.

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

loralib calcula $ xw_0^ top $ y $ x (ba)^ top $ respectivamente y luego fusiona los resultados. Mientras que loratorch fusiona el peso previamente capacitado $ W_0 $ y su peso lora $ Ba $ y luego calcula los resultados simplemente usando nn.Linear.forward() . No hay diferencia entre loralib y loratorch en las capas lineales. Pero en algunas capas no lineales o complejas, no estamos seguros de si esta capa satisface $ L (x, w_0)+l (x, ba) = l (x, w_0+ba) $ . Por lo tanto, es difícil extender Lora a algunas capas complejas utilizando loralib . Por el contrario, la idea de fusionar pesos primero en loratorch es más general y extensible. Simplemente llame merge_lora_param() en loratorch para fusionar pesos y luego llamar forward() en la capa original para calcular los resultados. Con la ayuda de loratorch , puede implementar fácilmente Lora en cualquier tipo de capa de torch.nn .

Capas compatibles

	loralib	loratorch
nn.Linear	✓	✓	lineal.ipynb
nn.Embedding	✓	✓	incrustación.ipynb
nn.Conv1d	✓	✓
nn.Conv2d	✓	✓
nn.Conv3d	✓	✓
nn.MultiheadAttention	✘	✓
MergedLinear	✓ (error)	✓	fusionado lineal.ipynb
$ cdots $	Difícil de extender	fácil de extender

Comparamos los resultados de loralib y loratorch en ejemplos para demostrar la corrección de la implementación en loratorch .

Comienzo rápido

El uso de loratorch es el mismo 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. Reemplace las capas donde desea usar 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 solo los parámetros de Lora como entrenables antes del circuito de entrenamiento.

    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. Guardar el modelo Lora (solo se guardarán las matrices Lora).

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

5. Modelo de carga Lora (debe cargar primero el modelo previamente capacitado).

    # 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 )

Contribuyente

loratorch es desarrollado y mantenido por Baijiong Lin.

Contáctenos

Si tiene alguna pregunta o sugerencia, no dude en contactarnos planteando un problema o enviando un correo electrónico a [email protected] .

Expresiones de gratitud

loratorch se basa en gran medida en loralib . Agradecemos a sus autores por su maravillosa y de código abierto.

Citación

Si encuentra útil loratorch para su investigación o desarrollo, cite lo siguiente:

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

Licencia

loratorch es liberado bajo la licencia MIT.