metavoice src

Metavoice-1b

Metavoice-1b est un modèle de base de paramètres 1.2b formé sur 100 000 heures de discours pour TTS (texte-vocation). Il a été construit avec les priorités suivantes:

• Rythme et ton de la parole émotionnelle en anglais.
• Cloning zéro-shot pour les voix américaines et britanniques , avec l'audio de référence des années 30.
• Prise en charge du clonage vocal (cross-lingual) avec finetuning .
  • Nous avons eu du succès avec aussi peu que des données d'entraînement d'une minute pour les locuteurs indiens.
• Synthèse du texte de longueur arbitraire

Nous publions MetaVoice-1B sous la licence Apache 2.0, il peut être utilisé sans restrictions .

QuickStart - TL; DR

Ui Web

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

Serveur

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

Installation

Pré-requis:

• GPU VRAM> = 12 Go
• Python> = 3,10, <3.12
• PIPX (instructions d'installation)

Configuration de l'environnement

 # 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

Installation des dépendances du projet

1. Utilisation de la poésie
2. Utilisation de pip / conda

Utilisation de la poésie (recommandée)

 # 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

Utilisation de pip / conda

Remarque 1: Lorsque vous soulevez des problèmes, nous vous demanderons d'abord d'essayer avec la poésie. Remarque 2: Toutes les commandes de cette lecture utilisent poetry par défaut, afin que vous puissiez simplement supprimer toute poetry run .

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

Usage

1. Téléchargez-le et utilisez-le n'importe où (y compris localement) avec notre implémentation de référence

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

Remarque: Le script prend 30 à 90 pour démarrer (selon le matériel). En effet, nous inversons le modèle pour une inférence rapide.

Sur Ampère, Ada-Lovelace et Hopper Architecture GPUS, une fois compilé, l'API synthétise () fonctionne plus rapidement que le temps réel, avec un facteur en temps réel (RTF) <1,0.

2. Déployez-le sur n'importe quel cloud (AWS / GCP / Azure), en utilisant notre serveur d'inférence ou notre interface utilisateur 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. Utilisez-le via le visage étreint
4. Démo Google Colab

Réglage fin

Nous prenons en charge le Finetuning la première étape LLM (voir la section Architecture).

Afin de Finetune, nous nous attendons à un ensemble de données CSV dédié au format suivant:

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

Notez que nous n'effectuons aucune vérification de chevauchement de données, assurez-vous donc que vos ensembles de données de train et VAL sont disjoints.

Essayez-le en utilisant nos exemples de jeux de données via:

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

Une fois que vous avez formé votre modèle, vous pouvez l'utiliser pour l'inférence via:

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

Configuration

Afin de définir des hyperparamètres tels que le taux d'apprentissage, que geler, etc., vous pouvez modifier le fichier finetune_params.py.

Nous avons une intégration légère et facultative avec W&B qui peut être activée via la définition de wandb_log = True & en installant les dépendances appropriées.

poetry install -E observable

Prochain

• Inférence plus rapide ⚡
• Code de réglage fin?
• Synthèse du texte de longueur arbitraire

Architecture

Nous prédisons les jetons d'encode à partir du texte et les informations du haut-parleur. Ceci est ensuite diffusé au niveau de la forme d'onde, avec le post-traitement appliqué pour nettoyer l'audio.

• Nous utilisons un GPT causal pour prédire les deux premières hiérarchies de jetons d'encode. Le texte et l'audio font partie du contexte LLM. Les informations sur le haut-parleur sont transmises via un conditionnement au niveau de la couche d'incorporation de jeton. Ce conditionnement du haut-parleur est obtenu à partir d'un réseau de vérification des haut-parleurs formés séparément.
  • Les deux hiérarchies sont prédites d'une manière "interlinée aplatie", nous prédisons le premier jeton de la première hiérarchie, puis le premier jeton de la deuxième hiérarchie, puis le deuxième jeton de la première hiérarchie, etc.
  • Nous utilisons un échantillonnage sans condition pour augmenter la capacité de clonage du modèle.
  • Le texte est tokenisé à l'aide d'un tokeniser BPE formé sur mesure avec 512 jetons.
  • Notez que nous avons sauté en prédisant les jetons sémantiques comme fait dans d'autres œuvres, car nous avons constaté que ce n'est pas strictement nécessaire.
• Nous utilisons un transformateur non causal (style coder) pour prédire le reste des 6 hiérarchies des deux premières hiérarchies. Il s'agit d'un modèle super petit (~ 10mn paramètres), et a une généralisation étendue à zéro à la plupart des haut-parleurs que nous avons essayés. Puisqu'il n'est pas causal, nous sommes également en mesure de prédire tous les pas de temps en parallèle.
• Nous utilisons la diffusion multi-bandes pour générer des formes d'onde à partir des jetons d'encode. Nous avons remarqué que le discours est plus clair que d'utiliser le décodeur RVQ d'origine ou vocos. Cependant, la diffusion au niveau de la forme d'onde laisse quelques artefacts de fond qui sont assez désagréables à l'oreille. Nous nettoyons cela à l'étape suivante.
• Nous utilisons DeepFilternet pour éliminer les artefacts introduits par la diffusion multi-bandes.

Optimisations

Le modèle prend en charge:

1. Kv-cache via le décodage flash
2. Lots (y compris les textes de différentes longueurs)

Contribuer

• Voir tous les problèmes actifs!

Remerciements

Nous sommes reconnaissants à Together.ai pour leur aide 24/7 dans le rassemblement de notre cluster. Nous remercions les équipes de AWS, GCP & Hugging Face pour leur soutien avec leurs plateformes cloud.

• Un Défossez et. al. pour Encodec.
• RS Roman et. al. pour la diffusion multibande.
• @Liusongxiang pour la mise en œuvre de l'encodeur de haut-parleur.
• @karpathy pour nanogpt sur lequel notre implémentation d'inférence est basée.
• @Rikorose pour DeepFilternet.

Excuses à l'avance si nous avons manqué quelqu'un. Veuillez nous faire savoir si nous l'avons fait.