# SanaVideoTransformer3DModel

Um modelo Diffusion Transformer para dados 3D (vídeo) de [SANA-Video: Efficient Video Generation with Block Linear Diffusion Transformer](https://huggingface.co/papers/2509.24695) da NVIDIA e MIT HAN Lab, por 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.

O resumo do artigo é:

*Apresentamos o SANA-Video, um pequeno modelo de difusão capaz de gerar vídeos de forma eficiente, com resolução de até 720x1280 e duração de até um minuto. O SANA-Video sintetiza vídeos de alta resolução, alta qualidade e longa duração, com forte alinhamento entre texto e vídeo, a uma velocidade notavelmente rápida, podendo ser implantado em GPUs RTX 5090. Dois designs centrais garantem a geração de vídeos eficiente, eficaz e longa: (1) Linear DiT: utilizamos a atenção linear como operação central, que é mais eficiente que a atenção convencional, dado o grande número de tokens processados na geração de vídeos. (2) Cache KV de memória constante para Block Linear Attention: projetamos uma abordagem autoregressiva por blocos para a geração de vídeos longos, empregando um estado de memória constante, derivado das propriedades cumulativas da atenção linear. Esse cache KV fornece ao Linear DiT contexto global a um custo de memória fixo, eliminando a necessidade de um cache KV tradicional e permitindo a geração eficiente de vídeos de longa duração. Além disso, exploramos filtros de dados eficazes e estratégias de treinamento do modelo, reduzindo o custo de treinamento para 12 dias em 64 GPUs H100, o que representa apenas 1% do custo do MovieGen. Dado seu baixo custo, o SANA-Video alcança desempenho competitivo em comparação com modelos de difusão pequenos e modernos do estado da arte (por exemplo, Wan 2.1-1.3B e SkyReel-V2-1.3B), sendo 16x mais rápido em latência medida. Além disso, o SANA-Video pode ser implantado em GPUs RTX 5090 com precisão NVFP4, acelerando a velocidade de inferência para a geração de um vídeo 720p de 5 segundos de 71s para 29s (aceleração de 2.4x). Em resumo, o SANA-Video permite a geração de vídeos de alta qualidade a baixo custo.*

O modelo pode ser carregado com o seguinte trecho de código.

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

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

**Parâmetros:**

in_channels (`int`, padrão `16`) : O número de canais na entrada.

out_channels (`int`, *opcional*, padrão `16`) : O número de canais na saída.

num_attention_heads (`int`, padrão `20`) : O número de cabeças a serem usadas para a atenção multi-cabeça.

attention_head_dim (`int`, padrão `112`) : O número de canais em cada head.

num_layers (`int`, padrão `20`) : O número de blocos de Transformer a serem usados.

num_cross_attention_heads (`int`, *opcional*, padrão `20`) : O número de cabeças a serem usadas para a atenção cruzada.

cross_attention_head_dim (`int`, *opcional*, padrão `112`) : O número de canais em cada cabeça para a atenção cruzada.

cross_attention_dim (`int`, *opcional*, padrão `2240`) : O número de canais na saída da cross-attention.

caption_channels (`int`, padrão `2304`) : O número de canais nos embeddings da legenda.

mlp_ratio (`float`, padrão `2.5`) : A razão de expansão a ser usada na camada GLUMBConv.

dropout (`float`, padrão `0.0`) : A probabilidade de dropout.

attention_bias (`bool`, padrão `False`) : Se deve usar viés na camada de atenção.

sample_size (`int`, padrão `32`) : O tamanho base do latente de entrada.

patch_size (`int`, padrão `1`) : O tamanho dos patches a serem usados na camada de incorporação de patches.

norm_elementwise_affine (`bool`, padrão `False`) : Se deve usar afinidade element-wise na camada de normalização.

norm_eps (`float`, padrão `1e-6`) : O valor de epsilon para a camada de normalização.

qk_norm (`str`, *opcional*, padrão `None`) : A normalização a ser usada para a consulta e a chave.

Um modelo Transformer 3D introduzido na família de modelos [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)
```

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

**Parâmetros:**

hidden_states (`torch.Tensor` de forma `(batch_size, in_channels, num_frames, height, width)`) : `hidden_states` de entrada.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, sequence_len, embed_dims)`) : Embeddings condicionais (embeddings calculados a partir das condições de entrada, como prompts) a serem usados.

timestep (`torch.LongTensor`) : Usado para indicar o passo de desruidamento.

guidance (`torch.Tensor`, *opcional*) : Embedding de escala de orientação.

encoder_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atenção cruzada aplicada a `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *opcional*) : Máscara de autoatenção aplicada a `hidden_states`.

attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

controlnet_block_samples (`tuple` de `torch.Tensor`, *opcional*) : Uma lista de tensores que, se especificada, é adicionada aos resíduos dos blocos de transformer.

return_dict (`bool`, *opcional*, padrão `True`) : Indica se deve retornar um `~models.transformer_2d.Transformer2DModelOutput` em vez de uma tupla simples.

**Retorna:**

Se `return_dict` for True, um `~models.transformer_2d.Transformer2DModelOutput` é retornado; caso contrário, uma `tuple` onde o primeiro elemento é o tensor da amostra.

O método forward do [SanaVideoTransformer3DModel](/docs/diffusers/v0.43.0/pt/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)
```

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

**Parâmetros:**

sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` ou `(batch size, num_vector_embeds - 1, num_latent_pixels)` se [Transformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/transformer2d#diffusers.Transformer2DModel) for discreto) : A saída dos estados ocultos condicionada à entrada `encoder_hidden_states`. Se discreto, retorna distribuições de probabilidade para os pixels latentes sem ruído.

A saída de [Transformer2DModel](/docs/diffusers/v0.43.0/pt/api/models/transformer2d#diffusers.Transformer2DModel).