diffusers/main/fr/api/models/transformer2d.md

Transformer2DModel

Un modèle Transformer pour des données de type image de CompVis, basé sur le Vision Transformer introduit par Dosovitskiy et al. Le 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 :

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]]

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

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]]

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

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.

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

Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

diffusers.models.modeling_outputs.Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

diffusers.models.modeling_outputs.Transformer2DModelOutput(sample: torch.Tensor)

Source

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