PEFT documentation
Lily: Adaptasi Interkoneksi Ber-Rendah-Rangking Lintas Lapisan
Lily: Adaptasi Interkoneksi Ber-Rendah-Rangking Lintas Lapisan
Lily adalah teknik fine-tuning yang efisien secara parameter, yang memperkenalkan berbagi bobot antar-lapisan untuk matriks adapter. Alih-alih mempelajari pasangan AB yang independen untuk setiap lapisan seperti pada LoRA, Lily menggunakan adapter A yang dibagikan secara lokal (setiap A dibagikan di antara blok stride_A lapisan berurutan) dan ekspert B yang dibagikan secara global (sebuah pool kecil berisi num_B adapter B dibagikan di antara semua lapisan). Pada setiap forward pass, router ringan yang bergantung pada data menghitung kombinasi berbobot softmax dari para ekspert B untuk menghasilkan B efektif untuk lapisan dan input tersebut.
Berbagi ini dapat mengurangi jumlah total matriks adapter dari 2N (LoRA standar) menjadi N / stride_A + num_B, sehingga membebaskan anggaran parameter untuk menggunakan rank r yang jauh lebih besar β biasanya 2Γβ4Γ dari yang Anda gunakan dalam LoRA. Rank yang lebih tinggi dan konektivitas antar-komponen yang lebih baik meningkatkan rank efektif dari pembaruan bobot ΞW = A Γ combined_B, yang menghasilkan kinerja adaptasi yang lebih baik.
Karena kombinasi B bersifat bergantung pada data (bobot router bergantung pada aktivasi input saat runtime), merge dan unmerge tidak didukung. Jika penggabungan bobot diperlukan untuk deployment Anda, pertimbangkan metode lain seperti LoRA.
Saat ini, Lily memiliki kendala tambahan berikut:
- Hanya lapisan
nn.Linearyang didukung. - Lapisan terkuantisasi tidak didukung.
Jika batasan-batasan ini tidak sesuai dengan kasus penggunaan Anda, pertimbangkan metode lain sebagai gantinya.
Abstrak dari makalah tersebut adalah:
Adaptasi peringkat rendah (LoRA) adalah metode penyesuaian halus yang efisien parameter (PEFT) yang banyak digunakan, yang mempelajari pembaruan bobot ΞW = AB untuk bobot pralatih W melalui adapter peringkat rendah A dan B. Meskipun LoRA memastikan efisiensi perangkat keras, pembaruan bobot peringkat rendahnya membatasi kinerja adaptasi. Dalam makalah ini, kami mengusulkan adaptasi peringkat rendah yang saling terhubung antar lapisan (Lily), sebuah metode PEFT baru yang memperkenalkan kerangka kerja saling terhubung dengan pakar A yang dibagikan secara lokal dan pakar B yang dibagikan secara global. Struktur ini menghilangkan pasangan AB per lapisan yang redundan, memungkinkan ΞW dengan peringkat yang lebih tinggi dengan jumlah parameter yang sama atau lebih sedikit. Untuk meningkatkan daya ekspresi, kami menggunakan router yang bergantung pada data untuk menentukan koneksi antar A-B, mencegah pakar B konvergen ke perilaku yang sama, dan meningkatkan daya representasi di berbagai domain. Eksperimen di berbagai modalitas, arsitektur, dan ukuran model menunjukkan kinerja dan efisiensi Lily yang unggul.
Ikhtisar benchmark
API
LilyConfig
kelas peft.LilyConfig
< source >( task_type: Optional[Union[str, TaskType]] = Nonepeft_type: Optional[Union[str, PeftType]] = Noneauto_mapping: Optional[dict] = Nonepeft_version: Optional[str] = Nonebase_model_name_or_path: Optional[str] = Nonerevision: Optional[str] = Noneinference_mode: bool = Falser: int = 32stride_A: int = 1num_B: int = 2scaling: float = 1.0target_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = Nonelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Noneinit_weights: bool = True )
Parameter
- r (
int) β Rank dari Lily. Menentukan dimensi hidden internal dari setiap adapter dan rank dari pembaruan bobotA @ B. Pada Lily, karena jumlah adapter biasanya lebih kecil daripada pada LoRA, setiap adapter perlu membawa lebih banyak kapasitas, sehingga disarankan untuk menggunakanryang lebih besar daripada pada LoRA β biasanya2x,3x, atau4xdari rank LoRA yang biasanya Anda gunakan. Jumlah total parameter yang dapat dilatih berskala denganr * (total_layers / stride_A + num_B), sehingga meningkatkanrsambil menjagastride_Atetap besar dannum_Btetap kecil adalah trade-off yang disarankan. - stride_A (
int) β Jumlah lapisan berurutan yang berbagi satu adapter A. Misalnya, jikastride_A=4, setiap 4 lapisan bersebelahan berbagi adapter A yang sama, sehingga menghasilkantotal_layers / stride_Aadapter A yang berbeda secara total. Adapter A mengompresi input menjadi representasi low-rank berukuranr.stride_Atidak boleh kurang dari- Nilai yang disarankan:
2,3, atau4(yaitu berbagi setiap 2, 3, atau 4 lapisan). Menjagastride_Abesar (lebih sedikit adapter A yang berbeda) dan meningkatkanrsebagai gantinya menghasilkan kinerja yang lebih baik daripada trade-off sebaliknya (stride_Akecil,rkecil). Mengaturstride_A=1berarti setiap lapisan memiliki adapter A-nya sendiri. CATATAN: berbagi A terjadi di dalam setiap target (lapisan dengan sufiks target yang sama). Misalnya, jika target_modules Anda adalah['q_proj', 'v_proj']dan Anda mengaturstride_A=2, maka setiap 2 lapisan q_proj yang berdekatan akan berbagi satu adapter A, dan setiap 2 lapisan v_proj yang berdekatan akan berbagi adapter A lainnya, tetapi lapisan q_proj dan v_proj tidak akan berbagi adapter A satu sama lain karena mereka memiliki sufiks yang berbeda.
- Nilai yang disarankan:
- num_B (
int) β Jumlah adapter B yang dibagikan. Berbeda dengan adapter A (yang dikelompokkan per lapisan), semua adapter B dibagikan secara global di setiap lapisan. Untuk setiap forward pass, sebuah router menghitung kombinasi berbobot dari semuanum_Badapter B (menggunakan bobot yang dinormalisasi dengan softmax) untuk menghasilkan satu adapter B gabungan, yang kemudian memproyeksikan representasi low-rank kembali ke dimensi asli. Disarankan untuk mengaturnum_Bke orde yang serupa dengantotal_layers / stride_A. Nilai yang disarankan:total_layers / 2,total_layers / 3, atautotal_layers / 4. Sama sepertistride_A, lebih baik memilihnum_Byang lebih kecil denganryang lebih besar daripadanum_Byang lebih besar denganryang lebih kecil. CATATAN: untuk melatih router, Anda membutuhkan setidaknya 2 adapter B (yaitunum_B >= 2), karena router belajar menghitung kombinasi berbobot dari adapter B. CATATAN: pembagian B terjadi di dalam setiap target (lapisan dengan sufiks target yang sama). Misalnya, jika target_modules Anda adalah['q_proj', 'v_proj']dan Anda mengaturnum_B=4, maka akan ada 4 adapter B yang dibagikan di semua lapisan q_proj, dan 4 adapter B lainnya yang dibagikan di semua lapisan v_proj, tetapi lapisan q_proj dan v_proj tidak akan saling membagikan adapter B karena mereka memiliki sufiks yang berbeda. - target_modules (
Union[List[str], str], opsional) β Nama-nama modul yang akan diterapkan Lily. Bisa berupa daftar string nama modul (mis.['q_proj', 'v_proj']) atau pola regex (mis.'.*decoder.*(SelfAttention|EncDecAttention).*(q|v)$'). Jika tidak dinyatakan, Lily akan diterapkan ke semua linear layer yang didukung. - scaling (
float) β Penggali skalar yang diterapkan pada output adapter gabungan (scaling * A @ combined_B) sebelum ditambahkan ke forward pass bobot beku. Berbeda dengan LoRA, Lily tidak menggunakan formulasialpha / r; sebagai gantinya,scalingadalah pengali langsung. Desain ini memudahkan pemindaian nilai pada skala log (misalnya0.01,0.1,1.0,10.0). Nilai optimal bergantung pada tugas dan harus diperlakukan sebagai hiperparameter. Kami merekomendasikan memulai dengan1.0. - modules_to_save (
List[str], opsional) β Daftar modul di luar lapisan Lily yang akan disetel sebagai trainable dan disimpan dalam checkpoint akhir. Sebagai contoh, pada tugas Sequence Classification atau Token Classification, lapisan akhirclassifier/scorediinisialisasi secara acak sehingga perlu dibuat trainable dan disimpan. - exclude_modules (
Union[List[str], str], opsional) β Nama-nama modul yang tidak akan diterapkan adapter. Saat meneruskan string, pencocokan regex akan dilakukan. Saat meneruskan daftar string, pencocokan persis akan dilakukan atau diperiksa apakah nama modul berakhiran dengan salah satu string yang diteruskan. - layers_to_transform (
Union[list[int], int], opsional) β Indeks layer yang akan ditransformasi. Jika argumen ini ditentukan, PEFT hanya akan mentransformasi indeks layer yang tercantum di dalam daftar ini. Jika satu bilangan bulat tunggal diberikan, PEFT hanya akan mentransformasi layer pada indeks tersebut. - layers_pattern (
Optional[Union[List[str], str]], opsional) β Nama pola layer, hanya digunakan jikalayers_to_transformberbeda dari None dan jika pola layer tersebut tidak ada dalam pola layer umum. Ini harus menargetkannn.ModuleListdari model, yang sering disebut sebagai'layers'atau'h'. - init_weights (
bool) β Apakah akan menginisialisasi bobot adapter Lily menggunakan skema inisialisasi default: matriks A diinisialisasi dengan Kaiming uniform, dan matriks B diinisialisasi ke nol, sehingga memastikan bahwa output adapter bernilai nol pada awal pelatihan dan tidak mengganggu model pretrained. Sangat disarankan untuk tetap mempertahankan nilai ini sebagaiTruekecuali Anda memiliki alasan spesifik untuk mengubahnya.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari LilyModel.
LilyModel
kelas peft.LilyModel
< source >( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None ) β torch.nn.Module
Parameter
- model (
torch.nn.Module) β Model yang akan diadaptasi. - config (LilyConfig) β Konfigurasi model Lily.
- adapter_name (
str) β Nama adapter, secara default"default".
Mengembalikan
torch.nn.Module
Model PEFT Lily.
Membuat model Low-Rank Interconnected Adaptation Across Layers (Lily) dari model transformers yang telah dilatih sebelumnya.
Metode ini dijelaskan secara rinci di https://arxiv.org/abs/2407.09946.
Atribut:
- model (PreTrainedModel) β Model yang akan diadaptasi.
- peft_config (LilyConfig): Konfigurasi model Lily.