# Tiny AutoEncoder

Tiny AutoEncoder for Stable Diffusion (TAESD) a été introduit dans [madebyollin/taesd](https://github.com/madebyollin/taesd) par Ollin Boer Bohan. Il s'agit d'une version distillée et compacte du VAE de Stable Diffusion, capable de décoder les latents d'un [StableDiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) ou d'un [StableDiffusionXLPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline) quasi instantanément.

Pour l'utiliser avec Stable Diffusion v-2.1 :

```python
import torch
from diffusers import DiffusionPipeline, AutoencoderTiny

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1-base", dtype=torch.float16
)
pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", dtype=torch.float16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "slice of delicious New York-style berry cheesecake"
image = pipe(prompt, num_inference_steps=25).images[0]
image
```

Pour utiliser avec Stable Diffusion XL 1.0

```python
import torch
from diffusers import DiffusionPipeline, AutoencoderTiny

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
)
pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesdxl", dtype=torch.float16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "slice of delicious New York-style berry cheesecake"
image = pipe(prompt, num_inference_steps=25).images[0]
image
```

## AutoencoderTiny[[diffusers.AutoencoderTiny]]

#### diffusers.AutoencoderTiny[[diffusers.AutoencoderTiny]]

```python
diffusers.AutoencoderTiny(in_channels: int = 3, out_channels: int = 3, encoder_block_out_channels: tuple[int, ...] = (64, 64, 64, 64), decoder_block_out_channels: tuple[int, ...] = (64, 64, 64, 64), act_fn: str = 'relu', upsample_fn: str = 'nearest', latent_channels: int = 4, upsampling_scaling_factor: int = 2, num_encoder_blocks: tuple[int, ...] = (1, 3, 3, 3), num_decoder_blocks: tuple[int, ...] = (3, 3, 3, 1), latent_magnitude: int = 3, latent_shift: float = 0.5, force_upcast: bool = False, scaling_factor: float = 1.0, shift_factor: float = 0.0)
```

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

**Paramètres :**

in_channels (`int`, *facultatif*, valeur par défaut 3) : Nombre de canaux dans l'image d'entrée.

out_channels (`int`,  *facultatif*, valeur par défaut 3) : Nombre de canaux dans la sortie.

encoder_block_out_channels (`tuple[int]`, *facultatif*, par défaut `(64, 64, 64, 64)`) : tuple d'entiers représentant le nombre de canaux de sortie pour chaque bloc d'encodeur. La longueur du tuple doit être égale au nombre de blocs d'encodeur.

decoder_block_out_channels (`tuple[int]`, *facultatif*, par défaut `(64, 64, 64, 64)`) : tuple d'entiers représentant le nombre de canaux de sortie pour chaque bloc du décodeur. La longueur du tuple doit être égale au nombre de blocs du décodeur.

act_fn (`str`, *facultatif*, valeur par défaut `"relu"`) : Fonction d'activation à utiliser dans tout le modèle.

latent_channels (`int`, *facultatif*, valeur par défaut 4) : Nombre de canaux dans la représentation latente. L'espace latent agit comme une représentation compressée de l'image d'entrée.

upsampling_scaling_factor (`int`, *facultatif*, valeur par défaut 2) : Facteur d'échelle pour le suréchantillonnage dans le décodeur. Il détermine la taille de l'image de sortie lors du processus de suréchantillonnage.

num_encoder_blocks (`tuple[int]`, *facultatif*, valeur par défaut `(1, 3, 3, 3)`) : tuple d'entiers représentant le nombre de blocs d'encodeur à chaque étape du processus d'encodage. La longueur du tuple doit être égale au nombre d'étapes de l'encodeur. Chaque étape possède un nombre différent de blocs d'encodeur.

num_decoder_blocks (`tuple[int]`, *facultatif*, valeur par défaut `(3, 3, 3, 1)`) : tuple d'entiers représentant le nombre de blocs décodeur à chaque étape du processus de décodage. La longueur du tuple doit être égale au nombre d'étapes du décodeur. Chaque étape possède un nombre différent de blocs décodeur.

latent_magnitude (`float`, *facultatif*, valeur par défaut 3.0) : Magnitude de la représentation latente. Ce paramètre met à l'échelle les valeurs de la représentation latente afin de contrôler le degré de préservation des informations.

latent_shift (float, *facultatif*, valeur par défaut 0.5) : Décalage appliqué à la représentation latente. Ce paramètre contrôle le centre de l'espace latent.

scaling_factor (`float`, *facultatif*, valeur par défaut 1.0) : L'écart-type par composante de l'espace latent entraîné, calculé à l'aide du premier lot du jeu de données d'entraînement. Il est utilisé pour mettre à l'échelle l'espace latent afin 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`. Pour plus de détails, consultez les sections 4.3.2 et D.1 de l'article [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752). Cependant, pour ce Autoencoder, aucun facteur d'échelle de ce type n'a été utilisé, d'où la valeur par défaut de 1.0.

force_upcast (`bool`, *facultatif*, par défaut `False`) : Si activé, force le VAE à s’exécuter en float32 pour les pipelines à haute résolution d’image, tels que SD-XL. Le VAE peut être affiné / entraîné sur une plage inférieure sans perdre trop de précision, auquel cas `force_upcast` peut être défini sur `False` (voir ce [AutoEncoder](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix) compatible fp16).

Un petit modèle VAE distillé pour encoder des images en latents et décoder des représentations latentes en images.

[AutoencoderTiny](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_tiny#diffusers.AutoencoderTiny) est un wrapper autour de l'implémentation originale de `TAESD`.

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

#### forward[[diffusers.AutoencoderTiny.forward]]

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

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

**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 :** `DecoderOutput` ou `tuple`

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

#### scale_latents[[diffusers.AutoencoderTiny.scale_latents]]

```python
scale_latents(x: Tensor)
```

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

latents bruts -> [0, 1]

#### unscale_latents[[diffusers.AutoencoderTiny.unscale_latents]]

```python
unscale_latents(x: Tensor)
```

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

[0, 1] -> latents bruts

## AutoencoderTinyOutput[[diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput]]

#### diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput[[diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput]]

```python
diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput(latents: Tensor)
```

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

**Paramètres :**

latents (`torch.Tensor`) : Sorties encodées du `Encoder`.

Sortie de la méthode d'encodage d'AutoencoderTiny.