# Kandinsky 6 Transformers

Kandinsky 6 utiliza un transformador de difusión multimodal que desruidea los latentes de video y audio de forma conjunta para la generación de video y audio a partir de texto o imagen, y un transformador de difusión sin texto para la superresolución de video.

## Kandinsky6Transformer3DModel[[diffusers.Kandinsky6Transformer3DModel]]

El transformer multimodal utilizado por [Kandinsky6TI2VAPipeline](/docs/diffusers/v0.43.0/es/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)
```

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

**Parámetros:**

in_visual_dim (*int*, *optional*, por defecto 16) : Número de canales latentes de entrada del video.

out_visual_dim (*int*, *optional*, por defecto 16) : Número de canales latentes de salida del video.

in_text_dim (*int*, *optional*, por defecto 3584) : Dimensión de la incrustación de tokens de texto.

in_text_dim2 (*int*, *optional*, por defecto 768) : Dimensión de la representación de texto agrupada.

time_dim (*int*, *optional*, por defecto 1024) : Dimensión del embedding temporal.

patch_size (*tuple[int, int, int]*, *opcional*, valor predeterminado `(1, 2, 2)`) : Tamaño del parche de video.

model_dim (*int*, *optional*, por defecto 4096) : Dimensión oculta del transformador de video.

ff_dim (*int*, *optional*, por defecto 16384) : Dimensión oculta del feed-forward del video.

num_text_blocks (*int*, *optional*, por defecto 4) : Número de bloques de texto por modalidad.

num_visual_blocks (*int*, *optional*, por defecto 60) : Número de bloques de video/audio fusionados.

axes_dims (*tuple[int, int, int]*, *opcional*, valor predeterminado `(32, 48, 48)`) : Dimensiones de RoPE para video.

visual_cond (*bool*, *opcional*, valor predeterminado True) : Indica si están presentes los canales de condicionamiento de video.

in_audio_dim (*int*, *optional*, por defecto 20) : Número de canales latentes de audio de entrada.

out_audio_dim (*int*, *optional*, por defecto 20) : Número de canales latentes de audio de salida.

model_dim_a (*int*, *optional*) : Dimensión oculta del transformador de audio. El valor predeterminado es *model_dim*.

time_dim_a (*int*, *optional*) : Dimensión del embedding temporal de audio. El valor predeterminado es *time_dim*.

ff_dim_a (*int*, *optional*) : Dimensión oculta del feed-forward de audio. El valor predeterminado es *ff_dim*.

axes_dims_a (*tuple[int, int, int]*, *optional*) : Dimensiones de RoPE para audio. El valor predeterminado es *axes_dims*.

audio_freqs_scaling (*float*, *optional*, por defecto 1.0) : Escalado de frecuencia de RoPE para audio.

scale_factor (*tuple[float, float, float]*, *optional*, por defecto *(1.0, 2.0, 2.0)*) : Escalado de frecuencia RoPE por eje *(t, h, w)* aplicado a las posiciones del video.

text_token_padding (*bool*, *opcional*, predeterminado en False) : Metadatos del checkpoint que registran si las secuencias de texto del modelo de referencia están rellenas. *forward* siempre acepta un *encoder_attention_mask* opcional, independientemente de esta bandera; si se pasa o no depende por completo del llamador.

ca_rope (*bool*, *opcional*, predeterminado en False) : Si se debe usar RoPE de audio multimodal.

cross_gates (*bool*, *opcional*, predeterminado en False) : Si se deben usar puertas residuales intermodales.

fix_modulation (*bool*, *opcional*, predeterminado en False) : Si se debe usar la variante de modulación fija.

visual_token_type_num_embeddings (*int*, *optional*, por defecto 0) : Número de embeddings de tipo de token visual.

Kandinsky 6, un transformer multimodal para la generación de video y audio a partir de texto/imagen.

El video y el audio se desruidan juntos a través de bloques de transformador fusionados y multimodales, cada uno condicionado por su propia rama de texto (tokens de Qwen2.5-VL + embedding agrupado de CLIP). Si no se pasa *audio_hidden_states*, se desruidan solo el video, ejecutando aún así las etapas de autoatención de video, atención cruzada y red feed-forward del bloque fusionado. Los embeddings rotatorios se calculan dentro de *forward* a partir de la cuadrícula de tokens.

Los puntos de control publicados establecen *text_token_padding*, *ca_rope*, *cross_gates* y *fix_modulation* en *True* (consulte el *transformer/config.json* de cada punto de control); los valores predeterminados de *False* solo describen una variante de arquitectura para la que este repositorio no incluye 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)
```

[Fuente](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 video en el formato `(B, T, H, W, C)`. Con `visual_cond=True`, `in_channels` es `2 * in_visual_dim + 1`: el latente con ruido, el latente de condicionamiento y una máscara de condicionamiento.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_length, in_text_dim)`) : Incrustaciones de tokens de texto, compartidas por las ramas de texto de video y audio.

pooled_projections (`torch.Tensor` de forma `(batch_size, in_text_dim2)`) : Incrustación de texto agrupada que se añade a la incrustación del paso de tiempo de ambas ramas.

timestep (`torch.Tensor` de forma `(batch_size,)`) : Paso de difusión en la escala `[0, num_train_timesteps]`, compartido por ambas modalidades.

audio_hidden_states (`torch.Tensor` de forma `(batch_size, audio_length, in_audio_dim)`, *opcional*) : Latentes de audio. Si se omite, los bloques fusionados solo ejecutan su ruta de video.

visual_rope_pos (`tuple[torch.Tensor, torch.Tensor, torch.Tensor]`, *opcional*) : Índices de posición rotacional por eje `(t, h, w)` de los tokens de video segmentados. Por defecto, se usa `arange` en cada eje. El pipeline pasa un índice temporal explícito cuando añade un cuadro de referencia que reutiliza la posición `0`.

encoder_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara booleana de relleno para `encoder_hidden_states`. Pasa `None` cuando no hay relleno en el prompt.

visual_token_type_ids (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : ids de tipo de token por cuadro, incrustados a través de `visual_token_type_embeddings`. Requiere `visual_token_type_num_embeddings > 0`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `Kandinsky6TransformerOutput` en lugar de una tupla simple.

**Devuelve:** `Kandinsky6TransformerOutput` o `tuple`

La velocidad de video predicha en el formato `(B, T, H, W, out_visual_dim)` y, cuando se proporcionó `audio_hidden_states`, la velocidad de audio predicha de forma `(B, audio_length, out_audio_dim)`.

## Kandinsky6SRTransformer3DModel[[diffusers.Kandinsky6SRTransformer3DModel]]

El transformer sin texto que utiliza [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) para refinar una baldosa a la vez del video 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)))
```

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

**Parámetros:**

in_visual_dim (`int`, por defecto `64`) : Número de canales latentes del K-VAE.

out_visual_dim (`int`, por defecto `640`) : Número de canales de salida.

time_dim (`int`, por defecto `512`) : Dimensión del embedding del timestep.

patch_size (`tuple[int, int, int]`, por defecto `(1, 1, 1)`) : Tamaño del parche como `(temporal, height, width)`.

model_dim (`int`, por defecto `1792`) : Dimensión oculta del transformer.

ff_dim (`int`, por defecto `7168`) : Dimensión interna de las redes feed-forward.

num_visual_blocks (`int`, por defecto `32`) : Número de bloques de transformer.

axes_dims (`tuple[int, int, int]`, por defecto `(16, 24, 24)`) : dimensiones de RoPE por eje `(t, h, w)`; su suma es la dimensión de la cabeza de atención.

scale_factor (`tuple[float, float, float]`, por defecto `(1.0, 2.0, 2.0)`) : Escalado de frecuencia de RoPE por eje aplicado a las posiciones de los tokens.

nabla_threshold (`float`, por defecto `0.8`) : Umbral de atención acumulativa para la selección de bloques de NABLA.

nabla_window (`tuple[int, int, int]`, por defecto `(11, 7, 7)`) : Extensiones impares `(t, h, w)` del prior de mosaico deslizante al que cada bloque de tokens 8x8 siempre presta atención.

tile_sizes (`tuple[tuple[int, int], ...]`, por defecto `((512, 512), (512, 768), (768, 512))`) : Tamaños de píxel `(height, width)` de los mosaicos de vídeo en los que se entrenó el modelo. [Kandinsky6SRPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) refina cada mosaico con el tamaño cuya relación de aspecto es la más cercana a la del vídeo de entrada.

Transformador de difusión sin texto para la superresolución de video de Kandinsky 6.

El modelo desruidiza los mosaicos del video latente de K-VAE. Su entrada concatena el latente ruidoso con el latente de anclaje y la máscara de anclaje que condicionan la superresolución (`2 * in_visual_dim + 1` canales), y su salida contiene `out_visual_dim` canales: `in_visual_dim` para un checkpoint de velocidad simple, o un `n_grid * in_visual_dim` ampliado para los checkpoints destilados de [PiflowScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/piflow#diffusers.PiflowScheduler). La autoatención del video se ejecuta a través del patrón de bloques dispersos NABLA en el backend de atención `flex`, que requiere que la cuadrícula de tokens (`height` y `width` después de `patch_size`) sea divisible entre 8.

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

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

[Fuente](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)`) : Baldosas latentes en el formato `(B, T, H, W, C)`: el latente con ruido, el latente de anclaje y la máscara de anclaje concatenados a lo largo del eje de canales.

timestep (`torch.Tensor` de forma `(batch_size,)`) : Paso de difusión en la escala `[0, num_train_timesteps]`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un [Transformer2DModelOutput](/docs/diffusers/v0.43.0/es/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) en lugar de una tupla simple.

**Devuelve:** [Transformer2DModelOutput](/docs/diffusers/v0.43.0/es/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) o `tuple`

La predicción de la forma `(batch_size, num_frames, height, width, out_visual_dim)`.