# AutoencoderKLMiniMaxH3Audio

O autoencoder de áudio usado em [MiniMax-H3](https://huggingface.co/MiniMaxAI) pela MiniMax. Ele recebe e produz waveforms, sem front-end mel e sem vocoder separado: um encoder convolucional com strides da linhagem DAC, uma projeção com atenção causal para a largura do latente de difusão e um decoder BigVGAN.

O codificador avança 800 amostras a 32 kHz, ou seja, 40 latentes por segundo, de modo que uma forma de onda de `800 * n` amostras é codificada em `n` latentes. Formas de onda que não correspondem a um número inteiro de avanços são preenchidas à direita.

A projeção de atenção causal passa pelo despachador de atenção, portanto `set_attention_backend` se aplica a ela; sua máscara é `is_causal=True`, que todos os backends respeitam, exceto `_native_npu`, cujo kernel não aceita uma flag causal.

O autoencoder é **mono** e normaliza os latentes por canal com `latents_mean` / `latents_std`, em vez de um `scaling_factor` escalar. O MiniMax-H3 carrega o estéreo como dois itens de *batch* e sempre consome a média do posterior (`latent_dist.mode()`), nunca uma amostra.

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

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

**Parâmetros:**

encoder_dim (`int`, padrão `64`) : Largura do canal da primeira convolução do codificador; dobra em cada etapa de downsampling.

encoder_rates (`tuple[int]`, padrão `(2, 4, 4, 5, 5)`) : Passos do codificador. O produto deles (`800`) é o comprimento do salto, ou seja, 40 latentes/s a 32 kHz.

latent_dim (`int`, padrão `2048`) : Largura do tronco do codificador e da entrada do decodificador, antes/depois das projeções latentes.

latent_channels (`int`, padrão `32`) : Largura do latente de difusão, ou seja, os canais de saída de `mean_proj` / `logs_proj`.

num_attention_heads (`int`, padrão `8`) : Número de cabeças na projeção de atenção causal `pre_block`.

decoder_dim (`int`, padrão `1024`) : número de canais iniciais do BigVGAN; reduzido pela metade em cada etapa de upsampling.

decoder_rates (`tuple[int]`, padrão `(5, 5, 2, 2, 2, 2, 2)`) : Taxas de upsampling do BigVGAN. O produto delas deve ser igual a `prod(encoder_rates)`.

decoder_kernel_sizes (`tuple[int]`, padrão `(9, 9, 4, 4, 4, 4, 4)`) : Tamanho do kernel de transposed-convolution por estágio de upsampling.

resblock_kernel_sizes (`tuple[int]`, padrão `(3, 7, 11)`) : Tamanhos dos kernels dos blocos residuais de AMP paralelos em cada estágio de upsampling.

resblock_dilation_sizes (`tuple[tuple[int]]`, padrão `((1, 3, 5), (1, 3, 5), (1, 3, 5))`) : Dilatações por bloco de AMP.

sampling_rate (`int`, padrão `32000`) : Taxa de amostragem da forma de onda.

latents_mean (`list[float]`, *opcional*) : Média latente por canal que o pipeline usa para normalizar/denormalizar os latentes.

latents_std (`list[float]`, *opcional*) : Desvio padrão latente por canal que o pipeline usa para normalizar/denormalizar os latentes.

O autoencoder de áudio usado pelo [MiniMax-H3](https://huggingface.co/MiniMaxAI): um codificador convolucional de linhagem DAC e um decodificador BigVGAN, operando diretamente em formas de onda mono de 32 kHz.

Este modelo herda de [ModelMixin](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin). Consulte a documentação da superclasse para os métodos genéricos que a biblioteca implementa para todos os modelos (como download ou salvamento).

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

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

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

**Parâmetros:**

sample (`torch.Tensor`) : Forma de onda mono com a forma `[batch_size, 1, samples]`. O MiniMax-H3 passa os dois canais estéreo de um clipe de referência como `batch_size = 2`.

return_dict (`bool`, padrão `True`) : Se deve retornar um `MiniMaxH3AudioEncoderOutput` em vez de uma tupla simples.

**Retorna:** `MiniMaxH3AudioEncoderOutput` ou `tuple`

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

Codifique uma forma de onda no posterior latente de áudio.

A forma de onda é primeiro preenchida à direita até um múltiplo de `hop_length` (800 amostras). O MiniMax-H3 sempre consome a média posterior **mean** (`latent_dist.mode()`) — o cabeçalho `logs_proj` nunca é avaliado pelo pipeline de referência.

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

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

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

**Parâmetros:**

latents (`torch.Tensor`) : Latentes desnornalizados com forma `[batch_size, latent_channels, num_frames]`. O MiniMax-H3 passa os dois canais estéreo como `batch_size = 2`.

return_dict (`bool`, padrão `True`) : Se deve retornar um [DecoderOutput](/docs/diffusers/main/pt/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) em vez de uma tupla simples.

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

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

Decodifique os latentes de áudio em uma 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)
```

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

**Parâmetros:**

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

sample_posterior (`bool`, padrão `False`) : Se deve amostrar a posterior em vez de tomar seu modo. O MiniMax-H3 usa o modo.

return_dict (`bool`, padrão `True`) : Se deve retornar um [DecoderOutput](/docs/diffusers/main/pt/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) em vez de uma tupla simples.

generator (`torch.Generator`, *opcional*) : Gerador usado quando `sample_posterior=True`.

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

A forma de onda de ida e volta, de forma `[batch_size, 1, num_frames * 800]`, limitada a `[-1, 1]`.

Codifique e depois decodifique uma forma de onda.