# # 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](https://huggingface.co/papers/2410.10629) 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.* > [!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. Este pipeline foi contribuído por [lawrence-cj](https://github.com/lawrence-cj) e [chenjy2003](https://github.com/chenjy2003). A base de código original pode ser encontrada [aqui](https://github.com/NVlabs/Sana). Os pesos originais podem ser encontrados em [hf.co/Efficient-Large-Model](https://huggingface.co/Efficient-Large-Model). Modelos disponíveis: | Model | dtype recomendado | |:-----:|:-----------------:| | [`Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers) | `torch.bfloat16` | | [`Efficient-Large-Model/Sana_1600M_1024px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px_diffusers) | `torch.float16` | | [`Efficient-Large-Model/Sana_1600M_1024px_MultiLing_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_1024px_MultiLing_diffusers) | `torch.float16` | | [`Efficient-Large-Model/Sana_1600M_512px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_512px_diffusers) | `torch.float16` | | [`Efficient-Large-Model/Sana_1600M_512px_MultiLing_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_1600M_512px_MultiLing_diffusers) | `torch.float16` | | [`Efficient-Large-Model/Sana_600M_1024px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_600M_1024px_diffusers) | `torch.float16` | | [`Efficient-Large-Model/Sana_600M_512px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_600M_512px_diffusers) | `torch.float16` | Consulte esta [coleção](https://huggingface.co/collections/Efficient-Large-Model/sana-673efba2a57ed99843f11f9e) 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. > [!TIP] > 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](https://huggingface.co/docs/diffusers/v0.31.0/en/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained). ## 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](../../quantization/overview) 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](/docs/diffusers/v0.43.0/pt/api/pipelines/sana#diffusers.SanaPipeline) quantizado para inferência com bitsandbytes. ```py 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]] ```python diffusers.SanaPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: DPMSolverMultistepScheduler) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana/pipeline_sana.py#L189) Pipeline para geração de texto para imagem usando [Sana](https://huggingface.co/papers/2410.10629). #### __call__[[diffusers.SanaPipeline.__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 = 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana/pipeline_sana.py#L673) **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](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-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. attention_kwargs : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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](/docs/diffusers/v0.43.0/pt/api/pipelines/sana_sprint#diffusers.pipelines.sana.pipeline_output.SanaPipelineOutput) ou `tuple` Se `return_dict` for `True`, [SanaPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/sana_sprint#diffusers.pipelines.sana.pipeline_output.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: ```py >>> 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]] ```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, complex_human_instruction: list[str] | None = None, lora_scale: float | None = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana/pipeline_sana.py#L280) **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]] ```python diffusers.SanaPAGPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: AutoencoderDC, transformer: SanaTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, pag_applied_layers: str | list[str] = 'transformer_blocks.0') ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pag/pipeline_pag_sana.py#L147) Pipeline para geração de texto para imagem usando [Sana](https://huggingface.co/papers/2410.10629). Este pipeline suporta o uso de [Perturbed Attention Guidance (PAG)](https://huggingface.co/docs/diffusers/main/en/using-diffusers/pag). #### __call__[[diffusers.SanaPAGPipeline.__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 = 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pag/pipeline_pag_sana.py#L594) **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](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-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. 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. pag_scale (`float`, *opcional*, padrão 3.0) : O fator de escala para o guia de atenção perturbada. Se definido como 0.0, o guia de atenção perturbada não será utilizado. pag_adaptive_scale (`float`, *opcional*, padrão 0.0) : O fator de escala adaptativo para o guia de atenção perturbada. Se definido como 0.0, `pag_scale` é usado. **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 SanaPAGPipeline >>> pipe = SanaPAGPipeline.from_pretrained( ... "Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers", ... pag_applied_layers=["transformer_blocks.8"], ... 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.SanaPAGPipeline.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, complex_human_instruction: list[str] | None = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/pag/pipeline_pag_sana.py#L188) **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. ## SanaPipelineOutput[[diffusers.pipelines.sana.pipeline_output.SanaPipelineOutput]] #### diffusers.pipelines.sana.pipeline_output.SanaPipelineOutput[[diffusers.pipelines.sana.pipeline_output.SanaPipelineOutput]] ```python diffusers.pipelines.sana.pipeline_output.SanaPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/sana/pipeline_output.py#L10) **Parâmetros:** images (`list[PIL.Image.Image]` ou `np.ndarray`) : lista de imagens PIL desruidas de comprimento `batch_size` ou array numpy de forma `(batch_size, height, width, num_channels)`. As imagens PIL ou o array numpy apresentam as imagens desruidas do pipeline de difusão. Classe de saída para pipelines Sana.