# SanaTransformer2DModel

Un modèle Diffusion Transformer pour des données 2D issu de [SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers](https://huggingface.co/papers/2410.10629) a été introduit par NVIDIA et le MIT HAN Lab, par Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han.

L'abstract de l'article est :

*Nous présentons Sana, un cadre de génération d'images à partir de texte capable de générer efficacement des images jusqu'à une résolution de 4096×4096. Sana peut synthétiser des images haute résolution et de haute qualité, avec un alignement texte-image solide, à une vitesse remarquablement rapide, et peut être déployé sur le GPU d'un ordinateur portable. Les conceptions principales incluent : (1) Auto-encodeur à compression profonde : contrairement aux AE traditionnels, qui ne compresse les images que 8×, nous avons entraîné un AE capable de compresser les images 32×, réduisant ainsi efficacement le nombre de jetons latents. (2) DiT linéaire : nous remplaçons toute l'attention vanilla dans DiT par une attention linéaire, plus efficace à haute résolution sans sacrifier la qualité. (3) Encodeur de texte uniquement décodeur : nous avons remplacé T5 par un petit LLM moderne uniquement décodeur en tant qu'encodeur de texte, et avons conçu des instructions humaines complexes avec l'apprentissage en contexte pour améliorer l'alignement texte-image. (4) Entraînement et échantillonnage efficaces : nous proposons Flow-DPM-Solver pour réduire le nombre d'étapes d'échantillonnage, avec un étiquetage et une sélection de légendes efficaces pour accélérer la convergence. En conséquence, Sana-0.6B est très compétitif par rapport aux modèles de diffusion géants modernes (par exemple Flux-12B), étant 20 fois plus petit et plus de 100 fois plus rapide en débit mesuré. De plus, Sana-0.6B peut être déployé sur un GPU d'ordinateur portable de 16 Go, prenant moins d'une seconde pour générer une image en résolution 1024×1024. Sana permet la création de contenu à faible coût. Le code et le modèle seront publiés.*

Le modèle peut être chargé à l'aide du fragment de code suivant.

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

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

**Paramètres :**

in_channels (`int`, par défaut `32`) : Le nombre de canaux dans l'entrée.

out_channels (`int`, *facultatif*, par défaut `32`) : Le nombre de canaux dans la sortie.

num_attention_heads (`int`, par défaut `70`) : Le nombre de têtes à utiliser pour l'attention multi-têtes.

attention_head_dim (`int`, par défaut `32`) : Le nombre de canaux dans chaque tête.

num_layers (`int`, par défaut `20`) : Le nombre de blocs Transformer à utiliser.

num_cross_attention_heads (`int`, *facultatif*, par défaut `20`) : Le nombre de têtes à utiliser pour l'attention croisée.

cross_attention_head_dim (`int`, *facultatif*, par défaut `112`) : Le nombre de canaux dans chaque tête pour l'attention croisée.

cross_attention_dim (`int`, *facultatif*, par défaut `2240`) : Le nombre de canaux dans la sortie de l'attention croisée.

caption_channels (`int`, par défaut `2304`) : Le nombre de canaux dans les embeddings de légende.

mlp_ratio (`float`, par défaut `2.5`) : Le ratio d'expansion à utiliser dans la couche GLUMBConv.

dropout (`float`, par défaut `0.0`) : La probabilité de dropout.

attention_bias (`bool`, par défaut `False`) : Indique s'il faut utiliser un biais dans la couche d'attention.

sample_size (`int`, par défaut `32`) : La taille de base du latent d'entrée.

patch_size (`int`, par défaut `1`) : La taille des patches à utiliser dans la couche d'encodage de patches.

norm_elementwise_affine (`bool`, par défaut `False`) : Indique s'il faut utiliser l'affinité élément par élément dans la couche de normalisation.

norm_eps (`float`, par défaut `1e-6`) : La valeur epsilon pour la couche de normalisation.

qk_norm (`str`, *facultatif*, par défaut `None`) : La normalisation à utiliser pour la requête et la clé.

timestep_scale (`float`, par défaut `1.0`) : L'échelle à utiliser pour les timesteps.

Un modèle Transformer 2D introduit dans la famille de modèles [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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/sana_transformer.py#L419)

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, in_channels, height, width)`) : `hidden_states` en entrée.

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, sequence_len, embed_dims)`) : Embeddings conditionnels (embeddings calculés à partir des conditions d'entrée telles que les prompts) à utiliser.

timestep (`torch.LongTensor`) : Utilisé pour indiquer l'étape de débruitage.

guidance (`torch.Tensor`, *facultatif*) : Embedding de l'échelle de guidage.

encoder_attention_mask (`torch.Tensor`, *facultatif*) : Masque d'attention croisée appliqué à `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *facultatif*) : Masque d'auto-attention appliqué à `hidden_states`.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

controlnet_block_samples (`tuple` de `torch.Tensor`, *facultatif*) : Une liste de tenseurs qui, si elle est spécifiée, est ajoutée aux résidus des blocs de transformeur.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~models.transformer_2d.Transformer2DModelOutput` plutôt qu'un simple tuple.

**Retourne :**

Si `return_dict` est True, un `~models.transformer_2d.Transformer2DModelOutput` est renvoyé, sinon un `tuple` dont le premier élément est le tenseur d'échantillon.

La méthode forward du [SanaTransformer2DModel](/docs/diffusers/v0.43.0/fr/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)
```

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

**Paramètres :**

sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)` ou `(batch size, num_vector_embeds - 1, num_latent_pixels)` si [Transformer2DModel](/docs/diffusers/v0.43.0/fr/api/models/transformer2d#diffusers.Transformer2DModel) est discret) : Les états cachés en sortie, conditionnés par l'entrée `encoder_hidden_states`. Si discret, renvoie les distributions de probabilité pour les pixels latents non bruités.

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