PEFT

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).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

GLoRA

Generalized Low-Rank Adaptation (GLoRA) adalah metode PEFT yang menggeneralisasi LoRA dan pendekatan terkait. GLoRA menguraikan pembaruan menjadi jalur yang dapat dikonfigurasi (A, B, C, D, E), di mana setiap jalur dapat menggunakan parameterisasi low-rank, vektor, konstan, atau nonaktif tergantung pada jalurnya.

Setiap jalur mendukung salah satu dari empat mode parameterisasi. Mode-mode ini menyeimbangkan jumlah parameter dengan ekspresivitas (seberapa kaya pembaruan yang dapat dilakukan):

"lora": Dekomposisi rank rendah (seperti LoRA standar). Menggunakan r * (out + in) parameter dan dapat mengekspresikan koreksi rank-r. Paling ekspresif, paling banyak parameter.
"vector": Vektor tunggal (misalnya bentuk (out, 1)), yang disiarkan di seluruh matriks. Menggunakan O(out) parameter; hanya penskalaan atau pergeseran per kanal.
"constant": Skalar tunggal yang dibagikan di semua elemen. Menggunakan 1 parameter; paling tidak ekspresif di antara opsi yang dapat dilatih.
"none": Nol tanpa parameter yang dapat dilatih; menonaktifkan jalur tersebut sepenuhnya.

Tidak semua jalur menerima semua mode (misalnya, config_D_E tidak mendukung "lora"). Memilih "lora" pada lebih banyak jalur meningkatkan kapasitas dan parameter yang dapat dilatih; "vector", "constant", atau "none" mengurangi keduanya.

GLoRA sangat berguna untuk penelitian dan aplikasi lanjutan di mana Anda ingin bereksperimen dengan pola pembaruan terstruktur dan menggabungkan beberapa mekanisme adaptasi dalam satu lapisan.

Secara umum, GLoRA memodifikasi lapisan linear yang dibekukan dengan: $W_{\mathrm{eff}} = W_0 + W_0 \odot A + B$ $b_{\mathrm{eff}} = b_0 + b_0 \odot D + E + W_0 C$

di mana setiap jalur diparameterisasi secara independen.

GloraConfig

kelas peft.GloraConfig

< 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 = 8target_modules: list[str] | str | None = Nonebias: str = 'none'modules_to_save: list[str] | None = Noneconfig_A_B: typing.Literal['lora', 'vector', 'constant', 'none'] = 'lora'config_C: typing.Literal['lora', 'vector', 'none'] = 'lora'config_D_E: typing.Literal['vector', 'constant', 'none'] = 'constant'init_weights: bool = True )

Parameter

r (int) — Rank dari dekomposisi low-rank yang digunakan ketika config diatur ke lora.
target_modules (Optional[Union[List[str], str]]) — Nama-nama modul yang akan diterapkan Glora.
config_A_B (str) — Parameterisasi untuk matriks A dan B (korektif perkalian dan aditif bobot). Nilai yang valid: lora, vector, constant, none.
config_C (str) — Parameterisasi untuk matriks C (keterkaitan bobot-ke-bias: b += W0 @ C). Nilai yang valid: lora, vector, none.
config_D_E (str) — Parameterisasi untuk skalar D dan E (koreksi multiplikatif dan aditif bias). Tidak mendukung lora karena D dan E adalah vektor berukuran bias, bukan matriks. Nilai yang valid: vector, constant, none.
init_weights (bool) — Jika True (default), inisialisasi GLoRA sebagai no-op (nol). Jika False, gunakan inisialisasi kaiming agar adapter bukan no-op.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari GloraModel.

Glora memodifikasi lapisan linear beku W0 sebagai: W_eff = W0 + W0 * A + B dan b_eff = b0 + b0 * D + E + W0 @ C.

Setiap matriks (A, B, C, D, E) dapat diparameterisasi secara independen. Nilai config mengontrol berapa banyak parameter yang digunakan dan bentuk apa yang dapat mereka nyatakan:

lora: Dekomposisi rank-rendah Xd @ Xu dengan bentuk (out, r) dan (r, in). Menggunakan r * (out + in) parameter dan dapat mengekspresikan koreksi rank-r apa pun. Sama seperti LoRA standar.
vector: Vektor kolom tunggal dengan bentuk (out, 1), yang di-broadcast ke seluruh matriks. Menggunakan out parameter; hanya penskalaan atau pergeseran per kanal output.
constant: Skalar tunggal yang dibagikan di semua elemen. Menggunakan 1 parameter; paling terbatas.
none: Nol, tidak ada parameter yang dapat dilatih. Secara efektif menonaktifkan jalur ini.

Opsi Konfigurasi Utama

r: Rank yang digunakan ketika path dikonfigurasi sebagai "lora" (default: 8).
target_modules: Daftar atau regex nama modul yang akan diadaptasi (misalnya, ["q_proj", "v_proj"]).
config_A_B: Tipe path untuk A dan B (“lora”, “vector”, “constant”, “none”).
config_C: Tipe Path untuk C (“lora”, “vector”, “none”).
config_D_E: Tipe path untuk D dan E (“constant”, “vector”, “none”).
bias: Bias handling ("none", "all", or "glora_only").
init_weights: Jika True (default), GLoRA diinisialisasi sebagai no-op. Jika False, menggunakan inisialisasi kaiming.

Catatan:

config_D_E tidak mendukung "lora".
target_modules dapat diabaikan untuk tipe model yang didukung (pemetaan default PEFT digunakan).

GloraModel

kelas peft.GloraModel

< source >

( modelpeft_config: Union[PeftConfig, dict[str, PeftConfig]]adapter_name: strlow_cpu_mem_usage: bool = Falsestate_dict: Optional[dict[str, torch.Tensor]] = None )

Membuat model Generalized Low Rank Adapter (GLoRA) dari model transformers yang telah dilatih sebelumnya.

Membungkus model dasar dan menyuntikkan adapter GLoRA ke dalam modul yang ditentukan.
Mendukung beberapa adapter, penggantian adapter, penggabungan/pemisahan, dan inferensi batch campuran.
Gunakan set_adapter, merge_and_unload, dan metode terkait untuk manajemen adapter.

GloraLayer dan GloraLinear

kelas peft.tuners.glora.GloraLayer

< source >

( base_layer: nn.Module**kwargs )

kelas peft.tuners.glora.GloraLinear

< source >

( base_layer: nn.Moduleadapter_name: strconfig**kwargs )

Adapter GLoRA yang membungkus ~torch.nn.Linear padat base_layer.

GloraLayer adalah logika inti untuk adaptasi peringkat rendah yang digeneralisasi, mendukung beberapa adapter dan konfigurasi jalur yang fleksibel.
GloraLinear adalah pengganti langsung untuk nn.Linear dengan dukungan GLoRA.
GLoRA saat ini mendukung lapisan dasar torch.nn.Linear biasa.

Contoh Penggunaan

from transformers import AutoModelForCausalLM
from peft import GloraConfig, get_peft_model

model = AutoModelForCausalLM.from_pretrained("your-model-id")
glora_config = GloraConfig(
    r=8,
    target_modules=["q_proj", "v_proj"],
    config_A_B="lora",
    config_C="vector",
    config_D_E="constant",
    task_type="CAUSAL_LM",
)
model = get_peft_model(model, glora_config)
model.print_healthcheck()

# Switch adapters, merge, etc.
model.set_adapter("default")
model.merge_and_unload()

Catatan

GLoRA adalah himpunan bagian dari LoRA: mengatur semua jalur menjadi “lora” akan mengembalikan LoRA standar.
Anda dapat menggunakan tipe path yang berbeda untuk A/B/C/D/E untuk bereksperimen dengan strategi adaptasi baru.
GLoRA mendukung semua fitur manajemen adapter PEFT standar (tambah, hapus, ganti, gabung, dll).

Lihat Juga

Update on GitHub

←FRoD GraLoRA→