Hugging Face's logo

Diffusers documentation

PixArt-Σ

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

PixArt-Σ

PixArt-Σ: Weak-to-Strong Training of Diffusion Transformer for 4K Text-to-Image Generation é 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 e todos os checkpoints disponíveis em 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.
  • 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.
  • 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.)

Certifique-se de consultar o guia 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 para aprender a carregar eficientemente os mesmos componentes em vários pipelines.

Você pode melhorar ainda mais a qualidade da geração passando a imagem gerada pelo PixArtSigmaPipeline para o modelo SDXL refiner.

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

Execute o 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:

pip install -U bitsandbytes

Em seguida, carregue o codificador de texto em 8 bits:

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:

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:

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:

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

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:

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 com menos de 8GB de VRAM de GPU.

Se você deseja um relatório do seu uso de memória, execute este script.

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

classe diffusers.PixArtSigmaPipeline

< >

( tokenizer: T5Tokenizertext_encoder: T5EncoderModelvae: AutoencoderKLtransformer: PixArtTransformer2DModelscheduler: KarrasDiffusionSchedulers )

Parâmetros

  • vae (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, especificamente a variante t5-v1_1-xxl.
  • tokenizer (T5Tokenizer) — Tokenizer da classe T5Tokenizer.
  • transformer (PixArtTransformer2DModel) — Um PixArtTransformer2DModel condicionado por texto para desruidar os latentes da imagem codificada. Inicialmente publicado como Transformer2DModel na configuração, mas a incompatibilidade pode ser ignorada.
  • scheduler (SchedulerMixin) — Um scheduler a 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. 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__

< >

( prompt: str | list[str] = Nonenegative_prompt: str = ''num_inference_steps: int = 20timesteps: list = Nonesigmas: list = Noneguidance_scale: float = 4.5num_images_per_prompt: int | None = 1height: int | None = Nonewidth: int | None = Noneeta: float = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Truecallback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = Nonecallback_steps: int = 1clean_caption: bool = Trueuse_resolution_binning: bool = Truemax_sequence_length: int = 300**kwargs ) → ImagePipelineOutput or tuple

Parâmetros

  • prompt (str ou list[str], opcional) — O prompt ou os prompts para orientar a geração da imagem. Se não for 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 for 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, à custa de uma inferência mais lenta.
  • timesteps (list[int], opcional) — Timesteps 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. guidance_scale é definido como w da equação 2 do Imagen Paper. 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 do DDIM: https://huggingface.co/papers/2010.02502. Aplica-se apenas a schedulers.DDIMScheduler, será ignorado para os demais.
  • generator (torch.Generator ou list[torch.Generator], opcional) — Um ou uma lista de geradores do torch 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) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas 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) — Incorporações de texto negativo pré-geradas. 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 negativos.
  • output_type (str, opcional, padrão "pil") — O formato de saída da imagem gerada. Escolha entre PIL: 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) — Indica se a legenda deve ser limpa 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 gerados 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 ou tuple

Se return_dict for True, ImagePipelineOutput é retornado; caso contrário, uma tuple é retornada, onde o primeiro elemento é uma lista com as imagens geradas

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

Exemplos:

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

< >

( prompt: str | list[str]do_classifier_free_guidance: bool = Truenegative_prompt: str = ''num_images_per_prompt: int = 1device: typing.Optional[torch.device] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Noneclean_caption: bool = Falsemax_sequence_length: int = 300**kwargs )

Parâmetros

  • prompt (str ou list[str], opcional) — prompt a ser codificado
  • negative_prompt (str ou list[str], opcional) — O prompt que não deve orientar a geração da imagem. Se não for 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). Para 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 em que os embeddings resultantes serão colocados
  • prompt_embeds (torch.Tensor, opcional) — Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidas, as incorporações de texto serão geradas a partir do argumento de entrada prompt.
  • negative_prompt_embeds (torch.Tensor, opcional) — Incorporações de texto negativo pré-geradas. Para o PixArt-Alpha, deve ser as incorporações da string "".
  • clean_caption (bool, padrão False) — Se True, a função pré-processa e limpa a legenda fornecida antes de codificá-la.
  • 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.

Update on GitHub

←PixArt-α PRX→