# AutoencoderKLMiniMaxH3Audio

Bộ tự mã hóa âm thanh được sử dụng trong [MiniMax-H3](https://huggingface.co/MiniMaxAI) của MiniMax. Nó nhận đầu vào dạng sóng và xuất ra dạng sóng, không có phần tiền xử lý mel và không có bộ tổng hợp âm thanh (vocoder) riêng biệt: bao gồm bộ mã hóa tích chập có bước nhảy theo dòng dõi DAC, phép chiếu chú ý nhân quả (causal-attention) lên chiều rộng ẩn của mô hình khuếch tán (diffusion), và bộ giải mã BigVGAN.

Bộ mã hóa nhảy 800 mẫu ở 32 kHz, tức là 40 latent mỗi giây, do đó một dạng sóng gồm `800 * n` mẫu sẽ được mã hóa thành `n` latent. Các dạng sóng không phải là số nguyên lần của bước nhảy sẽ được đệm bên phải.

Chiếu chú ý nhân quả đi qua bộ điều phối chú ý, do đó `set_attention_backend` áp dụng cho nó; mặt nạ của nó là `is_causal=True`, được mọi backend tuân thủ ngoại trừ `_native_npu`, trong đó kernel của nó không nhận cờ nhân quả.

Autoencoder là **mono**, và nó chuẩn hóa latents theo từng kênh bằng `latents_mean` / `latents_std` thay vì một `scaling_factor` vô hướng. MiniMax-H3 xử lý stereo như hai mục *batch*, và nó luôn sử dụng trung bình hậu nghiệm (`latent_dist.mode()`), không bao giờ dùng một mẫu.

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

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

**Tham số:**

encoder_dim (`int`, mặc định là `64`) : Bề rộng kênh của lớp tích chập đầu tiên của bộ mã hóa; tăng gấp đôi ở mỗi giai đoạn hạ mẫu.

encoder_rates (`tuple[int]`, mặc định là `(2, 4, 4, 5, 5)`) : Stride của encoder. Tích của chúng (`800`) là độ dài bước nhảy, tức là 40 latents/giây ở 32 kHz.

latent_dim (`int`, mặc định là `2048`) : Độ rộng của thân encoder và đầu vào của decoder, trước/sau các phép chiếu latent.

latent_channels (`int`, mặc định là `32`) : Độ rộng của latent khuếch tán, tức là số kênh đầu ra của `mean_proj` / `logs_proj`.

num_attention_heads (`int`, mặc định là `8`) : Số lượng đầu trong phép chiếu chú ý nhân quả `pre_block`.

decoder_dim (`int`, mặc định là `1024`) : Số lượng kênh ban đầu của BigVGAN; giảm một nửa ở mỗi giai đoạn upsampling.

decoder_rates (`tuple[int]`, mặc định là `(5, 5, 2, 2, 2, 2, 2)`) : Các tỷ lệ upsampling của BigVGAN. Tích của chúng phải bằng `prod(encoder_rates)`.

decoder_kernel_sizes (`tuple[int]`, mặc định là `(9, 9, 4, 4, 4, 4, 4)`) : Kích thước kernel của transposed-convolution cho mỗi giai đoạn upsampling.

resblock_kernel_sizes (`tuple[int]`, mặc định là `(3, 7, 11)`) : Kích thước kernel của các khối AMP dư song song ở mỗi giai đoạn lấy mẫu lên.

resblock_dilation_sizes (`tuple[tuple[int]]`, mặc định là `((1, 3, 5), (1, 3, 5), (1, 3, 5))`) : Dilations cho từng khối AMP.

sampling_rate (`int`, mặc định là `32000`) : Tần số lấy mẫu của dạng sóng.

latents_mean (`list[float]`, *tùy chọn*) : Giá trị trung bình latent theo từng kênh mà pipeline sử dụng để chuẩn hóa / khử chuẩn hóa latent.

latents_std (`list[float]`, *tùy chọn*) : Độ lệch chuẩn tiềm ẩn theo kênh mà pipeline sử dụng để chuẩn hóa / khử chuẩn hóa các giá trị tiềm ẩn.

Autoencoder âm thanh được sử dụng bởi [MiniMax-H3](https://huggingface.co/MiniMaxAI): một bộ mã hóa tích chập theo dòng DAC và một bộ giải mã BigVGAN, hoạt động trực tiếp trên dạng sóng mono 32 kHz.

Mô hình này kế thừa từ [ModelMixin](/docs/diffusers/main/vi/api/models/overview#diffusers.ModelMixin). Xem tài liệu của lớp cha để biết các phương thức chung mà thư viện triển khai cho tất cả các mô hình (chẳng hạn như tải xuống hoặc lưu).

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

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

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

**Tham số:**

sample (`torch.Tensor`) : Dạng sóng đơn (mono) có hình dạng `[batch_size, 1, samples]`. MiniMax-H3 truyền hai kênh stereo của một đoạn tham chiếu dưới dạng `batch_size = 2`.

return_dict (`bool`, mặc định là `True`) : Xác định có trả về một `MiniMaxH3AudioEncoderOutput` thay vì một tuple thông thường hay không.

**Trả về:** `MiniMaxH3AudioEncoderOutput` hoặc `tuple`

Hậu nghiệm tiềm ẩn trên `[batch_size, latent_channels, samples / 800]`.

Mã hóa một dạng sóng thành hậu nghiệm tiềm ẩn của âm thanh.

Tín hiệu sóng được đệm bên phải đến bội số của `hop_length` (800 mẫu) trước tiên. MiniMax-H3 luôn sử dụng **mean** hậu nghiệm (`latent_dist.mode()`) — đầu `logs_proj` không bao giờ được đánh giá bởi pipeline tham chiếu.

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

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

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

**Tham số:**

latents (`torch.Tensor`) : Latents chưa được chuẩn hóa, có hình dạng `[batch_size, latent_channels, num_frames]`. MiniMax-H3 truyền hai kênh âm thanh nổi dưới dạng `batch_size = 2`.

return_dict (`bool`, mặc định là `True`) : Có nên trả về một [DecoderOutput](/docs/diffusers/main/vi/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) thay vì một tuple thông thường hay không.

**Trả về:** [DecoderOutput](/docs/diffusers/main/vi/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) hoặc `tuple`

Dạng sóng có hình dạng `[batch_size, 1, num_frames * 800]`, được kẹp trong khoảng `[-1, 1]`.

Giải mã các ẩn âm thanh thành dạng sóng.

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

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

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

**Tham số:**

sample (`torch.Tensor`) : Dạng sóng đơn (mono) có hình dạng `[batch_size, 1, samples]`.

sample_posterior (`bool`, mặc định là `False`) : Có lấy mẫu từ phân phối hậu nghiệm thay vì lấy mode của nó hay không. MiniMax-H3 sử dụng mode.

return_dict (`bool`, mặc định là `True`) : Có nên trả về một [DecoderOutput](/docs/diffusers/main/vi/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) thay vì một tuple thông thường hay không.

generator (`torch.Generator`, *tùy chọn*) : Generator được sử dụng khi `sample_posterior=True`.

**Trả về:** [DecoderOutput](/docs/diffusers/main/vi/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) hoặc `tuple`

Đường sóng sau khi đi vòng qua có hình dạng `[batch_size, 1, num_frames * 800]`, được kẹp trong khoảng `[-1, 1]`.

Mã hóa rồi giải mã một dạng sóng.