# HunyuanDiT2DModel

Un modèle Diffusion Transformer pour des données 2D issu de [Hunyuan-DiT](https://github.com/Tencent/HunyuanDiT).

## HunyuanDiT2DModel[[diffusers.HunyuanDiT2DModel]]

#### diffusers.HunyuanDiT2DModel[[diffusers.HunyuanDiT2DModel]]

```python
diffusers.HunyuanDiT2DModel(num_attention_heads: int = 16, attention_head_dim: int = 88, in_channels: int | None = None, patch_size: int | None = None, activation_fn: str = 'gelu-approximate', sample_size = 32, hidden_size = 1152, num_layers: int = 28, mlp_ratio: float = 4.0, learn_sigma: bool = True, cross_attention_dim: int = 1024, norm_type: str = 'layer_norm', cross_attention_dim_t5: int = 2048, pooled_projection_dim: int = 1024, text_len: int = 77, text_len_t5: int = 256, use_style_cond_and_image_meta_size: bool = True)
```

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

**Paramètres :**

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

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

in_channels (`int`, *facultatif*) : Le nombre de canaux dans l'entrée et la sortie (à spécifier si l'entrée est **continue**).

patch_size (`int`, *facultatif*) : La taille du patch à utiliser pour l'entrée.

activation_fn (`str`, *facultatif*, par défaut `"geglu"`) : Fonction d'activation à utiliser dans le réseau de neurones à propagation avant.

sample_size (`int`, *facultatif*) : 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.

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

cross_attention_dim (`int`, *facultatif*) : Le nombre de dimensions dans l'embedding de texte de la clip.

hidden_size (`int`, *facultatif*) : La taille de la couche cachée dans les couches d'incorporation de conditionnement.

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

mlp_ratio (`float`, *facultatif*, valeur par défaut 4.0) : Le ratio de la taille de la couche cachée par rapport à la taille de l'entrée.

learn_sigma (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut prédire la variance.

cross_attention_dim_t5 (`int`, *facultatif*) : Le nombre de dimensions dans l'embedding de texte t5.

pooled_projection_dim (`int`, *facultatif*) : La taille de la projection agrégée.

text_len (`int`, *facultatif*) : La longueur de l'embedding de texte de la séquence.

text_len_t5 (`int`, *facultatif*) : La longueur de l'embedding de texte T5.

use_style_cond_and_image_meta_size (`bool`,  *facultatif*) : Indique s'il faut utiliser la condition de style et la taille métadonnée de l'image. True pour la version <=1.1, False pour la version >= 1.2

HunYuanDiT : modèle de diffusion avec un backbone Transformer.

Hériter de ModelMixin et ConfigMixin pour être compatible avec le sampler StableDiffusionPipeline de diffusers.

#### enable_forward_chunking[[diffusers.HunyuanDiT2DModel.enable_forward_chunking]]

```python
enable_forward_chunking(chunk_size: int | None = None, dim: int = 0)
```

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

**Paramètres :**

chunk_size (`int`, *facultatif*) : La taille des blocs des couches feed-forward. Si non spécifiée, la couche feed-forward est exécutée individuellement sur chaque tenseur de dim=`dim`.

dim (`int`, *facultatif*, par défaut `0`) : La dimension sur laquelle le calcul feed-forward doit être découpé. Choisissez entre dim=0 (batch) ou dim=1 (longueur de séquence).

Définit le processeur d'attention à utiliser [feed forward chunking](https://huggingface.co/blog/reformer#2-chunked-feed-forward-layers).

#### forward[[diffusers.HunyuanDiT2DModel.forward]]

```python
forward(hidden_states, timestep, encoder_hidden_states = None, text_embedding_mask = None, encoder_hidden_states_t5 = None, text_embedding_mask_t5 = None, image_meta_size = None, style = None, image_rotary_emb = None, controlnet_block_samples = None, return_dict = True)
```

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

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch size, dim, height, width)`) : Le tenseur d'entrée.

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

encoder_hidden_states ( `torch.Tensor` de forme `(batch size, sequence len, embed dims)`, *facultatif*) : Incrustations conditionnelles pour la couche d'attention croisée. Il s'agit de la sortie de `BertModel`.

text_embedding_mask : torch.Tensor Un masque d'attention de forme `(batch, key_tokens)` est appliqué à `encoder_hidden_states`. Il s'agit de la sortie de `BertModel`.

encoder_hidden_states_t5 ( `torch.Tensor` de forme `(batch size, sequence len, embed dims)`, *facultatif*) : Incrustations conditionnelles pour la couche d'attention croisée. Il s'agit de la sortie du T5 Text Encoder.

text_embedding_mask_t5 : torch.Tensor Un masque d'attention de forme `(batch, key_tokens)` est appliqué à `encoder_hidden_states`. Il s'agit de la sortie du T5 Text Encoder.

image_meta_size (torch.Tensor) : embedding conditionnel indiquant les tailles d'image

style : torch.Tensor: Embedding conditionnel indiquant le style

image_rotary_emb (`torch.Tensor`) : Les embeddings rotationnels d'image à appliquer aux tenseurs de requête et de clé lors du calcul de l'attention.

controlnet_block_samples (`list` 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 Indique s'il faut retourner un dictionnaire.

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

#### fuse_qkv_projections[[diffusers.HunyuanDiT2DModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

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

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.

#### set_default_attn_processor[[diffusers.HunyuanDiT2DModel.set_default_attn_processor]]

```python
set_default_attn_processor()
```

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

Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut.

#### unfuse_qkv_projections[[diffusers.HunyuanDiT2DModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

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

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

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