# AuraFlowTransformer2DModel

Un modèle Transformer pour des données de type image issu de [AuraFlow](https://blog.fal.ai/auraflow/).

## AuraFlowTransformer2DModel[[diffusers.AuraFlowTransformer2DModel]]

#### diffusers.AuraFlowTransformer2DModel[[diffusers.AuraFlowTransformer2DModel]]

```python
diffusers.AuraFlowTransformer2DModel(sample_size: int = 64, patch_size: int = 2, in_channels: int = 4, num_mmdit_layers: int = 4, num_single_dit_layers: int = 32, attention_head_dim: int = 256, num_attention_heads: int = 12, joint_attention_dim: int = 2048, caption_projection_dim: int = 3072, out_channels: int = 4, pos_embed_max_size: int = 1024)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/auraflow_transformer_2d.py#L278)

**Paramètres :**

sample_size (`int`) : La largeur des images latentes. Cette valeur est fixe pendant l'entraînement, car elle est utilisée pour apprendre un nombre d'embeddings de position.

patch_size (`int`) : Taille des patches pour découper les données d'entrée en petits patches.

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

num_mmdit_layers (`int`, *facultatif*, valeur par défaut 4) : Le nombre de blocs Transformer MMDiT à utiliser.

num_single_dit_layers (`int`, *facultatif*, valeur par défaut 32) : Le nombre de blocs Transformer à utiliser. Ces blocs utilisent des représentations d'image et de texte concaténées.

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

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

joint_attention_dim (`int`, *facultatif*) : Le nombre de dimensions de `encoder_hidden_states` à utiliser.

caption_projection_dim (`int`) : Nombre de dimensions à utiliser lors de la projection des `encoder_hidden_states`.

out_channels (`int`, par défaut 4) : Nombre de canaux de sortie.

pos_embed_max_size (`int`, par défaut 1024) : Nombre maximal de positions à intégrer à partir des latents de l'image.

Un modèle Transformer 2D tel que présenté dans AuraFlow (https://blog.fal.ai/auraflow/).

#### forward[[diffusers.AuraFlowTransformer2DModel.forward]]

```python
forward(hidden_states: FloatTensor, encoder_hidden_states: FloatTensor = None, timestep: LongTensor = None, attention_kwargs: dict[str, typing.Any] | None = None, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/auraflow_transformer_2d.py#L400)

**Paramètres :**

hidden_states (`torch.FloatTensor` de forme `(batch size, channel, height, width)`) : `hidden_states` en entrée.

encoder_hidden_states (`torch.FloatTensor` 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.

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

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 [AuraFlowTransformer2DModel](/docs/diffusers/main/fr/api/models/aura_flow_transformer2d#diffusers.AuraFlowTransformer2DModel).

#### fuse_qkv_projections[[diffusers.AuraFlowTransformer2DModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/auraflow_transformer_2d.py#L369)

Active les projections QKV fusionnées. Pour les modules d'auto-attention, toutes les matrices de projection (c'est-à-dire requête, clé, valeur) sont fusionnées. Pour les modules d'attention croisée, les matrices de projection des clés et des valeurs sont fusionnées.

> [!WARNING] > Cette API est 🧪 expérimentale.

#### unfuse_qkv_projections[[diffusers.AuraFlowTransformer2DModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/auraflow_transformer_2d.py#L391)

Désactive la projection QKV fusionnée si elle est activée.

> [!WARNING] > Cette API est 🧪 expérimentale.