# 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) es de Junsong Chen, Jincheng Yu, Chongjian Ge, Lewei Yao, Enze Xie, Yue Wu, Zhongdao Wang, James Kwok, Ping Luo, Huchuan Lu y Zhenguo Li.

El resumen del artículo es:

*En este artículo, presentamos PixArt-Σ, un modelo Diffusion Transformer (DiT) capaz de generar imágenes directamente a una resolución de 4K. PixArt-Σ representa un avance significativo con respecto a su predecesor, PixArt-α, ofreciendo imágenes de una fidelidad notablemente superior y una mejor alineación con los prompts de texto. Una característica clave de PixArt-Σ es su eficiencia en el entrenamiento. Aprovechando el pre-entrenamiento fundamental de PixArt-α, evoluciona desde la línea base “más débil” hasta un modelo “más fuerte” mediante la incorporación de datos de mayor calidad, un proceso al que denominamos “weak-to-strong training”. Los avances de PixArt-Σ son dobles: (1) Datos de entrenamiento de alta calidad: PixArt-Σ incorpora datos de imagen de calidad superior, emparejados con descripciones de imagen más precisas y detalladas. (2) Compresión eficiente de tokens: proponemos un módulo de atención novedoso dentro del marco DiT que comprime tanto las claves como los valores, mejorando significativamente la eficiencia y facilitando la generación de imágenes de ultra alta resolución. Gracias a estas mejoras, PixArt-Σ logra una calidad de imagen superior y una mayor capacidad de adherencia a los prompts del usuario, con un tamaño de modelo significativamente menor (0.6B parámetros) que los modelos de difusión de texto a imagen existentes, como SDXL (2.6B parámetros) y SD Cascade (5.1B parámetros). Además, la capacidad de PixArt-Σ para generar imágenes de 4K respalda la creación de pósters y fondos de pantalla de alta resolución, impulsando de manera eficiente la producción de contenido visual de alta calidad en industrias como el cine y los videojuegos.*

Puedes encontrar el código original en [PixArt-alpha/PixArt-sigma](https://github.com/PixArt-alpha/PixArt-sigma) y todos los puntos de control disponibles en [PixArt-alpha](https://huggingface.co/PixArt-alpha).

Algunas notas sobre este pipeline:

* Utiliza un backbone Transformer (en lugar de un UNet) para el desruido. En consecuencia, tiene una arquitectura similar a la de [DiT](https://hf.co/docs/transformers/model_doc/dit).
* Se entrenó utilizando condiciones de texto calculadas a partir de T5. Este aspecto hace que el pipeline sea más eficaz a la hora de seguir prompts de texto complejos con detalles intrincados.
* Es bueno para generar imágenes de alta resolución en diferentes relaciones de aspecto. Para obtener los mejores resultados, los autores recomiendan algunos rangos de tamaño que se pueden encontrar [aquí](https://github.com/PixArt-alpha/PixArt-sigma/blob/master/diffusion/data/datasets/utils.py).
* Su calidad es comparable a la de los sistemas de generación de texto a imagen más avanzados (a fecha de esta redacción), como PixArt-α, Stable Diffusion XL, Playground V2.0 y DALL-E 3, y además es más eficiente que ellos.
* Muestra la capacidad de generar imágenes de super alta resolución, como 2048px o incluso 4K.
* Muestra que los modelos de texto a imagen pueden evolucionar desde un modelo débil hasta uno más fuerte mediante varias mejoras (VAEs, conjuntos de datos, etc.).

> [!TIP]
> Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

> [!TIP]
> Puedes mejorar aún más la calidad de la generación pasando la imagen generada por [PixArtSigmaPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) al modelo [SDXL refiner](./stable_diffusion/stable_diffusion_xl#base-to-refiner-model).

## Inferencia con menos de 8 GB de VRAM en la GPU

Ejecuta el [PixArtSigmaPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) con menos de 8 GB de VRAM en la GPU cargando el codificador de texto en precisión de 8 bits. Veamos un ejemplo completo.

Primero, instala la biblioteca [bitsandbytes](https://github.com/TimDettmers/bitsandbytes):

```bash
pip install -U bitsandbytes
```

Luego, cargue el codificador de texto en 8 bits:

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

Ahora, usa `pipe` para codificar un prompt:

```python
with torch.no_grad():
    prompt = "cute cat"
    prompt_embeds, prompt_attention_mask, negative_embeds, negative_prompt_attention_mask = pipe.encode_prompt(prompt)
```

Dado que las incrustaciones de texto ya se han calculado, elimina `text_encoder` y `pipe` de la memoria y libera algo de VRAM de la GPU:

```python
import gc

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

del text_encoder
del pipe
flush()
```

Luego, calcule los latentes utilizando los embeddings del prompt como entradas:

```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]
> Tenga en cuenta que, al inicializar `pipe`, establece `text_encoder` en `None` para que no se cargue.

Una vez que se calculan los latentes, pásalos al VAE para decodificarlos en una imagen real:

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

Al eliminar los componentes que no estás utilizando y liberar la VRAM de la GPU, deberías poder ejecutar [PixArtSigmaPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) con menos de 8 GB de VRAM de GPU.

![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/pixart/8bits_cat.png)

Si deseas un informe de tu uso de memoria, ejecuta este [script](https://gist.github.com/sayakpaul/3ae0f847001d342af27018a96f467e4e).

> [!WARNING]
> Los embeddings de texto calculados en 8 bits pueden afectar la calidad de las imágenes generadas debido a la pérdida de información en el espacio de representación causada por la precisión reducida. Se recomienda comparar las salidas con y sin 8 bits.

Al cargar el `text_encoder`, estableces `load_in_8bit` en `True`. También podrías especificar `load_in_4bit` para reducir aún más los requisitos de memoria a menos de 7 GB.

## PixArtSigmaPipeline[[diffusers.PixArtSigmaPipeline]]

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

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

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

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.

text_encoder (`T5EncoderModel`) : Codificador de texto congelado. PixArt-Alpha utiliza [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [t5-v1_1-xxl](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl).

tokenizer (`T5Tokenizer`) : Tokenizador de la clase [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).

transformer ([PixArtTransformer2DModel](/docs/diffusers/v0.43.0/es/api/models/pixart_transformer2d#diffusers.PixArtTransformer2DModel)) : Un `PixArtTransformer2DModel` condicionado por texto para desruidar los latentes de imagen codificados. Inicialmente publicado como [`Transformer2DModel`](https://huggingface.co/PixArt-alpha/PixArt-Sigma-XL-2-1024-MS/blob/main/transformer/config.json#L2) en la configuración, pero la discrepancia puede ignorarse.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

Pipeline para la generación de imágenes a partir de texto usando PixArt-Sigma.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/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.)

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

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

**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` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

num_inference_steps (`int`, *opcional*, valor predeterminado 100) : 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.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.

guidance_scale (`float`, *opcional*, valor predeterminado 4.5) : 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.

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

width (`int`, *opcional*, predeterminado a self.unet.config.sample_size) : El ancho en píxeles de la imagen generada.

eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás.

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.Tensor`, *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`.

prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos.

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 devuelve un `~pipelines.stable_diffusion.IFPipelineOutput` en lugar de una tupla simple.

callback (`Callable`, *opcional*) : Una función que se llamará cada `callback_steps` pasos durante la inferencia. La función se llamará con los siguientes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, valor predeterminado 1) : La frecuencia con la que se llamará a la función `callback`. Si no se especifica, la callback se llamará en cada paso.

clean_caption (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe limpiar la descripción antes de crear los embeddings. Requiere que `beautifulsoup4` y `ftfy` estén instalados. Si las dependencias no están instaladas, los embeddings se crearán a partir del prompt sin procesar.

use_resolution_binning (`bool` por defecto `True`) : Si se establece en `True`, la altura y el ancho solicitados se mapean primero a las resoluciones más cercanas usando `ASPECT_RATIO_1024_BIN`. 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 que no son cuadradas.

max_sequence_length (`int` por defecto 300) : Longitud máxima de la secuencia a utilizar con el `prompt`.

**Devuelve:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple`

Si `return_dict` es `True`, se devuelve [ImagePipelineOutput](/docs/diffusers/v0.43.0/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput); en caso contrario, se devuelve una `tuple` cuyo 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 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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt que no debe guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). Para PixArt-Alpha, esto debería ser "".

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : si se debe usar classifier free guidance o no

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : número de imágenes que deben generarse por indicación

device : (`torch.device`, *opcional*): dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.Tensor`, *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.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados. Para PixArt-Alpha, deben ser los embeddings de la cadena "".

clean_caption (`bool`, por defecto `False`) : Si `True`, la función preprocesará y limpiará la descripción proporcionada antes de codificarla.

max_sequence_length (`int`, por defecto 300) : Longitud máxima de la secuencia a utilizar para el prompt.

Codifica el prompt en estados ocultos del codificador de texto.