Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /pt /api /pipelines /kandinsky5_image.md
mishig
3 days ago
preview code
download
raw
27.6 kB
# Imagem Kandinsky 5.0

[Kandinsky 5.0](https://arxiv.org/abs/2511.14993) é uma família de modelos de difusão para geração de Vídeo & Imagem.

Kandinsky 5.0 Image Lite é um modelo leve de geração de imagens (6B parâmetros).

O modelo introduz várias inovações principais:
- **Pipeline de difusão latente** com **Flow Matching** para melhorar a estabilidade do treinamento
- **Diffusion Transformer (DiT)** como o backbone generativo principal, com cross-attention para embeddings de texto
- Codificação dupla de texto usando **Qwen2.5-VL** e **CLIP** para uma compreensão abrangente do texto
- **Flux VAE** para codificação e decodificação eficientes de imagens

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

> [!TIP]
> Confira a organização [Kandinsky Lab](https://huggingface.co/kandinskylab) no Hub para os checkpoints oficiais de modelos para geração de texto para vídeo, incluindo variantes pré-treinadas, SFT, no-CFG e destiladas.

## Modelos Disponíveis

Kandinsky 5.0 Image Lite:

| model_id | Descrição | Casos de Uso |
|------------|-------------|-----------|
| [**kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers) | Modelo de 6B de imagens com ajuste fino supervisionado | Maior qualidade de geração |
| [**kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers) | Modelo de edição de imagem de 6B com ajuste fino supervisionado | Maior qualidade de geração |
| [**kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers) | Modelo pré-treinado base de imagem 6B | Pesquisa e ajuste fino |
| [**kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers) | Modelo pré-treinado base de edição de imagem 6B | Pesquisa e ajuste fino |
## Exemplos de uso
### Geração básica de texto para imagem
```python
import torch
from diffusers import Kandinsky5T2IPipeline
# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
pipe = Kandinsky5T2IPipeline.from_pretrained(model_id)
_ = pipe.to(device='cuda',dtype=torch.bfloat16)  # or "mps", "xpu", "cpu"

# Generate image
prompt = "A fluffy, expressive cat wearing a bright red hat with a soft, slightly textured fabric. The hat should look cozy and well-fitted on the cat’s head. On the front of the hat, add clean, bold white text that reads “SWEET”, clearly visible and neatly centered. Ensure the overall lighting highlights the hat’s color and the cat’s fur details."

output = pipe(
    prompt=prompt,
    negative_prompt="",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).image[0]
```
### Geração básica de imagem para imagem

```python
import torch
from diffusers import Kandinsky5I2IPipeline
from diffusers.utils import load_image 
# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers"
pipe = Kandinsky5I2IPipeline.from_pretrained(model_id)
_ = pipe.to(device='cuda',dtype=torch.bfloat16)  # or "mps", "xpu", "cpu"
pipe.enable_model_cpu_offload()                                               # <--- Enable CPU offloading for single GPU inference
# Edit the input image
image = load_image(
    "https://huggingface.co/kandinsky-community/kandinsky-3/resolve/main/assets/title.jpg?download=true"
)
prompt = "Change the background from a winter night scene to a bright summer day. Place the character on a sandy beach with clear blue sky, soft sunlight, and gentle waves in the distance. Replace the winter clothing with a light short-sleeved T-shirt (in soft pastel colors) and casual shorts. Ensure the character’s fur reflects warm daylight instead of cold winter tones. Add small beach details such as seashells, footprints in the sand, and a few scattered beach toys nearby. Keep the oranges in the scene, but place them naturally on the sand."
negative_prompt = ""
output = pipe(
    image=image,
    prompt=prompt,
    negative_prompt=negative_prompt,
    guidance_scale=3.5,
).image[0]
```

## Kandinsky5T2IPipeline[[diffusers.Kandinsky5T2IPipeline]]

#### diffusers.Kandinsky5T2IPipeline[[diffusers.Kandinsky5T2IPipeline]]

```python
diffusers.Kandinsky5T2IPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKL, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L120)

**Parâmetros:**

transformer (`Kandinsky5Transformer3DModel`) : Transformer condicional para desruidar os latentes de imagem codificados.

vae ([AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder [black-forest-labs/FLUX.1-dev (vae)](https://huggingface.co/black-forest-labs/FLUX.1-dev) para codificar e decodificar vídeos para e a partir de representações latentes.

text_encoder (`Qwen2_5_VLForConditionalGeneration`) : codificador de texto congelado [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`AutoProcessor`) : Tokenizador para Qwen2.5-VL.
text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) congelado, especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
tokenizer_2 (`CLIPTokenizer`) : Tokenizador para CLIP.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.

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

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 implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

#### __call__[[diffusers.Kandinsky5T2IPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 1024, width: int = 1024, num_inference_steps: int = 50, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, prompt_embeds_clip: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_clip: typing.Optional[torch.Tensor] = None, prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, negative_prompt_cu_seqlens: 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], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L534)

**Parâmetros:**

prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, passe `prompt_embeds` em vez disso.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts a evitar durante a geração de imagem. Se não definido, passe `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale` < `1`).

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

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

num_inference_steps (`int`, padrão `50`) : O número de etapas de desruido.

guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida na orientação livre de classificador.
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 gerador do torch para tornar a geração determinística.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados.

prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto Qwen pré-gerados.

prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pré-gerados.

negative_prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto negativo do Qwen pré-gerados.
negative_prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto negativos do CLIP pré-gerados.

prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos de sequência pré-gerados para o prompt positivo do Qwen.

negative_prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos de sequência pré-gerados para o prompt negativo do Qwen.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `KandinskyImagePipelineOutput`.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função que é chamada no final de cada etapa de remoção de ruído.

callback_on_step_end_tensor_inputs (`List`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`.

max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência para a codificação de texto.

**Retorna:** `~KandinskyImagePipelineOutput` ou `tuple`

Se `return_dict` for `True`, `KandinskyImagePipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas.

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

Exemplos:

```python
>>> import torch
>>> from diffusers import Kandinsky5T2IPipeline
>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers
>>> model_id = "kandinskylab/Kandinsky-5.0-T2I-Lite-sft-Diffusers"
>>> pipe = Kandinsky5T2IPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe = pipe.to("cuda")
>>> prompt = "A cat and a dog baking a cake together in a kitchen."
>>> output = pipe(
...     prompt=prompt,
...     negative_prompt="",
...     height=1024,
...     width=1024,
...     num_inference_steps=50,
...     guidance_scale=3.5,
... ).frames[0]
```

#### check_inputs[[diffusers.Kandinsky5T2IPipeline.check_inputs]]

```python
check_inputs(prompt, negative_prompt, height, width, prompt_embeds_qwen = None, prompt_embeds_clip = None, negative_prompt_embeds_qwen = None, negative_prompt_embeds_clip = None, prompt_cu_seqlens = None, negative_prompt_cu_seqlens = None, callback_on_step_end_tensor_inputs = None, max_sequence_length = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L380)

**Parâmetros:**

prompt : Prompt de entrada

negative_prompt : Prompt negativo para orientação
height : Altura da imagem
width : Largura da imagem
prompt_embeds_qwen : Embeddings de prompt do Qwen pré-computados
prompt_embeds_clip : Embeddings de prompt CLIP pré-computados
negative_prompt_embeds_qwen : Embeddings de prompt negativo pré-computados do Qwen

negative_prompt_embeds_clip : Embeddings de prompt negativo pré-computados do CLIP
prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt positivo do Qwen
negative_prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt negativo do Qwen

callback_on_step_end_tensor_inputs : Entradas de tensor de callback
**Exceções:** ``ValueError``
- ``ValueError`` -- Se as entradas forem inválidas
Valide os parâmetros de entrada do pipeline.
#### encode_prompt[[diffusers.Kandinsky5T2IPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], num_images_per_prompt: int = 1, max_sequence_length: int = 512, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L289)
**Parâmetros:**
prompt (`str` ou `list[str]`) : Prompt a ser codificado.
num_images_per_prompt (`int`, *opcional*, padrão 1) : Número de imagens a serem geradas por prompt.

max_sequence_length (`int`, *opcional*, padrão 512) : Comprimento máximo da sequência para codificação de texto. Deve ser menor que 1024

device (`torch.device`, *opcional*) : Dispositivo Torch.

dtype (`torch.dtype`, *opcional*) : dtype do Torch.

**Retorna:** tuple[torch.Tensor, torch.Tensor, torch.Tensor]

- Incorporações de texto Qwen de forma (batch_size * num_images_per_prompt, sequence_length, embedding_dim)
- CLIP pooled embeddings de forma (batch_size * num_images_per_prompt, clip_embedding_dim)
- Comprimentos de sequência cumulativos (`cu_seqlens`) para embeddings do Qwen, com forma (batch_size * num_images_per_prompt + 1,)

Codifica um único prompt (positivo ou negativo) em estados ocultos do codificador de texto.

Este método combina embeddings dos codificadores de texto Qwen2.5-VL e CLIP para criar representações de texto abrangentes para a geração de imagens.

#### prepare_latents[[diffusers.Kandinsky5T2IPipeline.prepare_latents]]

```python
prepare_latents(batch_size: int, num_channels_latents: int = 16, height: int = 1024, width: int = 1024, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L469)

**Parâmetros:**

batch_size (int) : Número de imagens a serem geradas
num_channels_latents (int) : Número de canais no espaço latente
height (int) : Altura da imagem gerada
width (int) : Largura da imagem gerada
dtype (torch.dtype) : Tipo de dados para latentes
device (torch.device) : Dispositivo em que os latentes serão criados
generator (torch.Generator) : Gerador de números aleatórios
latents (torch.Tensor) : Latentes preexistentes para usar
**Retorna:** `torch.Tensor`
Tensor latente preparado
Prepare variáveis latentes iniciais para a geração de imagem a partir de texto.
Este método cria latentes de ruído aleatório
## Kandinsky5I2IPipeline[[diffusers.Kandinsky5I2IPipeline]]
#### diffusers.Kandinsky5I2IPipeline[[diffusers.Kandinsky5I2IPipeline]]
```python
diffusers.Kandinsky5I2IPipeline(transformer: Kandinsky5Transformer3DModel, vae: AutoencoderKL, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2VLProcessor, text_encoder_2: CLIPTextModel, tokenizer_2: CLIPTokenizer, scheduler: FlowMatchEulerDiscreteScheduler)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L120)
**Parâmetros:**
transformer (`Kandinsky5Transformer3DModel`) : Transformer condicional para desruidar os latentes de imagem codificados.
vae ([AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder [black-forest-labs/FLUX.1-dev (vae)](https://huggingface.co/black-forest-labs/FLUX.1-dev) para codificar e decodificar vídeos para e a partir de representações latentes.
text_encoder (`Qwen2_5_VLForConditionalGeneration`) : codificador de texto congelado [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).

tokenizer (`AutoProcessor`) : Tokenizador para Qwen2.5-VL.

text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) congelado, especificamente a variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer_2 (`CLIPTokenizer`) : Tokenizador para CLIP.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/pt/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Um scheduler a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada.
Pipeline para geração de imagem a imagem usando Kandinsky 5.0.
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 implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).
#### __call__[[diffusers.Kandinsky5I2IPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, guidance_scale: float = 3.5, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, prompt_embeds_clip: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_qwen: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_clip: typing.Optional[torch.Tensor] = None, prompt_cu_seqlens: typing.Optional[torch.Tensor] = None, negative_prompt_cu_seqlens: 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], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 1024)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L567)
**Parâmetros:**
image (`PipelineImageInput`) : A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou um `torch.Tensor`.
prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, passe `prompt_embeds` em vez disso.

negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts a evitar durante a geração de imagem. Se não definido, passe `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale` < `1`).

height (`int`) : A altura, em pixels, da imagem gerada.

width (`int`) : A largura, em pixels, da imagem gerada.

num_inference_steps (`int`, padrão `50`) : O número de etapas de desruido.

guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida na orientação livre de classificador.
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 gerador do torch para tornar a geração determinística.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados.

prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto Qwen pré-gerados.

prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pré-gerados.

negative_prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto negativo do Qwen pré-gerados.
negative_prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto negativos do CLIP pré-gerados.

prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos de sequência pré-gerados para o prompt positivo do Qwen.

negative_prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Comprimentos cumulativos de sequência pré-gerados para o prompt negativo do Qwen.
output_type (`str`, *opcional*, padrão `"pil"`) : O formato de saída da imagem gerada.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `KandinskyImagePipelineOutput`.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Uma função que é chamada no final de cada etapa de remoção de ruído.

callback_on_step_end_tensor_inputs (`List`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`.

max_sequence_length (`int`, padrão `1024`) : O comprimento máximo da sequência para a codificação de texto e imagem do qwen. Deve ser menor que 1024

**Retorna:** `~KandinskyImagePipelineOutput` ou `tuple`

Se `return_dict` for `True`, `KandinskyImagePipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas.

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

Exemplos:

```python
>>> import torch
>>> from diffusers import Kandinsky5I2IPipeline
>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers
>>> # kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers
>>> model_id = "kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers"
>>> pipe = Kandinsky5I2IPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe = pipe.to("cuda")
>>> prompt = "A cat and a dog baking a cake together in a kitchen."
>>> output = pipe(
...     prompt=prompt,
...     negative_prompt="",
...     height=1024,
...     width=1024,
...     num_inference_steps=50,
...     guidance_scale=3.5,
... ).frames[0]
```

#### check_inputs[[diffusers.Kandinsky5I2IPipeline.check_inputs]]

```python
check_inputs(prompt, negative_prompt, image, height, width, prompt_embeds_qwen = None, prompt_embeds_clip = None, negative_prompt_embeds_qwen = None, negative_prompt_embeds_clip = None, prompt_cu_seqlens = None, negative_prompt_cu_seqlens = None, callback_on_step_end_tensor_inputs = None, max_sequence_length = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L388)

**Parâmetros:**

prompt : Prompt de entrada

negative_prompt : Prompt negativo para orientação
image : Imagem de entrada para condicionamento
height : Altura da imagem
width : Largura da imagem
prompt_embeds_qwen : Embeddings de prompt do Qwen pré-computados
prompt_embeds_clip : Embeddings de prompt CLIP pré-computados
negative_prompt_embeds_qwen : Embeddings de prompt negativo pré-computados do Qwen

negative_prompt_embeds_clip : Embeddings de prompt negativo pré-computados do CLIP
prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt positivo do Qwen
negative_prompt_cu_seqlens : Comprimentos cumulativos pré-computados da sequência para o prompt negativo do Qwen

callback_on_step_end_tensor_inputs : Entradas de tensor de callback
**Exceções:** ``ValueError``
- ``ValueError`` -- Se as entradas forem inválidas
Valide os parâmetros de entrada do pipeline.
#### encode_prompt[[diffusers.Kandinsky5I2IPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], image: Tensor, num_images_per_prompt: int = 1, max_sequence_length: int = 1024, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L295)
**Parâmetros:**
prompt (`str` ou `list[str]`) : Prompt a ser codificado.
num_images_per_prompt (`int`, *opcional*, padrão 1) : Número de imagens a serem geradas por prompt.

max_sequence_length (`int`, *opcional*, padrão 1024) : Comprimento máximo da sequência para codificação de texto. Deve ser menor que 1024

device (`torch.device`, *opcional*) : Dispositivo Torch.

dtype (`torch.dtype`, *opcional*) : dtype do Torch.

**Retorna:** tuple[torch.Tensor, torch.Tensor, torch.Tensor]

- Incorporações de texto Qwen de forma (batch_size * num_images_per_prompt, sequence_length, embedding_dim)
- CLIP pooled embeddings de forma (batch_size * num_images_per_prompt, clip_embedding_dim)
- Comprimentos de sequência cumulativos (`cu_seqlens`) para embeddings do Qwen, com forma (batch_size * num_images_per_prompt + 1,)

Codifica um único prompt (positivo ou negativo) em estados ocultos do codificador de texto.

Este método combina embeddings dos codificadores de texto Qwen2.5-VL e CLIP para criar representações de texto abrangentes para a geração de imagens.

#### prepare_latents[[diffusers.Kandinsky5I2IPipeline.prepare_latents]]

```python
prepare_latents(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], batch_size: int, num_channels_latents: int = 16, height: int = 1024, width: int = 1024, dtype: typing.Optional[torch.dtype] = None, device: typing.Optional[torch.device] = None, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L482)

**Parâmetros:**

image (PipelineImageInput) : Imagem de entrada para condicionar a geração

batch_size (int) : Número de imagens a serem geradas
num_channels_latents (int) : Número de canais no espaço latente
height (int) : Altura da imagem gerada
width (int) : Largura da imagem gerada
dtype (torch.dtype) : Tipo de dados para latentes
device (torch.device) : Dispositivo em que os latentes serão criados
generator (torch.Generator) : Gerador de números aleatórios
latents (torch.Tensor) : Latentes preexistentes para usar
**Retorna:** `torch.Tensor`
Tensor latente preparado com a imagem codificada
Prepare variáveis latentes iniciais para a geração de imagem para imagem.
Este método cria latentes de ruído aleatório com a imagem codificada,
## Citação
```bibtex
@misc{kandinsky2025,
    author = {Alexander Belykh and Alexander Varlamov and Alexey Letunovskiy and Anastasia Aliaskina and Anastasia Maltseva and Anastasiia Kargapoltseva and Andrey Shutkin and Anna Averchenkova and Anna Dmitrienko and Bulat Akhmatov and Denis Dimitrov and Denis Koposov and Denis Parkhomenko and Dmitrii and Ilya Vasiliev and Ivan Kirillov and Julia Agafonova and Kirill Chernyshev and Kormilitsyn Semen and Lev Novitskiy and Maria Kovaleva and Mikhail Mamaev and Mikhailov and Nikita Kiselev and Nikita Osterov and Nikolai Gerasimenko and Nikolai Vaulin and Olga Kim and Olga Vdovchenko and Polina Gavrilova and Polina Mikhailova and Tatiana Nikulina and Viacheslav Vasilev and Vladimir Arkhipkin and Vladimir Korviakov and Vladimir Polovnikov and Yury Kolabushin},
    title = {Kandinsky 5.0: A family of diffusion models for Video & Image generation},
    howpublished = {\url{https://github.com/kandinskylab/Kandinsky-5}},
    year = 2025
}
```
Xet Storage Details

Size:: 27.6 kB
Xet hash:: d5018af7259d92a20095aecad536146f1f2319398b6460fec79514a4a1c8d593
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.