# Kandinsky 6 Transformers

Kandinsky 6 usa um difusor de transformador multimodal que remove o ruído dos latentes de vídeo e áudio juntos para geração de vídeo e áudio a partir de texto/imagem, e um difusor de transformador sem texto para super-resolução de vídeo.

## Kandinsky6Transformer3DModel[[diffusers.Kandinsky6Transformer3DModel]]

O transformer multimodal usado por [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/pt/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)
```

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

**Parâmetros:**

in_visual_dim (*int*, *optional*, padrão 16) : Número de canais latentes de vídeo de entrada.

out_visual_dim (*int*, *opcional*, padrão 16) : Número de canais latentes de vídeo de saída.

in_text_dim (*int*, *optional*, padrão 3584) : Dimensão do embedding de tokens de texto.

in_text_dim2 (*int*, *opcional*, padrão 768) : Dimensão do embedding de texto agrupado.

time_dim (*int*, *optional*, padrão 1024) : Dimensão do embedding de tempo.

patch_size (*tuple[int, int, int]*, *opcional*, padrão `(1, 2, 2)`) : Tamanho do patch de vídeo.

model_dim (*int*, *optional*, padrão 4096) : Dimensão oculta do transformador de vídeo.

ff_dim (*int*, *optional*, padrão 16384) : Dimensão oculta do feed-forward do vídeo.

num_text_blocks (*int*, *opcional*, padrão 4) : Número de blocos de texto por modalidade.

num_visual_blocks (*int*, *opcional*, padrão 60) : Número de blocos de vídeo/áudio fundidos.

axes_dims (*tuple[int, int, int]*, *opcional*, padrão `(32, 48, 48)`) : Dimensões do RoPE para vídeo.

visual_cond (*bool*, *opcional*, padrão True) : Indica se os canais de condicionamento de vídeo estão presentes.

in_audio_dim (*int*, *opcional*, padrão 20) : Número de canais latentes de áudio de entrada.

out_audio_dim (*int*, *opcional*, padrão 20) : Número de canais latentes de áudio de saída.

model_dim_a (*int*, *optional*) : Dimensão oculta do transformador de áudio. O padrão é *model_dim*.

time_dim_a (*int*, *opcional*) : Dimensão do embedding de tempo de áudio. O padrão é *time_dim*.

ff_dim_a (*int*, *opcional*) : Dimensão oculta do feed-forward de áudio. O padrão é *ff_dim*.

axes_dims_a (*tuple[int, int, int]*, *opcional*) : Dimensões do Audio RoPE. O padrão é *axes_dims*.

audio_freqs_scaling (*float*, *optional*, padrão 1.0) : Escala de frequência do RoPE de áudio.

scale_factor (*tuple[float, float, float]*, *opcional*, padrão *(1.0, 2.0, 2.0)*) : Escala de frequência RoPE por eixo *(t, h, w)* aplicada às posições do vídeo.

text_token_padding (*bool*, *opcional*, padrão é False) : Metadados do checkpoint que registram se as sequências de texto do modelo de referência são preenchidas (padded). O *forward* sempre aceita um *encoder_attention_mask* opcional, independentemente desta flag; se um é realmente passado depende inteiramente do chamador.

ca_rope (*bool*, *opcional*, padrão é False) : Se deve usar RoPE de áudio cross-modal.

cross_gates (*bool*, *opcional*, padrão é False) : Se deve usar portões residuais intermodais.

fix_modulation (*bool*, *opcional*, padrão é False) : Se deve usar a variante de modulação fixa.

visual_token_type_num_embeddings (*int*, *opcional*, padrão 0) : Número de embeddings de tipo de token visual.

Kandinsky 6, um transformer multimodal para geração de vídeo e áudio a partir de texto/imagens.

Vídeo e áudio são desruídos juntos por meio de blocos de transformer fundidos e intermodais, cada um condicionado em seu próprio ramo de texto (tokens do Qwen2.5-VL + embedding agregado do CLIP). Ao não passar *audio_hidden_states*, apenas o vídeo é desruído, mas as etapas de autoatenção de vídeo, atenção cruzada e feed-forward do bloco fundido ainda são executadas. Os embeddings rotativos são calculados dentro de *forward* a partir da grade de tokens.

Os checkpoints liberados definem *text_token_padding*, *ca_rope*, *cross_gates* e *fix_modulation* como *True* (veja o *transformer/config.json* de cada checkpoint); os padrões *False* descrevem apenas uma variante de arquitetura para a qual este repositório não disponibiliza pesos.

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

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

**Parâmetros:**

hidden_states (`torch.Tensor` de forma `(batch_size, num_frames, height, width, in_channels)`) : Latentes de vídeo no layout `(B, T, H, W, C)`. Com `visual_cond=True`, `in_channels` é `2 * in_visual_dim + 1`: o latente com ruído, o latente de condicionamento e uma máscara de condicionamento.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, in_text_dim)`) : Incorporações de tokens de texto, compartilhadas pelos ramos de texto de vídeo e áudio.

pooled_projections (`torch.Tensor` de forma `(batch_size, in_text_dim2)`) : Incorporação de texto agregada adicionada à incorporação de passo de tempo de ambos os ramos.

timestep (`torch.Tensor` de forma `(batch_size,)`) : Passo de difusão na escala `[0, num_train_timesteps]`, compartilhado por ambas as modalidades.

audio_hidden_states (`torch.Tensor` de forma `(batch_size, audio_length, in_audio_dim)`, *opcional*) : Latentes de áudio. Quando omitido, os blocos fundidos executam apenas o caminho de vídeo.

visual_rope_pos (`tuple[torch.Tensor, torch.Tensor, torch.Tensor]`, *opcional*) : Índices de posição rotacional por eixo `(t, h, w)` dos tokens de vídeo patchificados. O padrão é `arange` em cada eixo. O pipeline passa um índice temporal explícito quando adiciona um quadro de referência que reutiliza a posição `0`.

encoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara de preenchimento booleana para `encoder_hidden_states`. Passe `None` quando nenhum prompt for preenchido.

visual_token_type_ids (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : ids de tipo de token por quadro, incorporados através de `visual_token_type_embeddings`. Exige `visual_token_type_num_embeddings > 0`.

return_dict (`bool`, padrão `True`) : Se deve retornar um `Kandinsky6TransformerOutput` em vez de uma tupla simples.

**Retorna:** `Kandinsky6TransformerOutput` ou `tuple`

A velocidade de vídeo prevista no layout `(B, T, H, W, out_visual_dim)` e, quando `audio_hidden_states` foi fornecido, a velocidade de áudio prevista com a forma `(B, audio_length, out_audio_dim)`.

## Kandinsky6SRTransformer3DModel[[diffusers.Kandinsky6SRTransformer3DModel]]

O transformer sem texto usado pelo [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) para refinar um tile de cada vez do vídeo ampliado.

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

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

**Parâmetros:**

in_visual_dim (`int`, padrão `64`) : Número de canais latentes do K-VAE.

out_visual_dim (`int`, padrão `640`) : Número de canais de saída.

time_dim (`int`, padrão `512`) : Dimensão do embedding de timestep.

patch_size (`tuple[int, int, int]`, padrão `(1, 1, 1)`) : Tamanho do patch como `(temporal, height, width)`.

model_dim (`int`, padrão `1792`) : Dimensão oculta do transformer.

ff_dim (`int`, padrão `7168`) : Dimensão interna das redes feed-forward.

num_visual_blocks (`int`, padrão `32`) : Número de blocos do transformer.

axes_dims (`tuple[int, int, int]`, padrão `(16, 24, 24)`) : dimensões de RoPE por eixo `(t, h, w)`; sua soma é a dimensão da cabeça de atenção.

scale_factor (`tuple[float, float, float]`, padrão `(1.0, 2.0, 2.0)`) : Escalonamento de frequência RoPE por eixo aplicado às posições dos tokens.

nabla_threshold (`float`, padrão `0.8`) : Limiar de atenção cumulativa para a seleção de blocos do NABLA.

nabla_window (`tuple[int, int, int]`, padrão `(11, 7, 7)`) : Extensões ímpares `(t, h, w)` do prior de tiles deslizantes ao qual cada bloco de tokens 8x8 sempre presta atenção.

tile_sizes (`tuple[tuple[int, int], ...]`, padrão `((512, 512), (512, 768), (768, 512))`) : Tamanhos de pixels `(height, width)` dos tiles de vídeo nos quais o modelo foi treinado. O [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) refina cada tile no tamanho cuja proporção de aspecto é a mais próxima da do vídeo de entrada.

Transformador de difusão sem texto para super-resolução de vídeo do Kandinsky 6.

O modelo remove o ruído dos tiles do vídeo latente do K-VAE. Sua entrada concatena o latente com ruído com o latente âncora e a máscara âncora que condicionam a super-resolução (`2 * in_visual_dim + 1` canais), e sua saída contém `out_visual_dim` canais: `in_visual_dim` para um checkpoint de velocidade simples, ou um `n_grid * in_visual_dim` ampliado para os checkpoints destilados do [PiflowScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/piflow#diffusers.PiflowScheduler). A autoatenção do vídeo é executada através do padrão de bloco esparsos NABLA no backend de atenção `flex`, que exige que a grade de tokens (`height` e `width` após `patch_size`) seja divisível por 8.

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

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

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

**Parâmetros:**

hidden_states (`torch.Tensor` de forma `(batch_size, num_frames, height, width, 2 * in_visual_dim + 1)`) : Tiles latentes no layout `(B, T, H, W, C)`: o latente com ruído, o latente âncora e a máscara âncora concatenados ao longo do eixo de canais.

timestep (`torch.Tensor` de forma `(batch_size,)`) : Passo de difusão na escala `[0, num_train_timesteps]`.

return_dict (`bool`, padrão `True`) : Se deve retornar um [Transformer2DModelOutput](/docs/diffusers/v0.43.0/pt/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) em vez de uma tupla simples.

**Retorna:** [Transformer2DModelOutput](/docs/diffusers/v0.43.0/pt/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) ou `tuple`

A previsão da forma `(batch_size, num_frames, height, width, out_visual_dim)`.