# AutoencoderDC

Le modèle d'auto-encodeur 2D utilisé dans [SANA](https://huggingface.co/papers/2410.10629) et introduit dans [DCAE](https://huggingface.co/papers/2410.10733) par les auteurs Junyu Chen\*, Han Cai\*, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han du MIT HAN Lab.

L'abstract de l'article est :

*Nous présentons Deep Compression Autoencoder (DC-AE), une nouvelle famille de modèles auto-encodeurs destinée à accélérer les modèles de diffusion haute résolution. Les modèles auto-encodeurs existants ont démontré des résultats impressionnants avec un ratio de compression spatiale modéré (par exemple, 8x), mais échouent à maintenir une précision de reconstruction satisfaisante pour des ratios de compression spatiale élevés (par exemple, 64x). Nous relevons ce défi en introduisant deux techniques clés : (1) l'auto-encodage résiduel, où nous concevons nos modèles pour apprendre des résidus basés sur les caractéristiques transformées espace-vers-canal afin d'atténuer la difficulté d'optimisation des auto-encodeurs à forte compression spatiale ; (2) l'adaptation découplée haute résolution, une stratégie d'entraînement découplée en trois phases efficace pour atténuer la pénalité de généralisation des auto-encodeurs à forte compression spatiale. Grâce à ces conceptions, nous améliorons le ratio de compression spatiale de l'auto-encodeur jusqu'à 128 tout en maintenant la qualité de reconstruction. En appliquant notre DC-AE aux modèles de diffusion latente, nous obtenons une accélération significative sans perte de précision. Par exemple, sur ImageNet 512x512, notre DC-AE offre une accélération d'inférence de 19,1x et une accélération d'entraînement de 17,9x sur GPU H100 pour UViT-H, tout en atteignant un FID meilleur, par rapport à l'auto-encodeur SD-VAE-f8 largement utilisé. Notre code est disponible à [cette URL https](https://github.com/mit-han-lab/efficientvit).*

Les modèles DCAE suivants sont publiés et pris en charge dans Diffusers.

| Format Diffusers | Format d'origine |
|:----------------:|:---------------:|
| [`mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-sana-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0)
| [`mit-han-lab/dc-ae-f32c32-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0)
| [`mit-han-lab/dc-ae-f32c32-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0)
| [`mit-han-lab/dc-ae-f64c128-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f64c128-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0)
| [`mit-han-lab/dc-ae-f64c128-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f64c128-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0)
| [`mit-han-lab/dc-ae-f128c512-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0)
| [`mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0)

Ce modèle a été contribué par [lawrence-cj](https://github.com/lawrence-cj).

Charger un modèle au format Diffusers avec [from_pretrained()](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin.from_pretrained).

```python
from diffusers import AutoencoderDC

ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", dtype=torch.float32).to("cuda")  # or "mps", "xpu", "cpu"
```

## Charger un modèle dans Diffusers via `from_single_file`

```python
from difusers import AutoencoderDC

ckpt_path = "https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0/blob/main/model.safetensors"
model = AutoencoderDC.from_single_file(ckpt_path) 

```

Le modèle `AutoencoderDC` dispose de variantes de points de contrôle en fichier unique `in` et `mix` qui possèdent des clés de point de contrôle identiques, mais utilisent des facteurs d’échelle différents. Diffusers ne peut pas déduire automatiquement le fichier de configuration correct à utiliser avec le modèle sur la base du seul point de contrôle et se rabattra sur la configuration de la variante `mix`. Pour remplacer la configuration déterminée automatiquement, veuillez utiliser l’argument `config` lors de l’utilisation du chargement en fichier unique avec des points de contrôle de la variante `in`.

```python
from diffusers import AutoencoderDC

ckpt_path = "https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0/blob/main/model.safetensors"
model = AutoencoderDC.from_single_file(ckpt_path, config="mit-han-lab/dc-ae-f128c512-in-1.0-diffusers")
```

## AutoencoderDC[[diffusers.AutoencoderDC]]

#### diffusers.AutoencoderDC[[diffusers.AutoencoderDC]]

```python
diffusers.AutoencoderDC(in_channels: int = 3, latent_channels: int = 32, attention_head_dim: int = 32, encoder_block_types: str | tuple[str] = 'ResBlock', decoder_block_types: str | tuple[str] = 'ResBlock', encoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), decoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), encoder_layers_per_block: tuple[int, ...] = (2, 2, 2, 3, 3, 3), decoder_layers_per_block: tuple[int, ...] = (3, 3, 3, 3, 3, 3), encoder_qkv_multiscales: tuple[tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), decoder_qkv_multiscales: tuple[tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), upsample_block_type: str = 'pixel_shuffle', downsample_block_type: str = 'pixel_unshuffle', decoder_norm_types: str | tuple[str] = 'rms_norm', decoder_act_fns: str | tuple[str] = 'silu', encoder_out_shortcut: bool = True, decoder_in_shortcut: bool = True, decoder_conv_act_fn: str = 'relu', scaling_factor: float = 1.0)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L380)

**Paramètres :**

in_channels (`int`, par défaut `3`) : Le nombre de canaux d'entrée dans les échantillons.

latent_channels (`int`, par défaut `32`) : Le nombre de canaux dans la représentation de l'espace latent.

encoder_block_types (`str | tuple[str]`, par défaut `"ResBlock"`) : Le(s) type(s) de bloc à utiliser dans l'encodeur.

decoder_block_types (`str | tuple[str]`, par défaut `"ResBlock"`) : Le(s) type(s) de bloc à utiliser dans le décodeur.

encoder_block_out_channels (`tuple[int, ...]`, par défaut `(128, 256, 512, 512, 1024, 1024)`) : Le nombre de canaux de sortie pour chaque bloc dans l'encodeur.

decoder_block_out_channels (`tuple[int, ...]`, par défaut `(128, 256, 512, 512, 1024, 1024)`) : Le nombre de canaux de sortie pour chaque bloc du décodeur.

encoder_layers_per_block (`tuple[int]`, par défaut `(2, 2, 2, 3, 3, 3)`) : Le nombre de couches par bloc dans l'encodeur.

decoder_layers_per_block (`tuple[int]`, defaults to `(3, 3, 3, 3, 3, 3)`) : The number of layers per block in the decoder.

encoder_qkv_multiscales (`tuple[tuple[int, ...], ...]`, par défaut `((), (), (), (5,), (5,), (5,))`) : Configurations multi-échelles pour les transformations QKV (query-key-value) de l'encodeur.

decoder_qkv_multiscales (`tuple[tuple[int, ...], ...]`, par défaut `((), (), (), (5,), (5,), (5,))`) : Configurations multi-échelles pour les transformations QKV (query-key-value) du décodeur.

upsample_block_type (`str`, par défaut `"pixel_shuffle"`) : Le type de bloc à utiliser pour le rééchantillonnage par interpolation (upsampling) dans le décodeur.

downsample_block_type (`str`, par défaut `"pixel_unshuffle"`) : Le type de bloc à utiliser pour le sous-échantillonnage dans l'encodeur.

decoder_norm_types (`str | tuple[str]`, par défaut `"rms_norm"`) : Le ou les types de normalisation à utiliser dans le décodeur.

decoder_act_fns (`str | tuple[str]`, par défaut `"silu"`) : La ou les fonctions d'activation à utiliser dans le décodeur.

encoder_out_shortcut  (`bool`, par défaut `True`) : Indique s'il faut utiliser un raccourci à la fin de l'encodeur.

decoder_in_shortcut (`bool`, par défaut `True`) : Indique s'il faut utiliser un raccourci au début du décodeur.

decoder_conv_act_fn (`str`, par défaut `"relu"`) : La fonction d'activation à utiliser à la fin du décodeur.

scaling_factor (`float`, par défaut `1.0`) : L'inverse multiplicatif de la racine carrée de la moyenne des carrés des caractéristiques latentes. Cela sert à mettre à l'échelle l'espace latent pour qu'il ait une variance unitaire lors de l'entraînement du modèle de diffusion. Les latents sont mis à l'échelle avec la formule `z = z * scaling_factor` avant d'être transmis au modèle de diffusion. Lors du décodage, les latents sont remis à l'échelle d'origine avec la formule : `z = 1 / scaling_factor * z`.

Un modèle Autoencoder introduit dans [DCAE](https://huggingface.co/papers/2410.10733) et utilisé dans [SANA](https://huggingface.co/papers/2410.10629).

Ce modèle hérite de [ModelMixin](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin). Consultez la documentation de la classe parente pour ses méthodes génériques implémentées pour tous les modèles (tels que le téléchargement ou l'enregistrement).

#### encode[[diffusers.AutoencoderDC.encode]]

```python
encode(x: Tensor, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L548)

**Paramètres :**

x (`torch.Tensor`) : Lot d'images en entrée.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `~models.vae.EncoderOutput` plutôt qu'un simple tuple.

**Retourne :**

Les représentations latentes des vidéos encodées. Si `return_dict` est True, un `~models.vae.EncoderOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

Encode un lot d'images en latents.

#### decode[[diffusers.AutoencoderDC.decode]]

```python
decode(z: Tensor, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L582)

**Paramètres :**

z (`torch.Tensor`) : Lot d'entrée de vecteurs latents.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `~models.vae.DecoderOutput` plutôt qu'un simple tuple.

**Retourne :** `~models.vae.DecoderOutput` ou `tuple`

Si `return_dict` est True, un `~models.vae.DecoderOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

Décoder un lot d'images.

#### enable_tiling[[diffusers.AutoencoderDC.enable_tiling]]

```python
enable_tiling(tile_sample_min_height: int | None = None, tile_sample_min_width: int | None = None, tile_sample_stride_height: float | None = None, tile_sample_stride_width: float | None = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L506)

**Paramètres :**

tile_sample_min_height (`int`, *facultatif*) : La hauteur minimale requise pour qu'un échantillon soit séparé en tuiles le long de la dimension de hauteur.

tile_sample_min_width (`int`, *facultatif*) : La largeur minimale requise pour qu'un échantillon soit séparé en tuiles le long de la dimension de la largeur.

tile_sample_stride_height (`int`, *facultatif*) : La quantité minimale de chevauchement entre deux tuiles verticales consécutives. Cela permet de s'assurer qu'aucun artefact de tuilage n'est produit le long de la dimension de hauteur.

tile_sample_stride_width (`int`, *facultatif*) : Le pas entre deux tuiles horizontales consécutives. Cela permet de s'assurer qu'aucun artefact de tuilage n'est produit le long de la dimension de largeur.

Activer le décodage AE par tuiles. Lorsque cette option est activée, l’AE divise le tenseur d’entrée en tuiles pour effectuer le décodage et l’encodage en plusieurs étapes. Cela est utile pour économiser une grande quantité de mémoire et pour permettre le traitement d’images plus grandes.

#### forward[[diffusers.AutoencoderDC.forward]]

```python
forward(sample: Tensor, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L708)

**Paramètres :**

sample (`torch.Tensor`) : Échantillon d'entrée.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `DecoderOutput` plutôt qu'un simple tuple.

**Retourne :** `~models.vae.DecoderOutput` ou `tuple`

Si `return_dict` est True, un `~models.vae.DecoderOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

## DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

#### diffusers.models.autoencoders.vae.DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

```python
diffusers.models.autoencoders.vae.DecoderOutput(sample: Tensor, commit_loss: typing.Optional[torch.FloatTensor] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/vae.py#L49)

**Paramètres :**

sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)`) : L'échantillon de sortie décodé de la dernière couche du modèle.

Sortie de la méthode de décodage.