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

PRXPixel adalah model generasi teks-ke-gambar di ruang piksel oleh Photoroom. `PRXTransformer2DModel` berukuran ~7B melakukan denoising pada gambar RGB mentah secara langsung — tidak diperlukan VAE. Model ini dikondisikan oleh encoder teks Qwen3-VL dan menggunakan flow matching, di mana transformer memprediksi gambar bersih pada setiap langkah (x-prediction). Resolusi generasi dimasukkan ke dalam modulasi timestep sehingga model menyadari ukuran target.

## Model yang tersedia

| Model | Resolusi | Deskripsi | Parameter yang disarankan | dtype yang direkomendasikan |
|:-----:|:---------:|:----------:|:----------:|:----------:|
| [`Photoroom/prxpixel-t2i`](https://huggingface.co/Photoroom/prxpixel-t2i) | 1024 | Model ruang piksel ~7B dengan pengkode teks Qwen3-VL | 28 langkah, cfg=5.0 | `torch.bfloat16` |

## Memuat pipeline

[PRXPixelPipeline](/docs/diffusers/main/id/api/pipelines/prx_pixel#diffusers.PRXPixelPipeline) membutuhkan `transformers >= 4.57` (versi yang memperkenalkan `Qwen3VLTextModel`). Muat dengan [from_pretrained()](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained):

```py
import torch
from diffusers import PRXPixelPipeline

pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

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

## Optimasi Memori

Untuk lingkungan dengan keterbatasan memori:

```py
import torch
from diffusers import PRXPixelPipeline

pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", dtype=torch.bfloat16)
pipe.enable_model_cpu_offload()

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

## PRXPixelPipeline[[diffusers.PRXPixelPipeline]]

#### diffusers.PRXPixelPipeline[[diffusers.PRXPixelPipeline]]

```python
diffusers.PRXPixelPipeline(transformer: PRXTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, text_encoder: PreTrainedModel, tokenizer: transformers.models.auto.tokenization_auto.AutoTokenizer | transformers.tokenization_utils_base.PreTrainedTokenizerBase, default_sample_size: int | None = 1024, prompt_max_tokens: int = 256, noise_scale: float = 2.0)
```

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

**Parameter:**

transformer (`PRXTransformer2DModel`) : Denoiser PRX dengan ~7B parameter. Untuk PRXPixel, model ini dibangun dengan `in_channels=3`, bottleneck `img_in`, dan `resolution_embeds=True`, serta dilatih untuk memprediksi gambar bersih `x0`.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Scheduler flow-matching yang digunakan untuk menghilangkan noise pada latents (ruang piksel).

text_encoder (`PreTrainedModel`) : Tulang punggung teks Qwen3-VL yang digunakan untuk mengkodekan prompt (menara visi dibuang). Harus mengembalikan `last_hidden_state`.

tokenizer (`PreTrainedTokenizerBase`) : Tokenizer untuk `text_encoder` (biasanya dimuat melalui `AutoTokenizer`).

default_sample_size (`int`, *opsional*, default 1024) : Tinggi/lebar default yang digunakan ketika tidak ada yang diberikan ke `__call__`.

prompt_max_tokens (`int`, *opsional*, default 256) : Jumlah token teks yang prompt di-pad/truncate ke nilai ini sebelum encoding.

noise_scale (`float`, *opsional*, default 2.0) : Skala yang diterapkan pada noise Gaussian awal. PRXPixel dilatih dengan skala noise awal yang tidak satu, sehingga sampling harus dimulai dari `randn * noise_scale`.

Pipeline untuk generasi teks-ke-gambar dengan model PRXPixel.

PRXPixel adalah pipeline teks-ke-gambar ruang piksel yang berdiri sendiri. Model ini melakukan denoising pada RGB mentah secara langsung dengan `PRXTransformer2DModel` berparameter ~7B dan tidak memiliki VAE (generasi terjadi sepenuhnya di ruang piksel, sehingga output hasil denoising *adalah* gambarnya). Prompt dikodekan dengan text encoder Qwen3-VL (vision tower dibuang). Berbeda dengan [PRXPipeline](/docs/diffusers/main/id/api/pipelines/prx#diffusers.PRXPipeline), transformer dilatih dengan x-prediction: pada setiap langkah, model memprediksi gambar bersih `x0`, yang kemudian dikonversi menjadi kecepatan flow-matching sebelum langkah scheduler. Sampling dimulai dari `randn * noise_scale` (dengan `noise_scale=2.0` secara default) dan resolusi default adalah 1024px.

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

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

>>> pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

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

#### __call__[[diffusers.PRXPixelPipeline.__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'])
```

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

**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`, *opsional*, defaultnya `default_sample_size`) : Tinggi gambar yang dihasilkan dalam piksel.

width (`int`, *opsional*, defaultnya `default_sample_size`) : Lebar gambar yang dihasilkan dalam piksel.

num_inference_steps (`int`, *opsional*, 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]`, *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.

guidance_scale (`float`, *opsional*, 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 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.

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 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 [PRXPipelineOutput](/docs/diffusers/main/id/api/pipelines/prx#diffusers.pipelines.prx.PRXPipelineOutput) alih-alih tuple biasa.

use_resolution_binning (`bool`, *opsional*, defaultnya `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`, *opsional*) : 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:** [PRXPipelineOutput](/docs/diffusers/main/id/api/pipelines/prx#diffusers.pipelines.prx.PRXPipelineOutput) atau `tuple`

[PRXPipelineOutput](/docs/diffusers/main/id/api/pipelines/prx#diffusers.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 PRXPixelPipeline

>>> pipe = PRXPixelPipeline.from_pretrained("Photoroom/prxpixel-t2i", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

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

#### check_inputs[[diffusers.PRXPixelPipeline.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_pixel.py#L324)

Periksa bahwa semua input berada dalam format yang benar.

#### encode_prompt[[diffusers.PRXPixelPipeline.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_pixel.py#L263)

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

#### prepare_latents[[diffusers.PRXPixelPipeline.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_pixel.py#L378)

Siapkan latens awal untuk proses difusi.

PRXPixel dilatih dengan skala noise awal yang tidak satu, sehingga noise yang disampelkan dikalikan dengan `self.config.noise_scale`.

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