# AutoencoderKLMiniMaxH3Audio

El autoencoder de audio utilizado en [MiniMax-H3](https://huggingface.co/MiniMaxAI) de MiniMax. Recibe y emite formas de onda, sin un preprocesador mel ni un vocoder separado: un encoder convolucional con saltos de la línea DAC, una proyección con atención causal hacia el ancho latente de la difusión y un decodificador BigVGAN.

El codificador salta 800 muestras a 32 kHz, es decir, 40 latentes por segundo, por lo que una forma de onda de `800 * n` muestras se codifica en `n` latentes. Las formas de onda que no son un número entero de saltos se rellenan a la derecha.

La proyección de atención causal pasa por el despachador de atención, por lo que `set_attention_backend` se aplica a ella; su máscara es `is_causal=True`, que todos los backends respetan excepto `_native_npu`, cuyo kernel no acepta ninguna bandera causal.

El autoencoder es **mono** y normaliza los latentes por canal con `latents_mean` / `latents_std` en lugar de un `scaling_factor` escalar. MiniMax-H3 lleva el estéreo como dos elementos de *batch* y siempre consume la media posterior (`latent_dist.mode()`), nunca una muestra.

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

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

**Parámetros:**

encoder_dim (`int`, por defecto `64`) : Ancho de canal de la primera convolución del codificador; se duplica en cada etapa de muestreo descendente.

encoder_rates (`tuple[int]`, por defecto `(2, 4, 4, 5, 5)`) : Pasos del codificador. Su producto (`800`) es la longitud del salto, es decir, 40 latentes/s a 32 kHz.

latent_dim (`int`, por defecto `2048`) : Ancho del tronco del codificador y de la entrada del decodificador, antes/después de las proyecciones latentes.

latent_channels (`int`, por defecto `32`) : Ancho del latente de difusión, es decir, los canales de salida de `mean_proj` / `logs_proj`.

num_attention_heads (`int`, por defecto `8`) : Número de cabezas en la proyección de atención causal `pre_block`.

decoder_dim (`int`, por defecto `1024`) : Número de canales iniciales de BigVGAN; se reduce a la mitad en cada etapa de remuestreo ascendente.

decoder_rates (`tuple[int]`, por defecto `(5, 5, 2, 2, 2, 2, 2)`) : Tasas de remuestreo ascendente de BigVGAN. Su producto debe ser igual a `prod(encoder_rates)`.

decoder_kernel_sizes (`tuple[int]`, por defecto `(9, 9, 4, 4, 4, 4, 4)`) : Tamaño del kernel de convolución transpuesta por etapa de remuestreo ascendente.

resblock_kernel_sizes (`tuple[int]`, por defecto `(3, 7, 11)`) : Tamaños de los núcleos de los bloques residuales AMP paralelos en cada etapa de muestreo ascendente.

resblock_dilation_sizes (`tuple[tuple[int]]`, por defecto `((1, 3, 5), (1, 3, 5), (1, 3, 5))`) : Dilataciones por bloque de AMP.

sampling_rate (`int`, por defecto `32000`) : Tasa de muestreo de la forma de onda.

latents_mean (`list[float]`, *opcional*) : Media latente por canal que utiliza el pipeline para normalizar / denormalizar los latentes.

latents_std (`list[float]`, *opcional*) : Desviación estándar latente por canal que la pipeline utiliza para normalizar / denormalizar los latentes.

El autoencoder de audio utilizado por [MiniMax-H3](https://huggingface.co/MiniMaxAI): un codificador convolucional de linaje DAC y un decodificador BigVGAN, que opera directamente sobre formas de onda mono de 32 kHz.

Este modelo hereda de [ModelMixin](/docs/diffusers/v0.43.0/es/api/models/overview#diffusers.ModelMixin). Consulta la documentación de la superclase para los métodos genéricos que la biblioteca implementa para todos los modelos (como la descarga o el guardado).

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

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

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

**Parámetros:**

sample (`torch.Tensor`) : Forma de onda mono de forma `[batch_size, 1, samples]`. MiniMax-H3 pasa los dos canales estéreo de un clip de referencia como `batch_size = 2`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `MiniMaxH3AudioEncoderOutput` en lugar de una tupla simple.

**Devuelve:** `MiniMaxH3AudioEncoderOutput` o `tuple`

La posterior latente sobre `[batch_size, latent_channels, samples / 800]`.

Codifica una forma de onda en el posterior latente de audio.

Primero, la forma de onda se rellena a la derecha hasta un múltiplo de `hop_length` (800 muestras). MiniMax-H3 siempre consume la **media** posterior (`latent_dist.mode()`); la cabeza `logs_proj` nunca se evalúa en el pipeline de referencia.

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

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

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

**Parámetros:**

latents (`torch.Tensor`) : Latentes denormalizados de forma `[batch_size, latent_channels, num_frames]`. MiniMax-H3 pasa los dos canales estéreo como `batch_size = 2`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) en lugar de una tupla simple.

**Devuelve:** [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) o `tuple`

Forma de onda de forma `[batch_size, 1, num_frames * 800]`, limitada a `[-1, 1]`.

Decodifica los latentes de audio en una forma de onda.

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

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3_audio.py#L653)

**Parámetros:**

sample (`torch.Tensor`) : Forma de onda mono de forma `[batch_size, 1, samples]`.

sample_posterior (`bool`, por defecto `False`) : Si se debe muestrear la posterior en lugar de tomar su modo. MiniMax-H3 utiliza el modo.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) en lugar de una tupla simple.

generator (`torch.Generator`, *opcional*) : Generador utilizado cuando `sample_posterior=True`.

**Devuelve:** [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) o `tuple`

La forma de onda de ida y vuelta de forma `[batch_size, 1, num_frames * 800]`, limitada a `[-1, 1]`.

Codificar y luego decodificar una forma de onda.