# Transformer2DModel Un modèle Transformer pour des données de type image de [CompVis](https://huggingface.co/CompVis), basé sur le [Vision Transformer](https://huggingface.co/papers/2010.11929) introduit par Dosovitskiy et al. Le [Transformer2DModel](/docs/diffusers/main/fr/api/models/transformer2d#diffusers.Transformer2DModel) accepte des entrées discrètes (classes de vecteurs d'incorporation) ou continues (incorporations réelles). Lorsque l'entrée est **continue** : 1. Projeter l'entrée et la redimensionner en `(batch_size, sequence_length, feature_dimension)`. 2. Appliquez les blocs Transformer de manière standard. 3. Redimensionner en image. Lorsque l'entrée est **discrète** : > [!TIP] > On suppose que l'une des classes d'entrée est le pixel latent masqué. Les classes prédites de l'image non bruitée ne contiennent pas de prédiction pour le pixel masqué, car l'image non bruitée ne peut pas être masquée. 1. Convertir l'entrée (classes de pixels latents) en embeddings et appliquer des embeddings positionnels. 2. Appliquez les blocs Transformer de manière standard. 3. Prédit les classes de l'image non bruitée. ## Transformer2DModel[[diffusers.Transformer2DModel]] #### diffusers.Transformer2DModel[[diffusers.Transformer2DModel]] ```python diffusers.Transformer2DModel(num_attention_heads: int = 16, attention_head_dim: int = 88, in_channels: int | None = None, out_channels: int | None = None, num_layers: int = 1, dropout: float = 0.0, norm_num_groups: int = 32, cross_attention_dim: int | None = None, attention_bias: bool = False, sample_size: int | None = None, num_vector_embeds: int | None = None, patch_size: int | None = None, activation_fn: str = 'geglu', num_embeds_ada_norm: int | None = None, use_linear_projection: bool = False, only_cross_attention: bool = False, double_self_attention: bool = False, upcast_attention: bool = False, norm_type: str = 'layer_norm', norm_elementwise_affine: bool = True, norm_eps: float = 1e-05, attention_type: str = 'default', caption_channels: int = None, interpolation_scale: float = None, use_additional_conditions: bool | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_2d.py#L39) **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**). num_layers (`int`, *facultatif*, valeur par défaut 1) : Le nombre de blocs Transformer à utiliser. dropout (`float`, *facultatif*, par défaut 0.0) : La probabilité de dropout à utiliser. cross_attention_dim (`int`, *facultatif*) : Le nombre de dimensions de `encoder_hidden_states` à utiliser. sample_size (`int`, *facultatif*) : La largeur des images latentes (à spécifier si l'entrée est **discrète**). Cette valeur est fixe pendant l'entraînement, car elle est utilisée pour apprendre un nombre d'embeddings de position. num_vector_embeds (`int`, *facultatif*) : Le nombre de classes des embeddings vectoriels des pixels latents (à spécifier si l'entrée est **discrète**). Inclut la classe du pixel latent masqué. activation_fn (`str`, *facultatif*, par défaut `"geglu"`) : Fonction d'activation à utiliser dans le réseau de neurones à propagation avant. num_embeds_ada_norm ( `int`, *facultatif*) : Le nombre d'étapes de diffusion utilisées pendant l'entraînement. À transmettre si au moins une des norm_layers est `AdaLayerNorm`. Cette valeur est fixe pendant l'entraînement, car elle sert à apprendre un nombre d'embeddings ajoutés aux états cachés. Lors de l'inférence, vous pouvez débruitiser jusqu'à, mais pas plus d'étapes que `num_embeds_ada_norm`. attention_bias (`bool`, *facultatif*) : Configure si l'attention des `TransformerBlocks` doit contenir un paramètre de biais. Un modèle Transformer 2D pour des données de type image. #### forward[[diffusers.Transformer2DModel.forward]] ```python forward(hidden_states: Tensor, encoder_hidden_states: typing.Optional[torch.Tensor] = None, timestep: typing.Optional[torch.LongTensor] = None, added_cond_kwargs: dict[str, torch.Tensor] = None, class_labels: typing.Optional[torch.LongTensor] = None, cross_attention_kwargs: dict[str, typing.Any] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True) ``` [Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_2d.py#L324) **Paramètres :** hidden_states (`torch.LongTensor` de forme `(batch size, num latent pixels)` si discret, `torch.Tensor` de forme `(batch size, channel, height, width)` si continu) : `hidden_states` en entrée. encoder_hidden_states ( `torch.Tensor` de forme `(batch size, sequence len, embed dims)`, *facultatif*) : Incrustations conditionnelles pour la couche d'attention croisée. Si non fournies, l'attention croisée se comporte par défaut comme une auto-attention. timestep ( `torch.LongTensor`, *facultatif*) : Sert à indiquer l'étape de débruitage. Pas de temps facultatif à appliquer en tant qu'embedding dans `AdaLayerNorm`. class_labels ( `torch.LongTensor` de forme `(batch size, num classes)`, *facultatif*) : Utilisé pour indiquer le conditionnement par étiquettes de classe. Étiquettes de classe facultatives à appliquer sous forme d'embedding dans `AdaLayerZeroNorm`. cross_attention_kwargs ( `dict[str, Any]`, *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). attention_mask ( `torch.Tensor`, *facultatif*) : Un masque d'attention de forme `(batch, key_tokens)` est appliqué à `encoder_hidden_states`. Si `1`, le masque est conservé, sinon, si `0`, il est supprimé. Le masque est converti en biais, qui ajoute de grandes valeurs négatives aux scores d'attention correspondant aux jetons « supprimés ». encoder_attention_mask ( `torch.Tensor`, *facultatif*) : Masque d'attention croisée appliqué à `encoder_hidden_states`. Deux formats pris en charge : * Masque `(batch, sequence_length)` True = conserver, False = supprimer. * Biais `(batch, 1, sequence_length)` 0 = conserver, -10000 = supprimer. Si `ndim == 2` : sera interprété comme un masque, puis converti en biais cohérent avec le format ci-dessus. Ce biais sera ajouté aux scores d'attention croisée. return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [UNet2DConditionOutput](/docs/diffusers/main/fr/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) plutôt qu'un simple tuple. **Retourne :** Si `return_dict` est True, un `Transformer2DModelOutput` est renvoyé, sinon un `tuple` dont le premier élément est le tenseur d'échantillon. La méthode forward du [Transformer2DModel](/docs/diffusers/main/fr/api/models/transformer2d#diffusers.Transformer2DModel). ## 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/main/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/main/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/main/fr/api/models/transformer2d#diffusers.Transformer2DModel).