# QwenImageTransformer2DModel

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

```python
from diffusers import QwenImageTransformer2DModel

transformer = QwenImageTransformer2DModel.from_pretrained("Qwen/QwenImage-20B", subfolder="transformer", dtype=torch.bfloat16)
```

## QwenImageTransformer2DModel[[diffusers.QwenImageTransformer2DModel]]

#### diffusers.QwenImageTransformer2DModel[[diffusers.QwenImageTransformer2DModel]]

```python
diffusers.QwenImageTransformer2DModel(patch_size: int = 2, in_channels: int = 64, out_channels: int | None = 16, num_layers: int = 60, attention_head_dim: int = 128, num_attention_heads: int = 24, joint_attention_dim: int = 3584, guidance_embeds: bool = False, axes_dims_rope: tuple[int, int, int] = (16, 56, 56), zero_cond_t: bool = False, use_additional_t_cond: bool = False, use_layer3d_rope: bool = False)
```

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

**Paramètres :**

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

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

out_channels (`int`, *facultatif*, par défaut `None`) : Le nombre de canaux dans la sortie. S'il n'est pas spécifié, il est défini sur `in_channels` par défaut.

num_layers (`int`, par défaut `60`) : Le nombre de blocs DiT à double flux à utiliser.

attention_head_dim (`int`, par défaut `128`) : Le nombre de dimensions à utiliser pour chaque tête d'attention.

num_attention_heads (`int`, par défaut `24`) : Le nombre de têtes d'attention à utiliser.

joint_attention_dim (`int`, par défaut `3584`) : Le nombre de dimensions à utiliser pour l'attention conjointe (dimension d'incorporation/canal de `encoder_hidden_states`).

guidance_embeds (`bool`, par défaut `False`) : Indique s'il faut utiliser des embeddings de guidance pour la variante du modèle distillée par guidance.

axes_dims_rope (`tuple[int]`, par défaut `(16, 56, 56)`) : Les dimensions à utiliser pour les embeddings positionnels rotatifs.

Le modèle Transformer introduit dans Qwen.

#### forward[[diffusers.QwenImageTransformer2DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor = None, encoder_hidden_states_mask: Tensor = None, timestep: LongTensor = None, img_shapes: list[tuple[int, int, int]] | None = None, guidance: Tensor = None, attention_kwargs: dict[str, typing.Any] | None = None, controlnet_block_samples = None, additional_t_cond = None, return_dict: bool = True)
```

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

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, image_sequence_length, in_channels)`) : `hidden_states` d'entrée.

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

encoder_hidden_states_mask (`torch.Tensor` de forme `(batch_size, text_sequence_length)`, *facultatif*) : Masque pour les états cachés de l’encodeur. Il est attendu que les jetons valides aient la valeur 1.0 et les jetons de bourrage la valeur 0.0. Utilisé dans le processeur d’attention pour empêcher l’attention de porter sur les jetons de bourrage. Le masque peut avoir n’importe quel motif (pas seulement des jetons valides contigus suivis de bourrage) car il est appliqué élément par élément dans l’attention.

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

img_shapes (`list[tuple[int, int, int]]`, *facultatif*) : Formes des images pour le calcul de RoPE.

guidance (`torch.Tensor`, *facultatif*) : Tenseur de guidage pour la génération conditionnelle.

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 (*facultatif*) : Échantillons de blocs ControlNet à ajouter aux blocs du transformer.

additional_t_cond (`torch.Tensor`, *facultatif*) : Conditionnement supplémentaire de l'étape temporelle ajouté à l'incorporation de l'étape temporelle.

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 `QwenTransformer2DModel`.

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