Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /fr /api /models /autoencoder_rae.md

mishig

8 days ago

preview code

download

raw

9.38 kB

# 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/main/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/main/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/main/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/main/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/main/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/main/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.

Xet Storage Details

Size:: 9.38 kB
Xet hash:: b07f831ac8c500f5c05aadc240f707c5f9c62731971b3fee2b0f02265dd26d99

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# 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/main/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/main/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/main/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/main/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/main/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/main/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.