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

Profundidade para imagem

O modelo Stable Diffusion também pode inferir profundidade com base em uma imagem usando MiDaS. Isso permite passar um prompt de texto e uma imagem inicial para condicionar a geração de novas imagens, bem como um depth_map para preservar a estrutura da imagem.

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!

StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

diffusers.StableDiffusionDepth2ImgPipeline[[diffusers.StableDiffusionDepth2ImgPipeline]]

diffusers.StableDiffusionDepth2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, depth_estimator: DPTForDepthEstimation, feature_extractor: DPTImageProcessorPil)

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 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 geração de imagem a partir de imagem baseada em profundidade guiada por texto usando Stable Diffusion.

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

call[[diffusers.StableDiffusionDepth2ImgPipeline.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, depth_map: typing.Optional[torch.Tensor] = None, strength: float = 0.8, num_inference_steps: int | None = 50, guidance_scale: float | None = 7.5, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int | None = 1, eta: float | None = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = 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, cross_attention_kwargs: dict[str, typing.Any] | None = None, clip_skip: int | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], **kwargs)

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 usado como ponto de partida. Pode aceitar latentes de imagem como image apenas se depth_map não for None.

depth_map (torch.Tensor, opcional) : Previsão de profundidade a ser usada como condicionamento adicional para o processo de geração de imagem. Se não for definida, a profundidade é prevista automaticamente com self.depth_estimator.

strength (float, opcional, padrão 0.8) : 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_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, às custas de uma inferência mais lenta. Este parâmetro é modulado por strength.

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

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.

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.

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.

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.

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:

>>> import torch
>>> import requests
>>> from PIL import Image

>>> from diffusers import StableDiffusionDepth2ImgPipeline

>>> pipe = StableDiffusionDepth2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-2-depth",
...     torch_dtype=torch.float16,
... )
>>> pipe.to("cuda")

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> init_image = Image.open(requests.get(url, stream=True).raw)
>>> prompt = "two tigers"
>>> n_prompt = "bad, deformed, ugly, bad anotomy"
>>> image = pipe(prompt=prompt, image=init_image, negative_prompt=n_prompt, strength=0.7).images[0]

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

disable_xformers_memory_efficient_attention()

Fonte

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

load_textual_inversion[[diffusers.StableDiffusionDepth2ImgPipeline.load_textual_inversion]]

load_textual_inversion(pretrained_model_name_or_path: str | list[str] | dict[str, torch.Tensor] | list[dict[str, torch.Tensor]], token: str | list[str] | None = None, tokenizer: 'PreTrainedTokenizer' | None = None, text_encoder: 'PreTrainedModel' | None = None, **kwargs)

Fonte

Parâmetros:

pretrained_model_name_or_path (str ou os.PathLike ou list[str or os.PathLike] ou Dict ou list[Dict]) : Pode ser um dos seguintes ou uma lista deles: - Uma string, o model id (por exemplo sd-concepts-library/low-poly-hd-logos-icons) de um modelo pré-treinado hospedado no Hub. - Um caminho para um diretório (por exemplo ./my_text_inversion_directory/) contendo os pesos de inversão textual. - Um caminho para um arquivo (por exemplo ./my_text_inversions.pt) contendo pesos de inversão textual. - Um torch state dict.

token (str ou list[str], opcional) : Substitui o token a ser usado para os pesos de inversão textual. Se pretrained_model_name_or_path for uma lista, então token também deve ser uma lista de comprimento igual.

text_encoder (CLIPTextModel, opcional) : Codificador de texto congelado (clip-vit-large-patch14). Se não for especificado, a função usará self.tokenizer.

tokenizer (CLIPTokenizer, opcional) : Um CLIPTokenizer para tokenizar texto. Se não for especificado, a função usará self.tokenizer.

weight_name (str, opcional) : Nome de um arquivo de pesos personalizado. Isso deve ser usado quando: - O arquivo de inversão textual salvo está no formato 🤗 Diffusers, mas foi salvo com um nome de pesos específico, como text_inv.bin. - O arquivo de inversão textual salvo está no formato Automatic1111.

cache_dir (str | os.PathLike, opcional) : Caminho para um diretório onde a configuração de um modelo pré-treinado baixado é armazenada em cache, caso o cache padrão não seja utilizado.

force_download (bool, opcional, padrão False) : Se deve forçar o (re-)download dos pesos do modelo e dos arquivos de configuração, sobrescrevendo as versões em cache, caso existam.

proxies (dict[str, str], opcional) : Um dicionário de servidores proxy a serem usados por protocolo ou endpoint, por exemplo, {'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}. Os proxies são usados em cada solicitação.

local_files_only (bool, opcional, padrão False) : Se deve carregar apenas os pesos e os arquivos de configuração do modelo localmente ou não. Se definido como True, o modelo não será baixado do Hub.

hf_token (str ou bool, opcional) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se True, o token gerado por diffusers-cli login (armazenado em ~/.huggingface) é utilizado.

revision (str, opcional, padrão "main") : A versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag, um id de commit ou qualquer identificador permitido pelo Git.

subfolder (str, opcional, padrão "") : A localização da subpasta de um arquivo de modelo dentro de um repositório de modelo maior no Hub ou localmente.

mirror (str, opcional) : Espelho de origem para resolver problemas de acessibilidade se você estiver baixando um modelo na China. Não garantimos a pontualidade ou a segurança da origem, e você deve consultar o site do espelho para obter mais informações.

Carregue os embeddings de Textual Inversion no codificador de texto do StableDiffusionPipeline (ambos os formatos 🤗 Diffusers e Automatic1111 são suportados).

Exemplo:

Para carregar um vetor de incorporação de Inversão Textual no formato 🤗 Diffusers:

from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("sd-concepts-library/cat-toy")

prompt = "A <cat-toy> backpack"

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("cat-backpack.png")

Para carregar um vetor de incorporação de Inversão Textual no formato Automatic1111, certifique-se de baixar o vetor primeiro (por exemplo, do civitAI) e, em seguida, carregar o vetor

localmente:

from diffusers import StableDiffusionPipeline
import torch

model_id = "stable-diffusion-v1-5/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to("cuda")

pipe.load_textual_inversion("./charturnerv2.pt", token="charturnerv2")

prompt = "charturnerv2, multiple views of the same character in the same outfit, a character turnaround of a woman wearing a black jacket and red shirt, best quality, intricate details."

image = pipe(prompt, num_inference_steps=50).images[0]
image.save("character.png")

load_lora_weights[[diffusers.StableDiffusionDepth2ImgPipeline.load_lora_weights]]

load_lora_weights(pretrained_model_name_or_path_or_dict: str | dict[str, torch.Tensor], adapter_name: str | None = None, hotswap: bool = False, **kwargs)

Fonte

Parâmetros:

pretrained_model_name_or_path_or_dict (str ou os.PathLike ou dict) : Veja lora_state_dict().

adapter_name (str, opcional) : Nome do adaptador a ser usado para referenciar o modelo de adaptador carregado. Se não for especificado, será usado default_{i}, onde i é o número total de adaptadores sendo carregados.

low_cpu_mem_usage (bool, opcional) : Acelera o carregamento do modelo carregando apenas os pesos LoRA pré-treinados e não inicializando os pesos aleatórios.

hotswap (bool, opcional) : O padrão é False. Se deve substituir um adaptador (LoRA) existente pelo adaptador recém-carregado no local. Isso significa que, em vez de carregar um adaptador adicional, isso pegará os pesos do adaptador existente e os substituirá pelos pesos do novo adaptador. Isso pode ser mais rápido e eficiente em termos de memória. No entanto, a principal vantagem do hotswap é que, quando o modelo é compilado com torch.compile, o carregamento do novo adaptador não requer a recompilação do modelo. Ao usar hotswap, o adapter_name passado deve ser o nome de um adaptador já carregado. Se o novo adaptador e o antigo tiverem ranks e/ou alfas LoRA (ou seja, escalonamento) diferentes, você precisa chamar um método adicional antes de carregar o adaptador: py pipeline = ... # load diffusers pipeline max_rank = ... # the highest rank among all LoRAs that you want to load # call *before* compiling and loading the LoRA adapter pipeline.enable_lora_hotswap(target_rank=max_rank) pipeline.load_lora_weights(file_name) # optionally compile the model now Observe que o hotswap de adaptadores do codificador de texto ainda não é suportado. Existem algumas limitações adicionais a essa técnica, que estão documentadas aqui: https://huggingface.co/docs/peft/main/en/package_reference/hotswap

kwargs (dict, opcional) : Veja lora_state_dict().

Carrega os pesos LoRA especificados em pretrained_model_name_or_path_or_dict para self.unet e self.text_encoder.

Todos os kwargs são encaminhados para self.lora_state_dict.

Veja lora_state_dict() para mais detalhes sobre como o state dict é carregado.

Veja load_lora_into_unet() para mais detalhes sobre como o state dict é carregado em self.unet.

Veja load_lora_into_text_encoder() para mais detalhes sobre como o state dict é carregado em self.text_encoder.

save_lora_weights[[diffusers.StableDiffusionDepth2ImgPipeline.save_lora_weights]]

save_lora_weights(save_directory: str | os.PathLike, unet_lora_layers: dict[str, typing.Union[torch.nn.Module, torch.Tensor]] = None, text_encoder_lora_layers: dict[str, torch.nn.Module] = None, is_main_process: bool = True, weight_name: str = None, save_function: typing.Callable = None, safe_serialization: bool = True, unet_lora_adapter_metadata = None, text_encoder_lora_adapter_metadata = None)

Fonte

Parâmetros:

save_directory (str ou os.PathLike) : Diretório para salvar os parâmetros LoRA. Será criado se não existir.

unet_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : State dict das camadas LoRA correspondentes ao unet.

text_encoder_lora_layers (dict[str, torch.nn.Module] ou dict[str, torch.Tensor]) : State dict das camadas LoRA correspondentes ao text_encoder. É necessário passar explicitamente o state dict do LoRA do text encoder, pois ele vem do 🤗 Transformers.

is_main_process (bool, opcional, padrão True) : Indica se o processo que está chamando esta função é o processo principal ou não. Útil durante o treinamento distribuído, quando é necessário chamar esta função em todos os processos. Nesse caso, defina is_main_process=True apenas no processo principal para evitar condições de corrida.

save_function (Callable) : A função a ser usada para salvar o dicionário de estado. Útil durante o treinamento distribuído quando você precisa substituir torch.save por outro método. Pode ser configurado com a variável de ambiente DIFFUSERS_SAVE_MODE.

safe_serialization (bool, opcional, padrão True) : Se o modelo deve ser salvo usando safetensors ou da maneira tradicional do PyTorch com pickle.

unet_lora_adapter_metadata : Metadados do adaptador LoRA associados ao unet a serem serializados com o state dict.

text_encoder_lora_adapter_metadata : Metadados do adaptador LoRA associados ao codificador de texto a serem serializados com o state dict.

Salve os parâmetros do LoRA correspondentes ao UNet e ao codificador de texto.

encode_prompt[[diffusers.StableDiffusionDepth2ImgPipeline.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.