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-α: Fast Training of Diffusion Transformer for Photorealistic Text-to-Image Synthesis é 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 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 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.

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.

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

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

pip install -U bitsandbytes

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

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:

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

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

PixArtAlphaPipeline

classe diffusers.PixArtAlphaPipeline

< >

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

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

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 = 120**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-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 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 120) — 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 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

< >

( 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 = 120**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 120) — 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

←Pika H3 Flex PixArt-Σ→