LoRA

Ini bersifat eksperimental dan API dapat berubah di masa depan.

LoRA (Low-Rank Adaptation of Large Language Models) adalah teknik pelatihan yang populer dan ringan, yang secara signifikan mengurangi jumlah parameter yang dapat dilatih. Teknik ini bekerja dengan menyisipkan sejumlah kecil bobot baru ke dalam model, dan hanya bobot tersebut yang dilatih. Hal ini membuat pelatihan dengan LoRA jauh lebih cepat, hemat memori, dan menghasilkan bobot model yang lebih kecil (beberapa ratus MB), sehingga lebih mudah disimpan dan dibagikan. LoRA juga dapat dikombinasikan dengan teknik pelatihan lain seperti DreamBooth untuk mempercepat pelatihan.

LoRA sangat serbaguna dan didukung untuk DreamBooth, Kandinsky 2.2, Stable Diffusion XL, dan text-to-image.

Panduan ini akan membahas skrip train_text_to_image_lora.py untuk membantu Anda lebih mengenalnya, serta bagaimana Anda dapat menyesuaikannya untuk kebutuhan Anda sendiri.

Sebelum menjalankan skrip, pastikan Anda menginstal pustaka dari sumber:

git clone https://github.com/huggingface/diffusers
cd diffusers
pip install .

Navigasi ke folder contoh dengan skrip pelatihan dan instal dependensi yang diperlukan untuk skrip yang Anda gunakan:

cd examples/text_to_image
pip install -r requirements.txt

🤗 Accelerate adalah pustaka untuk membantu Anda melatih pada beberapa GPU/TPU atau dengan presisi campuran. Pustaka ini akan mengonfigurasi pengaturan pelatihan Anda secara otomatis berdasarkan perangkat keras dan lingkungan Anda. Lihat Tour singkat 🤗 Accelerate untuk mempelajari lebih lanjut.

Inisialisasi lingkungan 🤗 Accelerate:

accelerate config

Untuk menyiapkan lingkungan 🤗 Accelerate default tanpa memilih konfigurasi apa pun:

accelerate config default

Atau jika lingkungan Anda tidak mendukung shell interaktif, seperti notebook, Anda dapat menggunakan:

from accelerate.utils import write_basic_config

write_basic_config()

Terakhir, jika Anda ingin melatih model pada dataset Anda sendiri, lihat panduan Membuat dataset untuk pelatihan untuk mempelajari cara membuat dataset yang berfungsi dengan skrip pelatihan.

Bagian-bagian berikut menyoroti bagian dari skrip pelatihan yang penting untuk dipahami agar Anda dapat memodifikasinya, namun tidak membahas setiap aspek skrip secara detail. Jika Anda tertarik untuk mempelajari lebih lanjut, silakan membaca skrip tersebut dan beri tahu kami jika Anda memiliki pertanyaan atau kekhawatiran.

Parameter skrip

Skrip pelatihan memiliki banyak parameter untuk membantu Anda menyesuaikan eksekusi pelatihan Anda. Semua parameter dan deskripsinya dapat ditemukan di fungsi parse_args(). Nilai default disediakan untuk sebagian besar parameter yang bekerja cukup baik, tetapi Anda juga dapat mengatur nilai Anda sendiri dalam perintah pelatihan jika Anda mau.

Sebagai contoh, untuk meningkatkan jumlah epoch pelatihan:

accelerate launch train_text_to_image_lora.py \
  --num_train_epochs=150 \

Banyak parameter dasar dan penting dijelaskan dalam panduan pelatihan Text-to-image, sehingga panduan ini hanya berfokus pada parameter yang relevan dengan LoRA:

• --rank: dimensi dalam dari matriks ber-rank rendah yang dilatih; rank yang lebih tinggi berarti lebih banyak parameter yang dapat dilatih
• --learning_rate: learning rate default adalah 1e-4, tetapi dengan LoRA, Anda dapat menggunakan learning rate yang lebih tinggi

Skrip pelatihan

Kode pra-pemrosesan dataset dan loop pelatihan dapat ditemukan di fungsi main(), dan jika Anda perlu menyesuaikan skrip pelatihan, di sinilah Anda akan melakukan perubahan.

Sama seperti parameter skrip, penjelasan langkah demi langkah dari skrip pelatihan tersedia di panduan pelatihan Text-to-image. Sebagai gantinya, panduan ini membahas bagian-bagian skrip yang relevan dengan LoRA.

unet_lora_config = LoraConfig(
    r=args.rank,
    lora_alpha=args.rank,
    init_lora_weights="gaussian",
    target_modules=["to_k", "to_q", "to_v", "to_out.0"],
)

unet.add_adapter(unet_lora_config)
lora_layers = filter(lambda p: p.requires_grad, unet.parameters())

text_lora_config = LoraConfig(
    r=args.rank,
    lora_alpha=args.rank,
    init_lora_weights="gaussian",
    target_modules=["q_proj", "k_proj", "v_proj", "out_proj"],
)

text_encoder_one.add_adapter(text_lora_config)
text_encoder_two.add_adapter(text_lora_config)
text_lora_parameters_one = list(filter(lambda p: p.requires_grad, text_encoder_one.parameters()))
text_lora_parameters_two = list(filter(lambda p: p.requires_grad, text_encoder_two.parameters()))

Optimizer diinisialisasi dengan lora_layers karena ini adalah satu-satunya bobot yang akan dioptimalkan:

optimizer = optimizer_cls(
    lora_layers,
    lr=args.learning_rate,
    betas=(args.adam_beta1, args.adam_beta2),
    weight_decay=args.adam_weight_decay,
    eps=args.adam_epsilon,
)

Selain mengatur lapisan LoRA, skrip pelatihan lebih atau kurang sama dengan train_text_to_image.py!

Jalankan skrip

Setelah Anda melakukan semua perubahan atau merasa puas dengan konfigurasi default, Anda siap untuk menjalankan skrip pelatihan! 🚀

Mari kita latih pada dataset Naruto BLIP captions untuk menghasilkan karakter Naruto Anda sendiri. Atur variabel lingkungan MODEL_NAME dan DATASET_NAME ke model dan dataset masing-masing. Anda juga harus menentukan di mana model disimpan dalam OUTPUT_DIR, dan nama model yang akan disimpan di Hub dengan HUB_MODEL_ID. Skrip ini membuat dan menyimpan file-file berikut ke repositori Anda:

• checkpoint model yang disimpan
• pytorch_lora_weights.safetensors (bobot LoRA yang telah dilatih)

Jika Anda melatih pada lebih dari satu GPU, tambahkan parameter --multi_gpu ke perintah accelerate launch.

Satu siklus pelatihan penuh membutuhkan waktu sekitar 5 jam pada GPU 2080 Ti dengan VRAM 11GB.

export MODEL_NAME="stable-diffusion-v1-5/stable-diffusion-v1-5"
export OUTPUT_DIR="/sddata/finetune/lora/naruto"
export HUB_MODEL_ID="naruto-lora"
export DATASET_NAME="lambdalabs/naruto-blip-captions"

accelerate launch --mixed_precision="fp16"  train_text_to_image_lora.py \
  --pretrained_model_name_or_path=$MODEL_NAME \
  --dataset_name=$DATASET_NAME \
  --dataloader_num_workers=8 \
  --resolution=512 \
  --center_crop \
  --random_flip \
  --train_batch_size=1 \
  --gradient_accumulation_steps=4 \
  --max_train_steps=15000 \
  --learning_rate=1e-04 \
  --max_grad_norm=1 \
  --lr_scheduler="cosine" \
  --lr_warmup_steps=0 \
  --output_dir=${OUTPUT_DIR} \
  --push_to_hub \
  --hub_model_id=${HUB_MODEL_ID} \
  --report_to=wandb \
  --checkpointing_steps=500 \
  --validation_prompt="A naruto with blue eyes." \
  --seed=1337

Setelah pelatihan selesai, Anda dapat menggunakan model Anda untuk inferensi:

from diffusers import AutoPipelineForText2Image
import torch

pipeline = AutoPipelineForText2Image.from_pretrained("stable-diffusion-v1-5/stable-diffusion-v1-5", dtype=torch.float16).to("cuda")  # or "mps", "xpu", "cpu"
pipeline.load_lora_weights("path/to/lora/model", weight_name="pytorch_lora_weights.safetensors")
image = pipeline("A naruto with blue eyes").images[0]

Langkah selanjutnya

Selamat karena Anda telah melatih model baru dengan LoRA! Untuk mempelajari lebih lanjut tentang cara menggunakan model baru Anda, panduan berikut mungkin dapat membantu:

• Pelajari cara memuat format LoRA yang berbeda yang dilatih menggunakan trainer komunitas seperti Kohya dan TheLastBen.
• Pelajari cara menggunakan dan menggabungkan beberapa LoRA dengan PEFT untuk inferensi.