# Kandinsky 6 Transformers

Kandinsky 6 menggunakan multimodal diffusion transformer yang melakukan denoising pada latens video dan audio secara bersamaan untuk generasi teks/gambar-ke-video-dan-audio, serta text-free diffusion transformer untuk super-resolusi video.

## Kandinsky6Transformer3DModel[[diffusers.Kandinsky6Transformer3DModel]]

Transformer multimodal yang digunakan oleh [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline).

```python
import torch
from diffusers import Kandinsky6Transformer3DModel

transformer = Kandinsky6Transformer3DModel.from_pretrained(
    "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", subfolder="transformer", torch_dtype=torch.bfloat16
)
```

#### diffusers.Kandinsky6Transformer3DModel[[diffusers.Kandinsky6Transformer3DModel]]

```python
diffusers.Kandinsky6Transformer3DModel(in_visual_dim: int = 16, out_visual_dim: int = 16, in_text_dim: int = 3584, in_text_dim2: int = 768, time_dim: int = 1024, patch_size: tuple = (1, 2, 2), model_dim: int = 4096, ff_dim: int = 16384, num_text_blocks: int = 4, num_visual_blocks: int = 60, axes_dims: tuple = (32, 48, 48), visual_cond: bool = True, in_audio_dim: int = 20, out_audio_dim: int = 20, model_dim_a: int | None = None, time_dim_a: int | None = None, ff_dim_a: int | None = None, axes_dims_a: tuple | None = None, audio_freqs_scaling: float = 1.0, scale_factor: tuple | list[float] = (1.0, 2.0, 2.0), text_token_padding: bool = False, ca_rope: bool = False, cross_gates: bool = False, fix_modulation: bool = False, visual_token_type_num_embeddings: int = 0)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_kandinsky6.py#L591)

**Parameter:**

in_visual_dim (*int*, *optional*, defaultnya 16) : Jumlah kanal laten video input.

out_visual_dim (*int*, *optional*, defaultnya 16) : Jumlah kanal laten video output.

in_text_dim (*int*, *optional*, defaultnya 3584) : Dimensi embedding token teks.

in_text_dim2 (*int*, *opsional*, default 768) : Dimensi embedding teks yang dipool.

time_dim (*int*, *optional*, defaultnya 1024) : Dimensi time embedding.

patch_size (*tuple[int, int, int]*, *opsional*, defaultnya `(1, 2, 2)`) : Ukuran patch video.

model_dim (*int*, *optional*, defaultnya 4096) : Dimensi tersembunyi transformer video.

ff_dim (*int*, *optional*, defaultnya 16384) : Dimensi tersembunyi feed-forward video.

num_text_blocks (*int*, *opsional*, default 4) : Jumlah blok teks per modalitas.

num_visual_blocks (*int*, *opsional*, default 60) : Jumlah blok video/audio yang digabungkan.

axes_dims (*tuple[int, int, int]*, *opsional*, defaultnya `(32, 48, 48)`) : Dimensi RoPE untuk video.

visual_cond (*bool*, *opsional*, defaultnya True) : Apakah kanal kondisioning video ada.

in_audio_dim (*int*, *optional*, defaultnya 20) : Jumlah kanal laten audio input.

out_audio_dim (*int*, *optional*, defaultnya 20) : Jumlah kanal laten audio keluaran.

model_dim_a (*int*, *opsional*) : Dimensi tersembunyi transformer audio. Bawaan adalah *model_dim*.

time_dim_a (*int*, *opsional*) : Dimensi embedding waktu audio. Bawaan adalah *time_dim*.

ff_dim_a (*int*, *opsional*) : Dimensi tersembunyi feed-forward audio. Bawaan adalah *ff_dim*.

axes_dims_a (*tuple[int, int, int]*, *optional*) : Dimensi Audio RoPE. Bawaan adalah *axes_dims*.

audio_freqs_scaling (*float*, *optional*, default 1.0) : Skala frekuensi Audio RoPE.

scale_factor (*tuple[float, float, float]*, *optional*, defaultnya *(1.0, 2.0, 2.0)*) : Penskalaan frekuensi RoPE *(t, h, w)* per sumbu yang diterapkan pada posisi video.

text_token_padding (*bool*, *opsional*, default False) : Metadata checkpoint yang mencatat apakah urutan teks model referensi di-pad. *forward* selalu menerima *encoder_attention_mask* opsional terlepas dari flag ini; apakah mask tersebut benar-benar diteruskan sepenuhnya bergantung pada pemanggil.

ca_rope (*bool*, *opsional*, defaultnya False) : Apakah akan menggunakan cross-modal audio RoPE.

cross_gates (*bool*, *opsional*, defaultnya False) : Apakah akan menggunakan gerbang residual lintas-modal.

fix_modulation (*bool*, *opsional*, defaultnya False) : Apakah akan menggunakan varian modulasi tetap.

visual_token_type_num_embeddings (*int*, *opsional*, default 0) : Jumlah embedding tipe token visual.

Kandinsky 6 transformer multimodal untuk generasi teks/gambar-ke-video-dan-audio.

Video dan audio didenois bersama melalui blok transformer lintas-modal yang terfusi, masing-masing dikondisikan pada cabang teksnya sendiri (token Qwen2.5-VL + embedding CLIP yang dipool). Jika tidak ada *audio_hidden_states* yang diteruskan, hanya video yang didenois, sementara tahap self-attention video, cross-attention, dan feed-forward dari blok terfusi tetap dijalankan. Embedding rotasi dihitung di dalam *forward* dari grid token.

Checkpoint yang dirilis mengatur *text_token_padding*, *ca_rope*, *cross_gates*, dan *fix_modulation* menjadi *True* (lihat *transformer/config.json* untuk masing-masing checkpoint); nilai default *False* hanya menggambarkan varian arsitektur yang tidak memiliki bobot yang disertakan di repo ini.

#### forward[[diffusers.Kandinsky6Transformer3DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor, pooled_projections: Tensor, timestep: Tensor, audio_hidden_states: Tensor | None = None, visual_rope_pos: tuple[Tensor, Tensor, Tensor] | None = None, encoder_attention_mask: Tensor | None = None, visual_token_type_ids: Tensor | None = None, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_kandinsky6.py#L739)

**Parameter:**

hidden_states (`torch.Tensor` dengan bentuk `(batch_size, num_frames, height, width, in_channels)`) : Laten video dalam tata letak `(B, T, H, W, C)`. Dengan `visual_cond=True`, `in_channels` adalah `2 * in_visual_dim + 1`: laten berisik, laten kondisioning, dan mask kondisioning.

encoder_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, in_text_dim)`) : Embedding token teks, yang dibagikan oleh cabang teks video dan audio.

pooled_projections (`torch.Tensor` dengan bentuk `(batch_size, in_text_dim2)`) : Embedding teks yang di-pool dan ditambahkan ke embedding timestep dari kedua cabang.

timestep (`torch.Tensor` dengan bentuk `(batch_size,)`) : Langkah difusi pada skala `[0, num_train_timesteps]`, yang digunakan bersama oleh kedua modalitas.

audio_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, audio_length, in_audio_dim)`, *opsional*) : Laten audio. Jika diabaikan, blok yang digabungkan hanya menjalankan jalur video.

visual_rope_pos (`tuple[torch.Tensor, torch.Tensor, torch.Tensor]`, *opsional*) : Indeks posisi rotasi per sumbu `(t, h, w)` untuk token video yang telah di-patchify. Nilainya secara default adalah `arange` di setiap sumbu. Pipeline meneruskan indeks temporal eksplisit saat menambahkan frame referensi yang menggunakan ulang posisi `0`.

encoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, sequence_length)`, *opsional*) : Mask padding Boolean untuk `encoder_hidden_states`. Berikan `None` ketika tidak ada prompt yang di-pad.

visual_token_type_ids (`torch.Tensor` dengan bentuk `(batch_size, num_frames)`, *opsional*) : ID tipe token per frame, yang disematkan melalui `visual_token_type_embeddings`. Memerlukan `visual_token_type_num_embeddings > 0`.

return_dict (`bool`, defaultnya `True`) : Apakah akan mengembalikan `Kandinsky6TransformerOutput` alih-alih tuple biasa.

**Mengembalikan:** `Kandinsky6TransformerOutput` atau `tuple`

Kecepatan video yang diprediksi dalam tata letak `(B, T, H, W, out_visual_dim)` dan, ketika `audio_hidden_states` diberikan, kecepatan audio yang diprediksi dengan bentuk `(B, audio_length, out_audio_dim)`.

## Kandinsky6SRTransformer3DModel[[diffusers.Kandinsky6SRTransformer3DModel]]

Transformer tanpa teks yang digunakan oleh [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) untuk menyempurnakan satu ubin video yang telah diperbesar pada satu waktu.

```python
import torch
from diffusers import Kandinsky6SRTransformer3DModel

transformer = Kandinsky6SRTransformer3DModel.from_pretrained(
    "kandinskylab/Kandinsky-6.0-VSR-distilled2steps-5s-Diffusers", subfolder="transformer", torch_dtype=torch.bfloat16
)
# The transformer always runs NABLA sparse attention (`nabla_threshold`, 0.8 by default) on the `flex` backend.
# Compile it, otherwise flex falls back to an eager implementation that needs far more memory at video resolutions.
transformer.compile_repeated_blocks(fullgraph=True)
```

#### diffusers.Kandinsky6SRTransformer3DModel[[diffusers.Kandinsky6SRTransformer3DModel]]

```python
diffusers.Kandinsky6SRTransformer3DModel(in_visual_dim: int = 64, out_visual_dim: int = 640, time_dim: int = 512, patch_size: tuple[int, int, int] = (1, 1, 1), model_dim: int = 1792, ff_dim: int = 7168, num_visual_blocks: int = 32, axes_dims: tuple[int, int, int] = (16, 24, 24), scale_factor: tuple[float, float, float] = (1.0, 2.0, 2.0), nabla_threshold: float = 0.8, nabla_window: tuple[int, int, int] = (11, 7, 7), tile_sizes: tuple[tuple[int, int], ...] = ((512, 512), (512, 768), (768, 512)))
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_kandinsky6_sr.py#L412)

**Parameter:**

in_visual_dim (`int`, defaultnya `64`) : Jumlah kanal laten dari K-VAE.

out_visual_dim (`int`, defaultnya `640`) : Jumlah saluran output.

time_dim (`int`, defaultnya `512`) : Dimensi dari embedding timestep.

patch_size (`tuple[int, int, int]`, defaultnya `(1, 1, 1)`) : Ukuran patch sebagai `(temporal, height, width)`.

model_dim (`int`, defaultnya `1792`) : Dimensi tersembunyi dari transformer.

ff_dim (`int`, defaultnya `7168`) : Dimensi dalam dari jaringan feed-forward.

num_visual_blocks (`int`, defaultnya `32`) : Jumlah blok transformer.

axes_dims (`tuple[int, int, int]`, defaultnya `(16, 24, 24)`) : dimensi RoPE per sumbu `(t, h, w)`; jumlah dari dimensi-dimensi tersebut adalah dimensi head perhatian.

scale_factor (`tuple[float, float, float]`, defaultnya `(1.0, 2.0, 2.0)`) : Penskalaan frekuensi RoPE per sumbu yang diterapkan pada posisi token.

nabla_threshold (`float`, defaultnya `0.8`) : Ambang batas atensi kumulatif untuk pemilihan blok NABLA.

nabla_window (`tuple[int, int, int]`, defaultnya `(11, 7, 7)`) : Rentang `(t, h, w)` ganjil dari prior sliding-tile yang selalu diperhatikan oleh setiap blok token 8x8.

tile_sizes (`tuple[tuple[int, int], ...]`, defaultnya `((512, 512), (512, 768), (768, 512))`) : Ukuran piksel `(height, width)` dari video tile yang digunakan untuk melatih model. [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/id/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) menyempurnakan setiap tile pada ukuran yang rasio aspeknya paling mendekati rasio aspek video input.

Diffusion transformer tanpa teks untuk super-resolusi video Kandinsky 6.

Model ini melakukan denoising pada tile dari video laten K-VAE. Inputnya menggabungkan laten berisik dengan laten jangkar dan mask jangkar yang mengondisikan super-resolusi (`2 * in_visual_dim + 1` channel), dan outputnya berisi `out_visual_dim` channel: `in_visual_dim` untuk checkpoint velocity biasa, atau `n_grid * in_visual_dim` yang diperlebar untuk checkpoint terdistilasi [PiflowScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/piflow#diffusers.PiflowScheduler). Self-attention video berjalan melalui pola blok sparse NABLA pada backend perhatian `flex`, yang membutuhkan grid token (`height` dan `width` setelah `patch_size`) dapat dibagi habis oleh 8.

#### forward[[diffusers.Kandinsky6SRTransformer3DModel.forward]]

```python
forward(hidden_states: Tensor, timestep: Tensor, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_kandinsky6_sr.py#L496)

**Parameter:**

hidden_states (`torch.Tensor` dengan bentuk `(batch_size, num_frames, height, width, 2 * in_visual_dim + 1)`) : Tile laten dalam tata letak `(B, T, H, W, C)`: laten berisik, laten jangkar, dan masker jangkar yang digabungkan sepanjang sumbu channel.

timestep (`torch.Tensor` dengan bentuk `(batch_size,)`) : Langkah difusi pada skala `[0, num_train_timesteps]`.

return_dict (`bool`, defaultnya `True`) : Apakah akan mengembalikan [Transformer2DModelOutput](/docs/diffusers/v0.43.0/id/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) alih-alih tuple biasa.

**Mengembalikan:** [Transformer2DModelOutput](/docs/diffusers/v0.43.0/id/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) atau `tuple`

Prediksi bentuk `(batch_size, num_frames, height, width, out_visual_dim)`.