Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /es /api /models /transformer2d.md

mishig

3 days ago

preview code

download

raw

8.31 kB

# Transformer2DModel

Un modelo Transformer para datos de tipo imagen de [CompVis](https://huggingface.co/CompVis) basado en el [Vision Transformer](https://huggingface.co/papers/2010.11929) introducido por Dosovitskiy et al. El [Transformer2DModel](/docs/diffusers/main/es/api/models/transformer2d#diffusers.Transformer2DModel) acepta entradas discretas (clases de embeddings de vectores) o continuas (embeddings reales).

Cuando la entrada es **continua**:

1. Proyecta la entrada y redimensiona su forma a `(batch_size, sequence_length, feature_dimension)`.
2. Aplica los bloques Transformer de la manera estándar.
3. Redimensionar a imagen.

Cuando la entrada es **discreta**:

> [!TIP]
> Se asume que una de las clases de entrada es el píxel latente enmascarado. Las clases predichas de la imagen sin ruido no contienen una predicción para el píxel enmascarado porque la imagen sin ruido no puede enmascararse.

1. Convierte la entrada (clases de píxeles latentes) en incrustaciones y aplica incrustaciones posicionales.
2. Aplica los bloques Transformer de la manera estándar.
3. Predice las clases de la imagen sin ruido.

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_2d.py#L39)

**Parámetros:**

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

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

in_channels (`int`, *opcional*) : El número de canales en la entrada y la salida (especifícalo si la entrada es **continua**).
num_layers (`int`, *opcional*, valor predeterminado 1) : El número de capas de bloques Transformer a utilizar.

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

cross_attention_dim (`int`, *opcional*) : El número de dimensiones de `encoder_hidden_states` a utilizar.

sample_size (`int`, *opcional*) : El ancho de las imágenes latentes (especificar si la entrada es **discreta**). Esto se fija durante el entrenamiento, ya que se utiliza para aprender un número de embeddings de posición.
num_vector_embeds (`int`, *opcional*) : El número de clases de las incrustaciones vectoriales de los píxeles latentes (especifícalo si la entrada es **discreta**). Incluye la clase para el píxel latente enmascarado.
activation_fn (`str`, *opcional*, por defecto `"geglu"`) : Función de activación a utilizar en el feed-forward.

num_embeds_ada_norm ( `int`, *opcional*) : El número de pasos de difusión utilizados durante el entrenamiento. Pásalo si al menos una de las norm_layers es `AdaLayerNorm`. Esto se fija durante el entrenamiento, ya que se utiliza para aprender un número de embeddings que se añaden a los estados ocultos. Durante la inferencia, puedes desruidar hasta, pero no más, pasos que `num_embeds_ada_norm`.

attention_bias (`bool`, *opcional*) : Configura si la atención de `TransformerBlocks` debe incluir un parámetro de sesgo.
Un modelo Transformer 2D para datos similares a imágenes.
#### 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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_2d.py#L324)
**Parámetros:**
hidden_states (`torch.LongTensor` de forma `(batch size, num latent pixels)` si es discreto, `torch.Tensor` de forma `(batch size, channel, height, width)` si es continuo) : `hidden_states` de entrada.

encoder_hidden_states ( `torch.Tensor` de forma `(batch size, sequence len, embed dims)`, *opcional*) : Incrustaciones condicionales para la capa de atención cruzada. Si no se proporcionan, la atención cruzada predeterminada es la autoatención.

timestep ( `torch.LongTensor`, *opcional*) : Se utiliza para indicar el paso de desruido. Paso temporal opcional que se aplica como un embedding en `AdaLayerNorm`.

class_labels ( `torch.LongTensor` de forma `(batch size, num classes)`, *opcional*) : Se utiliza para indicar la condición de etiquetas de clase. Etiquetas de clase opcionales que se aplicarán como un embedding en `AdaLayerZeroNorm`.
cross_attention_kwargs ( `dict[str, Any]`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` definido bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
attention_mask ( `torch.Tensor`, *opcional*) : Se aplica una máscara de atención de forma `(batch, key_tokens)` a `encoder_hidden_states`. Si es `1`, la máscara se conserva; en caso contrario, si es `0`, se descarta. La máscara se convertirá en un sesgo, que añade valores negativos grandes a las puntuaciones de atención correspondientes a los tokens "descartados".

encoder_attention_mask ( `torch.Tensor`, *opcional*) : Máscara de atención cruzada aplicada a `encoder_hidden_states`. Se admiten dos formatos:  * Máscara `(batch, sequence_length)` True = conservar, False = descartar. * Sesgo `(batch, 1, sequence_length)` 0 = conservar, -10000 = descartar.  Si `ndim == 2`: se interpretará como una máscara y luego se convertirá en un sesgo coherente con el formato anterior. Este sesgo se sumará a las puntuaciones de atención cruzada.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un [UNet2DConditionOutput](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) en lugar de una tupla simple.
**Devuelve:**
Si `return_dict` es True, se devuelve un `Transformer2DModelOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es el tensor de la muestra.

El método forward de [Transformer2DModel](/docs/diffusers/main/es/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)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_outputs.py#L21)
**Parámetros:**
sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` o `(batch size, num_vector_embeds - 1, num_latent_pixels)` si [Transformer2DModel](/docs/diffusers/main/es/api/models/transformer2d#diffusers.Transformer2DModel) es discreto): las salidas de estados ocultos condicionadas a la entrada `encoder_hidden_states`. Si es discreto, devuelve distribuciones de probabilidad para los píxeles latentes sin ruido.
La salida de [Transformer2DModel](/docs/diffusers/main/es/api/models/transformer2d#diffusers.Transformer2DModel).

Xet Storage Details

Size:: 8.31 kB
Xet hash:: 333de81809f1595ee69eed123feddb883f99f889e7575d2172240b09ad162b24

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# Transformer2DModel

	Un modelo Transformer para datos de tipo imagen de [CompVis](https://huggingface.co/CompVis) basado en el [Vision Transformer](https://huggingface.co/papers/2010.11929) introducido por Dosovitskiy et al. El [Transformer2DModel](/docs/diffusers/main/es/api/models/transformer2d#diffusers.Transformer2DModel) acepta entradas discretas (clases de embeddings de vectores) o continuas (embeddings reales).

	Cuando la entrada es continua:

	1. Proyecta la entrada y redimensiona su forma a `(batch_size, sequence_length, feature_dimension)`.
	2. Aplica los bloques Transformer de la manera estándar.
	3. Redimensionar a imagen.

	Cuando la entrada es discreta:

	> [!TIP]
	> Se asume que una de las clases de entrada es el píxel latente enmascarado. Las clases predichas de la imagen sin ruido no contienen una predicción para el píxel enmascarado porque la imagen sin ruido no puede enmascararse.

	1. Convierte la entrada (clases de píxeles latentes) en incrustaciones y aplica incrustaciones posicionales.
	2. Aplica los bloques Transformer de la manera estándar.
	3. Predice las clases de la imagen sin ruido.

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

	[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_2d.py#L39)

	Parámetros:

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

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

	in_channels (`int`, opcional) : El número de canales en la entrada y la salida (especifícalo si la entrada es continua).

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

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

	cross_attention_dim (`int`, opcional) : El número de dimensiones de `encoder_hidden_states` a utilizar.

	sample_size (`int`, opcional) : El ancho de las imágenes latentes (especificar si la entrada es discreta). Esto se fija durante el entrenamiento, ya que se utiliza para aprender un número de embeddings de posición.

	num_vector_embeds (`int`, opcional) : El número de clases de las incrustaciones vectoriales de los píxeles latentes (especifícalo si la entrada es discreta). Incluye la clase para el píxel latente enmascarado.

	activation_fn (`str`, opcional, por defecto `"geglu"`) : Función de activación a utilizar en el feed-forward.

	num_embeds_ada_norm ( `int`, opcional) : El número de pasos de difusión utilizados durante el entrenamiento. Pásalo si al menos una de las norm_layers es `AdaLayerNorm`. Esto se fija durante el entrenamiento, ya que se utiliza para aprender un número de embeddings que se añaden a los estados ocultos. Durante la inferencia, puedes desruidar hasta, pero no más, pasos que `num_embeds_ada_norm`.

	attention_bias (`bool`, opcional) : Configura si la atención de `TransformerBlocks` debe incluir un parámetro de sesgo.

	Un modelo Transformer 2D para datos similares a imágenes.

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

	[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_2d.py#L324)

	Parámetros:

	hidden_states (`torch.LongTensor` de forma `(batch size, num latent pixels)` si es discreto, `torch.Tensor` de forma `(batch size, channel, height, width)` si es continuo) : `hidden_states` de entrada.

	encoder_hidden_states ( `torch.Tensor` de forma `(batch size, sequence len, embed dims)`, opcional) : Incrustaciones condicionales para la capa de atención cruzada. Si no se proporcionan, la atención cruzada predeterminada es la autoatención.

	timestep ( `torch.LongTensor`, opcional) : Se utiliza para indicar el paso de desruido. Paso temporal opcional que se aplica como un embedding en `AdaLayerNorm`.

	class_labels ( `torch.LongTensor` de forma `(batch size, num classes)`, opcional) : Se utiliza para indicar la condición de etiquetas de clase. Etiquetas de clase opcionales que se aplicarán como un embedding en `AdaLayerZeroNorm`.

	cross_attention_kwargs ( `dict[str, Any]`, opcional) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` definido bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

	attention_mask ( `torch.Tensor`, opcional) : Se aplica una máscara de atención de forma `(batch, key_tokens)` a `encoder_hidden_states`. Si es `1`, la máscara se conserva; en caso contrario, si es `0`, se descarta. La máscara se convertirá en un sesgo, que añade valores negativos grandes a las puntuaciones de atención correspondientes a los tokens "descartados".

	encoder_attention_mask ( `torch.Tensor`, opcional) : Máscara de atención cruzada aplicada a `encoder_hidden_states`. Se admiten dos formatos: * Máscara `(batch, sequence_length)` True = conservar, False = descartar. * Sesgo `(batch, 1, sequence_length)` 0 = conservar, -10000 = descartar. Si `ndim == 2`: se interpretará como una máscara y luego se convertirá en un sesgo coherente con el formato anterior. Este sesgo se sumará a las puntuaciones de atención cruzada.

	return_dict (`bool`, opcional, valor predeterminado `True`) : Indica si se debe devolver un [UNet2DConditionOutput](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) en lugar de una tupla simple.

	Devuelve:

	Si `return_dict` es True, se devuelve un `Transformer2DModelOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es el tensor de la muestra.

	El método forward de [Transformer2DModel](/docs/diffusers/main/es/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)
	```

	[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_outputs.py#L21)

	Parámetros:

	sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` o `(batch size, num_vector_embeds - 1, num_latent_pixels)` si [Transformer2DModel](/docs/diffusers/main/es/api/models/transformer2d#diffusers.Transformer2DModel) es discreto): las salidas de estados ocultos condicionadas a la entrada `encoder_hidden_states`. Si es discreto, devuelve distribuciones de probabilidad para los píxeles latentes sin ruido.

	La salida de [Transformer2DModel](/docs/diffusers/main/es/api/models/transformer2d#diffusers.Transformer2DModel).