# PixArt-α

![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/pixart/header_collage.png)

[PixArt-α: Fast Training of Diffusion Transformer for Photorealistic Text-to-Image Synthesis](https://huggingface.co/papers/2310.00426) là của Junsong Chen, Jincheng Yu, Chongjian Ge, Lewei Yao, Enze Xie, Yue Wu, Zhongdao Wang, James Kwok, Ping Luo, Huchuan Lu, và Zhenguo Li.

Tóm tắt từ bài báo là:

*Các mô hình text-to-image (T2I) tiên tiến nhất đòi hỏi chi phí huấn luyện đáng kể (ví dụ: hàng triệu giờ GPU), gây trở ngại nghiêm trọng cho sự đổi mới cơ bản của cộng đồng AIGC đồng thời làm tăng lượng khí thải CO2. Bài báo này giới thiệu PIXART-α, một mô hình khuếch tán T2I dựa trên Transformer, có chất lượng tạo ảnh cạnh tranh với các trình tạo ảnh tiên tiến nhất (ví dụ: Imagen, SDXL và thậm chí cả Midjourney), đạt đến tiêu chuẩn ứng dụng gần thương mại. Ngoài ra, nó hỗ trợ tổng hợp ảnh độ phân giải cao lên đến 1024px với chi phí huấn luyện thấp, như được minh họa trong Hình 1 và 2. Để đạt được mục tiêu này, ba thiết kế cốt lõi được đề xuất: (1) Phân rã chiến lược huấn luyện: Chúng tôi xây dựng ba bước huấn luyện riêng biệt để tối ưu hóa lần lượt sự phụ thuộc của pixel, sự căn chỉnh văn bản-ảnh và chất lượng thẩm mỹ của ảnh; (2) T2I Transformer hiệu quả: Chúng tôi tích hợp các module cross-attention vào Diffusion Transformer (DiT) để tiêm điều kiện văn bản và đơn giản hóa nhánh điều kiện lớp có tính toán nặng; (3) Dữ liệu giàu thông tin: Chúng tôi nhấn mạnh tầm quan trọng của mật độ khái niệm trong các cặp văn bản-ảnh và tận dụng một mô hình Vision-Language lớn để tự động dán nhãn các chú thích giả dày đặc nhằm hỗ trợ việc học căn chỉnh văn bản-ảnh. Kết quả là, tốc độ huấn luyện của PIXART-α vượt trội rõ rệt so với các mô hình T2I quy mô lớn hiện có, ví dụ: PIXART-α chỉ mất 10,8% thời gian huấn luyện của Stable Diffusion v1.5 (675 so với 6.250 ngày GPU A100), tiết kiệm gần 300.000 đô la (26.000 đô la so với 320.000 đô la) và giảm 90% lượng khí thải CO2. Hơn nữa, so với một mô hình SOTA lớn hơn, RAPHAEL, chi phí huấn luyện của chúng tôi chỉ là 1%. Các thí nghiệm mở rộng cho thấy PIXART-α vượt trội về chất lượng ảnh, tính nghệ thuật và kiểm soát ngữ nghĩa. Chúng tôi hy vọng PIXART-α sẽ mang lại những hiểu biết mới cho cộng đồng AIGC và các startup để đẩy nhanh việc xây dựng các mô hình tạo sinh chất lượng cao nhưng chi phí thấp của riêng họ từ đầu.*

Bạn có thể tìm thấy mã nguồn gốc tại [PixArt-alpha/PixArt-alpha](https://github.com/PixArt-alpha/PixArt-alpha) và tất cả các checkpoint khả dụng tại [PixArt-alpha](https://huggingface.co/PixArt-alpha).

Một số lưu ý về pipeline này:

* Nó sử dụng bộ khung Transformer (thay vì UNet) để khử nhiễu. Do đó, nó có kiến trúc tương tự như [DiT](./dit).
* Mô hình được huấn luyện bằng các điều kiện văn bản được tính toán từ T5. Khía cạnh này giúp pipeline thực hiện tốt hơn trong việc tuân theo các prompt văn bản phức tạp với các chi tiết tinh vi.
* Mô hình này có khả năng tạo ra các hình ảnh độ phân giải cao với nhiều tỷ lệ khung hình khác nhau. Để đạt được kết quả tốt nhất, các tác giả khuyến nghị một số khoảng kích thước, có thể tìm thấy [tại đây](https://github.com/PixArt-alpha/PixArt-alpha/blob/08fbbd281ec96866109bdd2cdb75f2f58fb17610/diffusion/data/datasets/utils.py).
* Mô hình này sánh ngang về chất lượng với các hệ thống tạo ảnh từ văn bản tiên tiến nhất (tại thời điểm viết bài) như Stable Diffusion XL, Imagen và DALL-E 2, đồng thời hiệu quả hơn chúng.

> [!TIP]
> Hãy chắc chắn xem qua [hướng dẫn](../../using-diffusers/schedulers) về Schedulers để tìm hiểu cách khám phá sự đánh đổi giữa tốc độ và chất lượng của scheduler, và xem phần [tái sử dụng các thành phần giữa các pipeline](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) để tìm hiểu cách nạp các thành phần giống nhau vào nhiều pipeline một cách hiệu quả.

## Suy luận với GPU VRAM dưới 8GB

Chạy [PixArtAlphaPipeline](/docs/diffusers/main/vi/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) với dưới 8GB VRAM GPU bằng cách nạp text encoder ở độ chính xác 8-bit. Hãy cùng xem qua một ví dụ hoàn chỉnh.

Đầu tiên, cài đặt thư viện [bitsandbytes](https://github.com/TimDettmers/bitsandbytes):

```bash
pip install -U bitsandbytes
```

Sau đó, nạp text encoder ở 8-bit:

```python
from transformers import T5EncoderModel
from diffusers import PixArtAlphaPipeline
import torch

text_encoder = T5EncoderModel.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    subfolder="text_encoder",
    load_in_8bit=True,
    device_map="auto",

)
pipe = PixArtAlphaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    text_encoder=text_encoder,
    transformer=None,
    device_map="auto"
)
```

Bây giờ, hãy sử dụng `pipe` để mã hóa một prompt:

```python
with torch.no_grad():
    prompt = "cute cat"
    prompt_embeds, prompt_attention_mask, negative_embeds, negative_prompt_attention_mask = pipe.encode_prompt(prompt)
```

Vì các vector nhúng văn bản đã được tính toán, hãy xóa `text_encoder` và `pipe` khỏi bộ nhớ và giải phóng một phần VRAM GPU:

```python
import gc

def flush():
    gc.collect()
    torch.cuda.empty_cache()

del text_encoder
del pipe
flush()
```

Sau đó, tính toán các latents với các embeddings của prompt làm đầu vào:

```python
pipe = PixArtAlphaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-XL-2-1024-MS",
    text_encoder=None,
    dtype=torch.float16,
).to("cuda")  # or "mps", "xpu", "cpu"

latents = pipe(
    negative_prompt=None,
    prompt_embeds=prompt_embeds,
    negative_prompt_embeds=negative_embeds,
    prompt_attention_mask=prompt_attention_mask,
    negative_prompt_attention_mask=negative_prompt_attention_mask,
    num_images_per_prompt=1,
    output_type="latent",
).images

del pipe.transformer
flush()
```

> [!TIP]
> Lưu ý rằng khi khởi tạo `pipe`, bạn đang đặt `text_encoder` thành `None` để nó không được tải.

Sau khi các latents được tính toán, hãy truyền chúng cho VAE để giải mã thành một hình ảnh thực:

```python
with torch.no_grad():
    image = pipe.vae.decode(latents / pipe.vae.config.scaling_factor, return_dict=False)[0]
image = pipe.image_processor.postprocess(image, output_type="pil")[0]
image.save("cat.png")
```

Bằng cách xóa các thành phần bạn không sử dụng và giải phóng bộ nhớ VRAM của GPU, bạn nên có thể chạy [PixArtAlphaPipeline](/docs/diffusers/main/vi/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) với dưới 8GB VRAM GPU.

![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/pixart/8bits_cat.png)

Nếu bạn muốn có báo cáo về mức sử dụng bộ nhớ, hãy chạy [script](https://gist.github.com/sayakpaul/3ae0f847001d342af27018a96f467e4e) này.

> [!WARNING]
> Việc tính toán text embeddings ở 8-bit có thể ảnh hưởng đến chất lượng của hình ảnh được tạo ra do mất mát thông tin trong không gian biểu diễn gây ra bởi độ chính xác giảm. Khuyến nghị so sánh kết quả đầu ra khi có và không có 8-bit.

Trong khi nạp `text_encoder`, bạn đã đặt `load_in_8bit` thành `True`. Bạn cũng có thể chỉ định `load_in_4bit` để giảm yêu cầu bộ nhớ xuống còn dưới 7GB.

## PixArtAlphaPipeline[[diffusers.PixArtAlphaPipeline]]

#### diffusers.PixArtAlphaPipeline[[diffusers.PixArtAlphaPipeline]]

```python
diffusers.PixArtAlphaPipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, vae: AutoencoderKL, transformer: PixArtTransformer2DModel, scheduler: DPMSolverMultistepScheduler)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pixart_alpha/pipeline_pixart_alpha.py#L241)

**Tham số:**

vae ([AutoencoderKL](/docs/diffusers/main/vi/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Mô hình Variational Auto-Encoder (VAE) để mã hóa và giải mã hình ảnh sang và từ các biểu diễn ẩn.

text_encoder (`T5EncoderModel`) : Bộ mã hóa văn bản đóng băng. PixArt-Alpha sử dụng [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), cụ thể là biến thể [t5-v1_1-xxl](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl).

tokenizer (`T5Tokenizer`) : Tokenizer của lớp [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).

transformer ([PixArtTransformer2DModel](/docs/diffusers/main/vi/api/models/pixart_transformer2d#diffusers.PixArtTransformer2DModel)) : Một `PixArtTransformer2DModel` có điều kiện văn bản để khử nhiễu các latents ảnh đã mã hóa. Ban đầu được công bố dưới dạng [`Transformer2DModel`](https://huggingface.co/PixArt-alpha/PixArt-XL-2-1024-MS/blob/main/transformer/config.json#L2) trong cấu hình, nhưng sự không khớp này có thể bỏ qua.

scheduler ([SchedulerMixin](/docs/diffusers/main/vi/api/schedulers/overview#diffusers.SchedulerMixin)) : Một trình lập lịch được sử dụng kết hợp với `transformer` để khử nhiễu các latents ảnh đã mã hóa.

Pipeline để tạo ảnh từ văn bản sử dụng PixArt-Alpha.

Mô hình này kế thừa từ [DiffusionPipeline](/docs/diffusers/main/vi/api/pipelines/overview#diffusers.DiffusionPipeline). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các pipeline (chẳng hạn như tải xuống hoặc lưu, chạy trên một thiết bị cụ thể, v.v.)

#### __call__[[diffusers.PixArtAlphaPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 20, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 4.5, num_images_per_prompt: int | None = 1, height: int | None = None, width: int | None = None, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, clean_caption: bool = True, use_resolution_binning: bool = True, max_sequence_length: int = 120, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pixart_alpha/pipeline_pixart_alpha.py#L686)

**Tham số:**

prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt để hướng dẫn việc tạo ảnh. Nếu không được định nghĩa, bạn phải truyền `prompt_embeds` thay thế.

negative_prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt hoặc các prompt không được dùng để hướng dẫn việc tạo ảnh. Nếu không được định nghĩa, bạn phải truyền `negative_prompt_embeds` thay thế. Bỏ qua khi không sử dụng guidance (tức là bị bỏ qua nếu `guidance_scale` nhỏ hơn `1`).

num_inference_steps (`int`, *optional*, mặc định là 100) : Số bước khử nhiễu. Số bước khử nhiễu nhiều hơn thường dẫn đến hình ảnh có chất lượng cao hơn, với cái giá là suy luận chậm hơn.

timesteps (`list[int]`, *optional*) : Các bước thời gian (timesteps) tùy chỉnh để sử dụng cho quá trình khử nhiễu với các trình lập lịch (scheduler) hỗ trợ tham số `timesteps` trong phương thức `set_timesteps` của chúng. Nếu không được định nghĩa, hành vi mặc định khi `num_inference_steps` được truyền vào sẽ được sử dụng. Phải được sắp xếp theo thứ tự giảm dần.

sigmas (`list[float]`, *optional*) : Các sigma tùy chỉnh để sử dụng cho quá trình khử nhiễu với các trình lập lịch hỗ trợ tham số `sigmas` trong phương thức `set_timesteps` của chúng. Nếu không được định nghĩa, hành vi mặc định khi `num_inference_steps` được truyền vào sẽ được sử dụng.

guidance_scale (`float`, *optional*, mặc định là 4.5) : Thang độ dẫn hướng như được định nghĩa trong [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` được định nghĩa là `w` của phương trình 2. trong [Imagen Paper](https://huggingface.co/papers/2205.11487). Thang độ dẫn hướng được kích hoạt bằng cách đặt `guidance_scale > 1`. Thang độ dẫn hướng cao hơn khuyến khích tạo ra các hình ảnh gắn kết chặt chẽ với `prompt` văn bản, thường phải đánh đổi bằng chất lượng hình ảnh thấp hơn.

num_images_per_prompt (`int`, *tuỳ chọn*, mặc định là 1) : Số lượng hình ảnh cần tạo cho mỗi prompt.

height (`int`, *tuỳ chọn*, mặc định là self.unet.config.sample_size) : Chiều cao của hình ảnh được tạo ra, tính bằng pixel.

width (`int`, *tuỳ chọn*, mặc định là self.unet.config.sample_size) : Độ rộng tính bằng pixel của hình ảnh được tạo ra.

eta (`float`, *optional*, mặc định là 0.0) : Tương ứng với tham số eta (η) trong bài báo DDIM: https://huggingface.co/papers/2010.02502. Chỉ áp dụng cho [schedulers.DDIMScheduler](/docs/diffusers/main/vi/api/schedulers/ddim#diffusers.DDIMScheduler), sẽ bị bỏ qua với các trình lập lịch khác.

generator (`torch.Generator` hoặc `list[torch.Generator]`, *tùy chọn*) : Một hoặc một danh sách [torch generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) để đảm bảo quá trình sinh là tất định.

latents (`torch.Tensor`, *tùy chọn*) : Các latents nhiễu đã được tạo trước, được lấy mẫu từ phân phối Gaussian, dùng làm đầu vào cho việc tạo ảnh. Có thể được sử dụng để tinh chỉnh cùng một quá trình tạo với các prompt khác nhau. Nếu không được cung cấp, một tensor latents sẽ được tạo ra bằng cách lấy mẫu sử dụng `generator` ngẫu nhiên được cung cấp.

prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`.

prompt_attention_mask (`torch.Tensor`, *tùy chọn*) : Mặt nạ chú ý (attention mask) được tạo trước cho các vector nhúng văn bản.

negative_prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản âm đã được tạo trước. Đối với PixArt-Alpha, prompt âm này nên là "". Nếu không được cung cấp, negative_prompt_embeds sẽ được tạo từ đối số đầu vào `negative_prompt`.

negative_prompt_attention_mask (`torch.Tensor`, *tùy chọn*) : Mặt nạ chú ý (attention mask) được tạo trước cho các vector nhúng văn bản âm.

output_type (`str`, *tùy chọn*, mặc định là `"pil"`) : Định dạng đầu ra của hình ảnh được tạo. Chọn giữa [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` hoặc `np.array`.

return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một `~pipelines.stable_diffusion.IFPipelineOutput` thay vì một tuple thông thường hay không.

callback (`Callable`, *tùy chọn*) : Một hàm sẽ được gọi mỗi `callback_steps` bước trong quá trình suy luận. Hàm sẽ được gọi với các đối số sau: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *optional*, mặc định là 1) : Tần suất mà hàm `callback` sẽ được gọi. Nếu không được chỉ định, callback sẽ được gọi ở mỗi bước.

clean_caption (`bool`, *tùy chọn*, mặc định là `True`) : Có dọn dẹp chú thích trước khi tạo embeddings hay không. Yêu cầu `beautifulsoup4` và `ftfy` phải được cài đặt. Nếu các phụ thuộc này không được cài đặt, embeddings sẽ được tạo từ prompt thô.

use_resolution_binning (`bool` mặc định là `True`) : Nếu được đặt thành `True`, chiều cao và chiều rộng yêu cầu sẽ được ánh xạ trước tiên đến các độ phân giải gần nhất bằng cách sử dụng `ASPECT_RATIO_1024_BIN`. Sau khi các latents được tạo ra được giải mã thành hình ảnh, chúng sẽ được thay đổi kích thước trở lại độ phân giải yêu cầu. Hữu ích cho việc tạo ra các hình ảnh không vuông.

max_sequence_length (`int` mặc định là 120) : Độ dài tối đa của chuỗi để sử dụng với `prompt`.

**Trả về:** [ImagePipelineOutput](/docs/diffusers/main/vi/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) hoặc `tuple`

Nếu `return_dict` là `True`, [ImagePipelineOutput](/docs/diffusers/main/vi/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) sẽ được trả về, ngược lại một `tuple` sẽ được trả về trong đó phần tử đầu tiên là một danh sách chứa các hình ảnh đã được tạo

Hàm được gọi khi gọi pipeline cho việc sinh.

Ví dụ:
```py
>>> import torch
>>> from diffusers import PixArtAlphaPipeline

>>> # You can replace the checkpoint id with "PixArt-alpha/PixArt-XL-2-512x512" too.
>>> pipe = PixArtAlphaPipeline.from_pretrained("PixArt-alpha/PixArt-XL-2-1024-MS", torch_dtype=torch.float16)
>>> # Enable memory optimizations.
>>> pipe.enable_model_cpu_offload()

>>> prompt = "A small cactus with a happy face in the Sahara desert."
>>> image = pipe(prompt).images[0]
```

#### encode_prompt[[diffusers.PixArtAlphaPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 120, **kwargs)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/pixart_alpha/pipeline_pixart_alpha.py#L303)

**Tham số:**

prompt (`str` hoặc `list[str]`, *tùy chọn*) : prompt cần được mã hóa

negative_prompt (`str` hoặc `list[str]`, *tùy chọn*) : Prompt không dùng để hướng dẫn tạo ảnh. Nếu không được định nghĩa, cần truyền `negative_prompt_embeds` thay thế. Bỏ qua khi không sử dụng guidance (tức là bỏ qua nếu `guidance_scale` nhỏ hơn `1`). Đối với PixArt-Alpha, giá trị này nên là "".

do_classifier_free_guidance (`bool`, *tùy chọn*, mặc định là `True`) : có sử dụng classifier free guidance hay không

num_images_per_prompt (`int`, *tùy chọn*, mặc định là 1) : số lượng hình ảnh cần được tạo cho mỗi prompt

device : (`torch.device`, *tùy chọn*): thiết bị torch để đặt các embedding kết quả lên

prompt_embeds (`torch.Tensor`, *tùy chọn*) : Các vector nhúng văn bản đã được tạo trước. Có thể được sử dụng để dễ dàng điều chỉnh các đầu vào văn bản, *vd.* trọng số prompt. Nếu không được cung cấp, các vector nhúng văn bản sẽ được tạo từ đối số đầu vào `prompt`.

negative_prompt_embeds (`torch.Tensor`, *tuỳ chọn*) : Các vector nhúng văn bản âm đã được tạo trước. Đối với PixArt-Alpha, đây nên là các vector nhúng của chuỗi "".

clean_caption (`bool`, mặc định là `False`) : Nếu `True`, hàm sẽ tiền xử lý và làm sạch chú thích được cung cấp trước khi mã hóa.

max_sequence_length (`int`, mặc định là 120) : Độ dài tối đa của chuỗi được sử dụng cho prompt.

Mã hóa prompt thành các trạng thái ẩn của text encoder.