PEFT documentation

IA3

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

IA3

IA3 adalah pilihan yang sangat baik ketika Anda membutuhkan ukuran adapter yang sekecil mungkin β€” metode ini menggunakan vektor yang dipelajari alih-alih matriks ber-rank rendah, menjadikannya salah satu metode yang paling efisien dalam hal parameter. Jika prioritas Anda adalah jejak disk/ memori yang minimal dan pelatihan yang cepat, IA3 adalah kandidat yang kuat.

IA3 introduces three vectors, lv, lk and lff to scale value, key and feed-forward activations (image source).

Infused Adapter dengan Menghambat dan Memperkuat Aktivasi Internal, atau IA3, adalah metode yang menambahkan tiga vektor yang dipelajari untuk menskalakan ulang kunci dan nilai pada lapisan self-attention dan encoder-decoder attention, serta aktivasi perantara pada jaringan feed-forward per posisi.

Abstrak dari makalah tersebut adalah:

Pembelajaran kontekstual beberapa contoh (few-shot in-context learning/ICL) memungkinkan model bahasa pra-terlatih untuk menjalankan tugas yang belum pernah dilihat sebelumnya tanpa pelatihan berbasis gradien, dengan memberikan sejumlah kecil contoh pelatihan sebagai bagian dari input. ICL menimbulkan biaya komputasi, memori, dan penyimpanan yang besar karena melibatkan pemrosesan semua contoh pelatihan setiap kali prediksi dilakukan. Penyesuaian halus yang efisien secara parameter (parameter-efficient fine-tuning/PEFT) (misalnya modul adapter, prompt tuning, metode pembaruan jarang, dll.) menawarkan paradigma alternatif di mana sejumlah kecil parameter dilatih untuk memungkinkan model menjalankan tugas baru. Dalam makalah ini, kami membandingkan secara ketat few-shot ICL dan PEFT, serta menunjukkan bahwa yang terakhir menawarkan akurasi yang lebih baik serta biaya komputasi yang jauh lebih rendah. Di sepanjang prosesnya, kami memperkenalkan metode PEFT baru yang disebut (IA)^3 yang menskalakan aktivasi dengan vektor yang dipelajari, mencapai kinerja yang lebih kuat sambil hanya memperkenalkan sejumlah kecil parameter baru. Kami juga mengusulkan resep sederhana berdasarkan model T0 yang disebut T-Few, yang dapat diterapkan pada tugas baru tanpa penyetelan atau modifikasi yang spesifik untuk tugas tersebut. Kami memvalidasi efektivitas T-Few pada tugas yang benar-benar belum pernah dilihat dengan menerapkannya pada benchmark RAFT, mencapai kinerja super-untuk pertama kalinya dan melampaui state-of-the-art sebesar 6% absolut. Semua kode yang digunakan dalam eksperimen kami tersedia secara publik.

Untuk membuat fine-tuning lebih efisien, IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations) menyeskalakan ulang aktivasi internal dengan vektor yang dipelajari. Vektor-vektor yang dipelajari ini disuntikkan ke dalam modul attention dan feedforward pada arsitektur berbasis transformer yang umum. Vektor-vektor yang dipelajari ini adalah satu-satunya parameter yang dapat dilatih selama fine-tuning, sehingga bobot asli tetap dibekukan. Menangani vektor yang dipelajari (sebagai lawan dari pembaruan peringkat rendah yang dipelajari pada matriks bobot seperti LoRA) menjaga jumlah parameter yang dapat dilatih tetap jauh lebih kecil.

Karena mirip dengan LoRA, IA3 memiliki banyak keuntungan yang sama:

  • IA3 membuat fine-tuning lebih efisien dengan mengurangi jumlah parameter yang dapat dilatih secara drastis. (Untuk T0, model IA3 hanya memiliki sekitar 0,01% parameter yang dapat dilatih, sementara bahkan LoRA memiliki > 0,1%)
  • Bobot pra-terlatih asli tetap dibekukan, yang berarti Anda dapat memiliki beberapa model IA3 yang ringan dan portabel untuk berbagai tugas turunan yang dibangun di atasnya.
  • Kinerja model yang disempurnakan menggunakan IA3 sebanding dengan kinerja model yang disempurnakan secara penuh.
  • IA3 tidak menambah latensi inferensi karena bobot adapter dapat digabungkan dengan model dasar.

Secara prinsip, IA3 dapat diterapkan pada subset matriks bobot mana pun dalam jaringan saraf untuk mengurangi jumlah parameter yang dapat dilatih. Mengikuti implementasi para penulis, bobot IA3 ditambahkan ke lapisan kunci, nilai, dan feedforward dari model Transformer. Secara spesifik, untuk model transformer, bobot IA3 ditambahkan ke output dari lapisan kunci dan nilai, serta ke input dari lapisan feedforward kedua di setiap blok transformer.

Berdasarkan lapisan target untuk menyuntikkan parameter IA3, jumlah parameter yang dapat dilatih dapat ditentukan berdasarkan ukuran matriks bobot.

Penggunaan

Untuk model autoregresif, targetkan k_proj, v_proj, dan down_proj β€” ini adalah lapisan yang menurut para penulis paling efektif. Atur feedforward_modules=["down_proj"] agar IA3 mengetahui modul mana yang merupakan lapisan feedforward dan dapat menerapkan penskalaan yang benar.

Untuk tugas klasifikasi urutan, seseorang dapat menginisialisasi konfigurasi IA3 untuk model Llama sebagai berikut:

from peft import IA3Config, TaskType, get_peft_model
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("HuggingFaceTB/SmolLM-135M")
peft_config = IA3Config(
    task_type=TaskType.CAUSAL_LM,
    target_modules=["k_proj", "v_proj", "down_proj"],
    feedforward_modules=["down_proj"],
)
model = get_peft_model(model, peft_config)
model.print_healthcheck()

Kapan menggunakan IA3 vs LoRA

IA3 sangat efektif ketika Anda membutuhkan adapter dengan ukuran sekecil mungkin untuk deployment dengan keterbatasan penyimpanan, atau ketika Anda menginginkan konvergensi yang cepat dengan jumlah parameter yang dapat dilatih lebih sedikit. LoRA mungkin lebih disukai ketika Anda membutuhkan ekosistem yang lebih luas dari varian LoRA (DoRA, QLoRA, dll.) atau menginginkan pendekatan yang paling banyak diuji dengan dukungan komunitas yang luas.

Ikhtisar benchmark

API

IA3Config

kelas peft.IA3Config

< >

( 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 = Falsetarget_modules: Optional[Union[list[str], str]] = Noneexclude_modules: Optional[Union[list[str], str]] = Nonefeedforward_modules: Optional[Union[list[str], str]] = Nonefan_in_fan_out: bool = Falsemodules_to_save: Optional[list[str]] = Noneinit_ia3_weights: bool = True )

Parameter

  • target_modules (Optional[Union[List[str], str]]) β€” Nama-nama modul yang akan diterapkan adapter-nya. Jika ini ditentukan, hanya modul dengan nama yang ditentukan yang akan diganti. Saat meneruskan string, pencocokan regex akan dilakukan. Saat meneruskan daftar string, pencocokan persis akan dilakukan atau diperiksa apakah nama modul diakhiri dengan salah satu string yang diteruskan. Jika ini ditentukan sebagai β€˜all-linear’, maka semua modul linear/Conv1D akan dipilih, kecuali lapisan output. Jika ini tidak ditentukan, modul akan dipilih sesuai dengan arsitektur model. Jika arsitekturnya tidak diketahui, error akan dilempar β€” dalam hal ini, Anda harus menentukan modul target secara manual.
  • exclude_modules (Optional[Union[List[str], str]]) β€” 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 berakhiran dengan salah satu string yang dilewatkan.
  • feedforward_modules (Optional[Union[List[str], str]]) β€” Nama-nama modul yang akan diperlakukan sebagai modul feedforward, sebagaimana dalam paper aslinya. Modul-modul ini akan memiliki vektor (IA)Β³ yang dikalikan ke input, bukan ke output. feedforward_modules harus berupa nama atau subset dari nama-nama yang ada di target_modules.
  • fan_in_fan_out (bool) β€” Atur ini ke True jika layer yang akan diganti menyimpan bobot seperti (fan_in, fan_out). Misalnya, gpt-2 menggunakan Conv1D yang menyimpan bobot seperti (fan_in, fan_out) sehingga ini harus diatur ke True.
  • modules_to_save (Optional[List[str]]) β€” Daftar modul di luar lapisan (IA)Β³ yang akan diset sebagai trainable dan disimpan dalam checkpoint akhir.
  • init_ia3_weights (bool) β€” Apakah akan menginisialisasi vektor pada lapisan (IA)Β³, secara default True. Mengatur ini ke False tidak disarankan.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari IA3Model.

IA3Model

kelas peft.IA3Model

< >

( 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 (PreTrainedModel) β€” Model yang akan diadaptasi.
  • config (IA3Config) β€” Konfigurasi model (IA)^3.
  • adapter_name (str) β€” Nama adapter, secara default "default".
  • low_cpu_mem_usage (bool, optional, defaults to False) β€” Membuat bobot adapter kosong pada perangkat meta. Berguna untuk mempercepat proses pemuatan.

Mengembalikan

torch.nn.Module

Model (IA)^3.

Membuat model Infused Adapter by Inhibiting and Amplifying Inner Activations ((IA)^3) dari model transformers yang telah dilatih sebelumnya. Metode ini dijelaskan secara rinci di https://huggingface.co/papers/2205.05638

Contoh:

>>> from transformers import AutoModelForSeq2SeqLM
>>> from peft import IA3Config, get_peft_model

>>> config = IA3Config(
...     peft_type="IA3",
...     task_type="SEQ_2_SEQ_LM",
...     target_modules=["k", "v", "w0"],
...     feedforward_modules=["w0"],
... )

>>> model = AutoModelForSeq2SeqLM.from_pretrained("t5-base")
>>> ia3_model = get_peft_model(model, config)

Atribut:

add_weighted_adapter

< >

( adapters: list[str]weights: list[float]adapter_name: str )

Parameter

  • adapters (list) β€” Daftar nama adapter yang akan digabungkan.
  • weights (list) β€” Daftar bobot untuk setiap adapter.
  • adapter_name (str) β€” Nama adapter baru.

Metode ini menambahkan adapter baru dengan menggabungkan adapter yang diberikan dengan bobot yang diberikan.

Update on GitHub