# UNet2DConditionModel

El modelo [UNet](https://huggingface.co/papers/1505.04597) fue introducido originalmente por Ronneberger et al. para la segmentación de imágenes biomédicas, pero también se utiliza comúnmente en 🤗 Diffusers porque genera imágenes del mismo tamaño que la entrada. Es uno de los componentes más importantes de un sistema de difusión, ya que facilita el proceso de difusión propiamente dicho. Existen varias variantes del modelo UNet en 🤗 Diffusers, dependiendo de su número de dimensiones y de si es un modelo condicional o no. Este es un modelo UNet condicional de 2D.

El resumen del artículo es:

*Existe un amplio consenso de que el entrenamiento exitoso de redes profundas requiere miles de muestras de entrenamiento anotadas. En este artículo, presentamos una red y una estrategia de entrenamiento que se basa en el uso intensivo de aumentación de datos para utilizar las muestras anotadas disponibles de manera más eficiente. La arquitectura consiste en una ruta contractiva para capturar el contexto y una ruta expansiva simétrica que permite una localización precisa. Demostramos que una red de este tipo puede entrenarse de extremo a extremo a partir de muy pocas imágenes y supera al mejor método anterior (una red convolucional de ventana deslizante) en el desafío ISBI para la segmentación de estructuras neuronales en pilas de microscopía electrónica. Utilizando la misma red entrenada con imágenes de microscopía de luz transmitida (contraste de fase y DIC), ganamos el desafío de seguimiento celular ISBI 2015 en estas categorías por un amplio margen. Además, la red es rápida. La segmentación de una imagen de 512x512 toma menos de un segundo en una GPU reciente. La implementación completa (basada en Caffe) y las redes entrenadas están disponibles en http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net.*

## UNet2DConditionModel[[diffusers.UNet2DConditionModel]]

#### diffusers.UNet2DConditionModel[[diffusers.UNet2DConditionModel]]

```python
diffusers.UNet2DConditionModel(sample_size: int | tuple[int, int] | None = None, in_channels: int = 4, out_channels: int = 4, center_input_sample: bool = False, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str | None = 'UNetMidBlock2DCrossAttn', up_block_types: tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple = (320, 640, 1280, 1280), layers_per_block: int | tuple[int] = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, dropout: float = 0.0, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int | tuple[int] = 1280, transformer_layers_per_block: int | tuple[int] | tuple[tuple] = 1, reverse_transformer_layers_per_block: tuple[tuple[int]] | None = None, encoder_hid_dim: int | None = None, encoder_hid_dim_type: str | None = None, attention_head_dim: int | tuple[int] = 8, num_attention_heads: int | tuple[int] | None = None, dual_cross_attention: bool = False, use_linear_projection: bool = False, class_embed_type: str | None = None, addition_embed_type: str | None = None, addition_time_embed_dim: int | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', resnet_skip_time_act: bool = False, resnet_out_scale_factor: float = 1.0, time_embedding_type: str = 'positional', time_embedding_dim: int | None = None, time_embedding_act_fn: str | None = None, timestep_post_act: str | None = None, time_cond_proj_dim: int | None = None, conv_in_kernel: int = 3, conv_out_kernel: int = 3, projection_class_embeddings_input_dim: int | None = None, attention_type: str = 'default', class_embeddings_concat: bool = False, mid_block_only_cross_attention: bool | None = None, cross_attention_norm: str | None = None, addition_embed_type_num_heads: int = 64)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L76)

**Parámetros:**

sample_size (`int` o `tuple[int, int]`, *opcional*, valor predeterminado `None`) : Altura y ancho de la muestra de entrada/salida.

in_channels (`int`, *opcional*, valor predeterminado 4) : Número de canales en la muestra de entrada.

out_channels (`int`, *opcional*, valor predeterminado 4) : Número de canales en la salida.

center_input_sample (`bool`, *opcional*, por defecto `False`) : Si se debe centrar la muestra de entrada.

flip_sin_to_cos (`bool`, *opcional*, por defecto `True`) : Si se debe invertir el sin a cos en la incrustación temporal.

freq_shift (`int`, *opcional*, valor predeterminado 0) : El desplazamiento de frecuencia que se aplica a la incrustación temporal.

down_block_types (`tuple[str]`, *opcional*, por defecto `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : La tupla de bloques de muestreo descendente a utilizar.

mid_block_type (`str`, *opcional*, valor predeterminado `"UNetMidBlock2DCrossAttn"`) : Tipo de bloque para la parte media de UNet, puede ser uno de `UNetMidBlock2DCrossAttn`, `UNetMidBlock2D` o `UNetMidBlock2DSimpleCrossAttn`. Si es `None`, se omite la capa del bloque medio.

up_block_types (`tuple[str]`, *opcional*, por defecto `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : La tupla de bloques de remuestreo ascendente a utilizar.

only_cross_attention(`bool` o `tuple[bool]`, *opcional*, por defecto `False`) : Si se debe incluir la autoatención en los bloques básicos del transformer, ver `BasicTransformerBlock`.

block_out_channels (`tuple[int]`, *opcional*, valor predeterminado `(320, 640, 1280, 1280)`) : La tupla de canales de salida para cada bloque.

layers_per_block (`int`, *opcional*, valor predeterminado 2) : El número de capas por bloque.

downsample_padding (`int`, *opcional*, valor predeterminado 1) : El relleno a utilizar para la convolución de muestreo descendente.

mid_block_scale_factor (`float`, *opcional*, valor predeterminado 1.0) : El factor de escala a utilizar para el bloque intermedio.

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

act_fn (`str`, *opcional*, por defecto `"silu"`) : La función de activación a utilizar.

norm_num_groups (`int`, *opcional*, valor predeterminado 32) : El número de grupos a utilizar para la normalización. Si es `None`, se omiten las capas de normalización y activación en el posprocesamiento.

norm_eps (`float`, *opcional*, valor predeterminado 1e-5) : El epsilon a utilizar para la normalización.

cross_attention_dim (`int` o `tuple[int]`, *opcional*, valor predeterminado 1280) : La dimensión de las características de la atención cruzada.

transformer_layers_per_block (`int`, `tuple[int]` o `tuple[tuple]` , *opcional*, valor predeterminado 1) : El número de bloques de transformador de tipo `BasicTransformerBlock`. Solo es relevante para `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

reverse_transformer_layers_per_block : (`tuple[tuple]`, *opcional*, valor predeterminado None): El número de bloques de transformador de tipo `BasicTransformerBlock`, en los bloques de remuestreo ascendente de la U-Net. Solo es relevante si `transformer_layers_per_block` es de tipo `tuple[tuple]` y para `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

encoder_hid_dim (`int`, *opcional*, valor predeterminado None) : Si `encoder_hid_dim_type` está definido, `encoder_hidden_states` se proyectará de la dimensión `encoder_hid_dim` a `cross_attention_dim`.

encoder_hid_dim_type (`str`, *opcional*, valor predeterminado `None`) : Si se proporciona, `encoder_hidden_states` y posiblemente otras incrustaciones se proyectan hacia abajo a incrustaciones de texto de dimensión `cross_attention` según `encoder_hid_dim_type`.

attention_head_dim (`int`, *opcional*, valor predeterminado 8) : La dimensión de las cabezas de atención.

num_attention_heads (`int`, *opcional*) : El número de cabezas de atención. Si no se define, el valor predeterminado es `attention_head_dim`

resnet_time_scale_shift (`str`, *opcional*, valor predeterminado `"default"`) : Configuración de desplazamiento de escala temporal para los bloques ResNet (ver `ResnetBlock2D`). Elija entre `default` o `scale_shift`.

class_embed_type (`str`, *opcional*, valor predeterminado `None`) : El tipo de embedding de clase que se utilizará y que finalmente se suma con los embeddings de tiempo. Elija entre `None`, `"timestep"`, `"identity"`, `"projection"` o `"simple_projection"`.

addition_embed_type (`str`, *opcional*, valor predeterminado `None`) : Configura un embedding opcional que se sumará con los embeddings de tiempo. Elige entre `None` o "text". "text" utilizará la capa `TextTimeEmbedding`.

addition_time_embed_dim : (`int`, *opcional*, valor predeterminado `None`): Dimensión para las incrustaciones de paso de tiempo.

num_class_embeds (`int`, *opcional*, valor predeterminado `None`) : Dimensión de entrada de la matriz de incrustación aprendible que se proyectará a `time_embed_dim`, al realizar condicionamiento por clase con `class_embed_type` igual a `None`.

time_embedding_type (`str`, *opcional*, valor predeterminado `positional`) : El tipo de incrustación de posición a utilizar para los pasos de tiempo. Elija entre `positional` o `fourier`.

time_embedding_dim (`int`, *opcional*, valor predeterminado `None`) : Un valor opcional para sobrescribir la dimensión del embedding de tiempo proyectado.

time_embedding_act_fn (`str`, *opcional*, valor predeterminado `None`) : Función de activación opcional para usar solo una vez en las incrustaciones de tiempo antes de pasarlas al resto de la UNet. Elija entre `silu`, `mish`, `gelu` y `swish`.

timestep_post_act (`str`, *opcional*, valor predeterminado `None`) : La segunda función de activación a utilizar en la incrustación de paso de tiempo. Elija entre `silu`, `mish` y `gelu`.

time_cond_proj_dim (`int`, *opcional*, valor predeterminado `None`) : La dimensión de la capa `cond_proj` en la incrustación del paso de tiempo.

conv_in_kernel (`int`, *opcional*, valor predeterminado `3`) : El tamaño del kernel de la capa `conv_in`.

conv_out_kernel (`int`, *opcional*, valor predeterminado `3`) : El tamaño del kernel de la capa `conv_out`.

projection_class_embeddings_input_dim (`int`, *opcional*) : La dimensión de la entrada `class_labels` cuando `class_embed_type="projection"`. Obligatorio cuando `class_embed_type="projection"`.

class_embeddings_concat (`bool`, *opcional*, por defecto `False`) : Si se deben concatenar los embeddings de tiempo con los embeddings de clase.

mid_block_only_cross_attention (`bool`, *opcional*, valor predeterminado `None`) : Si se debe usar atención cruzada con el bloque intermedio al utilizar `UNetMidBlock2DSimpleCrossAttn`. Si `only_cross_attention` se proporciona como un único booleano y `mid_block_only_cross_attention` es `None`, se utiliza el valor de `only_cross_attention` como valor para `mid_block_only_cross_attention`. De lo contrario, el valor predeterminado es `False`.

Un modelo 2D UNet condicional que toma una muestra con ruido, un estado condicional y un paso de tiempo y devuelve una salida con forma de muestra.

Este modelo hereda de [ModelMixin](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin). Consulta la documentación de la superclase para sus métodos genéricos implementados para todos los modelos (como la descarga o el guardado).

#### disable_freeu[[diffusers.UNet2DConditionModel.disable_freeu]]

```python
disable_freeu()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L814)

Desactiva el mecanismo FreeU.

#### enable_freeu[[diffusers.UNet2DConditionModel.enable_freeu]]

```python
enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L790)

**Parámetros:**

s1 (`float`) : Factor de escala para la etapa 1 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

s2 (`float`) : Factor de escala para la etapa 2 para atenuar las contribuciones de las características de salto. Esto se hace para mitigar el "efecto de sobre-almohadillado" en el proceso de desruido mejorado.

b1 (`float`) : Factor de escala para la etapa 1 para amplificar las contribuciones de las características del backbone.

b2 (`float`) : Factor de escala para la etapa 2 para amplificar las contribuciones de las características del backbone.

Activa el mecanismo FreeU de https://huggingface.co/papers/2309.11497.

Los sufijos después de los factores de escalado representan los bloques de etapa en los que se están aplicando.

Consulte el [repositorio oficial](https://github.com/ChenyangSi/FreeU) para conocer las combinaciones de valores que funcionan bien en diferentes pipelines, como Stable Diffusion v1, v2 y Stable Diffusion XL.

#### forward[[diffusers.UNet2DConditionModel.forward]]

```python
forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, added_cond_kwargs: dict[str, torch.Tensor] | None = None, down_block_additional_residuals: tuple[torch.Tensor] | None = None, mid_block_additional_residual: typing.Optional[torch.Tensor] = None, down_intrablock_additional_residuals: tuple[torch.Tensor] | None = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L978)

**Parámetros:**

sample (`torch.Tensor`) : El tensor de entrada con ruido con la siguiente forma `(batch, channel, height, width)`.

timestep (`torch.Tensor` o `float` o `int`) : El número de pasos de tiempo para desruidar una entrada.

encoder_hidden_states (`torch.Tensor`) : Los estados ocultos del codificador con forma `(batch, sequence_length, feature_dim)`.

class_labels (`torch.Tensor`, *opcional*, valor predeterminado `None`) : Etiquetas de clase opcionales para la condición. Sus incrustaciones se sumarán con las incrustaciones del paso de tiempo.

timestep_cond : (`torch.Tensor`, *opcional*, valor predeterminado `None`): Incrustaciones condicionales para el paso de tiempo. Si se proporcionan, las incrustaciones se sumarán con las muestras que pasan por la capa `self.time_embedding` para obtener las incrustaciones del paso de tiempo.

attention_mask (`torch.Tensor`, *opcional*, valor predeterminado `None`) : Una máscara de atención de forma `(batch, key_tokens)` se aplica 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".

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

added_cond_kwargs : (`dict`, *opcional*): Un diccionario de kwargs que contiene embeddings adicionales que, si se especifican, se añaden a los embeddings que se pasan a los bloques del UNet.

down_block_additional_residuals : (`tuple` de `torch.Tensor`, *opcional*): Una tupla de tensores que, si se especifica, se suma a los residuos de los bloques down del unet.

mid_block_additional_residual : (`torch.Tensor`, *opcional*): Un tensor que, si se especifica, se suma al residual del bloque intermedio de unet.

down_intrablock_additional_residuals (`tuple` de `torch.Tensor`, *opcional*) : residuos adicionales que se deben sumar dentro de los bloques de bajada de UNet, por ejemplo, de los modelos laterales de T2I-Adapter

encoder_attention_mask (`torch.Tensor`) : Una máscara de atención cruzada de forma `(batch, sequence_length)` se aplica a `encoder_hidden_states`. Si es `True`, la máscara se conserva; en caso contrario, si es `False`, 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 de "descartar".

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:** [UNet2DConditionOutput](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) o `tuple`

Si `return_dict` es True, se devuelve un [UNet2DConditionOutput](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es el tensor de la muestra.

El método forward de [UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel).

#### fuse_qkv_projections[[diffusers.UNet2DConditionModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L822)

Habilita las proyecciones QKV fusionadas. Para los módulos de autoatención, todas las matrices de proyección (es decir, consulta, clave y valor) se fusionan. Para los módulos de atención cruzada, las matrices de proyección de clave y valor se fusionan.

> [!WARNING] > Esta API es 🧪 experimental.

#### set_attention_slice[[diffusers.UNet2DConditionModel.set_attention_slice]]

```python
set_attention_slice(slice_size: str | int | list[int] = 'auto')
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L725)

**Parámetros:**

slice_size (`str` o `int` o `list(int)`, *opcional*, por defecto `"auto"`) : Cuando es `"auto"`, la entrada a las cabezas de atención se reduce a la mitad, por lo que la atención se calcula en dos pasos. Si es `"max"`, se ahorra la máxima cantidad de memoria ejecutando solo una porción a la vez. Si se proporciona un número, se utilizan tantas porciones como `attention_head_dim // slice_size`. En este caso, `attention_head_dim` debe ser un múltiplo de `slice_size`.

Habilitar el cálculo de atención segmentada.

Cuando esta opción está habilitada, el módulo de atención divide el tensor de entrada en fragmentos para calcular la atención en varios pasos. Esto es útil para ahorrar algo de memoria a cambio de una pequeña disminución en la velocidad.

#### set_default_attn_processor[[diffusers.UNet2DConditionModel.set_default_attn_processor]]

```python
set_default_attn_processor()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L710)

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

#### unfuse_qkv_projections[[diffusers.UNet2DConditionModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L843)

Desactiva la proyección QKV fusionada si está habilitada.

> [!WARNING] > Esta API es 🧪 experimental.

## UNet2DConditionOutput[[diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput]]

#### diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput[[diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput]]

```python
diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput(sample: Tensor = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L64)

**Parámetros:**

sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) : Los estados ocultos de salida condicionados a la entrada `encoder_hidden_states`. Salida de la última capa del modelo.

La salida de [UNet2DConditionModel](/docs/diffusers/main/es/api/models/unet2d-cond#diffusers.UNet2DConditionModel).