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

O resumo do artigo é:

*Os modelos mais avançados de texto para imagem (T2I) exigem custos de treinamento significativos (por exemplo, milhões de horas de GPU), o que prejudica seriamente a inovação fundamental para a comunidade de AIGC, ao mesmo tempo em que aumenta as emissões de CO2. Este artigo apresenta o PIXART-α, um modelo de difusão T2I baseado em Transformer cuja qualidade de geração de imagens é competitiva com geradores de imagens de última geração (por exemplo, Imagen, SDXL e até mesmo Midjourney), alcançando padrões próximos aos de aplicação comercial. Além disso, ele suporta a síntese de imagens em alta resolução, até 1024px, com baixo custo de treinamento, conforme mostrado nas Figuras 1 e 2. Para alcançar esse objetivo, são propostos três designs centrais: (1) Decomposição da estratégia de treinamento: Desenvolvemos três etapas de treinamento distintas que otimizam separadamente a dependência de pixels, o alinhamento texto-imagem e a qualidade estética da imagem; (2) T2I Transformer eficiente: Incorporamos módulos de atenção cruzada no Diffusion Transformer (DiT) para injetar condições de texto e simplificar o ramo de condição de classe, que é intensivo em computação; (3) Dados altamente informativos: Enfatizamos a importância da densidade de conceitos em pares de texto e imagem e utilizamos um grande modelo de Visão-Linguagem para rotular automaticamente pseudo-legendas densas, auxiliando no aprendizado do alinhamento texto-imagem. Como resultado, a velocidade de treinamento do PIXART-α supera marcadamente os modelos T2I de grande escala existentes; por exemplo, o PIXART-α leva apenas 10,8% do tempo de treinamento do Stable Diffusion v1.5 (675 vs. 6.250 dias de GPU A100), economizando quase US$ 300.000 (US$ 26.000 vs. US$ 320.000) e reduzindo as emissões de CO2 em 90%. Além disso, em comparação com um modelo SOTA maior, o RAPHAEL, nosso custo de treinamento é de apenas 1%. Experimentos extensos demonstram que o PIXART-α se destaca em qualidade de imagem, arte e controle semântico. Esperamos que o PIXART-α forneça novos insights para a comunidade de AIGC e startups, acelerando a construção de seus próprios modelos generativos de alta qualidade e baixo custo do zero.*

Você pode encontrar o código original em [PixArt-alpha/PixArt-alpha](https://github.com/PixArt-alpha/PixArt-alpha) e todos os checkpoints disponíveis em [PixArt-alpha](https://huggingface.co/PixArt-alpha).

Algumas observações sobre este pipeline:

* Ele usa um backbone Transformer (em vez de um UNet) para o desruído. Dessa forma, possui uma arquitetura semelhante à do [DiT](./dit).
* Ele foi treinado usando condições de texto calculadas a partir do T5. Esse aspecto torna o pipeline mais eficaz em seguir prompts de texto complexos com detalhes intrincados.
* Ele é bom em gerar imagens de alta resolução em diferentes proporções. Para obter os melhores resultados, os autores recomendam alguns intervalos de tamanho que podem ser encontrados [aqui](https://github.com/PixArt-alpha/PixArt-alpha/blob/08fbbd281ec96866109bdd2cdb75f2f58fb17610/diffusion/data/datasets/utils.py).
* Ele rivaliza com a qualidade dos sistemas de geração de texto para imagem mais avançados (até o momento desta redação), como Stable Diffusion XL, Imagen e DALL-E 2, sendo mais eficiente do que eles.

> [!TIP]
> Certifique-se de consultar o [guia](../../using-diffusers/schedulers) de Schedulers para aprender a explorar o compromisso entre a velocidade e a qualidade do scheduler, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines.

## Inferência com menos de 8 GB de VRAM na GPU

Execute o [PixArtAlphaPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) com menos de 8 GB de VRAM na GPU carregando o codificador de texto em precisão de 8 bits. Vamos passar por um exemplo completo.

Primeiro, instale a biblioteca [bitsandbytes](https://github.com/TimDettmers/bitsandbytes):

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

Em seguida, carregue o codificador de texto em 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"
)
```

Agora, use o `pipe` para codificar um prompt:

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

Como os embeddings de texto já foram calculados, remova o `text_encoder` e o `pipe` da memória e libere um pouco de VRAM da GPU:

```python
import gc

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

del text_encoder
del pipe
flush()
```

Em seguida, calcule os latentes usando os embeddings do 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]
> Observe que, ao inicializar `pipe`, você define `text_encoder` como `None` para que ele não seja carregado.

Uma vez que os latentes são calculados, passe-os para o VAE para decodificá-los em uma imagem 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")
```

Ao remover os componentes que você não está usando e liberar a VRAM da GPU, você deve ser capaz de executar o [PixArtAlphaPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/pixart#diffusers.PixArtAlphaPipeline) com menos de 8GB de VRAM de GPU.

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

Se você deseja um relatório do seu uso de memória, execute este [script](https://gist.github.com/sayakpaul/3ae0f847001d342af27018a96f467e4e).

> [!WARNING]
> Os embeddings de texto computados em 8 bits podem impactar a qualidade das imagens geradas devido à perda de informação no espaço de representação causada pela precisão reduzida. É recomendado comparar as saídas com e sem 8 bits.

Ao carregar o `text_encoder`, você define `load_in_8bit` como `True`. Você também pode especificar `load_in_4bit` para reduzir ainda mais os requisitos de memória para menos de 7GB.

## PixArtAlphaPipeline[[diffusers.PixArtAlphaPipeline]]

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

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

[Fonte](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/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

text_encoder (`T5EncoderModel`) : Codificador de texto congelado. O PixArt-Alpha usa [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), especificamente a variante [t5-v1_1-xxl](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl).

tokenizer (`T5Tokenizer`) : Tokenizer da classe [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).

transformer ([PixArtTransformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/pixart_transformer2d#diffusers.PixArtTransformer2DModel)) : Um `PixArtTransformer2DModel` condicionado por texto para desruidar os latentes da imagem codificada. Inicialmente publicado como [`Transformer2DModel`](https://huggingface.co/PixArt-alpha/PixArt-XL-2-1024-MS/blob/main/transformer/config.json#L2) na configuração, mas a incompatibilidade pode ser ignorada.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

Pipeline para geração de texto para imagem usando PixArt-Alpha.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos que a biblioteca implementa para todos os pipelines (como download ou salvamento, execução em um 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)
```

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

timesteps (`list[int]`, *opcional*) : Passos de tempo personalizados para usar no processo de remoção de ruído com agendadores que suportam um argumento `timesteps` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado. Deve estar em ordem decrescente.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar no processo de desruidamento com agendadores que suportam um argumento `sigmas` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado.

guidance_scale (`float`, *opcional*, padrão 4.5) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem.

num_images_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt.

height (`int`, *opcional*, padrão é self.unet.config.sample_size) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão é self.unet.config.sample_size) : A largura em pixels da imagem gerada.

eta (`float`, *opcional*, padrão 0.0) : Corresponde ao parâmetro eta (η) no paper DDIM: https://huggingface.co/papers/2010.02502. Aplica-se apenas a [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler), será ignorado para os demais.

generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um ou uma lista de [geradores do torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes será gerado por amostragem usando o `generator` aleatório fornecido.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.

prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atenção pré-gerada para embeddings de texto.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Para o PixArt-Alpha, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`.

negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atenção pré-gerada para embeddings de texto negativo.

output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada. Escolha entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` ou `np.array`.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~pipelines.stable_diffusion.IFPipelineOutput` em vez de uma tupla simples.

callback (`Callable`, *opcional*) : Uma função que será chamada a cada `callback_steps` etapas durante a inferência. A função será chamada com os seguintes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, padrão 1) : A frequência com que a função `callback` será chamada. Se não for especificada, o callback será chamado a cada etapa.

clean_caption (`bool`, *opcional*, padrão `True`) : Se deve ou não limpar a legenda antes de criar os embeddings. Exige que `beautifulsoup4` e `ftfy` estejam instalados. Se as dependências não estiverem instaladas, os embeddings serão criados a partir do prompt bruto.

use_resolution_binning (`bool` padrão é `True`) : Se definido como `True`, a altura e a largura solicitadas são primeiro mapeadas para as resoluções mais próximas usando `ASPECT_RATIO_1024_BIN`. Após os latentes produzidos serem decodificados em imagens, eles são redimensionados de volta para a resolução solicitada. Útil para gerar imagens não quadradas.

max_sequence_length (`int` padrão é 120) : Comprimento máximo da sequência a ser usado com o `prompt`.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

Se `return_dict` for `True`, [ImagePipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas

Função invocada ao chamar o pipeline para geração.

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

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

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt para não orientar a geração da imagem. Se não for definido, é necessário passar `negative_prompt_embeds` no lugar. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). Para o PixArt-Alpha, isso deve ser "".

do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : se deve ou não usar classifier free guidance

num_images_per_prompt (`int`, *opcional*, padrão 1) : número de imagens que devem ser geradas por prompt

device : (`torch.device`, *opcional*): dispositivo torch onde os embeddings resultantes serão colocados

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embebidings de texto negativo pré-gerados. Para o PixArt-Alpha, deve ser os embebidings da string "".

clean_caption (`bool`, padrão `False`) : Se `True`, a função pré-processará e limpará a legenda fornecida antes da codificação.

max_sequence_length (`int`, padrão 120) : Comprimento máximo da sequência a ser usado para o prompt.

Codifica o prompt em estados ocultos do codificador de texto.