# AutoencoderKLQwenImage21

L'auto-encodeur variationnel à 64 canaux utilisé par Qwen-Image 2.1. Il compresse spatialement par un facteur de 16, et ses `latents_mean` / `latents_std` par canal font partie de la configuration plutôt que d'être un simple facteur d'échelle.

```python
import torch
from diffusers import AutoencoderKLQwenImage21

vae = AutoencoderKLQwenImage21.from_pretrained("Qwen/Qwen-Image-2.1", subfolder="vae", dtype=torch.bfloat16)
```

## AutoencoderKLQwenImage21[[diffusers.AutoencoderKLQwenImage21]]

#### diffusers.AutoencoderKLQwenImage21[[diffusers.AutoencoderKLQwenImage21]]

```python
diffusers.AutoencoderKLQwenImage21(base_dim: int = 96, decoder_base_dim: int | None = 144, z_dim: int = 64, dim_mult: list[int] = [1, 2, 4, 8, 8], num_res_blocks: int = 2, attn_scales: list[float] = [], temperal_downsample: list[bool] = [False, True, True, True], dropout: float = 0.0, latents_mean: list[float] = [0.5126, 0.7721, -0.0631, 1.3506, -0.7855, -2.1025, -0.3458, 1.3722, 1.8873, -1.7177, -0.651, 0.2732, 0.7562, -0.6163, -1.0277, 3.8363, 2.021, 0.0472, 0.932, 2.0087, 2.4954, -0.1391, -1.4249, 1.8464, -0.5236, 1.2826, 3.7046, -1.3035, 2.7286, -1.4518, -1.9036, -1.9955, -0.0342, -1.0265, -0.7636, 3.0555, 0.0746, -3.0751, -0.1076, 1.7376, -1.0914, -1.9435, -0.2784, -1.368, 0.4809, -0.4433, 0.3764, 0.5729, -2.0595, 1.096, -1.326, -2.0211, -5.0179, 0.5275, 4.0162, 1.8505, 0.3026, 1.9373, 1.4937, 0.2632, 0.5547, -1.7121, -0.1562, 0.0304], latents_std: list[float] = [3.2001, 3.2936, 3.4321, 3.0091, 3.1061, 4.0379, 4.0705, 3.791, 3.0785, 3.65, 3.9308, 3.0904, 2.8778, 3.7675, 3.732, 5.0756, 3.2864, 4.0397, 3.1317, 4.0443, 2.9249, 3.9454, 3.0988, 4.2489, 3.4896, 3.8513, 3.9323, 3.4719, 3.7498, 4.283, 3.5694, 4.2467, 3.9037, 3.2947, 5.077, 3.5075, 3.27, 3.4767, 2.8063, 5.1125, 3.5327, 4.7833, 3.1286, 4.1819, 3.8527, 3.8312, 3.5605, 4.3875, 3.9624, 4.0168, 3.5643, 4.055, 5.5614, 4.2963, 4.408, 3.4959, 3.8747, 3.7608, 3.5735, 3.149, 3.7662, 3.6746, 3.4563, 3.8161], is_residual: bool = True, in_channels: int = 4, out_channels: int = 4, patch_size: int | None = None, scale_factor_temporal: int | None = 8, scale_factor_spatial: int | None = 16)
```

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

Un modèle VAE avec perte KL pour encoder des vidéos en latents et décoder des représentations latentes en vidéos. Introduit dans [Qwen Image 2].

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

#### decode[[diffusers.AutoencoderKLQwenImage21.decode]]

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

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

**Paramètres :**

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

return_dict (`bool`, *facultatif*, 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.

#### encode[[diffusers.AutoencoderKLQwenImage21.encode]]

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

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

**Paramètres :**

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

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

**Retourne :**

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

Encode un lot d'images en latents.

#### enable_tiling[[diffusers.AutoencoderKLQwenImage21.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_kl_qwenimage21.py#L1207)

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

Active le décodage VAE par tuiles. Lorsque cette option est activée, le VAE 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.AutoencoderKLQwenImage21.forward]]

```python
forward(sample: Tensor, sample_posterior: bool = False, 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_kl_qwenimage21.py#L1532)

**Paramètres :**

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

sample_posterior (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut échantillonner à partir de la distribution a posteriori plutôt que de prendre son mode.

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*) : Générateur utilisé lorsque `sample_posterior` est `True`.

**Retourne :** [DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) ou `tuple`

[DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) si `return_dict` est True, sinon un simple `tuple`.

#### tiled_decode[[diffusers.AutoencoderKLQwenImage21.tiled_decode]]

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

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

**Paramètres :**

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

return_dict (`bool`, *facultatif*, 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 à l'aide d'un décodeur tuilé.

#### tiled_encode[[diffusers.AutoencoderKLQwenImage21.tiled_encode]]

```python
tiled_encode(x: Tensor)
```

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

**Paramètres :**

x (`torch.Tensor`) : Lot d'entrée de vidéos.

**Retourne :** `torch.Tensor`

La représentation latente des vidéos encodées.

Encoder un lot d'images à l'aide d'un encodeur tuilé.

## AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

#### diffusers.models.modeling_outputs.AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

```python
diffusers.models.modeling_outputs.AutoencoderKLOutput(latent_dist: DiagonalGaussianDistribution)
```

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

**Paramètres :**

latent_dist (`DiagonalGaussianDistribution`) : Sorties encodées de `Encoder` représentées par la moyenne et le logvar de `DiagonalGaussianDistribution`. `DiagonalGaussianDistribution` permet d'échantillonner des latents à partir de la distribution.

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

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