diffusers/main/pt/api/pipelines/stable_diffusion/latent_upscale.md

Upscaler latente

O modelo de upscaler latente do Stable Diffusion foi criado por Katherine Crowson em colaboração com a Stability AI. Ele é usado para aprimorar a resolução da imagem de saída por um fator de 2 (veja este notebook para uma demonstração da implementação original).

Certifique-se de conferir a seção Dicas do Stable Diffusion para aprender como explorar o equilíbrio entre a velocidade e a qualidade do agendador, e como reutilizar os componentes do pipeline de forma eficiente!

Se você tem interesse em usar um dos checkpoints oficiais para uma tarefa, explore as organizações CompVis e Stability AI no Hub!

StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

diffusers.StableDiffusionLatentUpscalePipeline[[diffusers.StableDiffusionLatentUpscalePipeline]]

diffusers.StableDiffusionLatentUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: EulerDiscreteScheduler)

Fonte

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 (CLIPTextModel) : Codificador de texto congelado (clip-vit-large-patch14).

tokenizer (CLIPTokenizer) : Um CLIPTokenizer para tokenizar texto.

unet (UNet2DConditionModel) : Um UNet2DConditionModel para desruidar os latentes da imagem codificada.

scheduler (SchedulerMixin) : Um EulerDiscreteScheduler a ser usado em combinação com unet para desruidar os latentes da imagem codificada.

Pipeline para aumentar a resolução da imagem de saída do Stable Diffusion por um fator de 2.

Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

O pipeline também herda os seguintes métodos de carregamento:

• para carregar arquivos .ckpt com from_single_file()

call[[diffusers.StableDiffusionLatentUpscalePipeline.call]]

__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, num_inference_steps: int = 75, guidance_scale: float = 9.0, negative_prompt: str | list[str] | None = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1)

Fonte

Parâmetros:

prompt (str ou list[str]) : O prompt ou os prompts para orientar o aumento de escala da imagem.

image (torch.Tensor, PIL.Image.Image, np.ndarray, list[torch.Tensor], list[PIL.Image.Image] ou list[np.ndarray]) : Image ou tensor representando um lote de imagens a ser ampliado. Se for um tensor, pode ser uma saída latente de um modelo Stable Diffusion ou um tensor de imagem no intervalo [-1, 1]. É considerado latent se image.shape[1] for 4; caso contrário, é considerado uma representação de imagem e codificado usando o codificador vae deste pipeline.

num_inference_steps (int, opcional, padrão 50) : O número de etapas de desruidamento. Mais etapas de desruidamento geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

guidance_scale (float, opcional, padrão 7.5) : Um valor mais alto de guidance scale incentiva o modelo a gerar imagens fortemente ligadas ao prompt de texto, em detrimento de uma menor qualidade de imagem. O guidance scale é ativado quando guidance_scale > 1.

negative_prompt (str ou list[str], opcional) : O prompt ou os prompts para orientar o que não incluir na geração de imagem. Se não definido, você precisa passar negative_prompt_embeds em vez disso. Ignorado quando não está usando orientação (guidance_scale < 1).

generator (torch.Generator ou list[torch.Generator], opcional) : Um torch.Generator 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 é 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 (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, negative_prompt_embeds são gerados a partir do argumento de entrada negative_prompt.

pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto agrupados pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto (ponderação do prompt). Se não for fornecido, os embeddings de texto agrupados são gerados a partir do argumento de entrada prompt.

negative_pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativo pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto (ponderação do prompt). Se não for fornecido, os negative_prompt_embeds são gerados a partir do argumento de entrada negative_prompt.

output_type (str, opcional, padrão "pil") : O formato de saída da imagem gerada. Escolha entre PIL.Image ou np.array.

return_dict (bool, opcional, padrão True) : Se deve ou não retornar um StableDiffusionPipelineOutput em vez de uma tupla simples.

callback (Callable, opcional) : Uma função que é chamada a cada callback_steps etapas durante a inferência. A função é 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 é chamada. Se não for especificada, o callback é chamado a cada etapa.

Retorna: StableDiffusionPipelineOutput ou tuple

Se return_dict for True, StableDiffusionPipelineOutput é retornado; caso contrário, uma tuple é retornada, em que o primeiro elemento é uma lista com as imagens geradas.

A função de chamada do pipeline para geração.

Exemplos:

>>> from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionPipeline
>>> import torch

>>> pipeline = StableDiffusionPipeline.from_pretrained(
...     "CompVis/stable-diffusion-v1-4", torch_dtype=torch.float16
... )
>>> pipeline.to("cuda")

>>> model_id = "stabilityai/sd-x2-latent-upscaler"
>>> upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
>>> upscaler.to("cuda")

>>> prompt = "a photo of an astronaut high resolution, unreal engine, ultra realistic"
>>> generator = torch.manual_seed(33)

>>> low_res_latents = pipeline(prompt, generator=generator, output_type="latent").images

>>> with torch.no_grad():
...     image = pipeline.decode_latents(low_res_latents)
>>> image = pipeline.numpy_to_pil(image)[0]

>>> image.save("../images/a1.png")

>>> upscaled_image = upscaler(
...     prompt=prompt,
...     image=low_res_latents,
...     num_inference_steps=20,
...     guidance_scale=0,
...     generator=generator,
... ).images[0]

>>> upscaled_image.save("../images/a2.png")

enable_sequential_cpu_offload[[diffusers.StableDiffusionLatentUpscalePipeline.enable_sequential_cpu_offload]]

enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)

Fonte

Parâmetros:

gpu_id (int, opcional) : O ID do acelerador que deve ser usado na inferência. Se não for especificado, o valor padrão será 0.

device (torch.Device ou str, opcional, padrão None) : O tipo de dispositivo PyTorch do acelerador que deve ser usado na inferência. Se não for especificado, ele detectará automaticamente o acelerador disponível e o usará.

Desloca todos os modelos para a CPU usando 🤗 Accelerate, reduzindo significativamente o uso de memória. Quando chamado, os state dicts de todos os componentes torch.nn.Module (exceto aqueles em self._exclude_from_cpu_offload) são salvos na CPU e então movidos para torch.device('meta') e carregados no acelerador apenas quando o método forward do submódulo específico é chamado. O offloading ocorre em nível de submódulo. As economias de memória são maiores do que com enable_model_cpu_offload, mas o desempenho é menor.

enable_attention_slicing[[diffusers.StableDiffusionLatentUpscalePipeline.enable_attention_slicing]]

enable_attention_slicing(slice_size: str | int = 'auto')

Fonte

Parâmetros:

slice_size (str ou int, opcional, padrão "auto") : Quando "auto", divide a entrada dos cabeçalhos de atenção pela metade, de modo que a atenção será calculada em duas etapas. Se "max", a quantidade máxima de memória será economizada executando apenas uma fatia por vez. Se um número for fornecido, usa tantas fatias quanto attention_head_dim // slice_size. Nesse caso, attention_head_dim deve ser um múltiplo de slice_size.

Ativa o cálculo de atenção fatiado. Quando esta opção está ativada, o módulo de atenção divide o tensor de entrada em fatias para calcular a atenção em várias etapas. Para mais de uma cabeça de atenção, o cálculo é executado sequencialmente em cada cabeça. Isso é útil para economizar memória em troca de uma pequena diminuição na velocidade.

> ⚠️ Não ative o fatiamento de atenção se você já estiver usando scaled_dot_product_attention (SDPA) do PyTorch > 2.0 ou xFormers. Esses cálculos de atenção já são muito eficientes em termos de memória, portanto, você não precisará habilitar > esta função. Se você habilitar o fatiamento de atenção com SDPA ou xFormers, isso pode levar a uma desaceleração significativa!

Exemplos:

>>> import torch
>>> from diffusers import StableDiffusionPipeline

>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5",
...     dtype=torch.float16,
...     use_safetensors=True,
... )

>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> pipe.enable_attention_slicing()
>>> image = pipe(prompt).images[0]

disable_attention_slicing[[diffusers.StableDiffusionLatentUpscalePipeline.disable_attention_slicing]]

disable_attention_slicing()

Fonte

Desativa o cálculo de atenção fatiado. Se enable_attention_slicing foi chamado anteriormente, a atenção é calculada em uma única etapa.

enable_xformers_memory_efficient_attention[[diffusers.StableDiffusionLatentUpscalePipeline.enable_xformers_memory_efficient_attention]]

enable_xformers_memory_efficient_attention(attention_op: typing.Optional[typing.Callable] = None)

Fonte

Parâmetros:

attention_op (Callable, opcional) : Substitui o operador padrão None para uso como argumento op da função memory_efficient_attention() do xFormers.

Ative a atenção eficiente em memória do xFormers. Quando essa opção estiver ativada, você deve observar um menor uso de memória de GPU e uma possível aceleração durante a inferência. A aceleração durante o treinamento não é garantida.

> ⚠️ Quando a atenção eficiente em memória e a atenção fatiada estão ambas habilitadas, a atenção eficiente attention tem > precedência.

Exemplos:

>>> import torch
>>> from diffusers import DiffusionPipeline
>>> from xformers.ops import MemoryEfficientAttentionFlashAttentionOp

>>> pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1", dtype=torch.float16)
>>> pipe = pipe.to("cuda")
>>> pipe.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
>>> # Workaround for not accepting attention shape using VAE for Flash Attention
>>> pipe.vae.enable_xformers_memory_efficient_attention(attention_op=None)

disable_xformers_memory_efficient_attention[[diffusers.StableDiffusionLatentUpscalePipeline.disable_xformers_memory_efficient_attention]]

disable_xformers_memory_efficient_attention()

Fonte

Desative a atenção eficiente em memória do xFormers.

encode_prompt[[diffusers.StableDiffusionLatentUpscalePipeline.encode_prompt]]

encode_prompt(prompt, device, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, pooled_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = None)

Fonte

Parâmetros:

prompt (str ou list(int)) : prompt a ser codificado

device : (torch.device): dispositivo torch

do_classifier_free_guidance (bool) : se deve ou não usar classifier free guidance

negative_prompt (str ou list[str]) : O prompt ou os prompts que não devem orientar a geração da imagem. Ignorado quando não se usa orientação (ou seja, ignorado se guidance_scale for menor que 1).

prompt_embeds (torch.FloatTensor, opcional) : Emojis de texto pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, os emojis de texto serão gerados a partir do argumento de entrada prompt.

negative_prompt_embeds (torch.FloatTensor, opcional) : Embeddings de texto negativos pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada negative_prompt.

pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto agrupados pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, os embeddings de texto agrupados serão gerados a partir do argumento de entrada prompt.

negative_pooled_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativo pré-gerados. Pode ser usado para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não for fornecido, os pooled negative_prompt_embeds serão gerados a partir do argumento de entrada negative_prompt.

Codifica o prompt em estados ocultos do codificador de texto.

StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput[[diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput]]

diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray, nsfw_content_detected: list[bool] | None)

Fonte

Parâmetros:

images (list[PIL.Image.Image] ou np.ndarray) : lista de imagens PIL desruídas de comprimento batch_size ou array NumPy de forma (batch_size, height, width, num_channels).

nsfw_content_detected (list[bool]) : lista indicando se a imagem gerada correspondente contém conteúdo "não seguro para o trabalho" (nsfw) ou None se a verificação de segurança não pôde ser realizada.

Classe de saída para pipelines do Stable Diffusion.