# PixArt-α

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

[PixArt-α: Fast Training of Diffusion Transformer for Photorealistic Text-to-Image Synthesis](https://huggingface.co/papers/2310.00426) 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:

*Los modelos de texto a imagen (T2I) más avanzados requieren costos de entrenamiento significativos (p. ej., millones de horas de GPU), lo que obstaculiza gravemente la innovación fundamental para la comunidad de AIGC y aumenta las emisiones de CO2. Este artículo presenta PIXART-α, un modelo de difusión T2I basado en Transformer cuya calidad de generación de imágenes es competitiva con los generadores de imágenes más avanzados (p. ej., Imagen, SDXL e incluso Midjourney), alcanzando estándares casi comerciales. Además, admite la síntesis de imágenes de alta resolución hasta 1024px con un bajo costo de entrenamiento, como se muestra en las Figuras 1 y 2. Para lograr este objetivo, se proponen tres diseños centrales: (1) Descomposición de la estrategia de entrenamiento: Diseñamos tres pasos de entrenamiento distintos que optimizan por separado la dependencia de píxeles, la alineación texto-imagen y la calidad estética de la imagen; (2) T2I Transformer eficiente: Incorporamos módulos de atención cruzada en Diffusion Transformer (DiT) para inyectar condiciones de texto y simplificar la rama de condición de clase intensiva en computación; (3) Datos de alta información: Destacamos la importancia de la densidad de conceptos en los pares texto-imagen y aprovechamos un gran modelo Vision-Language para etiquetar automáticamente descripciones pseudo-densas para asistir al aprendizaje de alineación texto-imagen. Como resultado, la velocidad de entrenamiento de PIXART-α supera notablemente a los modelos T2I a gran escala existentes, p. ej., PIXART-α solo toma el 10.8% del tiempo de entrenamiento de Stable Diffusion v1.5 (675 vs. 6,250 días de GPU A100), ahorrando casi $300,000 ($26,000 vs. $320,000) y reduciendo las emisiones de CO2 en un 90%. Además, en comparación con un modelo SOTA más grande, RAPHAEL, nuestro costo de entrenamiento es apenas del 1%. Experimentos extensos demuestran que PIXART-α destaca en calidad de imagen, arte y control semántico. Esperamos que PIXART-α proporcione nuevas perspectivas a la comunidad de AIGC y a las startups para acelerar la construcción de sus propios modelos generativos de alta calidad y bajo costo desde cero.*

Puedes encontrar el código original en [PixArt-alpha/PixArt-alpha](https://github.com/PixArt-alpha/PixArt-alpha) 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](./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-alpha/blob/08fbbd281ec96866109bdd2cdb75f2f58fb17610/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 Stable Diffusion XL, Imagen y DALL-E 2, y además es más eficiente que ellos.

> [!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.

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

Ejecuta el [PixArtAlphaPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) 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 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"
)
```

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

> [!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 [PixArtAlphaPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) 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.

## PixArtAlphaPipeline[[diffusers.PixArtAlphaPipeline]]

#### diffusers.PixArtAlphaPipeline[[diffusers.PixArtAlphaPipeline]]

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

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

**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-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-Alpha.

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.PixArtAlphaPipeline.__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 = 120, **kwargs)
```

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

**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-Alpha, 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 120) : 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 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[[diffusers.PixArtAlphaPipeline.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 = 120, **kwargs)
```

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

**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 120) : Longitud máxima de la secuencia a utilizar para el prompt.

Codifica el prompt en estados ocultos del codificador de texto.