# PriorTransformer

El Prior Transformer se introdujo originalmente en [Hierarchical Text-Conditional Image Generation with CLIP Latents](https://huggingface.co/papers/2204.06125) de Ramesh et al. Se utiliza para predecir embeddings de imagen de CLIP a partir de embeddings de texto de CLIP; los embeddings de imagen se predicen mediante un proceso de difusión de desruido.

El resumen del artículo es:

*Los modelos contrastivos como CLIP han demostrado aprender representaciones robustas de imágenes que capturan tanto la semántica como el estilo. Para aprovechar estas representaciones para la generación de imágenes, proponemos un modelo de dos etapas: un prior que genera un embedding de imagen de CLIP dado un texto de descripción, y un decodificador que genera una imagen condicionada al embedding de imagen. Mostramos que generar explícitamente representaciones de imagen mejora la diversidad de las imágenes con una pérdida mínima en fotorrealismo y similitud con la descripción. Nuestros decodificadores condicionados a representaciones de imagen también pueden producir variaciones de una imagen que preservan tanto su semántica como su estilo, mientras varían los detalles no esenciales ausentes de la representación de imagen. Además, el espacio de embedding conjunto de CLIP permite manipulaciones de imagen guiadas por lenguaje de forma zero-shot. Utilizamos modelos de difusión para el decodificador y experimentamos con modelos tanto autoregresivos como de difusión para el prior, encontrando que estos últimos son computacionalmente más eficientes y producen muestras de mayor calidad.*

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

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

**Parámetros:**

num_attention_heads (`int`, *opcional*, valor predeterminado 32) : El número de cabezas a utilizar para la atención multi-cabeza.

attention_head_dim (`int`, *opcional*, valor predeterminado 64) : El número de canales en cada cabeza.

num_layers (`int`, *opcional*, valor predeterminado 20) : El número de capas de bloques Transformer a utilizar.

embedding_dim (`int`, *opcional*, valor predeterminado 768) : La dimensión de la entrada del modelo `hidden_states`

num_embeddings (`int`, *opcional*, valor predeterminado 77) : El número de embeddings de la entrada del modelo `hidden_states`

additional_embeddings (`int`, *opcional*, valor predeterminado 4) : El número de tokens adicionales que se añaden a los `hidden_states` proyectados. La longitud real de los `hidden_states` utilizados es `num_embeddings + additional_embeddings`.

dropout (`float`, *opcional*, valor predeterminado 0.0) : La probabilidad de dropout a utilizar.

time_embed_act_fn (`str`, *opcional*, por defecto 'silu') : La función de activación que se utilizará para crear las incrustaciones de paso de tiempo.

norm_in_type (`str`, *opcional*, valor predeterminado None) : La capa de normalización que se aplica a los estados ocultos antes de pasarlos a los bloques Transformer. Establézcala en `None` si no se necesita normalización.

embedding_proj_norm_type (`str`, *opcional*, valor predeterminado None) : La capa de normalización que se aplica a la entrada `proj_embedding`. Establézcala en `None` si no se necesita normalización.

encoder_hid_proj_type (`str`, *opcional*, por defecto `linear`) : La capa de proyección que se aplica a la entrada `encoder_hidden_states`. Establézcala en `None` si `encoder_hidden_states` es `None`.

added_emb_type (`str`, *opcional*, valor predeterminado `prd`) : Embeddings adicionales para condicionar el modelo. Elija entre `prd` o `None`. Si se elige `prd`, se añadirá al inicio un token que indica el producto punto (cuantizado) entre el embedding de texto y el embedding de imagen, tal como se propone en el paper unclip https://huggingface.co/papers/2204.06125 Si es `None`, no se añadirán embeddings adicionales al inicio.

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*, valor predeterminado None) : La dimensión de `proj_embedding`. Si es None, se establecerá en `embedding_dim`.

clip_embed_dim (`int`, *opcional*, valor predeterminado None) : La dimensión de la salida. Si es None, se establecerá en `embedding_dim`.

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

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

**Parámetros:**

hidden_states (`torch.Tensor` de forma `(batch_size, embedding_dim)`) : Los embeddings de imagen actualmente predichos.

timestep (`torch.LongTensor`) : Paso actual de desruido.

proj_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`) : Vector de embedding proyectado sobre el que se condiciona el proceso de denoising.

encoder_hidden_states (`torch.Tensor` de forma `(batch_size, num_embeddings, embedding_dim)`) : Estados ocultos de las incrustaciones de texto en las que se condiciona el proceso de desruido.

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

return_dict (`bool`, *opcional*, por defecto `True`) : Indica si se debe devolver un [PriorTransformerOutput](/docs/diffusers/v0.43.0/es/api/models/prior_transformer#diffusers.models.transformers.prior_transformer.PriorTransformerOutput) en lugar de una tupla simple.

**Devuelve:** [PriorTransformerOutput](/docs/diffusers/v0.43.0/es/api/models/prior_transformer#diffusers.models.transformers.prior_transformer.PriorTransformerOutput) o `tuple`

Si return_dict es True, se devuelve un [PriorTransformerOutput](/docs/diffusers/v0.43.0/es/api/models/prior_transformer#diffusers.models.transformers.prior_transformer.PriorTransformerOutput); en caso contrario, se devuelve una tupla cuyo primer elemento es el tensor de la muestra.

El método forward de [PriorTransformer](/docs/diffusers/v0.43.0/es/api/models/prior_transformer#diffusers.PriorTransformer).

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

```python
set_default_attn_processor()
```

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

Desactiva los procesadores de atención personalizados y establece la implementación de atención predeterminada.

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

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

**Parámetros:**

predicted_image_embedding (`torch.Tensor` de forma `(batch_size, embedding_dim)`) : El embedding de imagen CLIP predicho, condicionado por la entrada de embedding de texto CLIP.

La salida de [PriorTransformer](/docs/diffusers/v0.43.0/es/api/models/prior_transformer#diffusers.PriorTransformer).