Hugging Face's logo

Diffusers documentation

PixArt-α

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

PixArt-α

PixArt-α: Fast Training of Diffusion Transformer for Photorealistic Text-to-Image Synthesis 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 dan semua checkpoint yang tersedia di PixArt-alpha.

Beberapa catatan tentang pipeline ini:

  • Model ini menggunakan tulang punggung Transformer (bukan UNet) untuk denoising. Dengan demikian, arsitekturnya serupa dengan 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.
  • 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.

Pastikan untuk melihat panduan Schedulers untuk mempelajari cara mengeksplorasi tradeoff antara kecepatan dan kualitas scheduler, serta lihat bagian reuse components across pipelines untuk mempelajari cara memuat komponen yang sama secara efisien ke dalam beberapa pipeline.

Inferensi dengan VRAM GPU di bawah 8GB

Jalankan PixArtAlphaPipeline dengan VRAM GPU di bawah 8GB dengan memuat text encoder dalam presisi 8-bit. Mari kita lihat contoh lengkap.

Pertama, instal pustaka bitsandbytes:

pip install -U bitsandbytes

Lalu muat text encoder dalam 8-bit:

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:

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:

import gc

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

del text_encoder
del pipe
flush()

Lalu hitung latents dengan prompt embeddings sebagai input:

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

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:

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 dengan VRAM GPU di bawah 8GB.

Jika Anda ingin laporan penggunaan memori, jalankan skrip ini.

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

kelas diffusers.PixArtAlphaPipeline

< >

( tokenizer: T5Tokenizertext_encoder: T5EncoderModelvae: AutoencoderKLtransformer: PixArtTransformer2DModelscheduler: DPMSolverMultistepScheduler )

Parameter

  • vae (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, khususnya varian t5-v1_1-xxl.
  • tokenizer (T5Tokenizer) — Tokenizer dari kelas T5Tokenizer.
  • transformer (PixArtTransformer2DModel) — PixArtTransformer2DModel yang dikondisikan teks untuk mendenois latens gambar yang terenkod. Awalnya dipublikasikan sebagai Transformer2DModel di config, tetapi ketidakcocokan ini dapat diabaikan.
  • scheduler (SchedulerMixin) — Scheduler 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. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua pipeline (seperti mengunduh atau menyimpan, menjalankan pada perangkat tertentu, dll.)

__call__

< >

( prompt: str | list[str] = Nonenegative_prompt: str = ''num_inference_steps: int = 20timesteps: list = Nonesigmas: list = Noneguidance_scale: float = 4.5num_images_per_prompt: int | None = 1height: int | None = Nonewidth: int | None = Noneeta: float = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecallback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = Nonecallback_steps: int = 1clean_caption: bool = Trueuse_resolution_binning: bool = Truemax_sequence_length: int = 120**kwargs ) → ImagePipelineOutput or tuple

Parameter

  • prompt (str atau list[str], opsional) — Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan prompt_embeds sebagai gantinya.
  • negative_prompt (str atau list[str], opsional) — Prompt atau prompt-prompt yang tidak digunakan untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan negative_prompt_embeds sebagai gantinya. Diabaikan jika 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 dilewatkan akan digunakan. Harus dalam urutan menurun.
  • sigmas (list[float], opsional) — Sigmas kustom untuk digunakan dalam proses denoising dengan scheduler yang mendukung argumen sigmas dalam 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. guidance_scale didefinisikan sebagai w dari persamaan 2. dari Imagen Paper. 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, akan diabaikan untuk yang lain.
  • generator (torch.Generator atau list[torch.Generator], opsional) — Satu atau daftar generator torch untuk membuat proses generasi menjadi deterministik.
  • latents (torch.Tensor, opsional) — Latents 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 latents 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 pembobotan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input prompt.
  • prompt_attention_mask (torch.Tensor, opsional) — Mask attention 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 harus berupa "". Jika tidak disediakan, negative_prompt_embeds akan dibuat dari argumen input negative_prompt.
  • negative_prompt_attention_mask (torch.Tensor, opsional) — Attention mask yang telah dibuat sebelumnya untuk embedding teks negatif.
  • output_type (str, opsional, defaultnya "pil") — Format output dari generate image. Pilih antara PIL: PIL.Image.Image atau np.array.
  • return_dict (bool, opsional, default 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, default True) — Apakah caption akan dibersihkan sebelum membuat embeddings. Memerlukan beautifulsoup4 dan ftfy untuk diinstal. Jika dependensi tidak diinstal, 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, ukuran gambar 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 atau tuple

Jika return_dict adalah True, 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:

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

< >

( prompt: str | list[str]do_classifier_free_guidance: bool = Truenegative_prompt: str = ''num_images_per_prompt: int = 1device: typing.Optional[torch.device] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Noneclean_caption: bool = Falsemax_sequence_length: int = 120**kwargs )

Parameter

  • prompt (str atau list[str], opsional) — prompt yang akan dienkod
  • negative_prompt (str atau list[str], opsional) — Prompt yang tidak digunakan untuk mengarahkan generasi gambar. Jika tidak didefinisikan, Anda harus meneruskan negative_prompt_embeds sebagai gantinya. Diabaikan jika tidak menggunakan guidance (yaitu, diabaikan jika guidance_scale kurang dari 1). Untuk PixArt-Alpha, ini harus berupa "".
  • do_classifier_free_guidance (bool, opsional, default 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 hasil
  • prompt_embeds (torch.Tensor, opsional) — Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, misalnya pembobotan 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 encoding.
  • max_sequence_length (int, defaultnya 120) — Panjang maksimum urutan yang digunakan untuk prompt.

Mengkodekan prompt menjadi hidden states dari text encoder.

Update on GitHub

←Pika H3 Flex PixArt-Σ→