Hugging Face's logo

Transformers documentation

DAC

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo se publicó en HF papers el 2023-06-11 y se contribuyó a Hugging Face Transformers el 2024-08-19.

DAC

Resumen

El modelo DAC fue propuesto en Descript Audio Codec: High-Fidelity Audio Compression with Improved RVQGAN 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. El código original se puede encontrar aquí.

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:

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

clase transformers.DacConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneencoder_hidden_size: int = 64downsampling_ratios: list[int] | tuple[int, ...] = (2, 4, 8, 8)decoder_hidden_size: int = 1536n_codebooks: int = 9codebook_size: int = 1024codebook_dim: int = 8quantizer_dropout: float | int = 0.0commitment_loss_weight: float = 0.25codebook_loss_weight: float = 1.0sampling_rate: int = 16000 )

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 downsampling en el codificador. Se utilizan en orden inverso para el upsampling 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 utilizados por el modelo.
  • codebook_size (int, opcional, valor predeterminado 1024) — El número de libros de códigos paralelos utilizados por 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 tasa 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

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

clase transformers.DacFeatureExtractor

< >

( feature_size: int = 1sampling_rate: int = 16000padding_value: float = 0.0hop_length: int = 512**kwargs )

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 tasa de muestreo a la que la forma de onda de audio debe digitalizarse, 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 las ventanas sucesivas.

Construye un extractor de características Dac.

Este extractor de características hereda de 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.

__call__

< >

( raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]padding: bool | str | transformers.utils.generic.PaddingStrategy | None = Nonetruncation: bool | None = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonesampling_rate: int | None = None )

Parámetros

  • raw_audio (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La secuencia o lote de secuencias a procesar. Cada secuencia puede ser un array de numpy, una lista de valores float, una lista de arrays de numpy o una lista de listas de valores float. El array de numpy debe tener 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, opcional, por defecto True) — Seleccione 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 generar un lote con secuencias de diferentes longitudes).
  • truncation (bool, opcional, valor predeterminado False) — Activa la truncación para recortar las secuencias de entrada más largas que max_length a max_length.
  • max_length (int, opcional) — Longitud máxima de la lista devuelta y, opcionalmente, longitud de relleno (véase arriba).
  • return_tensors (str o TensorType, opcional, valor predeterminado ‘pt’) — Si se establece, devolverá tensores en lugar de una lista de enteros de Python. Los valores aceptables son:
    • 'pt': Devuelve objetos torch.Tensor de PyTorch.
    • 'np': Devuelve objetos Numpy np.ndarray.
  • 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 de forward para evitar errores silenciosos.

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

DacModel

clase transformers.DacModel

< >

( config: DacConfig )

Parámetros

  • config (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() para cargar los pesos del modelo.

El modelo DAC (Descript Audio Codec).

Este modelo hereda de PreTrainedModel. Consulta 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 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

< >

( quantized_representation: typing.Optional[torch.Tensor] = Noneaudio_codes: typing.Optional[torch.Tensor] = Nonereturn_dict: bool | None = None ) → DacDecoderOutput or tuple(torch.Tensor)

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

< >

( input_values: Tensorn_quantizers: int | None = Nonereturn_dict: bool | None = None ) → DacEncoderOutput or tuple(torch.Tensor)

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

< >

( input_values: Tensorn_quantizers: int | None = Nonereturn_dict: bool | None = None ) → DacOutput or tuple(torch.Tensor)

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 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) y las entradas.

El método forward de 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 pre y postprocesamiento, 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:

>>> 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
Update on GitHub

←CSM Día→