# DAC

## Resumen

El modelo DAC fue propuesto en [Descript Audio Codec: High-Fidelity Audio Compression with Improved RVQGAN](https://huggingface.co/papers/2306.06546) por Rithesh Kumar, Prem Seetharaman, Alejandro Luebs, Ishaan Kumar y Kundan Kumar.

El modelo Descript Audio Codec (DAC) es una herramienta potente para comprimir datos de audio, lo que lo hace altamente eficiente para el almacenamiento y la transmisión. Al comprimir audio de 44,1 KHz en tokens con solo 8 kbps de ancho de banda, el modelo DAC permite un procesamiento de audio de alta calidad reduciendo significativamente la huella de datos. Esto resulta especialmente útil en escenarios donde el ancho de banda es limitado o el espacio de almacenamiento es escaso, como en aplicaciones de streaming, conferencias remotas y el archivo de grandes conjuntos de datos de audio.

El resumen del artículo es el siguiente:

*Los modelos de lenguaje se han utilizado con éxito para modelar señales naturales, como imágenes, voz y música. Un componente clave de estos modelos es un modelo de compresión neuronal de alta calidad que puede comprimir señales naturales de alta dimensión en tokens discretos de menor dimensión. Con ese fin, presentamos un algoritmo universal de compresión neuronal de audio de alta fidelidad que logra una compresión de ~90x de audio de 44,1 KHz en tokens con solo 8 kbps de ancho de banda. Logramos esto combinando avances en la generación de audio de alta fidelidad con mejores técnicas de cuantización vectorial del dominio de imágenes, junto con pérdidas adversarias y de reconstrucción mejoradas. Comprimimos todos los dominios (voz, entorno, música, etc.) con un único modelo universal, lo que lo hace ampliamente aplicable al modelado generativo de todo tipo de audio. Comparamos con algoritmos de compresión de audio competidores y encontramos que nuestro método los supera significativamente. Proporcionamos abstracciones exhaustivas para cada elección de diseño, así como código de código abierto y pesos de modelos entrenados. Esperamos que nuestro trabajo pueda sentar las bases para la próxima generación de modelado de audio de alta fidelidad.*

Este modelo fue aportado por [Kamil Akesbi](https://huggingface.co/kamilakesbi). El código original se puede encontrar [aquí](https://github.com/descriptinc/descript-audio-codec/tree/main?tab=readme-ov-file).

## Estructura del modelo

El modelo Descript Audio Codec (DAC) está estructurado en tres etapas distintas:

1. Modelo codificador: esta etapa comprime la entrada de audio, reduciendo su tamaño mientras conserva la información esencial.
2. Modelo de cuantizador vectorial residual (RVQ): trabajando en conjunto con el codificador, este modelo cuantiza los códigos latentes del audio, refinando la compresión y garantizando una reconstrucción de alta calidad.
3. Modelo decodificador: esta etapa final reconstruye el audio a partir de su forma comprimida, restituyéndolo a un estado que se asemeja estrechamente a la entrada original.

## 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 AutoProcessor, DacModel

librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

model = DacModel.from_pretrained("descript/dac_16khz", device_map="auto")
processor = AutoProcessor.from_pretrained("descript/dac_16khz")
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt").to(model.device)

encoder_outputs = model.encode(inputs["input_values"])
# Get the intermediate audio codes
audio_codes = encoder_outputs.audio_codes
# Reconstruct the audio from its quantized representation
audio_values = model.decode(encoder_outputs.quantized_representation)
# or the equivalent with a forward pass
audio_values = model(inputs["input_values"]).audio_values
```

## DacConfig[[transformers.DacConfig]]

#### transformers.DacConfig[[transformers.DacConfig]]

```python
transformers.DacConfig(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, encoder_hidden_size: int = 64, downsampling_ratios: list[int] | tuple[int, ...] = (2, 4, 8, 8), decoder_hidden_size: int = 1536, n_codebooks: int = 9, codebook_size: int = 1024, codebook_dim: int = 8, quantizer_dropout: float | int = 0.0, commitment_loss_weight: float = 0.25, codebook_loss_weight: float = 1.0, sampling_rate: int = 16000)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/configuration_dac.py#L27)

**Parámetros:**

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

downsampling_ratios (`list[int]`, *opcional*, valor predeterminado `[2, 4, 8, 8]`) : Proporciones para el muestreo descendente en el codificador. Se utilizan en orden inverso para el muestreo ascendente en el decodificador.

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

n_codebooks (`int`, *opcional*, valor predeterminado `9`) : El número de libros de códigos paralelos que utiliza el modelo.

codebook_size (`int`, *opcional*, valor predeterminado `1024`) : El número de libros de códigos paralelos que utiliza el modelo.

codebook_dim (`int`, *opcional*, valor predeterminado `8`) : Dimensionalidad de cada vector de incrustación del libro de códigos.

quantizer_dropout (`bool`, *opcional*, valor predeterminado 0) : Si se aplica dropout al cuantizador.

commitment_loss_weight (`float`, *opcional*, valor predeterminado 0.25) : Peso del término de pérdida de compromiso en la función de pérdida de VQVAE.

codebook_loss_weight (`float`, *opcional*, valor predeterminado 1.0) : Peso del término de pérdida del codebook en la función de pérdida de VQVAE.

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

Esta es la clase de configuración para almacenar la configuración de un DacModel. Se utiliza para instanciar un modelo Dac 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 [descript/dac_16khz](https://huggingface.co/descript/dac_16khz)

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 DacModel, DacConfig

>>> # Initializing a "descript/dac_16khz" style configuration
>>> configuration = DacConfig()

>>> # Initializing a model (with random weights) from the "descript/dac_16khz" style configuration
>>> model = DacModel(configuration)

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

## DacFeatureExtractor[[transformers.DacFeatureExtractor]]

#### transformers.DacFeatureExtractor[[transformers.DacFeatureExtractor]]

```python
transformers.DacFeatureExtractor(feature_size: int = 1, sampling_rate: int = 16000, padding_value: float = 0.0, hop_length: int = 512, **kwargs)
```

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

**Parámetros:**

feature_size (`int`, *opcional*, valor predeterminado 1) : La dimensión de las características de las características extraídas. Use 1 para mono y 2 para estéreo.

sampling_rate (`int`, *opcional*, valor predeterminado 16000) : 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.

hop_length (`int`, *opcional*, valor predeterminado 512) : Longitud de solapamiento entre ventanas sucesivas.

Construye un extractor de características Dac.

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.DacFeatureExtractor.__call__]]

```python
__call__(raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy | None = None, truncation: bool | None = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/feature_extraction_dac.py#L57)

**Parámetros:**

raw_audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : La secuencia o el lote de secuencias a procesar. Cada secuencia puede ser un array de numpy, una lista de valores flotantes, una lista de arrays de numpy o una lista de listas de valores flotantes. El array de numpy debe tener la forma `(num_samples,)` para audio mono (`feature_size = 1`), o `(2, num_samples)` para audio estéreo (`feature_size = 2`).

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

truncation (`bool`, *opcional*, valor predeterminado `False`) : Activa la truncación para recortar las secuencias de entrada más largas que `max_length` hasta `max_length`.

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

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*, valor predeterminado 'pt') : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'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 de `audio`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos.

Método principal para extraer características y preparar una o varias secuencias para el modelo.

## DacModel[[transformers.DacModel]]

#### transformers.DacModel[[transformers.DacModel]]

```python
transformers.DacModel(config: DacConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L563)

**Parámetros:**

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

El modelo DAC (Descript Audio Codec).

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.DacModel.decode]]

```python
decode(quantized_representation: typing.Optional[torch.Tensor] = None, audio_codes: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L609)

**Parámetros:**

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

audio_codes (`torch.Tensor` de forma `(batch_size, num_codebooks, time_steps)`, *opcional*) : Los índices de codebook para cada codebook, que representan la representación discreta cuantizada de la entrada. Este parámetro debe proporcionarse si se desea decodificar directamente desde los códigos de audio (sustituirá a quantized_representation).

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `DacDecoderOutput` en lugar de una tupla simple.

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

Un `DacDecoderOutput` 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 ([DacConfig](/docs/transformers/main/es/model_doc/dac#transformers.DacConfig)) y las entradas.

- **audio_values** (`torch.Tensor` de forma `(batch_size, input_length)`, *opcional*) -- Valores de audio decodificados, obtenidos mediante la parte decodificadora de Dac.

#### encode[[transformers.DacModel.encode]]

```python
encode(input_values: Tensor, n_quantizers: int | None = None, return_dict: bool | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L582)

**Parámetros:**

input_values (`torch.Tensor of shape `(batch_size, 1, time_steps)`) : Datos de audio de entrada para codificar,

n_quantizers (`int`, *opcional*) : Número de cuantizadores a utilizar. Si es None, se utilizan todos los cuantizadores. El valor predeterminado es None.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

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

Un `DacEncoderOutput` 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 ([DacConfig](/docs/transformers/main/es/model_doc/dac#transformers.DacConfig)) y las entradas.

- **loss** (`torch.Tensor`, *opcional*) -- Pérdida del modelo codificador, que comprende la combinación ponderada de las pérdidas de compromiso y del libro de códigos.
- **quantized_representation** (`torch.Tensor` de forma `(batch_size, dimension, time_steps)`, *opcional*) -- Representación continua cuantizada de la entrada.
- **audio_codes** (`torch.Tensor` de forma `(batch_size, num_codebooks, time_steps)`, *opcional*) -- Índices de codebook para cada codebook (representación discreta cuantizada de la entrada).
- **projected_latents** (`torch.Tensor` de forma `(batch_size, num_codebooks * dimension, time_steps)`, *opcional*) -- Latentes proyectados (representación continua de la entrada antes de la cuantización).

#### forward[[transformers.DacModel.forward]]

```python
forward(input_values: Tensor, n_quantizers: int | None = None, return_dict: bool | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/dac/modeling_dac.py#L642)

**Parámetros:**

input_values (`torch.Tensor` de forma `(batch_size, 1, time_steps)`) : Datos de audio para codificar.

n_quantizers (`int`, *opcional*) : Número de cuantizadores a utilizar. Si es `None`, se utilizan todos los cuantizadores. El valor predeterminado es `None`.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

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

Un `DacOutput` 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 ([DacConfig](/docs/transformers/main/es/model_doc/dac#transformers.DacConfig)) y las entradas.

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

- **loss** (`torch.Tensor`, *opcional*) -- Pérdida del modelo codificador, que comprende la combinación ponderada de las pérdidas de compromiso y del libro de códigos.
- **audio_values** (`torch.Tensor` de forma `(batch_size, input_length)`) -- Datos de audio reconstruidos.
- **quantized_representation** (`torch.Tensor` de forma `(batch_size, dimension, time_steps)`) -- Representación continua cuantizada de la entrada.
- **audio_codes** (`torch.LongTensor` de forma `(batch_size, num_codebooks, time_steps)`) -- Índices de codebook para cada codebook (representación discreta cuantizada de la entrada).
- **projected_latents** (`torch.Tensor` de forma `(batch_size, num_codebooks * dimension, time_steps)`) -- Latentes proyectados (representación continua de la entrada antes de la cuantización).

Ejemplos:

```python
>>> from datasets import load_dataset, Audio
>>> from transformers import DacModel, AutoProcessor
>>> librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> model = DacModel.from_pretrained("descript/dac_16khz")
>>> processor = AutoProcessor.from_pretrained("descript/dac_16khz")
>>> librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
>>> audio_sample = librispeech_dummy[-1]["audio"]["array"]
>>> inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt")

>>> encoder_outputs = model.encode(inputs["input_values"])
>>> # Get the intermediate audio codes
>>> audio_codes = encoder_outputs.audio_codes
>>> # Reconstruct the audio from its quantized representation
>>> audio_values = model.decode(encoder_outputs.quantized_representation)
>>> # or the equivalent with a forward pass
>>> audio_values = model(inputs["input_values"]).audio_values
```