# LoRA

> [!WARNING]
> Đây là tính năng thử nghiệm và API có thể thay đổi trong tương lai.

[LoRA (Low-Rank Adaptation of Large Language Models)](https://hf.co/papers/2106.09685) là một kỹ thuật huấn luyện phổ biến và nhẹ, giúp giảm đáng kể số lượng tham số có thể huấn luyện. Kỹ thuật này hoạt động bằng cách chèn một số lượng nhỏ các trọng số mới vào mô hình và chỉ huấn luyện các trọng số này. Điều này khiến việc huấn luyện với LoRA nhanh hơn, tiết kiệm bộ nhớ hơn và tạo ra các trọng số mô hình nhỏ hơn (vài trăm MB), dễ lưu trữ và chia sẻ hơn. LoRA cũng có thể kết hợp với các kỹ thuật huấn luyện khác như DreamBooth để tăng tốc quá trình huấn luyện.

> [!TIP]
> LoRA rất đa năng và được hỗ trợ cho [DreamBooth](https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth_lora.py), [Kandinsky 2.2](https://github.com/huggingface/diffusers/blob/main/examples/kandinsky2_2/text_to_image/train_text_to_image_lora_decoder.py), [Stable Diffusion XL](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_lora_sdxl.py) và [text-to-image](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_lora.py).

Hướng dẫn này sẽ khám phá script [train_text_to_image_lora.py](https://github.com/huggingface/diffusers/blob/main/examples/text_to_image/train_text_to_image_lora.py) để giúp bạn làm quen hơn với nó, cũng như 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/text_to_image
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/text_to_image/train_text_to_image_lora.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

Tệp kịch bản huấn luyện có nhiều tham số để giúp bạn tùy chỉnh phiên huấn luyện của mình. 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/dd9a5caf61f04d11c0fa9f3947b69ab0010c9a0f/examples/text_to_image/train_text_to_image_lora.py#L85). Các giá trị mặc định được cung cấp cho hầu hết các tham số và hoạt động khá tốt, nhưng bạn cũng có thể đặt giá trị của riêng mình trong lệnh huấn luyện nếu muốn.

Ví dụ, để tăng số lượng epoch khi huấn luyện:

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

Nhiều tham số cơ bản và quan trọng được mô tả trong hướng dẫn huấn luyện [Text-to-image](text2image#script-parameters), vì vậy hướng dẫn này chỉ tập trung vào các tham số liên quan đến LoRA:

- `--rank`: chiều trong của các ma trận hạng thấp cần huấn luyện; hạng càng cao thì số tham số có thể huấn luyện càng lớn
- `--learning_rate`: tốc độ học mặc định là 1e-4, nhưng với LoRA, bạn có thể sử dụng tốc độ học cao hơn

## Script huấn luyện

Mã tiền xử lý tập dữ liệu và vòng lặp huấn luyện nằm trong hàm [`main()`](https://github.com/huggingface/diffusers/blob/dd9a5caf61f04d11c0fa9f3947b69ab0010c9a0f/examples/text_to_image/train_text_to_image_lora.py#L371), và nếu bạn cần điều chỉnh script huấn luyện, đây là nơi bạn sẽ thực hiện các thay đổi.

Tương tự như các tham số của script, một hướng dẫn chi tiết về script huấn luyện được cung cấp trong hướng dẫn huấn luyện [Text-to-image](text2image#training-script). Thay vào đó, hướng dẫn này sẽ xem xét các phần liên quan đến LoRA trong script.

Diffusers sử dụng [LoraConfig](https://huggingface.co/docs/peft/main/en/package_reference/lora#peft.LoraConfig) từ thư viện [PEFT](https://hf.co/docs/peft) để thiết lập các tham số của bộ thích ứng LoRA, chẳng hạn như rank, alpha và các module cần chèn trọng số LoRA. Bộ thích ứng được thêm vào UNet, và chỉ các lớp LoRA được lọc để tối ưu hóa trong `lora_layers`.

```py
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())
```

Diffusers cũng hỗ trợ tinh chỉnh text encoder bằng LoRA từ thư viện [PEFT](https://hf.co/docs/peft) khi cần thiết, chẳng hạn như khi tinh chỉnh Stable Diffusion XL (SDXL). [LoraConfig](https://huggingface.co/docs/peft/main/en/package_reference/lora#peft.LoraConfig) được dùng để cấu hình các tham số của bộ thích ứng LoRA, sau đó được thêm vào text encoder, và chỉ các lớp LoRA được lọc ra để huấn luyện.

```py
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()))
```

[Trình tối ưu](https://github.com/huggingface/diffusers/blob/e4b8f173b97731686e290b2eb98e7f5df2b1b322/examples/text_to_image/train_text_to_image_lora.py#L529) được khởi tạo với `lora_layers` vì đây là những trọng số duy nhất sẽ được tối ưu:

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

Ngoài việc thiết lập các lớp LoRA, script huấn luyện về cơ bản giống hệt với train_text_to_image.py!

## Chạy script

Khi bạn đã thực hiện tất cả các thay đổi hoặc hài lòng với cấu hình mặc định, bạn đã sẵn sàng để chạy script huấn luyện! 🚀

Hãy huấn luyện trên bộ dữ liệu [Naruto BLIP captions](https://huggingface.co/datasets/lambdalabs/naruto-blip-captions) để tạo ra các nhân vật Naruto của riêng bạn. Đặt các biến môi trường `MODEL_NAME` và `DATASET_NAME` lần lượt thành tên mô hình và tên bộ dữ liệu. Bạn cũng nên chỉ định nơi lưu mô hình trong `OUTPUT_DIR`, và tên mô hình để lưu trên Hub bằng `HUB_MODEL_ID`. Script sẽ tạo và lưu các tệp sau vào kho của bạn:

- các checkpoint mô hình đã lưu
- `pytorch_lora_weights.safetensors` (các trọng số LoRA đã được huấn luyện)

Nếu bạn đang huấn luyện trên nhiều hơn một GPU, hãy thêm tham số `--multi_gpu` vào lệnh `accelerate launch`.

> [!WARNING]
> Một lần chạy huấn luyện đầy đủ mất khoảng 5 giờ trên GPU 2080 Ti với 11GB VRAM.

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

Sau khi quá trình huấn luyện hoàn tất, bạn có thể sử dụng mô hình của mình để suy luận:

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

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

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

- Tìm hiểu cách [tải các định dạng LoRA khác nhau](../tutorials/using_peft_for_inference) được huấn luyện bằng các trình huấn luyện của cộng đồng như Kohya và TheLastBen.
- Tìm hiểu cách sử dụng và [kết hợp nhiều LoRA](../tutorials/using_peft_for_inference) với PEFT để suy luận.