hf-doc-build/doc / diffusers /main /pt /api /pipelines /sana.md

|

raw

33.1 kB

Licenciado sob a Apache License, Versão 2.0 (a "Licença");

você não pode usar este arquivo, exceto em conformidade com a Licença.

Você pode obter uma cópia da Licença em

http://www.apache.org/licenses/LICENSE-2.0

A menos que exigido pela lei aplicável ou acordado por escrito, o software

distribuído sob a Licença é distribuído em uma base "COMO ESTÁ",

SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas.

Consulte a Licença para o idioma específico que rege as permissões e

limitações sob a Licença. -->

SanaPipeline

SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers da NVIDIA e do MIT HAN Lab, por Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han.

O resumo do artigo é:

Apresentamos o Sana, um framework de texto para imagem capaz de gerar imagens com resolução de até 4096×4096 de forma eficiente. O Sana pode sintetizar imagens de alta resolução e alta qualidade, com forte alinhamento entre texto e imagem, a uma velocidade notavelmente rápida, sendo implantável em GPUs de notebook. Os principais designs incluem: (1) Autoencoder de compressão profunda: diferentemente dos AEs tradicionais, que comprimem imagens apenas 8×, treinamos um AE que pode comprimir imagens 32×, reduzindo efetivamente o número de tokens latentes. (2) Linear DiT: substituímos todo o vanilla attention no DiT por linear attention, que é mais eficiente em altas resoluções sem sacrificar a qualidade. (3) Text encoder apenas com decoder: substituímos o T5 por um pequeno LLM moderno apenas com decoder como text encoder e projetamos instruções humanas complexas com in-context learning para aprimorar o alinhamento entre imagem e texto. (4) Treinamento e amostragem eficientes: propomos o Flow-DPM-Solver para reduzir os passos de amostragem, com rotulagem e seleção de legendas eficientes para acelerar a convergência. Como resultado, o Sana-0.6B é muito competitivo em relação a modelos de difusão gigantes modernos (por exemplo, Flux-12B), sendo 20 vezes menor e mais de 100 vezes mais rápido em throughput medido. Além disso, o Sana-0.6B pode ser implantado em uma GPU de notebook de 16GB, levando menos de 1 segundo para gerar uma imagem com resolução de 1024×1024. O Sana permite a criação de conteúdo a baixo custo. O código e o modelo serão publicamente liberados.

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.

Este pipeline foi contribuído por lawrence-cj e chenjy2003. A base de código original pode ser encontrada aqui. Os pesos originais podem ser encontrados em hf.co/Efficient-Large-Model.

Modelos disponíveis:

Model	dtype recomendado
`Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers`	`torch.bfloat16`
`Efficient-Large-Model/Sana_1600M_1024px_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_1600M_1024px_MultiLing_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_1600M_512px_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_1600M_512px_MultiLing_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_600M_1024px_diffusers`	`torch.float16`
`Efficient-Large-Model/Sana_600M_512px_diffusers`	`torch.float16`

Consulte esta coleção para mais informações.

Nota: O dtype recomendado mencionado é para os pesos do transformer. Os pesos do codificador de texto e do VAE devem permanecer em torch.bfloat16 ou torch.float32 para que o modelo funcione corretamente. Consulte o exemplo de inferência abaixo para ver como carregar o modelo com o dtype recomendado.

Certifique-se de passar o argumento variant para checkpoints baixados a fim de usar menos espaço em disco. Defina-o como "fp16" para modelos com dtype recomendado como torch.float16 e como "bf16" para modelos com dtype recomendado como torch.bfloat16. Por padrão, pesos torch.float32 são baixados, o que usa o dobro do armazenamento em disco. Além disso, pesos torch.float32 podem ser convertidos para um tipo menor em tempo de execução ao especificar o argumento dtype. Leia sobre isso na documentação.

Quantização

A quantização ajuda a reduzir os requisitos de memória de modelos muito grandes armazenando os pesos do modelo em um tipo de dados de menor precisão. No entanto, a quantização pode ter um impacto variável na qualidade do vídeo, dependendo do modelo de vídeo.

Consulte a visão geral de Quantization para saber mais sobre os backends de quantização suportados e sobre como selecionar um backend de quantização que atenda ao seu caso de uso. O exemplo abaixo demonstra como carregar um SanaPipeline quantizado para inferência com bitsandbytes.

import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, SanaTransformer2DModel, SanaPipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, AutoModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = AutoModel.from_pretrained(
    "Efficient-Large-Model/Sana_1600M_1024px_diffusers",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = SanaTransformer2DModel.from_pretrained(
    "Efficient-Large-Model/Sana_1600M_1024px_diffusers",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = SanaPipeline.from_pretrained(
    "Efficient-Large-Model/Sana_1600M_1024px_diffusers",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "a tiny astronaut hatching from an egg on the moon"
image = pipeline(prompt).images[0]
image.save("sana.png")

SanaPipeline[[diffusers.SanaPipeline]]

diffusers.SanaPipeline[[diffusers.SanaPipeline]]

diffusers.SanaPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: DPMSolverMultistepScheduler)

Fonte

Pipeline para geração de texto para imagem usando Sana.

call[[diffusers.SanaPipeline.call]]

__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 = 1024, width: int = 1024, 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, clean_caption: bool = False, use_resolution_binning: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 300, complex_human_instruction: list[str] = ["Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.', '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', 'Here are examples of how to transform or refine prompts:', '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.', '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.', 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', 'User Prompt: '])

Fonte

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 20) : 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. 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 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) : 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: 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.

attention_kwargs : Um dicionário de kwargs que, se especificado, é passado para o AttentionProcessor definido em self.processor em diffusers.models.attention_processor.

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.

callback_on_step_end (Callable, opcional) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs incluirá uma lista de todos os tensores, conforme especificado por callback_on_step_end_tensor_inputs.

callback_on_step_end_tensor_inputs (list, opcional) : A lista de entradas de tensor para a função callback_on_step_end. Os tensores especificados na lista serão passados como argumento callback_kwargs. Você só poderá incluir variáveis listadas no atributo ._callback_tensor_inputs da sua classe de pipeline.

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

complex_human_instruction (list[str], opcional) : Instruções para atenção humana complexa: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55.

Retorna: SanaPipelineOutput ou tuple

Se return_dict for True, SanaPipelineOutput é 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 SanaPipeline

>>> pipe = SanaPipeline.from_pretrained(
...     "Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers", torch_dtype=torch.float32
... )
>>> pipe.to("cuda")
>>> pipe.text_encoder.to(torch.bfloat16)
>>> pipe.transformer = pipe.transformer.to(torch.bfloat16)

>>> image = pipe(prompt='a cyberpunk cat with a neon sign that says "Sana"')[0]
>>> image[0].save("output.png")

encode_prompt[[diffusers.SanaPipeline.encode_prompt]]

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, complex_human_instruction: list[str] | None = None, lora_scale: float | None = None)

Fonte

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 Sana, 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.

complex_human_instruction (list[str], padrão complex_human_instruction) : Se complex_human_instruction não estiver vazio, a função usará a instrução complexa do Humano para o prompt.

Codifica o prompt em estados ocultos do codificador de texto.

SanaPAGPipeline[[diffusers.SanaPAGPipeline]]

diffusers.SanaPAGPipeline[[diffusers.SanaPAGPipeline]]

diffusers.SanaPAGPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, pag_applied_layers: str | list[str] = 'transformer_blocks.0')

Fonte

Pipeline para geração de texto para imagem usando Sana. Este pipeline suporta o uso de Perturbed Attention Guidance (PAG).

call[[diffusers.SanaPAGPipeline.call]]

__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 = 1024, width: int = 1024, 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, clean_caption: bool = False, use_resolution_binning: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 300, complex_human_instruction: list[str] = ["Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for image generation. Evaluate the level of detail in the user prompt:", '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, and spatial relationships to create vivid and concrete scenes.', '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', 'Here are examples of how to transform or refine prompts:', '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat curled up in a round shape, sleeping peacefully on a warm sunny windowsill, surrounded by pots of blooming red flowers.', '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps, a diverse crowd of people in colorful clothing, and a double-decker bus passing by towering glass skyscrapers.', 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', 'User Prompt: '], pag_scale: float = 3.0, pag_adaptive_scale: float = 0.0)