LoLDU

Loldu: Adaptasi peringkat rendah melalui dekomposisi diag-atas-atas

Loldu adalah teknik fine-tuning-tuning (PEFT) parameter-edge-edge yang dirancang untuk secara drastis mengurangi jumlah parameter yang dapat dilatih sambil mencapai tingkat kinerja yang sebanding dengan fine-tuning penuh. Dokumen ini menguraikan langkah -langkah yang diperlukan untuk mengintegrasikan Loldu ke dalam proyek Anda secara efektif.

Untuk perincian lebih lanjut, silakan merujuk ke makalah: https://arxiv.org/pdf/2410.13618

Daftar isi

1. Instalasi
2. Fitur utama
3. Awal yang cepat
4. Referensi API
5. Contoh penggunaan
6. Praktik terbaik

Instalasi

Untuk menginstal Loldu, cukup gunakan PIP:

git clone https://github.com/SKDDJ/LoLDU
cd LoLDU
pip install -e . 

Fitur utama

• Secara signifikan mengurangi jumlah parameter yang dapat dilatih (hingga 2600 kali lebih sedikit dari metode PEFT biasa)
• Mempertahankan kinerja yang sebanding dengan fine-tuning penuh
• Memanfaatkan dekomposisi diag-tinggi (LDU) untuk konvergensi dan ortogonalitas yang lebih cepat
• Berfokus pada mengoptimalkan matriks diagonal untuk transformasi penskalaan
• Kompatibel dengan berbagai arsitektur model (misalnya, Llama2, Roberta, Vit, Difusi Stabil)

Awal yang cepat

Berikut adalah contoh singkat tentang cara menggunakan Loldu:

 import torch
import torch . nn as nn
from functools import partial
from minloldu import LoLDUParametrization , add_loldu , get_loldu_params

# Define your model
model = YourModel ()

# Define LoLDU configuration
loldu_config = {
    nn . Linear : {
        "weight" : partial ( LoLDUParametrization . from_linear , rank = 15 ),
    },
}

# Add LoLDU to the model
add_loldu ( model , loldu_config = loldu_config )

# Freeze all parameters
for param in model . parameters ():
    param . requires_grad = False

# Enable gradients for LoLDU parameters
for param in get_loldu_params ( model ):
    param . requires_grad = True

# Now your model is ready for fine-tuning with LoLDU 

Referensi API

Fungsi utama

1. add_loldu(model, loldu_config)

   • Menambahkan parameterisasi Loldu ke model yang ditentukan.
   • model : Model Pytorch untuk memodifikasi.
   • loldu_config : Kamus Konfigurasi untuk Loldu.

2. get_loldu_params(model, print_shapes=False)

   • Mengembalikan parameter loldu dari model.
   • model : Model Pytorch dengan Loldu.
   • print_shapes : Jika benar, cetak bentuk parameter Loldu.

3. disable_loldu(model)

   • Sementara menonaktifkan Loldu dalam model.

4. enable_loldu(model)

   • Mengaktifkan kembali Loldu dalam model setelah menonaktifkan.

5. remove_loldu(model)

   • Benar -benar menghilangkan Loldu dari model.

6. merge_loldu(model)

   • Gabungkan parameter LOLDU ke dalam bobot model asli untuk inferensi yang efisien.

7. get_loldu_state_dict(model)

   • Mengembalikan Kamus Negara Parameter Loldu untuk disimpan.

Kelas Lolduparametrization

• LoLDUParametrization.from_linear(layer, rank)
  • Membuat parameterisasi loldu untuk lapisan linier.
  • layer : Lapisan linier untuk parameterisasi.
  • rank : Peringkat untuk perkiraan peringkat rendah.

Contoh penggunaan

Menambahkan Loldu ke model

 from minloldu import LoLDUParametrization , add_loldu
from functools import partial

class MyModel ( nn . Module ):
    def __init__ ( self ):
        super (). __init__ ()
        self . model = nn . Sequential (
            nn . Linear ( in_features = 15 , out_features = 15 ),
        )
    def forward ( self , x ):
        return self . model ( x )

model = MyModel ()

loldu_config = {
    nn . Linear : {
        "weight" : partial ( LoLDUParametrization . from_linear , rank = 15 ),
    },
}

add_loldu ( model , loldu_config = loldu_config )

Pelatihan dengan Loldu

 from minloldu import get_loldu_params

# Freeze all parameters
for param in model . parameters ():
    param . requires_grad = False

# Enable gradients for LoLDU parameters
for param in get_loldu_params ( model ):
    param . requires_grad = True

# Your training loop here

Menyimpan dan Memuat Negara Loldu

 from minloldu import get_loldu_state_dict

# Save LoLDU state
state_dict_to_save = get_loldu_state_dict ( model )
torch . save ( state_dict_to_save , "loldu_state.pth" )

# Load LoLDU state
loaded_state = torch . load ( "loldu_state.pth" )
model . load_state_dict ( loaded_state , strict = False )

Menggabungkan loldu untuk inferensi

 from minloldu import merge_loldu

# After training, merge LoLDU for efficient inference
merge_loldu ( model )

Praktik terbaik

1. Pilih peringkat yang sesuai : Parameter peringkat dalam lolduparametrization mempengaruhi pertukaran antara efisiensi parameter dan kinerja model. Bereksperimenlah dengan peringkat yang berbeda untuk menemukan keseimbangan optimal untuk tugas Anda.

2. Hyperparameters fine-tune : Loldu mungkin memerlukan tingkat pembelajaran yang berbeda dibandingkan dengan fine-tuning penuh. Sesuaikan tingkat pembelajaran Anda dan hiperparameter lainnya.

3. Pelatihan Monitor : Mengawasi proses pelatihan untuk memastikan bahwa Loldu secara efektif mengadaptasi model. Gunakan set validasi untuk mencegah overfitting.

4. Gabungkan untuk inferensi : Selalu gunakan merge_loldu() sebelum menggunakan model Anda untuk inferensi untuk menghilangkan overhead komputasi.

5. Kombinasikan dengan teknik lain : Loldu dapat dikombinasikan dengan teknik optimasi lainnya seperti kuantisasi untuk efisiensi yang lebih besar.

Untuk informasi yang lebih rinci dan penggunaan lanjutan, silakan merujuk ke makalah asli dan repositori kode sumber.

---

Catatan:
Perlu diketahui bahwa kode ini mungkin tidak sepenuhnya mereplikasi hasil yang disajikan dalam makalah karena kemungkinan kesalahan manusia yang terjadi selama persiapan dan pembersihan kode sebelum dirilis. Jika Anda mengalami tantangan dalam mereproduksi temuan kami, jangan ragu untuk menjangkau kami. Selain itu, kami berkomitmen untuk melakukan eksperimen pemeriksaan kewarasan dalam waktu dekat.

Pengakuan
Implementasi Loldu kami sangat ditingkatkan oleh Minlora Codebase.

Bibtex

 @misc { shi2024loldulowrankadaptationlowerdiagupper ,
  title = { LoLDU: Low-Rank Adaptation via Lower-Diag-Upper Decomposition for Parameter-Efficient Fine-Tuning } , 
  author = { Yiming Shi and Jiwei Wei and Yujia Wu and Ran Ran and Chengwei Sun and Shiyuan He and Yang Yang } ,
  year = { 2024 } ,
  eprint = { 2410.13618 } ,
  archivePrefix = { arXiv } ,
  primaryClass = { cs.CV } ,
  url = { https://arxiv.org/abs/2410.13618 } ,
}