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.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado no HF papers em 2023-06-11 e contribuído para o Hugging Face Transformers em 2024-08-19.

DAC

Visão geral

O modelo DAC foi proposto em Descript Audio Codec: High-Fidelity Audio Compression with Improved RVQGAN por Rithesh Kumar, Prem Seetharaman, Alejandro Luebs, Ishaan Kumar, Kundan Kumar.

O modelo Descript Audio Codec (DAC) é uma ferramenta poderosa para compressão de dados de áudio, tornando-o altamente eficiente para armazenamento e transmissão. Ao comprimir áudio de 44,1 KHz em tokens com apenas 8 kbps de largura de banda, o modelo DAC permite o processamento de áudio de alta qualidade, reduzindo significativamente a pegada de dados. Isso é particularmente útil em cenários em que a largura de banda é limitada ou o espaço de armazenamento é escasso, como em aplicações de streaming, conferências remotas e arquivamento de grandes conjuntos de dados de áudio.

O resumo do artigo é o seguinte:

Os modelos de linguagem têm sido utilizados com sucesso para modelar sinais naturais, como imagens, fala e música. Um componente-chave desses modelos é um modelo de compressão neural de alta qualidade, capaz de comprimir sinais naturais de alta dimensão em tokens discretos de dimensão inferior. Para isso, apresentamos um algoritmo universal de compressão neural de áudio de alta fidelidade que atinge uma compressão de ~90x de áudio de 44,1 KHz em tokens com apenas 8 kbps de largura de banda. Alcançamos isso combinando avanços na geração de áudio de alta fidelidade com técnicas aprimoradas de quantização vetorial do domínio de imagens, juntamente com perdas adversariais e de reconstrução melhoradas. Comprimimos todos os domínios (fala, ambiente, música, etc.) com um único modelo universal, tornando-o amplamente aplicável à modelagem generativa de todo o áudio. Comparamos com algoritmos concorrentes de compressão de áudio e constatamos que nosso método os supera significativamente. Fornecemos ablações detalhadas para cada escolha de design, bem como código open-source e pesos de modelos treinados. Esperamos que nosso trabalho possa estabelecer a base para a próxima geração de modelagem de áudio de alta fidelidade.

Este modelo foi contribuído por Kamil Akesbi. O código original pode ser encontrado aqui.

Estrutura do modelo

O modelo Descript Audio Codec (DAC) é estruturado em três estágios distintos:

  1. Modelo de codificador: Esta etapa comprime o áudio de entrada, reduzindo seu tamanho enquanto retém as informações essenciais.
  2. Modelo de Quantizador Vetorial Residual (RVQ): trabalhando em conjunto com o codificador, este modelo quantiza os códigos latentes do áudio, refinando a compressão e garantindo uma reconstrução de alta qualidade.
  3. Modelo Decodificador: Esta etapa final reconstrói o áudio a partir de sua forma comprimida, restaurando-o a um estado que se assemelha de perto à entrada original.

Exemplo de uso

Aqui está um exemplo rápido de como codificar e decodificar um áudio usando 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

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 )

Parâmetros

  • encoder_hidden_size (int, opcional, padrão 64) — Dimensão das representações ocultas.
  • downsampling_ratios (list[int], opcional, padrão [2, 4, 8, 8]) — Razões para o downsampling no encoder. Elas são usadas em ordem reversa para o upsampling no decoder.
  • decoder_hidden_size (int, opcional, padrão 1536) — Dimensão das representações ocultas.
  • n_codebooks (int, opcional, padrão 9) — O número de codebooks paralelos usados pelo modelo.
  • codebook_size (int, opcional, padrão 1024) — O número de codebooks paralelos usados pelo modelo.
  • codebook_dim (int, opcional, padrão 8) — Dimensão de cada vetor de incorporação do codebook.
  • quantizer_dropout (bool, opcional, padrão 0) — Se deve aplicar dropout ao quantizador.
  • commitment_loss_weight (float, opcional, padrão 0.25) — Peso do termo de perda de compromisso na função de perda do VQVAE.
  • codebook_loss_weight (float, opcional, padrão 1.0) — Peso do termo de perda do codebook na função de perda do VQVAE.
  • sampling_rate (int, opcional, padrão 16000) — A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).

Esta é a classe de configuração para armazenar a configuração de um DacModel. Ela é usada para instanciar um modelo Dac de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do descript/dac_16khz

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

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

Parâmetros

  • feature_size (int, opcional, padrão 1) — A dimensão dos recursos dos recursos extraídos. Use 1 para mono e 2 para estéreo.
  • sampling_rate (int, opcional, padrão 16000) — A taxa de amostragem na qual a forma de onda de áudio deve ser digitalizada, expressa em hertz (Hz).
  • padding_value (float, opcional, padrão 0.0) — O valor utilizado para preenchimento.
  • hop_length (int, opcional, padrão 512) — Comprimento de sobreposição entre janelas sucessivas.

Constrói um extrator de recursos Dac.

Este extrator de características herda de SequenceFeatureExtractor, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses 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]]) — A sequência ou lote de sequências a serem processadas. Cada sequência pode ser um array numpy, uma lista de valores float, uma lista de arrays numpy ou uma lista de listas de valores float. O array numpy deve ter a forma (num_samples,) para áudio mono (feature_size = 1), ou (2, num_samples) para áudio estéreo (feature_size = 2).
  • padding (bool, str ou PaddingStrategy, opcional, padrão é True) — Selecione uma estratégia para aplicar padding às sequências retornadas (de acordo com o lado de padding e o índice de padding do modelo) entre:
    • True ou 'longest': Preenche até a sequência mais longa do lote (ou não aplica preenchimento se apenas uma sequência for fornecida).
    • 'max_length': Preenche até o comprimento máximo especificado com o argumento max_length ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido.
    • False ou 'do_not_pad' (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes).
  • truncation (bool, opcional, padrão False) — Ativa a truncagem para cortar sequências de entrada com comprimento maior que max_length para max_length.
  • max_length (int, opcional) — Comprimento máximo da lista retornada e, opcionalmente, o comprimento do padding (veja acima).
  • return_tensors (str ou TensorType, opcional, padrão 'pt') — Se definido, retornará tensors em vez de uma lista de inteiros do Python. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do Numpy.
  • sampling_rate (int, opcional) — A taxa de amostragem na qual a entrada de audio foi amostrada. É fortemente recomendável passar sampling_rate na chamada de forward para evitar erros silenciosos.

Método principal para criar recursos e preparar uma ou várias sequências para o modelo.

DacModel

classe transformers.DacModel

< >

( config: DacConfig )

Parâmetros

  • config (DacConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo DAC (Descript Audio Codec).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

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) — Representação contínua quantizada da entrada.
  • audio_codes (torch.Tensor de forma (batch_size, num_codebooks, time_steps), opcional) — Os índices de codebook para cada codebook, representando a representação discreta quantizada da entrada. Este parâmetro deve ser fornecido se você deseja decodificar diretamente a partir dos códigos de áudio (ele sobrescreverá quantized_representation).
  • return_dict (bool, opcional, padrão True) — Se deve retornar um DacDecoderOutput em vez de uma tupla simples.

Retorna

DacDecoderOutput ou tuple(torch.Tensor)

Um DacDecoderOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (DacConfig) e das entradas.

  • audio_values (torch.Tensor de forma (batch_size, input_length), opcional) — Valores de áudio decodificados, obtidos usando a parte decodificadora do 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)`) — Dados de áudio de entrada para codificar,
  • n_quantizers (int, opcional) — Número de quantizadores a serem usados. Se for None, todos os quantizadores são usados. O padrão é None.
  • return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

DacEncoderOutput ou tuple(torch.Tensor)

Um DacEncoderOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (DacConfig) e das entradas.

  • loss (torch.Tensor, opcional) — Perda do modelo codificador, composta pela combinação ponderada das perdas de compromisso e do livro de códigos.
  • quantized_representation (torch.Tensor de forma (batch_size, dimension, time_steps), opcional) — Representação contínua quantizada da entrada.
  • audio_codes (torch.Tensor de forma (batch_size, num_codebooks, time_steps), opcional) — Índices de codebook para cada codebook (representação discreta quantizada da entrada).
  • projected_latents (torch.Tensor de forma (batch_size, num_codebooks * dimension, time_steps), opcional) — Latentes projetados (representação contínua da entrada antes da quantização).

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)) — Dados de áudio a serem codificados.
  • n_quantizers (int, opcional) — Número de quantizadores a serem usados. Se None, todos os quantizadores são usados. O padrão é None.
  • return_dict (bool, opcional) — Indica se deve retornar um ModelOutput em vez de uma tupla simples.

Retorna

DacOutput ou tuple(torch.Tensor)

Um DacOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos dependendo da configuração (DacConfig) e das entradas.

O método forward do DacModel sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor, opcional) — Perda do modelo codificador, composta pela combinação ponderada das perdas de compromisso e do livro de códigos.
  • audio_values (torch.Tensor de forma (batch_size, input_length)) — Dados de áudio reconstruídos.
  • quantized_representation (torch.Tensor de forma (batch_size, dimension, time_steps)) — Representação contínua quantizada da entrada.
  • audio_codes (torch.LongTensor de forma (batch_size, num_codebooks, time_steps)) — Índices de codebook para cada codebook (representação discreta quantizada da entrada).
  • projected_latents (torch.Tensor de forma (batch_size, num_codebooks * dimension, time_steps)) — Latentes projetados (representação contínua da entrada antes da quantização).

Exemplos:

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