diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/upscale.md

Super-resolução

O modelo de difusão upscaler do Stable Diffusion foi criado pelos pesquisadores e engenheiros da CompVis, Stability AI e LAION. Ele é usado para aprimorar a resolução de imagens de entrada por um fator de 4.

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!

StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

diffusers.StableDiffusionUpscalePipeline[[diffusers.StableDiffusionUpscalePipeline]]

diffusers.StableDiffusionUpscalePipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, low_res_scheduler: DDPMScheduler, scheduler: KarrasDiffusionSchedulers, safety_checker: typing.Any | None = None, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None = None, watermarker: typing.Any | None = None, max_noise_level: int = 350)

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.

low_res_scheduler (SchedulerMixin) : Um agendador usado para adicionar ruído inicial à imagem de condicionamento de baixa resolução. Deve ser uma instância de DDPMScheduler.

scheduler (SchedulerMixin) : Um scheduler para ser usado em combinação com unet para desruidar os latentes da imagem codificada. Pode ser um de DDIMScheduler, LMSDiscreteScheduler ou PNDMScheduler.

Pipeline para super-resolução de imagens guiada por texto usando Stable Diffusion 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:

• load_textual_inversion() para carregar embeddings de inversão textual
• load_lora_weights() para carregar os pesos do LoRA
• save_lora_weights() para salvar os pesos do LoRA
• para carregar arquivos .ckpt com from_single_file()

call[[diffusers.StableDiffusionUpscalePipeline.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, noise_level: int = 20, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, 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, negative_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, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int = None)

Fonte

Parâmetros:

prompt (str ou list[str], opcional) : O prompt ou os prompts para orientar a geração de imagens. Se não definido, você precisa passar prompt_embeds.

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.

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.

noise_level (int, opcional, padrão 20) : A quantidade de ruído a ser adicionada à imagem de entrada ampliada. Deve estar no intervalo [0, max_noise_level], onde max_noise_level é definido pelo agendador. Um noise_level mais alto adiciona mais ruído à entrada, aumentando a variação, mas reduzindo a fidelidade à imagem de origem.

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

num_images_per_prompt (int, opcional, padrão 1) : O número de imagens a serem geradas por prompt.

eta (float, opcional, padrão 0.0) : Corresponde ao parâmetro eta (η) do paper DDIM. Aplica-se apenas ao DDIMScheduler e é ignorado em outros agendadores.

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.

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.

cross_attention_kwargs (dict, opcional) : Um dicionário de kwargs que, se especificado, é passado ao AttentionProcessor conforme definido em self.processor.

clip_skip (int, opcional) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do prompt.

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 e o segundo elemento é uma lista de bools indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

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

Exemplos:

>>> import requests
>>> from PIL import Image
>>> from io import BytesIO
>>> from diffusers import StableDiffusionUpscalePipeline
>>> import torch

>>> # load model and scheduler
>>> model_id = "stabilityai/stable-diffusion-x4-upscaler"
>>> pipeline = StableDiffusionUpscalePipeline.from_pretrained(
...     model_id, variant="fp16", torch_dtype=torch.float16
... )
>>> pipeline = pipeline.to("cuda")

>>> # let's download an  image
>>> url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale/low_res_cat.png"
>>> response = requests.get(url)
>>> low_res_img = Image.open(BytesIO(response.content)).convert("RGB")
>>> low_res_img = low_res_img.resize((128, 128))
>>> prompt = "a white cat"

>>> upscaled_image = pipeline(prompt=prompt, image=low_res_img).images[0]
>>> upscaled_image.save("upsampled_cat.png")

enable_attention_slicing[[diffusers.StableDiffusionUpscalePipeline.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.StableDiffusionUpscalePipeline.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.StableDiffusionUpscalePipeline.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.StableDiffusionUpscalePipeline.disable_xformers_memory_efficient_attention]]

disable_xformers_memory_efficient_attention()

Fonte

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

encode_prompt[[diffusers.StableDiffusionUpscalePipeline.encode_prompt]]

encode_prompt(prompt, device, num_images_per_prompt, do_classifier_free_guidance, negative_prompt = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, lora_scale: float | None = None, clip_skip: int | None = None)

Fonte

Parâmetros:

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

device : (torch.device): dispositivo torch

num_images_per_prompt (int) : número de imagens que devem ser geradas por prompt

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

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

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) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada negative_prompt.

lora_scale (float, opcional) : Uma escala LoRA que será aplicada a todas as camadas LoRA do codificador de texto, caso as camadas LoRA sejam carregadas.

clip_skip (int, opcional) : Número de camadas a serem ignoradas do CLIP ao calcular os embeddings do prompt. Um valor de 1 significa que a saída da camada pré-final será usada para calcular os embeddings do 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.