# Kandinsky 2.2

Kandinsky 2.2 foi criado por [Arseniy Shakhmatov](https://github.com/cene555), [Anton Razzhigaev](https://github.com/razzant), [Aleksandr Nikolich](https://github.com/AlexWortega), [Vladimir Arkhipkin](https://github.com/oriBetelgeuse), [Igor Pavlov](https://github.com/boomb0om), [Andrey Kuznetsov](https://github.com/kuznetsoffandrey) e [Denis Dimitrov](https://github.com/denndimitrov).

A descrição em sua página no GitHub é:

*O Kandinsky 2.2 traz melhorias substanciais em relação ao seu antecessor, o Kandinsky 2.1, ao introduzir um novo codificador de imagens mais poderoso - o CLIP-ViT-G - e o suporte ao ControlNet. A troca para o CLIP-ViT-G como codificador de imagens aumenta significativamente a capacidade do modelo de gerar imagens mais estéticas e de compreender melhor o texto, aprimorando assim o desempenho geral do modelo. A adição do mecanismo ControlNet permite que o modelo controle efetivamente o processo de geração de imagens. Isso resulta em saídas mais precisas e visualmente atraentes e abre novas possibilidades para a manipulação de imagens guiada por texto.*

O código-fonte original pode ser encontrado em [ai-forever/Kandinsky-2](https://github.com/ai-forever/Kandinsky-2).

> [!TIP]
> Confira a organização [Kandinsky Community](https://huggingface.co/kandinsky-community) no Hub para os checkpoints oficiais de modelos para tarefas como text-to-image, image-to-image e inpainting.

> [!TIP]
> Certifique-se de consultar o [guia](../../using-diffusers/schedulers) dos agendadores para aprender a explorar o compromisso entre a velocidade e a qualidade do agendador, e veja a seção [reutilização de componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a carregar eficientemente os mesmos componentes em vários pipelines.

## KandinskyV22PriorPipeline[[diffusers.KandinskyV22PriorPipeline]]

#### diffusers.KandinskyV22PriorPipeline[[diffusers.KandinskyV22PriorPipeline]]

```python
diffusers.KandinskyV22PriorPipeline(prior: PriorTransformer, image_encoder: CLIPVisionModelWithProjection, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, scheduler: UnCLIPScheduler, image_processor: CLIPImageProcessorPil)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_prior.py#L88)

**Parâmetros:**

prior ([PriorTransformer](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.PriorTransformer)) : O prior unCLIP canônico para aproximar o embedding da imagem a partir do embedding do texto.

image_encoder (`CLIPVisionModelWithProjection`) : Codificador de imagem congelado.

text_encoder (`CLIPTextModelWithProjection`) : Codificador de texto congelado.

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

scheduler (`UnCLIPScheduler`) : Um agendador a ser usado em combinação com `prior` para gerar incorporação de imagem.

image_processor (`CLIPImageProcessor`) : um image_processor a ser usado para pré-processar imagens do clip.

Pipeline para gerar prior de imagem para Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22PriorPipeline.__call__]]

```python
__call__(prompt: str | list[str], negative_prompt: str | list[str] | None = None, num_images_per_prompt: int = 1, num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, guidance_scale: float = 4.0, output_type: str | None = 'pt', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'])
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_prior.py#L374)

**Parâmetros:**

prompt (`str` ou `list[str]`) : O prompt ou os prompts para orientar a geração da imagem.

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

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

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

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.

guidance_scale (`float`, *opcional*, padrão 4.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.

output_type (`str`, *opcional*, padrão `"pt"`) : O formato de saída da imagem gerada. Escolha entre: `"np"` (`np.array`) ou `"pt"` (`torch.Tensor`).

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** `KandinskyPriorPipelineOutput` ou `tuple`

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

Exemplos:
```py
>>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline
>>> import torch

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior")
>>> pipe_prior.to("cuda")
>>> prompt = "red cat, 4k photo"
>>> image_emb, negative_image_emb = pipe_prior(prompt).to_tuple()

>>> pipe = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder")
>>> pipe.to("cuda")
>>> image = pipe(
...     image_embeds=image_emb,
...     negative_image_embeds=negative_image_emb,
...     height=768,
...     width=768,
...     num_inference_steps=50,
... ).images
>>> image[0].save("cat.png")
```

#### interpolate[[diffusers.KandinskyV22PriorPipeline.interpolate]]

```python
interpolate(images_and_prompts: list, weights: list, num_images_per_prompt: int = 1, num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, negative_prior_prompt: str | None = None, negative_prompt: str = '', guidance_scale: float = 4.0, device = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_prior.py#L135)

**Parâmetros:**

images_and_prompts (`list[str | PIL.Image.Image | torch.Tensor]`) : lista de prompts e imagens para orientar a geração de imagens.

weights : (`list[float]`): lista de pesos para cada condição em `images_and_prompts`

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

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

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.

negative_prior_prompt (`str`, *opcional*) : O prompt para não orientar o processo de difusão anterior. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

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

guidance_scale (`float`, *opcional*, padrão 4.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.

**Retorna:** `KandinskyPriorPipelineOutput` ou `tuple`

Função invocada ao usar o pipeline anterior para interpolação.

Exemplos:
```py
>>> from diffusers import KandinskyV22PriorPipeline, KandinskyV22Pipeline
>>> from diffusers.utils import load_image
>>> import PIL
>>> import torch
>>> from torchvision import transforms

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16
... )
>>> pipe_prior.to("cuda")
>>> img1 = load_image(
...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png"
... )
>>> img2 = load_image(
...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
...     "/kandinsky/starry_night.jpeg"
... )
>>> images_texts = ["a cat", img1, img2]
>>> weights = [0.3, 0.3, 0.4]
>>> out = pipe_prior.interpolate(images_texts, weights)
>>> pipe = KandinskyV22Pipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16
... )
>>> pipe.to("cuda")
>>> image = pipe(
...     image_embeds=out.image_embeds,
...     negative_image_embeds=out.negative_image_embeds,
...     height=768,
...     width=768,
...     num_inference_steps=50,
... ).images[0]
>>> image.save("starry_cat.png")
```

## KandinskyV22Pipeline[[diffusers.KandinskyV22Pipeline]]

#### diffusers.KandinskyV22Pipeline[[diffusers.KandinskyV22Pipeline]]

```python
diffusers.KandinskyV22Pipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2.py#L72)

**Parâmetros:**

scheduler (`DDIMScheduler` | `DDPMScheduler`) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

Pipeline para geração de texto para imagem usando Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22Pipeline.__call__]]

```python
__call__(image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], negative_image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], height: int = 512, width: int = 512, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2.py#L130)

**Parâmetros:**

image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clip para o prompt de texto, que serão usados para condicionar a geração da imagem.

negative_image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clipe para o prompt de texto negativo, que serão usados para condicionar a geração da imagem.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 4.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.

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

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.

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

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:
```py
>>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline
>>> import torch

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained("kandinsky-community/kandinsky-2-2-prior")
>>> pipe_prior.to("cuda")
>>> prompt = "red cat, 4k photo"
>>> out = pipe_prior(prompt)
>>> image_emb = out.image_embeds
>>> zero_image_emb = out.negative_image_embeds
>>> pipe = KandinskyV22Pipeline.from_pretrained("kandinsky-community/kandinsky-2-2-decoder")
>>> pipe.to("cuda")
>>> image = pipe(
...     image_embeds=image_emb,
...     negative_image_embeds=zero_image_emb,
...     height=768,
...     width=768,
...     num_inference_steps=50,
... ).images
>>> image[0].save("cat.png")
```

## KandinskyV22CombinedPipeline[[diffusers.KandinskyV22CombinedPipeline]]

#### diffusers.KandinskyV22CombinedPipeline[[diffusers.KandinskyV22CombinedPipeline]]

```python
diffusers.KandinskyV22CombinedPipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel, prior_prior: PriorTransformer, prior_image_encoder: CLIPVisionModelWithProjection, prior_text_encoder: CLIPTextModelWithProjection, prior_tokenizer: CLIPTokenizer, prior_scheduler: UnCLIPScheduler, prior_image_processor: CLIPImageProcessorPil)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L107)

**Parâmetros:**

scheduler (`DDIMScheduler` | `DDPMScheduler`) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

prior_prior ([PriorTransformer](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.PriorTransformer)) : O prior unCLIP canônico para aproximar o embedding da imagem a partir do embedding do texto.

prior_image_encoder (`CLIPVisionModelWithProjection`) : Codificador de imagem congelado.

prior_text_encoder (`CLIPTextModelWithProjection`) : Codificador de texto congelado.

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

prior_scheduler (`UnCLIPScheduler`) : Um agendador a ser usado em combinação com `prior` para gerar incorporação de imagem.

prior_image_processor (`CLIPImageProcessor`) : um image_processor a ser usado para pré-processar imagens do clip.

Pipeline combinado para geração de texto para imagem usando Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22CombinedPipeline.__call__]]

```python
__call__(prompt: str | list[str], negative_prompt: str | list[str] | None = None, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, height: int = 512, width: int = 512, prior_guidance_scale: float = 4.0, prior_num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True, prior_callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, prior_callback_on_step_end_tensor_inputs: list = ['latents'], callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'])
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L202)

**Parâmetros:**

prompt (`str` ou `list[str]`) : O prompt ou os prompts para orientar a geração da imagem.

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

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

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

prior_guidance_scale (`float`, *opcional*, padrão 4.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.

prior_num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 4.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.

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.

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

callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas durante a inferência. A função é chamada com os seguintes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, padrão 1) : A frequência com que a função `callback` é chamada. Se não for especificada, o callback é chamado a cada etapa.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

prior_callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência do pipeline de prior. A função é chamada com os seguintes argumentos: `prior_callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`.

prior_callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `prior_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 prior.

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência do pipeline do decodificador. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:
```py
from diffusers import AutoPipelineForText2Image
import torch

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()

prompt = "A lion in galaxies, spirals, nebulae, stars, smoke, iridescent, intricate detail, octane render, 8k"

image = pipe(prompt=prompt, num_inference_steps=25).images[0]
```

#### enable_sequential_cpu_offload[[diffusers.KandinskyV22CombinedPipeline.enable_sequential_cpu_offload]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L182)

Desloca todos os modelos para a CPU usando accelerate, reduzindo significativamente o uso de memória. Quando chamado, unet, text_encoder, vae e safety checker têm seus state dicts salvos na CPU e, em seguida, são movidos para um `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called. Note that offloading happens on a submodule basis. Memory savings are higher than with `enable_model_cpu_offload`, but performance is lower.

## KandinskyV22ControlnetPipeline[[diffusers.KandinskyV22ControlnetPipeline]]

#### diffusers.KandinskyV22ControlnetPipeline[[diffusers.KandinskyV22ControlnetPipeline]]

```python
diffusers.KandinskyV22ControlnetPipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_controlnet.py#L114)

**Parâmetros:**

scheduler ([DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler)) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

Pipeline para geração de texto para imagem usando Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22ControlnetPipeline.__call__]]

```python
__call__(image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], negative_image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], hint: Tensor, height: int = 512, width: int = 512, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_controlnet.py#L159)

**Parâmetros:**

hint (`torch.Tensor`) : A condição do controlnet.

image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clip para o prompt de texto, que serão usados para condicionar a geração da imagem.

negative_image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clipe para o prompt de texto negativo, que serão usados para condicionar a geração da imagem.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 4.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.

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

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.

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

callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas durante a inferência. A função é chamada com os seguintes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, padrão 1) : A frequência com que a função `callback` é chamada. Se não for especificada, o callback é chamado a cada etapa.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:

## KandinskyV22PriorEmb2EmbPipeline[[diffusers.KandinskyV22PriorEmb2EmbPipeline]]

#### diffusers.KandinskyV22PriorEmb2EmbPipeline[[diffusers.KandinskyV22PriorEmb2EmbPipeline]]

```python
diffusers.KandinskyV22PriorEmb2EmbPipeline(prior: PriorTransformer, image_encoder: CLIPVisionModelWithProjection, text_encoder: CLIPTextModelWithProjection, tokenizer: CLIPTokenizer, scheduler: UnCLIPScheduler, image_processor: CLIPImageProcessorPil)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_prior_emb2emb.py#L103)

**Parâmetros:**

prior ([PriorTransformer](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.PriorTransformer)) : O prior unCLIP canônico para aproximar o embedding da imagem a partir do embedding do texto.

image_encoder (`CLIPVisionModelWithProjection`) : Codificador de imagem congelado.

text_encoder (`CLIPTextModelWithProjection`) : Codificador de texto congelado.

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

scheduler (`UnCLIPScheduler`) : Um agendador a ser usado em combinação com `prior` para gerar incorporação de imagem.

Pipeline para gerar prior de imagem para Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22PriorEmb2EmbPipeline.__call__]]

```python
__call__(prompt: str | list[str], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], strength: float = 0.3, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int = 1, num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, guidance_scale: float = 4.0, output_type: str | None = 'pt', return_dict: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_prior_emb2emb.py#L397)

**Parâmetros:**

prompt (`str` ou `list[str]`) : O prompt ou os prompts para orientar a geração da imagem.

image (`torch.Tensor`, `PIL.Image.Image`, `list[torch.Tensor]` ou `list[PIL.Image.Image]`) : `Image`, ou tensor representando um lote de imagens, que será usado como ponto de partida para o embedding da imagem. Também pode aceitar latentes de imagem como `image`; se latentes forem passados diretamente, eles não serão codificados novamente.

strength (`float`, *opcional*, padrão 0.8) : 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 desruidamento depende da quantidade de ruído inicialmente adicionada.

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

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

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

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.

guidance_scale (`float`, *opcional*, padrão 4.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.

output_type (`str`, *opcional*, padrão `"pt"`) : O formato de saída da imagem gerada. Escolha entre: `"np"` (`np.array`) ou `"pt"` (`torch.Tensor`).

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

**Retorna:** `KandinskyPriorPipelineOutput` ou `tuple`

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

Exemplos:
```py
>>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorEmb2EmbPipeline
>>> import torch

>>> pipe_prior = KandinskyPriorPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16
... )
>>> pipe_prior.to("cuda")

>>> prompt = "red cat, 4k photo"
>>> img = load_image(
...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png"
... )
>>> image_emb, nagative_image_emb = pipe_prior(prompt, image=img, strength=0.2).to_tuple()

>>> pipe = KandinskyPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-decoder, torch_dtype=torch.float16"
... )
>>> pipe.to("cuda")

>>> image = pipe(
...     image_embeds=image_emb,
...     negative_image_embeds=negative_image_emb,
...     height=768,
...     width=768,
...     num_inference_steps=100,
... ).images

>>> image[0].save("cat.png")
```

#### interpolate[[diffusers.KandinskyV22PriorEmb2EmbPipeline.interpolate]]

```python
interpolate(images_and_prompts: list, weights: list, num_images_per_prompt: int = 1, num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, negative_prior_prompt: str | None = None, negative_prompt: str = '', guidance_scale: float = 4.0, device = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_prior_emb2emb.py#L156)

**Parâmetros:**

images_and_prompts (`list[str | PIL.Image.Image | torch.Tensor]`) : lista de prompts e imagens para orientar a geração de imagens.

weights : (`list[float]`): lista de pesos para cada condição em `images_and_prompts`

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

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

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.

negative_prior_prompt (`str`, *opcional*) : O prompt para não orientar o processo de difusão anterior. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`).

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

guidance_scale (`float`, *opcional*, padrão 4.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.

**Retorna:** `KandinskyPriorPipelineOutput` ou `tuple`

Função invocada ao usar o pipeline anterior para interpolação.

Exemplos:
```py
>>> from diffusers import KandinskyV22PriorEmb2EmbPipeline, KandinskyV22Pipeline
>>> from diffusers.utils import load_image
>>> import PIL

>>> import torch
>>> from torchvision import transforms

>>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-prior", torch_dtype=torch.float16
... )
>>> pipe_prior.to("cuda")

>>> img1 = load_image(
...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png"
... )

>>> img2 = load_image(
...     "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
...     "/kandinsky/starry_night.jpeg"
... )

>>> images_texts = ["a cat", img1, img2]
>>> weights = [0.3, 0.3, 0.4]
>>> image_emb, zero_image_emb = pipe_prior.interpolate(images_texts, weights)

>>> pipe = KandinskyV22Pipeline.from_pretrained(
...     "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16
... )
>>> pipe.to("cuda")

>>> image = pipe(
...     image_embeds=image_emb,
...     negative_image_embeds=zero_image_emb,
...     height=768,
...     width=768,
...     num_inference_steps=150,
... ).images[0]

>>> image.save("starry_cat.png")
```

## KandinskyV22Img2ImgPipeline[[diffusers.KandinskyV22Img2ImgPipeline]]

#### diffusers.KandinskyV22Img2ImgPipeline[[diffusers.KandinskyV22Img2ImgPipeline]]

```python
diffusers.KandinskyV22Img2ImgPipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_img2img.py#L77)

**Parâmetros:**

scheduler ([DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler)) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

Pipeline para geração de imagem a imagem usando Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22Img2ImgPipeline.__call__]]

```python
__call__(image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], negative_image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], height: int = 512, width: int = 512, num_inference_steps: int = 100, guidance_scale: float = 4.0, strength: float = 0.3, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_img2img.py#L182)

**Parâmetros:**

image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clip para o prompt de texto, que serão usados para condicionar a geração da imagem.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image` ou tensor representando um lote de imagens, que será usado como ponto de partida para o processo. Também pode aceitar latentes de imagem como `image`; se latentes forem passados diretamente, eles não serão codificados novamente.

strength (`float`, *opcional*, padrão 0.8) : 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 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 `image`.

negative_image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clipe para o prompt de texto negativo, que serão usados para condicionar a geração da imagem.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 4.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.

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

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.

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

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:

## KandinskyV22Img2ImgCombinedPipeline[[diffusers.KandinskyV22Img2ImgCombinedPipeline]]

#### diffusers.KandinskyV22Img2ImgCombinedPipeline[[diffusers.KandinskyV22Img2ImgCombinedPipeline]]

```python
diffusers.KandinskyV22Img2ImgCombinedPipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel, prior_prior: PriorTransformer, prior_image_encoder: CLIPVisionModelWithProjection, prior_text_encoder: CLIPTextModelWithProjection, prior_tokenizer: CLIPTokenizer, prior_scheduler: UnCLIPScheduler, prior_image_processor: CLIPImageProcessorPil)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L341)

**Parâmetros:**

scheduler (`DDIMScheduler` | `DDPMScheduler`) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

prior_prior ([PriorTransformer](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.PriorTransformer)) : O prior unCLIP canônico para aproximar o embedding da imagem a partir do embedding do texto.

prior_image_encoder (`CLIPVisionModelWithProjection`) : Codificador de imagem congelado.

prior_text_encoder (`CLIPTextModelWithProjection`) : Codificador de texto congelado.

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

prior_scheduler (`UnCLIPScheduler`) : Um agendador a ser usado em combinação com `prior` para gerar incorporação de imagem.

prior_image_processor (`CLIPImageProcessor`) : um image_processor a ser usado para pré-processar imagens do clip.

Pipeline combinado para geração de imagem a imagem usando Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22Img2ImgCombinedPipeline.__call__]]

```python
__call__(prompt: str | list[str], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], negative_prompt: str | list[str] | None = None, num_inference_steps: int = 100, guidance_scale: float = 4.0, strength: float = 0.3, num_images_per_prompt: int = 1, height: int = 512, width: int = 512, prior_guidance_scale: float = 4.0, prior_num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True, prior_callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, prior_callback_on_step_end_tensor_inputs: list = ['latents'], callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'])
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L446)

**Parâmetros:**

prompt (`str` ou `list[str]`) : O prompt ou os prompts para orientar a geração da imagem.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image` ou tensor representando um lote de imagens, que será usado como ponto de partida para o processo. Também pode aceitar latentes de imagem como `image`; se latentes forem passados diretamente, eles não serão codificados novamente.

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

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

guidance_scale (`float`, *opcional*, padrão 4.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.

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

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

prior_guidance_scale (`float`, *opcional*, padrão 4.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.

prior_num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

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.

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

callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas durante a inferência. A função é chamada com os seguintes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, padrão 1) : A frequência com que a função `callback` é chamada. Se não for especificada, o callback é chamado a cada etapa.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

prior_callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência do pipeline de prior. A função é chamada com os seguintes argumentos: `prior_callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`.

prior_callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `prior_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 prior.

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência do pipeline do decodificador. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:
```py
from diffusers import AutoPipelineForImage2Image
import torch
import requests
from io import BytesIO
from PIL import Image
import os

pipe = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder", torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()

prompt = "A fantasy landscape, Cinematic lighting"
negative_prompt = "low quality, bad quality"

url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"

response = requests.get(url)
image = Image.open(BytesIO(response.content)).convert("RGB")
image.thumbnail((768, 768))

image = pipe(prompt=prompt, image=original_image, num_inference_steps=25).images[0]
```

#### enable_model_cpu_offload[[diffusers.KandinskyV22Img2ImgCombinedPipeline.enable_model_cpu_offload]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L416)

Desloca todos os modelos para a CPU usando accelerate, reduzindo o uso de memória com baixo impacto no desempenho. Em comparação com `enable_sequential_cpu_offload`, este método move um modelo inteiro de cada vez para a GPU quando seu método `forward` é chamado, e o modelo permanece na GPU até que o próximo modelo seja executado. As economias de memória são menores do que com `enable_sequential_cpu_offload`, mas o desempenho é muito melhor devido à execução iterativa do `unet`.

#### enable_sequential_cpu_offload[[diffusers.KandinskyV22Img2ImgCombinedPipeline.enable_sequential_cpu_offload]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L426)

Desloca todos os modelos para a CPU usando accelerate, reduzindo significativamente o uso de memória. Quando chamado, unet, text_encoder, vae e safety checker têm seus state dicts salvos na CPU e, em seguida, são movidos para um `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called. Note that offloading happens on a submodule basis. Memory savings are higher than with `enable_model_cpu_offload`, but performance is lower.

## KandinskyV22ControlnetImg2ImgPipeline[[diffusers.KandinskyV22ControlnetImg2ImgPipeline]]

#### diffusers.KandinskyV22ControlnetImg2ImgPipeline[[diffusers.KandinskyV22ControlnetImg2ImgPipeline]]

```python
diffusers.KandinskyV22ControlnetImg2ImgPipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_controlnet_img2img.py#L106)

**Parâmetros:**

scheduler ([DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler)) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

Pipeline para geração de imagem a imagem usando Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22ControlnetImg2ImgPipeline.__call__]]

```python
__call__(image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], negative_image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], hint: Tensor, height: int = 512, width: int = 512, num_inference_steps: int = 100, guidance_scale: float = 4.0, strength: float = 0.3, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, output_type: str | None = 'pil', callback: typing.Optional[typing.Callable[[int, int, torch.Tensor], NoneType]] = None, callback_steps: int = 1, return_dict: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_controlnet_img2img.py#L199)

**Parâmetros:**

image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clip para o prompt de texto, que serão usados para condicionar a geração da imagem.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image` ou tensor representando um lote de imagens, que será usado como ponto de partida para o processo. Também pode aceitar latentes de imagem como `image`; se latentes forem passados diretamente, eles não serão codificados novamente.

strength (`float`, *opcional*, padrão 0.8) : 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 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 `image`.

hint (`torch.Tensor`) : A condição do controlnet.

negative_image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clipe para o prompt de texto negativo, que serão usados para condicionar a geração da imagem.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 4.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.

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

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.

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

callback (`Callable`, *opcional*) : Uma função que é chamada a cada `callback_steps` etapas durante a inferência. A função é chamada com os seguintes argumentos: `callback(step: int, timestep: int, latents: torch.Tensor)`.

callback_steps (`int`, *opcional*, padrão 1) : A frequência com que a função `callback` é chamada. Se não for especificada, o callback é chamado a cada etapa.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:

## KandinskyV22InpaintPipeline[[diffusers.KandinskyV22InpaintPipeline]]

#### diffusers.KandinskyV22InpaintPipeline[[diffusers.KandinskyV22InpaintPipeline]]

```python
diffusers.KandinskyV22InpaintPipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_inpainting.py#L242)

**Parâmetros:**

scheduler ([DDIMScheduler](/docs/diffusers/main/pt/api/schedulers/ddim#diffusers.DDIMScheduler)) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

Pipeline para inpainting de imagem guiado por texto usando Kandinsky2.1

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22InpaintPipeline.__call__]]

```python
__call__(image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], image: typing.Union[torch.Tensor, PIL.Image.Image], mask_image: typing.Union[PIL.Image.Image, torch.Tensor, numpy.ndarray], negative_image_embeds: typing.Union[torch.Tensor, list[torch.Tensor]], height: int = 512, width: int = 512, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_inpainting.py#L301)

**Parâmetros:**

image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clip para o prompt de texto, que serão usados para condicionar a geração da imagem.

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 (`np.array`) : 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, deve conter um canal de cor (L) em vez de 3, portanto a forma esperada seria `(B, H, W, 1)`.

negative_image_embeds (`torch.Tensor` ou `list[torch.Tensor]`) : Os embeddings de imagem do clipe para o prompt de texto negativo, que serão usados para condicionar a geração da imagem.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

guidance_scale (`float`, *opcional*, padrão 4.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.

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

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.

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

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:

## KandinskyV22InpaintCombinedPipeline[[diffusers.KandinskyV22InpaintCombinedPipeline]]

#### diffusers.KandinskyV22InpaintCombinedPipeline[[diffusers.KandinskyV22InpaintCombinedPipeline]]

```python
diffusers.KandinskyV22InpaintCombinedPipeline(unet: UNet2DConditionModel, scheduler: DDPMScheduler, movq: VQModel, prior_prior: PriorTransformer, prior_image_encoder: CLIPVisionModelWithProjection, prior_text_encoder: CLIPTextModelWithProjection, prior_tokenizer: CLIPTokenizer, prior_scheduler: UnCLIPScheduler, prior_image_processor: CLIPImageProcessorPil)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L607)

**Parâmetros:**

scheduler (`DDIMScheduler` | `DDPMScheduler`) : Um agendador a ser usado em combinação com `unet` para gerar latentes de imagem.

unet ([UNet2DConditionModel](/docs/diffusers/main/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel)) : Arquitetura de U-Net condicional para desruidar o embedding da imagem.

movq ([VQModel](/docs/diffusers/main/pt/api/models/vq#diffusers.VQModel)) : Decodificador MoVQ para gerar a imagem a partir dos latentes.

prior_prior ([PriorTransformer](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.PriorTransformer)) : O prior unCLIP canônico para aproximar o embedding da imagem a partir do embedding do texto.

prior_image_encoder (`CLIPVisionModelWithProjection`) : Codificador de imagem congelado.

prior_text_encoder (`CLIPTextModelWithProjection`) : Codificador de texto congelado.

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

prior_scheduler (`UnCLIPScheduler`) : Um agendador a ser usado em combinação com `prior` para gerar incorporação de imagem.

prior_image_processor (`CLIPImageProcessor`) : um image_processor a ser usado para pré-processar imagens do clip.

Pipeline combinado para geração de inpainting usando Kandinsky

Este modelo herda de [DiffusionPipeline](/docs/diffusers/main/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.)

#### __call__[[diffusers.KandinskyV22InpaintCombinedPipeline.__call__]]

```python
__call__(prompt: str | list[str], image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], mask_image: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]], negative_prompt: str | list[str] | None = None, num_inference_steps: int = 100, guidance_scale: float = 4.0, num_images_per_prompt: int = 1, height: int = 512, width: int = 512, prior_guidance_scale: float = 4.0, prior_num_inference_steps: int = 25, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, prior_callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, prior_callback_on_step_end_tensor_inputs: list = ['latents'], callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list = ['latents'], **kwargs)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L702)

**Parâmetros:**

prompt (`str` ou `list[str]`) : O prompt ou os prompts para orientar a geração da imagem.

image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` ou `list[np.ndarray]`) : `Image` ou tensor representando um lote de imagens, que será usado como ponto de partida para o processo. Também pode aceitar latentes de imagem como `image`; se latentes forem passados diretamente, eles não serão codificados novamente.

mask_image (`np.array`) : 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, deve conter um canal de cor (L) em vez de 3, portanto a forma esperada seria `(B, H, W, 1)`.

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

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

guidance_scale (`float`, *opcional*, padrão 4.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.

num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

height (`int`, *opcional*, padrão 512) : A altura em pixels da imagem gerada.

width (`int`, *opcional*, padrão 512) : A largura em pixels da imagem gerada.

prior_guidance_scale (`float`, *opcional*, padrão 4.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.

prior_num_inference_steps (`int`, *opcional*, padrão 100) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, às custas de uma inferência mais lenta.

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.

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

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) em vez de uma tupla simples.

prior_callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: `prior_callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`.

prior_callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `prior_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.

callback_on_step_end (`Callable`, *opcional*) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline.

**Retorna:** [ImagePipelineOutput](/docs/diffusers/main/pt/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) ou `tuple`

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

Exemplos:
```py
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image
import torch
import numpy as np

pipe = AutoPipelineForInpainting.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder-inpaint", torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()

prompt = "A fantasy landscape, Cinematic lighting"
negative_prompt = "low quality, bad quality"

original_image = load_image(
    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/kandinsky/cat.png"
)

mask = np.zeros((768, 768), dtype=np.float32)
# Let's mask out an area above the cat's head
mask[:250, 250:-250] = 1

image = pipe(prompt=prompt, image=original_image, mask_image=mask, num_inference_steps=25).images[0]
```

#### enable_sequential_cpu_offload[[diffusers.KandinskyV22InpaintCombinedPipeline.enable_sequential_cpu_offload]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky2_2/pipeline_kandinsky2_2_combined.py#L682)

Desloca todos os modelos para a CPU usando accelerate, reduzindo significativamente o uso de memória. Quando chamado, unet, text_encoder, vae e safety checker têm seus state dicts salvos na CPU e, em seguida, são movidos para um `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called. Note that offloading happens on a submodule basis. Memory savings are higher than with `enable_model_cpu_offload`, but performance is lower.