# SanaVideoTransformer3DModel

Model Diffusion Transformer untuk data 3D (video) dari [SANA-Video: Efficient Video Generation with Block Linear Diffusion Transformer](https://huggingface.co/papers/2509.24695) dari NVIDIA dan MIT HAN Lab, oleh 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.

Abstrak dari makalah tersebut adalah:

*Kami memperkenalkan SANA-Video, sebuah model difusi kecil yang dapat menghasilkan video hingga resolusi 720x1280 dan durasi sepanjang satu menit secara efisien. SANA-Video mensintesis video beresolusi tinggi, berkualitas tinggi, dan panjang dengan keselarasan teks-video yang kuat pada kecepatan yang sangat cepat, dan dapat di-deploy pada GPU RTX 5090. Dua desain inti memastikan generasi video yang efisien, efektif, dan panjang: (1) Linear DiT: Kami memanfaatkan linear attention sebagai operasi inti, yang lebih efisien daripada vanilla attention mengingat jumlah token yang besar yang diproses dalam generasi video. (2) KV cache ber-Constant-Memory untuk Block Linear Attention: kami merancang pendekatan autoregressive per blok untuk generasi video panjang dengan menggunakan state ber-constant-memory, yang diturunkan dari sifat kumulatif linear attention. KV cache ini menyediakan konteks global bagi Linear DiT dengan biaya memori tetap, menghilangkan kebutuhan akan KV cache tradisional, dan memungkinkan generasi video sepanjang satu menit secara efisien. Selain itu, kami mengeksplorasi filter data dan strategi pelatihan model yang efektif, sehingga mempersempit biaya pelatihan menjadi 12 hari pada 64 GPU H100, yang hanya 1% dari biaya MovieGen. Mengingat biayanya yang rendah, SANA-Video mencapai kinerja yang kompetitif dibandingkan dengan model difusi kecil state-of-the-art modern (misalnya, Wan 2.1-1.3B dan SkyReel-V2-1.3B) sambil menjadi 16x lebih cepat dalam latensi yang diukur. Selain itu, SANA-Video dapat di-deploy pada GPU RTX 5090 dengan presisi NVFP4, mempercepat kecepatan inferensi untuk menghasilkan video 720p berdurasi 5 detik dari 71 detik menjadi 29 detik (percepatan 2.4x). Secara ringkas, SANA-Video memungkinkan generasi video berkualitas tinggi dengan biaya rendah.*

Model dapat dimuat dengan potongan kode berikut.

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

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

**Parameter:**

in_channels (`int`, defaultnya `16`) : Jumlah channel pada input.

out_channels (`int`, *opsional*, defaultnya `16`) : Jumlah channel pada output.

num_attention_heads (`int`, defaultnya `20`) : Jumlah head yang digunakan untuk multi-head attention.

attention_head_dim (`int`, defaultnya `112`) : Jumlah channel di setiap head.

num_layers (`int`, defaultnya `20`) : Jumlah lapisan blok Transformer yang akan digunakan.

num_cross_attention_heads (`int`, *opsional*, defaultnya `20`) : Jumlah head yang digunakan untuk cross-attention.

cross_attention_head_dim (`int`, *opsional*, defaultnya `112`) : Jumlah channel di setiap head untuk cross-attention.

cross_attention_dim (`int`, *opsional*, defaultnya `2240`) : Jumlah channel pada output cross-attention.

caption_channels (`int`, defaultnya `2304`) : Jumlah channel dalam caption embeddings.

mlp_ratio (`float`, defaultnya `2.5`) : Rasio ekspansi yang digunakan di lapisan GLUMBConv.

dropout (`float`, defaultnya `0.0`) : Probabilitas dropout.

attention_bias (`bool`, defaultnya `False`) : Apakah akan menggunakan bias di lapisan perhatian.

sample_size (`int`, defaultnya `32`) : Ukuran dasar dari input laten.

patch_size (`int`, defaultnya `1`) : Ukuran patch yang akan digunakan di lapisan patch embedding.

norm_elementwise_affine (`bool`, defaultnya `False`) : Apakah akan menggunakan afinitas elemen per elemen di lapisan normalisasi.

norm_eps (`float`, defaultnya `1e-6`) : Nilai epsilon untuk lapisan normalisasi.

qk_norm (`str`, *opsional*, defaultnya `None`) : Normalisasi yang digunakan untuk query dan key.

Model Transformer 3D yang diperkenalkan dalam keluarga model [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)
```

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

**Parameter:**

hidden_states (`torch.Tensor` dengan bentuk `(batch_size, in_channels, num_frames, height, width)`) : `hidden_states` masukan.

encoder_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_len, embed_dims)`) : Embedding kondisional (embedding yang dihitung dari kondisi input seperti prompt) yang akan digunakan.

timestep (`torch.LongTensor`) : Digunakan untuk menunjukkan langkah denoising.

guidance (`torch.Tensor`, *opsional*) : Embedding skala panduan.

encoder_attention_mask (`torch.Tensor`, *opsional*) : Mask cross-attention yang diterapkan pada `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *opsional*) : Mask self-attention yang diterapkan pada `hidden_states`.

attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

controlnet_block_samples (`tuple` dari `torch.Tensor`, *opsional*) : Daftar tensor yang, jika ditentukan, akan ditambahkan ke residual blok transformer.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~models.transformer_2d.Transformer2DModelOutput` alih-alih tuple biasa.

**Mengembalikan:**

Jika `return_dict` bernilai True, sebuah `~models.transformer_2d.Transformer2DModelOutput` akan dikembalikan, selain itu sebuah `tuple` di mana elemen pertama adalah tensor sampel.

Metode forward dari [SanaVideoTransformer3DModel](/docs/diffusers/v0.43.0/id/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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_outputs.py#L21)

**Parameter:**

sample (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)` atau `(batch size, num_vector_embeds - 1, num_latent_pixels)` jika [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel) bersifat diskrit) : Output hidden states yang dikondisikan pada input `encoder_hidden_states`. Jika diskrit, mengembalikan distribusi probabilitas untuk piksel laten yang tidak berisik.

Output dari [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel).