# UNet2DConditionModel

O modelo [UNet](https://huggingface.co/papers/1505.04597) foi originalmente introduzido por Ronneberger et al. para segmentação de imagens biomédicas, mas também é comumente usado no 🤗 Diffusers porque ele gera imagens com o mesmo tamanho da entrada. Ele é um dos componentes mais importantes de um sistema de difusão, pois facilita o processo de difusão em si. Existem várias variantes do modelo UNet no 🤗 Diffusers, dependendo do número de dimensões e de se trata de um modelo condicional ou não. Este é um modelo UNet condicional 2D.

O resumo do artigo é:

*Há amplo consenso de que o treinamento bem-sucedido de redes profundas requer milhares de amostras de treinamento anotadas. Neste artigo, apresentamos uma rede e uma estratégia de treinamento que dependem do uso intenso de aumento de dados para utilizar as amostras anotadas disponíveis de forma mais eficiente. A arquitetura consiste em um caminho contrativo para capturar o contexto e um caminho expansivo simétrico que permite a localização precisa. Mostramos que uma rede como essa pode ser treinada de ponta a ponta a partir de muito poucas imagens e supera o melhor método anterior (uma rede convolucional de janela deslizante) no desafio ISBI para segmentação de estruturas neuronais em pilhas de microscopia eletrônica. Usando a mesma rede treinada em imagens de microscopia de luz transmitida (contraste de fase e DIC), vencemos o desafio de rastreamento celular ISBI 2015 nessas categorias por uma grande margem. Além disso, a rede é rápida. A segmentação de uma imagem de 512x512 leva menos de um segundo em uma GPU recente. A implementação completa (baseada em Caffe) e as redes treinadas estão disponíveis em 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[str, ...] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str | None = 'UNetMidBlock2DCrossAttn', up_block_types: tuple[str, ...] = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int, ...] = (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)
```

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

**Parâmetros:**

sample_size (`int` ou `tuple[int, int]`, *opcional*, padrão `None`) : Altura e largura da amostra de entrada/saída.

in_channels (`int`, *opcional*, padrão 4) : Número de canais na amostra de entrada.

out_channels (`int`, *opcional*, padrão 4) : Número de canais na saída.

center_input_sample (`bool`, *opcional*, padrão `False`) : Se deve centralizar a amostra de entrada.

flip_sin_to_cos (`bool`, *opcional*, padrão `True`) : Se deve inverter o sin para cos no embedding de tempo.

freq_shift (`int`, *opcional*, padrão 0) : O deslocamento de frequência a ser aplicado ao embedding de tempo.

down_block_types (`tuple[str]`, *opcional*, padrão `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : A tupla de blocos de downsampling a serem usados.

mid_block_type (`str`, *opcional*, padrão `"UNetMidBlock2DCrossAttn"`) : Tipo de bloco para o meio do UNet, pode ser um de `UNetMidBlock2DCrossAttn`, `UNetMidBlock2D` ou `UNetMidBlock2DSimpleCrossAttn`. Se `None`, a camada do bloco intermediário é ignorada.

up_block_types (`tuple[str]`, *opcional*, padrão `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : A tupla de blocos de upsample a serem usados.

only_cross_attention(`bool` or `tuple[bool]`, *opcional*, padrão `False`) : Se deve incluir autoatenção nos blocos básicos do transformer, veja `BasicTransformerBlock`.

block_out_channels (`tuple[int]`, *opcional*, padrão `(320, 640, 1280, 1280)`) : A tupla de canais de saída para cada bloco.

layers_per_block (`int`, *opcional*, padrão 2) : O número de camadas por bloco.

downsample_padding (`int`, *opcional*, padrão 1) : O padding a ser usado para a convolução de downsampling.

mid_block_scale_factor (`float`, *opcional*, padrão 1.0) : O fator de escala a ser usado para o bloco intermediário.

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

act_fn (`str`, *opcional*, padrão `"silu"`) : A função de ativação a ser utilizada.

norm_num_groups (`int`, *opcional*, padrão 32) : O número de grupos a serem usados para a normalização. Se `None`, as camadas de normalização e ativação são ignoradas no pós-processamento.

norm_eps (`float`, *opcional*, padrão 1e-5) : O epsilon a ser usado para a normalização.

cross_attention_dim (`int` ou `tuple[int]`, *opcional*, padrão 1280) : A dimensão dos recursos de atenção cruzada.

transformer_layers_per_block (`int`, `tuple[int]` ou `tuple[tuple]` , *opcional*, padrão 1) : O número de blocos de transformador do tipo `BasicTransformerBlock`. Relevante apenas para `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

reverse_transformer_layers_per_block : (`tuple[tuple]`, *opcional*, padrão None): O número de blocos de transformador do tipo `BasicTransformerBlock`, nos blocos de amostragem ascendente da U-Net. Relevante apenas se `transformer_layers_per_block` for do tipo `tuple[tuple]` e para `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

encoder_hid_dim (`int`, *opcional*, padrão None) : Se `encoder_hid_dim_type` estiver definido, `encoder_hidden_states` será projetado da dimensão `encoder_hid_dim` para `cross_attention_dim`.

encoder_hid_dim_type (`str`, *opcional*, padrão `None`) : Se fornecido, o `encoder_hidden_states` e possivelmente outros embeddings são projetados para baixo para embeddings de texto de dimensão `cross_attention` de acordo com `encoder_hid_dim_type`.

attention_head_dim (`int`, *opcional*, padrão 8) : A dimensão dos cabeçalhos de atenção.

num_attention_heads (`int`, *opcional*) : O número de cabeças de atenção. Se não definido, o padrão é `attention_head_dim`

resnet_time_scale_shift (`str`, *opcional*, padrão `"default"`) : Configuração de deslocamento de escala de tempo para blocos ResNet (veja `ResnetBlock2D`). Escolha entre `default` ou `scale_shift`.

class_embed_type (`str`, *opcional*, padrão `None`) : O tipo de embedding de classe a ser usado, que é somado aos embeddings de tempo. Escolha entre `None`, `"timestep"`, `"identity"`, `"projection"` ou `"simple_projection"`.

addition_embed_type (`str`, *opcional*, padrão `None`) : Configura um embedding opcional que será somado aos embeddings de tempo. Escolha entre `None` ou "text". "text" usará a camada `TextTimeEmbedding`.

addition_time_embed_dim : (`int`, *opcional*, padrão `None`): Dimensão para os embeddings de timestep.

num_class_embeds (`int`, *opcional*, padrão `None`) : Dimensão de entrada da matriz de incorporação aprendível a ser projetada para `time_embed_dim`, ao realizar condicionamento de classe com `class_embed_type` igual a `None`.

time_embedding_type (`str`, *opcional*, padrão `positional`) : O tipo de incorporação de posição a ser usado para os passos de tempo. Escolha entre `positional` ou `fourier`.

time_embedding_dim (`int`, *opcional*, padrão `None`) : Uma substituição opcional para a dimensão do embedding de tempo projetado.

time_embedding_act_fn (`str`, *opcional*, padrão `None`) : Função de ativação opcional para usar apenas uma vez nos embeddings de tempo antes de serem passados para o restante da UNet. Escolha entre `silu`, `mish`, `gelu` e `swish`.

timestep_post_act (`str`, *opcional*, padrão `None`) : A segunda função de ativação a ser usada no incorporamento de passo de tempo. Escolha entre `silu`, `mish` e `gelu`.

time_cond_proj_dim (`int`, *opcional*, padrão `None`) : A dimensão da camada `cond_proj` no embedding de timestep.

conv_in_kernel (`int`, *opcional*, padrão `3`) : O tamanho do kernel da camada `conv_in`.

conv_out_kernel (`int`, *opcional*, padrão `3`) : O tamanho do kernel da camada `conv_out`.

projection_class_embeddings_input_dim (`int`, *opcional*) : A dimensão da entrada `class_labels` quando `class_embed_type="projection"`. Obrigatório quando `class_embed_type="projection"`.

class_embeddings_concat (`bool`, *opcional*, padrão `False`) : Se deve concatenar os embeddings de tempo com os embeddings de classe.

mid_block_only_cross_attention (`bool`, *opcional*, padrão `None`) : Se deve usar atenção cruzada com o bloco intermediário ao usar o `UNetMidBlock2DSimpleCrossAttn`. Se `only_cross_attention` for fornecido como um único booleano e `mid_block_only_cross_attention` for `None`, o valor de `only_cross_attention` é usado como o valor para `mid_block_only_cross_attention`. Caso contrário, o padrão é `False`.

Um modelo 2D UNet condicional que recebe uma amostra com ruído, um estado condicional e um passo de tempo e retorna uma saída com a forma da amostra.

Este modelo herda de [ModelMixin](/docs/diffusers/v0.43.0/pt/api/models/overview#diffusers.ModelMixin). Consulte a documentação da superclasse para seus métodos genéricos implementados para todos os modelos (como download ou salvamento).

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

```python
disable_freeu()
```

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

Desativa o mecanismo FreeU.

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

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

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

**Parâmetros:**

s1 (`float`) : Fator de escala para a etapa 1 para atenuar as contribuições dos recursos de skip. Isso é feito para mitigar o "efeito de sobre-suavização" no processo de desruidamento aprimorado.

s2 (`float`) : Fator de escala para a etapa 2 para atenuar as contribuições dos recursos de skip. Isso é feito para mitigar o "efeito de sobre-suavização" no processo aprimorado de remoção de ruído.

b1 (`float`) : Fator de escala para a etapa 1 para amplificar as contribuições dos recursos do backbone.

b2 (`float`) : Fator de escala para a etapa 2 para amplificar as contribuições dos recursos do backbone.

Ativa o mecanismo FreeU de https://huggingface.co/papers/2309.11497.

Os sufixos após os fatores de escala representam os blocos de estágio em que eles estão sendo aplicados.

Consulte o [repositório oficial](https://github.com/ChenyangSi/FreeU) para combinações de valores que são conhecidas por funcionar bem em diferentes pipelines, como Stable Diffusion v1, v2 e 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)
```

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

**Parâmetros:**

sample (`torch.Tensor`) : O tensor de entrada com ruído, com a seguinte forma `(batch, channel, height, width)`.

timestep (`torch.Tensor` ou `float` ou `int`) : O número de timesteps para desruidar uma entrada.

encoder_hidden_states (`torch.Tensor`) : Os estados ocultos do codificador com a forma `(batch, sequence_length, feature_dim)`.

class_labels (`torch.Tensor`, *opcional*, padrão `None`) : Rótulos de classe opcionais para condicionamento. Seus embeddings serão somados aos embeddings de timestep.

timestep_cond : (`torch.Tensor`, *opcional*, padrão `None`): embeddings condicionais para o timestep. Se fornecidos, os embeddings serão somados às amostras passadas pela camada `self.time_embedding` para obter os embeddings de timestep.

attention_mask (`torch.Tensor`, *opcional*, padrão `None`) : Uma máscara de atenção com forma `(batch, key_tokens)` é aplicada a `encoder_hidden_states`. Se `1`, a máscara é mantida; caso contrário, se `0`, ela é descartada. A máscara será convertida em um viés, que adiciona valores negativos grandes às pontuações de atenção correspondentes aos tokens "descartados".

cross_attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

added_cond_kwargs : (`dict`, *opcional*): Um dicionário de kwargs contendo embeddings adicionais que, se especificados, são adicionados aos embeddings que são passados para os blocos do UNet.

down_block_additional_residuals : (`tuple` de `torch.Tensor`, *opcional*): Uma tupla de tensores que, se especificada, é adicionada aos resíduos dos blocos down do unet.

mid_block_additional_residual : (`torch.Tensor`, *opcional*): Um tensor que, se especificado, é adicionado ao residual do bloco unet intermediário.

down_intrablock_additional_residuals (`tuple` de `torch.Tensor`, *opcional*) : resíduos adicionais a serem adicionados nos blocos de down do UNet, por exemplo, de modelos laterais do T2I-Adapter

encoder_attention_mask (`torch.Tensor`) : Uma máscara de atenção cruzada de forma `(batch, sequence_length)` é aplicada a `encoder_hidden_states`. Se `True`, a máscara é mantida; caso contrário, se `False`, ela é descartada. A máscara será convertida em um viés, que adiciona valores negativos grandes às pontuações de atenção correspondentes aos tokens "descartados".

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um [UNet2DConditionOutput](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) em vez de uma tupla simples.

**Retorna:** [UNet2DConditionOutput](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) ou `tuple`

Se `return_dict` for True, um [UNet2DConditionOutput](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é o tensor da amostra.

O método forward do [UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel).

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

```python
fuse_qkv_projections()
```

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

Ativa as projeções QKV fundidas. Para os módulos de autoatenção, todas as matrizes de projeção (ou seja, query, key, value) são fundidas. Para os módulos de atenção cruzada, as matrizes de projeção de key e value são fundidas.

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

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

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

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

**Parâmetros:**

slice_size (`str` ou `int` ou `list(int)`, *opcional*, padrão `"auto"`) : Quando `"auto"`, a entrada para as cabeças de atenção é reduzida pela metade, de modo que a atenção é calculada em duas etapas. Se `"max"`, a quantidade máxima de memória é economizada executando apenas uma fatia por vez. Se um número for fornecido, usa tantas fatias quanto `attention_head_dim // slice_size`. Nesse caso, `attention_head_dim` deve ser um múltiplo de `slice_size`.

Ative o cálculo de atenção fatiado.

Quando esta opção está habilitada, o módulo de atenção divide o tensor de entrada em fatias para calcular a atenção em várias etapas. Isso é útil para economizar memória em troca de uma pequena diminuição na velocidade.

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

```python
set_default_attn_processor()
```

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

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

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

```python
unfuse_qkv_projections()
```

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

Desativa a projeção QKV fundida, se estiver habilitada.

> [!WARNING] > Esta API é 🧪 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)
```

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

**Parâmetros:**

sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) : Os estados ocultos de saída condicionados à entrada `encoder_hidden_states`. Saída da última camada do modelo.

A saída de [UNet2DConditionModel](/docs/diffusers/v0.43.0/pt/api/models/unet2d-cond#diffusers.UNet2DConditionModel).