# SanaVideoTransformer3DModel

Un modèle Diffusion Transformer pour des données 3D (vidéo) issu de [SANA-Video: Efficient Video Generation with Block Linear Diffusion Transformer](https://huggingface.co/papers/2509.24695) de NVIDIA et du MIT HAN Lab, par Junsong Chen, Yuyang Zhao, Jincheng Yu, Ruihang Chu, Junyu Chen, Shuai Yang, Xianbang Wang, Yicheng Pan, Daquan Zhou, Huan Ling, Haozhe Liu, Hongwei Yi, Hao Zhang, Muyang Li, Yukang Chen, Han Cai, Sanja Fidler, Ping Luo, Song Han, Enze Xie.

L'abstract de l'article est :

*Nous présentons SANA-Video, un petit modèle de diffusion capable de générer efficacement des vidéos jusqu'à une résolution de 720x1280 et d'une durée d'une minute. SANA-Video synthétise des vidéos haute résolution, de haute qualité et longues, avec un fort alignement texte-vidéo, à une vitesse remarquablement rapide, et peut être déployé sur un GPU RTX 5090. Deux conceptions clés garantissent notre génération de vidéos efficace, performante et longue : (1) Linear DiT : nous exploitons l'attention linéaire comme opération centrale, ce qui est plus efficace que l'attention standard compte tenu du grand nombre de jetons traités dans la génération de vidéos. (2) Cache KV à mémoire constante pour l'attention linéaire par blocs : nous concevons une approche autorégressive par blocs pour la génération de vidéos longues en utilisant un état à mémoire constante, dérivé des propriétés cumulatives de l'attention linéaire. Ce cache KV fournit au Linear DiT un contexte global à un coût mémoire fixe, éliminant le besoin d'un cache KV traditionnel et permettant une génération efficace de vidéos d'une minute. En outre, nous explorons des filtres de données et des stratégies d'entraînement efficaces, réduisant le coût d'entraînement à 12 jours sur 64 GPU H100, soit seulement 1 % du coût de MovieGen. Compte tenu de son faible coût, SANA-Video atteint des performances compétitives par rapport aux petits modèles de diffusion modernes de pointe (par exemple, Wan 2.1-1.3B et SkyReel-V2-1.3B) tout en étant 16 fois plus rapide en latence mesurée. De plus, SANA-Video peut être déployé sur des GPU RTX 5090 avec une précision NVFP4, accélérant la vitesse d'inférence de la génération d'une vidéo 720p de 5 secondes de 71 s à 29 s (accélération de 2,4 fois). En résumé, SANA-Video permet une génération de vidéos de haute qualité à faible coût.*

Le modèle peut être chargé à l'aide du fragment de code suivant.

```python
from diffusers import SanaVideoTransformer3DModel
import torch

transformer = SanaVideoTransformer3DModel.from_pretrained("Efficient-Large-Model/SANA-Video_2B_480p_diffusers", subfolder="transformer", dtype=torch.bfloat16)
```

## SanaVideoTransformer3DModel[[diffusers.SanaVideoTransformer3DModel]]

#### diffusers.SanaVideoTransformer3DModel[[diffusers.SanaVideoTransformer3DModel]]

```python
diffusers.SanaVideoTransformer3DModel(in_channels: int = 16, out_channels: int | None = 16, num_attention_heads: int = 20, attention_head_dim: int = 112, num_layers: int = 20, num_cross_attention_heads: int | None = 20, cross_attention_head_dim: int | None = 112, cross_attention_dim: int | None = 2240, caption_channels: int = 2304, mlp_ratio: float = 2.5, dropout: float = 0.0, attention_bias: bool = False, sample_size: int = 30, patch_size: tuple[int, int, int] = (1, 2, 2), norm_elementwise_affine: bool = False, norm_eps: float = 1e-06, interpolation_scale: int | None = None, guidance_embeds: bool = False, guidance_embeds_scale: float = 0.1, qk_norm: str | None = 'rms_norm_across_heads', rope_max_seq_len: int = 1024)
```

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

**Paramètres :**

in_channels (`int`, par défaut `16`) : Le nombre de canaux dans l'entrée.

out_channels (`int`, *facultatif*, par défaut `16`) : Le nombre de canaux dans la sortie.

num_attention_heads (`int`, par défaut `20`) : Le nombre de têtes à utiliser pour l'attention multi-têtes.

attention_head_dim (`int`, par défaut `112`) : Le nombre de canaux dans chaque tête.

num_layers (`int`, par défaut `20`) : Le nombre de blocs Transformer à utiliser.

num_cross_attention_heads (`int`, *facultatif*, par défaut `20`) : Le nombre de têtes à utiliser pour l'attention croisée.

cross_attention_head_dim (`int`, *facultatif*, par défaut `112`) : Le nombre de canaux dans chaque tête pour l'attention croisée.

cross_attention_dim (`int`, *facultatif*, par défaut `2240`) : Le nombre de canaux dans la sortie de l'attention croisée.

caption_channels (`int`, par défaut `2304`) : Le nombre de canaux dans les embeddings de légende.

mlp_ratio (`float`, par défaut `2.5`) : Le ratio d'expansion à utiliser dans la couche GLUMBConv.

dropout (`float`, par défaut `0.0`) : La probabilité de dropout.

attention_bias (`bool`, par défaut `False`) : Indique s'il faut utiliser un biais dans la couche d'attention.

sample_size (`int`, par défaut `32`) : La taille de base du latent d'entrée.

patch_size (`int`, par défaut `1`) : La taille des patches à utiliser dans la couche d'encodage de patches.

norm_elementwise_affine (`bool`, par défaut `False`) : Indique s'il faut utiliser l'affinité élément par élément dans la couche de normalisation.

norm_eps (`float`, par défaut `1e-6`) : La valeur epsilon pour la couche de normalisation.

qk_norm (`str`, *facultatif*, par défaut `None`) : La normalisation à utiliser pour la requête et la clé.

Un modèle Transformer 3D introduit dans la famille de modèles [Sana-Video](https://huggingface.co/papers/2509.24695).

#### forward[[diffusers.SanaVideoTransformer3DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor, timestep: Tensor, guidance: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, attention_kwargs: dict[str, typing.Any] | None = None, controlnet_block_samples: tuple[torch.Tensor] | None = None, return_dict: bool = True)
```

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

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, in_channels, num_frames, height, width)`) : `hidden_states` en entrée.

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, sequence_len, embed_dims)`) : Embeddings conditionnels (embeddings calculés à partir des conditions d'entrée telles que les prompts) à utiliser.

timestep (`torch.LongTensor`) : Utilisé pour indiquer l'étape de débruitage.

guidance (`torch.Tensor`, *facultatif*) : Embedding de l'échelle de guidage.

encoder_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention croisée appliqué à `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *facultatif*) : Masque d'auto-attention appliqué à `hidden_states`.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

controlnet_block_samples (`tuple` de `torch.Tensor`, *facultatif*) : Une liste de tenseurs qui, si elle est spécifiée, est ajoutée aux résidus des blocs de transformeur.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~models.transformer_2d.Transformer2DModelOutput` plutôt qu'un simple tuple.

**Retourne :**

Si `return_dict` est True, un `~models.transformer_2d.Transformer2DModelOutput` est renvoyé, sinon un `tuple` dont le premier élément est le tenseur d'échantillon.

La méthode forward du [SanaVideoTransformer3DModel](/docs/diffusers/main/fr/api/models/sana_video_transformer3d#diffusers.SanaVideoTransformer3DModel).

## Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

#### diffusers.models.modeling_outputs.Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

```python
diffusers.models.modeling_outputs.Transformer2DModelOutput(sample: torch.Tensor)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_outputs.py#L21)

**Paramètres :**

sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` ou `(batch size, num_vector_embeds - 1, num_latent_pixels)` si [Transformer2DModel](/docs/diffusers/main/fr/api/models/transformer2d#diffusers.Transformer2DModel) est discret) : Les états cachés en sortie, conditionnés par l'entrée `encoder_hidden_states`. Si discret, renvoie les distributions de probabilité pour les pixels latents non bruités.

La sortie de [Transformer2DModel](/docs/diffusers/main/fr/api/models/transformer2d#diffusers.Transformer2DModel).