# X-Codec2

## Resumen

El modelo X-Codec2 fue propuesto en [Llasa: Scaling Train-Time and Inference-Time Compute for Llama-based Speech Synthesis](https://huggingface.co/papers/2502.04128).

X-Codec2 es un códec de audio neuronal diseñado para mejorar la síntesis de voz y la generación de audio general en las tuberías de modelos de lenguaje de gran escala (LLM). Extiende el X-Codec original al refinar cómo se integran y tokenizan la información semántica y acústica, lo que permite una representación de audio eficiente y de alta fidelidad.

Sobre su arquitectura:
- **Tokenización semántico-acústica unificada**: X-Codec2 fusiona las salidas de un codificador semántico (p. ej., Wav2Vec2-BERT) y un codificador acústico en una única representación, capturando tanto el significado de alto nivel (p. ej., contenido textual, emoción) como los detalles de audio de bajo nivel (p. ej., timbre).
- **Cuantización escalar de características de un solo paso (FSQ)**: A diferencia de la VQ residual de múltiples capas utilizada en la mayoría de los enfoques (p. ej., [DAC](./dac), [EnCodec](./encodec), [X-Codec](./xcodec), [Mimi](./mimi)), X-Codec2 utiliza una sola capa de cuantización escalar de características (FSQ) para garantizar estabilidad y compatibilidad con LLMs causales y autoregresivos.
- **Diseño compatible con Transformers**: La estructura de tokens 1D de X-Codec2 se alinea de forma natural con el modelado autoregresivo en LLMs como LLaMA, lo que mejora la eficiencia del entrenamiento y la compatibilidad con tareas posteriores.

Hay un punto de control del modelo disponible en [HKUSTAudio/xcodec2-hf](https://huggingface.co/HKUSTAudio/xcodec2-hf).

Este modelo fue aportado por [Eric Bezzam](https://huggingface.co/bezzam) y [Steven Zheng](https://huggingface.co/Steveeeeeeen). El código de modelado original se puede encontrar [aquí](https://huggingface.co/HKUSTAudio/xcodec2/blob/main/modeling_xcodec2.py), mientras que su código de entrenamiento está [aquí](https://github.com/zhenye234/X-Codec-2.0).

## Ejemplo de uso 

Aquí hay un ejemplo rápido de cómo codificar y decodificar un audio con este modelo:

```python 
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

model_id = "HKUSTAudio/xcodec2-hf"
model = AutoModel.from_pretrained(model_id, device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio = dataset[0]["audio"]["array"]
inputs = feature_extractor(audio=audio, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(
    model.device, model.dtype
)
print("Input waveform shape:", inputs["input_values"].shape)
# Input waveform shape: torch.Size([1, 1, 93760])

# encoder and decoder
audio_codes = model.encode(**inputs).audio_codes
print("Audio codes shape:", audio_codes.shape)
# Audio codes shape: torch.Size([1, 1, 293])
audio_values = model.decode(audio_codes).audio_values
print("Audio values shape:", audio_values.shape)
# Audio values shape: torch.Size([1, 1, 93760])

# Equivalently, you can do encoding and decoding in one step
model_output = model(**inputs)
audio_codes = model_output.audio_codes
audio_values = model_output.audio_values
```

### Procesamiento por lotes

Esta implementación también admite entradas por lotes, a diferencia de la [versión original](https://huggingface.co/HKUSTAudio/xcodec2)

```python
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

batch_size = 2
model_id = "HKUSTAudio/xcodec2-hf"
model = AutoModel.from_pretrained(model_id, device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audios = [dataset[i]["audio"]["array"] for i in range(batch_size)]
inputs = feature_extractor(audio=audios, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(
    model.device, model.dtype
)
print("Input waveform shape:", inputs["input_values"].shape)
# Input waveform shape: torch.Size([2, 1, 93760])

# encoder and decoder
encoder_output = model.encode(**inputs)
audio_codes = encoder_output.audio_codes
print("Audio codes shape:", audio_codes.shape)
# Audio codes shape: torch.Size([2, 1, 293])
audio_values = model.decode(audio_codes).audio_values
print("Audio values shape:", audio_values.shape)
# Audio values shape: torch.Size([2, 1, 93760])

# Equivalently, you can do encoding and decoding in one step
model_output = model(**inputs)
audio_codes = model_output.audio_codes
audio_values = model_output.audio_values
```

### Aceleración con `torch.compile`

Puede acelerar la inferencia con [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html). Las primeras llamadas serán más lentas debido a la sobrecarga de compilación, pero las llamadas posteriores serán más rápidas.

En una A100, observamos una aceleración de ~1.35 para un tamaño de lote de 4 ([script](https://gist.github.com/ebezzam/3b79481b5d48d8e35c4ecc582aee0cb3#file-benchmark_torch_compile-py)).

```python
import torch
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

batch_size = 4
model_id = "HKUSTAudio/xcodec2-hf"
model = AutoModel.from_pretrained(model_id, device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audios = [dataset[i]["audio"]["array"] for i in range(batch_size)]
inputs = feature_extractor(
    audio=audios, sampling_rate=feature_extractor.sampling_rate, padding=True, return_tensors="pt"
).to(model.device, model.dtype)

compiled_model = torch.compile(model, fullgraph=True)

# Warmup (includes compilation on first call)
for _ in range(10):
    with torch.inference_mode():
        _ = compiled_model(**inputs)

with torch.inference_mode():
    output = compiled_model(**inputs)
print("Audio values shape:", output.audio_values.shape)
```

## Xcodec2Config[[transformers.Xcodec2Config]]

#### transformers.Xcodec2Config[[transformers.Xcodec2Config]]

```python
transformers.Xcodec2Config(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, hidden_size: int = 1024, intermediate_size: int = 4096, num_hidden_layers: int = 12, num_attention_heads: int = 16, num_key_value_heads: int = 16, hidden_act: str = 'silu', max_position_embeddings: int = 4096, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, pad_token_id: int | None = None, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, head_dim: int = 64, encoder_hidden_size: int = 48, downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 4, 5), semantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, sampling_rate: int = 16000, activation_dropout: float = 0.1, quantization_dim: int = 2048, quantization_levels: list[int] | tuple[int, ...] = (4, 4, 4, 4, 4, 4, 4, 4))
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/configuration_xcodec2.py#L33)

**Parámetros:**

hidden_size (`int`, *opcional*, valor predeterminado `1024`) : Dimensión de las representaciones ocultas.

intermediate_size (`int`, *opcional*, valor predeterminado `4096`) : Dimensión de las representaciones MLP.

num_hidden_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer.

num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer.

num_key_value_heads (`int`, *opcional*, valor predeterminado `16`) : Este es el número de cabezas de key_value que se deben utilizar para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo utilizará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo utilizará Multi Query Attention (MQA); en caso contrario, se utilizará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante el promedio (meanpooling) de todas las cabezas originales dentro de ese grupo. Para más detalles, consulte [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

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

max_position_embeddings (`int`, *opcional*, valor predeterminado `4096`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

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

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

pad_token_id (`int`, *opcional*) : Id de token utilizado para el relleno en el vocabulario.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `False`) : Si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largas.

attention_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un sesgo en las capas de proyección de consulta, clave, valor y salida durante la autoatención.

attention_dropout (`Union[int, float]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

head_dim (`int`, *opcional*, valor predeterminado `64`) : La dimensión de la cabeza de atención. Si es None, se establecerá en hidden_size // num_attention_heads

encoder_hidden_size (`int`, *opcional*, valor predeterminado `48`) : Dimensión de las representaciones ocultas.

downsampling_ratios (`list[int]`, *opcional*, valor predeterminado `[2, 2, 4, 4, 5]`) : Proporciones para el muestreo descendente en el codificador.

semantic_model_config (`Union[Dict, Wav2Vec2BertConfig]`, *opcional*) : Una instancia del objeto de configuración para el modelo semántico (Wav2Vec2BertConfig).

sampling_rate (`int`, *opcional*, valor predeterminado `16000`) : La frecuencia de muestreo a la que deben digitalizarse los archivos de audio, expresada en hercios (Hz).

activation_dropout (`float`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las activaciones dentro de la capa totalmente conectada.

quantization_dim (`int`, *opcional*, valor predeterminado 2048) : Dimensión del libro de códigos de la cuantización de vectores.

quantization_levels (`list[int]`, *opcional*, valor predeterminado `[4, 4, 4, 4, 4, 4, 4, 4]`) : Niveles para el libro de códigos de cuantización vectorial.

Esta es la clase de configuración para almacenar la configuración de un Xcodec2Model. Se utiliza para instanciar un modelo Xcodec2 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 [HKUSTAudio/xcodec2-hf](https://huggingface.co/HKUSTAudio/xcodec2-hf)

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 Xcodec2Config, Xcodec2Model

>>> # Initializing configuration
>>> configuration = Xcodec2Config()

>>> # Initializing a model (with random weights) from the configuration
>>> model = Xcodec2Model(configuration)

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

## Xcodec2FeatureExtractor[[transformers.Xcodec2FeatureExtractor]]

#### transformers.Xcodec2FeatureExtractor[[transformers.Xcodec2FeatureExtractor]]

```python
transformers.Xcodec2FeatureExtractor(feature_size = 80, sampling_rate = 16000, padding_value = 1.0, hop_length = 320, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/feature_extraction_xcodec2.py#L37)

**Parámetros:**

feature_size (`int`, *opcional*, valor predeterminado 80) : La dimensión de las características de las características extraídas.

sampling_rate (`int`, *opcional*, valor predeterminado 16000) : La frecuencia de muestreo a la que se deben digitalizar los archivos de audio, expresada en hercios (Hz).

padding_value (`float`, *opcional*, valor predeterminado 1.0) : El valor que se utiliza para rellenar los vectores de relleno del espectrograma mel.

hop_length (`int`, *opcional*, valor predeterminado 320) : Número de muestras de audio codificadas por cuadro. Equivale al producto de las ratios de reducción de muestreo. Necesario para el relleno de la entrada del codificador acústico.

Construye un extractor de características de Xcodec2, que calcula las características del banco de filtros mel para el codificador semántico y el audio relleno para el codificador acústico.

Este extractor de características hereda de [SequenceFeatureExtractor](/docs/transformers/main/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

#### __llamada__[[transformers.Xcodec2FeatureExtractor.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/feature_extraction_xcodec2.py#L85)

**Parámetros:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Matriz de Numpy o tensor de torch con forma (num_channels, sequence_length). También se puede proporcionar una lista de dichas matrices o tensores para un lote de entradas.

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

max_length (`int`, *opcional*) : Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (ver arriba).

truncation (`bool`) : Activa el recorte para cortar las secuencias de entrada más largas que *max_length* hasta *max_length*.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'tf'`: Devuelve objetos `tf.constant` de TensorFlow. - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

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

device (`str`, *opcional*, valor predeterminado `"cpu"`) : Dispositivo para los tensores de PyTorch durante la extracción de características del banco de filtros mel.

kwargs (*opcional*) : Diccionario restante de argumentos por nombre que se pasará al tokenizador o al extractor de características.

## Xcodec2Model[[transformers.Xcodec2Model]]

#### transformers.Xcodec2Model[[transformers.Xcodec2Model]]

```python
transformers.Xcodec2Model(config: Xcodec2Config)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L939)

**Parámetros:**

config ([Xcodec2Config](/docs/transformers/main/es/model_doc/xcodec2#transformers.Xcodec2Config)) : 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.

Modelo de códec de audio neuronal Xcodec2.

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.

#### decode[[transformers.Xcodec2Model.decode]]

```python
decode(audio_codes: typing.Optional[torch.Tensor] = None, latents: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L1012)

**Parámetros:**

audio_codes (`torch.LongTensor` de forma `(batch_size, 1, codes_length)`) : Índices de códigos discretos calculados usando `model.encode`.

latents (`torch.Tensor` de forma `(batch_size, dimension, time_steps)`, *opcional*) : Representación continua cuantizada de la entrada.

**Devuelve:** `Xcodec2DecoderOutput` o `tuple(torch.Tensor)`

Un `Xcodec2DecoderOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración (`None`) y las entradas.

- **audio_values** (`torch.Tensor` de forma `(batch_size, 1, segment_length)`, *opcional*) -- Valores de la forma de onda de audio decodificada en el dominio del tiempo, obtenidos al convertir los códigos discretos de vuelta en señales de audio continuas. Esto representa el audio reconstruido que se puede reproducir.

#### encode[[transformers.Xcodec2Model.encode]]

```python
encode(input_values: Tensor, input_features: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, output_latents: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L958)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, 1, sequence_length)`) : Forma de onda de audio de entrada.

input_features (`torch.Tensor` de forma `(batch_size, mel_bins, time_steps)`) : Espectrograma mel de audio de entrada para la codificación semántica.

padding_mask (`torch.Tensor` de forma `(batch_size, 1, sequence_length)`) : Máscara de relleno utilizada para rellenar `input_values`.

input_features_mask (`torch.Tensor` de forma `(batch_size, time_steps)`, *opcional*) : Máscara de atención para la entrada de espectrograma al codificador semántico. `1` para los fotogramas válidos, `0` para el relleno.

output_latents (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver la representación latente continua del cuantizador.

**Devuelve:** `Xcodec2EncoderOutput` o `tuple(torch.Tensor)`

Un `Xcodec2EncoderOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración (`None`) y las entradas.

- **audio_codes** (`torch.LongTensor` de forma `(batch_size, 1, codes_length)`, *opcional*) -- Incrustaciones de códigos discretos calculadas con `model.encode`. Estas representan la forma comprimida y cuantizada de la señal de audio de entrada, que puede utilizarse para almacenamiento, transmisión o generación.
- **latents** (`torch.Tensor` de forma `(batch_size, dimension, time_steps)`) -- Representación continua cuantizada del embedding de la entrada.
- **audio_codes_mask** (`torch.int32` de forma `(batch_size, 1, codes_length)`, *opcional*) -- `padding_mask` submuestreado para indicar los códigos de audio válidos en `audio_codes`.

#### forward[[transformers.Xcodec2Model.forward]]

```python
forward(input_values: Tensor, input_features: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, output_latents: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L1037)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, 1, sequence_length)`) : Forma de onda de audio de entrada.

input_features (`torch.Tensor` de forma `(batch_size, mel_bins, time_steps)`) : Espectrograma mel de audio de entrada para la codificación semántica.

padding_mask (`torch.Tensor` de forma `(batch_size, 1, sequence_length)`) : Máscara de relleno utilizada para rellenar `input_values`.

input_features_mask (`torch.Tensor` de forma `(batch_size, time_steps)`, *opcional*) : Máscara de atención para la entrada de espectrograma al codificador semántico. `1` para los fotogramas válidos, `0` para el relleno.

output_latents (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver la representación latente continua del cuantizador.

**Devuelve:** `Xcodec2Output` o `tuple(torch.Tensor)`

Un `Xcodec2Output` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración (`None`) y las entradas.

El método forward de [Xcodec2Model](/docs/transformers/main/es/model_doc/xcodec2#transformers.Xcodec2Model) reemplaza 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.

- **audio_values** (`torch.Tensor` de forma `(batch_size, 1, sequence_length)`, *opcional*) -- Valores de la forma de onda de audio decodificados en el dominio del tiempo, obtenidos mediante la parte decodificadora de Xcodec2. Estos representan la señal de audio reconstruida.
- **audio_codes** (`torch.LongTensor` de forma `(batch_size, 1, codes_length)`, *opcional*) -- Incrustaciones de códigos discretos calculadas mediante `model.encode`. Estas son las representaciones cuantizadas del audio de entrada utilizadas para un procesamiento o generación posteriores.
- **latents** (`torch.Tensor` de forma `(batch_size, dimension, time_steps)`) -- Representación continua cuantizada del embedding de la entrada.
- **audio_codes_mask** (`torch.int32` de forma `(batch_size, 1, codes_length)`, *opcional*) -- `padding_mask` submuestreado para indicar los códigos de audio válidos en `audio_codes`.

Ejemplos:

```python
>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, Xcodec2Model

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio = dataset["train"]["audio"][0]["array"]

>>> model_id = "HKUSTAudio/xcodec2-hf"
>>> model = Xcodec2Model.from_pretrained(model_id)
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

>>> inputs = feature_extractor(audio=audio, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values
```