# SanaVideoTransformer3DModel

Một mô hình Diffusion Transformer cho dữ liệu 3D (video) từ [SANA-Video: Efficient Video Generation with Block Linear Diffusion Transformer](https://huggingface.co/papers/2509.24695) của NVIDIA và MIT HAN Lab, bởi 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.

Tóm tắt từ bài báo là:

*Chúng tôi giới thiệu SANA-Video, một mô hình khuếch tán nhỏ có khả năng tạo video hiệu quả với độ phân giải lên đến 720x1280 và thời lượng dài tới vài phút. SANA-Video tổng hợp các video độ phân giải cao, chất lượng cao và dài với sự tương thích mạnh mẽ giữa văn bản và video ở tốc độ nhanh đáng kể, có thể triển khai trên GPU RTX 5090. Hai thiết kế cốt lõi đảm bảo việc tạo video hiệu quả, hiệu suất cao và dài của chúng tôi: (1) Linear DiT: Chúng tôi tận dụng chú ý tuyến tính (linear attention) làm thao tác cốt lõi, hiệu quả hơn so với chú ý thông thường (vanilla attention) khi xử lý số lượng token lớn trong tạo video. (2) Bộ nhớ đệm KV có bộ nhớ không đổi cho Block Linear Attention: chúng tôi thiết kế phương pháp tự hồi quy theo khối (block-wise autoregressive) cho việc tạo video dài bằng cách sử dụng trạng thái bộ nhớ không đổi, được suy ra từ các tính chất tích lũy của chú ý tuyến tính. Bộ nhớ đệm KV này cung cấp ngữ cảnh toàn cục cho Linear DiT với chi phí bộ nhớ cố định, loại bỏ nhu cầu về bộ nhớ đệm KV truyền thống và cho phép tạo video dài vài phút một cách hiệu quả. Ngoài ra, chúng tôi khám phá các bộ lọc dữ liệu và chiến lược huấn luyện mô hình hiệu quả, thu hẹp chi phí huấn luyện xuống còn 12 ngày trên 64 GPU H100, chỉ bằng 1% chi phí của MovieGen. Với chi phí thấp, SANA-Video đạt hiệu suất cạnh tranh so với các mô hình khuếch tán nhỏ tiên tiến hiện đại (ví dụ: Wan 2.1-1.3B và SkyReel-V2-1.3B) trong khi nhanh hơn 16 lần về độ trễ đo được. Hơn nữa, SANA-Video có thể được triển khai trên GPU RTX 5090 với độ chính xác NVFP4, tăng tốc độ suy luận khi tạo video 720p dài 5 giây từ 71 giây xuống 29 giây (tăng tốc 2,4 lần). Tóm lại, SANA-Video cho phép tạo video chất lượng cao với chi phí thấp.*

Mô hình có thể được tải bằng đoạn mã sau.

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

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

**Tham số:**

in_channels (`int`, mặc định là `16`) : Số lượng kênh trong đầu vào.

out_channels (`int`, *tuỳ chọn*, mặc định là `16`) : Số lượng kênh trong đầu ra.

num_attention_heads (`int`, mặc định là `20`) : Số lượng đầu (heads) được sử dụng cho chú ý đa đầu (multi-head attention).

attention_head_dim (`int`, mặc định là `112`) : Số lượng kênh trong mỗi head.

num_layers (`int`, mặc định là `20`) : Số lượng lớp khối Transformer cần sử dụng.

num_cross_attention_heads (`int`, *tuỳ chọn*, mặc định là `20`) : Số lượng đầu (heads) được sử dụng cho cross-attention.

cross_attention_head_dim (`int`, *tuỳ chọn*, mặc định là `112`) : Số lượng kênh trong mỗi đầu cho cross-attention.

cross_attention_dim (`int`, *tùy chọn*, mặc định là `2240`) : Số lượng kênh trong đầu ra của cross-attention.

caption_channels (`int`, mặc định là `2304`) : Số lượng kênh trong các embedding mô tả.

mlp_ratio (`float`, mặc định là `2.5`) : Tỷ lệ mở rộng được sử dụng trong lớp GLUMBConv.

dropout (`float`, mặc định là `0.0`) : Xác suất dropout.

attention_bias (`bool`, mặc định là `False`) : Có sử dụng bias trong lớp attention hay không.

sample_size (`int`, mặc định là `32`) : Kích thước cơ bản của latent đầu vào.

patch_size (`int`, mặc định là `1`) : Kích thước của các patch được sử dụng trong lớp nhúng patch.

norm_elementwise_affine (`bool`, mặc định là `False`) : Có sử dụng độ tương thích từng phần tử trong lớp chuẩn hóa hay không.

norm_eps (`float`, mặc định là `1e-6`) : Giá trị epsilon cho lớp chuẩn hóa.

qk_norm (`str`, *tùy chọn*, mặc định là `None`) : Phương pháp chuẩn hóa cần sử dụng cho query và key.

Mô hình Transformer 3D được giới thiệu trong dòng mô hình [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)
```

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

**Tham số:**

hidden_states (`torch.Tensor` có hình dạng `(batch_size, in_channels, num_frames, height, width)`) : `hidden_states` đầu vào.

encoder_hidden_states (`torch.Tensor` có shape `(batch_size, sequence_len, embed_dims)`) : Các embeddings điều kiện (embeddings được tính từ các điều kiện đầu vào như prompts) cần sử dụng.

timestep (`torch.LongTensor`) : Dùng để chỉ bước khử nhiễu.

guidance (`torch.Tensor`, *tùy chọn*) : Nhúng thang độ dẫn hướng.

encoder_attention_mask (`torch.Tensor`, *tùy chọn*) : Mặt nạ chú ý chéo (cross-attention mask) được áp dụng cho `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *tùy chọn*) : Mặt nạ tự chú ý (self-attention mask) được áp dụng cho `hidden_states`.

attention_kwargs (`dict`, *tùy chọn*) : Một từ điển kwargs mà nếu được chỉ định sẽ được truyền đến `AttentionProcessor` như đã định nghĩa dưới `self.processor` trong [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

controlnet_block_samples (`tuple` của `torch.Tensor`, *tùy chọn*) : Một danh sách các tensor mà nếu được chỉ định sẽ được cộng vào phần dư (residuals) của các khối transformer.

return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một `~models.transformer_2d.Transformer2DModelOutput` thay vì một tuple thông thường hay không.

**Trả về:**

Nếu `return_dict` là True, một `~models.transformer_2d.Transformer2DModelOutput` sẽ được trả về, ngược lại một `tuple` trong đó phần tử đầu tiên là tensor mẫu.

Phương thức forward của [SanaVideoTransformer3DModel](/docs/diffusers/v0.43.0/vi/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)
```

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

**Tham số:**

sample (`torch.Tensor` có shape `(batch_size, num_channels, height, width)` hoặc `(batch size, num_vector_embeds - 1, num_latent_pixels)` nếu [Transformer2DModel](/docs/diffusers/v0.43.0/vi/api/models/transformer2d#diffusers.Transformer2DModel) là discrete) : Đầu ra của hidden states được điều kiện bởi đầu vào `encoder_hidden_states`. Nếu là discrete, trả về các phân phối xác suất cho các latent pixels chưa bị nhiễu.

Đầu ra của [Transformer2DModel](/docs/diffusers/v0.43.0/vi/api/models/transformer2d#diffusers.Transformer2DModel).