# Lily: Adaptasi Interkoneksi Ber-Rendah-Rangking Lintas Lapisan

[Lily](https://huggingface.co/papers/2407.09946) 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

<iframe src="https://peft-internal-testing-peft-method-comparison-embed.hf.space/?highlight[type]=LILY" frameborder="0" width="850" height="1000"
>

# API

## LilyConfig[[peft.LilyConfig]]

#### peft.LilyConfig[[peft.LilyConfig]]

```python
peft.LilyConfig(task_type: Optional[Union[str, TaskType]] = None, peft_type: Optional[Union[str, PeftType]] = None, auto_mapping: Optional[dict] = None, peft_version: Optional[str] = None, base_model_name_or_path: Optional[str] = None, revision: Optional[str] = None, inference_mode: bool = False, r: int = 32, stride_A: int = 1, num_B: int = 2, scaling: float = 1.0, target_modules: Optional[Union[list[str], str]] = None, exclude_modules: Optional[Union[list[str], str]] = None, modules_to_save: Optional[list[str]] = None, layers_to_transform: Optional[Union[list[int], int]] = None, layers_pattern: Optional[Union[list[str], str]] = None, init_weights: bool = True)
```

[Sumber](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/lily/config.py#L24)

**Parameter:**

r (`int`) : peringkat Lily. Menentukan dimensi tersembunyi internal dari setiap adapter dan peringkat 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 peringkat 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 kompromi yang disarankan.

stride_A (`int`) : Jumlah lapisan berurutan yang berbagi satu adapter A. Sebagai contoh, jika `stride_A=4`, setiap 4 lapisan yang berdekatan berbagi adapter A yang sama, sehingga menghasilkan `total_layers / stride_A` adapter A yang berbeda secara total. Adapter A mengompresi input menjadi representasi ber-rank rendah berukuran `r`. `stride_A` harus tidak kurang dari 1. Nilai yang disarankan: `2`, `3`, atau `4` (yaitu berbagi setiap 2, 3, atau 4 lapisan). Menjaga `stride_A` tetap besar (lebih sedikit adapter A yang berbeda) dan meningkatkan `r` alih-alih menghasilkan kinerja yang lebih baik dibandingkan 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). Sebagai contoh, 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 bersama. 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`. Mirip dengan `stride_A`, lebih utamakan `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 ditentukan, Lily akan diterapkan ke semua lapisan linear yang didukung.

scaling (`float`) : Pengali skalar yang diterapkan pada output adapter gabungan (`scaling * A @ combined_B`) sebelum ditambahkan ke jalur maju bobot beku. Berbeda dengan LoRA, Lily tidak menggunakan formulasi `alpha / r`; sebagai gantinya, `scaling` adalah pengali langsung. Desain ini memudahkan pengujian nilai pada skala logaritma (mis. `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 diatur sebagai dapat dilatih dan disimpan dalam checkpoint akhir. Misalnya, dalam tugas Sequence Classification atau Token Classification, lapisan akhir `classifier/score` diinisialisasi secara acak sehingga perlu dapat dilatih dan disimpan.

exclude_modules (`Union[List[str], str]`, *opsional*) : Nama-nama modul yang tidak akan diterapkan adapter. Saat melewatkan string, pencocokan regex akan dilakukan. Saat melewatkan daftar string, pencocokan persis akan dilakukan atau diperiksa apakah nama modul diakhiri dengan salah satu string yang dilewatkan.

layers_to_transform (`Union[list[int], int]`, *opsional*) : Indeks lapisan yang akan ditransformasi. Jika argumen ini ditentukan, PEFT hanya akan mentransformasi indeks lapisan yang ditentukan di dalam daftar ini. Jika satu bilangan bulat tunggal diberikan, PEFT hanya akan mentransformasi lapisan 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 tidak ada dalam pola layer umum. Ini harus menargetkan `nn.ModuleList` dari model, yang sering disebut `'layers'` atau `'h'`.

init_weights (`bool`) : Apakah akan menginisialisasi bobot adapter Lily menggunakan skema inisialisasi bawaan: 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](/docs/peft/v0.22.0/id/package_reference/lily#peft.LilyModel).

## LilyModel[[peft.LilyModel]]

#### peft.LilyModel[[peft.LilyModel]]

```python
peft.LilyModel(model, peft_config: Union[PeftConfig, dict[str, PeftConfig]], adapter_name: str, low_cpu_mem_usage: bool = False, state_dict: Optional[dict[str, torch.Tensor]] = None)
```

[Sumber](https://github.com/huggingface/peft/blob/v0.22.0/src/peft/tuners/lily/model.py#L30)

**Parameter:**

model (`torch.nn.Module`) : Model yang akan diadaptasi.

config ([LilyConfig](/docs/peft/v0.22.0/id/package_reference/lily#peft.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 detail di https://arxiv.org/abs/2407.09946.

**Atribut**:
- **model** ([PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel)) -- Model yang akan diadaptasi.
- **peft_config** ([LilyConfig](/docs/peft/v0.22.0/id/package_reference/lily#peft.LilyConfig)): Konfigurasi model Lily.

