diffusers/main/pt/api/pipelines/pix2pix.md

InstructPix2Pix

InstructPix2Pix: Learning to Follow Image Editing Instructions é de Tim Brooks, Aleksander Holynski e Alexei A. Efros.

O resumo do artigo é:

Propomos um método para editar imagens a partir de instruções humanas: dada uma imagem de entrada e uma instrução escrita que informa ao modelo o que fazer, nosso modelo segue essas instruções para editar a imagem. Para obter dados de treinamento para esse problema, combinamos o conhecimento de dois grandes modelos pré-treinados -- um modelo de linguagem (GPT-3) e um modelo de texto para imagem (Stable Diffusion) -- para gerar um grande conjunto de dados de exemplos de edição de imagem. Nosso modelo de difusão condicional, InstructPix2Pix, é treinado em nossos dados gerados e generaliza para imagens reais e instruções escritas pelos usuários no momento da inferência. Como ele realiza as edições na passagem direta e não requer ajuste fino por exemplo ou inversão, nosso modelo edita imagens rapidamente, em questão de segundos. Mostramos resultados convincentes de edição para uma coleção diversificada de imagens de entrada e instruções escritas.

Você pode encontrar informações adicionais sobre o InstructPix2Pix no artigo, no repositório de código original e experimentá-lo em uma demonstração.

Certifique-se de consultar o guia 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 para aprender a carregar eficientemente os mesmos componentes em vários pipelines.

StableDiffusionInstructPix2PixPipeline[[diffusers.StableDiffusionInstructPix2PixPipeline]]

diffusers.StableDiffusionInstructPix2PixPipeline[[diffusers.StableDiffusionInstructPix2PixPipeline]]

diffusers.StableDiffusionInstructPix2PixPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, tokenizer: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, safety_checker: StableDiffusionSafetyChecker, feature_extractor: CLIPImageProcessorPil, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None, requires_safety_checker: bool = True)

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.

safety_checker (StableDiffusionSafetyChecker) : Módulo de classificação que estima se as imagens geradas podem ser consideradas ofensivas ou prejudiciais. Consulte o model card para mais detalhes sobre os potenciais danos de um modelo.

feature_extractor (CLIPImageProcessor) : Um CLIPImageProcessor para extrair recursos de imagens geradas; usado como entradas para o safety_checker.

Pipeline para edição de imagens em nível de pixel seguindo instruções de texto (baseado no 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
• load_ip_adapter() para carregar IP Adapters

call[[diffusers.StableDiffusionInstructPix2PixPipeline.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 = 100, guidance_scale: float = 7.5, image_guidance_scale: float = 1.5, 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, ip_adapter_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, ip_adapter_image_embeds: list[torch.Tensor] | None = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], cross_attention_kwargs: dict[str, typing.Any] | None = None, **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 np.ndarray, PIL.Image.Image, list[torch.Tensor], list[PIL.Image.Image] ou list[np.ndarray]) : Image ou tensor representando um lote de imagens a ser repintado de acordo com prompt. Também pode aceitar latentes de imagem como image, mas, se latentes forem passados diretamente, eles não são codificados novamente.

num_inference_steps (int, opcional, padrão 100) : 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.

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.

image_guidance_scale (float, optional, defaults to 1.5) : Push the generated image towards the initial image. Image guidance scale is enabled by setting image_guidance_scale > 1. Higher image guidance scale encourages generated images that are closely linked to the source image, usually at the expense of lower image quality. This pipeline requires a value of at least 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, 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.

ip_adapter_image : (PipelineImageInput, opcional): Entrada de imagem opcional para trabalhar com IP Adapters.

ip_adapter_image_embeds (list[torch.Tensor], opcional) : Embebimentos de imagem pré-gerados para IP-Adapter. Deve ser uma lista com o mesmo comprimento que o número de IP-adapters. Cada elemento deve ser um tensor de forma (batch_size, num_images, emb_dim). Deve conter o embebimento de imagem negativo se do_classifier_free_guidance estiver definido como True. Se não for fornecido, os embebimentos são calculados a partir do argumento de entrada ip_adapter_image.

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_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, opcional) : Uma função ou uma subclasse de PipelineCallback ou MultiPipelineCallbacks que é chamada no final de cada etapa de remoção de ruído durante a inferência, 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.

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

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 PIL
>>> import requests
>>> import torch
>>> from io import BytesIO

>>> from diffusers import StableDiffusionInstructPix2PixPipeline

>>> def download_image(url):
...     response = requests.get(url)
...     return PIL.Image.open(BytesIO(response.content)).convert("RGB")

>>> img_url = "https://huggingface.co/datasets/diffusers/diffusers-images-docs/resolve/main/mountain.png"

>>> image = download_image(img_url).resize((512, 512))

>>> pipe = StableDiffusionInstructPix2PixPipeline.from_pretrained(
...     "timbrooks/instruct-pix2pix", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")

>>> prompt = "make the mountains snowy"
>>> image = pipe(prompt=prompt, image=image).images[0]

load_textual_inversion[[diffusers.StableDiffusionInstructPix2PixPipeline.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.StableDiffusionInstructPix2PixPipeline.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.StableDiffusionInstructPix2PixPipeline.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.

StableDiffusionXLInstructPix2PixPipeline[[diffusers.StableDiffusionXLInstructPix2PixPipeline]]

diffusers.StableDiffusionXLInstructPix2PixPipeline[[diffusers.StableDiffusionXLInstructPix2PixPipeline]]

diffusers.StableDiffusionXLInstructPix2PixPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None, is_cosxl_edit: bool | None = False)

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. O Stable Diffusion XL usa a parte de texto do CLIP, especificamente a variante clip-vit-large-patch14.

text_encoder_2 ( CLIPTextModelWithProjection) : Segundo codificador de texto congelado. O Stable Diffusion XL usa a parte de texto e pool do CLIP, especificamente a variante laion/CLIP-ViT-bigG-14-laion2B-39B-b160k.

tokenizer (CLIPTokenizer) : Tokenizer da classe CLIPTokenizer.

tokenizer_2 (CLIPTokenizer) : Segundo Tokenizer da classe CLIPTokenizer.

unet (UNet2DConditionModel) : Arquitetura de U-Net condicional 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.

requires_aesthetics_score (bool, opcional, padrão "False") : Indica se o unet requer que uma condição de aesthetic_score seja passada durante a inferência. Consulte também a configuração de stabilityai/stable-diffusion-xl-refiner-1-0.

force_zeros_for_empty_prompt (bool, opcional, padrão "True") : Se os embeddings do prompt negativo devem ser forçados a sempre serem definidos como 0. Veja também a configuração de stabilityai/stable-diffusion-xl-base-1-0.

add_watermarker (bool, opcional) : Se deve usar a invisible_watermark library para aplicar marca d'água nas imagens de saída. Se não definido, o padrão será True se o pacote estiver instalado; caso contrário, nenhuma marca d'água será usada.

is_cosxl_edit (bool, opcional) : Quando definido, os latentes da imagem são escalados.

Pipeline para edição de imagens em nível de pixel seguindo instruções de texto. Baseado no Stable Diffusion XL.

Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos que a biblioteca implementa para todos os pipelines (como download ou 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
• para carregar arquivos .ckpt com from_single_file()
• load_lora_weights() para carregar os pesos do LoRA
• save_lora_weights() para salvar os pesos do LoRA

call[[diffusers.StableDiffusionXLInstructPix2PixPipeline.call]]

__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 100, denoising_end: float | None = None, guidance_scale: float = 5.0, image_guidance_scale: float = 1.5, negative_prompt: str | list[str] | None = None, negative_prompt_2: 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, 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, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] = None)

Fonte

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.

prompt_2 (str ou list[str], opcional) : O prompt ou os prompts a serem enviados para o tokenizer_2 e o text_encoder_2. Se não definido, prompt é usado em ambos os text-encoders

image (torch.Tensor ou PIL.Image.Image ou np.ndarray ou list[torch.Tensor] ou list[PIL.Image.Image] ou list[np.ndarray]) : A(s) imagem(ns) a serem modificadas pelo pipeline.

height (int, opcional, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada.

width (int, opcional, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada.

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.

denoising_end (float, opcional) : Quando especificado, determina a fração (entre 0.0 e 1.0) do processo total de remoção de ruído que deve ser concluída antes de ser encerrado prematuramente de forma intencional. Como resultado, a amostra retornada ainda reterá uma quantidade substancial de ruído, conforme determinado pelos passos discretos selecionados pelo agendador. O parâmetro denoising_end deve ser idealmente utilizado quando este pipeline faz parte de uma configuração multi-pipeline de "Mixture of Denoisers", conforme detalhado em Refinamento da Saída da Imagem

guidance_scale (float, opcional, padrão 5.0) : Escala de orientação definida em Classifier-Free Diffusion Guidance. guidance_scale é definido como w da equação 2. do Imagen Paper. 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_guidance_scale (float, optional, defaults to 1.5) : Image guidance scale is to push the generated image towards the initial image image. Image guidance scale is enabled by setting image_guidance_scale > 1. Higher image guidance scale encourages to generate images that are closely linked to the source image image, usually at the expense of lower image quality. This pipeline requires a value of at least 1.

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

negative_prompt_2 (str ou list[str], opcional) : O prompt ou os prompts que não devem orientar a geração da imagem a serem enviados para tokenizer_2 e text_encoder_2. Se não definido, negative_prompt é usado em ambos os text-encoders.

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 (η) no paper DDIM: https://huggingface.co/papers/2010.02502. Aplica-se apenas a schedulers.DDIMScheduler, será ignorado para os demais.

generator (torch.Generator ou list[torch.Generator], opcional) : Um ou uma lista de geradores do torch 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.

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.

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.

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

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

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

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

guidance_rescale (float, opcional, padrão 0.0) : Fator de rescalonamento de orientação proposto por Common Diffusion Noise Schedules and Sample Steps are Flawed guidance_scale é definido como φ na equação 16. de Common Diffusion Noise Schedules and Sample Steps are Flawed. O fator de rescalonamento de orientação deve corrigir a sobreexposição ao usar SNR terminal zero.

original_size (tuple[int], opcional, padrão (1024, 1024)) : Se original_size não for o mesmo que target_size, a imagem parecerá ter sido reduzida ou ampliada. original_size tem como padrão (height, width) se não for especificado. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de https://huggingface.co/papers/2307.01952.

crops_coords_top_left (tuple[int], opcional, padrão (0, 0)) : crops_coords_top_left pode ser usado para gerar uma imagem que parece ter sido "recortada" a partir da posição crops_coords_top_left para baixo. Imagens favoráveis e bem centralizadas são geralmente obtidas ao definir crops_coords_top_left como (0, 0). Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de https://huggingface.co/papers/2307.01952.

target_size (tuple[int], opcional, padrão (1024, 1024)) : Na maioria dos casos, target_size deve ser definido para a altura e largura desejadas da imagem gerada. Se não for especificado, o padrão será (height, width). Parte do micro-conditioning do SDXL, conforme explicado na seção 2.2 de https://huggingface.co/papers/2307.01952.

Retorna: ~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput ou tuple

~pipelines.stable_diffusion_xl.StableDiffusionXLPipelineOutput se return_dict for True, caso contrário, uma tuple. Ao retornar uma tupla, o primeiro elemento é uma lista com as imagens geradas.

Função invocada ao chamar o pipeline para geração.

Exemplos:

>>> import torch
>>> from diffusers import StableDiffusionXLInstructPix2PixPipeline
>>> from diffusers.utils import load_image

>>> resolution = 768
>>> image = load_image(
...     "https://hf.co/datasets/diffusers/diffusers-images-docs/resolve/main/mountain.png"
... ).resize((resolution, resolution))
>>> edit_instruction = "Turn sky into a cloudy one"

>>> pipe = StableDiffusionXLInstructPix2PixPipeline.from_pretrained(
...     "diffusers/sdxl-instructpix2pix-768", torch_dtype=torch.float16
... ).to("cuda")

>>> edited_image = pipe(
...     prompt=edit_instruction,
...     image=image,
...     height=resolution,
...     width=resolution,
...     guidance_scale=3.0,
...     image_guidance_scale=1.5,
...     num_inference_steps=30,
... ).images[0]
>>> edited_image

encode_prompt[[diffusers.StableDiffusionXLInstructPix2PixPipeline.encode_prompt]]

encode_prompt(prompt: str, prompt_2: str | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, do_classifier_free_guidance: bool = True, negative_prompt: str | None = None, negative_prompt_2: str | None = 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, lora_scale: float | None = None)

Fonte

Parâmetros:

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

prompt_2 (str ou list[str], opcional) : O prompt ou os prompts a serem enviados para o tokenizer_2 e o text_encoder_2. Se não definido, prompt é usado em ambos os text-encoders

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

negative_prompt_2 (str ou list[str], opcional) : O prompt ou os prompts que não devem orientar a geração da imagem a serem enviados para tokenizer_2 e text_encoder_2. Se não definido, negative_prompt é usado em ambos os text-encoders

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.

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.

lora_scale (float, opcional) : Uma escala lora que será aplicada a todas as camadas LoRA do text encoder, caso as camadas LoRA sejam carregadas.

Codifica o prompt em estados ocultos do codificador de texto.