# Kandinsky 6 Transformers

Kandinsky 6 sử dụng một diffusion transformer đa phương thức để khử nhiễu các latents của video và âm thanh cùng nhau cho việc tạo video và âm thanh từ văn bản/hình ảnh, và một diffusion transformer không cần văn bản cho siêu phân giải video.

## Kandinsky6Transformer3DModel[[diffusers.Kandinsky6Transformer3DModel]]

Transformer đa phương thức được sử dụng bởi [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/vi/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)
```

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

**Tham số:**

in_visual_dim (*int*, *optional*, mặc định là 16) : Số lượng kênh tiềm ẩn của video đầu vào.

out_visual_dim (*int*, *optional*, mặc định là 16) : Số lượng kênh latent của video đầu ra.

in_text_dim (*int*, *optional*, mặc định là 3584) : Kích thước nhúng token văn bản.

in_text_dim2 (*int*, *optional*, mặc định là 768) : Kích thước nhúng văn bản đã gộp (pooled).

time_dim (*int*, *optional*, mặc định là 1024) : Kích thước nhúng thời gian.

patch_size (*tuple[int, int, int]*, *optional*, mặc định là `(1, 2, 2)`) : Kích thước patch của video.

model_dim (*int*, *optional*, mặc định là 4096) : Kích thước ẩn của transformer video.

ff_dim (*int*, *optional*, mặc định là 16384) : Kích thước ẩn của lớp feed-forward cho video.

num_text_blocks (*int*, *optional*, mặc định là 4) : Số lượng khối văn bản cho mỗi phương thức.

num_visual_blocks (*int*, *optional*, mặc định là 60) : Số lượng khối video/âm thanh được hợp nhất.

axes_dims (*tuple[int, int, int]*, *tuỳ chọn*, mặc định là `(32, 48, 48)`) : Các chiều RoPE cho video.

visual_cond (*bool*, *optional*, mặc định là True) : Xác định xem các kênh điều kiện video có hiện diện hay không.

in_audio_dim (*int*, *optional*, mặc định là 20) : Số lượng kênh tiềm ẩn của âm thanh đầu vào.

out_audio_dim (*int*, *optional*, mặc định là 20) : Số lượng kênh âm thanh tiềm ẩn đầu ra.

model_dim_a (*int*, *optional*) : Kích thước ẩn của audio transformer. Mặc định là *model_dim*.

time_dim_a (*int*, *optional*) : Kích thước nhúng thời gian âm thanh. Mặc định là *time_dim*.

ff_dim_a (*int*, *optional*) : Kích thước chiều ẩn của mạng feed-forward cho âm thanh. Mặc định là *ff_dim*.

axes_dims_a (*tuple[int, int, int]*, *optional*) : Kích thước Audio RoPE. Mặc định là *axes_dims*.

audio_freqs_scaling (*float*, *optional*, mặc định là 1.0) : Thang tần số RoPE cho âm thanh.

scale_factor (*tuple[float, float, float]*, *optional*, mặc định là *(1.0, 2.0, 2.0)*) : Hệ số mở rộng tần số RoPE theo từng trục *(t, h, w)* được áp dụng cho các vị trí video.

text_token_padding (*bool*, *optional*, mặc định là False) : Metadata của checkpoint ghi nhận xem các chuỗi văn bản của model tham chiếu có được padding hay không. *forward* luôn chấp nhận một *encoder_attention_mask* tùy chọn bất kể cờ này; việc có thực sự truyền nó hay không hoàn toàn do người gọi quyết định.

ca_rope (*bool*, *optional*, mặc định là False) : Có sử dụng cross-modal audio RoPE hay không.

cross_gates (*bool*, *optional*, mặc định là False) : Có sử dụng cổng dư liên phương thức (cross-modal residual gates) hay không.

fix_modulation (*bool*, *optional*, mặc định là False) : Có sử dụng biến thể điều chế cố định hay không.

visual_token_type_num_embeddings (*int*, *optional*, mặc định là 0) : Số lượng embedding của loại token thị giác.

Kandinsky 6 transformer đa phương thức để tạo video và âm thanh từ văn bản/hình ảnh.

Video và audio được khử nhiễu cùng nhau thông qua các khối transformer liên hợp, đa phương thức, mỗi khối được điều kiện bởi nhánh văn bản riêng của nó (token Qwen2.5-VL + embedding CLIP đã pool). Việc không truyền *audio_hidden_states* sẽ khử nhiễu video đơn lẻ trong khi vẫn thực hiện các giai đoạn tự chú ý video, chú ý chéo và mạng truyền thẳng của khối liên hợp. Các embedding xoay được tính toán bên trong *forward* từ lưới token.

Các checkpoint được phát hành đặt *text_token_padding*, *ca_rope*, *cross_gates* và *fix_modulation* thành *True* (xem *transformer/config.json* của từng checkpoint); các giá trị mặc định *False* chỉ mô tả một biến thể kiến trúc mà kho này không cung cấp trọng số.

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

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

**Tham số:**

hidden_states (`torch.Tensor` có shape `(batch_size, num_frames, height, width, in_channels)`) : Video latents trong layout `(B, T, H, W, C)`. Với `visual_cond=True`, `in_channels` là `2 * in_visual_dim + 1`: latent nhiễu, latent điều kiện và mask điều kiện.

encoder_hidden_states (`torch.Tensor` có hình dạng `(batch_size, sequence_length, in_text_dim)`) : Các embedding token văn bản, được chia sẻ bởi các nhánh văn bản của video và âm thanh.

pooled_projections (`torch.Tensor` có shape `(batch_size, in_text_dim2)`) : Nhúng văn bản đã pool được thêm vào nhúng timestep của cả hai nhánh.

timestep (`torch.Tensor` có shape `(batch_size,)`) : Bước thời gian khuếch tán trên thang `[0, num_train_timesteps]`, được chia sẻ bởi cả hai phương thức.

audio_hidden_states (`torch.Tensor` có shape `(batch_size, audio_length, in_audio_dim)`, *tùy chọn*) : Audio latents. Khi bị bỏ qua, các khối hợp nhất chỉ chạy đường dẫn video của chúng.

visual_rope_pos (`tuple[torch.Tensor, torch.Tensor, torch.Tensor]`, *optional*) : Các chỉ số vị trí rotary theo từng trục `(t, h, w)` của các token video đã được patchify. Mặc định là `arange` trên mỗi trục. Pipeline truyền một chỉ số thời gian rõ ràng khi nó thêm một khung hình tham chiếu tái sử dụng vị trí `0`.

encoder_attention_mask (`torch.Tensor` có shape `(batch_size, sequence_length)`, *tùy chọn*) : Mặt nạ padding Boolean cho `encoder_hidden_states`. Truyền `None` khi prompt không được padding.

visual_token_type_ids (`torch.Tensor` có shape `(batch_size, num_frames)`, *tùy chọn*) : Token type ids cho từng khung hình, được nhúng thông qua `visual_token_type_embeddings`. Yêu cầu `visual_token_type_num_embeddings > 0`.

return_dict (`bool`, mặc định là `True`) : Có nên trả về một `Kandinsky6TransformerOutput` thay vì một tuple thông thường hay không.

**Trả về:** `Kandinsky6TransformerOutput` hoặc `tuple`

Tốc độ video dự đoán trong bố cục `(B, T, H, W, out_visual_dim)` và, khi `audio_hidden_states` được cung cấp, tốc độ âm thanh dự đoán có hình dạng `(B, audio_length, out_audio_dim)`.

## Kandinsky6SRTransformer3DModel[[diffusers.Kandinsky6SRTransformer3DModel]]

Transformer không có văn bản được sử dụng bởi [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) để tinh chỉnh từng ô của video đã được phóng to một cách tuần tự.

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

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

**Tham số:**

in_visual_dim (`int`, mặc định là `64`) : Số lượng kênh tiềm ẩn của K-VAE.

out_visual_dim (`int`, mặc định là `640`) : Số lượng kênh đầu ra.

time_dim (`int`, mặc định là `512`) : Kích thước của embedding bước thời gian.

patch_size (`tuple[int, int, int]`, mặc định là `(1, 1, 1)`) : Kích thước patch dưới dạng `(temporal, height, width)`.

model_dim (`int`, mặc định là `1792`) : Kích thước chiều ẩn của transformer.

ff_dim (`int`, mặc định là `7168`) : Kích thước chiều trong của các mạng feed-forward.

num_visual_blocks (`int`, mặc định là `32`) : Số lượng khối transformer.

axes_dims (`tuple[int, int, int]`, mặc định là `(16, 24, 24)`) : Các chiều RoPE theo từng trục `(t, h, w)`; tổng của chúng là chiều đầu chú ý (attention head dimension).

scale_factor (`tuple[float, float, float]`, mặc định là `(1.0, 2.0, 2.0)`) : Hệ số mở rộng tần số RoPE theo từng trục được áp dụng cho các vị trí token.

nabla_threshold (`float`, mặc định là `0.8`) : Ngưỡng chú ý tích lũy (cumulative-attention threshold) của việc chọn khối NABLA.

nabla_window (`tuple[int, int, int]`, mặc định là `(11, 7, 7)`) : Kích thước `(t, h, w)` lẻ của prior trượt ô mà mọi khối token 8x8 luôn chú ý đến.

tile_sizes (`tuple[tuple[int, int], ...]`, mặc định là `((512, 512), (512, 768), (768, 512))`) : Kích thước `(height, width)` của các ô video (tiles) mà mô hình được huấn luyện. [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/vi/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) tinh chỉnh mọi ô ở kích thước có tỷ lệ khung hình gần nhất với video đầu vào.

Biến đổi khuếch tán không có văn bản cho siêu phân giải video Kandinsky 6.

Mô hình khử nhiễu các ô của video tiềm ẩn K-VAE. Đầu vào của nó nối ghép latent nhiễu với latent neo và mặt nạ neo để điều kiện cho siêu phân giải (`2 * in_visual_dim + 1` kênh), và đầu ra của nó chứa `out_visual_dim` kênh: `in_visual_dim` cho checkpoint vận tốc thông thường, hoặc `n_grid * in_visual_dim` mở rộng cho các checkpoint chưng cất [PiflowScheduler](/docs/diffusers/v0.43.0/vi/api/schedulers/piflow#diffusers.PiflowScheduler). Tự chú ý video chạy qua mẫu khối thưa NABLA trên backend chú ý `flex`, đòi hỏi lưới token (`height` và `width` sau `patch_size`) phải chia hết cho 8.

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

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

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

**Tham số:**

hidden_states (`torch.Tensor` có shape `(batch_size, num_frames, height, width, 2 * in_visual_dim + 1)`) : Các lát latent trong bố cục `(B, T, H, W, C)`: latent nhiễu, latent neo và mặt nạ neo được nối theo trục kênh.

timestep (`torch.Tensor` có shape `(batch_size,)`) : Bước thời gian khuếch tán trên thang đo `[0, num_train_timesteps]`.

return_dict (`bool`, mặc định là `True`) : Có nên trả về một [Transformer2DModelOutput](/docs/diffusers/v0.43.0/vi/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) thay vì một tuple thông thường hay không.

**Trả về:** [Transformer2DModelOutput](/docs/diffusers/v0.43.0/vi/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) hoặc `tuple`

Dự đoán hình dạng `(batch_size, num_frames, height, width, out_visual_dim)`.