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

Ce modèle a été publié dans HF papers le 2023-06-11 et ajouté à Hugging Face Transformers le 2024-08-19.

DAC

Aperçu

Le modèle DAC a été proposé dans Descript Audio Codec: High-Fidelity Audio Compression with Improved RVQGAN par Rithesh Kumar, Prem Seetharaman, Alejandro Luebs, Ishaan Kumar, Kundan Kumar.

Le modèle Descript Audio Codec (DAC) est un outil puissant pour la compression des données audio, ce qui le rend très efficace pour le stockage et la transmission. En compressant l'audio 44,1 KHz en jetons avec une bande passante de seulement 8 kbps, le modèle DAC permet un traitement audio de haute qualité tout en réduisant considérablement l'empreinte des données. Cela est particulièrement utile dans les scénarios où la bande passante est limitée ou l'espace de stockage est précieux, comme dans les applications de streaming, les conférences à distance et l'archivage de grands jeux de données audio.

L'abstract de l'article est le suivant :

Les modèles de langage ont été utilisés avec succès pour modéliser des signaux naturels, tels que les images, la parole et la musique. Un composant clé de ces modèles est un modèle de compression neuronale de haute qualité capable de compresser des signaux naturels de haute dimension en jetons discrets de dimension inférieure. À cette fin, nous introduisons un algorithme universel de compression neuronale audio haute fidélité qui atteint un taux de compression d’environ 90x pour l’audio 44,1 KHz, en jetons avec une bande passante de seulement 8 kbps. Nous y parvenons en combinant les avancées en génération audio haute fidélité avec de meilleures techniques de quantification vectorielle issues du domaine de l’image, ainsi que des pertes adversariales et de reconstruction améliorées. Nous compressons tous les domaines (parole, environnement, musique, etc.) avec un seul modèle universel, ce qui le rend largement applicable à la modélisation générative de tout type d’audio. Nous comparons notre approche aux algorithmes de compression audio concurrents et constatons que notre méthode les surpasse de manière significative. Nous fournissons des ablations approfondies pour chaque choix de conception, ainsi que du code open source et des poids de modèles entraînés. Nous espérons que notre travail posera les bases de la prochaine génération de modélisation audio haute fidélité.

Ce modèle a été contribué par Kamil Akesbi. Le code d'origine peut être trouvé ici.

Structure du modèle

Le modèle Descript Audio Codec (DAC) est structuré en trois étapes distinctes :

  1. Modèle encodeur : cette étape compresse l'audio d'entrée, réduisant sa taille tout en conservant les informations essentielles.
  2. Modèle de quantificateur vectoriel résiduel (RVQ) : Fonctionnant en tandem avec l'encodeur, ce modèle quantifie les codes latents de l'audio, affinant la compression et garantissant une reconstruction de haute qualité.
  3. Modèle décodeur : cette dernière étape reconstruit l'audio à partir de sa forme compressée, le ramenant à un état qui ressemble étroitement à l'entrée d'origine.

Exemple d'utilisation

Voici un exemple rapide de l’encodage et du décodage d’un audio à l’aide de ce modèle :

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

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

Paramètres

  • encoder_hidden_size (int, facultatif, par défaut 64) — Dimension des représentations cachées.
  • downsampling_ratios (list[int], facultatif, par défaut [2, 4, 8, 8]) — Ratios de sous-échantillonnage dans l'encodeur. Ils sont utilisés dans l'ordre inverse pour le sur-échantillonnage dans le décodeur.
  • decoder_hidden_size (int, facultatif, par défaut 1536) — Dimension des représentations cachées.
  • n_codebooks (int, facultatif, par défaut 9) — Le nombre de codebooks parallèles utilisés par le modèle.
  • codebook_size (int, facultatif, par défaut 1024) — Le nombre de codebooks parallèles utilisés par le modèle.
  • codebook_dim (int, facultatif, par défaut 8) — Dimension de chaque vecteur d'embedding de codebook.
  • quantizer_dropout (bool, facultatif, valeur par défaut 0) — Indique s'il faut appliquer un dropout au quantizer.
  • commitment_loss_weight (float, facultatif, valeur par défaut 0.25) — Poids du terme de perte de commitment dans la fonction de perte VQVAE.
  • codebook_loss_weight (float, facultatif, valeur par défaut 1.0) — Poids du terme de perte du codebook dans la fonction de perte VQVAE.
  • sampling_rate (int, facultatif, par défaut 16000) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).

Ceci est la classe de configuration destinée à stocker la configuration d'un DacModel. Elle est utilisée pour instancier un modèle Dac en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de descript/dac_16khz

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.DacFeatureExtractor

< >

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

Paramètres

  • feature_size (int, facultatif, par défaut 1) — La dimension des caractéristiques des fonctionnalités extraites. Utilisez 1 pour le mono, 2 pour le stéréo.
  • sampling_rate (int, facultatif, valeur par défaut 16000) — La fréquence d'échantillonnage à laquelle la forme d'onde audio doit être numérisée, exprimée en hertz (Hz).
  • padding_value (float, facultatif, par défaut 0.0) — La valeur utilisée pour le bourrage.
  • hop_length (int, facultatif, par défaut 512) — Longueur de chevauchement entre les fenêtres successives.

Construit un extracteur de fonctionnalités Dac.

Cet extracteur de fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

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

Paramètres

  • raw_audio (np.ndarray, list[float], list[np.ndarray], list[list[float]]) — La séquence ou le lot de séquences à traiter. Chaque séquence peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes. Le tableau numpy doit avoir la forme (num_samples,) pour un audio mono (feature_size = 1), ou (2, num_samples) pour un audio stéréo (feature_size = 2).
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : True) — Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, facultatif, par défaut False) — Active la troncature pour couper les séquences d’entrée plus longues que max_length à max_length.
  • max_length (int, facultatif) — Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).
  • return_tensors (str ou TensorType, facultatif, par défaut ‘pt’) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • sampling_rate (int, facultatif) — La fréquence d’échantillonnage à laquelle l’entrée audio a été échantillonnée. Il est fortement recommandé de passer sampling_rate lors de l’appel forward afin d’éviter les erreurs silencieuses.

Méthode principale pour vectoriser et préparer une ou plusieurs séquences pour le modèle.

DacModel

classe transformers.DacModel

< >

( config: DacConfig )

Paramètres

  • config (DacConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle DAC (Descript Audio Codec).

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

décoder

< >

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

Paramètres

  • quantized_representation (torch.Tensor de forme (batch_size, dimension, time_steps), facultatif) — Représentation continue quantifiée de l'entrée.
  • audio_codes (torch.Tensor de forme (batch_size, num_codebooks, time_steps), facultatif) — Les indices de codebook pour chaque codebook, représentant la représentation discrète quantifiée de l’entrée. Ce paramètre doit être fourni si vous souhaitez décoder directement à partir des codes audio (il remplacera quantized_representation).
  • return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un DacDecoderOutput plutôt qu'un simple tuple.

Retourne

DacDecoderOutput ou tuple(torch.Tensor)

Un DacDecoderOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (DacConfig) et des entrées.

  • audio_values (torch.Tensor de forme (batch_size, input_length), facultatif) — Valeurs audio décodées, obtenues à l’aide de la partie décodeur de Dac.

encode

< >

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

Paramètres

  • input_values (torch.Tensor of shape (batch_size, 1, time_steps)`) — Données audio d'entrée à encoder,
  • n_quantizers (int, facultatif) — Nombre de quantificateurs à utiliser. Si None, tous les quantificateurs sont utilisés. La valeur par défaut est None.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

DacEncoderOutput ou tuple(torch.Tensor)

Un DacEncoderOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (DacConfig) et des entrées.

  • loss (torch.Tensor, facultatif) — Perte du modèle encodeur, comprenant la combinaison pondérée des pertes de commitment et de codebook.
  • quantized_representation (torch.Tensor de forme (batch_size, dimension, time_steps), facultatif) — Représentation continue quantifiée de l'entrée.
  • audio_codes (torch.Tensor de forme (batch_size, num_codebooks, time_steps), facultatif) — Indices de codebook pour chaque codebook (représentation discrète quantifiée de l'entrée).
  • projected_latents (torch.Tensor de forme (batch_size, num_codebooks * dimension, time_steps), facultatif) — Latents projetés (représentation continue de l'entrée avant quantification).

forward

< >

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

Paramètres

  • input_values (torch.Tensor de forme (batch_size, 1, time_steps)) — Données audio à encoder.
  • n_quantizers (int, facultatif) — Nombre de quantificateurs à utiliser. Si None, tous les quantificateurs sont utilisés. La valeur par défaut est None.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

DacOutput ou tuple(torch.Tensor)

Un DacOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (DacConfig) et des entrées.

La méthode forward de DacModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

  • loss (torch.Tensor, facultatif) — Perte du modèle encodeur, comprenant la combinaison pondérée des pertes de commitment et de codebook.
  • audio_values (torch.Tensor de forme (batch_size, input_length)) — Données audio reconstruites.
  • quantized_representation (torch.Tensor de forme (batch_size, dimension, time_steps)) — Représentation continue quantifiée de l'entrée.
  • audio_codes (torch.LongTensor de forme (batch_size, num_codebooks, time_steps)) — Indices de codebook pour chaque codebook (représentation discrète quantifiée de l'entrée).
  • projected_latents (torch.Tensor de forme (batch_size, num_codebooks * dimension, time_steps)) — Latents projetés (représentation continue de l'entrée avant quantification).

Exemples :

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