metavoice src

Metavoice-1b

O Metavoice-1b é um modelo de base de parâmetros de 1,2b treinado em 100 mil horas de fala para TTS (texto em fala). Foi construído com as seguintes prioridades:

• Ritmo e tom emocional da fala em inglês.
• Clonagem zero para vozes americanas e britânicas , com áudio de referência dos 30 anos.
• Suporte para clonagem de voz (transfrondual) com Finetuning .
  • Tivemos sucesso com apenas 1 minuto de treinamento de dados para falantes indianos.
• Síntese de texto de comprimento arbitrário

Estamos lançando o metavoice-1b sob a licença Apache 2.0, ela pode ser usada sem restrições .

Quickstart - tl; dr

UI da web

docker-compose up -d ui && docker-compose ps && docker-compose logs -f

Servidor

 # navigate to <URL>/docs for API definitions
docker-compose up -d server && docker-compose ps && docker-compose logs -f

Instalação

Pré-requisitos:

• GPU vram> = 12 GB
• Python> = 3.10, <3,12
• PIPX (Instruções de instalação)

Configuração do ambiente

 # install ffmpeg
wget https://johnvansickle.com/ffmpeg/builds/ffmpeg-git-amd64-static.tar.xz
wget https://johnvansickle.com/ffmpeg/builds/ffmpeg-git-amd64-static.tar.xz.md5
md5sum -c ffmpeg-git-amd64-static.tar.xz.md5
tar xvf ffmpeg-git-amd64-static.tar.xz
sudo mv ffmpeg-git- * -static/ffprobe ffmpeg-git- * -static/ffmpeg /usr/local/bin/
rm -rf ffmpeg-git- *

# install rust if not installed (ensure you've restarted your terminal after installation)
curl --proto ' =https ' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Instalação de dependências do projeto

1. Usando poesia
2. Usando pip/conda

Usando poesia (recomendado)

 # install poetry if not installed (ensure you've restarted your terminal after installation)
pipx install poetry

# disable any conda envs that might interfere with poetry's venv
conda deactivate

# if running from Linux, keyring backend can hang on `poetry install`. This prevents that.
export PYTHON_KEYRING_BACKEND=keyring.backends.fail.Keyring

# pip's dependency resolver will complain, this is temporary expected behaviour
# full inference & finetuning functionality will still be available
poetry install && poetry run pip install torch==2.2.1 torchaudio==2.2.1

Usando pip/conda

Nota 1: Ao levantar problemas, pediremos que você tente primeiro com a poesia. Nota 2: Todos os comandos nesta leitura usam poetry por padrão, para que você possa remover qualquer poetry run .

pip install -r requirements.txt
pip install torch==2.2.1 torchaudio==2.2.1
pip install -e . 

Uso

1. Faça o download e use -o em qualquer lugar (inclusive localmente) com nossa implementação de referência

 # You can use `--quantisation_mode int4` or `--quantisation_mode int8` for experimental faster inference.  This will degrade the quality of the audio.
# Note: int8 is slower than bf16/fp16 for undebugged reasons. If you want fast, try int4 which is roughly 2x faster than bf16/fp16.
poetry run python -i fam/llm/fast_inference.py

# Run e.g. of API usage within the interactive python session
tts.synthesise(text= " This is a demo of text to speech by MetaVoice-1B, an open-source foundational audio model. " , spk_ref_path= " assets/bria.mp3 " )

NOTA: O script leva 30-90s para inicializar (dependendo do hardware). Isso ocorre porque nós tocamos.Compile o modelo para inferência rápida.

Em GPUs de arquitetura de ampere, Ada-Lovelace e Hopper, uma vez compiladas, a API Synthesise () funciona mais rápido que em tempo real, com um fator em tempo real (RTF) <1,0.

2. Implantá -lo em qualquer nuvem (AWS/GCP/Azure), usando nosso servidor de inferência ou interface da web

 # You can use `--quantisation_mode int4` or `--quantisation_mode int8` for experimental faster inference. This will degrade the quality of the audio.
# Note: int8 is slower than bf16/fp16 for undebugged reasons. If you want fast, try int4 which is roughly 2x faster than bf16/fp16.

# navigate to <URL>/docs for API definitions
poetry run python serving.py

poetry run python app.py

3. Use -o através do rosto abraçado
4. Demoção do Google Colab

Afinação

Apoiamos o Finetuning o primeiro estágio LLM (consulte a seção de arquitetura).

Para Finetune, esperamos um conjunto de dados CSV "|" |

 audio_files|captions
./data/audio.wav|./data/caption.txt

Observe que não executamos nenhuma verificação sobre sobreposição do conjunto de dados, portanto, verifique se os conjuntos de dados de trem e Val estão desconexos.

Experimente usando nossos conjuntos de dados de amostra via:

poetry run finetune --train ./datasets/sample_dataset.csv --val ./datasets/sample_val_dataset.csv

Depois de treinar seu modelo, você pode usá -lo para inferência via:

poetry run python -i fam/llm/fast_inference.py --first_stage_path ./my-finetuned_model.pt

Configuração

Para definir hiperparâmetros como a taxa de aprendizado, o que congelar, etc., você pode editar o arquivo Finetune_params.py.

Temos uma integração leve e opcional com a W&B que pode ser ativada através da configuração wandb_log = True e instalando as dependências apropriadas.

poetry install -E observable

Por vir

• Inferência mais rápida ⚡
• Código de ajuste fino?
• Síntese de texto de comprimento arbitrário

Arquitetura

Prevemos os tokens do Codec do texto e informações sobre o alto -falante. Isso é difundido até o nível da forma de onda, com o pós-processamento aplicado para limpar o áudio.

• Utilizamos um GPT causal para prever as duas primeiras hierarquias dos tokens do Codec. Texto e áudio fazem parte do contexto LLM. As informações do alto -falante são passadas por meio de condicionamento na camada de incorporação do token. Esse condicionamento do alto -falante é obtido de uma rede de verificação de alto -falante treinada separadamente.
  • As duas hierarquias são previstas de maneira "achatada intercalada", prevemos o primeiro token da primeira hierarquia, depois o primeiro sinal da segunda hierarquia, depois o segundo sinal da primeira hierarquia e assim por diante.
  • Utilizamos amostragem sem condição para aumentar a capacidade de clonagem do modelo.
  • O texto é tokenizado usando um tokeniser BPE treinado personalizado com 512 tokens.
  • Observe que ignoramos a previsão de tokens semânticos, conforme feito em outros trabalhos, pois descobrimos que isso não é estritamente necessário.
• Utilizamos um transformador não causal (estilo de codificador) para prever o restante das 6 hierarquias das duas primeiras hierarquias. Este é um modelo super pequeno (~ 10mn parâmetros) e possui uma extensa generalização zero para a maioria dos alto-falantes que tentamos. Como não é causal, também podemos prever todos os texiços em paralelo.
• Utilizamos difusão de várias bandas para gerar formas de onda a partir dos tokens do Codec. Percebemos que o discurso é mais claro do que usar o decodificador RVQ original ou o VOCOS. No entanto, a difusão no nível da forma de onda deixa alguns artefatos de fundo que são bastante desagradáveis ​​para o ouvido. Nós limpamos isso na próxima etapa.
• Utilizamos o DeepFilternet para esclarecer os artefatos introduzidos pela difusão de várias bandas.

Otimizações

O modelo suporta:

1. KV-Caching via flash decodificando
2. Lotes (incluindo textos de diferentes comprimentos)

Contribuir

• Veja todos os problemas ativos!

Agradecimentos

Somos gratos juntos. Agradecemos às equipes da AWS, GCP e Hugging Face pelo apoio às suas plataformas em nuvem.

• A Défossez et. al. para codec.
• RS Roman et. al. Para difusão multibanda.
• @liusongxiang para implementação do codificador de alto -falante.
• @KarPathy para o Nanogpt, no qual nossa implementação de inferência é baseada.
• @Rikorose para DeepFilternet.

Desculpas antecipadamente, se perdemos alguém. Por favor, informe -nos se tivermos.