# 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) adalah karya Junsong Chen, Jincheng Yu, Chongjian Ge, Lewei Yao, Enze Xie, Yue Wu, Zhongdao Wang, James Kwok, Ping Luo, Huchuan Lu, dan Zhenguo Li.

Abstrak dari makalah tersebut adalah:

*Model text-to-image (T2I) paling canggih memerlukan biaya pelatihan yang signifikan (misalnya, jutaan jam GPU), yang sangat menghambat inovasi fundamental bagi komunitas AIGC sekaligus meningkatkan emisi CO2. Kertas ini memperkenalkan PIXART-α, model difusi T2I berbasis Transformer yang kualitas generasi gambarnya kompetitif dengan generator gambar state-of-the-art (misalnya, Imagen, SDXL, dan bahkan Midjourney), mencapai standar aplikasi komersial. Selain itu, model ini mendukung sintesis gambar resolusi tinggi hingga resolusi 1024px dengan biaya pelatihan rendah, seperti yang ditunjukkan pada Gambar 1 dan 2. Untuk mencapai tujuan ini, tiga desain inti diusulkan: (1) Dekomposisi strategi pelatihan: Kami merancang tiga langkah pelatihan yang berbeda yang mengoptimalkan dependensi piksel, keselarasan teks-gambar, dan kualitas estetika gambar secara terpisah; (2) T2I Transformer yang efisien: Kami mengintegrasikan modul cross-attention ke dalam Diffusion Transformer (DiT) untuk menyuntikkan kondisi teks dan menyederhanakan cabang class-condition yang intensif komputasi; (3) Data yang informatif tinggi: Kami menekankan pentingnya kepadatan konsep dalam pasangan teks-gambar dan memanfaatkan model Vision-Language besar untuk memberi label otomatis pada pseudo-caption yang padat guna membantu pembelajaran keselarasan teks-gambar. Akibatnya, kecepatan pelatihan PIXART-α jauh melampaui model T2I skala besar yang ada, misalnya, PIXART-α hanya membutuhkan 10,8% dari waktu pelatihan Stable Diffusion v1.5 (675 vs. 6.250 hari GPU A100), menghemat hampir $300.000 ($26.000 vs. $320.000) dan mengurangi emisi CO2 sebesar 90%. Selain itu, dibandingkan dengan model SOTA yang lebih besar, RAPHAEL, biaya pelatihan kami hanya 1%. Eksperimen ekstensif menunjukkan bahwa PIXART-α unggul dalam kualitas gambar, seni, dan kontrol semantik. Kami berharap PIXART-α akan memberikan wawasan baru bagi komunitas AIGC dan startup untuk mempercepat pembangunan model generatif berkualitas tinggi namun berbiaya rendah mereka sendiri dari nol.*

Anda dapat menemukan basis kode asli di [PixArt-alpha/PixArt-alpha](https://github.com/PixArt-alpha/PixArt-alpha) dan semua checkpoint yang tersedia di [PixArt-alpha](https://huggingface.co/PixArt-alpha).

Beberapa catatan tentang pipeline ini:

* Model ini menggunakan tulang punggung Transformer (bukan UNet) untuk denoising. Dengan demikian, arsitekturnya serupa dengan [DiT](./dit).
* Model ini dilatih menggunakan kondisi teks yang dihitung dari T5. Aspek ini membuat pipeline lebih baik dalam mengikuti prompt teks kompleks dengan detail yang rumit.
* Model ini sangat baik dalam menghasilkan gambar resolusi tinggi dengan berbagai rasio aspek. Untuk mendapatkan hasil terbaik, para penulis merekomendasikan beberapa rentang ukuran yang dapat ditemukan [di sini](https://github.com/PixArt-alpha/PixArt-alpha/blob/08fbbd281ec96866109bdd2cdb75f2f58fb17610/diffusion/data/datasets/utils.py).
* Kualitasnya menyaingi sistem generasi teks-ke-gambar terkini (per penulisan ini) seperti Stable Diffusion XL, Imagen, dan DALL-E 2, sekaligus lebih efisien daripada sistem-sistem tersebut.

> [!TIP]
> Pastikan untuk melihat [panduan](../../using-diffusers/schedulers) Schedulers untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta lihat bagian [reuse components across pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) untuk mempelajari cara memuat komponen yang sama secara efisien ke dalam beberapa pipeline.

## Inferensi dengan VRAM GPU di bawah 8GB

Jalankan [PixArtAlphaPipeline](/docs/diffusers/main/id/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) dengan VRAM GPU di bawah 8GB dengan memuat text encoder dalam presisi 8-bit. Mari kita lihat contoh lengkap.

Pertama, instal pustaka [bitsandbytes](https://github.com/TimDettmers/bitsandbytes):

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

Lalu muat text encoder dalam 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"
)
```

Sekarang, gunakan `pipe` untuk mengkodekan prompt:

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

Karena embedding teks telah dihitung, hapus `text_encoder` dan `pipe` dari memori, dan bebaskan sebagian VRAM GPU:

```python
import gc

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

del text_encoder
del pipe
flush()
```

Lalu hitung latents dengan prompt embeddings sebagai input:

```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]
> Perhatikan bahwa saat menginisialisasi `pipe`, Anda mengatur `text_encoder` menjadi `None` agar tidak dimuat.

Setelah latents dihitung, teruskan ke VAE untuk didekode menjadi gambar nyata:

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

Dengan menghapus komponen yang tidak Anda gunakan dan mengosongkan VRAM GPU, Anda seharusnya dapat menjalankan [PixArtAlphaPipeline](/docs/diffusers/main/id/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) dengan VRAM GPU di bawah 8GB.

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

Jika Anda ingin laporan penggunaan memori, jalankan [skrip](https://gist.github.com/sayakpaul/3ae0f847001d342af27018a96f467e4e) ini.

> [!WARNING]
> Embedding teks yang dihitung dalam 8-bit dapat memengaruhi kualitas gambar yang dihasilkan karena hilangnya informasi di ruang representasi yang disebabkan oleh presisi yang lebih rendah. Disarankan untuk membandingkan output dengan dan tanpa 8-bit.

Saat memuat `text_encoder`, Anda mengatur `load_in_8bit` ke `True`. Anda juga dapat menentukan `load_in_4bit` untuk menurunkan kebutuhan memori Anda lebih jauh hingga di bawah 7GB.

## PixArtAlphaPipeline[[diffusers.PixArtAlphaPipeline]]

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

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

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

**Parameter:**

vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.

text_encoder (`T5EncoderModel`) : Text-encoder yang dibekukan. PixArt-Alpha menggunakan [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), khususnya varian [t5-v1_1-xxl](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl).

tokenizer (`T5Tokenizer`) : Tokenizer dari kelas [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).

transformer ([PixArtTransformer2DModel](/docs/diffusers/main/id/api/models/pixart_transformer2d#diffusers.PixArtTransformer2DModel)) : `PixArtTransformer2DModel` yang dikondisikan teks untuk mendenois latens gambar yang telah dikodekan. Awalnya dipublikasikan sebagai [`Transformer2DModel`](https://huggingface.co/PixArt-alpha/PixArt-XL-2-1024-MS/blob/main/transformer/config.json#L2) dalam konfigurasi, tetapi ketidakcocokan tersebut dapat diabaikan.

scheduler ([SchedulerMixin](/docs/diffusers/main/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.

Pipeline untuk generasi teks-ke-gambar menggunakan PixArt-Alpha.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua pipeline (seperti mengunduh atau menyimpan, menjalankan pada perangkat tertentu, dll.)

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

```python
__call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 20, timesteps: list = None, sigmas: list = 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)
```

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

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus melewatkan `prompt_embeds` sebagai gantinya.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang tidak akan memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan guidance (yaitu, diabaikan jika `guidance_scale` kurang dari `1`).

num_inference_steps (`int`, *opsional*, default 100) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `timesteps` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan. Harus dalam urutan menurun.

sigmas (`list[float]`, *opsional*) : Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen `sigmas` di metode `set_timesteps` mereka. Jika tidak didefinisikan, perilaku default saat `num_inference_steps` diteruskan akan digunakan.

guidance_scale (`float`, *opsional*, default 4.5) : Skala panduan seperti yang didefinisikan dalam [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` didefinisikan sebagai `w` dari persamaan 2. pada [Imagen Paper](https://huggingface.co/papers/2205.11487). Skala panduan diaktifkan dengan mengatur `guidance_scale > 1`. Skala panduan yang lebih tinggi mendorong generasi gambar yang sangat terkait dengan `prompt` teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah.

num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.

height (`int`, *opsional*, defaultnya self.unet.config.sample_size) : Tinggi gambar yang dihasilkan dalam piksel.

width (`int`, *opsional*, defaultnya self.unet.config.sample_size) : Lebar gambar yang dihasilkan dalam piksel.

eta (`float`, *opsional*, default 0.0) : Bersesuaian dengan parameter eta (η) dalam paper DDIM: https://huggingface.co/papers/2010.02502. Hanya berlaku untuk [schedulers.DDIMScheduler](/docs/diffusers/main/id/api/schedulers/ddim#diffusers.DDIMScheduler), akan diabaikan untuk yang lain.

generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Satu atau daftar [generator torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat proses generasi menjadi deterministik.

latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya, diambil dari distribusi Gaussian, untuk digunakan sebagai input untuk generasi gambar. Dapat digunakan untuk menyesuaikan generasi yang sama dengan prompt yang berbeda. Jika tidak disediakan, tensor laten akan dibuat dengan pengambilan sampel menggunakan `generator` acak yang diberikan.

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.

prompt_attention_mask (`torch.Tensor`, *opsional*) : Mask perhatian yang telah dibuat sebelumnya untuk embedding teks.

negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Untuk PixArt-Alpha, prompt negatif ini seharusnya "". Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input `negative_prompt`.

negative_prompt_attention_mask (`torch.Tensor`, *opsional*) : Mask perhatian yang telah dibuat sebelumnya untuk embedding teks negatif.

output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari gambar yang dihasilkan. Pilih antara [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` atau `np.array`.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~pipelines.stable_diffusion.IFPipelineOutput` alih-alih tuple biasa.

callback (`Callable`, *opsional*) : Fungsi yang akan dipanggil setiap `callback_steps` langkah selama inferensi. Fungsi ini akan dipanggil dengan argumen berikut: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opsional*, default 1) : Frekuensi pemanggilan fungsi `callback`. Jika tidak ditentukan, callback akan dipanggil di setiap langkah.

clean_caption (`bool`, *opsional*, defaultnya `True`) : Apakah caption akan dibersihkan sebelum membuat embeddings. Memerlukan `beautifulsoup4` dan `ftfy` terpasang. Jika dependensi tidak terpasang, embeddings akan dibuat dari prompt mentah.

use_resolution_binning (`bool` defaultnya `True`) : Jika diset ke `True`, tinggi dan lebar yang diminta pertama kali dipetakan ke resolusi terdekat menggunakan `ASPECT_RATIO_1024_BIN`. Setelah latents yang dihasilkan didekode menjadi gambar, ukurannya dikembalikan ke resolusi yang diminta. Berguna untuk menghasilkan gambar yang tidak persegi.

max_sequence_length (`int` defaultnya 120) : Panjang maksimum urutan yang digunakan dengan `prompt`.

**Mengembalikan:** [ImagePipelineOutput](/docs/diffusers/main/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) atau `tuple`

Jika `return_dict` adalah `True`, [ImagePipelineOutput](/docs/diffusers/main/id/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) dikembalikan, selain itu sebuah `tuple` dikembalikan di mana elemen pertama adalah daftar dengan gambar yang dihasilkan

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:
```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)
```

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

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt yang tidak digunakan untuk memandu generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan `negative_prompt_embeds` sebagai gantinya. Diabaikan saat tidak menggunakan panduan (yaitu, diabaikan jika `guidance_scale` kurang dari `1`). Untuk PixArt-Alpha, ini harus berupa "".

do_classifier_free_guidance (`bool`, *opsional*, defaultnya `True`) : apakah akan menggunakan classifier free guidance atau tidak

num_images_per_prompt (`int`, *opsional*, default 1) : jumlah gambar yang harus dihasilkan per prompt

device : (`torch.device`, *opsional*): perangkat torch untuk menempatkan embedding yang dihasilkan

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Untuk PixArt-Alpha, ini seharusnya berupa embedding dari string "".

clean_caption (`bool`, defaultnya `False`) : Jika `True`, fungsi akan memproses pra dan membersihkan caption yang diberikan sebelum pengkodean.

max_sequence_length (`int`, defaultnya 120) : Panjang maksimum urutan yang digunakan untuk prompt.

Mengkodekan prompt menjadi hidden states dari text encoder.