Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /id /training /dreambooth.md
mishig
8 days ago
preview code
download
raw
26.2 kB
# DreamBooth

[DreamBooth](https://huggingface.co/papers/2208.12242) adalah teknik pelatihan yang memperbarui seluruh model difusi dengan melatihnya hanya pada beberapa gambar subjek atau gaya. Cara kerjanya adalah dengan mengaitkan kata khusus dalam prompt dengan gambar-gambar contoh tersebut.

Untuk memuat checkpoint yang telah dilatih untuk inferensi, lihat [Memuat model DreamBooth untuk inferensi](../using-diffusers/dreambooth).

Jika Anda melatih pada GPU dengan vRAM terbatas, Anda sebaiknya mencoba mengaktifkan parameter `gradient_checkpointing` dan `mixed_precision` dalam perintah pelatihan. Anda juga dapat mengurangi jejak memori dengan menggunakan perhatian yang hemat memori dengan [xFormers](../optimization/attention_backends).

Panduan ini akan membahas skrip [train_dreambooth.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py) untuk membantu Anda lebih mengenalnya, serta bagaimana Anda dapat menyesuaikannya untuk kebutuhan Anda sendiri.

Sebelum menjalankan skrip, pastikan Anda menginstal pustaka dari sumber:

```bash
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:

```bash
cd examples/dreambooth
pip install -r requirements.txt
```

> [!TIP]
> 🤗 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](https://huggingface.co/docs/accelerate/quicktour) 🤗 Accelerate untuk mempelajari lebih lanjut.

Inisialisasi lingkungan 🤗 Accelerate:

```bash
accelerate config
```

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

```bash
accelerate config default
```

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

```py
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](create_dataset) untuk mempelajari cara membuat dataset yang berfungsi dengan skrip pelatihan.

> [!TIP]
> 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](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py) tersebut dan beri tahu kami jika Anda memiliki pertanyaan atau kekhawatiran.

## Parameter skrip

> [!WARNING]
> DreamBooth sangat sensitif terhadap hiperparameter pelatihan, dan mudah mengalami overfitting. Baca artikel blog [Training Stable Diffusion with Dreambooth using 🧨 Diffusers](https://huggingface.co/blog/dreambooth) untuk pengaturan yang direkomendasikan untuk berbagai subjek agar Anda dapat memilih hiperparameter yang tepat.

Skrip pelatihan menawarkan banyak parameter untuk menyesuaikan eksekusi pelatihan Anda. Semua parameter beserta deskripsinya dapat ditemukan di fungsi [`parse_args()`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L228). Parameter diatur dengan nilai default yang seharusnya berfungsi cukup baik secara bawaan, tetapi Anda juga dapat mengatur nilai Anda sendiri dalam perintah pelatihan jika Anda mau.

Sebagai contoh, untuk melatih dalam format bf16:

```bash
accelerate launch train_dreambooth.py \
    --mixed_precision="bf16"
```

Beberapa parameter dasar dan penting yang perlu diketahui dan ditentukan adalah:

- `--pretrained_model_name_or_path`: nama model di Hub atau jalur lokal ke model pretrained
- `--instance_data_dir`: path ke folder yang berisi dataset pelatihan (contoh gambar)
- `--instance_prompt`: prompt teks yang berisi kata khusus untuk gambar contoh
- `--train_text_encoder`: apakah text encoder juga akan dilatih
- `--output_dir`: tempat menyimpan model yang telah dilatih
- `--push_to_hub`: apakah model yang dilatih akan didorong ke Hub
- `--checkpointing_steps`: frekuensi penyimpanan checkpoint saat model dilatih; ini berguna jika pelatihan terputus karena alasan tertentu, Anda dapat melanjutkan pelatihan dari checkpoint tersebut dengan menambahkan `--resume_from_checkpoint` ke perintah pelatihan Anda

### Penimbangan Min-SNR

Strategi penimbangan [Min-SNR](https://huggingface.co/papers/2303.09556) dapat membantu pelatihan dengan menyeimbangkan ulang loss untuk mencapai konvergensi yang lebih cepat. Skrip pelatihan mendukung prediksi `epsilon` (noise) atau `v_prediction`, tetapi Min-SNR kompatibel dengan kedua jenis prediksi tersebut. Strategi penimbangan ini hanya didukung oleh PyTorch.

Tambahkan parameter `--snr_gamma` dan atur nilainya ke nilai yang direkomendasikan, yaitu 5.0:

```bash
accelerate launch train_dreambooth.py \
  --snr_gamma=5.0
```

### Prior preservation loss

Prior preservation loss adalah metode yang menggunakan sampel yang dihasilkan oleh model itu sendiri untuk membantunya belajar cara menghasilkan gambar yang lebih beragam. Karena gambar sampel yang dihasilkan ini termasuk dalam kelas yang sama dengan gambar yang Anda berikan, mereka membantu model mempertahankan apa yang telah dipelajarinya tentang kelas tersebut dan bagaimana ia dapat menggunakan pengetahuan yang sudah dimilikinya tentang kelas tersebut untuk membuat komposisi baru.

- `--with_prior_preservation`: apakah akan menggunakan prior preservation loss
- `--prior_loss_weight`: mengontrol pengaruh prior preservation loss pada model
- `--class_data_dir`: path ke folder yang berisi gambar sampel kelas yang dihasilkan
- `--class_prompt`: prompt teks yang menjelaskan kelas dari gambar sampel yang dihasilkan

```bash
accelerate launch train_dreambooth.py \
  --with_prior_preservation \
  --prior_loss_weight=1.0 \
  --class_data_dir="path/to/class/images" \
  --class_prompt="text prompt describing class"
```

### Latih pengkode teks

Untuk meningkatkan kualitas output yang dihasilkan, Anda juga dapat melatih text encoder selain UNet. Hal ini memerlukan memori tambahan dan Anda membutuhkan GPU dengan vRAM minimal 24GB. Jika Anda memiliki perangkat keras yang diperlukan, melatih text encoder akan menghasilkan hasil yang lebih baik, terutama saat menghasilkan gambar wajah. Aktifkan opsi ini dengan:

```bash
accelerate launch train_dreambooth.py \
  --train_text_encoder
```

## Skrip pelatihan

DreamBooth dilengkapi dengan kelas dataset-nya sendiri:

- [`DreamBoothDataset`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L604): memproses pra gambar dan gambar kelas, serta melakukan tokenisasi prompt untuk pelatihan
- [`PromptDataset`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L738): menghasilkan prompt embeddings untuk menghasilkan gambar kelas

Jika Anda mengaktifkan [prior preservation loss](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L842), gambar kelas dihasilkan di sini:

```py
sample_dataset = PromptDataset(args.class_prompt, num_new_images)
sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size)
sample_dataloader = accelerator.prepare(sample_dataloader)
pipeline.to(accelerator.device)
for example in tqdm(
    sample_dataloader, desc="Generating class images", disable=not accelerator.is_local_main_process
):
    images = pipeline(example["prompt"]).images
```

Berikutnya adalah fungsi [`main()`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L799) yang menangani pengaturan dataset untuk pelatihan dan loop pelatihan itu sendiri. Skrip memuat [tokenizer](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L898), [scheduler dan model](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L912C1-L912C1):

```py
# Load the tokenizer
if args.tokenizer_name:
    tokenizer = AutoTokenizer.from_pretrained(args.tokenizer_name, revision=args.revision, use_fast=False)
elif args.pretrained_model_name_or_path:
    tokenizer = AutoTokenizer.from_pretrained(
        args.pretrained_model_name_or_path,
        subfolder="tokenizer",
        revision=args.revision,
        use_fast=False,
    )
# Load scheduler and models
noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler")
text_encoder = text_encoder_cls.from_pretrained(
    args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision
)
if model_has_vae(args):
    vae = AutoencoderKL.from_pretrained(
        args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision
    )
else:
    vae = None
unet = UNet2DConditionModel.from_pretrained(
    args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision
)
```

Lalu, saatnya untuk [membuat dataset pelatihan](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L1073) dan DataLoader dari `DreamBoothDataset`:

```py
train_dataset = DreamBoothDataset(
    instance_data_root=args.instance_data_dir,
    instance_prompt=args.instance_prompt,
    class_data_root=args.class_data_dir if args.with_prior_preservation else None,
    class_prompt=args.class_prompt,
    class_num=args.num_class_images,
    tokenizer=tokenizer,
    size=args.resolution,
    center_crop=args.center_crop,
    encoder_hidden_states=pre_computed_encoder_hidden_states,
    class_prompt_encoder_hidden_states=pre_computed_class_prompt_encoder_hidden_states,
    tokenizer_max_length=args.tokenizer_max_length,
)
train_dataloader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=args.train_batch_size,
    shuffle=True,
    collate_fn=lambda examples: collate_fn(examples, args.with_prior_preservation),
    num_workers=args.dataloader_num_workers,
)
```

Terakhir, [training loop](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L1151) menangani langkah-langkah tersisa seperti mengonversi gambar ke ruang laten, menambahkan noise ke input, memprediksi residual noise, dan menghitung loss.

Jika Anda ingin mempelajari lebih lanjut tentang cara kerja loop pelatihan, lihat tutorial [Memahami pipeline, model, dan scheduler](../using-diffusers/write_own_pipeline) yang menguraikan pola dasar dari proses denoising.

## Jalankan skrip

Anda sekarang siap untuk menjalankan skrip pelatihan! 🚀

Untuk panduan ini, Anda akan mengunduh beberapa gambar [anjing](https://huggingface.co/datasets/diffusers/dog-example) dan menyimpannya dalam sebuah direktori. Namun, ingatlah bahwa Anda dapat membuat dan menggunakan dataset Anda sendiri jika diinginkan (lihat panduan [Membuat dataset untuk pelatihan](create_dataset)).

```py
from huggingface_hub import snapshot_download
local_dir = "./dog"
snapshot_download(
    "diffusers/dog-example",
    local_dir=local_dir,
    repo_type="dataset",
    ignore_patterns=".gitattributes",
)
```

Setel variabel lingkungan `MODEL_NAME` ke id model di Hub atau path ke model lokal, `INSTANCE_DIR` ke path tempat Anda baru saja mengunduh gambar anjing, dan `OUTPUT_DIR` ke tempat Anda ingin menyimpan model. Anda akan menggunakan `sks` sebagai kata khusus untuk mengaitkan pelatihan.

Jika Anda tertarik untuk mengikuti proses pelatihan, Anda dapat menyimpan gambar yang dihasilkan secara berkala seiring berjalannya pelatihan. Tambahkan parameter berikut ke perintah pelatihan:

```bash
--validation_prompt="a photo of a sks dog"
--num_validation_images=4
--validation_steps=100
```

Satu hal lagi sebelum Anda menjalankan skrip! Tergantung pada GPU yang Anda miliki, Anda mungkin perlu mengaktifkan optimasi tertentu untuk melatih DreamBooth.

Pada GPU 16GB, Anda dapat menggunakan optimizer 8-bit dari bitsandbytes dan gradient checkpointing untuk membantu Anda melatih model DreamBooth. Instal bitsandbytes:

```py
pip install bitsandbytes
```

Lalu, tambahkan parameter berikut ke perintah pelatihan Anda:

```bash
accelerate launch train_dreambooth.py \
  --gradient_checkpointing \
  --use_8bit_adam \
```

Pada GPU 12GB, Anda akan memerlukan optimizer 8-bit bitsandbytes, gradient checkpointing, xFormers, dan mengatur gradien menjadi `None` alih-alih nol untuk mengurangi penggunaan memori Anda.

```bash
accelerate launch train_dreambooth.py \
  --use_8bit_adam \
  --gradient_checkpointing \
  --enable_xformers_memory_efficient_attention \
  --set_grads_to_none \
```

Pada GPU 8GB, Anda akan membutuhkan [DeepSpeed](https://www.deepspeed.ai/) untuk memindahkan sebagian tensor dari vRAM ke CPU atau NVME agar pelatihan dapat dilakukan dengan memori GPU yang lebih sedikit.

Jalankan perintah berikut untuk mengonfigurasi lingkungan 🤗 Accelerate Anda:

```bash
accelerate config
```

Selama konfigurasi, pastikan Anda ingin menggunakan DeepSpeed. Sekarang, seharusnya Anda dapat melatih model dengan vRAM di bawah 8GB dengan menggabungkan DeepSpeed stage 2, presisi campuran fp16, dan offloading parameter model serta state optimizer ke CPU. Kekurangannya adalah hal ini membutuhkan lebih banyak RAM sistem (~25 GB). Lihat [dokumentasi DeepSpeed](https://huggingface.co/docs/accelerate/usage_guides/deepspeed) untuk opsi konfigurasi lainnya.

Anda juga harus mengganti optimizer Adam default dengan versi Adam yang dioptimalkan oleh DeepSpeed, yaitu [`deepspeed.ops.adam.DeepSpeedCPUAdam`](https://deepspeed.readthedocs.io/en/latest/optimizers.html#adam-cpu), untuk mendapatkan peningkatan kecepatan yang signifikan. Mengaktifkan `DeepSpeedCPUAdam` memerlukan versi CUDA toolchain sistem Anda sama dengan versi yang diinstal bersama PyTorch.

Optimizer 8-bit dari bitsandbytes tampaknya belum kompatibel dengan DeepSpeed saat ini.

Itu saja! Anda tidak perlu menambahkan parameter tambahan apa pun ke perintah pelatihan Anda.

```bash
export MODEL_NAME="stable-diffusion-v1-5/stable-diffusion-v1-5"
export INSTANCE_DIR="./dog"
export OUTPUT_DIR="path_to_saved_model"
accelerate launch train_dreambooth.py \
  --pretrained_model_name_or_path=$MODEL_NAME  \
  --instance_data_dir=$INSTANCE_DIR \
  --output_dir=$OUTPUT_DIR \
  --instance_prompt="a photo of sks dog" \
  --resolution=512 \
  --train_batch_size=1 \
  --gradient_accumulation_steps=1 \
  --learning_rate=5e-6 \
  --lr_scheduler="constant" \
  --lr_warmup_steps=0 \
  --max_train_steps=400 \
  --push_to_hub
```

Setelah pelatihan selesai, Anda dapat menggunakan model yang baru dilatih untuk inferensi!

> [!TIP]
> Tidak sabar ingin mencoba model Anda untuk inferensi sebelum pelatihan selesai? 🤭 Pastikan Anda telah menginstal versi terbaru dari 🤗 Accelerate.
>
> ```py
> from diffusers import DiffusionPipeline, UNet2DConditionModel
> from transformers import CLIPTextModel
> import torch
>
> unet = UNet2DConditionModel.from_pretrained("path/to/model/checkpoint-100/unet")
>
> # if you have trained with `--args.train_text_encoder` make sure to also load the text encoder
> text_encoder = CLIPTextModel.from_pretrained("path/to/model/checkpoint-100/checkpoint-100/text_encoder")
>
> pipeline = DiffusionPipeline.from_pretrained(
>     "stable-diffusion-v1-5/stable-diffusion-v1-5", unet=unet, text_encoder=text_encoder, dtype=torch.float16,
> ).to("cuda")
>
> image = pipeline("A photo of sks dog in a bucket", num_inference_steps=50, guidance_scale=7.5).images[0]
> image.save("dog-bucket.png")
> ```

```py
from diffusers import DiffusionPipeline
import torch
pipeline = DiffusionPipeline.from_pretrained("path_to_saved_model", dtype=torch.float16, use_safetensors=True).to("cuda")  # or "mps", "xpu", "cpu"
image = pipeline("A photo of sks dog in a bucket", num_inference_steps=50, guidance_scale=7.5).images[0]
image.save("dog-bucket.png")
```

## LoRA

LoRA adalah teknik pelatihan untuk mengurangi secara signifikan jumlah parameter yang dapat dilatih. Akibatnya, pelatihan menjadi lebih cepat dan lebih mudah untuk menyimpan bobot yang dihasilkan karena ukurannya jauh lebih kecil (~100MB). Gunakan skrip [train_dreambooth_lora.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_lora.py) untuk melatih dengan LoRA.

Skrip pelatihan LoRA dibahas lebih detail dalam panduan [pelatihan LoRA](lora).

## Stable Diffusion XL

Stable Diffusion XL (SDXL) adalah model teks-ke-gambar yang kuat yang menghasilkan gambar resolusi tinggi, dan menambahkan text-encoder kedua ke arsitekturnya. Gunakan skrip [train_dreambooth_lora_sdxl.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_lora_sdxl.py) untuk melatih model SDXL dengan LoRA.

Skrip pelatihan SDXL dibahas lebih detail dalam panduan [pelatihan SDXL](sdxl).

## DeepFloyd IF

DeepFloyd IF adalah model difusi piksel kaskade dengan tiga tahap. Tahap pertama menghasilkan gambar dasar, dan tahap kedua serta ketiga secara bertahap memperbesar gambar dasar menjadi gambar resolusi tinggi 1024x1024. Gunakan skrip [train_dreambooth_lora.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_lora.py) atau [train_dreambooth.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py) untuk melatih model DeepFloyd IF dengan LoRA atau model penuh.

DeepFloyd IF menggunakan varians yang diprediksi, tetapi skrip pelatihan Diffusers menggunakan error yang diprediksi sehingga model DeepFloyd IF yang telah dilatih beralih ke jadwal varians tetap. Skrip pelatihan akan memperbarui konfigurasi scheduler dari model yang sepenuhnya terlatih untuk Anda. Namun, saat Anda memuat bobot LoRA yang disimpan, Anda juga harus memperbarui konfigurasi scheduler dari pipeline.

```py
from diffusers import DiffusionPipeline
pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-XL-v1.0", use_safetensors=True)
pipe.load_lora_weights("<lora weights path>")
# Update scheduler config to fixed variance schedule
pipe.scheduler = pipe.scheduler.__class__.from_config(pipe.scheduler.config, variance_type="fixed_small")
```

Model tahap 2 memerlukan gambar validasi tambahan untuk di-upscale. Anda dapat mengunduh dan menggunakan versi yang diperkecil dari gambar pelatihan untuk keperluan ini.

```py
from huggingface_hub import snapshot_download
local_dir = "./dog_downsized"
snapshot_download(
    "diffusers/dog-example-downsized",
    local_dir=local_dir,
    repo_type="dataset",
    ignore_patterns=".gitattributes",
)
```

Contoh kode di bawah ini memberikan gambaran singkat tentang cara melatih model DeepFloyd IF dengan kombinasi DreamBooth dan LoRA. Beberapa parameter penting yang perlu diperhatikan adalah:

* `--resolution=64`, resolusi yang jauh lebih kecil diperlukan karena DeepFloyd IF adalah model difusi piksel dan untuk bekerja pada piksel yang tidak dikompresi, gambar input harus lebih kecil
* `--pre_compute_text_embeddings`, hitung text embeddings terlebih dahulu untuk menghemat memori karena [T5Model](https://huggingface.co/docs/transformers/main/en/model_doc/t5#transformers.T5Model) dapat menggunakan banyak memori
* `--tokenizer_max_length=77`, Anda dapat menggunakan panjang teks default yang lebih panjang dengan T5 sebagai encoder teks, tetapi prosedur encoding model default menggunakan panjang teks yang lebih pendek
* `--text_encoder_use_attention_mask`, untuk meneruskan attention mask ke text encoder

Tahap pelatihan 1 dari DeepFloyd IF dengan LoRA dan DreamBooth membutuhkan sekitar 28GB memori.

```bash
export MODEL_NAME="DeepFloyd/IF-I-XL-v1.0"
export INSTANCE_DIR="dog"
export OUTPUT_DIR="dreambooth_dog_lora"
accelerate launch train_dreambooth_lora.py \
  --report_to wandb \
  --pretrained_model_name_or_path=$MODEL_NAME  \
  --instance_data_dir=$INSTANCE_DIR \
  --output_dir=$OUTPUT_DIR \
  --instance_prompt="a sks dog" \
  --resolution=64 \
  --train_batch_size=4 \
  --gradient_accumulation_steps=1 \
  --learning_rate=5e-6 \
  --scale_lr \
  --max_train_steps=1200 \
  --validation_prompt="a sks dog" \
  --validation_epochs=25 \
  --checkpointing_steps=100 \
  --pre_compute_text_embeddings \
  --tokenizer_max_length=77 \
  --text_encoder_use_attention_mask
```

Untuk tahap 2 dari DeepFloyd IF dengan LoRA dan DreamBooth, perhatikan parameter-parameter berikut:

* `--validation_images`, gambar yang akan di-upscale selama validasi
* `--class_labels_conditioning=timesteps`, untuk mengondisikan UNet secara tambahan sesuai kebutuhan di tahap 2
* `--learning_rate=1e-6`, learning rate yang lebih rendah digunakan dibandingkan tahap 1
* `--resolution=256`, resolusi yang diharapkan untuk upscaler

```bash
export MODEL_NAME="DeepFloyd/IF-II-L-v1.0"
export INSTANCE_DIR="dog"
export OUTPUT_DIR="dreambooth_dog_upscale"
export VALIDATION_IMAGES="dog_downsized/image_1.png dog_downsized/image_2.png dog_downsized/image_3.png dog_downsized/image_4.png"
python train_dreambooth_lora.py \
    --report_to wandb \
    --pretrained_model_name_or_path=$MODEL_NAME \
    --instance_data_dir=$INSTANCE_DIR \
    --output_dir=$OUTPUT_DIR \
    --instance_prompt="a sks dog" \
    --resolution=256 \
    --train_batch_size=4 \
    --gradient_accumulation_steps=1 \
    --learning_rate=1e-6 \
    --max_train_steps=2000 \
    --validation_prompt="a sks dog" \
    --validation_epochs=100 \
    --checkpointing_steps=500 \
    --pre_compute_text_embeddings \
    --tokenizer_max_length=77 \
    --text_encoder_use_attention_mask \
    --validation_images $VALIDATION_IMAGES \
    --class_labels_conditioning=timesteps
```

Untuk tahap 1 dari DeepFloyd IF dengan DreamBooth, perhatikan parameter-parameter berikut:

* `--skip_save_text_encoder`, untuk melewati penyimpanan T5 text encoder lengkap bersama model yang telah difinetune
* `--use_8bit_adam`, untuk menggunakan optimizer 8-bit Adam guna menghemat memori karena ukuran state optimizer saat melatih model penuh
* `--learning_rate=1e-7`, learning rate yang sangat rendah harus digunakan untuk pelatihan model penuh, jika tidak kualitas model akan menurun (Anda dapat menggunakan learning rate yang lebih tinggi dengan ukuran batch yang lebih besar)

Pelatihan dengan 8-bit Adam dan ukuran batch 4, model lengkap dapat dilatih dengan memori sekitar 48GB.

```bash
export MODEL_NAME="DeepFloyd/IF-I-XL-v1.0"
export INSTANCE_DIR="dog"
export OUTPUT_DIR="dreambooth_if"
accelerate launch train_dreambooth.py \
  --pretrained_model_name_or_path=$MODEL_NAME  \
  --instance_data_dir=$INSTANCE_DIR \
  --output_dir=$OUTPUT_DIR \
  --instance_prompt="a photo of sks dog" \
  --resolution=64 \
  --train_batch_size=4 \
  --gradient_accumulation_steps=1 \
  --learning_rate=1e-7 \
  --max_train_steps=150 \
  --validation_prompt "a photo of sks dog" \
  --validation_steps 25 \
  --text_encoder_use_attention_mask \
  --tokenizer_max_length 77 \
  --pre_compute_text_embeddings \
  --use_8bit_adam \
  --set_grads_to_none \
  --skip_save_text_encoder \
  --push_to_hub
```

Untuk tahap 2 dari DeepFloyd IF dengan DreamBooth, perhatikan parameter-parameter berikut:

* `--learning_rate=5e-6`, gunakan learning rate yang lebih rendah dengan effective batch size yang lebih kecil
* `--resolution=256`, resolusi yang diharapkan untuk upscaler
* `--train_batch_size=2` dan `--gradient_accumulation_steps=6`, untuk melatih secara efektif pada gambar dengan wajah membutuhkan ukuran batch yang lebih besar

```bash
export MODEL_NAME="DeepFloyd/IF-II-L-v1.0"
export INSTANCE_DIR="dog"
export OUTPUT_DIR="dreambooth_dog_upscale"
export VALIDATION_IMAGES="dog_downsized/image_1.png dog_downsized/image_2.png dog_downsized/image_3.png dog_downsized/image_4.png"
accelerate launch train_dreambooth.py \
  --report_to wandb \
  --pretrained_model_name_or_path=$MODEL_NAME \
  --instance_data_dir=$INSTANCE_DIR \
  --output_dir=$OUTPUT_DIR \
  --instance_prompt="a sks dog" \
  --resolution=256 \
  --train_batch_size=2 \
  --gradient_accumulation_steps=6 \
  --learning_rate=5e-6 \
  --max_train_steps=2000 \
  --validation_prompt="a sks dog" \
  --validation_steps=150 \
  --checkpointing_steps=500 \
  --pre_compute_text_embeddings \
  --tokenizer_max_length=77 \
  --text_encoder_use_attention_mask \
  --validation_images $VALIDATION_IMAGES \
  --class_labels_conditioning timesteps \
  --push_to_hub
```

### Tips pelatihan

Melatih model DeepFloyd IF bisa menantang, tetapi berikut adalah beberapa tips yang kami temukan sangat membantu:

- LoRA sudah cukup untuk melatih model tahap 1 karena resolusi rendah model membuat representasi detail yang lebih halus sulit dilakukan terlepas dari hal tersebut.
- Untuk objek yang umum atau sederhana, Anda tidak selalu perlu melakukan finetune pada upscaler. Pastikan prompt yang diteruskan ke upscaler disesuaikan untuk menghapus token baru dari instance prompt. Misalnya, jika prompt tahap 1 Anda adalah "a sks dog", maka prompt tahap 2 Anda harus menjadi "a dog".
- Untuk detail yang lebih halus seperti wajah, melatih penuh upscaler tahap 2 lebih baik daripada melatih model tahap 2 dengan LoRA. Menggunakan learning rate yang lebih rendah dengan batch size yang lebih besar juga membantu.
- Laju pembelajaran yang lebih rendah harus digunakan untuk melatih model tahap 2.
- [DDPMScheduler](/docs/diffusers/main/id/api/schedulers/ddpm#diffusers.DDPMScheduler) bekerja lebih baik daripada DPMSolver yang digunakan dalam skrip pelatihan.

## Langkah selanjutnya

Selamat atas pelatihan model DreamBooth Anda! Untuk mempelajari lebih lanjut tentang cara menggunakan model baru Anda, panduan berikut mungkin dapat membantu:

- Pelajari cara [memuat checkpoint DreamBooth](../using-diffusers/dreambooth) untuk inferensi.
- Jika Anda melatih dengan LoRA, lihat [LoRA untuk inferensi](../tutorials/using_peft_for_inference).
Xet Storage Details

Size:: 26.2 kB
Xet hash:: 0339c4bebda9a30103d788f197011228fbb683cb43eb7da0af87f74fcc3e3e29
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.