descript audio codec

Codec de áudio descritivo (.dac): compressão de áudio de alta fidelidade com rvqgan aprimorado

Este repositório contém scripts de treinamento e inferência para o codec de áudio descritivo (.dac), um codec de áudio neural geral de alta fidelidade, introduzido no artigo intitulado Compressão de áudio de alta fidelidade com RVQGan aprimorada .

Arxiv Paper: Compressão de áudio de alta fidelidade com rvqgan aprimorado
? Site de demonstração
⚙ Pesos do modelo

Com o codec de áudio descritivo, você pode comprimir 44,1 kHz de áudio em códigos discretos com uma taxa de bits baixa de 8 kbps .
? Isso é aproximadamente 90x de compressão , mantendo a fidelidade excepcional e minimizando artefatos.
? Nosso modelo universal funciona em todos os domínios (fala, ambiente, música etc.), tornando -o amplamente aplicável à modelagem generativa de todo o áudio.
? Ele pode ser usado como substituição do Encodec para todos os aplicativos de modelagem de idiomas de áudio (como Audiolms, Musiclms, MusicGen, etc.)

Uso

Instalação

 pip install descript-audio-codec

OU

 pip install git+https://github.com/descriptinc/descript-audio-codec

Pesos

Os pesos são liberados como parte deste repositório sob licença do MIT. Lançamos pesos para modelos que podem suportar taxas de amostragem de 16 kHz, 24kHz e 44,1kHz. Os pesos são baixados automaticamente quando você executa o comando encode ou decode pela primeira vez. Você pode cache -os usando um dos seguintes comandos

python3 -m dac download # downloads the default 44kHz variant
python3 -m dac download --model_type 44khz # downloads the 44kHz variant
python3 -m dac download --model_type 24khz # downloads the 24kHz variant
python3 -m dac download --model_type 16khz # downloads the 16kHz variant

Fornecemos um DockerFile que instala todas as dependências necessárias para codificação e decodificação. O processo de construção armazena em cache os pesos do modelo padrão dentro da imagem. Isso permite que a imagem seja usada sem uma conexão com a Internet. Consulte as instruções abaixo.

Compressa áudio

 python3 -m dac encode /path/to/input --output /path/to/output/codes

Este comando criará arquivos .dac com o mesmo nome que os arquivos de entrada. Ele também preservará a estrutura do diretório em relação à raiz de entrada e a recrie no diretório de saída. Use python -m dac encode --help para obter mais opções.

Reconstrua o áudio de códigos compactados

 python3 -m dac decode /path/to/output/codes --output /path/to/reconstructed_input

Este comando criará arquivos .wav com o mesmo nome que os arquivos de entrada. Ele também preservará a estrutura do diretório em relação à raiz de entrada e a recrie no diretório de saída. Use python -m dac decode --help para obter mais opções.

Uso programático

 import dac
from audiotools import AudioSignal

# Download a model
model_path = dac . utils . download ( model_type = "44khz" )
model = dac . DAC . load ( model_path )

model . to ( 'cuda' )

# Load audio signal file
signal = AudioSignal ( 'input.wav' )

# Encode audio signal as one long file
# (may run out of GPU memory on long files)
signal . to ( model . device )

x = model . preprocess ( signal . audio_data , signal . sample_rate )
z , codes , latents , _ , _ = model . encode ( x )

# Decode audio signal
y = model . decode ( z )

# Alternatively, use the `compress` and `decompress` functions
# to compress long files.

signal = signal . cpu ()
x = model . compress ( signal )

# Save and load to and from disk
x . save ( "compressed.dac" )
x = dac . DACFile . load ( "compressed.dac" )

# Decompress it back to an AudioSignal
y = model . decompress ( x )

# Write to file
y . write ( 'output.wav' )

Imagem do Docker

Fornecemos um Dockerfile para criar uma imagem do Docker com todas as dependências necessárias.

1. Construindo a imagem.

    docker build -t dac .
   

2. Usando a imagem.

   Uso na CPU:

    docker run dac <command>
   

   Uso na GPU:

    docker run --gpus=all dac <command>
   

   <command> pode ser um dos comandos de compactação e reconstrução listados acima. Por exemplo, se você deseja executar compressão,

    docker run --gpus=all dac python3 -m dac encode ...
   

Treinamento

A configuração do modelo de linha de base pode ser treinada usando os seguintes comandos.

Pré-requisitos

Instale as dependências corretas

 pip install -e ".[dev]"

Configuração do ambiente

Fornecemos uma configuração DockerFile e Docker Compõe que facilita a execução de experimentos.

Para construir a imagem do Docker:

 docker compose build

Então, para lançar um contêiner, faça:

 docker compose run -p 8888:8888 -p 6006:6006 dev

Os argumentos da porta ( -p ) são opcionais, mas úteis se você deseja iniciar uma instância Jupyter e Tensorboard dentro do contêiner. A senha padrão para Jupyter é password e o diretório atual é montado para /u/home/src , que também se torna o diretório de trabalho.

Em seguida, execute seu comando de treinamento.

Treinamento de GPU único

 export CUDA_VISIBLE_DEVICES=0
python scripts/train.py --args.load conf/ablations/baseline.yml --save_path runs/baseline/

Treinamento multi -GPU

 export CUDA_VISIBLE_DEVICES=0,1
torchrun --nproc_per_node gpu scripts/train.py --args.load conf/ablations/baseline.yml --save_path runs/baseline/

Teste

Fornecemos dois scripts de teste para testar a funcionalidade de treinamento CLI +. Certifique-se de que os pré-requisitos do Trainig sejam satisfeitos antes de lançar esses testes. Para iniciar esses testes, execute

 python -m pytest tests

Resultados