# VibeVoice Acoustic Tokenizer

## Visão geral

[VibeVoice](https://huggingface.co/papers/2508.19205) é um novo framework para sintetizar fala de alta fidelidade e longa duração com múltiplos falantes, empregando uma abordagem de difusão de próximo token dentro de uma estrutura de Large Language Model (LLM). Ele foi projetado para capturar a "vibe" autêntica de conversas e é particularmente adequado para gerar conteúdo de áudio como podcasts e audiobooks com múltiplos participantes.

Uma característica fundamental do VibeVoice é o uso de dois tokenizadores de áudio contínuos, um para extrair características acústicas e outro para características semânticas.

Um checkpoint do modelo está disponível em [microsoft/VibeVoice-AcousticTokenizer](https://huggingface.co/microsoft/VibeVoice-AcousticTokenizer)

Este modelo foi contribuído por [Eric Bezzam](https://huggingface.co/bezzam).

## Arquitetura

A arquitetura é uma estrutura encoder-decoder simétrica por espelhamento. O encoder adota um design hierárquico com 7 estágios de blocos semelhantes ao ConvNeXt, que utilizam convoluções causais 1D profundas para processamento de streaming eficiente. Seis camadas de downsampling alcançam uma taxa de downsampling cumulativa de 3200X a partir de uma entrada de 24kHz, resultando em 7,5 tokens/frames por segundo. Cada componente encoder/decoder possui aproximadamente 340M de parâmetros, totalizando cerca de 680M de parâmetros. O objetivo de treinamento segue o de [DAC](./dac), incluindo seus designs de discriminador e de perda.

O Acoustic Tokenizer adota os princípios de um Autoencoder Variacional (VAE). O codificador mapeia o áudio de entrada para os parâmetros de uma distribuição latente, a saber, a média. Juntamente com um desvio padrão fixo, um vetor latente é então amostrado usando o truque de reparametrização. Consulte o [relatório técnico](https://huggingface.co/papers/2508.19205) para mais detalhes.

## Uso

Abaixo está um exemplo de uso para codificar e decodificar áudio:

```python
import torch
from scipy.io import wavfile

from transformers import AutoFeatureExtractor, VibeVoiceAcousticTokenizerModel
from transformers.audio_utils import load_audio_librosa

model_id = "microsoft/VibeVoice-AcousticTokenizer"

# load model
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = VibeVoiceAcousticTokenizerModel.from_pretrained(model_id, device_map="auto")
print("Model loaded on device:", model.device)
print("Model dtype:", model.dtype)

# load audio
audio = load_audio_librosa(
    "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
    sampling_rate=feature_extractor.sampling_rate,
)

# preprocess audio
inputs = feature_extractor(
    audio,
    sampling_rate=feature_extractor.sampling_rate,
    pad_to_multiple_of=3200,
).to(model.device, model.dtype)
print("Input audio shape:", inputs.input_values.shape)
# Input audio shape: torch.Size([1, 1, 224000])

with torch.no_grad():
    # set VAE sampling to False for deterministic output
    encoded_outputs = model.encode(inputs.input_values, sample=False)
    print("Latent shape:", encoded_outputs.latents.shape)
    # Latent shape: torch.Size([1, 70, 64])

    decoded_outputs = model.decode(**encoded_outputs)
    print("Reconstructed audio shape:", decoded_outputs.audio.shape)
    # Reconstructed audio shape: torch.Size([1, 1, 224000])

# Save audio
output_fp = "vibevoice_acoustic_tokenizer_reconstructed.wav"
wavfile.write(output_fp, feature_extractor.sampling_rate, decoded_outputs.audio.squeeze().float().cpu().numpy())
print(f"Reconstructed audio saved to : {output_fp}")
```

## Streaming

Para ASR ou TTS em streaming, em que é necessário acompanhar os estados em cache, o parâmetro `use_cache` pode ser usado ao codificar ou decodificar o áudio:

```python
import torch
from scipy.io import wavfile

from transformers import AutoFeatureExtractor, VibeVoiceAcousticTokenizerModel
from transformers.audio_utils import load_audio_librosa

model_id = "microsoft/VibeVoice-AcousticTokenizer"

# load model
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = VibeVoiceAcousticTokenizerModel.from_pretrained(model_id, device_map="auto")
print("Model loaded on device:", model.device)
print("Model dtype:", model.dtype)

# load audio
audio = load_audio_librosa(
    "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
    sampling_rate=feature_extractor.sampling_rate,
)

# preprocess audio
inputs = feature_extractor(
    audio,
    sampling_rate=feature_extractor.sampling_rate,
    pad_to_multiple_of=3200,
).to(model.device, model.dtype)
print("Input audio shape:", inputs.input_values.shape)
# Input audio shape: torch.Size([1, 1, 224000])

# cache will be initialized after a first pass
encoder_cache = None
decoder_cache = None
with torch.no_grad():
    # set VAE sampling to False for deterministic output
    encoded_outputs = model.encode(inputs.input_values, sample=False, padding_cache=encoder_cache, use_cache=True)
    print("Latent shape:", encoded_outputs.latents.shape)
    # Latent shape: torch.Size([1, 70, 64])

    decoded_outputs = model.decode(encoded_outputs.latents, padding_cache=decoder_cache, use_cache=True)
    print("Reconstructed audio shape:", decoded_outputs.audio.shape)
    # Reconstructed audio shape: torch.Size([1, 1, 224000])

    # `padding_cache` can be extracted from the outputs for subsequent passes
    encoder_cache = encoded_outputs.padding_cache
    print("Number of cached encoder layers:", len(encoder_cache.per_layer_in_channels))
    # Number of cached encoder layers: 34
    decoder_cache = decoded_outputs.padding_cache
    print("Number of cached decoder layers:", len(decoder_cache.per_layer_in_channels))
    # Number of cached decoder layers: 34

# Save audio
output_fp = "vibevoice_acoustic_tokenizer_reconstructed.wav"
wavfile.write(output_fp, feature_extractor.sampling_rate, decoded_outputs.audio.squeeze().float().cpu().numpy())
print(f"Reconstructed audio saved to : {output_fp}")
```

## VibeVoiceAcousticTokenizerConfig[[transformers.VibeVoiceAcousticTokenizerConfig]]

#### transformers.VibeVoiceAcousticTokenizerConfig[[transformers.VibeVoiceAcousticTokenizerConfig]]

```python
transformers.VibeVoiceAcousticTokenizerConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, channels: int = 1, hidden_size: int = 64, kernel_size: int = 7, rms_norm_eps: float = 1e-05, layer_scale_init_value: float = 1e-06, initializer_range: float = 0.01, num_filters: int = 32, downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 5, 5, 8), depths: list[int] | tuple[int, ...] = (3, 3, 3, 3, 3, 3, 8), hidden_act: str = 'gelu', ffn_expansion: int = 4, vae_std: float = 0.625)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/configuration_vibevoice_acoustic_tokenizer.py#L26)

**Parâmetros:**

channels (`int`, *opcional*, padrão 1) : Número de canais de entrada.

hidden_size (`int`, *opcional*, padrão 64) : Dimensionalidade das representações latentes.

kernel_size (`int`, *opcional*, padrão 7) : Tamanho do kernel para as camadas convolucionais.

rms_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização rms.

layer_scale_init_value (`float`, *opcional*, padrão `1e-06`) : Escala a ser usada nas camadas de autoatenção. 0.1 para base, 1e-6 para large. Defina 0 para desativar a escala da camada.

initializer_range (`float`, *opcional*, padrão `0.01`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

num_filters (`int`, *opcional*, padrão 32) : Número de filtros na camada convolucional inicial, e dobra após cada downsampling.

downsampling_ratios (`List[int]`, *opcional*, padrão `[2, 2, 4, 5, 5, 8]`) : Razões de downsampling para cada camada.

depths (`List[int]`, *opcional*, padrão `[3, 3, 3, 3, 3, 3, 8]`) : Número de blocos ConvNeXt em cada estágio.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

ffn_expansion (`int`, *opcional*, padrão 4) : Fator de expansão para redes feed-forward.

vae_std (`float`, *opcional*, padrão 0.625) : Desvio padrão da Gaussiana da qual a escala de ruído por amostra é extraída quando o ruído é adicionado aos latentes do codificador (`sample=True`).

Esta é a classe de configuração para armazenar a configuração de um VibeVoiceAcousticTokenizerModel. Ela é usada para instanciar um modelo Vibevoice Acoustic Tokenizer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [microsoft/VibeVoice-1.5B](https://huggingface.co/microsoft/VibeVoice-1.5B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import VibeVoiceAcousticTokenizerModel, VibeVoiceAcousticTokenizerConfig

>>> # Initializing a VibeVoice Acoustic Tokenizer configuration
>>> configuration = VibeVoiceAcousticTokenizerConfig()

>>> # Initializing a model (with random weights)
>>> model = VibeVoiceAcousticTokenizerModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## VibeVoiceAcousticTokenizerEncoderConfig[[transformers.VibeVoiceAcousticTokenizerEncoderConfig]]

#### transformers.VibeVoiceAcousticTokenizerEncoderConfig[[transformers.VibeVoiceAcousticTokenizerEncoderConfig]]

```python
transformers.VibeVoiceAcousticTokenizerEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, channels: int = 1, hidden_size: int = 64, kernel_size: int = 7, rms_norm_eps: float = 1e-05, layer_scale_init_value: float = 1e-06, initializer_range: float = 0.01, num_filters: int = 32, downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 5, 5, 8), depths: list[int] | tuple[int, ...] = (3, 3, 3, 3, 3, 3, 8), hidden_act: str = 'gelu', ffn_expansion: int = 4, vae_std: float = 0.625)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/configuration_vibevoice_acoustic_tokenizer.py#L93)

**Parâmetros:**

channels (`int`, *opcional*, padrão 1) : Número de canais de entrada.

hidden_size (`int`, *opcional*, padrão 64) : Dimensionalidade das representações latentes.

kernel_size (`int`, *opcional*, padrão 7) : Tamanho do kernel para as camadas convolucionais.

rms_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização rms.

layer_scale_init_value (`float`, *opcional*, padrão `1e-06`) : Escala a ser usada nas camadas de autoatenção. 0.1 para base, 1e-6 para large. Defina 0 para desativar a escala da camada.

initializer_range (`float`, *opcional*, padrão `0.01`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

num_filters (`int`, *opcional*, padrão 32) : Número de filtros na camada convolucional inicial, e dobra após cada downsampling.

downsampling_ratios (`List[int]`, *opcional*, padrão `[2, 2, 4, 5, 5, 8]`) : Razões de downsampling para cada camada.

depths (`List[int]`, *opcional*, padrão `[3, 3, 3, 3, 3, 3, 8]`) : Número de blocos ConvNeXt em cada estágio.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

ffn_expansion (`int`, *opcional*, padrão 4) : Fator de expansão para redes feed-forward.

vae_std (`float`, *opcional*, padrão 0.625) : Desvio padrão da Gaussiana da qual a escala de ruído por amostra é extraída quando o ruído é adicionado aos latentes do codificador (`sample=True`).

Esta é a classe de configuração para armazenar a configuração de um VibeVoiceAcousticTokenizerModel. Ela é usada para instanciar um modelo Vibevoice Acoustic Tokenizer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [microsoft/VibeVoice-1.5B](https://huggingface.co/microsoft/VibeVoice-1.5B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## VibeVoiceAcousticTokenizerDecoderConfig[[transformers.VibeVoiceAcousticTokenizerDecoderConfig]]

#### transformers.VibeVoiceAcousticTokenizerDecoderConfig[[transformers.VibeVoiceAcousticTokenizerDecoderConfig]]

```python
transformers.VibeVoiceAcousticTokenizerDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, channels: int = 1, hidden_size: int = 64, kernel_size: int = 7, rms_norm_eps: float = 1e-05, layer_scale_init_value: float = 1e-06, initializer_range: float = 0.01, num_filters: int = 32, downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 5, 5, 8), depths: list[int] | tuple[int, ...] = (3, 3, 3, 3, 3, 3, 8), hidden_act: str = 'gelu', ffn_expansion: int = 4, vae_std: float = 0.625)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/configuration_vibevoice_acoustic_tokenizer.py#L124)

**Parâmetros:**

channels (`int`, *opcional*, padrão 1) : Número de canais de entrada.

hidden_size (`int`, *opcional*, padrão 64) : Dimensionalidade das representações latentes.

kernel_size (`int`, *opcional*, padrão 7) : Tamanho do kernel para as camadas convolucionais.

rms_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização rms.

layer_scale_init_value (`float`, *opcional*, padrão `1e-06`) : Escala a ser usada nas camadas de autoatenção. 0.1 para base, 1e-6 para large. Defina 0 para desativar a escala da camada.

initializer_range (`float`, *opcional*, padrão `0.01`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

num_filters (`int`, *opcional*, padrão 32) : Número de filtros na camada convolucional inicial, e dobra após cada downsampling.

downsampling_ratios (`List[int]`, *opcional*, padrão `[2, 2, 4, 5, 5, 8]`) : Razões de downsampling para cada camada.

depths (`List[int]`, *opcional*, padrão `[3, 3, 3, 3, 3, 3, 8]`) : Número de blocos ConvNeXt em cada estágio.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

ffn_expansion (`int`, *opcional*, padrão 4) : Fator de expansão para redes feed-forward.

vae_std (`float`, *opcional*, padrão 0.625) : Desvio padrão da Gaussiana da qual a escala de ruído por amostra é extraída quando o ruído é adicionado aos latentes do codificador (`sample=True`).

Esta é a classe de configuração para armazenar a configuração de um VibeVoiceAcousticTokenizerModel. Ela é usada para instanciar um modelo Vibevoice Acoustic Tokenizer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [microsoft/VibeVoice-1.5B](https://huggingface.co/microsoft/VibeVoice-1.5B)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## VibeVoiceAcousticTokenizerFeatureExtractor[[transformers.VibeVoiceAcousticTokenizerFeatureExtractor]]

#### transformers.VibeVoiceAcousticTokenizerFeatureExtractor[[transformers.VibeVoiceAcousticTokenizerFeatureExtractor]]

```python
transformers.VibeVoiceAcousticTokenizerFeatureExtractor(feature_size = 1, sampling_rate = 24000, padding_value = 0.0, normalize_audio = True, target_dB_FS = -25, eps = 1e-06, pad_to_multiple_of = 3200, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/feature_extraction_vibevoice_acoustic_tokenizer.py#L29)

**Parâmetros:**

feature_size (`int`, *opcional*, padrão 1) : O número de canais.

sampling_rate (`int`, *opcional*, padrão 24000) : A taxa de amostragem na qual a forma de onda de áudio deve ser digitalizada, expressa em hertz (Hz).

padding_value (`float`, *opcional*, padrão 0.0) : O valor usado para preenchimento.

normalize_audio (`bool`, *opcional*, padrão `True`) : Se normalizar o áudio para um dB FS alvo.

target_dB_FS (`float`, *opcional*, padrão -25) : dB FS de destino para normalização.

eps (`float`, *opcional*, padrão 1e-06) : Um valor pequeno para evitar divisão por zero durante a normalização.

pad_to_multiple_of (`int`, *opcional*, padrão 3200) : Preenche o áudio até um múltiplo deste valor, que deve corresponder ao comprimento do salto (hop length) do tokenizador acústico, ou seja, o fator de redução de amostragem (downsampling) do seu codificador.

Constrói um extrator de recursos VibeVoiceAcousticTokenizer.

#### __call__[[transformers.VibeVoiceAcousticTokenizerFeatureExtractor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], sampling_rate: int | None = None, padding: bool | str | transformers.utils.generic.PaddingStrategy | None = True, pad_to_multiple_of: int | None = None, max_length: int | None = None, return_attention_mask: bool | None = True, return_tensors: str | None = 'pt', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/feature_extraction_vibevoice_acoustic_tokenizer.py#L72)

**Parâmetros:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]` : A sequência ou lote de sequências a ser processado. Cada sequência pode ser um array numpy, um tensor torch, uma lista de arrays numpy ou uma lista de tensors torch.

sampling_rate (`int`, *opcional*) : A taxa de amostragem na qual a entrada `audio` foi amostrada. É fortemente recomendável passar `sampling_rate` na chamada de forward para evitar erros silenciosos.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `True`) : Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:  - `True` ou `'longest'`: Aplica padding até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Aplica padding até um comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode retornar um lote com sequências de comprimentos diferentes).

pad_to_multiple_of (`int`, *opcional*) : Se definido, preenche a sequência até um múltiplo do valor fornecido. O padrão é `self.pad_to_multiple_of` se não for fornecido.

## VibeVoiceAcousticTokenizerModel[[transformers.VibeVoiceAcousticTokenizerModel]]

#### transformers.VibeVoiceAcousticTokenizerModel[[transformers.VibeVoiceAcousticTokenizerModel]]

```python
transformers.VibeVoiceAcousticTokenizerModel(config: VibeVoiceAcousticTokenizerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L503)

**Parâmetros:**

config ([VibeVoiceAcousticTokenizerConfig](/docs/transformers/main/pt/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

VibeVoice, um tokenizador acústico com um codificador e um decodificador para tokens acústicos contínuos.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### encode[[transformers.VibeVoiceAcousticTokenizerModel.encode]]

```python
encode(input_values, padding_cache = None, use_cache = None, sample = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L510)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`) : Forma de onda de áudio de entrada a ser codificada em representação latente.

padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *opcional*) : Objeto de cache para o modo de streaming, usado para manter os estados de convolução entre as camadas.

use_cache (`bool`, *opcional*) : Se deve usar cache para os estados de convolução.

sample (`bool`, *opcional*) : Se deve adicionar ruído gaussiano aos latentes (σ-VAE: a escala do ruído é extraída por item do lote de N(0, `config.vae_std`)). Se False, a saída do codificador é retornada como está.

#### decode[[transformers.VibeVoiceAcousticTokenizerModel.decode]]

```python
decode(latents, padding_cache = None, use_cache = False)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L537)

**Parâmetros:**

latents (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`) : Representação latente de entrada a ser decodificada de volta para áudio.

padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *opcional*) : Objeto de cache para o modo de streaming, usado para manter os estados de convolução entre as camadas.

use_cache (`bool`, *opcional*) : Se deve usar cache para os estados de convolução.

#### forward[[transformers.VibeVoiceAcousticTokenizerModel.forward]]

```python
forward(input_values, padding_cache = None, use_cache = False, sample = True, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L551)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, channels, sequence_length)`) : Forma de onda de áudio de entrada a ser codificada em representação latente.

padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *opcional*) : Objeto de cache para o modo de streaming, usado para manter os estados de convolução entre as camadas. Observe que é usado apenas pelo decodificador.

use_cache (`bool`, *opcional*) : Se deve usar cache para os estados de convolução.

sample (`bool`, *opcional*) : Se deve adicionar ruído gaussiano aos latentes (σ-VAE: a escala do ruído é extraída por item do lote de N(0, `config.vae_std`)). Se False, a saída do codificador é retornada como está.

O método forward do [VibeVoiceAcousticTokenizerModel](/docs/transformers/main/pt/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

## VibeVoiceAcousticTokenizerEncoderModel[[transformers.VibeVoiceAcousticTokenizerEncoderModel]]

#### transformers.VibeVoiceAcousticTokenizerEncoderModel[[transformers.VibeVoiceAcousticTokenizerEncoderModel]]

```python
transformers.VibeVoiceAcousticTokenizerEncoderModel(config: VibeVoiceAcousticTokenizerEncoderConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L373)

#### forward[[transformers.VibeVoiceAcousticTokenizerEncoderModel.forward]]

```python
forward(hidden_states, padding_cache = None, use_cache = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L394)

## VibeVoiceAcousticTokenizerDecoderModel[[transformers.VibeVoiceAcousticTokenizerDecoderModel]]

#### transformers.VibeVoiceAcousticTokenizerDecoderModel[[transformers.VibeVoiceAcousticTokenizerDecoderModel]]

```python
transformers.VibeVoiceAcousticTokenizerDecoderModel(config: VibeVoiceAcousticTokenizerDecoderConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L466)

#### forward[[transformers.VibeVoiceAcousticTokenizerDecoderModel.forward]]

```python
forward(hidden_states, padding_cache = None, use_cache = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice_acoustic_tokenizer/modeling_vibevoice_acoustic_tokenizer.py#L487)