# MiniMaxH3ImageTransformer2DModel

Un modèle Diffusion Transformer pour la génération et l'édition d'images, introduit dans [MiniMax-H3-Image](https://huggingface.co/MiniMaxAI/MiniMax-H3-Image) par MiniMax.

Il s’agit du [MiniMaxH3Transformer3DModel](/docs/diffusers/main/fr/api/models/minimax_h3_transformer3d#diffusers.MiniMaxH3Transformer3DModel) sans son flux audio : une seule pile de blocs traite **une séquence 1-D compacte** qui contient le conditionnement texte, les lignes des images de référence et les lignes de l’image générée. La construction de la disposition compacte est à la charge de l’appelant, c’est pourquoi la signature de la méthode forward reçoit la disposition séparément des latents : la grille de positions `(t, h, w)`, les étiquettes de modalité par ligne, les indices de timestep par ligne et les deux tenseurs d’index qui adressent les lignes d’image et de texte. [MiniMaxH3ImageBlocks](/docs/diffusers/main/fr/api/pipelines/minimax_h3_image#diffusers.MiniMaxH3ImageBlocks) construit l’ensemble.

Le point de contrôle est distillé en six étapes d'échantillonnage via la distillation par décodage parallèle (PDD), qui conserve une tête de sortie par étape. `forward` prend donc `pdd_step_index`, l'étape en cours d'exécution, et projette avec la tête de cette étape.

```python
import torch
from diffusers import MiniMaxH3ImageTransformer2DModel

transformer = MiniMaxH3ImageTransformer2DModel.from_pretrained(
    "MiniMaxAI/MiniMax-H3-Image", subfolder="transformer_diffusers", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"
```

Le point de contrôle est en précision mixte : la projection des patches d’entrée, le MLP de pas de temps et les têtes de sortie sont en float32, tandis que la pile de blocs est en bfloat16. `from_pretrained` conserve cette organisation grâce à `_keep_in_fp32_modules` ; passez donc `dtype=torch.bfloat16` et laissez-le placer les modules en float32, plutôt que de convertir le modèle avec `.to(torch.bfloat16)` par la suite.

## MiniMaxH3ImageTransformer2DModel[[diffusers.MiniMaxH3ImageTransformer2DModel]]

#### diffusers.MiniMaxH3ImageTransformer2DModel[[diffusers.MiniMaxH3ImageTransformer2DModel]]

```python
diffusers.MiniMaxH3ImageTransformer2DModel(num_attention_heads: int = 56, attention_head_dim: int = 128, hidden_size: int = 5376, num_layers: int = 50, num_refiner_layers: int = 2, ffn_dim: int = 14336, in_channels: int = 24, patch_size: tuple[int, int, int] = (1, 2, 2), text_dim: int = 5120, freq_dim: int = 256, time_embed_hidden_dim: int = 5376, time_embed_dim: int = 2688, rope_freq_dim: int = 16, rope_theta: float = 10000.0, norm_eps: float = 1e-05, qk_norm_eps: float = 1e-05, final_norm_eps: float = 1e-05, num_pdd_heads: int = 6)
```

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

**Paramètres :**

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

attention_head_dim (`int`, par défaut `128`) : Le nombre de canaux dans chaque tête d'attention. Notez que `num_attention_heads * attention_head_dim` est *supérieur* à `hidden_size`.

hidden_size (`int`, par défaut `5376`) : Le nombre de canaux de la séquence compactée (le flux résiduel).

num_layers (`int`, par défaut `50`) : Le nombre de blocs transformer.

num_refiner_layers (`int`, par défaut `2`) : Le nombre de blocs de raffinement de jetons appliqués au flux de texte projeté.

ffn_dim (`int`, par défaut `14336`) : La dimension interne des couches feed-forward SwiGLU.

in_channels (`int`, par défaut `24`) : Le nombre de canaux des latents de l'image.

patch_size (`tuple[int, int, int]`, par défaut `(1, 2, 2)`) : le patch `(t, h, w)` utilisé pour empaqueter les latents en lignes.

text_dim (`int`, par défaut `5120`) : Le nombre de canaux de la condition de texte produite par l'encodeur de texte.

freq_dim (`int`, par défaut `256`) : La dimension de l'encodage sinusoïdal des pas de temps. Les pas de temps sont consommés non mis à l'échelle dans `[0, 1]`.

time_embed_hidden_dim (`int`, par défaut `5376`) : La dimension interne du MLP de pas de temps.

time_embed_dim (`int`, par défaut `2688`) : La dimension de sortie du MLP de pas de temps, c'est-à-dire l'entrée de chaque projection AdaLN.

rope_freq_dim (`int`, par défaut `16`) : Le nombre de fréquences rotatives par axe. Les axes `(t, h, w)` partagent un tampon `inv_freq` de cette longueur et `2 * 3 * rope_freq_dim` des canaux `attention_head_dim` sont rotés.

rope_theta (`float`, par défaut `10000.0`) : La base du calendrier de fréquences rotatives à partir duquel le tampon `rope.inv_freq` est calculé.

norm_eps (`float`, par défaut `1e-5`) : Epsilon des normalisations pré-attention et pré-feed-forward.

qk_norm_eps (`float`, par défaut `1e-5`) : Epsilon des normes de requête/clé par tête.

final_norm_eps (`float`, par défaut `1e-5`) : Epsilon de la norme de sortie du raffineur de jetons et de `norm_out`.

num_pdd_heads (`int`, par défaut `6`) : Le nombre d'étapes d'échantillonnage auxquelles le point de contrôle a été distillé, chacune ayant sa propre tête de sortie.

Un modèle Transformer pour la génération et l'édition d'images, introduit dans MiniMax-H3-Image.

Il s’agit du transformeur MiniMax-H3 sans son flux audio : une seule pile de blocs traite **une séquence 1-D compacte** qui contient la condition texte, les lignes des images de référence et les lignes de l’image générée. L’attention est une auto-attention complète sur cette séquence ; il n’y a pas d’attention croisée. Le point de contrôle est distillé vers un nombre fixe d’étapes d’échantillonnage avec la Parallel Decoding Distillation (PDD), qui conserve une tête de sortie par étape, de sorte que `forward` reçoit l’indice de l’étape en cours d’exécution.

L'appelant est responsable de la construction de la mise en page compacte : patchification des latents, ordonnancement des lignes et production de la grille de positions `(t, h, w)`, des étiquettes de modalité par ligne et des indices de pas de temps par ligne. La séquence ne contient aucun bourrage, de sorte que l'attention s'exécute sans masque sur un seul document et que tous les backends d'attention restent disponibles.

L'axe de lot est un axe de pure réplication : les arguments structurels (`timestep`, `timestep_indices`, `token_tags`, `position_ids` et les deux tenseurs d'indices) décrivent une mise en page compacte unique partagée par tous les éléments du lot.

#### forward[[diffusers.MiniMaxH3ImageTransformer2DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor, timestep: Tensor, timestep_indices: Tensor, token_tags: Tensor, position_ids: Tensor, image_indices: Tensor, text_indices: Tensor, pdd_step_index: int, return_dict: bool = True)
```

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

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, num_image_tokens, in_channels * prod(patch_size))`) : Lignes latentes patchifiées — les lignes des images de référence et les lignes de l'image générée — ordonnées comme elles apparaissent dans la séquence compactée, c'est-à-dire correspondant à `image_indices`.

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, num_text_tokens, text_dim)`) : Conditionnement par le texte, ordonné pour correspondre à `text_indices`.

timestep (`torch.Tensor` de forme `(num_timesteps,)`) : Les valeurs de pas de temps *distinctes* présentes dans la séquence compacte, dans `[0, 1]` et non échelonnées. Un seul passage avant sert des lignes à différents niveaux de bruit (lignes générées, lignes de référence).

timestep_indices (`torch.Tensor` de forme `(seq_len,)`) : Pour chaque ligne de la séquence compactée, l'index de son pas de temps dans `timestep`.

token_tags (`torch.Tensor` de forme `(seq_len,)`) : Pour chaque ligne de la séquence compactée, sa modalité : `0` image, `1` texte.

position_ids (`torch.Tensor` de forme `(seq_len, 3)`) : Les coordonnées rotatives `(t, h, w)` de chaque ligne de la séquence compactée.

image_indices (`torch.Tensor` de forme `(num_image_tokens,)`) : Positions des lignes d'image dans la séquence compactée.

text_indices (`torch.Tensor` de forme `(num_text_tokens,)`) : Positions des lignes de texte dans la séquence compactée.

pdd_step_index (`int`) : L'étape d'échantillonnage, qui sélectionne la tête de sortie.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un [Transformer2DModelOutput](/docs/diffusers/main/fr/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) plutôt qu'un simple tuple.

**Retourne :** [Transformer2DModelOutput](/docs/diffusers/main/fr/api/models/cogview3plus_transformer2d#diffusers.models.modeling_outputs.Transformer2DModelOutput) ou `tuple`

La vitesse de chaque ligne d'image, de forme `(batch_size, num_image_tokens, in_channels * prod(patch_size))`, dans l'ordre des lignes de `image_indices`.