# DreamBooth

[DreamBooth](https://huggingface.co/papers/2208.12242) là một kỹ thuật huấn luyện cập nhật toàn bộ mô hình khuếch tán bằng cách huấn luyện trên chỉ một vài hình ảnh của một chủ thể hoặc phong cách. Nó hoạt động bằng cách liên kết một từ đặc biệt trong prompt với các hình ảnh mẫu.

Để tải checkpoint đã huấn luyện cho suy luận, xem [Tải mô hình DreamBooth cho suy luận](../using-diffusers/dreambooth).

Nếu bạn đang huấn luyện trên GPU có vRAM hạn chế, bạn nên thử bật các tham số `gradient_checkpointing` và `mixed_precision` trong lệnh huấn luyện. Bạn cũng có thể giảm lượng bộ nhớ sử dụng bằng cách dùng attention tiết kiệm bộ nhớ với [xFormers](../optimization/attention_backends).

Hướng dẫn này sẽ khám phá script [train_dreambooth.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py) để giúp bạn làm quen hơn với nó, và cách bạn có thể điều chỉnh nó cho trường hợp sử dụng của riêng mình.

Trước khi chạy script, hãy đảm bảo bạn cài đặt thư viện từ mã nguồn:

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

Điều hướng đến thư mục chứa ví dụ với script huấn luyện và cài đặt các phụ thuộc cần thiết cho script bạn đang sử dụng:

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

> [!TIP]
> 🤗 Accelerate là một thư viện giúp bạn huấn luyện trên nhiều GPU/TPU hoặc với độ chính xác hỗn hợp. Nó sẽ tự động cấu hình thiết lập huấn luyện của bạn dựa trên phần cứng và môi trường của bạn. Hãy xem 🤗 Accelerate [Quick tour](https://huggingface.co/docs/accelerate/quicktour) để tìm hiểu thêm.

Khởi tạo một môi trường 🤗 Accelerate:

```bash
accelerate config
```

Để thiết lập môi trường 🤗 Accelerate mặc định mà không cần chọn bất kỳ cấu hình nào:

```bash
accelerate config default
```

Hoặc nếu môi trường của bạn không hỗ trợ shell tương tác, chẳng hạn như notebook, bạn có thể sử dụng:

```py
from accelerate.utils import write_basic_config

write_basic_config()
```

Cuối cùng, nếu bạn muốn huấn luyện một mô hình trên bộ dữ liệu của riêng mình, hãy xem hướng dẫn [Tạo bộ dữ liệu để huấn luyện](create_dataset) để tìm hiểu cách tạo một bộ dữ liệu tương thích với script huấn luyện.

> [!TIP]
> Các phần tiếp theo làm nổi bật những phần quan trọng trong script huấn luyện để hiểu cách chỉnh sửa nó, nhưng không đi sâu vào mọi khía cạnh của script. Nếu bạn muốn tìm hiểu thêm, hãy tự do đọc qua [script](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py) và cho chúng tôi biết nếu bạn có bất kỳ câu hỏi hoặc lo ngại nào.

## Tham số của script

> [!WARNING]
> DreamBooth rất nhạy cảm với các siêu tham số huấn luyện và dễ bị overfit. Hãy đọc bài viết trên blog [Training Stable Diffusion with Dreambooth using 🧨 Diffusers](https://huggingface.co/blog/dreambooth) để xem các cài đặt được khuyến nghị cho các chủ thể khác nhau, giúp bạn chọn được siêu tham số phù hợp.

Tệp kịch bản huấn luyện cung cấp nhiều tham số để tùy chỉnh phiên huấn luyện của bạn. Tất cả các tham số và mô tả của chúng được tìm thấy trong hàm [`parse_args()`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L228). Các tham số được đặt với các giá trị mặc định nên hoạt động khá tốt ngay khi sử dụng, nhưng bạn cũng có thể đặt giá trị riêng của mình trong lệnh huấn luyện nếu muốn.

Ví dụ, để huấn luyện ở định dạng bf16:

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

Một số tham số cơ bản và quan trọng cần biết và chỉ định là:

- `--pretrained_model_name_or_path`: tên của model trên Hub hoặc đường dẫn cục bộ đến model được huấn luyện trước
- `--instance_data_dir`: đường dẫn đến thư mục chứa bộ dữ liệu huấn luyện (các hình ảnh ví dụ)
- `--instance_prompt`: câu lệnh văn bản chứa từ đặc biệt cho các hình ảnh ví dụ
- `--train_text_encoder`: có huấn luyện cả text encoder hay không
- `--output_dir`: nơi lưu trữ mô hình đã được huấn luyện
- `--push_to_hub`: có đẩy mô hình đã huấn luyện lên Hub hay không
- `--checkpointing_steps`: tần suất lưu checkpoint trong quá trình huấn luyện mô hình; điều này hữu ích nếu vì một lý do nào đó quá trình huấn luyện bị gián đoạn, bạn có thể tiếp tục huấn luyện từ checkpoint đó bằng cách thêm `--resume_from_checkpoint` vào lệnh huấn luyện của bạn

### Trọng số Min-SNR

Chiến lược trọng số [Min-SNR](https://huggingface.co/papers/2303.09556) có thể hỗ trợ quá trình huấn luyện bằng cách cân bằng lại loss để đạt được sự hội tụ nhanh hơn. Script huấn luyện hỗ trợ dự đoán `epsilon` (noise) hoặc `v_prediction`, nhưng Min-SNR tương thích với cả hai loại dự đoán. Chiến lược trọng số này chỉ được hỗ trợ bởi PyTorch.

Thêm tham số `--snr_gamma` và đặt nó bằng giá trị khuyến nghị là 5.0:

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

### Mất mát bảo toàn tiên nghiệm

Mất bảo toàn tiên nghiệm là một phương pháp sử dụng các mẫu do chính mô hình tạo ra để giúp nó học cách tạo ra các hình ảnh đa dạng hơn. Vì các hình ảnh mẫu được tạo ra này thuộc cùng một lớp với các hình ảnh bạn đã cung cấp, chúng giúp mô hình giữ lại những gì đã học được về lớp đó và cách sử dụng kiến thức hiện có về lớp để tạo ra các bố cục mới.

- `--with_prior_preservation`: có sử dụng prior preservation loss hay không
- `--prior_loss_weight`: kiểm soát mức độ ảnh hưởng của tổn thất bảo toàn tiên nghiệm lên mô hình
- `--class_data_dir`: đường dẫn đến thư mục chứa các hình ảnh mẫu lớp đã được tạo
- `--class_prompt`: câu lệnh văn bản mô tả lớp của các hình ảnh mẫu được tạo

```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"
```

### Huấn luyện text encoder

Để cải thiện chất lượng của các đầu ra được tạo ra, bạn cũng có thể huấn luyện text encoder bên cạnh UNet. Điều này đòi hỏi thêm bộ nhớ và bạn sẽ cần một GPU có ít nhất 24GB vRAM. Nếu bạn có phần cứng cần thiết, việc huấn luyện text encoder sẽ cho kết quả tốt hơn, đặc biệt khi tạo ảnh khuôn mặt. Bật tùy chọn này bằng cách:

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

## Script huấn luyện

DreamBooth đi kèm với các lớp dữ liệu riêng:

- [`DreamBoothDataset`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L604): tiền xử lý các hình ảnh và hình ảnh lớp, và mã hóa các prompt để huấn luyện
- [`PromptDataset`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L738): tạo các prompt embeddings để tạo ảnh lớp

Nếu bạn đã bật [mất mát bảo tồn trước đó](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L842), các hình ảnh lớp sẽ được tạo tại đây:

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

Tiếp theo là hàm [`main()`](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L799) xử lý việc thiết lập bộ dữ liệu cho quá trình huấn luyện và chính vòng lặp huấn luyện. Script sẽ nạp [tokenizer](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L898), [trình lập lịch và các mô hình](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
)
```

Sau đó, đến lúc [tạo bộ dữ liệu huấn luyện](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L1073) và DataLoader từ `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,
)
```

Cuối cùng, [vòng lặp huấn luyện](https://github.com/huggingface/diffusers/blob/072e00897a7cf4302c347a63ec917b4b8add16d4/examples/dreambooth/train_dreambooth.py#L1151) sẽ xử lý các bước còn lại như chuyển đổi ảnh sang không gian ẩn, thêm nhiễu vào đầu vào, dự đoán phần dư nhiễu và tính toán tổn thất.

Nếu bạn muốn tìm hiểu thêm về cách hoạt động của vòng lặp huấn luyện, hãy xem hướng dẫn [Hiểu về pipeline, mô hình và trình lập lịch](../using-diffusers/write_own_pipeline), nơi phân tích chi tiết mẫu cơ bản của quá trình khử nhiễu.

## Chạy script

Bạn đã sẵn sàng để chạy script huấn luyện! 🚀

Trong hướng dẫn này, bạn sẽ tải xuống một số hình ảnh của một [con chó](https://huggingface.co/datasets/diffusers/dog-example) và lưu chúng vào một thư mục. Nhưng hãy nhớ rằng bạn có thể tự tạo và sử dụng bộ dữ liệu của riêng mình nếu muốn (xem hướng dẫn [Tạo bộ dữ liệu để huấn luyện](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",
)
```

Đặt biến môi trường `MODEL_NAME` thành id của một model trên Hub hoặc đường dẫn đến một model cục bộ, `INSTANCE_DIR` thành đường dẫn nơi bạn vừa tải xuống các hình ảnh chó, và `OUTPUT_DIR` thành nơi bạn muốn lưu model. Bạn sẽ sử dụng `sks` làm từ đặc biệt để gắn kết quá trình huấn luyện.

Nếu bạn quan tâm đến việc theo dõi quá trình huấn luyện, bạn có thể định kỳ lưu các hình ảnh được tạo ra khi quá trình huấn luyện diễn ra. Thêm các tham số sau vào lệnh huấn luyện:

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

Một điều nữa trước khi bạn chạy script! Tùy thuộc vào GPU bạn đang dùng, bạn có thể cần bật một số tối ưu hóa nhất định để huấn luyện DreamBooth.

Trên GPU 16GB, bạn có thể sử dụng trình tối ưu hóa 8-bit của bitsandbytes và gradient checkpointing để hỗ trợ huấn luyện mô hình DreamBooth. Cài đặt bitsandbytes:

```py
pip install bitsandbytes
```

Sau đó, thêm tham số sau vào lệnh huấn luyện của bạn:

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

Trên GPU 12GB, bạn sẽ cần trình tối ưu hóa 8-bit của bitsandbytes, gradient checkpointing, xFormers, và đặt gradient thành `None` thay vì số 0 để giảm mức sử dụng bộ nhớ.

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

Trên GPU 8GB, bạn sẽ cần [DeepSpeed](https://www.deepspeed.ai/) để offload một số tensor từ vRAM sang CPU hoặc NVME, cho phép huấn luyện với bộ nhớ GPU ít hơn.

Chạy lệnh sau để cấu hình môi trường 🤗 Accelerate của bạn:

```bash
accelerate config
```

Trong quá trình cấu hình, hãy xác nhận rằng bạn muốn sử dụng DeepSpeed. Bây giờ, bạn có thể huấn luyện với dưới 8GB vRAM bằng cách kết hợp DeepSpeed stage 2, fp16 mixed precision, và offload các tham số mô hình cùng trạng thái optimizer sang CPU. Nhược điểm là cách này yêu cầu nhiều bộ nhớ hệ thống hơn (~25 GB). Xem [tài liệu DeepSpeed](https://huggingface.co/docs/accelerate/usage_guides/deepspeed) để biết thêm các tùy chọn cấu hình.

Bạn cũng nên thay đổi bộ tối ưu Adam mặc định thành phiên bản Adam được tối ưu của DeepSpeed [`deepspeed.ops.adam.DeepSpeedCPUAdam`](https://deepspeed.readthedocs.io/en/latest/optimizers.html#adam-cpu) để tăng tốc đáng kể. Việc bật `DeepSpeedCPUAdam` yêu cầu phiên bản CUDA toolchain của hệ thống phải giống với phiên bản đã cài đặt cùng PyTorch.

Các optimizer 8-bit của bitsandbytes hiện có vẻ không tương thích với DeepSpeed.

Xong rồi! Bạn không cần thêm bất kỳ tham số nào khác vào lệnh huấn luyện của mình.

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

Khi quá trình huấn luyện hoàn tất, bạn có thể sử dụng mô hình vừa được huấn luyện để suy luận!

> [!TIP]
> Không thể chờ để thử mô hình của bạn cho suy luận trước khi huấn luyện hoàn tất? 🤭 Hãy đảm bảo bạn đã cài đặt phiên bản mới nhất của 🤗 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 là một kỹ thuật huấn luyện giúp giảm đáng kể số lượng tham số có thể huấn luyện. Nhờ đó, quá trình huấn luyện diễn ra nhanh hơn và việc lưu trữ các trọng số kết quả cũng dễ dàng hơn vì kích thước của chúng nhỏ hơn rất nhiều (~100MB). Hãy sử dụng script [train_dreambooth_lora.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_lora.py) để huấn luyện với LoRA.

Tài liệu hướng dẫn [Đào tạo LoRA](lora) thảo luận chi tiết hơn về script đào tạo LoRA.

## Stable Diffusion XL

Stable Diffusion XL (SDXL) là một mô hình text-to-image mạnh mẽ, tạo ra các hình ảnh độ phân giải cao, và nó bổ sung một text-encoder thứ hai vào kiến trúc của mình. Sử dụng script [train_dreambooth_lora_sdxl.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_lora_sdxl.py) để huấn luyện một mô hình SDXL với LoRA.

Tài liệu hướng dẫn [huấn luyện SDXL](sdxl) thảo luận chi tiết hơn về script huấn luyện SDXL.

## DeepFloyd IF

DeepFloyd IF là mô hình khuếch tán pixel dạng liên tiếp với ba giai đoạn. Giai đoạn đầu tiên tạo ra ảnh cơ sở, và hai giai đoạn thứ hai và thứ ba lần lượt phóng to ảnh cơ sở thành ảnh độ phân giải cao 1024x1024. Sử dụng các script [train_dreambooth_lora.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_lora.py) hoặc [train_dreambooth.py](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py) để huấn luyện mô hình DeepFloyd IF với LoRA hoặc toàn bộ mô hình.

DeepFloyd IF sử dụng phương sai dự đoán, nhưng các script huấn luyện của Diffusers sử dụng lỗi dự đoán nên các mô hình DeepFloyd IF đã được huấn luyện sẽ được chuyển sang lịch trình phương sai cố định. Các script huấn luyện sẽ tự động cập nhật cấu hình scheduler của mô hình đã được huấn luyện hoàn chỉnh cho bạn. Tuy nhiên, khi bạn tải trọng số LoRA đã lưu, bạn cũng phải cập nhật cấu hình scheduler của 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")
```

Mô hình giai đoạn 2 cần thêm các hình ảnh xác thực để tăng độ phân giải. Bạn có thể tải xuống và sử dụng một phiên bản thu nhỏ của các hình ảnh huấn luyện cho mục đích này.

```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",
)
```

Các ví dụ mã dưới đây cung cấp cái nhìn tổng quan ngắn gọn về cách huấn luyện một mô hình DeepFloyd IF bằng cách kết hợp DreamBooth và LoRA. Một số tham số quan trọng cần lưu ý là:

* `--resolution=64`, độ phân giải nhỏ hơn nhiều được yêu cầu vì DeepFloyd IF là mô hình khuếch tán pixel và để làm việc trên các pixel chưa nén, các hình ảnh đầu vào phải nhỏ hơn
* `--pre_compute_text_embeddings`, tính toán trước các text embeddings để tiết kiệm bộ nhớ vì [T5Model](https://huggingface.co/docs/transformers/v5.22.2/en/model_doc/t5#transformers.T5Model) có thể chiếm rất nhiều bộ nhớ
* `--tokenizer_max_length=77`, bạn có thể sử dụng độ dài văn bản mặc định dài hơn với T5 làm bộ mã hóa văn bản, nhưng quy trình mã hóa mô hình mặc định sử dụng độ dài văn bản ngắn hơn
* `--text_encoder_use_attention_mask`, để truyền attention mask vào text encoder

Giai đoạn 1 của quá trình huấn luyện DeepFloyd IF với LoRA và DreamBooth yêu cầu ~28GB bộ nhớ.

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

Đối với giai đoạn 2 của DeepFloyd IF với LoRA và DreamBooth, hãy chú ý đến các tham số sau:

* `--validation_images`, các hình ảnh để tăng độ phân giải trong quá trình kiểm tra
* `--class_labels_conditioning=timesteps`, để thêm điều kiện cho UNet khi cần ở giai đoạn 2
* `--learning_rate=1e-6`, tốc độ học thấp hơn so với giai đoạn 1
* `--resolution=256`, độ phân giải mong đợi cho trình tăng độ phân giải

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

Đối với giai đoạn 1 của DeepFloyd IF với DreamBooth, hãy chú ý đến các tham số sau:

* `--skip_save_text_encoder`, để bỏ qua việc lưu bộ mã hóa văn bản T5 đầy đủ cùng với mô hình đã tinh chỉnh
* `--use_8bit_adam`, để sử dụng bộ tối ưu hóa Adam 8-bit nhằm tiết kiệm bộ nhớ do kích thước của trạng thái bộ tối ưu hóa khi huấn luyện toàn bộ mô hình
* `--learning_rate=1e-7`, một tốc độ học thực sự thấp nên được sử dụng cho việc huấn luyện toàn bộ mô hình, nếu không chất lượng mô hình sẽ bị suy giảm (bạn có thể sử dụng tốc độ học cao hơn với kích thước lô lớn hơn)

Khi huấn luyện với 8-bit Adam và kích thước lô là 4, toàn bộ mô hình có thể được huấn luyện với ~48GB bộ nhớ.

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

Đối với giai đoạn 2 của DeepFloyd IF với DreamBooth, hãy chú ý đến các tham số sau:

* `--learning_rate=5e-6`, sử dụng learning rate thấp hơn với kích thước batch hiệu dụng nhỏ hơn
* `--resolution=256`, độ phân giải mong đợi cho trình tăng độ phân giải
* `--train_batch_size=2` và `--gradient_accumulation_steps=6`, để huấn luyện hiệu quả trên các hình ảnh có khuôn mặt cần kích thước batch lớn hơn

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

### Mẹo huấn luyện

Việc huấn luyện mô hình DeepFloyd IF có thể gây khó khăn, nhưng dưới đây là một số mẹo mà chúng tôi thấy hữu ích:

- LoRA là đủ để huấn luyện mô hình giai đoạn 1 vì độ phân giải thấp của mô hình khiến việc thể hiện các chi tiết tinh tế trở nên khó khăn bất kể trường hợp nào.
- Đối với các đối tượng phổ biến hoặc đơn giản, bạn không nhất thiết phải tinh chỉnh bộ tăng độ phân giải. Hãy đảm bảo rằng prompt được truyền vào bộ tăng độ phân giải đã được điều chỉnh để loại bỏ token mới khỏi prompt của instance. Ví dụ, nếu prompt ở giai đoạn 1 của bạn là "a sks dog" thì prompt ở giai đoạn 2 nên là "a dog".
- Đối với các chi tiết nhỏ hơn như khuôn mặt, việc huấn luyện hoàn toàn bộ upscaler giai đoạn 2 sẽ hiệu quả hơn so với việc huấn luyện mô hình giai đoạn 2 bằng LoRA. Đồng thời, việc sử dụng tốc độ học thấp hơn với kích thước lô lớn hơn cũng giúp ích.
- Nên sử dụng tốc độ học thấp hơn để huấn luyện mô hình giai đoạn 2.
- [DDPMScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/ddpm#diffusers.DDPMScheduler) hoạt động tốt hơn so với DPMSolver được sử dụng trong các script huấn luyện.

## Các bước tiếp theo

Chúc mừng bạn đã huấn luyện thành công mô hình DreamBooth! Để tìm hiểu thêm về cách sử dụng mô hình mới của bạn, hướng dẫn sau có thể hữu ích:

- Tìm hiểu cách [tải checkpoint DreamBooth](../using-diffusers/dreambooth) để suy luận.
- Nếu bạn đã huấn luyện với LoRA, hãy xem [LoRA cho suy luận](../tutorials/using_peft_for_inference).