# Kandinsky 5.0 Video

[Kandinsky 5.0](https://arxiv.org/abs/2511.14993) adalah keluarga model difusi untuk generasi Video & Gambar.

Kandinsky 5.0 Lite adalah lini model generasi video ringan (2B parameter) yang menempati peringkat #1 di antara model open-source dalam kelasnya. Model ini melampaui model yang lebih besar dan menawarkan pemahaman terbaik tentang konsep-konsep Rusia dalam ekosistem open-source.

Kandinsky 5.0 Pro adalah lini model generasi video berkualitas tinggi berskala besar (19B parameter). Model ini menawarkan generasi berkualitas tinggi dalam resolusi HD serta lebih banyak format generasi seperti I2V.

Model ini memperkenalkan beberapa inovasi utama:
- **Pipeline difusi laten** dengan **Flow Matching** untuk stabilitas pelatihan yang lebih baik
- **Diffusion Transformer (DiT)** sebagai tulang punggung generatif utama dengan cross-attention ke embedding teks
- Pengkodean teks ganda menggunakan **Qwen2.5-VL** dan **CLIP** untuk pemahaman teks yang komprehensif
- **HunyuanVideo 3D VAE** untuk enkripsi dan dekripsi video yang efisien
- **Mekanisme perhatian sparsa** (NABLA) untuk pemrosesan urutan panjang yang efisien

Kodebase asli dapat ditemukan di [kandinskylab/Kandinsky-5](https://github.com/kandinskylab/Kandinsky-5).

> [!TIP]
> Lihat organisasi [Kandinsky Lab](https://huggingface.co/kandinskylab) di Hub untuk checkpoint model resmi untuk generasi teks-ke-video, termasuk varian pretrained, SFT, no-CFG, dan distilled.

## Model yang Tersedia

Kandinsky 5.0 T2V Pro:

| model_id | Deskripsi | Kasus Penggunaan |
|------------|-------------|-----------|
| **kandinskylab/Kandinsky-5.0-T2V-Pro-sft-5s-Diffusers** | Model Pro Teks-ke-Video 5 detik | Generasi teks-ke-video berkualitas tinggi |
| **kandinskylab/Kandinsky-5.0-I2V-Pro-sft-5s-Diffusers** | Model Pro Gambar-ke-Video 5 detik | Generasi gambar-ke-video berkualitas tinggi |

Kandinsky 5.0 T2V Lite:
| model_id | Deskripsi | Kasus Penggunaan |
|------------|-------------|-----------|
| **kandinskylab/Kandinsky-5.0-T2V-Lite-sft-5s-Diffusers** | Model Supervised Fine-Tuned 5 detik | Kualitas generasi tertinggi |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-sft-10s-Diffusers** | Model Supervised Fine-Tuned 10 detik | Kualitas generasi tertinggi |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-5s-Diffusers** | 5 second Classifier-Free Guidance yang telah di-distil | Inferensi 2× lebih cepat |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-nocfg-10s-Diffusers** | 10 second Classifier-Free Guidance yang telah di-distil | Inferensi 2× lebih cepat |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-5s-Diffusers** | 5 second Diffusion yang di-distill menjadi 16 langkah | Inferensi 6× lebih cepat, kehilangan kualitas minimal |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-distilled16steps-10s-Diffusers** | 10 second Diffusion yang di-distill menjadi 16 langkah | Inferensi 6× lebih cepat, kehilangan kualitas minimal |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-5s-Diffusers** | Model pretrained Base 5 detik | Penelitian dan penyesuaian halus |
| **kandinskylab/Kandinsky-5.0-T2V-Lite-pretrain-10s-Diffusers** | Model pra-terlatih Base 10 detik | Penelitian dan penyesuaian halus |

## Contoh Penggunaan

### Generasi Teks-ke-Video Dasar

#### Pro
**⚠️ Peringatan!** semua model Pro harus diinfer menggunakan 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)
```

### Model 10 detik
**⚠️ Peringatan!** semua model 10 detik harus digunakan dengan Flex attention dan kompilasi 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)
```

### Model Distilled Diffusion
**⚠️ Peringatan!** semua model nocfg dan diffusion distilled harus diinfer tanpa 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)
```

### Generasi Gambar-ke-Video Dasar
**⚠️ Peringatan!** semua model Pro harus diinfer menggunakan 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)
```

## Evaluasi berdampingan Kandinsky 5.0 Pro

  
      
          
      
      
         
      

  
      
          Perbandingan dengan Veo 3
      
      
          Perbandingan dengan Veo 3 fast
      
  
      
          
      
      
          
      
  
      
          Perbandingan dengan mode Text-to-Video Wan 2.2 A14B
      
      
          Perbandingan dengan mode Image-to-Video Wan 2.2 A14B
      

## Evaluasi berdampingan Kandinsky 5.0 Lite

Evaluasi didasarkan pada prompt yang diperluas dari [Movie Gen benchmark](https://github.com/facebookresearch/MovieGenBench), yang tersedia di kolom expanded_prompt pada file benchmark/moviegen_bench.csv.

  
      
          
      
      
          
      
  
      
          
      
      
          
      
  
      
          
      

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

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

**Parameter:**

transformer (`Kandinsky5Transformer3DModel`) : Transformer bersyarat untuk mendenoise latens video yang telah dikodekan.

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/main/id/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Model Variational Auto-Encoder [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) untuk mengodekan dan mendekodekan video ke dan dari representasi laten.

text_encoder (`Qwen2_5_VLForConditionalGeneration`) : text-encoder beku [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).

tokenizer (`AutoProcessor`) : Tokenizer untuk Qwen2.5-VL.

text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) yang dibekukan, khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer_2 (`CLIPTokenizer`) : Tokenizer untuk CLIP.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens video yang telah dikodekan.

Pipeline untuk generasi teks-ke-video menggunakan Kandinsky 5.0.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan untuk semua pipeline (mengunduh, menyimpan, menjalankan pada perangkat tertentu, dll.).

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

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

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi video. Jika tidak didefinisikan, gunakan `prompt_embeds` sebagai gantinya.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang harus dihindari selama pembuatan video. Jika tidak didefinisikan, gunakan `negative_prompt_embeds` sebagai gantinya. Diabaikan jika tidak menggunakan guidance (`guidance_scale` < `1`).

height (`int`, defaultnya `512`) : Tinggi video yang dihasilkan dalam piksel.

width (`int`, defaultnya `768`) : Lebar video yang dihasilkan dalam piksel.

num_frames (`int`, defaultnya `25`) : Jumlah frame dalam video yang dihasilkan.

num_inference_steps (`int`, defaultnya `50`) : Jumlah langkah denoising.

guidance_scale (`float`, defaultnya `5.0`) : Skala panduan seperti yang didefinisikan dalam classifier-free guidance.

num_videos_per_prompt (`int`, *opsional*, default 1) : Jumlah video yang akan dihasilkan per prompt.

generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Generator torch untuk membuat proses generasi menjadi deterministik.

latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya.

prompt_embeds_qwen (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya dari encoder teks Qwen.

prompt_embeds_clip (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya dari pengode teks CLIP.

negative_prompt_embeds_qwen (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya dari pengkode teks Qwen.

negative_prompt_embeds_clip (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya dari pengkode teks CLIP.

prompt_cu_seqlens (`torch.Tensor`, *opsional*) : Panjang sekuens kumulatif untuk embedding prompt Qwen, digunakan untuk perhatian dengan panjang variabel.

negative_prompt_cu_seqlens (`torch.Tensor`, *opsional*) : Panjang sekuens kumulatif untuk embedding prompt negatif Qwen, digunakan untuk perhatian dengan panjang variabel.

output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari video yang dihasilkan.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `KandinskyPipelineOutput` atau tidak.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising.

callback_on_step_end_tensor_inputs (`list`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`.

max_sequence_length (`int`, defaultnya `512`) : Panjang maksimum sekuens untuk pengkodean teks.

**Mengembalikan:** `~KandinskyPipelineOutput` atau `tuple`

Jika `return_dict` adalah `True`, maka `KandinskyPipelineOutput` yang dikembalikan, selain itu sebuah `tuple` yang dikembalikan di mana elemen pertama adalah daftar berisi gambar yang dihasilkan.

Fungsi panggilan untuk pipeline pada generasi.

Contoh:

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L511)

**Parameter:**

prompt : Prompt input

negative_prompt : Prompt negatif untuk panduan

height : Tinggi video

width : Lebar video

prompt_embeds_qwen : Embedding prompt Qwen yang telah dihitung sebelumnya

prompt_embeds_clip : Embedding prompt CLIP yang telah dihitung sebelumnya

negative_prompt_embeds_qwen : Embedding prompt negatif Qwen yang telah dihitung sebelumnya

negative_prompt_embeds_clip : Embedding prompt negatif CLIP yang telah dihitung sebelumnya

prompt_cu_seqlens : Panjang kumulatif urutan yang sudah dihitung sebelumnya untuk prompt positif Qwen

negative_prompt_cu_seqlens : Panjang kumulatif urutan yang sudah dihitung sebelumnya untuk prompt negatif Qwen

callback_on_step_end_tensor_inputs : Input tensor callback

**Mengangkat:** ``ValueError``

- ``ValueError`` -- Jika input tidak valid

Validasi parameter input untuk 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L418)

**Parameter:**

prompt (`str` atau `list[str]`) : Prompt yang akan dienkod.

num_videos_per_prompt (`int`, *opsional*, default 1) : Jumlah video yang akan dihasilkan per prompt.

max_sequence_length (`int`, *opsional*, default 512) : Panjang maksimum urutan untuk pengkodean teks.

device (`torch.device`, *opsional*) : Perangkat Torch.

dtype (`torch.dtype`, *opsional*) : dtype Torch.

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

- Qwen text embeddings dengan bentuk (batch_size * num_videos_per_prompt, sequence_length, embedding_dim)
- CLIP pooled embeddings dengan bentuk (batch_size * num_videos_per_prompt, clip_embedding_dim)
- Panjang sekuens kumulatif (`cu_seqlens`) untuk Qwen embeddings dengan bentuk (batch_size * num_videos_per_prompt + 1,)

Mengkodekan satu prompt (positif atau negatif) ke dalam hidden states text encoder.

Metode ini menggabungkan embedding dari kedua encoder teks Qwen2.5-VL dan CLIP untuk membuat representasi teks yang komprehensif untuk generasi 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')
```

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

**Parameter:**

T (int) : Jumlah frame temporal

H (int) : Tinggi di ruang laten

W (int) : Lebar di ruang laten

wT (int) : Ukuran jendela atensi temporal

wH (int) : Ukuran jendela perhatian tinggi

wW (int) : Ukuran jendela perhatian

device (str) : Perangkat untuk membuat tensor

**Mengembalikan:** `torch.Tensor`

Sparse attention mask dengan bentuk (T*H*W, T*H*W)

Buat mask sparse temporal attention (STA) untuk generasi video yang efisien.

Metode ini menghasilkan mask yang membatasi perhatian pada frame dan posisi spasial di sekitarnya, sehingga mengurangi kompleksitas komputasi untuk generasi video.

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

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

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

**Parameter:**

sample (torch.Tensor) : tensor sampel input

device (torch.device) : Perangkat untuk menempatkan tensor

**Mengembalikan:** `Dict`

Dictionary yang berisi parameter sparse attention

Generate parameter perhatian jarang untuk transformer berdasarkan dimensi sampel.

Metode ini menghitung konfigurasi perhatian jarang yang diperlukan untuk pemrosesan video yang efisien dalam model 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky.py#L597)

**Parameter:**

batch_size (int) : Jumlah video yang akan dibuat

num_channels_latents (int) : Jumlah saluran di ruang laten

height (int) : Tinggi video yang dihasilkan

width (int) : Lebar video yang dihasilkan

num_frames (int) : Jumlah frame dalam video

dtype (torch.dtype) : Tipe data untuk latents

device (torch.device) : Perangkat untuk membuat latents

generator (torch.Generator) : Generator bilangan acak

latents (torch.Tensor) : Laten yang sudah ada untuk digunakan

**Mengembalikan:** `torch.Tensor`

Tensor laten yang disiapkan

Siapkan variabel laten awal untuk pembuatan video.

Metode ini membuat latens noise acak atau menggunakan latens yang disediakan sebagai titik awal untuk proses denoising.

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

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

**Parameter:**

transformer (`Kandinsky5Transformer3DModel`) : Transformer bersyarat untuk mendenoise latens video yang telah dikodekan.

vae ([AutoencoderKLHunyuanVideo](/docs/diffusers/main/id/api/models/autoencoder_kl_hunyuan_video#diffusers.AutoencoderKLHunyuanVideo)) : Model Variational Auto-Encoder [hunyuanvideo-community/HunyuanVideo (vae)](https://huggingface.co/hunyuanvideo-community/HunyuanVideo) untuk mengodekan dan mendekodekan video ke dan dari representasi laten.

text_encoder (`Qwen2_5_VLForConditionalGeneration`) : text-encoder beku [Qwen2.5-VL](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).

tokenizer (`AutoProcessor`) : Tokenizer untuk Qwen2.5-VL.

text_encoder_2 (`CLIPTextModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel) yang dibekukan, khususnya varian [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14).

tokenizer_2 (`CLIPTokenizer`) : Tokenizer untuk CLIP.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens video yang telah dikodekan.

Pipeline untuk generasi gambar-ke-video menggunakan Kandinsky 5.0.

Model ini mewarisi dari [DiffusionPipeline](/docs/diffusers/main/id/api/pipelines/overview#diffusers.DiffusionPipeline). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan untuk semua pipeline (mengunduh, menyimpan, menjalankan pada perangkat tertentu, dll.).

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L748)

**Parameter:**

image (`PipelineImageInput`) : Gambar input untuk mengondisikan generasi. Harus berupa gambar, daftar gambar, atau `torch.Tensor`.

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi video. Jika tidak didefinisikan, gunakan `prompt_embeds` sebagai gantinya.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt yang harus dihindari selama pembuatan video. Jika tidak didefinisikan, gunakan `negative_prompt_embeds` sebagai gantinya. Diabaikan jika tidak menggunakan guidance (`guidance_scale` < `1`).

height (`int`, defaultnya `512`) : Tinggi video yang dihasilkan dalam piksel.

width (`int`, defaultnya `768`) : Lebar video yang dihasilkan dalam piksel.

num_frames (`int`, defaultnya `121`) : Jumlah frame dalam video yang dihasilkan.

num_inference_steps (`int`, defaultnya `50`) : Jumlah langkah denoising.

guidance_scale (`float`, defaultnya `5.0`) : Skala panduan seperti yang didefinisikan dalam classifier-free guidance.

num_videos_per_prompt (`int`, *opsional*, default 1) : Jumlah video yang akan dihasilkan per prompt.

generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Generator torch untuk membuat proses generasi menjadi deterministik.

latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya.

prompt_embeds_qwen (`torch.Tensor`, *opsional*) : Embedding teks Qwen yang telah dibuat sebelumnya.

prompt_embeds_clip (`torch.Tensor`, *opsional*) : Embedding teks CLIP yang telah dibuat sebelumnya.

negative_prompt_embeds_qwen (`torch.Tensor`, *opsional*) : Embedding teks negatif Qwen yang telah dibuat sebelumnya.

negative_prompt_embeds_clip (`torch.Tensor`, *opsional*) : Embedding teks negatif CLIP yang telah dibuat sebelumnya.

prompt_cu_seqlens (`torch.Tensor`, *opsional*) : Panjang kumulatif urutan yang telah dibuat sebelumnya untuk prompt positif Qwen.

negative_prompt_cu_seqlens (`torch.Tensor`, *opsional*) : Panjang kumulatif urutan yang telah dibuat sebelumnya untuk prompt negatif Qwen.

output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output dari video yang dihasilkan.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `KandinskyPipelineOutput` atau tidak.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising.

callback_on_step_end_tensor_inputs (`List`, *opsional*) : Daftar input tensor untuk fungsi `callback_on_step_end`.

max_sequence_length (`int`, defaultnya `512`) : Panjang maksimum sekuens untuk pengkodean teks.

**Mengembalikan:** `~KandinskyPipelineOutput` atau `tuple`

Jika `return_dict` adalah `True`, maka `KandinskyPipelineOutput` yang dikembalikan, selain itu sebuah `tuple` yang dikembalikan di mana elemen pertama adalah daftar berisi video yang dihasilkan.

Fungsi panggilan untuk pipeline pada generasi gambar-ke-video.

Contoh:

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

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L545)

**Parameter:**

prompt : Prompt input

negative_prompt : Prompt negatif untuk panduan

image : Gambar input untuk kondisioning

height : Tinggi video

width : Lebar video

prompt_embeds_qwen : Embedding prompt Qwen yang telah dihitung sebelumnya

prompt_embeds_clip : Embedding prompt CLIP yang telah dihitung sebelumnya

negative_prompt_embeds_qwen : Embedding prompt negatif Qwen yang telah dihitung sebelumnya

negative_prompt_embeds_clip : Embedding prompt negatif CLIP yang telah dihitung sebelumnya

prompt_cu_seqlens : Panjang kumulatif urutan yang sudah dihitung sebelumnya untuk prompt positif Qwen

negative_prompt_cu_seqlens : Panjang kumulatif urutan yang sudah dihitung sebelumnya untuk prompt negatif Qwen

callback_on_step_end_tensor_inputs : Input tensor callback

**Mengangkat:** ``ValueError``

- ``ValueError`` -- Jika input tidak valid

Validasi parameter input untuk 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L454)

**Parameter:**

prompt (`str` atau `list[str]`) : Prompt yang akan dienkod.

num_videos_per_prompt (`int`, *opsional*, default 1) : Jumlah video yang akan dihasilkan per prompt.

max_sequence_length (`int`, *opsional*, default 512) : Panjang maksimum urutan untuk pengkodean teks.

device (`torch.device`, *opsional*) : Perangkat Torch.

dtype (`torch.dtype`, *opsional*) : dtype Torch.

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

- Qwen text embeddings dengan bentuk (batch_size * num_videos_per_prompt, sequence_length, embedding_dim)
- CLIP pooled embeddings dengan bentuk (batch_size * num_videos_per_prompt, clip_embedding_dim)
- Panjang sekuens kumulatif (`cu_seqlens`) untuk Qwen embeddings dengan bentuk (batch_size * num_videos_per_prompt + 1,)

Mengkodekan satu prompt (positif atau negatif) ke dalam hidden states text encoder.

Metode ini menggabungkan embedding dari kedua encoder teks Qwen2.5-VL dan CLIP untuk membuat representasi teks yang komprehensif untuk generasi 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')
```

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

**Parameter:**

T (int) : Jumlah frame temporal

H (int) : Tinggi di ruang laten

W (int) : Lebar di ruang laten

wT (int) : Ukuran jendela atensi temporal

wH (int) : Ukuran jendela perhatian tinggi

wW (int) : Ukuran jendela perhatian

device (str) : Perangkat untuk membuat tensor

**Mengembalikan:** `torch.Tensor`

Sparse attention mask dengan bentuk (T*H*W, T*H*W)

Buat mask sparse temporal attention (STA) untuk generasi video yang efisien.

Metode ini menghasilkan mask yang membatasi perhatian pada frame dan posisi spasial di sekitarnya, sehingga mengurangi kompleksitas komputasi untuk generasi video.

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

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

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

**Parameter:**

sample (torch.Tensor) : tensor sampel input

device (torch.device) : Perangkat untuk menempatkan tensor

**Mengembalikan:** `Dict`

Dictionary yang berisi parameter sparse attention

Generate parameter perhatian jarang untuk transformer berdasarkan dimensi sampel.

Metode ini menghitung konfigurasi perhatian jarang yang diperlukan untuk pemrosesan video yang efisien dalam model 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/kandinsky5/pipeline_kandinsky_i2v.py#L636)

**Parameter:**

image (PipelineImageInput) : Gambar input untuk mengondisikan generasi

batch_size (int) : Jumlah video yang akan dibuat

num_channels_latents (int) : Jumlah saluran di ruang laten

height (int) : Tinggi video yang dihasilkan

width (int) : Lebar video yang dihasilkan

num_frames (int) : Jumlah frame dalam video

dtype (torch.dtype) : Tipe data untuk latents

device (torch.device) : Perangkat untuk membuat latents

generator (torch.Generator) : Generator bilangan acak

latents (torch.Tensor) : Laten yang sudah ada untuk digunakan

**Mengembalikan:** `torch.Tensor`

Tensor laten yang disiapkan dengan frame pertama sebagai gambar yang dikodekan

Siapkan variabel laten awal untuk pembuatan video dari gambar.

Metode ini membuat latens noise acak untuk semua frame kecuali frame pertama, yang diganti dengan gambar input yang telah dienkod.

## Sitasi
```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
}
```