# Stable Diffusion XL

  
  

Stable Diffusion XL (SDXL) foi proposto em [SDXL: Improving Latent Diffusion Models for High-Resolution Image Synthesis](https://huggingface.co/papers/2307.01952) por Dustin Podell, Zion English, Kyle Lacey, Andreas Blattmann, Tim Dockhorn, Jonas Müller, Joe Penna e Robin Rombach.

O resumo do artigo é:

*Apresentamos o SDXL, um modelo de difusão latente para síntese de imagem a partir de texto. Em comparação com versões anteriores do Stable Diffusion, o SDXL utiliza um backbone UNet três vezes maior: o aumento nos parâmetros do modelo deve-se principalmente a mais blocos de atenção e a um contexto de atenção cruzada maior, pois o SDXL usa um segundo codificador de texto. Projetamos vários esquemas de condicionamento inovadores e treinamos o SDXL em múltiplas proporções de aspecto. Também introduzimos um modelo de refinamento, que é usado para melhorar a fidelidade visual das amostras geradas pelo SDXL usando uma técnica de imagem-para-imagem a posteriori. Demonstramos que o SDXL apresenta um desempenho drasticamente melhorado em comparação com as versões anteriores do Stable Diffusion e alcança resultados competitivos com os de geradores de imagem de ponta fechados.*

## Dicas

- O uso do SDXL com um agendador DPM++ para menos de 50 etapas é conhecido por produzir [artefatos visuais](https://github.com/huggingface/diffusers/issues/5433) porque o solucionador se torna numericamente instável. Para corrigir esse problema, veja este [PR](https://github.com/huggingface/diffusers/pull/5541), que recomenda para solucionadores ODE/SDE:
	- Defina `use_karras_sigmas=True` ou `lu_lambdas=True` para melhorar a qualidade da imagem
	- Defina `euler_at_final=True` se você estiver usando um solver com tamanhos de passo uniformes (DPM++2M ou DPM++2M SDE)
- A maioria dos checkpoints do SDXL funciona melhor com um tamanho de imagem de 1024x1024. Tamanhos de imagem de 768x768 e 512x512 também são suportados, mas os resultados não são tão bons. Qualquer tamanho abaixo de 512x512 não é recomendado e provavelmente não será para checkpoints padrão como [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0).
- O SDXL pode passar um prompt diferente para cada um dos codificadores de texto nos quais foi treinado. Podemos até passar partes diferentes do mesmo prompt para os codificadores de texto.
- As imagens de saída do SDXL podem ser aprimoradas ao utilizar um modelo refinador em uma configuração de imagem-para-imagem.
- O SDXL oferece `negative_original_size`, `negative_crops_coords_top_left` e `negative_target_size` para condicionar negativamente o modelo com base nos parâmetros de resolução e recorte da imagem.

> [!TIP]
> Confira a organização [Stability AI](https://huggingface.co/stabilityai) no Hub para os checkpoints oficiais dos modelos base e refiner!

Certifique-se de que as seguintes bibliotecas estão instaladas.

```py
# uncomment to install the necessary libraries in Colab
#!pip install -q diffusers transformers accelerate invisible-watermark>=0.2.0
```

> [!WARNING]
> Recomendamos instalar a biblioteca [invisible-watermark](https://pypi.org/project/invisible-watermark/) para ajudar a identificar imagens geradas. Se a biblioteca invisible-watermark estiver instalada, ela é usada por padrão. Para desativar o marca-d'água:
>
> ```py
> pipeline = StableDiffusionXLPipeline.from_pretrained(..., add_watermarker=False)
> ```

## Carregar checkpoints de modelos

Os pesos do modelo podem estar armazenados em subpastas separadas no Hub ou localmente, caso em que você deve usar o método [from_pretrained()](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline.from_pretrained):

```py
from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = StableDiffusionXLImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0", dtype=torch.float16, use_safetensors=True, variant="fp16"
).to("cuda")
```

Você também pode usar o método [from_single_file()](/docs/diffusers/v0.43.0/pt/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file) para carregar um checkpoint de modelo armazenado em um formato de arquivo único (`.ckpt` ou `.safetensors`) do Hub ou localmente:

```py
from diffusers import StableDiffusionXLPipeline, StableDiffusionXLImg2ImgPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_single_file(
    "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/blob/main/sd_xl_base_1.0.safetensors",
    dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = StableDiffusionXLImg2ImgPipeline.from_single_file(
    "https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0/blob/main/sd_xl_refiner_1.0.safetensors", dtype=torch.float16
).to("cuda")
```

## Texto para imagem

Para texto-para-imagem, passe um prompt de texto. Por padrão, o SDXL gera uma imagem de 1024x1024 para os melhores resultados. Você pode tentar definir os parâmetros `height` e `width` para 768x768 ou 512x512, mas qualquer valor abaixo de 512x512 provavelmente não funcionará.

```py
from diffusers import AutoPipelineForText2Image
import torch

pipeline_text2image = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipeline_text2image(prompt=prompt).images[0]
image
```

    

## Imagem para imagem

Para image-to-image, o SDXL funciona especialmente bem com tamanhos de imagem entre 768x768 e 1024x1024. Passe uma imagem inicial e um prompt de texto para condicionar a imagem com:

```py
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image, make_image_grid

# use from_pipe to avoid consuming additional memory when loading a checkpoint
pipeline = AutoPipelineForImage2Image.from_pipe(pipeline_text2image).to("cuda")  # or "mps", "xpu", "cpu"

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png"
init_image = load_image(url)
prompt = "a dog catching a frisbee in the jungle"
image = pipeline(prompt, image=init_image, strength=0.8, guidance_scale=10.5).images[0]
make_image_grid([init_image, image], rows=1, cols=2)
```

    

## Inpainting

Para inpainting, você precisará da imagem original e de uma máscara do que deseja substituir na imagem original. Crie um prompt para descrever o que deseja substituir a área mascarada.

```py
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image, make_image_grid

# use from_pipe to avoid consuming additional memory when loading a checkpoint
pipeline = AutoPipelineForInpainting.from_pipe(pipeline_text2image).to("cuda")  # or "mps", "xpu", "cpu"

img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png"
mask_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-inpaint-mask.png"

init_image = load_image(img_url)
mask_image = load_image(mask_url)

prompt = "A deep sea diver floating"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, strength=0.85, guidance_scale=12.5).images[0]
make_image_grid([init_image, mask_image, image], rows=1, cols=3)
```

    

## Refinar a qualidade da imagem

O SDXL inclui um [modelo refinador](https://huggingface.co/stabilityai/stable-diffusion-xl-refiner-1.0) especializado em reduzir o ruído de imagens da etapa de baixo ruído para gerar imagens de maior qualidade a partir do modelo base. Existem duas maneiras de usar o refinador:

1. use os modelos base e refiner juntos para produzir uma imagem refinada
2. use o modelo base para gerar uma imagem e, em seguida, use o modelo refinador para adicionar mais detalhes à imagem (foi assim que o SDXL foi originalmente treinado)

### Modelo base + refinador

Quando você usa o modelo base e o modelo refinador juntos para gerar uma imagem, isso é conhecido como um [*conjunto de desruidos especialistas*](https://research.nvidia.com/labs/dir/eDiff-I/). A abordagem de conjunto de desruidos especialistas requer menos etapas gerais de desruidagem em comparação com passar a saída do modelo base para o modelo refinador, portanto, deve ser significativamente mais rápido de executar. No entanto, você não será capaz de inspecionar a saída do modelo base, pois ela ainda contém uma grande quantidade de ruído.

Como um conjunto de desruidadores especialistas, o modelo base atua como o especialista durante o estágio de difusão de alto ruído e o modelo refinador atua como o especialista durante o estágio de difusão de baixo ruído. Carregue o modelo base e o modelo refinador:

```py
from diffusers import DiffusionPipeline
import torch

base = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base.text_encoder_2,
    vae=base.vae,
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
).to("cuda")
```

Para usar essa abordagem, você precisa definir o número de timesteps para que cada modelo execute suas respectivas etapas. Para o modelo base, isso é controlado pelo parâmetro [`denoising_end`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline.__call__.denoising_end) e, para o modelo refiner, pelo parâmetro [`denoising_start`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLImg2ImgPipeline.__call__.denoising_start).

> [!TIP]
> Os parâmetros `denoising_end` e `denoising_start` devem ser um número flutuante entre 0 e 1. Esses parâmetros são representados como uma proporção dos timesteps discretos definidos pelo agendador. Se você também estiver usando o parâmetro `strength`, ele será ignorado, pois o número de etapas de desruidamento é determinado pelos timesteps discretos nos quais o modelo foi treinado e pelo corte fracionário declarado.

Vamos definir `denoising_end=0.8` para que o modelo base execute os primeiros 80% do desruidamento nos timesteps de **alto ruído** e definir `denoising_start=0.8` para que o modelo refinador execute os últimos 20% do desruidamento nos timesteps de **baixo ruído**. A saída do modelo base deve estar no espaço **latente** em vez de ser uma imagem PIL.

```py
prompt = "A majestic lion jumping from a big stone at night"

image = base(
    prompt=prompt,
    num_inference_steps=40,
    denoising_end=0.8,
    output_type="latent",
).images
image = refiner(
    prompt=prompt,
    num_inference_steps=40,
    denoising_start=0.8,
    image=image,
).images[0]
image
```

  
    
    modelo base padrão
  
  
    
    conjunto de especialistas de remoção de ruído
  

O modelo refiner também pode ser usado para inpainting no [StableDiffusionXLInpaintPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLInpaintPipeline):

```py
from diffusers import StableDiffusionXLInpaintPipeline
from diffusers.utils import load_image, make_image_grid
import torch

base = StableDiffusionXLInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = StableDiffusionXLInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base.text_encoder_2,
    vae=base.vae,
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
).to("cuda")

img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"

init_image = load_image(img_url)
mask_image = load_image(mask_url)

prompt = "A majestic tiger sitting on a bench"
num_inference_steps = 75
high_noise_frac = 0.7

image = base(
    prompt=prompt,
    image=init_image,
    mask_image=mask_image,
    num_inference_steps=num_inference_steps,
    denoising_end=high_noise_frac,
    output_type="latent",
).images
image = refiner(
    prompt=prompt,
    image=image,
    mask_image=mask_image,
    num_inference_steps=num_inference_steps,
    denoising_start=high_noise_frac,
).images[0]
make_image_grid([init_image, mask_image, image.resize((512, 512))], rows=1, cols=3)
```

Esse método de conjunto de denoisers especializados funciona bem para todos os agendadores disponíveis!

### Modelo base para o modelo refinador

O SDXL obtém um aumento na qualidade da imagem ao usar o modelo refiner para adicionar detalhes adicionais de alta qualidade à imagem totalmente desruída pelo modelo base, em uma configuração de imagem-para-imagem.

Carregue os modelos base e refiner:

```py
from diffusers import DiffusionPipeline
import torch

base = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

refiner = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base.text_encoder_2,
    vae=base.vae,
    dtype=torch.float16,
    use_safetensors=True,
    variant="fp16",
).to("cuda")
```

> [!WARNING]
> Você pode usar o SDXL refiner com um modelo base diferente. Por exemplo, você pode usar os pipelines [Hunyuan-DiT](../hunyuandit) ou [PixArt-Sigma](../pixart_sigma) para gerar imagens com melhor aderência ao prompt. Depois de gerar uma imagem, você pode passá-la para o modelo SDXL refiner para aprimorar a qualidade final da geração.

Gere uma imagem a partir do modelo base e defina a saída do modelo para o espaço **latent**:

```py
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"

image = base(prompt=prompt, output_type="latent").images[0]
```

Passe a imagem gerada para o modelo refinador:

```py
image = refiner(prompt=prompt, image=image[None, :]).images[0]
```

  
    
    modelo base
  
  
    
    modelo base + modelo refinador
  

Para inpainting, carregue o modelo base e o modelo refinador no [StableDiffusionXLInpaintPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLInpaintPipeline), remova os parâmetros `denoising_end` e `denoising_start` e escolha um número menor de etapas de inferência para o refinador.

## Micro-condicionamento

O treinamento do SDXL envolve várias técnicas adicionais de condicionamento, referidas como *micro-condicionamento*. Essas incluem o tamanho original da imagem, o tamanho da imagem de destino e os parâmetros de recorte. Os micro-condicionamentos podem ser usados no momento da inferência para criar imagens de alta qualidade e centralizadas.

> [!TIP]
> Você pode usar os parâmetros de micro-condicionamento e micro-condicionamento negativo graças ao classifier-free guidance. Eles estão disponíveis no [StableDiffusionXLPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline), [StableDiffusionXLImg2ImgPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLImg2ImgPipeline), [StableDiffusionXLInpaintPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLInpaintPipeline) e [StableDiffusionXLControlNetPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/controlnet_sdxl#diffusers.StableDiffusionXLControlNetPipeline).

### Condição de tamanho

Existem dois tipos de condicionamento de tamanho:

- O condicionamento de [`original_size`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline.__call__.original_size) vem de imagens ampliadas no lote de treinamento (pois seria desperdício descartar as imagens menores, que compõem quase 40% dos dados de treinamento totais). Dessa forma, o SDXL aprende que artefatos de ampliação não devem estar presentes em imagens de alta resolução. Durante a inferência, você pode usar `original_size` para indicar a resolução da imagem original. Usar o valor padrão de `(1024, 1024)` produz imagens de maior qualidade que se assemelham às imagens de 1024x1024 no conjunto de dados. Se você optar por usar uma resolução menor, como `(256, 256)`, o modelo ainda gera imagens de 1024x1024, mas elas parecerão com as imagens de baixa resolução (padrões mais simples, desfoque) no conjunto de dados.

- O condicionamento de [`target_size`](https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline.__call__.target_size) vem do finetuning do SDXL para suportar diferentes proporções de imagem. Durante a inferência, se você usar o valor padrão de `(1024, 1024)`, obterá uma imagem que se assemelha à composição das imagens quadradas no dataset. Recomendamos usar o mesmo valor para `target_size` e `original_size`, mas sinta-se à vontade para experimentar outras opções!

🤗 O Diffusers também permite especificar condições negativas sobre o tamanho de uma imagem para direcionar a geração para longe de certas resoluções de imagem:

```py
from diffusers import StableDiffusionXLPipeline
import torch

pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipe(
    prompt=prompt,
    negative_original_size=(512, 512),
    negative_target_size=(1024, 1024),
).images[0]
```

  
  Imagens condicionadas negativamente em resoluções de imagem de (128, 128), (256, 256) e (512, 512).

### Condição de recorte

Imagens geradas por modelos anteriores de Stable Diffusion podem, às vezes, parecer recortadas. Isso ocorre porque as imagens são, de fato, recortadas durante o treinamento para que todas as imagens em um lote tenham o mesmo tamanho. Ao condicionar nas coordenadas de recorte, o SDXL *aprende* que a ausência de recorte - coordenadas `(0, 0)` - geralmente está correlacionada com sujeitos centralizados e rostos completos (este é o valor padrão no 🤗 Diffusers). Você pode experimentar diferentes coordenadas se quiser gerar composições fora do centro!

```py
from diffusers import StableDiffusionXLPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipeline(prompt=prompt, crops_coords_top_left=(256, 0)).images[0]
image
```

    

Você também pode especificar coordenadas de recorte negativas para direcionar a geração para longe de certos parâmetros de recorte:

```py
from diffusers import StableDiffusionXLPipeline
import torch

pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
image = pipe(
    prompt=prompt,
    negative_original_size=(512, 512),
    negative_crops_coords_top_left=(0, 0),
    negative_target_size=(1024, 1024),
).images[0]
image
```

## Use um prompt diferente para cada text-encoder

O SDXL usa dois text-encoders, portanto é possível passar um prompt diferente para cada text-encoder, o que pode [melhorar a qualidade](https://github.com/huggingface/diffusers/issues/4004#issuecomment-1627764201). Passe seu prompt original para `prompt` e o segundo prompt para `prompt_2` (use `negative_prompt` e `negative_prompt_2` se estiver usando prompts negativos):

```py
from diffusers import StableDiffusionXLPipeline
import torch

pipeline = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16, variant="fp16", use_safetensors=True
).to("cuda")  # or "mps", "xpu", "cpu"

# prompt is passed to OAI CLIP-ViT/L-14
prompt = "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k"
# prompt_2 is passed to OpenCLIP-ViT/bigG-14
prompt_2 = "Van Gogh painting"
image = pipeline(prompt=prompt, prompt_2=prompt_2).images[0]
image
```

    

Os codificadores de texto duplos também suportam incorporações de inversão textual que precisam ser carregadas separadamente, conforme explicado no guia de [inversão textual](../../../using-diffusers/legacy_adapters#textual-inversion).

## Otimizações

SDXL é um modelo grande e você pode precisar otimizar a memória para executá-lo no seu hardware. Aqui estão algumas dicas para economizar memória e acelerar a inferência.

1. Desative o modelo para a CPU com [enable_model_cpu_offload()](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline.enable_model_cpu_offload) para erros de memória insuficiente:

```diff
- base.to("cuda")  # or "mps", "xpu", "cpu"
- refiner.to("cuda")
+ base.enable_model_cpu_offload()
+ refiner.enable_model_cpu_offload()
```

2. Use `torch.compile` para uma aceleração de ~20% (você precisa de `torch>=2.0`):

```diff
+ base.unet = torch.compile(base.unet, mode="reduce-overhead", fullgraph=True)
+ refiner.unet = torch.compile(refiner.unet, mode="reduce-overhead", fullgraph=True)
```

3. Ative o [xFormers](../../../optimization/attention_backends) para executar o SDXL se `torch<2.0`:

```diff
+ base.enable_xformers_memory_efficient_attention()
+ refiner.enable_xformers_memory_efficient_attention()
```

## Recursos

Se você estiver interessado em experimentar uma versão mínima do [UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel) usado no SDXL, dê uma olhada na implementação [minSDXL](https://github.com/cloneofsimo/minSDXL), que é escrita em PyTorch e é diretamente compatível com o 🤗 Diffusers.

## StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]]

#### diffusers.StableDiffusionXLPipeline[[diffusers.StableDiffusionXLPipeline]]

```python
diffusers.StableDiffusionXLPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L170)

**Parâmetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.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](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/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](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), especificamente a variante [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k).

tokenizer (`CLIPTokenizer`) : Tokenizer da classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

tokenizer_2 (`CLIPTokenizer`) : Segundo Tokenizer da classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar os latentes da imagem codificada.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `unet` para desruidar os latentes da imagem codificada. Pode ser um de [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/pndm#diffusers.PNDMScheduler).

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](https://github.com/ShieldMnt/invisible-watermark/) 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.

Pipeline para geração de texto para imagem usando Stable Diffusion XL.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.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()](/docs/diffusers/v0.43.0/pt/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para carregar embeddings de inversão textual
- para carregar arquivos `.ckpt` com [from_single_file()](/docs/diffusers/v0.43.0/pt/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file)
- [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para carregar os pesos do LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para salvar os pesos do LoRA
- [load_ip_adapter()](/docs/diffusers/v0.43.0/pt/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para carregar IP Adapters

#### __call__[[diffusers.StableDiffusionXLPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, prompt_2: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_end: float | None = None, guidance_scale: float = 5.0, 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, 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, cross_attention_kwargs: dict[str, typing.Any] | None = None, guidance_rescale: float = 0.0, original_size: tuple[int, int] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), target_size: tuple[int, int] | None = None, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, clip_skip: int | None = None, 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'], **kwargs)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L823)

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

height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. Qualquer valor abaixo de 512 pixels não funcionará bem para [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) e checkpoints que não foram especificamente ajustados em resoluções baixas.

width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. Qualquer valor abaixo de 512 pixels não funcionará bem para [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) e checkpoints que não foram especificamente ajustados em resoluções baixas.

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.

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.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar no processo de desruidamento com agendadores que suportam um argumento `sigmas` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado.

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**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output)

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

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](/docs/diffusers/v0.43.0/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`.

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

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](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_xl.StableDiffusionXLPipelineOutput` em vez de uma tupla simples.

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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

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](https://huggingface.co/papers/2305.08891) `guidance_scale` é definido como `φ` na equação 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). 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](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](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](https://huggingface.co/papers/2307.01952).

negative_original_size (`tuple[int]`, *opcional*, padrão (1024, 1024)) : Para condicionar negativamente o processo de geração com base em uma resolução de imagem específica. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

negative_crops_coords_top_left (`tuple[int]`, *opcional*, padrão (0, 0)) : Para condicionar negativamente o processo de geração com base em coordenadas específicas de recorte. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

negative_target_size (`tuple[int]`, *opcional*, padrão (1024, 1024)) : Para condicionar negativamente o processo de geração com base em uma resolução de imagem alvo. Deve ser o mesmo que o `target_size` na maioria dos casos. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

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

**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:
```py
>>> import torch
>>> from diffusers import StableDiffusionXLPipeline

>>> pipe = StableDiffusionXLPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")

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

#### encode_prompt[[diffusers.StableDiffusionXLPipeline.encode_prompt]]

```python
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, clip_skip: int | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L283)

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

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.

#### get_guidance_scale_embedding[[diffusers.StableDiffusionXLPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py#L758)

**Parâmetros:**

w (`torch.Tensor`) : Gera vetores de incorporação com uma escala de orientação especificada para, em seguida, enriquecer as incorporações de passo de tempo.

embedding_dim (`int`, *opcional*, padrão 512) : Dimensão dos embeddings a serem gerados.

dtype (`torch.dtype`, *opcional*, padrão `torch.float32`) : Tipo de dados dos embeddings gerados.

**Retorna:** `torch.Tensor`

Vetores de incorporação com forma `(len(w), embedding_dim)`.

Veja https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

## StableDiffusionXLImg2ImgPipeline[[diffusers.StableDiffusionXLImg2ImgPipeline]]

#### diffusers.StableDiffusionXLImg2ImgPipeline[[diffusers.StableDiffusionXLImg2ImgPipeline]]

```python
diffusers.StableDiffusionXLImg2ImgPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L188)

**Parâmetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.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](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/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](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), especificamente a variante [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k).

tokenizer (`CLIPTokenizer`) : Tokenizer da classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

tokenizer_2 (`CLIPTokenizer`) : Segundo Tokenizer da classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar os latentes da imagem codificada.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `unet` para desruidar os latentes da imagem codificada. Pode ser um de [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/pndm#diffusers.PNDMScheduler).

requires_aesthetics_score (`bool`, *opcional*, padrão `"False"`) : Indica se o `unet` requer que a condição `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](https://github.com/ShieldMnt/invisible-watermark/) 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.

Pipeline para geração de texto para imagem usando Stable Diffusion XL.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.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()](/docs/diffusers/v0.43.0/pt/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para carregar embeddings de inversão textual
- para carregar arquivos `.ckpt` com [from_single_file()](/docs/diffusers/v0.43.0/pt/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file)
- [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para carregar os pesos do LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para salvar os pesos do LoRA
- [load_ip_adapter()](/docs/diffusers/v0.43.0/pt/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para carregar IP Adapters

#### __call__[[diffusers.StableDiffusionXLImg2ImgPipeline.__call__]]

```python
__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, strength: float = 0.3, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_start: float | None = None, denoising_end: float | None = None, guidance_scale: float = 5.0, 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, 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, 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, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, 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'], **kwargs)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L975)

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

strength (`float`, *opcional*, padrão 0.3) : Conceitualmente, indica o quanto transformar a `image` de referência. Deve estar entre 0 e 1. `image` será usado como ponto de partida, adicionando mais ruído à medida que o `strength` aumenta. O número de etapas de remoção de ruído depende da quantidade de ruído inicialmente adicionada. Quando `strength` é 1, o ruído adicionado será máximo e o processo de remoção de ruído será executado pelo número total de iterações especificado em `num_inference_steps`. Um valor de 1, portanto, essencialmente ignora `image`. Observe que, no caso de `denoising_start` ser declarado como um inteiro, o valor de `strength` será ignorado.

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.

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.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar no processo de desruidamento com agendadores que suportam um argumento `sigmas` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado.

denoising_start (`float`, *opcional*) : Quando especificado, indica a fração (entre 0.0 e 1.0) do processo total de remoção de ruído que será ignorada antes de sua iniciação. Consequentemente, a parte inicial do processo de remoção de ruído é pulada e assume-se que a `image` passada é uma imagem parcialmente desruidada. Observe que, quando isso é especificado, a strength será ignorada. O parâmetro `denoising_start` é particularmente benéfico quando este pipeline é integrado a uma configuração multi-pipeline de "Mixture of Denoisers", conforme detalhado em [**Refine Image Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality).

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 (aprox. 20% final dos timesteps ainda necessários) e deve ser desruidada por um pipeline sucessor que tenha `denoising_start` definido como 0.8, para que ele apenas desruide os 20% finais do 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 [**Refine Image Quality**](https://huggingface.co/docs/diffusers/using-diffusers/sdxl#refine-image-quality).

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

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](/docs/diffusers/v0.43.0/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`.

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

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](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.StableDiffusionXLPipelineOutput` em vez de uma tupla simples.

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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

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](https://huggingface.co/papers/2305.08891) `guidance_scale` é definido como `φ` na equação 16. de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://huggingface.co/papers/2305.08891). 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](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](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](https://huggingface.co/papers/2307.01952).

negative_original_size (`tuple[int]`, *opcional*, padrão (1024, 1024)) : Para condicionar negativamente o processo de geração com base em uma resolução de imagem específica. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

negative_crops_coords_top_left (`tuple[int]`, *opcional*, padrão (0, 0)) : Para condicionar negativamente o processo de geração com base em coordenadas específicas de recorte. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

negative_target_size (`tuple[int]`, *opcional*, padrão (1024, 1024)) : Para condicionar negativamente o processo de geração com base em uma resolução de imagem alvo. Deve ser o mesmo que o `target_size` na maioria dos casos. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

aesthetic_score (`float`, *opcional*, padrão 6.0) : Usado para simular uma pontuação estética da imagem gerada, influenciando a condição de texto positiva. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).

negative_aesthetic_score (`float`, *opcional*, padrão 2.5) : Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Pode ser usado para simular uma pontuação estética da imagem gerada, influenciando a condição de texto negativo.

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

**Retorna:** `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` ou `tuple`

`~pipelines.stable_diffusion.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:
```py
>>> import torch
>>> from diffusers import StableDiffusionXLImg2ImgPipeline
>>> from diffusers.utils import load_image

>>> pipe = StableDiffusionXLImg2ImgPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-xl-refiner-1.0", torch_dtype=torch.float16
... )
>>> pipe = pipe.to("cuda")
>>> url = "https://huggingface.co/datasets/patrickvonplaten/images/resolve/main/aa_xl/000000009.png"

>>> init_image = load_image(url).convert("RGB")
>>> prompt = "a photo of an astronaut riding a horse on mars"
>>> image = pipe(prompt, image=init_image).images[0]
```

#### encode_prompt[[diffusers.StableDiffusionXLImg2ImgPipeline.encode_prompt]]

```python
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, clip_skip: int | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L301)

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

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.

#### get_guidance_scale_embedding[[diffusers.StableDiffusionXLImg2ImgPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_img2img.py#L906)

**Parâmetros:**

w (`torch.Tensor`) : Gera vetores de incorporação com uma escala de orientação especificada para, em seguida, enriquecer as incorporações de passo de tempo.

embedding_dim (`int`, *opcional*, padrão 512) : Dimensão dos embeddings a serem gerados.

dtype (`torch.dtype`, *opcional*, padrão `torch.float32`) : Tipo de dados dos embeddings gerados.

**Retorna:** `torch.Tensor`

Vetores de incorporação com forma `(len(w), embedding_dim)`.

Veja https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

## StableDiffusionXLInpaintPipeline[[diffusers.StableDiffusionXLInpaintPipeline]]

#### diffusers.StableDiffusionXLInpaintPipeline[[diffusers.StableDiffusionXLInpaintPipeline]]

```python
diffusers.StableDiffusionXLInpaintPipeline(vae: AutoencoderKL, text_encoder: CLIPTextModel, text_encoder_2: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, tokenizer_2: CLIPTokenizer, unet: UNet2DConditionModel, scheduler: KarrasDiffusionSchedulers, image_encoder: CLIPVisionModelWithProjection = None, feature_extractor: CLIPImageProcessorPil = None, requires_aesthetics_score: bool = False, force_zeros_for_empty_prompt: bool = True, add_watermarker: bool | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L215)

**Parâmetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/pt/api/models/autoencoderkl#diffusers.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](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/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](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModelWithProjection), especificamente a variante [laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k).

tokenizer (`CLIPTokenizer`) : Tokenizer da classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

tokenizer_2 (`CLIPTokenizer`) : Segundo Tokenizer da classe [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).

unet ([UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar os latentes da imagem codificada.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/pt/api/schedulers/overview#diffusers.SchedulerMixin)) : Um scheduler para ser usado em combinação com `unet` para desruidar os latentes da imagem codificada. Pode ser um de [DDIMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler), [LMSDiscreteScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/lms_discrete#diffusers.LMSDiscreteScheduler) ou [PNDMScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/pndm#diffusers.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](https://github.com/ShieldMnt/invisible-watermark/) 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.

Pipeline para geração de texto para imagem usando Stable Diffusion XL.

Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.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()](/docs/diffusers/v0.43.0/pt/api/loaders/textual_inversion#diffusers.loaders.TextualInversionLoaderMixin.load_textual_inversion) para carregar embeddings de inversão textual
- para carregar arquivos `.ckpt` com [from_single_file()](/docs/diffusers/v0.43.0/pt/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file)
- [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.load_lora_weights) para carregar os pesos do LoRA
- [save_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.StableDiffusionXLLoraLoaderMixin.save_lora_weights) para salvar os pesos do LoRA
- [load_ip_adapter()](/docs/diffusers/v0.43.0/pt/api/loaders/ip_adapter#diffusers.loaders.IPAdapterMixin.load_ip_adapter) para carregar IP Adapters

#### __call__[[diffusers.StableDiffusionXLInpaintPipeline.__call__]]

```python
__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, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: Tensor = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.9999, num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, denoising_start: float | None = None, denoising_end: float | None = None, guidance_scale: float = 7.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, 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, 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, negative_original_size: tuple[int, int] | None = None, negative_crops_coords_top_left: tuple[int, int] = (0, 0), negative_target_size: tuple[int, int] | None = None, aesthetic_score: float = 6.0, negative_aesthetic_score: float = 2.5, clip_skip: int | None = None, 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'], **kwargs)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L1080)

**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 (`PIL.Image.Image`) : `Image`, ou tensor representando um lote de imagens que será submetido a inpainting, *ou seja*, partes da imagem serão mascaradas com `mask_image` e repintadas de acordo com `prompt`.

mask_image (`PIL.Image.Image`) : `Image`, ou tensor representando um lote de imagens, para mascarar `image`. Os pixels brancos na máscara serão repintados, enquanto os pixels pretos serão preservados. Se `mask_image` for uma imagem PIL, ela será convertida para um único canal (luminância) antes do uso. Se for um tensor, ele deve conter um canal de cor (L) em vez de 3, portanto, a forma esperada seria `(B, H, W, 1)`.

masked_image_latents (`torch.Tensor`, *opcional*) : Latente pré-codificado da imagem mascarada (para inpainting).

height (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A altura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. Qualquer valor abaixo de 512 pixels não funcionará bem para [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) e checkpoints que não foram especificamente ajustados em resoluções baixas.

width (`int`, *opcional*, padrão é self.unet.config.sample_size * self.vae_scale_factor) : A largura em pixels da imagem gerada. Isso é definido como 1024 por padrão para os melhores resultados. Qualquer valor abaixo de 512 pixels não funcionará bem para [stabilityai/stable-diffusion-xl-base-1.0](https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0) e checkpoints que não foram especificamente ajustados em resoluções baixas.

padding_mask_crop (`int`, *opcional*, padrão `None`) : O tamanho da margem no recorte a ser aplicado à imagem e à máscara. Se `None`, nenhum recorte é aplicado à imagem e à mask_image. Se `padding_mask_crop` não for `None`, primeiro será encontrada uma região retangular com a mesma proporção de aspecto da imagem e que contenha toda a área mascarada, e então essa área será expandida com base em `padding_mask_crop`. A imagem e a mask_image serão então recortadas com base na área expandida antes de serem redimensionadas para o tamanho original da imagem para o inpainting. Isso é útil quando a área mascarada é pequena, mas a imagem é grande e contém informações irrelevantes para o inpainting, como o fundo.

strength (`float`, *opcional*, padrão 0.9999) : Conceitualmente, indica o quanto transformar a porção mascarada da `image` de referência. Deve estar entre 0 e 1. `image` será usado como ponto de partida, adicionando mais ruído a ela 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 será máximo e o processo de desruidamento será executado pelo número total de iterações especificado em `num_inference_steps`. Um valor de 1, portanto, essencialmente ignora a porção mascarada da `image` de referência. Observe que, no caso de `denoising_start` ser declarado como um inteiro, o valor de `strength` será ignorado.

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.

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.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar no processo de desruidamento com agendadores que suportam um argumento `sigmas` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado.

denoising_start (`float`, *opcional*) : Quando especificado, indica a fração (entre 0.0 e 1.0) do processo total de desruido que será ignorada antes de ser iniciado. Consequentemente, a parte inicial do processo de desruido é pulada e assume-se que a `image` passada é uma imagem parcialmente desruidada. Observe que, quando isso é especificado, a strength será ignorada. O parâmetro `denoising_start` é particularmente benéfico quando este pipeline é integrado a uma configuração multi-pipeline de "Mixture of Denoisers", conforme detalhado em [**Refinamento da Saída da Imagem**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output).

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 (aprox. 20% final dos timesteps ainda necessários) e deve ser desruidada por um pipeline sucessor que tenha `denoising_start` definido como 0.8, para que ele remova o ruído apenas dos 20% finais do 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**](https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion/stable_diffusion_xl#refining-the-image-output).

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

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

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

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](/docs/diffusers/v0.43.0/pt/api/schedulers/ddim#diffusers.DDIMScheduler), será ignorado para os demais.

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

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 [StableDiffusionPipelineOutput](/docs/diffusers/v0.43.0/pt/api/pipelines/stable_diffusion/img2img#diffusers.pipelines.stable_diffusion.StableDiffusionPipelineOutput) em vez de uma tupla simples.

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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

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](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](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](https://huggingface.co/papers/2307.01952).

negative_original_size (`tuple[int]`, *opcional*, padrão (1024, 1024)) : Para condicionar negativamente o processo de geração com base em uma resolução de imagem específica. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

negative_crops_coords_top_left (`tuple[int]`, *opcional*, padrão (0, 0)) : Para condicionar negativamente o processo de geração com base em coordenadas específicas de recorte. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

negative_target_size (`tuple[int]`, *opcional*, padrão (1024, 1024)) : Para condicionar negativamente o processo de geração com base em uma resolução de imagem alvo. Deve ser o mesmo que o `target_size` na maioria dos casos. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Para mais informações, consulte este tópico: https://github.com/huggingface/diffusers/issues/4208.

aesthetic_score (`float`, *opcional*, padrão 6.0) : Usado para simular uma pontuação estética da imagem gerada, influenciando a condição de texto positiva. Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952).

negative_aesthetic_score (`float`, *opcional*, padrão 2.5) : Parte do micro-condicionamento do SDXL, conforme explicado na seção 2.2 de [https://huggingface.co/papers/2307.01952](https://huggingface.co/papers/2307.01952). Pode ser usado para simular uma pontuação estética da imagem gerada, influenciando a condição de texto negativo.

guidance_rescale (`float`, *opcional*, padrão 0.0) : Fator de rescalonamento de orientação de [Common Diffusion Noise Schedules and Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf).

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

**Retorna:** `~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` ou `tuple`

`~pipelines.stable_diffusion.StableDiffusionXLPipelineOutput` se `return_dict` for True, caso contrário, uma `tuple. `tuple. Ao retornar uma tuple, 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 StableDiffusionXLInpaintPipeline
>>> from diffusers.utils import load_image

>>> pipe = StableDiffusionXLInpaintPipeline.from_pretrained(
...     "stabilityai/stable-diffusion-xl-base-1.0",
...     torch_dtype=torch.float16,
...     variant="fp16",
...     use_safetensors=True,
... )
>>> pipe.to("cuda")

>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"

>>> init_image = load_image(img_url).convert("RGB")
>>> mask_image = load_image(mask_url).convert("RGB")

>>> prompt = "A majestic tiger sitting on a bench"
>>> image = pipe(
...     prompt=prompt, image=init_image, mask_image=mask_image, num_inference_steps=50, strength=0.80
... ).images[0]
```

#### encode_prompt[[diffusers.StableDiffusionXLInpaintPipeline.encode_prompt]]

```python
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, clip_skip: int | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L405)

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

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.

#### get_guidance_scale_embedding[[diffusers.StableDiffusionXLInpaintPipeline.get_guidance_scale_embedding]]

```python
get_guidance_scale_embedding(w: Tensor, embedding_dim: int = 512, dtype: dtype = torch.float32)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl_inpaint.py#L1011)

**Parâmetros:**

w (`torch.Tensor`) : Gera vetores de incorporação com uma escala de orientação especificada para, em seguida, enriquecer as incorporações de passo de tempo.

embedding_dim (`int`, *opcional*, padrão 512) : Dimensão dos embeddings a serem gerados.

dtype (`torch.dtype`, *opcional*, padrão `torch.float32`) : Tipo de dados dos embeddings gerados.

**Retorna:** `torch.Tensor`

Vetores de incorporação com forma `(len(w), embedding_dim)`.

Veja https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298