LoRA Torch

Lora-torch

Basis kode ini mengimplementasikan lora: adaptasi rendah dari model bahasa besar (ICLR 2022) dan direkonstruksi berdasarkan loralb.

Fitur

Implementasi loratorch dan loralib sangat berbeda. Kami menganggap nn.Linear sebagai contoh sebagai berikut.

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

Di mana $ x di mathbb {r}^{k kali n} $ adalah matriks input, $ W_0 di mathbb {r}^{m kali n} $ adalah matriks berat pra-terlatih, $ r $ adalah peringkat Lora yang telah ditentukan, $ B di mathbb {r}^{m kali r} $ Dan $ A in mathbb {r}^{r kali n} $ adalah matriks lora, dan $ alpha $ adalah hiper-parameter.

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

loralib menghitung $ xw_0^ top $ Dan $ x (ba)^ top $ masing -masing dan kemudian menggabungkan hasilnya. Sementara loratorch menggabungkan berat pra-terlatih $ W_0 $ dan beratnya Lora $ Ba $ dan kemudian menghitung hasil dengan hanya menggunakan nn.Linear.forward() . Tidak ada perbedaan antara loralib dan loratorch di lapisan linier. Tetapi di beberapa lapisan no-linear atau kompleks, kami tidak yakin apakah lapisan ini memuaskan $ L (x, w_0)+l (x, ba) = l (x, w_0+ba) $ . Oleh karena itu, sulit untuk memperluas Lora ke beberapa lapisan kompleks dengan menggunakan loralib . Sebaliknya, gagasan menggabungkan bobot pertama di loratorch lebih umum dan dapat diperluas. Anda hanya memanggil merge_lora_param() di loratorch untuk menggabungkan bobot dan kemudian menelepon forward() di lapisan asli untuk menghitung hasilnya. Dengan bantuan loratorch , Anda dapat dengan mudah mengimplementasikan Lora ke semua jenis lapisan torch.nn .

Lapisan yang didukung

	loralib	loratorch
nn.Linear	✓	✓	linear.ipynb
nn.Embedding	✓	✓	embedding.ipynb
nn.Conv1d	✓	✓
nn.Conv2d	✓	✓
nn.Conv3d	✓	✓
nn.MultiheadAttention	✘	✓
MergedLinear	✓ (kesalahan)	✓	mergedlinear.ipynb
$ cdots $	sulit diperluas	mudah diperpanjang

Kami membandingkan hasil loralib dan loratorch dalam contoh untuk menunjukkan kebenaran implementasi di loratorch .

Awal yang cepat

Penggunaan loratorch sama dengan loralib .

1. Instal 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. Ganti lapisan tempat Anda ingin menggunakan Lora dengan menggunakan 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. Tandai hanya parameter Lora sebagai dapat dilatih sebelum loop pelatihan.

    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. Simpan model Lora (hanya matriks Lora yang akan disimpan).

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

5. Muat model LORA (perlu memuat model terlatih terlebih dahulu).

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

Penyumbang

loratorch dikembangkan dan dikelola oleh Baijiong Lin.

Hubungi kami

Jika Anda memiliki pertanyaan atau saran, jangan ragu untuk menghubungi kami dengan mengangkat masalah atau mengirim email ke [email protected] .

Ucapan Terima Kasih

loratorch sangat didasarkan pada loralib . Kami berterima kasih kepada penulisnya atas basis kode mereka yang luar biasa dan open-source.

Kutipan

Jika Anda menemukan loratorch berguna untuk penelitian atau pengembangan Anda, silakan kutip yang berikut:

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

Lisensi

loratorch dirilis di bawah lisensi MIT.