# SanaVideoTransformer3DModel

Un modelo Diffusion Transformer para datos 3D (vídeo) de [SANA-Video: Efficient Video Generation with Block Linear Diffusion Transformer](https://huggingface.co/papers/2509.24695) de NVIDIA y 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.

El resumen del artículo es:

*Presentamos SANA-Video, un modelo de difusión pequeño que puede generar videos de forma eficiente hasta una resolución de 720x1280 y una duración de un minuto. SANA-Video sintetiza videos de alta resolución, alta calidad y larga duración con una fuerte alineación texto-video a una velocidad notablemente rápida, y es desplegable en una GPU RTX 5090. Dos diseños centrales garantizan nuestra generación de video eficiente, efectiva y de larga duración: (1) Linear DiT: aprovechamos la atención lineal como operación central, que es más eficiente que la atención estándar dado el gran número de tokens procesados en la generación de video. (2) KV cache de memoria constante para Block Linear Attention: diseñamos un enfoque autoregresivo por bloques para la generación de video de larga duración empleando un estado de memoria constante, derivado de las propiedades acumulativas de la atención lineal. Este KV cache proporciona al Linear DiT un contexto global a un costo de memoria fijo, eliminando la necesidad de un KV cache tradicional y permitiendo una generación de video de un minuto de duración de forma eficiente. Además, exploramos filtros de datos efectivos y estrategias de entrenamiento del modelo, reduciendo el costo de entrenamiento a 12 días en 64 GPUs H100, lo que representa solo el 1% del costo de MovieGen. Dado su bajo costo, SANA-Video logra un rendimiento competitivo en comparación con los modelos de difusión pequeños modernos de última generación (p. ej., Wan 2.1-1.3B y SkyReel-V2-1.3B) mientras es 16 veces más rápido en latencia medida. Además, SANA-Video puede desplegarse en GPUs RTX 5090 con precisión NVFP4, acelerando la velocidad de inferencia para generar un video de 5 segundos en 720p de 71s a 29s (aceleración de 2.4x). En resumen, SANA-Video permite la generación de video de alta calidad y bajo costo.*

El modelo se puede cargar con el siguiente fragmento 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)
```

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

**Parámetros:**

in_channels (`int`, por defecto `16`) : El número de canales en la entrada.

out_channels (`int`, *opcional*, valor predeterminado `16`) : El número de canales en la salida.

num_attention_heads (`int`, por defecto `20`) : El número de cabezas a utilizar para la atención multi-cabeza.

attention_head_dim (`int`, por defecto `112`) : El número de canales en cada cabeza.

num_layers (`int`, por defecto `20`) : El número de bloques de Transformer a utilizar.

num_cross_attention_heads (`int`, *opcional*, valor predeterminado `20`) : El número de cabezas a utilizar para la atención cruzada.

cross_attention_head_dim (`int`, *opcional*, valor predeterminado `112`) : El número de canales en cada cabeza para la atención cruzada.

cross_attention_dim (`int`, *opcional*, valor predeterminado `2240`) : El número de canales en la salida de la atención cruzada.

caption_channels (`int`, por defecto `2304`) : El número de canales en las incrustaciones de la descripción.

mlp_ratio (`float`, por defecto `2.5`) : La ratio de expansión a utilizar en la capa GLUMBConv.

dropout (`float`, por defecto `0.0`) : La probabilidad de dropout.

attention_bias (`bool`, por defecto `False`) : Si se debe usar sesgo en la capa de atención.

sample_size (`int`, por defecto `32`) : El tamaño base del latente de entrada.

patch_size (`int`, por defecto `1`) : El tamaño de los parches a utilizar en la capa de incrustación de parches.

norm_elementwise_affine (`bool`, por defecto `False`) : Si se debe usar afinidad por elemento en la capa de normalización.

norm_eps (`float`, por defecto `1e-6`) : El valor de epsilon para la capa de normalización.

qk_norm (`str`, *opcional*, valor predeterminado `None`) : La normalización a utilizar para la consulta y la clave.

Un modelo Transformer 3D introducido en la familia 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)
```

[Fuente](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 condicionales (embeddings calculados a partir de las condiciones de entrada, como los prompts) a utilizar.

timestep (`torch.LongTensor`) : Se utiliza para indicar el paso de desruido.

guidance (`torch.Tensor`, *opcional*) : Incrustación de escala de guía.

encoder_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención cruzada aplicada a `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *opcional*) : Máscara de autoatención aplicada a `hidden_states`.

attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [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*) : Una lista de tensores que, si se especifica, se añaden a los residuales de los bloques de transformador.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~models.transformer_2d.Transformer2DModelOutput` en lugar de una tupla simple.

**Devuelve:**

Si `return_dict` es True, se devuelve un `~models.transformer_2d.Transformer2DModelOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es el tensor de la muestra.

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

[Fuente](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)` o `(batch size, num_vector_embeds - 1, num_latent_pixels)` si [Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/transformer2d#diffusers.Transformer2DModel) es discreto): las salidas de estados ocultos condicionadas a la entrada `encoder_hidden_states`. Si es discreto, devuelve distribuciones de probabilidad para los píxeles latentes sin ruido.

La salida de [Transformer2DModel](/docs/diffusers/v0.43.0/es/api/models/transformer2d#diffusers.Transformer2DModel).