# SanaTransformer2DModel

Un modelo Diffusion Transformer para datos 2D de [SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers](https://huggingface.co/papers/2410.10629) fue introducido por NVIDIA y MIT HAN Lab, por Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han.

El resumen del artículo es:

*Presentamos Sana, un marco de texto a imagen que puede generar imágenes de forma eficiente hasta una resolución de 4096×4096. Sana puede sintetizar imágenes de alta resolución y alta calidad con una fuerte alineación texto-imagen a una velocidad notablemente rápida, y es desplegable en la GPU de un portátil. Los diseños principales incluyen: (1) Autoencoder de compresión profunda: a diferencia de los AE tradicionales, que comprimen las imágenes solo 8×, entrenamos un AE que puede comprimir las imágenes 32×, reduciendo efectivamente el número de tokens latentes. (2) DiT lineal: reemplazamos toda la atención vanilla en DiT con atención lineal, que es más eficiente en altas resoluciones sin sacrificar la calidad. (3) Codificador de texto solo decodificador: reemplazamos T5 con un pequeño LLM moderno solo decodificador como codificador de texto y diseñamos instrucciones humanas complejas con aprendizaje in-context para mejorar la alineación imagen-texto. (4) Entrenamiento y muestreo eficientes: proponemos Flow-DPM-Solver para reducir los pasos de muestreo, con etiquetado y selección de descripciones eficientes para acelerar la convergencia. Como resultado, Sana-0.6B es muy competitivo con el modelo de difusión gigante moderno (p. ej. Flux-12B), siendo 20 veces más pequeño y más de 100 veces más rápido en el rendimiento medido. Además, Sana-0.6B puede desplegarse en una GPU de portátil de 16GB, tardando menos de 1 segundo en generar una imagen de resolución 1024×1024. Sana permite la creación de contenido a bajo costo. El código y el modelo se publicarán.*

El modelo se puede cargar con el siguiente fragmento de código.

```python
from diffusers import SanaTransformer2DModel

transformer = SanaTransformer2DModel.from_pretrained("Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers", subfolder="transformer", dtype=torch.bfloat16)
```

## SanaTransformer2DModel[[diffusers.SanaTransformer2DModel]]

#### diffusers.SanaTransformer2DModel[[diffusers.SanaTransformer2DModel]]

```python
diffusers.SanaTransformer2DModel(in_channels: int = 32, out_channels: int | None = 32, num_attention_heads: int = 70, attention_head_dim: int = 32, 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 = 32, patch_size: int = 1, 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 = None, timestep_scale: float = 1.0)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/sana_transformer.py#L294)

**Parámetros:**

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

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

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

attention_head_dim (`int`, por defecto `32`) : 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.

timestep_scale (`float`, por defecto `1.0`) : La escala a utilizar para los pasos de tiempo.

Un modelo Transformer 2D introducido en la familia de modelos [Sana](https://huggingface.co/papers/2410.10629).

#### forward[[diffusers.SanaTransformer2DModel.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/main/src/diffusers/models/transformers/sana_transformer.py#L419)

**Parámetros:**

hidden_states (`torch.Tensor` de forma `(batch_size, in_channels, 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 [SanaTransformer2DModel](/docs/diffusers/main/es/api/models/sana_transformer2d#diffusers.SanaTransformer2DModel).

## 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/main/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/main/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/main/es/api/models/transformer2d#diffusers.Transformer2DModel).