PEFT documentation
OFT
OFT

Orthogonal Finetuning (OFT) dan OFTv2 adalah metode yang dikembangkan untuk mengadaptasi model difusi teks-ke-gambar. Metode ini bekerja dengan mereparameterisasi matriks bobot pralatih menggunakan matriks ortogonalnya untuk mempertahankan informasi dalam model pralatih. Untuk mengurangi jumlah parameter, OFT memperkenalkan struktur blok-diagonal pada matriks ortogonal. Metode ini terutama berfokus pada mempertahankan kinerja generatif model pralatih dalam model yang telah di-finetune. Metode ini berusaha mempertahankan kemiripan kosinus (hyperspherical energy) yang sama di antara semua pasangan neuron dalam suatu lapisan karena hal ini lebih baik dalam menangkap informasi semantik di antara neuron. Artinya, OFT lebih mampu mempertahankan subjek dan lebih baik untuk generasi yang dapat dikendalikan (mirip dengan ControlNet).
Abstrak dari makalah tersebut adalah:
Model difusi teks-ke-gambar berskala besar memiliki kemampuan yang mengesankan dalam menghasilkan gambar fotorealistis dari prompt teks. Bagaimana cara efektif mengarahkan atau mengendalikan model-model yang kuat ini untuk menjalankan tugas turunan yang berbeda menjadi masalah terbuka yang penting. Untuk mengatasi tantangan ini, kami memperkenalkan metode penyesuaian halus (finetuning) yang berprinsip β Orthogonal Finetuning (OFT), untuk mengadaptasi model difusi teks-ke-gambar ke tugas turunan. Berbeda dengan metode yang ada, OFT dapat secara terbukti mempertahankan energi hipersferis yang mengkarakterisasi hubungan neuron berpasangan pada hipersfera satuan. Kami menemukan bahwa properti ini sangat penting untuk mempertahankan kemampuan generasi semantik model difusi teks-ke-gambar. Untuk meningkatkan stabilitas penyesuaian halus, kami selanjutnya mengusulkan Constrained Orthogonal Finetuning (COFT) yang memberlakukan kendala radius tambahan pada hipersfera. Secara spesifik, kami mempertimbangkan dua tugas penyesuaian halus teks-ke-gambar yang penting: generasi yang digerakkan oleh subjek, di mana tujuannya adalah menghasilkan gambar spesifik subjek yang diberikan beberapa gambar dari sebuah subjek dan prompt teks, serta generasi yang dapat dikendalikan, di mana tujuannya adalah memungkinkan model untuk menerima sinyal kontrol tambahan. Kami menunjukkan secara empiris bahwa kerangka kerja OFT kami melampaui metode yang ada dalam hal kualitas generasi dan kecepatan konvergensi.
OFT mempertahankan energi hipersferis dengan mempelajari transformasi ortogonal untuk neuron agar kemiripan kosinus di antara mereka tetap tidak berubah, yang berpotensi mengurangi pelupaan pengetahuan yang telah dipelajari sebelumnya. Dalam praktiknya, ini berarti mengambil hasil perkalian matriks dari matriks ortogonal dengan matriks bobot pralatih. Namun, agar efisien secara parameter, matriks ortogonal tersebut direpresentasikan sebagai matriks blok-diagonal dengan blok ber-rangking r. Sementara LoRA mengurangi jumlah parameter yang dapat dilatih dengan struktur ber-rangking rendah, OFT mengurangi jumlah parameter yang dapat dilatih dengan struktur matriks blok-diagonal yang jarang.
Ikhtisar benchmark
Menggabungkan bobot OFT ke dalam model dasar
Mirip dengan LoRA, bobot yang dipelajari oleh OFT dapat diintegrasikan ke dalam matriks bobot pralatih menggunakan fungsi [~OFTModel.merge_and_unload(). Fungsi ini menggabungkan bobot adapter dengan model dasar, yang memungkinkan Anda menggunakan model gabungan baru secara efektif sebagai model mandiri.
Contoh Penggunaan OFT
Untuk menggunakan OFT untuk finetuning kuantisasi dengan TRL untuk SFT, PPO, atau DPO fine-tuning, ikuti kerangka berikut:
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
from trl import SFTTrainer
from peft import OFTConfig
if use_quantization:
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_storage=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
"model_name",
quantization_config=bnb_config
)
tokenizer = AutoTokenizer.from_pretrained("model_name")
# Configure OFT
peft_config = OFTConfig(
oft_block_size=32,
use_cayley_neumann=True,
target_modules="all-linear",
bias="none",
task_type="CAUSAL_LM"
)
trainer = SFTTrainer(
model=model,
train_dataset=ds['train'],
peft_config=peft_config,
processing_class=tokenizer,
args=training_arguments,
data_collator=collator,
)
trainer.train()API
OFTConfig
kelas peft.OFTConfig
< 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 = 0oft_block_size: int = 32module_dropout: float = 0.0target_modules: Optional[Union[list[str], str]] = Nonefan_in_fan_out: bool = Falsebias: Literal['none', 'all', 'oft_only'] = 'none'exclude_modules: Optional[Union[list[str], str]] = Noneinit_weights: bool = Truelayers_to_transform: Optional[Union[list[int], int]] = Nonelayers_pattern: Optional[Union[list[str], str]] = Nonemodules_to_save: Optional[list[str]] = Nonecoft: bool = Falseeps: float = 6e-05block_share: bool = Falseuse_cayley_neumann: bool = Truenum_cayley_neumann_terms: int = 5 )
Parameter
- r (
int) β Rank OFT, jumlah blok OFT per lapisan yang disuntikkan. Nilairyang lebih besar menghasilkan matriks pembaruan yang lebih jarang dengan parameter yang dapat dilatih lebih sedikit. Anda hanya dapat menentukanratauoft_block_size, tetapi tidak keduanya secara bersamaan, karenarΓoft_block_size= dimensi lapisan. Untuk kesederhanaan, kami memungkinkan Anda menentukanratauoft_block_sizedan menyimpulkan yang lainnya. Nilai default diatur ker = 0, pengguna disarankan untuk mengaturoft_block_sizesebagai gantinya untuk kejelasan yang lebih baik. - oft_block_size (
int) β Ukuran blok OFT di berbagai lapisan. Nilaioft_block_sizeyang lebih besar menghasilkan matriks pembaruan yang lebih padat dengan lebih banyak parameter yang dapat dilatih. Pilihoft_block_sizeagar dapat dibagi habis oleh dimensi input lapisan (in_features), misalnya 4, 8, 16. Anda hanya dapat menentukan salah satu dariratauoft_block_size, tetapi tidak keduanya secara bersamaan, karenarΓoft_block_size= dimensi lapisan. Untuk kesederhanaan, kami memungkinkan Anda menentukan salah satu dariratauoft_block_sizedan menyimpulkan yang lainnya. Nilai default diatur keoft_block_size = 32. - use_cayley_neumann (bool) β Menentukan apakah akan menggunakan parameterisasi Cayley-Neumann (efisien tetapi
aproksimatif) atau parameterisasi Cayley biasa (eksak tetapi mahal secara komputasi karena invers matriks).
Kami merekomendasikan untuk mengaturnya ke
Trueuntuk efisiensi yang lebih baik, tetapi kinerja mungkin sedikit lebih buruk karena kesalahan aproksimasi. Silakan uji kedua pengaturan (TruedanFalse) sesuai kebutuhan Anda. Nilai default adalahFalse. - module_dropout (
float) β Probabilitas dropout multiplikatif, dengan mengatur blok OFT menjadi identitas selama pelatihan, serupa dengan lapisan dropout dalam LoRA. - 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 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. - fan_in_fan_out (
bool) β Setel ini ke True jika layer yang akan diganti menyimpan bobot seperti (fan_in, fan_out). - bias (
str) — Bias type for OFT. Can be ‘none’, ‘all’ or ‘oft_only’. If ‘all’ or ‘oft_only’, the corresponding biases will be updated during training. Be aware that this means that, even when disabling the adapters, the model will not produce the same output as the base model would have without adaptation. - 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. - init_weights (
bool) β Apakah akan melakukan inisialisasi bobot OFT. - layers_to_transform (
Union[List[int], int]) β Indeks layer yang akan ditransformasi. Jika daftar int yang dilewatkan, adapter akan diterapkan pada indeks layer yang ditentukan dalam daftar ini. Jika satu integer yang dilewatkan, transformasi akan diterapkan pada layer di indeks ini. - layers_pattern (
Optional[Union[List[str], str]]) β Nama pola layer, hanya digunakan jikalayers_to_transformberbeda dariNone. Ini harus menargetkannn.ModuleListdari model, yang sering disebut'layers'atau'h'. - modules_to_save (
List[str]) β Daftar modul selain lapisan adapter yang akan diatur sebagai dapat dilatih dan disimpan dalam checkpoint akhir. - coft (
bool) β Apakah akan menggunakan varian OFT yang terkonstrain atau tidak, secara default nonaktif. - eps (
float) β Kekuatan kontrol COFT. Kebebasan rotasi. Hanya berpengaruh jikacoftdiatur ke True. - block_share (
bool) β Apakah parameter OFT akan dibagikan antar blok atau tidak. Secara default, ini adalahFalse.
Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari OFTModel.
check_kwargs
< source >( **kwargs )
Periksa apakah kwargs valid untuk konfigurasi.
OFTModel
kelas peft.OFTModel
< source >( 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 tempat lapisan tuner adapter akan dilampirkan. - config (OFTConfig) β Konfigurasi model OFT.
- adapter_name (
str) β Nama adapter, secara default"default". - low_cpu_mem_usage (
bool,optional, defaults toFalse) β Membuat bobot adapter kosong pada perangkat meta. Berguna untuk mempercepat proses pemuatan.
Mengembalikan
torch.nn.Module
Model OFT.
Membuat model Orthogonal Finetuning dari model pretrained. Metode ini dijelaskan di https://huggingface.co/papers/2306.07280
Contoh:
>>> from diffusers import StableDiffusionPipeline
>>> from peft import OFTConfig, get_peft_model
>>> config_te = OFTConfig(
... oft_block_size=32,
... target_modules=["k_proj", "q_proj", "v_proj", "out_proj", "fc1", "fc2"],
... module_dropout=0.0,
... init_weights=True,
... )
>>> config_unet = OFTConfig(
... oft_block_size=32,
... target_modules=[
... "proj_in",
... "proj_out",
... "to_k",
... "to_q",
... "to_v",
... "to_out.0",
... "ff.net.0.proj",
... "ff.net.2",
... ],
... module_dropout=0.0,
... init_weights=True,
... )
>>> model = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
>>> model.text_encoder = get_peft_model(model.text_encoder, config_te)
>>> model.unet = get_peft_model(model.unet, config_unet)Atribut:
- model (
~torch.nn.Module) β Model yang akan diadaptasi. - peft_config (OFTConfig): Konfigurasi model OFT.