# UVit2DModel

Le modèle [U-ViT](https://hf.co/papers/2301.11093) est un UNet basé sur un vision transformer (ViT). Ce modèle intègre des éléments du ViT (considère toutes les entrées, telles que le temps, les conditions et les patches d'image bruités, comme des tokens) et de l'UNet (connexions de saut longues entre les couches superficielles et profondes). La connexion de saut est importante pour la prédiction des caractéristiques au niveau des pixels. Un bloc convolutif 3x3 supplémentaire est appliqué avant la sortie finale pour améliorer la qualité de l'image.

L'abstract de l'article est :

*Actuellement, l’application de modèles de diffusion dans l’espace pixel d’images haute résolution est difficile. Les approches existantes se concentrent plutôt sur la diffusion dans des espaces de plus faible dimension (diffusion latente) ou sur plusieurs niveaux de super-résolution de génération, appelés cascades. L’inconvénient est que ces approches ajoutent une complexité supplémentaire au cadre de diffusion. Cet article vise à améliorer la diffusion de débruitage pour les images haute résolution tout en gardant le modèle aussi simple que possible. L’article est centré sur la question de recherche suivante : comment entraîner des modèles de diffusion de débruitage standard sur des images haute résolution et obtenir tout de même des performances comparables à ces approches alternatives ? Les quatre principaux résultats sont : 1) le calendrier de bruit doit être ajusté pour les images haute résolution, 2) il suffit de mettre à l’échelle une partie particulière de l’architecture, 3) un dropout doit être ajouté à des emplacements spécifiques de l’architecture, et 4) le sous-échantillonnage est une stratégie efficace pour éviter les cartes de caractéristiques haute résolution. En combinant ces techniques simples mais efficaces, nous atteignons l’état de l’art en génération d’images parmi les modèles de diffusion, sans modificateurs d’échantillonnage, sur 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)
```

[Source](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)
```

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

**Paramètres :**

input_ids (`torch.LongTensor`) : Identifiants des jetons de l'image latente masquée, avec la forme `(batch_size, height, width)`.

encoder_hidden_states (`torch.Tensor`) : Embeddings conditionnels (embeddings calculés à partir des conditions d'entrée telles que les prompts) à utiliser.

pooled_text_emb (`torch.Tensor`) : Embeddings de texte agrégés utilisés pour un conditionnement supplémentaire.

micro_conds (`torch.Tensor`) : Valeurs de micro-conditionnement qui sont intégrées et combinées avec `pooled_text_emb`.

cross_attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor`.

**Retourne :** `torch.Tensor`

Les logits sur le codebook pour chaque jeton d'image, de forme `(batch_size, codebook_size, height, width)`.

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

```python
set_default_attn_processor()
```

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

Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut.

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

[Source](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)
```

[Source](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)
```

[Source](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)
```

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