# AutoencoderKLMiniMaxH3Image

Le modèle d'auto-encodeur variationnel (VAE) d'image avec perte KL utilisé dans [MiniMax-H3-Image](https://huggingface.co/MiniMaxAI/MiniMax-H3-Image) par MiniMax. Il associe l'encodeur CNN 3D causal de [AutoencoderKLMiniMaxH3](/docs/diffusers/main/fr/api/models/autoencoderkl_minimax_h3#diffusers.AutoencoderKLMiniMaxH3), exécuté sur une seule image, à un décodeur ViT 2D, et compresse spatialement par un facteur de 16. `encode` et `decode` prennent en entrée et renvoient des tenseurs d'image 4D.

Elle partage trois conventions avec [AutoencoderKLMiniMaxH3](/docs/diffusers/main/fr/api/models/autoencoderkl_minimax_h3#diffusers.AutoencoderKLMiniMaxH3) :

- **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-Image a été publié avec le tuilage activé pour l’encodage et le décodage, et les images publiées sont celles issues du mélange de tuiles ; 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.

```python
import torch
from diffusers import AutoencoderKLMiniMaxH3Image

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

## AutoencoderKLMiniMaxH3Image[[diffusers.AutoencoderKLMiniMaxH3Image]]

#### diffusers.AutoencoderKLMiniMaxH3Image[[diffusers.AutoencoderKLMiniMaxH3Image]]

```python
diffusers.AutoencoderKLMiniMaxH3Image(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 = 24, decoder_num_attention_heads: int = 16, 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.5, decoder_norm_eps: float = 1e-05, 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/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_image.py#L499)

Un modèle VAE doté d'un encodeur CNN 3D causal et d'un décodeur ViT 2D non causal, utilisé dans [MiniMax-H3-Image](https://huggingface.co/MiniMaxAI). L'encodeur est l'encodeur vidéo MiniMax-H3 appliqué à une seule image ; le décodeur est un ViT dédié aux images.

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

Contrairement à la plupart des autoencodeurs de la bibliothèque, le tuilage spatial est **activé par défaut** : MiniMax-H3-Image a été publié avec le tuilage activé pour l’encodage et le décodage, et les images publiées sont celles obtenues par fusion de tuiles, 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.AutoencoderKLMiniMaxH3Image.encode]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_image.py#L758)

**Paramètres :**

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

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

**Retourne :**

La distribution latente des images encodées, sur des latents de forme `(batch_size, latent_channels, height // spatial_compression_ratio, width // spatial_compression_ratio)`. Notez que MiniMax-H3-Image normalise ensuite les latents échantillonnés avec `latents_mean` / `latents_std`.

Encode un lot d'images en latents.

#### decode[[diffusers.AutoencoderKLMiniMaxH3Image.decode]]

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

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_image.py#L786)

**Paramètres :**

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

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

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

Les images décodées, de forme `(batch_size, out_channels, height * spatial_compression_ratio, width * spatial_compression_ratio)`.

Décoder un lot de latents.

#### enable_tiling[[diffusers.AutoencoderKLMiniMaxH3Image.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/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_image.py#L608)

**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.AutoencoderKLMiniMaxH3Image.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/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_image.py#L812)

**Paramètres :**

sample (`torch.Tensor`) : Lot d'images en entrée, de forme `(batch_size, in_channels, 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/main/fr/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) plutôt qu'un simple tuple.

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

Les images après aller-retour, de forme `(batch_size, out_channels, height, width)`.

Encoder puis décoder un lot d'images.