# AutoencoderKLMiniMaxH3Audio

L'autoencodeur audio utilisé dans [MiniMax-H3](https://huggingface.co/MiniMaxAI) par MiniMax. Il prend une forme d'onde en entrée et en sort une forme d'onde, sans front-end mel et sans vocoder séparé : un encodeur à convolutions à pas (strided) de lignée DAC, une projection par attention causale vers la largeur latente de la diffusion, et un décodeur BigVGAN.

L’encodeur saute 800 échantillons à 32 kHz, soit 40 latents par seconde, de sorte qu’une forme d’onde de `800 * n` échantillons est encodée en `n` latents. Les formes d’onde dont la durée n’est pas un multiple entier des sauts sont complétées à droite.

La projection d’attention causale passe par le dispatcheur d’attention, donc `set_attention_backend` s’applique à celle-ci ; son masque est `is_causal=True`, que tous les backends respectent à l’exception de `_native_npu`, dont le kernel n’accepte pas de drapeau causal.

L'autoencodeur est **mono** et il normalise les latents par canal avec `latents_mean` / `latents_std` plutôt qu'un `scaling_factor` scalaire. MiniMax-H3 gère le stéréo sous forme de deux éléments de *batch* et consomme toujours la moyenne a posteriori (`latent_dist.mode()`), jamais un échantillon.

```python
import torch
from diffusers import AutoencoderKLMiniMaxH3Audio

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

## AutoencoderKLMiniMaxH3Audio[[diffusers.AutoencoderKLMiniMaxH3Audio]]

#### diffusers.AutoencoderKLMiniMaxH3Audio[[diffusers.AutoencoderKLMiniMaxH3Audio]]

```python
diffusers.AutoencoderKLMiniMaxH3Audio(encoder_dim: int = 64, encoder_rates: tuple[int, ...] = (2, 4, 4, 5, 5), latent_dim: int = 2048, latent_channels: int = 32, num_attention_heads: int = 8, decoder_dim: int = 1024, decoder_rates: tuple[int, ...] = (5, 5, 2, 2, 2, 2, 2), decoder_kernel_sizes: tuple[int, ...] = (9, 9, 4, 4, 4, 4, 4), resblock_kernel_sizes: tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: tuple[tuple[int, ...], ...] = ((1, 3, 5), (1, 3, 5), (1, 3, 5)), sampling_rate: int = 32000, latents_mean: list[float] | None = None, latents_std: list[float] | None = None)
```

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

**Paramètres :**

encoder_dim (`int`, par défaut `64`) : Largeur des canaux de la première convolution de l'encodeur ; doublée à chaque étape de sous-échantillonnage.

encoder_rates (`tuple[int]`, par défaut `(2, 4, 4, 5, 5)`) : Pas de l'encodeur. Leur produit (`800`) correspond à la longueur de saut, soit 40 latents/s à 32 kHz.

latent_dim (`int`, par défaut `2048`) : Largeur du tronc de l'encodeur et de l'entrée du décodeur, avant/après les projections latentes.

latent_channels (`int`, par défaut `32`) : Largeur du latent de diffusion, c'est-à-dire les canaux de sortie de `mean_proj` / `logs_proj`.

num_attention_heads (`int`, par défaut `8`) : Nombre de têtes dans la projection d'attention causale `pre_block`.

decoder_dim (`int`, par défaut `1024`) : nombre de canaux initial de BigVGAN ; divisé par deux à chaque étape de suréchantillonnage.

decoder_rates (`tuple[int]`, par défaut `(5, 5, 2, 2, 2, 2, 2)`) : Taux de suréchantillonnage de BigVGAN. Leur produit doit être égal à `prod(encoder_rates)`.

decoder_kernel_sizes (`tuple[int]`, par défaut `(9, 9, 4, 4, 4, 4, 4)`) : Taille du noyau de convolution transposée pour chaque étape de remonte en résolution.

resblock_kernel_sizes (`tuple[int]`, par défaut `(3, 7, 11)`) : Tailles des noyaux des blocs résiduels AMP parallèles à chaque étape de suréchantillonnage.

resblock_dilation_sizes (`tuple[tuple[int]]`, par défaut `((1, 3, 5), (1, 3, 5), (1, 3, 5))`) : Dilations par bloc AMP.

sampling_rate (`int`, par défaut `32000`) : Fréquence d'échantillonnage du signal audio.

latents_mean (`list[float]`, *facultatif*) : Moyenne latente par canal que le pipeline utilise pour normaliser / dénormaliser les latents.

latents_std (`list[float]`, *facultatif*) : Écart-type latent par canal utilisé par le pipeline pour normaliser / dénormaliser les latents.

L'autoencodeur audio utilisé par [MiniMax-H3](https://huggingface.co/MiniMaxAI) : un encodeur convolutif de lignée DAC et un décodeur BigVGAN, fonctionnant directement sur des formes d'onde mono à 32 kHz.

Ce modèle hérite de [ModelMixin](/docs/diffusers/main/fr/api/models/overview#diffusers.ModelMixin). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous les modèles (téléchargement ou sauvegarde, par exemple).

#### encode[[diffusers.AutoencoderKLMiniMaxH3Audio.encode]]

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

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

**Paramètres :**

sample (`torch.Tensor`) : Forme d'onde mono de forme `[batch_size, 1, samples]`. MiniMax-H3 transmet les deux canaux stéréo d'un clip de référence en tant que `batch_size = 2`.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `MiniMaxH3AudioEncoderOutput` plutôt qu'un simple tuple.

**Retourne :** `MiniMaxH3AudioEncoderOutput` ou `tuple`

La postérieure latente sur `[batch_size, latent_channels, samples / 800]`.

Encoder une forme d'onde dans le postérieur latent audio.

La forme d’onde est d’abord complétée à droite jusqu’à un multiple de `hop_length` (800 échantillons). MiniMax-H3 consomme toujours la **moyenne** a posteriori (`latent_dist.mode()`) — la tête `logs_proj` n’est jamais évaluée par le pipeline de référence.

#### decode[[diffusers.AutoencoderKLMiniMaxH3Audio.decode]]

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

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

**Paramètres :**

latents (`torch.Tensor`) : Latents non normalisés de forme `[batch_size, latent_channels, num_frames]`. MiniMax-H3 transmet les deux canaux stéréo en définissant `batch_size = 2`.

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

Forme d'onde de forme `[batch_size, 1, num_frames * 800]`, bornée à `[-1, 1]`.

Décoder les latents audio en une forme d’onde.

#### forward[[diffusers.AutoencoderKLMiniMaxH3Audio.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/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_audio.py#L653)

**Paramètres :**

sample (`torch.Tensor`) : Forme d'onde mono de forme `[batch_size, 1, samples]`.

sample_posterior (`bool`, par défaut `False`) : Indique s'il faut échantillonner la distribution a posteriori plutôt que d'en prendre le mode. MiniMax-H3 utilise le mode.

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

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

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

La forme d'onde de forme `[batch_size, 1, num_frames * 800]` après aller-retour, bornée à `[-1, 1]`.

Encoder puis décoder une forme d'onde.