# AutoencoderKLMiniMaxH3

Le modèle de variational autoencoder (VAE) vidéo avec perte KL utilisé dans [MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) par MiniMax. Il associe un encodeur CNN 3D causal à un décodeur ViT non causal et compresse 16x spatialement et 4x temporellement.

Trois éléments la distinguent de la plupart des auto-encodeurs de la bibliothèque :

- **Les latents sont normalisés par canal.** Il n'y a pas de `scaling_factor` : un pipeline encode avec `(latent - latents_mean) / latents_std` et décode avec `latent * latents_std + latents_mean`.
- **La convention des pixels est le RGB normalisé ImageNet sur une plage de base `[0, 1]`**, et non la plage habituelle `[-1, 1]`. `encode` s'attend à `(pixel - imagenet_mean) / imagenet_std` et `decode` renvoie des valeurs dans cet même espace, de sorte qu'un pipeline applique `sample * imagenet_std + imagenet_mean` et borne à `[0, 1]` avant le post-traitement.
- **Le tuilage spatial est activé par défaut.** MiniMax-H3 a été publié avec le tuilage activé pour l’encodage et le décodage, et les images publiées sont celles issues du tuilage fusionné ; le désactiver modifie donc la sortie. Utilisez `enable_tiling` pour modifier la géométrie des tuiles et `disable_tiling` pour le désactiver.

La géométrie temporelle est fixée par `clip_length` (17 trames de pixels par bloc d’encodeur) et `token_drop` (3 trames latentes finales supprimées par encodage), de sorte que `17 * n + 5` trames de pixels correspondent à `5 * n + 2` trames latentes.

```python
import torch
from diffusers import AutoencoderKLMiniMaxH3

vae = AutoencoderKLMiniMaxH3.from_pretrained(
    "MiniMaxAI/MiniMax-H3", subfolder="vae", dtype=torch.float32
).to("cuda")  # or "mps", "xpu", "cpu"
```

## AutoencoderKLMiniMaxH3[[diffusers.AutoencoderKLMiniMaxH3]]

#### diffusers.AutoencoderKLMiniMaxH3[[diffusers.AutoencoderKLMiniMaxH3]]

```python
diffusers.AutoencoderKLMiniMaxH3(in_channels: int = 3, out_channels: int = 3, latent_channels: int = 24, block_out_channels: tuple[int, ...] = (128, 256, 256, 512, 512, 1024), layers_per_block: int = 2, spatial_downsample_factors: tuple[int, ...] = (2, 2, 2, 2, 1, 1), temporal_downsample_factors: tuple[int, ...] = (1, 2, 2, 1, 1, 1), norm_num_groups: int = 32, norm_eps: float = 1e-06, spatial_padding_mode: str = 'reflect', decoder_num_layers: int = 36, decoder_num_attention_heads: int = 32, decoder_attention_head_dim: int = 64, decoder_num_register_tokens: int = 4, decoder_ffn_mult: int = 4, decoder_rope_theta: float = 100.0, decoder_rope_dim_ratio: float = 0.75, decoder_norm_eps: float = 1e-05, clip_length: int = 17, token_drop: int = 3, latents_mean: tuple[float, ...] = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), latents_std: tuple[float, ...] = (1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0))
```

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

Un modèle VAE doté d'un encodeur CNN 3D causal et d'un décodeur ViT non causal, utilisé dans [MiniMax-H3](https://huggingface.co/MiniMaxAI).

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

Les latents sont normalisés par canal avec `latents_mean` / `latents_std` plutôt qu’avec un `scaling_factor` ; un pipeline encode avec `(latent - latents_mean) / latents_std` et décode avec `latent * latents_std + latents_mean`.

La convention des pixels est le RGB normalisé ImageNet sur une plage de base `[0, 1]`, et non la plage habituelle `[-1, 1]` : `encode` s'attend à `(pixel - imagenet_mean) / imagenet_std` et `decode` renvoie des valeurs dans cet même espace, de sorte qu'un pipeline doit appliquer `sample * imagenet_std + imagenet_mean` (moyenne `(0.485, 0.456, 0.406)`, écart-type `(0.229, 0.224, 0.225)`) et limiter à `[0, 1]` avant le post-traitement.

La géométrie temporelle est fixée par `clip_length` (17 trames de pixels par bloc d’encodeur) et `token_drop` (3 trames latentes finales supprimées par encodage) : `17 * n + 5` trames de pixels correspondent à `5 * n + 2` trames latentes.

Contrairement à la plupart des autoencodeurs de la bibliothèque, le tuilage spatial est **activé par défaut** : MiniMax-H3 a été publié avec le tuilage activé pour l’encodage et le décodage, et les images publiées sont celles issues du tuilage fusionné, de sorte que la désactivation du tuilage modifie la sortie. Utilisez `enable_tiling` pour modifier la géométrie des tuiles et `disable_tiling` pour le désactiver.

#### encode[[diffusers.AutoencoderKLMiniMaxH3.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_minimax_h3.py#L855)

**Paramètres :**

x (`torch.Tensor`) : Lot d'entrée de vidéos, de forme `(batch_size, in_channels, num_frames, height, width)`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [AutoencoderKLOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.modeling_outputs.AutoencoderKLOutput) plutôt qu'un simple tuple.

**Retourne :**

La distribution latente des vidéos encodées. Notez que MiniMax-H3 normalise ensuite les latentes échantillonnées avec `latents_mean` / `latents_std`.

Encoder un lot de vidéos en latents.

#### decode[[diffusers.AutoencoderKLMiniMaxH3.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_minimax_h3.py#L883)

**Paramètres :**

z (`torch.Tensor`) : Lot d'entrée de vidéos latentes, de forme `(batch_size, latent_channels, num_latent_frames, height, width)`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) plutôt qu'un simple tuple.

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

Les vidéos décodées, de forme `(batch_size, out_channels, num_frames, height, width)`.

Décoder un lot de vidéos latentes.

#### enable_tiling[[diffusers.AutoencoderKLMiniMaxH3.enable_tiling]]

```python
enable_tiling(tile_sample_min_height: int | None = None, tile_sample_min_width: int | None = None, tile_sample_min_overlap_height: int | None = None, tile_sample_min_overlap_width: int | None = None)
```

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

**Paramètres :**

tile_sample_min_height (`int`, *facultatif*) : La hauteur de la tuile en espace pixel. Les images plus hautes que cette valeur sont divisées le long de la dimension de hauteur.

tile_sample_min_width (`int`, *facultatif*) : La largeur de la tuile en espace pixel. Les images plus larges que cette valeur sont divisées le long de la dimension de largeur.

tile_sample_min_overlap_height (`int`, *facultatif*) : Le chevauchement minimal, en pixels, entre deux tuiles verticales consécutives.

tile_sample_min_overlap_width (`int`, *facultatif*) : Le chevauchement minimal, en pixels, entre deux tuiles horizontales consécutives.

Active l’encodage/décodage VAE par tuiles. Lorsque cette option est activée, le VAE divise les images en tuiles, encode ou décode chaque tuile séparément, puis fusionne linéairement les zones de chevauchement. Cela réduit la consommation mémoire et permet de traiter des images de plus grande taille.

#### forward[[diffusers.AutoencoderKLMiniMaxH3.forward]]

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

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

**Paramètres :**

sample (`torch.Tensor`) : Lot d'entrée de vidéos, de forme `(batch_size, in_channels, num_frames, height, width)`.

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

generator (`torch.Generator`, *facultatif*) : Générateur utilisé lorsque `sample_posterior=True`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un [DecoderOutput](/docs/diffusers/v0.43.0/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) plutôt qu'un simple tuple.

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

Les vidéos après aller-retour, de forme `(batch_size, out_channels, num_frames, height, width)`.

Encoder puis décoder un lot de vidéos.