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

# SANA-Sprint

  

[SANA-Sprint: One-Step Diffusion with Continuous-Time Consistency Distillation](https://huggingface.co/papers/2503.09641) da NVIDIA, MIT HAN Lab e Hugging Face, por Junsong Chen, Shuchen Xue, Yuyang Zhao, Jincheng Yu, Sayak Paul, Junyu Chen, Han Cai, Enze Xie, Song Han

O resumo do artigo é:

*Este artigo apresenta o SANA-Sprint, um modelo de difusão eficiente para geração ultra-rápida de texto para imagem (T2I). O SANA-Sprint é construído sobre um modelo de fundação pré-treinado e aprimorado com destilação híbrida, reduzindo drasticamente as etapas de inferência de 20 para 1-4. Introduzimos três inovações-chave: (1) Propomos uma abordagem sem treinamento que transforma um modelo de flow-matching pré-treinado para destilação de consistência em tempo contínuo (sCM), eliminando o treinamento custoso do zero e alcançando alta eficiência de treinamento. Nossa estratégia de destilação híbrida combina sCM com destilação adversarial latente (LADD): o sCM garante o alinhamento com o modelo professor, enquanto o LADD melhora a fidelidade da geração em uma única etapa. (2) O SANA-Sprint é um modelo unificado adaptativo de etapas que alcança geração de alta qualidade em 1-4 etapas, eliminando o treinamento específico de etapas e melhorando a eficiência. (3) Integramos o ControlNet com o SANA-Sprint para geração de imagens interativa em tempo real, permitindo feedback visual instantâneo para interação do usuário. O SANA-Sprint estabelece uma nova fronteira de Pareto em compromissos entre velocidade e qualidade, alcançando desempenho state-of-the-art com 7.59 FID e 0.74 GenEval em apenas 1 etapa — superando o FLUX-schnell (7.94 FID / 0.71 GenEval) enquanto é 10× mais rápido (0,1s vs 1,1s em H100). Ele também alcança latência de 0,1s (T2I) e 0,25s (ControlNet) para imagens de 1024×1024 em H100, e 0,31s (T2I) em uma RTX 4090, demonstrando sua eficiência excepcional e potencial para aplicações de consumo impulsionadas por IA (AIPC). O código e os modelos pré-treinados serão disponibilizados em código aberto.*

Este pipeline foi contribuído por [lawrence-cj](https://github.com/lawrence-cj), [shuchen Xue](https://github.com/scxue) e [Enze Xie](https://github.com/xieenze). 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_Sprint_1.6B_1024px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers) | `torch.bfloat16`  |
| [`Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers`](https://huggingface.co/Efficient-Large-Model/Sana_Sprint_0.6B_1024px_diffusers) | `torch.bfloat16`  |

Consulte esta [coleção](https://huggingface.co/collections/Efficient-Large-Model/sana-sprint-67d6810d65235085b3b17c76) para mais informações.

Nota: O dtype recomendado mencionado é para os pesos do transformer. O codificador de texto deve permanecer em `torch.bfloat16` e os pesos 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.

## 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 [SanaSprintPipeline](/docs/diffusers/main/pt/api/pipelines/sana_sprint#diffusers.SanaSprintPipeline) quantizado para inferência com bitsandbytes.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, SanaTransformer2DModel, SanaSprintPipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, AutoModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = AutoModel.from_pretrained(
    "Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.bfloat16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = SanaTransformer2DModel.from_pretrained(
    "Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.bfloat16,
)

pipeline = SanaSprintPipeline.from_pretrained(
    "Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.bfloat16,
    device_map="balanced",
)

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

## Definindo `max_timesteps`

Os usuários podem ajustar o valor de `max_timesteps` para experimentar a qualidade visual das saídas geradas. O valor padrão de `max_timesteps` foi obtido por meio de um processo de busca no tempo de inferência. Para mais detalhes sobre isso, consulte o paper.

## Imagem para Imagem 

O [SanaSprintImg2ImgPipeline](/docs/diffusers/main/pt/api/pipelines/sana_sprint#diffusers.SanaSprintImg2ImgPipeline) é um pipeline para geração de imagem a partir de imagem. Ele recebe uma imagem de entrada e um prompt e gera uma nova imagem com base na imagem de entrada e no prompt.

```py
import torch
from diffusers import SanaSprintImg2ImgPipeline
from diffusers.utils.loading_utils import load_image

image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/penguin.png"
)

pipe = SanaSprintImg2ImgPipeline.from_pretrained(
    "Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers", 
    dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = pipe(
    prompt="a cute pink bear", 
    image=image, 
    strength=0.5, 
    height=832, 
    width=480
).images[0]
image.save("output.png")
```

## SanaSprintPipeline[[diffusers.SanaSprintPipeline]]

#### diffusers.SanaSprintPipeline[[diffusers.SanaSprintPipeline]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana/pipeline_sana_sprint.py#L140)

Pipeline para geração de texto para imagem usando [SANA-Sprint](https://huggingface.co/papers/2503.09641).

#### __call__[[diffusers.SanaSprintPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, num_inference_steps: int = 2, timesteps: list[int] = None, max_timesteps: float = 1.5708, intermediate_timesteps: float = 1.3, 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, 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/main/src/diffusers/pipelines/sana/pipeline_sana_sprint.py#L561)

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

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.

max_timesteps (`float`, *opcional*, padrão 1.57080) : O valor máximo de timestep usado no agendador SCM.

intermediate_timesteps (`float`, *opcional*, padrão 1.3) : O valor do passo intermediário usado no agendador SCM (usado apenas quando num_inference_steps=2).

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.

guidance_scale (`float`, *opcional*, padrão 4.5) : A escala de orientação embutida é ativada ao definir `guidance_scale` > 1. Valores maiores de `guidance_scale` incentivam o modelo a gerar imagens mais alinhadas com o `prompt`, em detrimento de uma menor qualidade de imagem. Modelos destilados por orientação aproximam a orientação livre de classificador verdadeira para `guidance_scale` > 1. Consulte o [artigo](https://huggingface.co/papers/2210.03142) para saber mais.

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.

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/main/pt/api/pipelines/sana_sprint#diffusers.pipelines.sana.pipeline_output.SanaPipelineOutput) ou `tuple`

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

>>> pipe = SanaSprintPipeline.from_pretrained(
...     "Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")

>>> image = pipe(prompt="a tiny astronaut hatching from an egg on the moon")[0]
>>> image[0].save("output.png")
```

#### encode_prompt[[diffusers.SanaSprintPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, 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/main/src/diffusers/pipelines/sana/pipeline_sana_sprint.py#L232)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

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

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.

## SanaSprintImg2ImgPipeline[[diffusers.SanaSprintImg2ImgPipeline]]

#### diffusers.SanaSprintImg2ImgPipeline[[diffusers.SanaSprintImg2ImgPipeline]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana/pipeline_sana_sprint_img2img.py#L146)

Pipeline para geração de texto para imagem usando [SANA-Sprint](https://huggingface.co/papers/2503.09641).

#### __call__[[diffusers.SanaSprintImg2ImgPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, num_inference_steps: int = 2, timesteps: list[int] = None, max_timesteps: float = 1.5708, intermediate_timesteps: float = 1.3, guidance_scale: float = 4.5, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, strength: float = 0.6, 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, 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/main/src/diffusers/pipelines/sana/pipeline_sana_sprint_img2img.py#L629)

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

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.

max_timesteps (`float`, *opcional*, padrão 1.57080) : O valor máximo de timestep usado no agendador SCM.

intermediate_timesteps (`float`, *opcional*, padrão 1.3) : O valor do passo intermediário usado no agendador SCM (usado apenas quando num_inference_steps=2).

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.

guidance_scale (`float`, *opcional*, padrão 4.5) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://arxiv.org/pdf/2205.11487.pdf). 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.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image`, array numpy ou tensor representando um lote de imagens a ser usado como ponto de partida. Também pode aceitar latentes de imagem como `image`, mas, se latentes forem passados diretamente, eles não são codificados novamente.

strength (`float`, *opcional*, padrão 0.6) : Indica o grau de transformação da `image` de referência. Deve estar entre 0 e 1. `image` é usado como ponto de partida e mais ruído é adicionado quanto maior for o `strength`. O número de etapas de desruidamento depende da quantidade de ruído inicialmente adicionada. Quando `strength` é 1, o ruído adicionado é máximo e o processo de desruidamento executa pelo número total de iterações especificado em `num_inference_steps`. Um valor de 1 essencialmente ignora `image`.

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://arxiv.org/abs/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.

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/main/pt/api/pipelines/sana_sprint#diffusers.pipelines.sana.pipeline_output.SanaPipelineOutput) ou `tuple`

Se `return_dict` for `True`, [SanaPipelineOutput](/docs/diffusers/main/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 SanaSprintImg2ImgPipeline
>>> from diffusers.utils.loading_utils import load_image

>>> pipe = SanaSprintImg2ImgPipeline.from_pretrained(
...     "Efficient-Large-Model/Sana_Sprint_1.6B_1024px_diffusers", torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")

>>> image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/penguin.png"
... )

>>> image = pipe(prompt="a cute pink bear", image=image, strength=0.5, height=832, width=480).images[0]
>>> image[0].save("output.png")
```

#### encode_prompt[[diffusers.SanaSprintImg2ImgPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, 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/main/src/diffusers/pipelines/sana/pipeline_sana_sprint_img2img.py#L240)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado

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

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/main/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.