# VibeVoice Acoustic Tokenizer

## Resumen

[VibeVoice](https://huggingface.co/papers/2508.19205) es un marco novedoso para sintetizar audio de alta fidelidad y de larga duración con múltiples hablantes, empleando un enfoque de difusión de próximo token dentro de una estructura de modelo de lenguaje de gran escala (LLM). Está diseñado para capturar la auténtica "vibe" conversacional y es especialmente adecuado para generar contenido de audio como podcasts y audiolibros con múltiples participantes.

Una característica clave de VibeVoice es el uso de dos tokenizadores de audio continuos, uno para extraer características acústicas y otro para características semánticas.

Hay un punto de control del modelo disponible en [microsoft/VibeVoice-AcousticTokenizer](https://huggingface.co/microsoft/VibeVoice-AcousticTokenizer)

Este modelo fue aportado por [Eric Bezzam](https://huggingface.co/bezzam).

## Arquitectura

La arquitectura es una estructura codificador-decodificador simétrica por espejo. El codificador emplea un diseño jerárquico con 7 etapas de bloques similares a ConvNeXt, que utilizan convoluciones causales de profundidad 1D para un procesamiento de streaming eficiente. Seis capas de muestreo descendente logran una tasa de muestreo descendente acumulada de 3200X a partir de una entrada de 24kHz, lo que produce 7,5 tokens/marcos por segundo. Cada componente codificador/decodificador tiene aproximadamente 340M de parámetros, para un total de alrededor de 680M de parámetros. El objetivo de entrenamiento sigue el de [DAC](./dac), incluyendo sus diseños de discriminador y de pérdida.

Acoustic Tokenizer adopta los principios de un Variational Autoencoder (VAE). El codificador mapea el audio de entrada a los parámetros de una distribución latente, a saber, la media. Junto con una desviación estándar fija, se muestrea un vector latente utilizando el truco de reparametrización. Consulte el [informe técnico](https://huggingface.co/papers/2508.19205) para obtener más detalles.

## Uso

A continuación se muestra un ejemplo de uso para codificar y decodificar audio:

```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 o TTS en streaming, donde es necesario hacer seguimiento de los estados en caché, se puede usar el parámetro `use_cache` al codificar o decodificar el audio:

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

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

**Parámetros:**

channels (`int`, *opcional*, valor predeterminado 1) : Número de canales de entrada.

hidden_size (`int`, *opcional*, valor predeterminado 64) : Dimensionalidad de las representaciones latentes.

kernel_size (`int`, *opcional*, valor predeterminado 7) : Tamaño del kernel para las capas convolucionales.

rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización rms.

layer_scale_init_value (`float`, *opcional*, valor predeterminado `1e-06`) : Escala a utilizar en las capas de autoatención. 0.1 para base, 1e-6 para large. Establezca 0 para deshabilitar la escala de capa.

initializer_range (`float`, *opcional*, valor predeterminado `0.01`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

num_filters (`int`, *opcional*, valor predeterminado 32) : Número de filtros en la capa convolucional inicial, que se duplica tras cada muestreo descendente.

downsampling_ratios (`List[int]`, *opcional*, valor predeterminado `[2, 2, 4, 5, 5, 8]`) : Ratios de reducción de muestreo para cada capa.

depths (`List[int]`, *opcional*, valor predeterminado `[3, 3, 3, 3, 3, 3, 8]`) : Número de bloques ConvNeXt en cada etapa.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

ffn_expansion (`int`, *opcional*, valor predeterminado 4) : Factor de expansión para las redes feed-forward.

vae_std (`float`, *opcional*, valor predeterminado 0.625) : Desviación estándar de la distribución gaussiana de la que se extrae la escala de ruido por muestra cuando se añade ruido a los latentes del codificador (`sample=True`).

Esta es la clase de configuración para almacenar la configuración de un VibeVoiceAcousticTokenizerModel. Se utiliza para instanciar un modelo Vibevoice Acoustic Tokenizer según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [microsoft/VibeVoice-1.5B](https://huggingface.co/microsoft/VibeVoice-1.5B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**Parámetros:**

channels (`int`, *opcional*, valor predeterminado 1) : Número de canales de entrada.

hidden_size (`int`, *opcional*, valor predeterminado 64) : Dimensionalidad de las representaciones latentes.

kernel_size (`int`, *opcional*, valor predeterminado 7) : Tamaño del kernel para las capas convolucionales.

rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización rms.

layer_scale_init_value (`float`, *opcional*, valor predeterminado `1e-06`) : Escala a utilizar en las capas de autoatención. 0.1 para base, 1e-6 para large. Establezca 0 para deshabilitar la escala de capa.

initializer_range (`float`, *opcional*, valor predeterminado `0.01`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

num_filters (`int`, *opcional*, valor predeterminado 32) : Número de filtros en la capa convolucional inicial, que se duplica tras cada muestreo descendente.

downsampling_ratios (`List[int]`, *opcional*, valor predeterminado `[2, 2, 4, 5, 5, 8]`) : Ratios de reducción de muestreo para cada capa.

depths (`List[int]`, *opcional*, valor predeterminado `[3, 3, 3, 3, 3, 3, 8]`) : Número de bloques ConvNeXt en cada etapa.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

ffn_expansion (`int`, *opcional*, valor predeterminado 4) : Factor de expansión para las redes feed-forward.

vae_std (`float`, *opcional*, valor predeterminado 0.625) : Desviación estándar de la distribución gaussiana de la que se extrae la escala de ruido por muestra cuando se añade ruido a los latentes del codificador (`sample=True`).

Esta es la clase de configuración para almacenar la configuración de un VibeVoiceAcousticTokenizerModel. Se utiliza para instanciar un modelo Vibevoice Acoustic Tokenizer según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [microsoft/VibeVoice-1.5B](https://huggingface.co/microsoft/VibeVoice-1.5B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

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

**Parámetros:**

channels (`int`, *opcional*, valor predeterminado 1) : Número de canales de entrada.

hidden_size (`int`, *opcional*, valor predeterminado 64) : Dimensionalidad de las representaciones latentes.

kernel_size (`int`, *opcional*, valor predeterminado 7) : Tamaño del kernel para las capas convolucionales.

rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización rms.

layer_scale_init_value (`float`, *opcional*, valor predeterminado `1e-06`) : Escala a utilizar en las capas de autoatención. 0.1 para base, 1e-6 para large. Establezca 0 para deshabilitar la escala de capa.

initializer_range (`float`, *opcional*, valor predeterminado `0.01`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

num_filters (`int`, *opcional*, valor predeterminado 32) : Número de filtros en la capa convolucional inicial, que se duplica tras cada muestreo descendente.

downsampling_ratios (`List[int]`, *opcional*, valor predeterminado `[2, 2, 4, 5, 5, 8]`) : Ratios de reducción de muestreo para cada capa.

depths (`List[int]`, *opcional*, valor predeterminado `[3, 3, 3, 3, 3, 3, 8]`) : Número de bloques ConvNeXt en cada etapa.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

ffn_expansion (`int`, *opcional*, valor predeterminado 4) : Factor de expansión para las redes feed-forward.

vae_std (`float`, *opcional*, valor predeterminado 0.625) : Desviación estándar de la distribución gaussiana de la que se extrae la escala de ruido por muestra cuando se añade ruido a los latentes del codificador (`sample=True`).

Esta es la clase de configuración para almacenar la configuración de un VibeVoiceAcousticTokenizerModel. Se utiliza para instanciar un modelo Vibevoice Acoustic Tokenizer según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [microsoft/VibeVoice-1.5B](https://huggingface.co/microsoft/VibeVoice-1.5B)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

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

[Fuente](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*, valor predeterminado 1) : El número de canales.

sampling_rate (`int`, *opcional*, valor predeterminado 24000) : La frecuencia de muestreo a la que se debe digitalizar la forma de onda de audio, expresada en hercios (Hz).

padding_value (`float`, *opcional*, valor predeterminado 0.0) : El valor que se utiliza para el relleno.

normalize_audio (`bool`, *opcional*, valor predeterminado `True`) : Si se debe normalizar el audio a un nivel objetivo en dB FS.

target_dB_FS (`float`, *opcional*, valor predeterminado: -25) : dB FS objetivo para la normalización.

eps (`float`, *opcional*, valor predeterminado 1e-06) : Un valor pequeño para evitar la división por cero al normalizar.

pad_to_multiple_of (`int`, *opcional*, valor predeterminado 3200) : Rellena el audio hasta un múltiplo de este valor, que debe corresponder a la longitud del salto del tokenizador acústico, es decir, al factor de muestreo descendente de su codificador.

Construye un extractor de características VibeVoiceAcousticTokenizer.

#### __llamada__[[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)
```

[Fuente](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]` : La secuencia o el lote de secuencias a procesar. Cada secuencia puede ser un array de numpy, un tensor de torch, una lista de arrays de numpy o una lista de tensores de torch.

sampling_rate (`int`, *opcional*) : La tasa de muestreo a la que se muestreó la entrada de `audio`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/main/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `True`) : Selecciona una estrategia para rellenar las secuencias devueltas (según el lado de relleno y el índice de relleno del modelo) entre:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede devolver un lote con secuencias de longitudes diferentes).

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellena la secuencia hasta un múltiplo del valor proporcionado. Si no se proporciona, el valor predeterminado es `self.pad_to_multiple_of`.

## VibeVoiceAcousticTokenizerModel[[transformers.VibeVoiceAcousticTokenizerModel]]

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

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

[Fuente](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/es/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

VibeVoice, un tokenizador acústico con un codificador y un decodificador para tokens acústicos continuos.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

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

[Fuente](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 audio de entrada que se codificará en una representación latente.

padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *opcional*) : Objeto de caché para el modo de transmisión que mantiene los estados de convolución entre capas.

use_cache (`bool`, *opcional*) : Si se debe usar caché para los estados de convolución.

sample (`bool`, *opcional*) : Indica si se debe añadir ruido gaussiano a los latentes (σ-VAE: la escala del ruido se extrae por elemento del lote de N(0, `config.vae_std`)). Si es False, se devuelve la salida del codificador tal cual.

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

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

[Fuente](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)`) : Representación latente de entrada que se decodificará de nuevo en audio.

padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *opcional*) : Objeto de caché para el modo de transmisión que mantiene los estados de convolución entre capas.

use_cache (`bool`, *opcional*) : Si se debe usar caché para los estados de convolución.

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

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

[Fuente](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 audio de entrada que se codificará en una representación latente.

padding_cache (`VibeVoiceAcousticTokenizerConv1dPaddingCache`, *opcional*) : Objeto de caché para el modo de transmisión que mantiene los estados de convolución entre capas. Tenga en cuenta que solo se utiliza en el decodificador.

use_cache (`bool`, *opcional*) : Si se debe usar caché para los estados de convolución.

sample (`bool`, *opcional*) : Indica si se debe añadir ruido gaussiano a los latentes (σ-VAE: la escala del ruido se extrae por elemento del lote de N(0, `config.vae_std`)). Si es False, se devuelve la salida del codificador tal cual.

El método forward de [VibeVoiceAcousticTokenizerModel](/docs/transformers/main/es/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

## VibeVoiceAcousticTokenizerEncoderModel[[transformers.VibeVoiceAcousticTokenizerEncoderModel]]

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

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

[Fuente](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)
```

[Fuente](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)
```

[Fuente](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)
```

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