# UVit2DModel

El modelo [U-ViT](https://hf.co/papers/2301.11093) es un UNet basado en vision transformer (ViT). Este modelo incorpora elementos de ViT (considera todas las entradas, como el tiempo, las condiciones y los parches de imagen con ruido, como tokens) y de UNet (conexiones de salto largas entre las capas superficiales y profundas). La conexión de salto es importante para predecir características a nivel de píxel. Se aplica un bloque convolucional adicional de 3x3 antes de la salida final para mejorar la calidad de la imagen.

El resumen del artículo es:

*Actualmente, aplicar modelos de difusión en el espacio de píxeles de imágenes de alta resolución es difícil. En su lugar, los enfoques existentes se centran en la difusión en espacios de menor dimensión (difusión latente) o en múltiples niveles de superresolución de generación, conocidos como cascadas. La desventaja es que estos enfoques añaden complejidad adicional al marco de difusión. Este trabajo busca mejorar la difusión de desruido para imágenes de alta resolución manteniendo el modelo lo más simple posible. El artículo se centra en la pregunta de investigación: ¿Cómo se puede entrenar un modelo estándar de difusión de desruido en imágenes de alta resolución y, aun así, obtener un rendimiento comparable a estos enfoques alternativos? Los cuatro hallazgos principales son: 1) el programa de ruido debe ajustarse para imágenes de alta resolución, 2) es suficiente escalar solo una parte particular de la arquitectura, 3) se debe añadir dropout en ubicaciones específicas de la arquitectura y 4) el muestreo descendente es una estrategia efectiva para evitar mapas de características de alta resolución. Combinando estas técnicas simples pero efectivas, logramos el estado del arte en la generación de imágenes entre los modelos de difusión, sin modificadores de muestreo, en ImageNet.*

## UVit2DModel[[diffusers.UVit2DModel]]

#### diffusers.UVit2DModel[[diffusers.UVit2DModel]]

```python
diffusers.UVit2DModel(hidden_size: int = 1024, use_bias: bool = False, hidden_dropout: float = 0.0, cond_embed_dim: int = 768, micro_cond_encode_dim: int = 256, micro_cond_embed_dim: int = 1280, encoder_hidden_size: int = 768, vocab_size: int = 8256, codebook_size: int = 8192, in_channels: int = 768, block_out_channels: int = 768, num_res_blocks: int = 3, downsample: bool = False, upsample: bool = False, block_num_heads: int = 12, num_hidden_layers: int = 22, num_attention_heads: int = 16, attention_dropout: float = 0.0, intermediate_size: int = 2816, layer_norm_eps: float = 1e-06, ln_elementwise_affine: bool = True, sample_size: int = 64)
```

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

#### forward[[diffusers.UVit2DModel.forward]]

```python
forward(input_ids, encoder_hidden_states, pooled_text_emb, micro_conds, cross_attention_kwargs = None)
```

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

**Parámetros:**

input_ids (`torch.LongTensor`) : ids de los tokens de la imagen latente enmascarada, con forma `(batch_size, height, width)`.

encoder_hidden_states (`torch.Tensor`) : Embeddings condicionales (embeddings calculados a partir de las condiciones de entrada, como los prompts) a utilizar.

pooled_text_emb (`torch.Tensor`) : Embeddings de texto agrupados utilizados para una condición adicional.

micro_conds (`torch.Tensor`) : Valores de micro-condicionamiento que se incrustan y combinan con `pooled_text_emb`.

cross_attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor`.

**Devuelve:** `torch.Tensor`

Los logits sobre el codebook para cada token de imagen, de forma `(batch_size, codebook_size, height, width)`.

#### set_default_attn_processor[[diffusers.UVit2DModel.set_default_attn_processor]]

```python
set_default_attn_processor()
```

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

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

## UVit2DConvEmbed[[diffusers.models.unets.uvit_2d.UVit2DConvEmbed]]

#### diffusers.models.unets.uvit_2d.UVit2DConvEmbed[[diffusers.models.unets.uvit_2d.UVit2DConvEmbed]]

```python
diffusers.models.unets.uvit_2d.UVit2DConvEmbed(in_channels, block_out_channels, vocab_size, elementwise_affine, eps, bias)
```

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

## UVitBlock[[diffusers.models.unets.uvit_2d.UVitBlock]]

#### diffusers.models.unets.uvit_2d.UVitBlock[[diffusers.models.unets.uvit_2d.UVitBlock]]

```python
diffusers.models.unets.uvit_2d.UVitBlock(channels, num_res_blocks: int, hidden_size, hidden_dropout, ln_elementwise_affine, layer_norm_eps, use_bias, block_num_heads, attention_dropout, downsample: bool, upsample: bool)
```

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

## ConvNextBlock[[diffusers.models.unets.uvit_2d.ConvNextBlock]]

#### diffusers.models.unets.uvit_2d.ConvNextBlock[[diffusers.models.unets.uvit_2d.ConvNextBlock]]

```python
diffusers.models.unets.uvit_2d.ConvNextBlock(channels, layer_norm_eps, ln_elementwise_affine, use_bias, hidden_dropout, hidden_size, res_ffn_factor = 4)
```

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

## ConvMlmLayer[[diffusers.models.unets.uvit_2d.ConvMlmLayer]]

#### diffusers.models.unets.uvit_2d.ConvMlmLayer[[diffusers.models.unets.uvit_2d.ConvMlmLayer]]

```python
diffusers.models.unets.uvit_2d.ConvMlmLayer(block_out_channels: int, in_channels: int, use_bias: bool, ln_elementwise_affine: bool, layer_norm_eps: float, codebook_size: int)
```

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