# 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) é 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 é:

*Neste artigo, apresentamos o PixArt-Σ, um modelo Diffusion Transformer (DiT) capaz de gerar imagens diretamente em resolução 4K. O PixArt-Σ representa um avanço significativo em relação ao seu antecessor, o PixArt-α, oferecendo imagens com fidelidade notavelmente superior e melhor alinhamento com os prompts de texto. Um recurso-chave do PixArt-Σ é a eficiência do seu treinamento. Aproveitando o pré-treinamento fundamental do PixArt-α, ele evolui da linha de base “mais fraca” para um modelo “mais forte” por meio da incorporação de dados de maior qualidade, um processo que denominamos “treinamento de fraco para forte”. Os avanços no PixArt-Σ são duplos: (1) Dados de Treinamento de Alta Qualidade: o PixArt-Σ incorpora dados de imagem de qualidade superior, acompanhados de legendas de imagem mais precisas e detalhadas. (2) Compressão Eficiente de Tokens: propomos um novo módulo de atenção dentro da estrutura DiT que comprime tanto as chaves quanto os valores, melhorando significativamente a eficiência e facilitando a geração de imagens em ultra-alta resolução. Graças a essas melhorias, o PixArt-Σ atinge qualidade de imagem superior e capacidade de aderência aos prompts do usuário com um tamanho de modelo significativamente menor (0,6B parâmetros) do que os modelos de difusão de texto para imagem existentes, como o SDXL (2,6B parâmetros) e o SD Cascade (5,1B parâmetros). Além disso, a capacidade do PixArt-Σ de gerar imagens 4K suporta a criação de pôsteres e papéis de parede em alta resolução, fortalecendo eficientemente a produção de conteúdo visual de alta qualidade em indústrias como cinema e jogos.*

Você pode encontrar o código original em [PixArt-alpha/PixArt-sigma](https://github.com/PixArt-alpha/PixArt-sigma) 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](https://hf.co/docs/transformers/model_doc/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-sigma/blob/master/diffusion/data/datasets/utils.py).
* Ele rivaliza com a qualidade de sistemas de geração de texto para imagem de última geração (até o momento desta redação), como PixArt-α, Stable Diffusion XL, Playground V2.0 e DALL-E 3, sendo mais eficiente do que eles.
* Mostra a capacidade de gerar imagens com resolução extremamente alta, como 2048px ou até mesmo 4K.
* Isso mostra que os modelos de texto para imagem podem evoluir de um modelo fraco para um mais forte por meio de várias melhorias (VAEs, conjuntos de dados, etc.)

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

> [!TIP]
> Você pode melhorar ainda mais a qualidade da geração passando a imagem gerada pelo [PixArtSigmaPipeline](/docs/diffusers/main/pt/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) para o modelo [SDXL refiner](./stable_diffusion/stable_diffusion_xl#base-to-refiner-model).

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

Execute o [PixArtSigmaPipeline](/docs/diffusers/main/pt/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) 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 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"
)
```

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 = 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]
> 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 [PixArtSigmaPipeline](/docs/diffusers/main/pt/api/pipelines/pixart_sigma#diffusers.PixArtSigmaPipeline) 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.

## PixArtSigmaPipeline[[diffusers.PixArtSigmaPipeline]]

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

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

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

**Parâmetros:**

vae ([AutoencoderKL](/docs/diffusers/main/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/main/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-Sigma-XL-2-1024-MS/blob/main/transformer/config.json#L2) na configuração, mas a incompatibilidade pode ser ignorada.

scheduler ([SchedulerMixin](/docs/diffusers/main/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-Sigma.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.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)
```

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

**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/main/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-Sigma, 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 é 300) : Comprimento máximo da sequência a ser usado com o `prompt`.

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

Se `return_dict` for `True`, [ImagePipelineOutput](/docs/diffusers/main/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 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)
```

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

**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 300) : Comprimento máximo da sequência a ser usado para o prompt.

Codifica o prompt em estados ocultos do codificador de texto.