# Kandinsky 5.0 Video

[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 Lite, una línea de modelos ligeros de generación de video (2B parámetros) que ocupa el puesto #1 entre los modelos de código abierto de su clase. Supera a modelos más grandes y ofrece la mejor comprensión de conceptos rusos en el ecosistema de código abierto.

Kandinsky 5.0 Pro, una línea de modelos de gran tamaño para la generación de videos de alta calidad (19 mil millones de parámetros). Ofrece una generación de alta calidad en HD y más formatos de generación, como I2V.

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
- **HunyuanVideo 3D VAE** para la codificación y decodificación eficientes de video
- **Mecanismos de atención dispersa** (NABLA) para el procesamiento eficiente de secuencias largas

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 T2V Pro:

| model_id | Descripción | Casos de uso |
|------------|-------------|-----------|
| **kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers** | Modelo Pro de Texto a Video de 5 segundos | Generación de texto a video de alta calidad |
| **kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers** | Modelo Pro de imagen a video de 5 segundos | Generación de video a partir de imágenes de alta calidad |

Kandinsky 5.0 T2V Lite:
| model_id | Descripción | Casos de uso |
|------------|-------------|-----------|
| **kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers** | Modelo de ajuste fino supervisado de 5 segundos | Mejor calidad de generación |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers** | Modelo de ajuste fino supervisado de 10 segundos | Mejor calidad de generación |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers** | 5 segundos de Classifier-Free Guidance destilado | Inferencia 2× más rápida |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers** | 10 segundos de Classifier-Free Guidance destilado | Inferencia 2× más rápida |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers** | Diffusión de 5 segundos destilada a 16 pasos | Inferencia 6 veces más rápida, pérdida mínima de calidad |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers** | Diffusión de 10 segundos destilada a 16 pasos | Inferencia 6 veces más rápida, pérdida mínima de calidad |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers** | Modelo Base preentrenado de 5 segundos | Investigación y ajuste fino |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers** | Modelo Base preentrenado de 10 segundos | Investigación y ajuste fino |

## Ejemplos de uso

### Generación básica de texto a video

#### Pro
**⚠️ ¡Advertencia!** todos los modelos Pro deben inferirse con pipeline.enable_model_cpu_offload()
```python
import torch
from diffusers import Kandinsky5T2VPipeline
from diffusers.utils import export_to_video

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)

pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"
pipeline.transformer.set_attention_backend("flex")                            # <--- Set attention backend to Flex
pipeline.enable_model_cpu_offload()                                           # <--- Enable cpu offloading for single GPU inference
pipeline.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=True) # <--- Compile with max-autotune-no-cudagraphs

# Generate video
prompt = "A cat and a dog baking a cake together in a kitchen."
negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=768,
    width=1024,
    num_frames=121,  # ~5 seconds at 24fps
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)
```

#### Lite
```python
import torch
from diffusers import Kandinsky5T2VPipeline
from diffusers.utils import export_to_video

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

# Generate video
prompt = "A cat and a dog baking a cake together in a kitchen."
negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=512,
    width=768,
    num_frames=121,  # ~5 seconds at 24fps
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)
```

### Modelos de 10 segundos
**⚠️ ¡Advertencia!** todos los modelos de 10 segundos deben usarse con Flex attention y compilación max-autotune-no-cudagraphs:

```python
pipe = Kandinsky5T2VPipeline.from_pretrained(
    "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers", 
    dtype=torch.bfloat16
)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

pipe.transformer.set_attention_backend(
    "flex"
)                                       # <--- Set attention backend to Flex
pipe.transformer.compile(
    mode="max-autotune-no-cudagraphs", 
    dynamic=True
)                                       # <--- Compile with max-autotune-no-cudagraphs

prompt = "A cat and a dog baking a cake together in a kitchen."
negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=512,
    width=768,
    num_frames=241,
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)
```

### Modelo de difusión destilado
**⚠️ ¡Advertencia!** todos los modelos nocfg y destilados de difusión deben inferirse sin CFG (```guidance_scale=1.0```):

```python
model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

output = pipe(
    prompt="A beautiful sunset over mountains",
    num_inference_steps=16,  # <--- Model is distilled in 16 steps
    guidance_scale=1.0,      # <--- no CFG
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)
```

### Generación básica de imagen a video
**⚠️ ¡Advertencia!** todos los modelos Pro deben inferirse con pipeline.enable_model_cpu_offload()
```python
import torch
from diffusers import Kandinsky5T2VPipeline
from diffusers.utils import export_to_video

# Load the pipeline
model_id = "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers"
pipe = Kandinsky5T2VPipeline.from_pretrained(model_id, dtype=torch.bfloat16)

pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"
pipeline.transformer.set_attention_backend("flex")                            # <--- Set attention backend to Flex
pipeline.enable_model_cpu_offload()                                           # <--- Enable cpu offloading for single GPU inference
pipeline.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=True) # <--- Compile with max-autotune-no-cudagraphs

# Generate video
image = load_image(
    "https://huggingface.co/kandinsky-community/kandinsky-3/resolve/main/assets/title.jpg?download=true"
)
height = 896
width = 896
image = image.resize((width, height))

prompt = "An funny furry creture smiles happily and holds a sign that says 'Kandinsky'"
negative_prompt = ""

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=height,
    width=width,
    num_frames=121,  # ~5 seconds at 24fps
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "output.mp4", fps=24, quality=9)
```

## Evaluación lado a lado de Kandinsky 5.0 Pro

  
      
          
      
      
         
      

  
      
          Comparación con Veo 3
      
      
          Comparación con Veo 3 fast
      
  
      
          
      
      
          
      
  
      
          Comparación con el modo de texto a video de Wan 2.2 A14B
      
      
          Comparación con el modo de imagen a video de Wan 2.2 A14B
      

## Evaluación lado a lado de Kandinsky 5.0 Lite

La evaluación se basa en los prompts ampliados del [Movie Gen benchmark](https://github.com/facebookresearch/MovieGenBench), que están disponibles en la columna expanded_prompt del archivo benchmark/moviegen_bench.csv.

  
      
          
      
      
          
      
  
      
          
      
      
          
      
  
      
          
      

## Evaluación lado a lado de Kandinsky 5.0 Lite Distill

  
      
          
      
      
          
      

## Kandinsky5T2VPipeline[[diffusers.Kandinsky5T2VPipeline]]

#### diffusers.Kandinsky5T2VPipeline[[diffusers.Kandinsky5T2VPipeline]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L131)

**Parámetros:**

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

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Modelo de Autoencoder Variacional [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) para codificar y decodificar videos hacia 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/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de video codificados.

Pipeline para la generación de texto a video usando Kandinsky 5.0.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/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.Kandinsky5T2VPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 768, num_frames: int = 121, num_inference_steps: int = 50, guidance_scale: float = 5.0, num_videos_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.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L680)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación del video. 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 video. 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 `512`) : La altura en píxeles del video generado.

width (`int`, por defecto `768`) : El ancho en píxeles del video generado.

num_frames (`int`, por defecto `25`) : El número de fotogramas en el video generado.

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_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos 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*) : Incrustaciones de texto pregeneradas del codificador de texto de Qwen.

prompt_embeds_clip (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas del codificador de texto de CLIP.

negative_prompt_embeds_qwen (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados del codificador de texto de Qwen.

negative_prompt_embeds_clip (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados por el codificador de texto de CLIP.

prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Longitudes de secuencia acumuladas para las incrustaciones del prompt de Qwen, utilizadas para la atención de longitud variable.

negative_prompt_cu_seqlens (`torch.Tensor`, *opcional*) : Longitudes de secuencia acumuladas para los embeddings del prompt negativo de Qwen, utilizadas para la atención de longitud variable.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida del video generado.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve o no una `KandinskyPipelineOutput`.

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:** `~KandinskyPipelineOutput` o `tuple`

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

La función de llamada para el pipeline de generación.

Ejemplos:

```python
>>> import torch
>>> from diffusers import Kandinsky5T2VPipeline
>>> from diffusers.utils import export_to_video

>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers
>>> # kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers

>>> model_id = "kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers"
>>> pipe = Kandinsky5T2VPipeline.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."
>>> negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     height=512,
...     width=768,
...     num_frames=121,
...     num_inference_steps=50,
...     guidance_scale=5.0,
... ).frames[0]

>>> export_to_video(output, "output.mp4", fps=24, quality=9)
```

#### check_inputs[[diffusers.Kandinsky5T2VPipeline.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/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L511)

**Parámetros:**

prompt : Prompt de entrada

negative_prompt : Prompt negativo para la guía

height : Altura del video

width : Ancho del video

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.Kandinsky5T2VPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_videos_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/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L418)

**Parámetros:**

prompt (`str` o `list[str]`) : Prompt que se codificará.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de vídeos 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.

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_videos_per_prompt, sequence_length, embedding_dim)
- CLIP pooled embeddings de forma (batch_size * num_videos_per_prompt, clip_embedding_dim)
- Longitudes de secuencia acumuladas (`cu_seqlens`) para los embeddings de Qwen de forma (batch_size * num_videos_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 video.

#### fast_sta_nabla[[diffusers.Kandinsky5T2VPipeline.fast_sta_nabla]]

```python
fast_sta_nabla(T: int, H: int, W: int, wT: int = 3, wH: int = 3, wW: int = 3, device = 'cuda')
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L229)

**Parámetros:**

T (int) : Número de fotogramas temporales

H (int) : Altura en el espacio latente

W (int) : Ancho en el espacio latente

wT (int) : Tamaño de la ventana de atención temporal

wH (int) : Tamaño de la ventana de atención de altura

wW (int) : Tamaño de la ventana de atención

device (str) : Dispositivo en el que crear el tensor

**Devuelve:** `torch.Tensor`

Máscara de atención dispersa de forma (T*H*W, T*H*W)

Cree una máscara de atención temporal dispersa (STA) para una generación de video eficiente.

Este método genera una máscara que limita la atención a fotogramas y posiciones espaciales cercanos, reduciendo la complejidad computacional para la generación de video.

#### get_sparse_params[[diffusers.Kandinsky5T2VPipeline.get_sparse_params]]

```python
get_sparse_params(sample, device)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L264)

**Parámetros:**

sample (torch.Tensor) : tensor de muestra de entrada

device (torch.device) : Dispositivo en el que colocar los tensores

**Devuelve:** `Dict`

Diccionario que contiene los parámetros de atención dispersa

Genera los parámetros de atención dispersa para el transformador en función de las dimensiones de la muestra.

Este método calcula la configuración de atención dispersa necesaria para un procesamiento de video eficiente en el modelo transformer.

#### prepare_latents[[diffusers.Kandinsky5T2VPipeline.prepare_latents]]

```python
prepare_latents(batch_size: int, num_channels_latents: int = 16, height: int = 480, width: int = 832, num_frames: int = 81, 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/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L597)

**Parámetros:**

batch_size (int) : Número de vídeos a generar

num_channels_latents (int) : Número de canales en el espacio latente

height (int) : Altura del video generado

width (int) : Ancho del video generado

num_frames (int) : Número de fotogramas en el video

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

Este método crea latentes de ruido aleatorio o utiliza los latentes proporcionados como punto de partida para el proceso de desruido.

## Kandinsky5I2VPipeline[[diffusers.Kandinsky5I2VPipeline]]

#### diffusers.Kandinsky5I2VPipeline[[diffusers.Kandinsky5I2VPipeline]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L128)

**Parámetros:**

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

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Modelo de Autoencoder Variacional [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) para codificar y decodificar videos hacia 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/v0.43.0/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de video codificados.

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

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/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.Kandinsky5I2VPipeline.__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 = 512, width: int = 768, num_frames: int = 121, num_inference_steps: int = 50, guidance_scale: float = 5.0, num_videos_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/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L748)

**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 del video. 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 video. 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 `512`) : La altura en píxeles del video generado.

width (`int`, por defecto `768`) : El ancho en píxeles del video generado.

num_frames (`int`, por defecto `121`) : El número de fotogramas en el video generado.

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_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos 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 del video generado.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve o no una `KandinskyPipelineOutput`.

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:** `~KandinskyPipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `KandinskyPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con los videos generados.

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

Ejemplos:

```python
>>> import torch
>>> from diffusers import Kandinsky5I2VPipeline
>>> from diffusers.utils import export_to_video, load_image

>>> # Available models:
>>> # kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers

>>> model_id = "kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers"
>>> pipe = Kandinsky5I2VPipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16)
>>> pipe = pipe.to("cuda")

>>> image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
... )
>>> prompt = "An astronaut floating in space with Earth in the background, cinematic shot"
>>> negative_prompt = "Static, 2D cartoon, cartoon, 2d animation, paintings, images, worst quality, low quality, ugly, deformed, walking backwards"

>>> output = pipe(
...     image=image,
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     height=512,
...     width=768,
...     num_frames=121,
...     num_inference_steps=50,
...     guidance_scale=5.0,
... ).frames[0]

>>> export_to_video(output, "output.mp4", fps=24, quality=9)
```

#### check_inputs[[diffusers.Kandinsky5I2VPipeline.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/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L545)

**Parámetros:**

prompt : Prompt de entrada

negative_prompt : Prompt negativo para la guía

image : Imagen de entrada para el condicionamiento

height : Altura del video

width : Ancho del video

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.Kandinsky5I2VPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], num_videos_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/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L454)

**Parámetros:**

prompt (`str` o `list[str]`) : Prompt que se codificará.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de vídeos 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.

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_videos_per_prompt, sequence_length, embedding_dim)
- CLIP pooled embeddings de forma (batch_size * num_videos_per_prompt, clip_embedding_dim)
- Longitudes de secuencia acumuladas (`cu_seqlens`) para los embeddings de Qwen de forma (batch_size * num_videos_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 video.

#### fast_sta_nabla[[diffusers.Kandinsky5I2VPipeline.fast_sta_nabla]]

```python
fast_sta_nabla(T: int, H: int, W: int, wT: int = 3, wH: int = 3, wW: int = 3, device = 'cuda')
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L226)

**Parámetros:**

T (int) : Número de fotogramas temporales

H (int) : Altura en el espacio latente

W (int) : Ancho en el espacio latente

wT (int) : Tamaño de la ventana de atención temporal

wH (int) : Tamaño de la ventana de atención de altura

wW (int) : Tamaño de la ventana de atención

device (str) : Dispositivo en el que crear el tensor

**Devuelve:** `torch.Tensor`

Máscara de atención dispersa de forma (T*H*W, T*H*W)

Cree una máscara de atención temporal dispersa (STA) para una generación de video eficiente.

Este método genera una máscara que limita la atención a fotogramas y posiciones espaciales cercanos, reduciendo la complejidad computacional para la generación de video.

#### get_sparse_params[[diffusers.Kandinsky5I2VPipeline.get_sparse_params]]

```python
get_sparse_params(sample, device)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L261)

**Parámetros:**

sample (torch.Tensor) : tensor de muestra de entrada

device (torch.device) : Dispositivo en el que colocar los tensores

**Devuelve:** `Dict`

Diccionario que contiene los parámetros de atención dispersa

Genera los parámetros de atención dispersa para el transformador en función de las dimensiones de la muestra.

Este método calcula la configuración de atención dispersa necesaria para un procesamiento de video eficiente en el modelo transformer.

#### prepare_latents[[diffusers.Kandinsky5I2VPipeline.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 = 480, width: int = 832, num_frames: int = 81, 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/v0.43.0/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L636)

**Parámetros:**

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

batch_size (int) : Número de vídeos a generar

num_channels_latents (int) : Número de canales en el espacio latente

height (int) : Altura del video generado

width (int) : Ancho del video generado

num_frames (int) : Número de fotogramas en el video

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 el primer fotograma como imagen codificada

Prepara las variables latentes iniciales para la generación de imagen a video.

Este método crea latentes de ruido aleatorio para todos los fotogramas excepto el primero, que se reemplaza con la imagen de entrada 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
}
```