# PixArt-Σ

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

[PixArt-Σ: Weak-to-Strong Training of Diffusion Transformer for 4K Text-to-Image Generation](https://huggingface.co/papers/2403.04692) 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:

*Dalam makalah ini, kami memperkenalkan PixArt-Σ, sebuah model Diffusion Transformer (DiT) yang mampu menghasilkan gambar langsung pada resolusi 4K. PixArt-Σ merupakan kemajuan signifikan dibandingkan pendahulunya, PixArt-α, dengan menawarkan gambar yang memiliki fidelitas jauh lebih tinggi dan keselarasan yang lebih baik dengan prompt teks. Salah satu fitur utama PixArt-Σ adalah efisiensi pelatihannya. Dengan memanfaatkan pra-pelatihan dasar dari PixArt-α, model ini berkembang dari baseline yang ‘lebih lemah’ menjadi model yang ‘lebih kuat’ melalui penggabungan data berkualitas lebih tinggi, sebuah proses yang kami sebut “weak-to-strong training”. Kemajuan pada PixArt-Σ bersifat dua arah: (1) Data Pelatihan Berkualitas Tinggi: PixArt-Σ mengintegrasikan data gambar dengan kualitas yang lebih unggul, yang dipasangkan dengan caption gambar yang lebih presisi dan detail. (2) Kompresi Token yang Efisien: kami mengusulkan modul perhatian baru dalam kerangka DiT yang mengompresi baik keys maupun values, sehingga secara signifikan meningkatkan efisiensi dan memfasilitasi generasi gambar beresolusi ultra-tinggi. Berkat peningkatan-peningkatan ini, PixArt-Σ mencapai kualitas gambar dan kemampuan kepatuhan terhadap prompt pengguna yang lebih unggul dengan ukuran model yang jauh lebih kecil (0,6B parameter) dibandingkan model difusi teks-ke-gambar yang ada, seperti SDXL (2,6B parameter) dan SD Cascade (5,1B parameter). Selain itu, kemampuan PixArt-Σ untuk menghasilkan gambar 4K mendukung pembuatan poster dan wallpaper beresolusi tinggi, yang secara efisien memperkuat produksi konten visual berkualitas tinggi di industri seperti film dan game.*

Anda dapat menemukan basis kode asli di [PixArt-alpha/PixArt-sigma](https://github.com/PixArt-alpha/PixArt-sigma) 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](https://hf.co/docs/transformers/model_doc/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-sigma/blob/master/diffusion/data/datasets/utils.py).
* Kualitasnya menyaingi sistem generasi teks-ke-gambar terkini (per penulisan ini) seperti PixArt-α, Stable Diffusion XL, Playground V2.0, dan DALL-E 3, sekaligus lebih efisien daripada sistem-sistem tersebut.
* Hal ini menunjukkan kemampuannya untuk menghasilkan gambar dengan resolusi sangat tinggi, seperti 2048px atau bahkan 4K.
* Hal ini menunjukkan bahwa model teks-ke-gambar dapat berkembang dari model yang lemah menjadi model yang lebih kuat melalui beberapa peningkatan (VAE, dataset, dan sebagainya.)

> [!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.

> [!TIP]
> Anda dapat meningkatkan kualitas generasi lebih lanjut dengan meneruskan gambar yang dihasilkan dari [PixArtSigmaPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) ke model [SDXL refiner](./stable_diffusion/stable_diffusion_xl#base-to-refiner-model).

## Inferensi dengan VRAM GPU di bawah 8GB

Jalankan [PixArtSigmaPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) 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 PixArtSigmaPipeline
import torch

text_encoder = T5EncoderModel.from_pretrained(
    "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS",
    subfolder="text_encoder",
    load_in_8bit=True,
    device_map="auto",
)
pipe = PixArtSigmaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-Sigma-XL-2-1024-MS",
    text_encoder=text_encoder,
    transformer=None,
    device_map="balanced"
)
```

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 = PixArtSigmaPipeline.from_pretrained(
    "PixArt-alpha/PixArt-Sigma-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 [PixArtSigmaPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) 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.

## PixArtSigmaPipeline[[diffusers.PixArtSigmaPipeline]]

#### diffusers.PixArtSigmaPipeline[[diffusers.PixArtSigmaPipeline]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pixart_alpha/pipeline_pixart_sigma.py#L185)

**Parameter:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/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/v0.43.0/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-Sigma-XL-2-1024-MS/blob/main/transformer/config.json#L2) dalam konfigurasi, tetapi ketidakcocokan tersebut dapat diabaikan.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/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-Sigma.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/v0.43.0/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.PixArtSigmaPipeline.__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 = 300, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pixart_alpha/pipeline_pixart_sigma.py#L631)

**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/v0.43.0/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-Sigma, prompt negatif ini harus "". 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 300) : Panjang maksimum urutan yang digunakan dengan `prompt`.

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

Jika `return_dict` adalah `True`, [ImagePipelineOutput](/docs/diffusers/v0.43.0/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 PixArtSigmaPipeline

>>> # You can replace the checkpoint id with "PixArt-alpha/PixArt-Sigma-XL-2-512-MS" too.
>>> pipe = PixArtSigmaPipeline.from_pretrained(
...     "PixArt-alpha/PixArt-Sigma-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.PixArtSigmaPipeline.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 = 300, **kwargs)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pixart_alpha/pipeline_pixart_sigma.py#L247)

**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 300) : Panjang maksimum urutan yang digunakan untuk prompt.

Mengkodekan prompt menjadi hidden states dari text encoder.