PEFT documentation

Lily: Adaptasi Interkoneksi Ber-Rendah-Rangking Lintas Lapisan

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.21.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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.Linear yang 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

< >

( 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 bobot A @ B. Pada Lily, karena jumlah adapter biasanya lebih kecil daripada pada LoRA, setiap adapter perlu membawa lebih banyak kapasitas, sehingga disarankan untuk menggunakan r yang lebih besar daripada pada LoRA β€” biasanya 2x, 3x, atau 4x dari rank LoRA yang biasanya Anda gunakan. Jumlah total parameter yang dapat dilatih berskala dengan r * (total_layers / stride_A + num_B), sehingga meningkatkan r sambil menjaga stride_A tetap besar dan num_B tetap kecil adalah trade-off yang disarankan.
  • stride_A (int) β€” Jumlah lapisan berurutan yang berbagi satu adapter A. Misalnya, jika stride_A=4, setiap 4 lapisan bersebelahan berbagi adapter A yang sama, sehingga menghasilkan total_layers / stride_A adapter A yang berbeda secara total. Adapter A mengompresi input menjadi representasi low-rank berukuran r. stride_A tidak boleh kurang dari
    1. Nilai yang disarankan: 2, 3, atau 4 (yaitu berbagi setiap 2, 3, atau 4 lapisan). Menjaga stride_A besar (lebih sedikit adapter A yang berbeda) dan meningkatkan r sebagai gantinya menghasilkan kinerja yang lebih baik daripada trade-off sebaliknya (stride_A kecil, r kecil). Mengatur stride_A=1 berarti 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 mengatur stride_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.
  • 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 semua num_B adapter 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 mengatur num_B ke orde yang serupa dengan total_layers / stride_A. Nilai yang disarankan: total_layers / 2, total_layers / 3, atau total_layers / 4. Sama seperti stride_A, lebih baik memilih num_B yang lebih kecil dengan r yang lebih besar daripada num_B yang lebih besar dengan r yang lebih kecil. CATATAN: untuk melatih router, Anda membutuhkan setidaknya 2 adapter B (yaitu num_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 mengatur num_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 formulasi alpha / r; sebagai gantinya, scaling adalah pengali langsung. Desain ini memudahkan pemindaian nilai pada skala log (misalnya 0.01, 0.1, 1.0, 10.0). Nilai optimal bergantung pada tugas dan harus diperlakukan sebagai hiperparameter. Kami merekomendasikan memulai dengan 1.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 akhir classifier/score diinisialisasi 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 jika layers_to_transform berbeda dari None dan jika pola layer tersebut tidak ada dalam pola layer umum. Ini harus menargetkan nn.ModuleList dari 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 sebagai True kecuali Anda memiliki alasan spesifik untuk mengubahnya.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari LilyModel.

LilyModel

kelas peft.LilyModel

< >

( 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:

Update on GitHub