# Kandinsky 6 Transformers

Kandinsky 6 utilise un transformeur de diffusion multimodal qui débruite conjointement les latents vidéo et audio pour la génération de vidéo et d’audio à partir de texte ou d’image, ainsi qu’un transformeur de diffusion sans texte pour la super-résolution vidéo.

## Kandinsky6Transformer3DModel[[diffusers.Kandinsky6Transformer3DModel]]

Le transformer multimodal utilisé par [Kandinsky6TI2VAPipeline](/docs/diffusers/main/fr/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)
```

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

**Paramètres :**

in_visual_dim (*int*, *optionnel*, par défaut 16) : Nombre de canaux latents de la vidéo d'entrée.

out_visual_dim (*int*, *optionnel*, par défaut 16) : Nombre de canaux latents de sortie de la vidéo.

in_text_dim (*int*, *optionnel*, valeur par défaut 3584) : Dimension de l'intégration des jetons de texte.

in_text_dim2 (*int*, *optionnel*, par défaut 768) : Dimension de l'embedding de texte agrégé.

time_dim (*int*, *optionnel*, par défaut 1024) : Dimension de l'embedding temporel.

patch_size (*tuple[int, int, int]*, *facultatif*, par défaut `(1, 2, 2)`) : Taille des patches vidéo.

model_dim (*int*, *optionnel*, valeur par défaut 4096) : Dimension cachée du transformateur vidéo.

ff_dim (*int*, *optionnel*, par défaut 16384) : Dimension cachée du réseau feed-forward de la vidéo.

num_text_blocks (*int*, *optionnel*, valeur par défaut 4) : Nombre de blocs de texte par modalité.

num_visual_blocks (*int*, *optionnel*, valeur par défaut 60) : Nombre de blocs vidéo/audio fusionnés.

axes_dims (*tuple[int, int, int]*, *facultatif*, valeur par défaut `(32, 48, 48)`) : dimensions RoPE pour la vidéo.

visual_cond (*bool*, *facultatif*, valeur par défaut True) : Indique si les canaux de conditionnement vidéo sont présents.

in_audio_dim (*int*, *optionnel*, valeur par défaut 20) : Nombre de canaux latents d'entrée audio.

out_audio_dim (*int*, *optionnel*, par défaut 20) : Nombre de canaux latents audio en sortie.

model_dim_a (*int*, *optionnel*) : Dimension cachée du transformeur audio. Par défaut, *model_dim*.

time_dim_a (*int*, *optionnel*) : Dimension de l'embedding temporel audio. Par défaut, *time_dim*.

ff_dim_a (*int*, *optionnel*) : Dimension cachée du réseau de propagation avant audio. Par défaut, *ff_dim*.

axes_dims_a (*tuple[int, int, int]*, *optionnel*) : Dimensions de RoPE audio. Valeur par défaut : *axes_dims*.

audio_freqs_scaling (*float*, *optionnel*, valeur par défaut 1.0) : Mise à l'échelle de la fréquence de RoPE audio.

scale_factor (*tuple[float, float, float]*, *optionnel*, par défaut *(1.0, 2.0, 2.0)*) : Échelle de fréquence RoPE par axe *(t, h, w)* appliquée aux positions de la vidéo.

text_token_padding (*bool*, *facultatif*, défaut : False) : Métadonnées du point de contrôle indiquant si les séquences de texte du modèle de référence sont remplies. *forward* accepte toujours un *encoder_attention_mask* facultatif, indépendamment de ce drapeau ; le fait de le transmettre ou non relève entièrement de l'appelant.

ca_rope (*bool*, *facultatif*, valeur par défaut False) : Indique s'il faut utiliser le RoPE audio intermodal.

cross_gates (*bool*, *facultatif*, valeur par défaut : False) : Indique s'il faut utiliser des portes résiduelles inter-modales.

fix_modulation (*bool*, *facultatif*, valeur par défaut : False) : Indique s'il faut utiliser la variante de modulation fixe.

visual_token_type_num_embeddings (*int*, *optionnel*, valeur par défaut 0) : Nombre d'embeddings de type de jeton visuel.

Kandinsky 6, un transformeur multimodal pour la génération de vidéo et d'audio à partir de texte et d'images.

La vidéo et l'audio sont débruités ensemble à travers des blocs de transformateurs fusionnés inter-modaux, chacun étant conditionné par sa propre branche de texte (jetons Qwen2.5-VL + plongée CLIP agrégée). Ne pas passer de *audio_hidden_states* débruite la vidéo seule tout en exécutant toujours les étapes d'auto-attention vidéo, d'attention croisée et de réseau de neurones entièrement connecté du bloc fusionné. Les plongées rotationnelles sont calculées à l'intérieur de *forward* à partir de la grille de jetons.

Les points de contrôle publiés définissent *text_token_padding*, *ca_rope*, *cross_gates* et *fix_modulation* sur *True* (voir le *transformer/config.json* de chaque point de contrôle) ; les valeurs par défaut *False* ne décrivent qu'une variante d'architecture pour laquelle ce dépôt ne fournit pas de poids.

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

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

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, num_frames, height, width, in_channels)`) : Latents vidéo dans le format `(B, T, H, W, C)`. Avec `visual_cond=True`, `in_channels` vaut `2 * in_visual_dim + 1` : le latent bruité, le latent de conditionnement et un masque de conditionnement.

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, sequence_length, in_text_dim)`) : Embeddings de jetons de texte, partagés par les branches texte de la vidéo et de l'audio.

pooled_projections (`torch.Tensor` de forme `(batch_size, in_text_dim2)`) : Embedding de texte agrégé ajouté à l'embedding de timestep des deux branches.

timestep (`torch.Tensor` de forme `(batch_size,)`) : Pas de diffusion sur l'échelle `[0, num_train_timesteps]`, partagé par les deux modalités.

audio_hidden_states (`torch.Tensor` de forme `(batch_size, audio_length, in_audio_dim)`, *facultatif*) : Latents audio. S'ils sont omis, les blocs fusionnés n'exécutent que leur chemin vidéo.

visual_rope_pos (`tuple[torch.Tensor, torch.Tensor, torch.Tensor]`, *facultatif*) : Indices de position rotative par axe `(t, h, w)` des jetons vidéo patchifiés. Par défaut, `arange` est appliqué sur chaque axe. Le pipeline transmet un index temporel explicite lorsqu'il ajoute un cadre de référence qui réutilise la position `0`.

encoder_attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque de bourrage booléen pour `encoder_hidden_states`. Passez `None` si le prompt n’est pas bourré.

visual_token_type_ids (`torch.Tensor` de forme `(batch_size, num_frames)`, *facultatif*) : Identifiants de type de jeton par image, intégrés via `visual_token_type_embeddings`. Nécessite `visual_token_type_num_embeddings > 0`.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `Kandinsky6TransformerOutput` plutôt qu'un simple tuple.

**Retourne :** `Kandinsky6TransformerOutput` ou `tuple`

La vitesse vidéo prédite dans la disposition `(B, T, H, W, out_visual_dim)` et, lorsque `audio_hidden_states` a été fourni, la vitesse audio prédite de forme `(B, audio_length, out_audio_dim)`.

## Kandinsky6SRTransformer3DModel[[diffusers.Kandinsky6SRTransformer3DModel]]

Le transformer sans texte utilisé par [Kandinsky6SRPipeline](/docs/diffusers/main/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) pour affiner une tuile à la fois de la vidéo mise à l'échelle.

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

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

**Paramètres :**

in_visual_dim (`int`, par défaut `64`) : Nombre de canaux latents du K-VAE.

out_visual_dim (`int`, par défaut `640`) : Nombre de canaux de sortie.

time_dim (`int`, par défaut `512`) : Dimension de l'embedding de timestep.

patch_size (`tuple[int, int, int]`, par défaut `(1, 1, 1)`) : Taille du patch en tant que `(temporal, height, width)`.

model_dim (`int`, par défaut `1792`) : Dimension cachée du transformer.

ff_dim (`int`, par défaut `7168`) : Dimension interne des réseaux feed-forward.

num_visual_blocks (`int`, par défaut `32`) : Nombre de blocs transformer.

axes_dims (`tuple[int, int, int]`, par défaut `(16, 24, 24)`) : dimensions de RoPE par axe `(t, h, w)` ; leur somme correspond à la dimension de tête d'attention.

scale_factor (`tuple[float, float, float]`, par défaut `(1.0, 2.0, 2.0)`) : Mise à l'échelle des fréquences RoPE par axe appliquée aux positions des jetons.

nabla_threshold (`float`, par défaut `0.8`) : Seuil d'attention cumulative pour la sélection des blocs NABLA.

nabla_window (`tuple[int, int, int]`, par défaut `(11, 7, 7)`) : Étendues impaires `(t, h, w)` du prior de tuile glissante auquel chaque bloc de jetons 8x8 accorde toujours son attention.

tile_sizes (`tuple[tuple[int, int], ...]`, par défaut `((512, 512), (512, 768), (768, 512))`) : Tailles `(height, width)` en pixels des tuiles vidéo sur lesquelles le modèle a été entraîné. [Kandinsky6SRPipeline](/docs/diffusers/main/fr/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) affine chaque tuile à la taille dont le ratio d’aspect est le plus proche de celui de la vidéo d’entrée.

Transformeur de diffusion sans texte pour la super-résolution vidéo de Kandinsky 6.

Le modèle débruite les tuiles de la vidéo latente du K-VAE. Son entrée concatène le latent bruité avec le latent d’ancrage et le masque d’ancrage qui conditionnent la super-résolution (`2 * in_visual_dim + 1` canaux), et sa sortie contient `out_visual_dim` canaux : `in_visual_dim` pour un point de contrôle de vitesse standard, ou un `n_grid * in_visual_dim` élargi pour les points de contrôle distillés [PiflowScheduler](/docs/diffusers/main/fr/api/schedulers/piflow#diffusers.PiflowScheduler). L’auto-attention vidéo passe par le motif de blocs creux NABLA sur le backend d’attention `flex`, qui exige que la grille de jetons (`height` et `width` après `patch_size`) soit divisible par 8.

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

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

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

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, num_frames, height, width, 2 * in_visual_dim + 1)`) : Tuiles latentes dans la disposition `(B, T, H, W, C)` : le latent bruité, le latent d’ancrage et le masque d’ancrage concaténés le long de l’axe des canaux.

timestep (`torch.Tensor` de forme `(batch_size,)`) : Pas de diffusion sur l'échelle `[0, num_train_timesteps]`.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [Transformer2DModelOutput](/docs/diffusers/main/fr/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) plutôt qu'un simple tuple.

**Retourne :** [Transformer2DModelOutput](/docs/diffusers/main/fr/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) ou `tuple`

La prédiction de la forme `(batch_size, num_frames, height, width, out_visual_dim)`.