# AutoencoderRAE

Le modèle Representation Autoencoder (RAE) introduit dans [Diffusion Transformers with Representation Autoencoders](https://huggingface.co/papers/2510.11690) par Boyang Zheng, Nanye Ma, Shengbang Tong et Saining Xie de NYU VISIONx.

RAE combine un encodeur visuel pré-entraîné figé (DINOv2, SigLIP2 ou MAE) avec un décodeur de type ViT-MAE entraînable. Dans la recette d'entraînement en deux étapes de RAE, l'auto-encodeur est entraîné à l'étape 1 (reconstruction), puis un modèle de diffusion est entraîné sur l'espace latent résultant à l'étape 2 (génération).

Les modèles RAE suivants sont publiés et pris en charge dans Diffusers :

| Modèle | Encodeur | Forme latente (entrée de 224 px) |
|:------|:--------|:---------------------------|
| [`nyu-visionx/RAE-dinov2-wReg-base-ViTXL-n08`](https://huggingface.co/nyu-visionx/RAE-dinov2-wReg-base-ViTXL-n08) | DINOv2-base | 768 x 16 x 16 |
| [`nyu-visionx/RAE-dinov2-wReg-base-ViTXL-n08-i512`](https://huggingface.co/nyu-visionx/RAE-dinov2-wReg-base-ViTXL-n08-i512) | DINOv2-base (512 px) | 768 x 32 x 32 |
| [`nyu-visionx/RAE-dinov2-wReg-small-ViTXL-n08`](https://huggingface.co/nyu-visionx/RAE-dinov2-wReg-small-ViTXL-n08) | DINOv2-small | 384 x 16 x 16 |
| [`nyu-visionx/RAE-dinov2-wReg-large-ViTXL-n08`](https://huggingface.co/nyu-visionx/RAE-dinov2-wReg-large-ViTXL-n08) | DINOv2-large | 1024 x 16 x 16 |
| [`nyu-visionx/RAE-siglip2-base-p16-i256-ViTXL-n08`](https://huggingface.co/nyu-visionx/RAE-siglip2-base-p16-i256-ViTXL-n08) | SigLIP2-base | 768 x 16 x 16 |
| [`nyu-visionx/RAE-mae-base-p16-ViTXL-n08`](https://huggingface.co/nyu-visionx/RAE-mae-base-p16-ViTXL-n08) | MAE-base | 768 x 16 x 16 |

## Chargement d'un modèle pré-entraîné

```python
from diffusers import AutoencoderRAE

model = AutoencoderRAE.from_pretrained(
    "nyu-visionx/RAE-dinov2-wReg-base-ViTXL-n08"
).to("cuda").eval()  # or "mps", "xpu", "cpu"
```

## Encodage et décodage d'une image réelle

```python
import torch
from diffusers import AutoencoderRAE
from diffusers.utils import load_image
from torchvision.transforms.functional import to_tensor, to_pil_image

model = AutoencoderRAE.from_pretrained(
    "nyu-visionx/RAE-dinov2-wReg-base-ViTXL-n08"
).to("cuda").eval()  # or "mps", "xpu", "cpu"

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")
image = image.convert("RGB").resize((224, 224))
x = to_tensor(image).unsqueeze(0).to("cuda")  # (1, 3, 224, 224), values in [0, 1]

with torch.no_grad():
    latents = model.encode(x).latent        # (1, 768, 16, 16)
    recon = model.decode(latents).sample     # (1, 3, 256, 256)

recon_image = to_pil_image(recon[0].clamp(0, 1).cpu())
recon_image.save("recon.png")
```

## Normalisation latente

Certains points de contrôle préentraînés incluent des statistiques par canal `latents_mean` et `latents_std` pour normaliser l’espace latent. Lorsqu’elles sont présentes, `encode` et `decode` appliquent automatiquement la normalisation et la dénormalisation, respectivement.

```python
model = AutoencoderRAE.from_pretrained(
    "nyu-visionx/RAE-dinov2-wReg-base-ViTXL-n08"
).to("cuda").eval()  # or "mps", "xpu", "cpu"

# Latent normalization is handled automatically inside encode/decode
# when the checkpoint config includes latents_mean/latents_std.
with torch.no_grad():
    latents = model.encode(x).latent   # normalized latents
    recon = model.decode(latents).sample
```

## AutoencoderRAE[[diffusers.AutoencoderRAE]]

#### diffusers.AutoencoderRAE[[diffusers.AutoencoderRAE]]

```python
diffusers.AutoencoderRAE(encoder_type: str = 'dinov2', encoder_hidden_size: int = 768, encoder_patch_size: int = 14, encoder_num_hidden_layers: int = 12, decoder_hidden_size: int = 512, decoder_num_hidden_layers: int = 8, decoder_num_attention_heads: int = 16, decoder_intermediate_size: int = 2048, patch_size: int = 16, encoder_input_size: int = 224, image_size: int | None = None, num_channels: int = 3, encoder_norm_mean: list | None = None, encoder_norm_std: list | None = None, latents_mean: typing.Union[list, tuple, torch.Tensor, NoneType] = None, latents_std: typing.Union[list, tuple, torch.Tensor, NoneType] = None, noise_tau: float = 0.0, reshape_to_2d: bool = True, use_encoder_loss: bool = False, scaling_factor: float = 1.0)
```

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

**Paramètres :**

encoder_type (`str`, *facultatif*, par défaut `"dinov2"`) : Type d'encodeur figé à utiliser. L'un des `"dinov2"`, `"siglip2"` ou `"mae"`.

encoder_hidden_size (`int`, *facultatif*, par défaut `768`) : Taille cachée du modèle encodeur.

encoder_patch_size (`int`, *facultatif*, valeur par défaut `14`) : Taille du patch du modèle encodeur.

encoder_num_hidden_layers (`int`, *facultatif*, valeur par défaut `12`) : Nombre de couches cachées dans le modèle encodeur.

patch_size (`int`, *facultatif*, par défaut `16`) : Taille des patches du décodeur (utilisée pour l'unpatchify et la tête du décodeur).

encoder_input_size (`int`, *facultatif*, valeur par défaut `224`) : Taille d'entrée attendue par l'encodeur.

image_size (`int`, *facultatif*) : Taille de l'image de sortie du décodeur. Si `None`, elle est dérivée du nombre de jetons de l'encodeur et de `patch_size` comme dans RAE-main : `image_size = patch_size * sqrt(num_patches)`, où `num_patches = (encoder_input_size // encoder_patch_size) ** 2`.

num_channels (`int`, *facultatif*, par défaut `3`) : Nombre de canaux d'entrée/sortie.

encoder_norm_mean (`list`, *facultatif*, valeur par défaut `[0.485, 0.456, 0.406]`) : Moyenne par canal pour la normalisation de l'entrée de l'encodeur (valeurs par défaut d'ImageNet).

encoder_norm_std (`list`, *facultatif*, valeur par défaut `[0.229, 0.224, 0.225]`) : Écart-type par canal pour la normalisation de l'entrée de l'encodeur (valeurs par défaut d'ImageNet).

latents_mean (`list` ou `tuple`, *facultatif*) : Moyenne facultative pour la normalisation des latents. Les entrées de type Tensor sont acceptées et converties en listes sérialisables dans la configuration.

latents_std (`list` ou `tuple`, *facultatif*) : Écart-type facultatif pour la normalisation des latents. Les entrées de type Tensor sont acceptées et converties en listes sérialisables dans la configuration.

noise_tau (`float`, *facultatif*, valeur par défaut `0.0`) : Niveau de bruit pour l'entraînement (ajoute du bruit aux latents pendant l'entraînement).

reshape_to_2d (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut redimensionner les latents au format 2D (B, C, H, W).

use_encoder_loss (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser les états cachés de l'encodeur dans la perte (pour l'entraînement avancé).

Modèle Representation Autoencoder (RAE) pour encoder des images en latents et décoder des latents en images.

Ce modèle utilise un encodeur pré-entraîné figé (DINOv2, SigLIP2 ou MAE) avec un décodeur ViT entraînable pour reconstruire des images à partir de représentations apprises.

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 (téléchargement ou sauvegarde, par exemple).

#### encode[[diffusers.AutoencoderRAE.encode]]

```python
encode(x: Tensor, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None)
```

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

#### decode[[diffusers.AutoencoderRAE.decode]]

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

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

#### forward[[diffusers.AutoencoderRAE.forward]]

```python
forward(sample: Tensor, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None)
```

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

**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.

generator (`torch.Generator`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre l'échantillonnage déterministe.

**Retourne :** `DecoderOutput` ou `tuple`

Si `return_dict` est True, un `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.