Buckets:

hf-doc-build
/

doc

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

[Kandinsky 5.0](https://arxiv.org/abs/2511.14993) es una familia de modelos de difusión para la generación de video e imágenes.

Kandinsky 5.0 Image Lite es un modelo ligero de generación de imágenes (6B parámetros).

El modelo introduce varias innovaciones clave:
- **Pipeline de difusión latente** con **Flow Matching** para mejorar la estabilidad del entrenamiento
- **Diffusion Transformer (DiT)** como columna vertebral generativa principal, con atención cruzada a los incrustados de texto
- Codificación de texto dual usando **Qwen2.5-VL** y **CLIP** para una comprensión exhaustiva del texto
- **Flux VAE** para la codificación y decodificación de imágenes de forma eficiente

El código original se puede encontrar en [kandinskylab/Kandinsky-5](https://github.com/kandinskylab/Kandinsky-5).

> [!TIP]
> Consulta la organización [Kandinsky Lab](https://huggingface.co/kandinskylab) en el Hub para los puntos de control oficiales de modelos para la generación de texto a video, que incluyen variantes preentrenadas, SFT, no-CFG y destiladas.

## Modelos disponibles

Kandinsky 5.0 Image Lite:

| model_id | Descripción | 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 imágenes con ajuste fino supervisado | Mejor calidad de generación |
| [**kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-I2I-Lite-sft-Diffusers) | Modelo de 6B para edición de imágenes con ajuste fino supervisado | Mejor calidad de generación |
| [**kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-T2I-Lite-pretrain-Diffusers) | Modelo preentrenado base de imagen 6B | Investigación y ajuste fino |
| [**kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers**](https://huggingface.co/kandinskylab/Kandinsky-5.0-I2I-Lite-pretrain-Diffusers) | Modelo preentrenado base de edición de imágenes 6B | Investigación y ajuste fino |
## Ejemplos de uso
### Generación básica de texto a imagen
```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]
```
### Generación básica de imagen a imagen

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

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

**Parámetros:**

transformer (`Kandinsky5Transformer3DModel`) : Transformer condicional para desruidar los latentes de imagen codificados.

vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Autoencoder Variacional [black-forest-labs/FLUX.1-dev (vae)](https://huggingface.co/black-forest-labs/FLUX.1-dev) para codificar y decodificar videos a y desde representaciones 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, específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).
tokenizer_2 (`CLIPTokenizer`) : Tokenizador para CLIP.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

Pipeline para la generación de imágenes a partir de texto usando Kandinsky 5.0.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un 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)
```

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

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, pase `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts a evitar durante la generación de imágenes. Si no se define, pase `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale` < `1`).

height (`int`, por defecto `1024`) : La altura en píxeles de la imagen generada.

width (`int`, por defecto `1024`) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido.

guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en la guía libre de clasificador.
num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un generador de torch para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados.

prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto de Qwen pregenerados.

prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pregenerados.

negative_prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto negativo de Qwen pregenerados.
negative_prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto negativos de CLIP pregenerados.

prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Longitudes de secuencia acumuladas pregeneradas para el prompt positivo de Qwen.

negative_prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Longitudes de secuencia acumuladas pregeneradas para el prompt negativo de Qwen.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve o no una `KandinskyImagePipelineOutput`.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Una función que se llama al final de cada paso de desruido.

callback_on_step_end_tensor_inputs (`List`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`.

max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia para la codificación de texto.

**Devuelve:** `~KandinskyImagePipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `KandinskyImagePipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas.

La función de llamada al pipeline para la generación de texto a imagen.

Ejemplos:

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

[Fuente](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 la guía
height : Altura de la imagen
width : Ancho de la imagen
prompt_embeds_qwen : Embeddings de prompts de Qwen precalculados
prompt_embeds_clip : Embeddings de prompts CLIP precalculados
negative_prompt_embeds_qwen : Embeddings de prompts negativos precalculados de Qwen

negative_prompt_embeds_clip : Embeddings de prompts negativos precalculados de CLIP
prompt_cu_seqlens : Longitudes de secuencia acumuladas precalculadas para el prompt positivo de Qwen
negative_prompt_cu_seqlens : Longitudes de secuencia acumuladas precalculadas para el prompt negativo de Qwen

callback_on_step_end_tensor_inputs : Entradas de tensor de callback
**Excepciones:** ``ValueError``
- ``ValueError`` -- Si las entradas no son válidas
Validar los parámetros de entrada del 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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_t2i.py#L289)
**Parámetros:**
prompt (`str` o `list[str]`) : Prompt que se codificará.
num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de imágenes a generar por indicación.

max_sequence_length (`int`, *opcional*, valor predeterminado 512) : Longitud máxima de la secuencia para la codificación de texto. Debe ser menor que 1024

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

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

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

- Incrustaciones de texto de 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)
- Longitudes de secuencia acumuladas (`cu_seqlens`) para los embeddings de Qwen de forma (batch_size * num_images_per_prompt + 1,)

Codifica un único prompt (positivo o negativo) en estados ocultos del codificador de texto.

Este método combina los embeddings de los codificadores de texto de Qwen2.5-VL y CLIP para crear representaciones de texto integrales para la generación de imágenes.

#### 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)
```

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

**Parámetros:**

batch_size (int) : Número de imágenes a generar
num_channels_latents (int) : Número de canales en el espacio latente
height (int) : Altura de la imagen generada
width (int) : Ancho de la imagen generada
dtype (torch.dtype) : Tipo de datos para los latentes
device (torch.device) : Dispositivo en el que se crearán los latentes
generator (torch.Generator) : Generador de números aleatorios
latents (torch.Tensor) : Latentes existentes para usar
**Devuelve:** `torch.Tensor`
Tensor latente preparado
Prepara las variables latentes iniciales para la generación de imágenes a partir de texto.
Este método crea latentes de ruido aleatorio
## 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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L120)
**Parámetros:**
transformer (`Kandinsky5Transformer3DModel`) : Transformer condicional para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Autoencoder Variacional [black-forest-labs/FLUX.1-dev (vae)](https://huggingface.co/black-forest-labs/FLUX.1-dev) para codificar y decodificar videos a y desde representaciones 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, específicamente la variante [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer_2 (`CLIPTokenizer`) : Tokenizador para CLIP.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
Pipeline para la generación de imagen a imagen usando Kandinsky 5.0.
Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un 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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L567)
**Parámetros:**
image (`PipelineImageInput`) : La imagen de entrada para condicionar la generación. Debe ser una imagen, una lista de imágenes o un `torch.Tensor`.
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, pase `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts a evitar durante la generación de imágenes. Si no se define, pase `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale` < `1`).

height (`int`) : La altura en píxeles de la imagen generada.

width (`int`) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido.

guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en la guía libre de clasificador.
num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un generador de torch para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados.

prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto de Qwen pregenerados.

prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto CLIP pregenerados.

negative_prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto negativo de Qwen pregenerados.
negative_prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto negativos de CLIP pregenerados.

prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Longitudes de secuencia acumuladas pregeneradas para el prompt positivo de Qwen.

negative_prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Longitudes de secuencia acumuladas pregeneradas para el prompt negativo de Qwen.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve o no una `KandinskyImagePipelineOutput`.
callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Una función que se llama al final de cada paso de desruido.

callback_on_step_end_tensor_inputs (`List`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`.

max_sequence_length (`int`, por defecto `1024`) : La longitud máxima de secuencia para la codificación de texto e imagen de qwen. Debe ser menor que 1024

**Devuelve:** `~KandinskyImagePipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `KandinskyImagePipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas.

La función de llamada al pipeline para la generación de imagen a imagen.

Ejemplos:

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

[Fuente](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 la guía
image : Imagen de entrada para el condicionamiento
height : Altura de la imagen
width : Ancho de la imagen
prompt_embeds_qwen : Embeddings de prompts de Qwen precalculados
prompt_embeds_clip : Embeddings de prompts CLIP precalculados
negative_prompt_embeds_qwen : Embeddings de prompts negativos precalculados de Qwen

negative_prompt_embeds_clip : Embeddings de prompts negativos precalculados de CLIP
prompt_cu_seqlens : Longitudes de secuencia acumuladas precalculadas para el prompt positivo de Qwen
negative_prompt_cu_seqlens : Longitudes de secuencia acumuladas precalculadas para el prompt negativo de Qwen

callback_on_step_end_tensor_inputs : Entradas de tensor de callback
**Excepciones:** ``ValueError``
- ``ValueError`` -- Si las entradas no son válidas
Validar los parámetros de entrada del 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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2i.py#L295)
**Parámetros:**
prompt (`str` o `list[str]`) : Prompt que se codificará.
num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de imágenes a generar por indicación.

max_sequence_length (`int`, *opcional*, valor predeterminado 1024) : Longitud máxima de la secuencia para la codificación de texto. Debe ser menor que 1024

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

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

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

- Incrustaciones de texto de 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)
- Longitudes de secuencia acumuladas (`cu_seqlens`) para los embeddings de Qwen de forma (batch_size * num_images_per_prompt + 1,)

Codifica un único prompt (positivo o negativo) en estados ocultos del codificador de texto.

Este método combina los embeddings de los codificadores de texto de Qwen2.5-VL y CLIP para crear representaciones de texto integrales para la generación de imágenes.

#### 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)
```

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

**Parámetros:**

image (PipelineImageInput) : Imagen de entrada para condicionar la generación

batch_size (int) : Número de imágenes a generar
num_channels_latents (int) : Número de canales en el espacio latente
height (int) : Altura de la imagen generada
width (int) : Ancho de la imagen generada
dtype (torch.dtype) : Tipo de datos para los latentes
device (torch.device) : Dispositivo en el que se crearán los latentes
generator (torch.Generator) : Generador de números aleatorios
latents (torch.Tensor) : Latentes existentes para usar
**Devuelve:** `torch.Tensor`
Tensor latente preparado con la imagen codificada
Prepara las variables latentes iniciales para la generación de imagen a imagen.
Este método crea latentes de ruido aleatorio con la imagen codificada,
## Cita
```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.8 kB
Xet hash:: 59b9a0ba1d93f8a562dafe154a6a1be541ebe8e6a082ed61f9e7feda02a6623c
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.