PEFT documentation

PEANuT: Adaptasi Efisien Parameter dengan Tweaker Neural yang Menyadari Bobot

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

PEANuT: Adaptasi Efisien Parameter dengan Tweaker Neural yang Menyadari Bobot

PEANuT adalah teknik fine-tuning yang efisien secara parameter, yang memperkenalkan neural tweakers yang sadar bobot untuk menghasilkan pembaruan adapter dari bobot pretrained yang dibekukan itu sendiri. Alih-alih mempelajari pembaruan low-rank yang murni linear seperti pada LoRA, PEANuT mengondisikan transformasi adapter pada bobot dasar, yang membuat aturan pembaruan lebih ekspresif sambil tetap menjaga jumlah parameter yang dapat dilatih tetap kecil.

PEANuT menggunakan proyeksi input A, proyeksi output B, dan pasangan encoder/decoder residual antara yang opsional dengan aktivasi non-linear. Hal ini memungkinkan pemodelan pola pembaruan yang lebih kompleks daripada adapter linear yang agnostik terhadap bobot, sambil tetap berada dalam pengaturan PEFT.

PEANuT saat ini memiliki beberapa tradeoff berikut:

Kelebihan:

  • Ekspresivitas teoretis yang lebih tinggi daripada pembaruan peringkat rendah linear.
  • Performa yang lebih baik daripada LoRA pada berbagai tugas dengan anggaran yang serupa.
  • Berjalan dengan baik pada rentang parameter yang sangat rendah, misalnya sekitar 0.2M parameter yang dapat dilatih.

Kekurangan:

  • Penggunaan memori lebih tinggi daripada LoRA, karena Ξ”W secara eksplisit dibangun sebelum diterapkan.
  • Pelatihan dan inferensi lebih lambat daripada LoRA, dan lapisan perantara yang lebih dalam meningkatkan overhead lebih lanjut.
  • Non-linearitas dapat memerlukan penyetelan hiperparameter yang lebih cermat, terutama untuk learning rate dan pengaturan optimasi terkait.

Jika tradeoff ini tidak sesuai dengan use case Anda, pertimbangkan metode PEFT lain seperti LoRA.

Abstrak dari makalah tersebut adalah:

Fine-tuning model fondasi pra-terlatih yang besar sering kali menghasilkan kinerja hilir yang sangat baik, tetapi biayanya sangat mahal ketika memperbarui semua parameter. Metode fine-tuning yang efisien secara parameter (PEFT) seperti LoRA meringankan masalah ini dengan memperkenalkan modul pembaruan yang ringan, namun mereka umumnya mengandalkan aproksimasi linear yang agnostik terhadap bobot, yang membatasi ekspresivitasnya. Dalam karya ini, kami mengusulkan PEANuT, sebuah kerangka kerja PEFT baru yang memperkenalkan neural tweakers yang sadar bobot, yaitu modul neural ringkas yang menghasilkan pembaruan yang adaptif terhadap tugas dengan dikondisikan pada bobot pra-terlatih yang dibekukan. PEANuT menyediakan cara yang fleksibel namun efisien untuk menangkap pola pembaruan yang kompleks tanpa penyetelan model penuh. Kami menunjukkan secara teoretis bahwa PEANuT mencapai ekspresivitas yang setara atau lebih besar daripada metode PEFT linear yang ada dengan jumlah parameter yang sebanding atau lebih sedikit. Eksperimen ekstensif di empat benchmark dengan lebih dari dua puluh dataset menunjukkan bahwa PEANuT secara konsisten melampaui baseline yang kuat dalam tugas NLP dan visi, sambil mempertahankan overhead komputasi yang rendah.

Ikhtisar benchmark

API

PeanutConfig

kelas peft.PeanutConfig

< >

( 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 = 32depth: int = 0act_fn: str = 'relu'scaling: 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 PEANuT. Ini adalah dimensi tersembunyi yang digunakan oleh adapter. Mirip dengan rank LoRA, nilai r yang lebih besar meningkatkan kapasitas adapter dan parameter yang dapat dilatih.
  • depth (int) β€” Jumlah lapisan adapter tersembunyi per sisi encoder/decoder dalam PEANuT. Proyeksi input A dan proyeksi output B selalu ada di samping lapisan tersembunyi ini. Oleh karena itu, depth harus berupa bilangan bulat non-negatif.
    • depth=0: A, B.
    • depth=1: A, satu encoder, satu decoder, B.
    • depth=2: A, dua encoder, dua decoder, B.
    • depth=3: A, tiga encoder, tiga decoder, B, dan seterusnya.
  • act_fn (str) β€” Aktivasi non-linear yang diterapkan dalam jaringan PEANuT. Ini sesuai dengan non_linear dalam implementasi PyTorch vanilla. Default adalah "relu". Setiap kunci aktivasi yang tersedia di transformers.activations.ACT2FN didukung dan mungkin memberikan performa yang lebih baik pada tugas yang berbeda.
  • scaling (float) β€” Penggali skalar yang diterapkan pada output PEANuT sebelum ditambahkan ke output lapisan dasar yang dibekukan. Kontribusi adapter akhir adalah scaling * (x @ delta_w).
  • target_modules (Union[List[str], str], opsional) β€” Nama-nama modul yang akan diterapkan PEANuT. Bisa berupa daftar string nama modul (mis. ['q_proj', 'v_proj']) atau pola regex.
  • modules_to_save (List[str], opsional) β€” Daftar modul di luar lapisan PEANuT yang akan diset sebagai trainable dan disimpan dalam checkpoint akhir.
  • 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 ditentukan 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 bukan None dan jika pola layer tersebut tidak ada dalam pola layer umum.
  • init_weights (bool) β€” Apakah akan menginisialisasi bobot adapter PEANuT menggunakan skema inisialisasi bawaan:
    • Jika True: semua bobot kecuali B diinisialisasi dengan Kaiming uniform, dan B diinisialisasi ke nol.
    • Jika False: semua bobot (termasuk B) diinisialisasi dengan Kaiming uniform.

    Menginisialisasi B ke nol membuat adapter dimulai sebagai no-op yang persis.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari PeanutModel.

Catatan: PEANuT menggunakan jalur yang mempertimbangkan bobot, di mana bobot delta dikondisikan pada bobot dasar. Adapter A diterapkan pada dimensi output dari bobot dasar, sehingga A memiliki bentuk (out_dim -> r) alih-alih (in_dim -> r) yang biasa digunakan oleh metode serupa LoRA.

PeanutModel

kelas peft.PeanutModel

< >

( 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 (PeanutConfig) β€” Konfigurasi model PEANuT.
  • adapter_name (str) β€” Nama adapter, secara default "default".

Mengembalikan

torch.nn.Module

Model PEFT PEANuT.

Membuat model PEANuT dari model transformers yang telah dilatih sebelumnya.

Metode ini dijelaskan secara rinci di https://arxiv.org/abs/2410.01870.

Atribut:

Update on GitHub