PEFT documentation

OFT

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

OFT

Controlling Text-to-Image Diffusion by Orthogonal Finetuning

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

< >

( 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. Nilai r yang lebih besar menghasilkan matriks pembaruan yang lebih jarang dengan parameter yang dapat dilatih lebih sedikit. Anda hanya dapat menentukan r atau oft_block_size, tetapi tidak keduanya secara bersamaan, karena r Γ— oft_block_size = dimensi lapisan. Untuk kesederhanaan, kami memungkinkan Anda menentukan r atau oft_block_size dan menyimpulkan yang lainnya. Nilai default diatur ke r = 0, pengguna disarankan untuk mengatur oft_block_size sebagai gantinya untuk kejelasan yang lebih baik.
  • oft_block_size (int) β€” Ukuran blok OFT di berbagai lapisan. Nilai oft_block_size yang lebih besar menghasilkan matriks pembaruan yang lebih padat dengan lebih banyak parameter yang dapat dilatih. Pilih oft_block_size agar dapat dibagi habis oleh dimensi input lapisan (in_features), misalnya 4, 8, 16. Anda hanya dapat menentukan salah satu dari r atau oft_block_size, tetapi tidak keduanya secara bersamaan, karena r Γ— oft_block_size = dimensi lapisan. Untuk kesederhanaan, kami memungkinkan Anda menentukan salah satu dari r atau oft_block_size dan menyimpulkan yang lainnya. Nilai default diatur ke oft_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 True untuk efisiensi yang lebih baik, tetapi kinerja mungkin sedikit lebih buruk karena kesalahan aproksimasi. Silakan uji kedua pengaturan (True dan False) sesuai kebutuhan Anda. Nilai default adalah False.
  • 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 jika layers_to_transform berbeda dari None. Ini harus menargetkan nn.ModuleList dari 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 jika coft diatur ke True.
  • block_share (bool) β€” Apakah parameter OFT akan dibagikan antar blok atau tidak. Secara default, ini adalah False.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari OFTModel.

check_kwargs

< >

( **kwargs )

Parameter

  • kwargs (argumen kata kunci tambahan, opsional) β€” Argumen kata kunci tambahan yang diteruskan ke inisialisasi kelas anak.

Periksa apakah kwargs valid untuk konfigurasi.

OFTModel

kelas peft.OFTModel

< >

( 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 to False) β€” 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.
Update on GitHub