Amphion MaskGCT : Modèle de clonage de la synthèse vocale à zéro échantillon (paquet de déploiement local en un clic)

Dernières ressources sur l'IAMise à jour il y a 10 mois Cercle de partage de l'IA

16.3K 00

Introduction générale

MaskGCT (Masked Generative Codec Transformer) est un modèle de synthèse vocale entièrement non autorégressif introduit conjointement par Funky Maru Technology et l'Université chinoise de Hong Kong. Le modèle élimine le besoin d'informations explicites sur l'alignement texte-parole et adopte une approche de génération en deux phases, prédisant d'abord le codage sémantique à partir du texte, puis générant le codage acoustique à partir du codage sémantique.MaskGCT donne de bons résultats dans la tâche TTS à zéro échantillon, fournissant une sortie vocale de haute qualité, similaire et facile à comprendre.

Bêta publique : Funmaru Chiyo, outil de clonage de voix et de traduction multilingue de vidéos
Thèse : https://arxiv.org/abs/2409.00750

Démonstration en ligne : https://huggingface.co/spaces/amphion/maskgct

Liste des fonctions

Conversion texte-parole (TTS)Convertit le texte d'entrée en sortie vocale.
encodage sémantiqueLe langage : Il convertit le discours en un codage sémantique en vue d'un traitement ultérieur.
code acoustiqueLe codage sémantique : Convertir le codage sémantique en codage acoustique et reconstruire la forme d'onde audio.
l'apprentissage à partir de l'échantillon zéroLa synthèse vocale de haute qualité sans information explicite sur l'alignement : La synthèse vocale de haute qualité sans information explicite sur l'alignement.
Modèle de pré-entraînementLes modèles pré-entraînés : Une large gamme de modèles pré-entraînés est disponible pour permettre un déploiement et une utilisation rapides.

Utiliser l'aide

Processus d'installation

projet de clonage: :

git clone https://github.com/open-mmlab/Amphion.git

Création d'un environnement et installation des dépendances: :
```
bash ./models/tts/maskgct/env.sh
```

Processus d'utilisation

Télécharger le modèle pré-entraînéLes modèles pré-entraînés nécessaires peuvent être téléchargés à partir de HuggingFace :

from huggingface_hub import hf_hub_download
# 下载语义编码模型
semantic_code_ckpt = hf_hub_download("amphion/MaskGCT", filename="semantic_codec/model.safetensors")
# 下载声学编码模型
codec_encoder_ckpt = hf_hub_download("amphion/MaskGCT", filename="acoustic_codec/model.safetensors")
codec_decoder_ckpt = hf_hub_download("amphion/MaskGCT", filename="acoustic_codec/model_1.safetensors")
# 下载TTS模型
t2s_model_ckpt = hf_hub_download("amphion/MaskGCT", filename="t2s_model/model.safetensors")

Générer un discoursLe code suivant permet de générer de la parole à partir d'un texte :

# 导入必要的库
from amphion.models.tts.maskgct import MaskGCT
# 初始化模型
model = MaskGCT()
# 输入文本
text = "你好，欢迎使用MaskGCT模型。"
# 生成语音
audio = model.text_to_speech(text)
# 保存生成的语音
with open("output.wav", "wb") as f:
f.write(audio)

formation au modèleSi vous avez besoin d'entraîner votre propre modèle, vous pouvez vous référer aux scripts d'entraînement et aux fichiers de configuration du projet pour la préparation des données et l'entraînement du modèle.

mise en garde

Configuration de l'environnementLes bibliothèques dépendantes doivent être installées et les variables d'environnement doivent être configurées correctement.
Préparation des donnéesLa formation à l'aide de données vocales de haute qualité pour une meilleure synthèse vocale.
Optimisation du modèleLes résultats de l'analyse de l'impact sur l'environnement : Ajuster les paramètres du modèle et les stratégies de formation pour obtenir des performances optimales en fonction de scénarios d'application spécifiques.

Tutoriel de déploiement local (avec installateur local en un clic)

Il y a quelques jours, un autre modèle d'IA de synthèse vocale non autorégressive, MaskGCT, a ouvert son code source. Comme le modèle F5-TTS, qui est également non autorégressif, le modèle MaskGCT est entraîné sur l'ensemble de données Emilia de 100 000 heures, et il est compétent dans la synthèse interlinguistique de six langues, à savoir le chinois, l'anglais, le japonais, le coréen, le français et l'allemand. L'ensemble de données Emilia est l'un des ensembles de données vocales multilingues de haute qualité les plus vastes et les plus diversifiés au monde.

Cette fois-ci, nous vous expliquons comment déployer le projet MaskGCT localement pour que votre carte graphique se remette à fonctionner.

Installation des dépendances de base

Tout d'abord, assurez-vous que Python 3.11 est installé localement. Vous pouvez télécharger le paquetage depuis le site officiel de Python.

python.org

Clonage ultérieur de projets officiels.

git clone https://github.com/open-mmlab/Amphion.git

Des scripts d'installation officiels sous Linux sont fournis :

pip install setuptools ruamel.yaml tqdm   
pip install tensorboard tensorboardX torch==2.0.1  
pip install transformers===4.41.1  
pip install -U encodec  
pip install black==24.1.1  
pip install oss2  
sudo apt-get install espeak-ng  
pip install phonemizer  
pip install g2p_en  
pip install accelerate==0.31.0  
pip install funasr zhconv zhon modelscope  
# pip install git+https://github.com/lhotse-speech/lhotse  
pip install timm  
pip install jieba cn2an  
pip install unidecode  
pip install -U cos-python-sdk-v5  
pip install pypinyin  
pip install jiwer  
pip install omegaconf  
pip install pyworld  
pip install py3langid==0.2.2 LangSegment  
pip install onnxruntime  
pip install pyopenjtalk  
pip install pykakasi  
pip install -U openai-whisper

L'auteur convertit ici le fichier de dépendance requirements.txt pour Windows :

setuptools   
ruamel.yaml   
tqdm   
transformers===4.41.1  
encodec  
black==24.1.1  
oss2  
phonemizer  
g2p_en  
accelerate==0.31.0  
funasr   
zhconv   
zhon   
modelscope  
timm  
jieba   
cn2an  
unidecode  
cos-python-sdk-v5  
pypinyin  
jiwer  
omegaconf  
pyworld  
py3langid==0.2.2  
LangSegment  
onnxruntime  
pyopenjtalk  
pykakasi  
openai-whisper  
json5

Exécuter la commande :

pip3 install -r requirements.txt

Il suffit d'installer les dépendances.

Installer onnxruntime-gpu.

pip3 install onnxruntime-gpu

Installation de l'ensemble de 3 pièces de la torche.

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

Configuration Windows espeak-ng

Comme le projet MaskGCT repose sur le logiciel espeak pour son backend, il doit être configuré localement. eSpeak est un synthétiseur texte-parole (TTS) compact et open-source qui prend en charge plusieurs langues et accents. Il utilise une approche de "synthèse de crête par résonance" qui permet de fournir plusieurs langues dans un encombrement réduit. La parole est claire et peut être utilisée à grande vitesse, mais elle n'est pas aussi naturelle et fluide que les synthétiseurs plus importants basés sur des enregistrements de la parole humaine, et MaskGCT s'appuie sur la synthèse d'espeak avec un raisonnement secondaire.

Exécutez d'abord la commande d'installation d'espeak :

winget install espeak

Si vous ne pouvez pas l'installer, vous pouvez également télécharger le programme d'installation et l'installer manuellement :

https://sourceforge.net/projects/espeak/files/espeak/espeak-1.48/setup_espeak-1.48.04.exe/download

Téléchargez ensuite le programme d'installation espeak-ng :

https://github.com/espeak-ng/espeak-ng/releases

Télécharger et double-cliquer pour installer.

Copiez ensuite C:\NProgram Files\eSpeak NG\ebespeak-ng.dll dans le répertoire C:\NProgram Files (x86)\eSpeak\ecommand_line.

Renommez ensuite libespeak-ng.dll en espeak-ng.dll.

Enfin, il suffit de configurer le répertoire C:\NProgram Files (x86)\eSpeak\Ncommand_line dans la variable d'environnement.

MaskGCT Raisonnement local

Une fois tout cela configuré, écrivez le script d'inférence local_test.py :

from models.tts.maskgct.maskgct_utils import *  
from huggingface_hub import hf_hub_download  
import safetensors  
import soundfile as sf  
import os  
import argparse  
os.environ['HF_HOME'] = os.path.join(os.path.dirname(__file__), 'hf_download')  
print(os.path.join(os.path.dirname(__file__), 'hf_download'))  
parser = argparse.ArgumentParser(description="GPT-SoVITS api")  
parser.add_argument("-p", "--prompt_text", type=str, default="说得好像您带我以来我考好过几次一样")  
parser.add_argument("-a", "--audio", type=str, default="./说得好像您带我以来我考好过几次一样.wav")  
parser.add_argument("-t", "--text", type=str, default="你好")  
parser.add_argument("-l", "--language", type=str, default="zh")  
parser.add_argument("-lt", "--target_language", type=str, default="zh")  
args = parser.parse_args()  
if __name__ == "__main__":  
# download semantic codec ckpt  
semantic_code_ckpt = hf_hub_download("amphion/MaskGCT", filename="semantic_codec/model.safetensors")  
# download acoustic codec ckpt  
codec_encoder_ckpt = hf_hub_download("amphion/MaskGCT", filename="acoustic_codec/model.safetensors")  
codec_decoder_ckpt = hf_hub_download("amphion/MaskGCT", filename="acoustic_codec/model_1.safetensors")  
# download t2s model ckpt  
t2s_model_ckpt = hf_hub_download("amphion/MaskGCT", filename="t2s_model/model.safetensors")  
# download s2a model ckpt  
s2a_1layer_ckpt = hf_hub_download("amphion/MaskGCT", filename="s2a_model/s2a_model_1layer/model.safetensors")  
s2a_full_ckpt = hf_hub_download("amphion/MaskGCT", filename="s2a_model/s2a_model_full/model.safetensors")  
# build model  
device = torch.device("cuda")  
cfg_path = "./models/tts/maskgct/config/maskgct.json"  
cfg = load_config(cfg_path)  
# 1. build semantic model (w2v-bert-2.0)  
semantic_model, semantic_mean, semantic_std = build_semantic_model(device)  
# 2. build semantic codec  
semantic_codec = build_semantic_codec(cfg.model.semantic_codec, device)  
# 3. build acoustic codec  
codec_encoder, codec_decoder = build_acoustic_codec(cfg.model.acoustic_codec, device)  
# 4. build t2s model  
t2s_model = build_t2s_model(cfg.model.t2s_model, device)  
# 5. build s2a model  
s2a_model_1layer = build_s2a_model(cfg.model.s2a_model.s2a_1layer, device)  
s2a_model_full =  build_s2a_model(cfg.model.s2a_model.s2a_full, device)  
# load semantic codec  
safetensors.torch.load_model(semantic_codec, semantic_code_ckpt)  
# load acoustic codec  
safetensors.torch.load_model(codec_encoder, codec_encoder_ckpt)  
safetensors.torch.load_model(codec_decoder, codec_decoder_ckpt)  
# load t2s model  
safetensors.torch.load_model(t2s_model, t2s_model_ckpt)  
# load s2a model  
safetensors.torch.load_model(s2a_model_1layer, s2a_1layer_ckpt)  
safetensors.torch.load_model(s2a_model_full, s2a_full_ckpt)  
# inference  
prompt_wav_path = args.audio  
save_path = "output.wav"  
prompt_text = args.prompt_text  
target_text = args.text  
# Specify the target duration (in seconds). If target_len = None, we use a simple rule to predict the target duration.  
target_len = None  
maskgct_inference_pipeline = MaskGCT_Inference_Pipeline(  
semantic_model,  
semantic_codec,  
codec_encoder,  
codec_decoder,  
t2s_model,  
s2a_model_1layer,  
s2a_model_full,  
semantic_mean,  
semantic_std,  
device,  
)  
recovered_audio = maskgct_inference_pipeline.maskgct_inference(  
prompt_wav_path, prompt_text, target_text,args.language,args.target_language, target_len=target_len  
)  
sf.write(save_path, recovered_audio, 24000)

La première inférence téléchargera 10 G de modèles dans le répertoire hf_download.

Le processus de raisonnement occupe 11G de mémoire vidéo :

Si vous disposez de moins de 11 Go de mémoire vidéo, veillez à activer la politique de repli de la mémoire système dans le panneau de configuration Nvidia afin de recharger votre mémoire vidéo par le biais de la mémoire système :

Si vous le souhaitez, vous pouvez également écrire une interface webui simple basée sur gradio, app.py :.

import os  
import gc  
import re  
import gradio as gr  
import numpy as np  
import subprocess  
os.environ['HF_HOME'] = os.path.join(os.path.dirname(__file__), 'hf_download')  
# 设置HF_ENDPOINT环境变量  
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"  
reference_wavs = ["请选择参考音频或者自己上传"]  
for name in os.listdir("./参考音频/"):  
reference_wavs.append(name)  
def change_choices():  
reference_wavs = ["请选择参考音频或者自己上传"]  
for name in os.listdir("./参考音频/"):  
reference_wavs.append(name)  
return {"choices":reference_wavs, "__type__": "update"}  
def change_wav(audio_path):  
text = audio_path.replace(".wav","").replace(".mp3","").replace(".WAV","")  
# text = replace_speaker(text)  
return f"./参考音频/{audio_path}",text  
def do_cloth(gen_text_input,ref_audio_input,model_choice_text,model_choice_re,ref_text_input):  
cmd = fr'.\py311_cu118\python.exe local_test.py -t "{gen_text_input}" -p "{ref_text_input}" -a "{ref_audio_input}" -l {model_choice_re} -lt {model_choice_text} '  
print(cmd)  
res = subprocess.Popen(cmd)  
res.wait()  
return "output.wav"  
with gr.Blocks() as app_demo:  
gr.Markdown(  
"""  
项目地址:https://github.com/open-mmlab/Amphion/tree/main/models/tts/maskgct  
整合包制作:刘悦的技术博客 https://space.bilibili.com/3031494  
"""  
)  
gen_text_input = gr.Textbox(label="生成文本", lines=4)  
model_choice_text = gr.Radio(  
choices=["zh", "en"], label="生成文本语种", value="zh",interactive=True)  
wavs_dropdown = gr.Dropdown(label="参考音频列表",choices=reference_wavs,value="选择参考音频或者自己上传",interactive=True)  
refresh_button = gr.Button("刷新参考音频")  
refresh_button.click(fn=change_choices, inputs=[], outputs=[wavs_dropdown])  
ref_audio_input = gr.Audio(label="Reference Audio", type="filepath")  
ref_text_input = gr.Textbox(  
label="Reference Text",  
info="Leave blank to automatically transcribe the reference audio. If you enter text it will override automatic transcription.",  
lines=2,  
)  
model_choice_re = gr.Radio(  
choices=["zh", "en"], label="参考音频语种", value="zh",interactive=True  
)  
wavs_dropdown.change(change_wav,[wavs_dropdown],[ref_audio_input,ref_text_input])  
generate_btn = gr.Button("Synthesize", variant="primary")  
audio_output = gr.Audio(label="Synthesized Audio")  
generate_btn.click(do_cloth,[gen_text_input,ref_audio_input,model_choice_text,model_choice_re,ref_text_input],[audio_output])  
def main():  
global app_demo  
print(f"Starting app...")  
app_demo.launch(inbrowser=True)  
if __name__ == "__main__":  
main()

Et bien sûr, n'oubliez pas d'installer la dépendance gradio :

pip3 install -U gradio

L'effet d'exécution se présente comme suit :

remarques finales

L'avantage du modèle MaskGCT est que le niveau de tonalité et de rythme est très remarquable, comparable à la voix réelle, l'inconvénient est également très évident, le coût de fonctionnement est élevé, l'optimisation du niveau d'ingénierie est insuffisante.La page d'accueil du projet MaskGCT a sa version commerciale du modèle de l'entrée, selon cette déduction, l'officiel ne devrait pas être trop puissant dans la version open source, et enfin, le paquet d'intégration à clé unique est présenté avec tous les gens pour profiter de la même chose.