#
# Bajo licencia Apache License, versión 2.0 (la "Licencia");
# no puede usar este archivo excepto en cumplimiento de la Licencia.
# Puede obtener una copia de la Licencia en
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que la ley aplicable lo exija o se haya acordado por escrito, el software
# distribuido bajo la Licencia se distribuye en una base "TAL CUAL",
# SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.
# Consulte la Licencia para el lenguaje específico que rige los permisos y
# limitaciones de la Licencia. -->

# PRX Pixel

PRXPixel es un modelo de generación de texto a imagen en el espacio de píxeles de Photoroom. Un `PRXTransformer2DModel` de ~7B desruidifica imágenes RGB crudas directamente, sin necesidad de un VAE. El modelo se condiciona con un codificador de texto Qwen3-VL y utiliza flow matching, donde el transformer predice la imagen limpia en cada paso (x-prediction). La resolución de generación se introduce en la modulación del timestep para que el modelo sea consciente del tamaño objetivo.

## Modelos disponibles

| Modelo | Resolución | Descripción | Parámetros sugeridos | dtype recomendado |
|:-----:|:---------:|:----------:|:----------:|:----------:|
| [`Photoroom/prxpixel-t2i`](https://huggingface.co/Photoroom/prxpixel-t2i) | 1024 | Modelo de espacio de píxeles ~7B con codificador de texto Qwen3-VL | 28 pasos, cfg=5.0 | `torch.bfloat16` |

## Carga del pipeline

[PRXPixelPipeline](/docs/diffusers/main/es/api/pipelines/prx_pixel#diffusers.PRXPixelPipeline) requiere `transformers >= 4.57` (la versión que introdujo `Qwen3VLTextModel`). Cargalo con [from_pretrained()](/docs/diffusers/main/es/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")
```

## Optimización de memoria

Para entornos con limitaciones de memoria:

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

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

**Parámetros:**

transformer (`PRXTransformer2DModel`) : El denoiser PRX de ~7B parámetros. Para PRXPixel, se construye con `in_channels=3`, un cuello de botella `img_in` y `resolution_embeds=True`, y se entrena para predecir la imagen limpia `x0`.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Programador de flow-matching utilizado para desruidar los latentes (en el espacio de píxeles).

text_encoder (`PreTrainedModel`) : El backbone de texto de Qwen3-VL utilizado para codificar los prompts (la torre de visión se descarta). Debe devolver un `last_hidden_state`.

tokenizer (`PreTrainedTokenizerBase`) : Tokenizador para `text_encoder` (generalmente cargado mediante `AutoTokenizer`).

default_sample_size (`int`, *opcional*, valor predeterminado 1024) : Altura/ancho predeterminados utilizados cuando no se proporciona ninguno a `__call__`.

prompt_max_tokens (`int`, *opcional*, valor predeterminado 256) : Número de tokens de texto a los que se rellena o trunca el prompt antes de codificarlo.

noise_scale (`float`, *opcional*, valor predeterminado 2.0) : Escala aplicada al ruido gaussiano inicial. PRXPixel se entrena con una escala de ruido inicial no unitaria, por lo que la muestreo debe comenzar desde `randn * noise_scale`.

Pipeline para la generación de imágenes a partir de texto con el modelo PRXPixel.

PRXPixel es una pipeline independiente de texto a imagen en el espacio de píxeles. Ruidifica directamente el RGB crudo con un `PRXTransformer2DModel` de ~7B parámetros y no tiene VAE (la generación ocurre por completo en el espacio de píxeles, por lo que la salida desruidada *es* la imagen). Los prompts se codifican con un codificador de texto Qwen3-VL (la torre de visión se descarta). A diferencia de [PRXPipeline](/docs/diffusers/main/es/api/pipelines/prx#diffusers.PRXPipeline), el transformer se entrena con x-predicción: en cada paso predice la imagen limpia `x0`, que se convierte en una velocidad de flow-matching antes del paso del scheduler. El muestreo comienza desde `randn * noise_scale` (`noise_scale=2.0` por defecto) y la resolución predeterminada es de 1024px.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.)

Ejemplos:
```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'])
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.

negative_prompt (`str`, *opcional*, valor predeterminado `""`) : El prompt o los prompts que no deben guiar la generación de la imagen. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

height (`int`, *opcional*, valor predeterminado `default_sample_size`) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*, valor predeterminado `default_sample_size`) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, *opcional*, valor predeterminado 28) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente.

guidance_scale (`float`, *opcional*, valor predeterminado 4.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan y `guidance_scale > 1`, se generarán embeddings negativos a partir de una cadena vacía.

prompt_attention_mask (`torch.BoolTensor`, *opcional*) : Máscara de atención pregenerada para `prompt_embeds`. Si no se proporciona, la máscara de atención se generará a partir del argumento de entrada `prompt`.

negative_prompt_attention_mask (`torch.BoolTensor`, *opcional*) : Máscara de atención pregenerada para `negative_prompt_embeds`. Si no se proporciona y `guidance_scale > 1`, la máscara de atención se generará a partir de una cadena vacía.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un [PRXPipelineOutput](/docs/diffusers/main/es/api/pipelines/prx#diffusers.pipelines.prx.PRXPipelineOutput) en lugar de una tupla simple.

use_resolution_binning (`bool`, *opcional*, valor predeterminado `True`) : Si se establece en `True`, la altura y el ancho solicitados se mapean primero a las resoluciones más cercanas utilizando bins de relación de aspecto predefinidos. Después de que los latentes generados se decodifican en imágenes, se redimensionan de nuevo a la resolución solicitada. Útil para generar imágenes no cuadradas en resoluciones óptimas.

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self, step, timestep, callback_kwargs)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir tensores que estén listados en el atributo `._callback_tensor_inputs`.

**Devuelve:** [PRXPipelineOutput](/docs/diffusers/main/es/api/pipelines/prx#diffusers.pipelines.prx.PRXPipelineOutput) o `tuple`

[PRXPipelineOutput](/docs/diffusers/main/es/api/pipelines/prx#diffusers.pipelines.prx.PRXPipelineOutput) si `return_dict` es True, de lo contrario una `tuple. Al devolver una tupla, el primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

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

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

Comprueba que todas las entradas estén en el formato correcto.

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

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

Codifica el prompt de texto usando el codificador y el tokenizador de texto estándar, o usa embeddings precalculados.

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

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

Prepara los latentes iniciales para el proceso de difusión.

PRXPixel se entrena con una escala de ruido inicial no unitaria, por lo que el ruido muestreado se multiplica por `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)
```

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

**Parámetros:**

images (`list[PIL.Image.Image]` o `np.ndarray`) : lista de imágenes PIL desruidas de longitud `batch_size` o matriz numpy de forma `(batch_size, height, width, num_channels)`. Las imágenes PIL o la matriz numpy presentan las imágenes desruidas del pipeline de difusión.

Clase de salida para las tuberías de PRX.