# PriorTransformer

O Prior Transformer foi originalmente introduzido em [Hierarchical Text-Conditional Image Generation with CLIP Latents](https://huggingface.co/papers/2204.06125) por Ramesh et al. Ele é usado para prever embeddings de imagem do CLIP a partir de embeddings de texto do CLIP; os embeddings de imagem são previstos por meio de um processo de difusão de desruido.

O resumo do artigo é:

*Modelos contrastivos como o CLIP demonstraram ser capazes de aprender representações robustas de imagens que capturam tanto a semântica quanto o estilo. Para aproveitar essas representações na geração de imagens, propomos um modelo de duas etapas: um prior que gera um embedding de imagem do CLIP dado um texto de legenda, e um decodificador que gera uma imagem condicionada ao embedding de imagem. Mostramos que a geração explícita de representações de imagem melhora a diversidade das imagens com perda mínima em fotorrealismo e similaridade com a legenda. Nossos decodificadores condicionados a representações de imagem também podem produzir variações de uma imagem que preservam tanto a semântica quanto o estilo, enquanto variam os detalhes não essenciais ausentes da representação de imagem. Além disso, o espaço de embedding conjunto do CLIP permite manipulações de imagem guiadas por linguagem de forma zero-shot. Usamos modelos de difusão para o decodificador e experimentamos com modelos autoregressivos e de difusão para o prior, constatando que os últimos são computacionalmente mais eficientes e produzem amostras de maior qualidade.*

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

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

**Parâmetros:**

num_attention_heads (`int`, *opcional*, padrão 32) : O número de cabeças a serem usadas para a atenção multi-cabeça.

attention_head_dim (`int`, *opcional*, padrão 64) : O número de canais em cada head.

num_layers (`int`, *opcional*, padrão 20) : O número de blocos de Transformer a serem usados.

embedding_dim (`int`, *opcional*, padrão 768) : A dimensão da entrada do modelo `hidden_states`

num_embeddings (`int`, *opcional*, padrão 77) : O número de embeddings da entrada do modelo `hidden_states`

additional_embeddings (`int`, *opcional*, padrão 4) : O número de tokens adicionais anexados aos `hidden_states` projetados. O comprimento real dos `hidden_states` utilizados é `num_embeddings + additional_embeddings`.

dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout a ser utilizada.

time_embed_act_fn (`str`, *opcional*, padrão 'silu') : A função de ativação a ser usada para criar incorporações de passo de tempo.

norm_in_type (`str`, *opcional*, padrão None) : A camada de normalização a ser aplicada nos estados ocultos antes de passá-los para os blocos Transformer. Defina como `None` se a normalização não for necessária.

embedding_proj_norm_type (`str`, *opcional*, padrão None) : A camada de normalização a ser aplicada na entrada `proj_embedding`. Defina como `None` se a normalização não for necessária.

encoder_hid_proj_type (`str`, *opcional*, padrão `linear`) : A camada de projeção a ser aplicada na entrada `encoder_hidden_states`. Defina como `None` se `encoder_hidden_states` for `None`.

added_emb_type (`str`, *opcional*, padrão `prd`) : Embutimentos adicionais para condicionar o modelo. Escolha entre `prd` ou `None`. Se escolher `prd`, será adicionado no início um token indicando o produto escalar (quantizado) entre o embutimento de texto e o embutimento de imagem, conforme proposto no paper unclip https://huggingface.co/papers/2204.06125 Se for `None`, nenhum embutimento adicional será adicionado no início.

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`, *opcional*, padrão None) : A dimensão de `proj_embedding`. Se None, será definida como `embedding_dim`.

clip_embed_dim (`int`, *opcional*, padrão None) : A dimensão da saída. Se None, será definida como `embedding_dim`.

Um modelo 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)
```

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

**Parâmetros:**

hidden_states (`torch.Tensor` de forma `(batch_size, embedding_dim)`) : Os embeddings de imagem atualmente previstos.

timestep (`torch.LongTensor`) : Etapa atual de remoção de ruído.

proj_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`) : Vetor de incorporação projetado no qual o processo de remoção de ruído é condicionado.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, num_embeddings, embedding_dim)`) : Estados ocultos dos embeddings de texto nos quais o processo de desruido é condicionado.

attention_mask (`torch.BoolTensor` de forma `(batch_size, num_embeddings)`) : Máscara de texto para os embeddings de texto.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [PriorTransformerOutput](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.models.transformers.prior_transformer.PriorTransformerOutput) em vez de uma tupla simples.

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

Se return_dict for True, um [PriorTransformerOutput](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.models.transformers.prior_transformer.PriorTransformerOutput) é retornado; caso contrário, uma tupla é retornada, em que o primeiro elemento é o tensor da amostra.

O método forward do [PriorTransformer](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.PriorTransformer).

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

```python
set_default_attn_processor()
```

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

Desativa os processadores de atenção personalizados e define a implementação padrão de atenção.

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

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

**Parâmetros:**

predicted_image_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`) : O embedding de imagem CLIP previsto, condicionado na entrada de embedding de texto CLIP.

A saída de [PriorTransformer](/docs/diffusers/main/pt/api/models/prior_transformer#diffusers.PriorTransformer).