#
# Berlisensi di bawah Apache License, Versi 2.0 ("Lisensi");
# Anda mungkin tidak dapat menggunakan file ini kecuali sesuai dengan Lisensi.
# Anda dapat memperoleh salinan Lisensi di
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Kecuali diwajibkan oleh hukum yang berlaku atau disepakati secara tertulis, perangkat lunak
# distribusikan di bawah Lisensi berdasarkan basis "SEBAGAIMANA ADANYA",
# TANPA JAMINAN ATAU SYARAT DALAM BENTUK APAPUN, baik yang dinyatakan maupun yang tersirat.
# Lihat Lisensi untuk bahasa tertentu yang mengatur izin dan
# batasan di bawah Lisensi. -->

# PRX

PRX menghasilkan gambar berkualitas tinggi dari teks menggunakan arsitektur MMDIT yang disederhanakan, di mana token teks tidak diperbarui melalui blok transformer. Model ini menerapkan flow matching dengan penjadwalan diskrit untuk sampling yang efisien dan menggunakan model T5Gemma-2B-2B-UL2 dari Google untuk pengkodean teks multibahasa. Transformer dengan sekitar 1,3 miliar parameter ini memberikan inferensi cepat tanpa mengorbankan kualitas. Anda dapat memilih antara Flux VAE (kompresi 8x, 16 kanal laten) untuk keseimbangan kualitas dan kecepatan, atau DC-AE (kompresi 32x, 32 kanal laten) untuk kompresi laten dan pemrosesan yang lebih cepat.

## Model yang tersedia

PRX menawarkan beberapa varian dengan konfigurasi VAE yang berbeda, masing-masing dioptimalkan untuk resolusi tertentu. Model dasar unggul dengan prompt yang detail, menangkap komposisi kompleks dan detail halus. Model yang telah dihaluskan (fine-tuned) dan dilatih pada [Alchemist dataset](https://huggingface.co/datasets/yandex/alchemist) meningkatkan kualitas estetika, terutama dengan prompt yang lebih sederhana.

| Model | Resolusi | Disediakan | Distil | Deskripsi | Prompt yang disarankan | Parameter yang disarankan | dtype yang direkomendasikan |
|:-----:|:-----------------:|:----------:|:----------:|:----------:|:----------:|:----------:|:----------:|
| [`Photoroom/prx-256-t2i`](https://huggingface.co/Photoroom/prx-256-t2i)| 256 | Tidak | Tidak | Model dasar yang telah dilatih sebelumnya pada 256 dengan Flux VAE|Berfungsi paling baik dengan prompt detail dalam bahasa alami|28 langkah, cfg=5.0| `torch.bfloat16` |
| [`Photoroom/prx-256-t2i-sft`](https://huggingface.co/Photoroom/prx-256-t2i-sft)| 512 | Ya | Tidak | Dilatih ulang pada dataset [Alchemist dataset](https://huggingface.co/datasets/yandex/alchemist) dengan Flux VAE | Dapat menangani prompt yang kurang detail|28 langkah, cfg=5.0| `torch.bfloat16` |
| [`Photoroom/prx-512-t2i`](https://huggingface.co/Photoroom/prx-512-t2i)| 512 | Tidak | Tidak | Model dasar yang telah dilatih sebelumnya pada 512 dengan Flux VAE |Berfungsi paling baik dengan prompt detail dalam bahasa alami|28 langkah, cfg=5.0| `torch.bfloat16` |
| [`Photoroom/prx-512-t2i-sft`](https://huggingface.co/Photoroom/prx-512-t2i-sft)| 512 | Ya | Tidak | Dilatih ulang pada dataset [Alchemist dataset](https://huggingface.co/datasets/yandex/alchemist) dengan Flux VAE | Dapat menangani prompt yang kurang detail dalam bahasa alami|28 langkah, cfg=5.0| `torch.bfloat16` |
| [`Photoroom/prx-512-t2i-sft-distilled`](https://huggingface.co/Photoroom/prx-512-t2i-sft-distilled)| 512 | Ya | Ya | Model terdistil 8 langkah dari [`Photoroom/prx-512-t2i-sft`](https://huggingface.co/Photoroom/prx-512-t2i-sft) | Dapat menangani prompt yang kurang detail dalam bahasa alami|8 langkah, cfg=1.0| `torch.bfloat16` |
| [`Photoroom/prx-512-t2i-dc-ae`](https://huggingface.co/Photoroom/prx-512-t2i-dc-ae)| 512 | Tidak | Tidak | Model dasar yang telah dilatih sebelumnya pada 512 dengan [Deep Compression Autoencoder (DC-AE)](https://hanlab.mit.edu/projects/dc-ae)|Berfungsi paling baik dengan prompt detail dalam bahasa alami|28 langkah, cfg=5.0| `torch.bfloat16` |
| [`Photoroom/prx-512-t2i-dc-ae-sft`](https://huggingface.co/Photoroom/prx-512-t2i-dc-ae-sft)| 512 | Ya | Tidak | Dilatih ulang pada dataset [Alchemist dataset](https://huggingface.co/datasets/yandex/alchemist) dengan [Deep Compression Autoencoder (DC-AE)](https://hanlab.mit.edu/projects/dc-ae) | Dapat menangani prompt yang kurang detail dalam bahasa alami|28 langkah, cfg=5.0| `torch.bfloat16` |
| [`Photoroom/prx-512-t2i-dc-ae-sft-distilled`](https://huggingface.co/Photoroom/prx-512-t2i-dc-ae-sft-distilled)| 512 | Ya | Ya | Model terdistil 8 langkah dari [`Photoroom/prx-512-t2i-dc-ae-sft-distilled`](https://huggingface.co/Photoroom/prx-512-t2i-dc-ae-sft-distilled) | Dapat menangani prompt yang kurang detail dalam bahasa alami|8 langkah, cfg=1.0| `torch.bfloat16` |s

Lihat [koleksi ini](https://huggingface.co/collections/Photoroom/prx-models-68e66254c202ebfab99ad38e) untuk informasi lebih lanjut.

## Memuat pipeline

Muat pipeline dengan [from_pretrained()](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained).

```py
from diffusers.pipelines.prx import PRXPipeline

# Load pipeline - VAE and text encoder will be loaded from HuggingFace
pipe = PRXPipeline.from_pretrained("Photoroom/prx-512-t2i-sft", dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A front-facing portrait of a lion the golden savanna at sunset."
image = pipe(prompt, num_inference_steps=28, guidance_scale=5.0).images[0]
image.save("prx_output.png")
```

### Memuat Komponen Secara Manual

Muat komponen secara individual untuk menyesuaikan pipeline, misalnya untuk menggunakan model terkuantisasi.

```py
import torch
from diffusers.pipelines.prx import PRXPipeline
from diffusers.models import AutoencoderKL, AutoencoderDC
from diffusers.models.transformers.transformer_prx import PRXTransformer2DModel
from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
from transformers import T5GemmaModel, GemmaTokenizerFast
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig
from transformers import BitsAndBytesConfig as BitsAndBytesConfig

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
# Load transformer
transformer = PRXTransformer2DModel.from_pretrained(
    "checkpoints/prx-512-t2i-sft",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.bfloat16,
)

# Load scheduler
scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
    "checkpoints/prx-512-t2i-sft", subfolder="scheduler"
)

# Load T5Gemma text encoder
t5gemma_model = T5GemmaModel.from_pretrained("google/t5gemma-2b-2b-ul2",
                                            quantization_config=quant_config,
                                            dtype=torch.bfloat16)
text_encoder = t5gemma_model.encoder.to(dtype=torch.bfloat16)
tokenizer = GemmaTokenizerFast.from_pretrained("google/t5gemma-2b-2b-ul2")
tokenizer.model_max_length = 256

# Load VAE - choose either Flux VAE or DC-AE
# Flux VAE
vae = AutoencoderKL.from_pretrained("black-forest-labs/FLUX.1-dev",
                                    subfolder="vae",
                                    quantization_config=quant_config,
                                    dtype=torch.bfloat16)

pipe = PRXPipeline(
    transformer=transformer,
    scheduler=scheduler,
    text_encoder=text_encoder,
    tokenizer=tokenizer,
    vae=vae
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"
```

## Optimasi Memori

Untuk lingkungan dengan keterbatasan memori:

```py
import torch
from diffusers.pipelines.prx import PRXPipeline

pipe = PRXPipeline.from_pretrained("Photoroom/prx-512-t2i-sft", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()  # Offload components to CPU when not in use

# Or use sequential CPU offload for even lower memory
pipe.enable_sequential_cpu_offload()
```

## PRXPipeline[[diffusers.PRXPipeline]]

#### diffusers.PRXPipeline[[diffusers.PRXPipeline]]

```python
diffusers.PRXPipeline(transformer: PRXTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, text_encoder: T5GemmaEncoder, tokenizer: transformers.models.t5.tokenization_t5.T5Tokenizer | transformers.models.gemma.tokenization_gemma.GemmaTokenizer | transformers.models.auto.tokenization_auto.AutoTokenizer, vae: diffusers.models.autoencoders.autoencoder_kl.AutoencoderKL | diffusers.models.autoencoders.autoencoder_dc.AutoencoderDC | None = None, default_sample_size: int | None = 512)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/prx/pipeline_prx.py#L257)

**Parameter:**

transformer (`PRXTransformer2DModel`) : Model transformer PRX untuk menghilangkan noise pada latens gambar yang telah dikodekan.

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

text_encoder (`T5GemmaEncoder`) : Model pengkode teks untuk mengkodekan prompt.

tokenizer ([`T5TokenizerFast` atau `GemmaTokenizerFast`]) : Tokenizer untuk text encoder.

vae ([AutoencoderKL](/docs/diffusers/main/id/api/models/autoencoderkl#diffusers.AutoencoderKL) atau [AutoencoderDC](/docs/diffusers/main/id/api/models/autoencoder_dc#diffusers.AutoencoderDC)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten. Mendukung baik AutoencoderKL (kompresi 8x) maupun AutoencoderDC (kompresi 32x).

Pipeline untuk generasi teks-ke-gambar menggunakan PRX Transformer.

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.PRXPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str = '', height: int | None = None, width: int | None = None, num_inference_steps: int = 28, timesteps: list = None, guidance_scale: float = 4.0, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, prompt_attention_mask: typing.Optional[torch.BoolTensor] = None, negative_prompt_attention_mask: typing.Optional[torch.BoolTensor] = None, output_type: str | None = 'pil', return_dict: bool = True, use_resolution_binning: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], tokenizer_max_length: int | None = None, skip_text_cleaning: bool = False)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/prx/pipeline_prx.py#L554)

**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*, *opsional*, defaultnya *""*) : Prompt atau prompt-prompt yang tidak boleh memandu generasi gambar. Diabaikan saat tidak menggunakan panduan (yaitu, diabaikan jika *guidance_scale* kurang dari *1*).

height (*int*, *optional*, defaultnya self.transformer.config.sample_size * self.vae_scale_factor) : Tinggi gambar yang dihasilkan dalam piksel.

width (*int*, *optional*, defaultnya self.transformer.config.sample_size * self.vae_scale_factor) : Lebar gambar yang dihasilkan dalam piksel.

num_inference_steps (*int*, *optional*, defaultnya 28) : Jumlah langkah denoising. Semakin banyak langkah denoising, biasanya menghasilkan gambar dengan kualitas lebih tinggi, namun dengan biaya inferensi yang lebih lambat.

timesteps (*list[int]*, *optional*) : 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.

guidance_scale (*float*, *optional*, default 4.0) : 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 lebih erat kaitannya dengan *prompt* teks, biasanya dengan mengorbankan kualitas gambar yang lebih rendah.

num_images_per_prompt (*int*, *optional*, defaultnya 1) : Jumlah gambar yang akan dihasilkan per prompt.

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.FloatTensor*, *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.FloatTensor*, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan dan *guidance_scale > 1*, embedding negatif akan dibuat dari string kosong.

prompt_attention_mask (*torch.BoolTensor*, *opsional*) : Attention mask yang telah dibuat sebelumnya untuk *prompt_embeds*. Jika tidak disediakan, attention mask akan dibuat dari argumen input *prompt*.

negative_prompt_attention_mask (*torch.BoolTensor*, *opsional*) : Attention mask yang telah dibuat sebelumnya untuk *negative_prompt_embeds*. Jika tidak disediakan dan *guidance_scale > 1*, attention mask akan dibuat dari string kosong.

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

tokenizer_max_length (*int*, *opsional*) : Menimpa jumlah maksimum token yang digunakan saat melakukan tokenisasi prompt. Secara default menggunakan `model_max_length` milik tokenizer jika tidak diatur.

skip_text_cleaning (*bool*, *opsional*, default *False*) : Jika *True*, hanya menggunakan pembersihan prompt ringan (perbaikan encoding + unescape HTML) alih-alih pipeline pembersihan DeepFloyd penuh.

return_dict (*bool*, *opsional*, defaultnya *True*) : Apakah akan mengembalikan [*~pipelines.prx.PRXPipelineOutput*] atau sekadar tuple biasa.

use_resolution_binning (*bool*, *opsional*, default *True*) : Jika diset ke *True*, tinggi dan lebar yang diminta pertama kali dipetakan ke resolusi terdekat menggunakan bin rasio aspek yang predefined. Setelah latents yang dihasilkan didekode menjadi gambar, ukuran gambar dikembalikan ke resolusi yang diminta. Berguna untuk menghasilkan gambar non-persegi pada resolusi optimal.

callback_on_step_end (*Callable*, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising selama inferensi. Fungsi ini dipanggil dengan argumen berikut: *callback_on_step_end(self, step, timestep, callback_kwargs)*. *callback_kwargs* akan berisi daftar semua tensor sesuai yang ditentukan oleh *callback_on_step_end_tensor_inputs*.

callback_on_step_end_tensor_inputs (*list*, *optional*) : Daftar input tensor untuk fungsi *callback_on_step_end*. Tensor yang ditentukan dalam daftar akan diteruskan sebagai argumen *callback_kwargs*. Anda hanya dapat menyertakan tensor yang tercantum dalam atribut *._callback_tensor_inputs*.

**Mengembalikan:** [*~pipelines.prx.PRXPipelineOutput*] atau *tuple`

[*~pipelines.prx.PRXPipelineOutput*] jika *return_dict* bernilai True, selain itu berupa *tuple*. Saat mengembalikan tuple, elemen pertama adalah daftar berisi gambar yang dihasilkan.

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:
```py
>>> import torch
>>> from diffusers import PRXPipeline

>>> # Load pipeline with from_pretrained
>>> pipe = PRXPipeline.from_pretrained("Photoroom/prx-512-t2i-sft")
>>> pipe.to("cuda")

>>> prompt = "A digital painting of a rusty, vintage tram on a sandy beach"
>>> image = pipe(prompt, num_inference_steps=28, guidance_scale=5.0).images[0]
>>> image.save("prx_output.png")
```

#### check_inputs[[diffusers.PRXPipeline.check_inputs]]

```python
check_inputs(prompt: str | list[str], height: int, width: int, guidance_scale: float, callback_on_step_end_tensor_inputs: list[str] | None = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/prx/pipeline_prx.py#L500)

Periksa bahwa semua input berada dalam format yang benar.

#### encode_prompt[[diffusers.PRXPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, prompt_attention_mask: typing.Optional[torch.BoolTensor] = None, negative_prompt_attention_mask: typing.Optional[torch.BoolTensor] = None, tokenizer_max_length: int | None = None, skip_text_cleaning: bool = False)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/prx/pipeline_prx.py#L376)

Enkode prompt teks menggunakan encoder teks dan tokenizer standar, atau gunakan embedding yang sudah dihitung sebelumnya.

#### get_default_resolution[[diffusers.PRXPipeline.get_default_resolution]]

```python
get_default_resolution()
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/prx/pipeline_prx.py#L340)

**Mengembalikan:** `int`

Ukuran sampel (tinggi/lebar) default yang digunakan untuk generasi.

Tentukan resolusi default berdasarkan VAE dan config yang dimuat.

#### prepare_latents[[diffusers.PRXPipeline.prepare_latents]]

```python
prepare_latents(batch_size: int, num_channels_latents: int, height: int, width: int, dtype: dtype, device: device, generator: typing.Optional[torch.Generator] = None, latents: typing.Optional[torch.Tensor] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/prx/pipeline_prx.py#L352)

Siapkan latens awal untuk proses difusi.

## PRXPipelineOutput[[diffusers.pipelines.prx.PRXPipelineOutput]]

#### diffusers.pipelines.prx.PRXPipelineOutput[[diffusers.pipelines.prx.PRXPipelineOutput]]

```python
diffusers.pipelines.prx.PRXPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/prx/pipeline_output.py#L24)

**Parameter:**

images (`list[PIL.Image.Image]` atau `np.ndarray`) : daftar gambar PIL yang telah didenois dengan panjang `batch_size` atau array numpy dengan bentuk `(batch_size, height, width, num_channels)`. Gambar PIL atau array numpy menyajikan gambar-gambar yang telah didenois dari pipeline difusi.

Kelas output untuk pipeline PRX.