# PriorTransformer

Le Prior Transformer a été initialement introduit dans [Hierarchical Text-Conditional Image Generation with CLIP Latents](https://huggingface.co/papers/2204.06125) par Ramesh et al. Il est utilisé pour prédire les embeddings d’images CLIP à partir des embeddings de texte CLIP ; les embeddings d’images sont prédits par un processus de diffusion de débruitage.

L'abstract de l'article est :

*Les modèles contrastifs comme CLIP ont démontré leur capacité à apprendre des représentations robustes d’images qui capturent à la fois la sémantique et le style. Pour exploiter ces représentations pour la génération d’images, nous proposons un modèle en deux étapes : un modèle a priori qui génère un embedding d’image CLIP à partir d’une légende textuelle, et un décodeur qui génère une image conditionnée par l’embedding d’image. Nous montrons que la génération explicite de représentations d’images améliore la diversité des images avec une perte minimale en photoréalisme et en similarité avec la légende. Nos décodeurs conditionnés par des représentations d’images peuvent également produire des variations d’une image qui préservent à la fois sa sémantique et son style, tout en faisant varier les détails non essentiels absents de la représentation d’image. De plus, l’espace d’embedding conjoint de CLIP permet des manipulations d’images guidées par le langage de manière zéro-shot. Nous utilisons des modèles de diffusion pour le décodeur et expérimentons avec des modèles autorégressifs et des modèles de diffusion pour le modèle a priori, constatant que ces derniers sont plus efficaces sur le plan computationnel et produisent des échantillons de meilleure qualité.*

## PriorTransformer[[diffusers.PriorTransformer]]

#### diffusers.PriorTransformer[[diffusers.PriorTransformer]]

```python
diffusers.PriorTransformer(num_attention_heads: int = 32, attention_head_dim: int = 64, num_layers: int = 20, embedding_dim: int = 768, num_embeddings = 77, additional_embeddings = 4, dropout: float = 0.0, time_embed_act_fn: str = 'silu', norm_in_type: str | None = None, embedding_proj_norm_type: str | None = None, encoder_hid_proj_type: str | None = 'linear', added_emb_type: str | None = 'prd', time_embed_dim: int | None = None, embedding_proj_dim: int | None = None, clip_embed_dim: int | None = None)
```

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

**Paramètres :**

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

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

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

embedding_dim (`int`, *facultatif*, valeur par défaut 768) : La dimension de l'entrée du modèle `hidden_states`

num_embeddings (`int`, *facultatif*, valeur par défaut 77) : Le nombre d'embeddings de l'entrée du modèle `hidden_states`

additional_embeddings (`int`, *facultatif*, valeur par défaut 4) : Le nombre de jetons supplémentaires ajoutés aux `hidden_states` projetés. La longueur réelle des `hidden_states` utilisés est `num_embeddings + additional_embeddings`.

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

time_embed_act_fn (`str`, *facultatif*, par défaut 'silu') : La fonction d'activation à utiliser pour créer les embeddings de pas de temps.

norm_in_type (`str`, *facultatif*, par défaut None) : La couche de normalisation à appliquer sur les états cachés avant de les transmettre aux blocs Transformer. Définissez-la sur `None` si la normalisation n'est pas nécessaire.

embedding_proj_norm_type (`str`, *facultatif*, par défaut None) : La couche de normalisation à appliquer sur l'entrée `proj_embedding`. Définissez-la sur `None` si la normalisation n'est pas nécessaire.

encoder_hid_proj_type (`str`, *facultatif*, par défaut `linear`) : La couche de projection à appliquer sur l'entrée `encoder_hidden_states`. Définissez-la sur `None` si `encoder_hidden_states` est `None`.

added_emb_type (`str`, *facultatif*, par défaut `prd`) : Embeddings supplémentaires pour conditionner le modèle. Choisissez entre `prd` ou `None`. Si vous choisissez `prd`, un jeton indiquant le produit scalaire (quantifié) entre l'embedding du texte et l'embedding de l'image sera ajouté en préfixe, comme proposé dans l'article unclip https://huggingface.co/papers/2204.06125 S'il s'agit de `None`, aucun embedding supplémentaire ne sera ajouté en préfixe.

time_embed_dim (`int, *optional*, defaults to None) : The dimension of timestep embeddings. If None, will be set to `num_attention_heads * attention_head_dim`

embedding_proj_dim (`int`, *facultatif*, par défaut None) : La dimension de `proj_embedding`. Si None, elle sera définie sur `embedding_dim`.

clip_embed_dim (`int`, *facultatif*, par défaut None) : La dimension de la sortie. Si None, elle sera définie sur `embedding_dim`.

Modèle Transformer A Prior.

#### forward[[diffusers.PriorTransformer.forward]]

```python
forward(hidden_states, timestep: typing.Union[torch.Tensor, float, int], proj_embedding: Tensor, encoder_hidden_states: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.BoolTensor] = None, return_dict: bool = True)
```

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

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, embedding_dim)`) : Les embeddings d'image actuellement prédits.

timestep (`torch.LongTensor`) : Étape de débruitage actuelle.

proj_embedding (`torch.Tensor` de forme `(batch_size, embedding_dim)`) : Vecteur d'embedding projeté sur lequel le processus de débruitage est conditionné.

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, num_embeddings, embedding_dim)`) : États cachés des embeddings de texte sur lesquels le processus de débruitage est conditionné.

attention_mask (`torch.BoolTensor` de forme `(batch_size, num_embeddings)`) : Masque de texte pour les embeddings de texte.

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

**Retourne :** [PriorTransformerOutput](/docs/diffusers/main/fr/api/models/prior_transformer#diffusers.models.transformers.prior_transformer.PriorTransformerOutput) ou `tuple`

Si return_dict est True, un [PriorTransformerOutput](/docs/diffusers/main/fr/api/models/prior_transformer#diffusers.models.transformers.prior_transformer.PriorTransformerOutput) est renvoyé, sinon un tuple est renvoyé dont le premier élément est le tenseur d'échantillon.

La méthode forward de [PriorTransformer](/docs/diffusers/main/fr/api/models/prior_transformer#diffusers.PriorTransformer).

#### set_default_attn_processor[[diffusers.PriorTransformer.set_default_attn_processor]]

```python
set_default_attn_processor()
```

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

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

## PriorTransformerOutput[[diffusers.models.transformers.prior_transformer.PriorTransformerOutput]]

#### diffusers.models.transformers.prior_transformer.PriorTransformerOutput[[diffusers.models.transformers.prior_transformer.PriorTransformerOutput]]

```python
diffusers.models.transformers.prior_transformer.PriorTransformerOutput(predicted_image_embedding: Tensor)
```

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

**Paramètres :**

predicted_image_embedding (`torch.Tensor` de forme `(batch_size, embedding_dim)`) : L'embedding d'image CLIP prédit, conditionné par l'entrée d'embedding de texte CLIP.

La sortie de [PriorTransformer](/docs/diffusers/main/fr/api/models/prior_transformer#diffusers.PriorTransformer).