Amphion MaskGCT : Modèle de clonage de la synthèse vocale à zéro échantillon (paquet de déploiement local en un clic)
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.
Kit de déploiement en un clic MaskGCT
https://pan.quark.cn/s/e74726b84c78
Courtesy of Ten Horsemen : https://pan.quark.cn/s/1a8428b6ff73 Code d'extraction : kind
https://drive.google.com/drive/folders/11JHi5FnusZA34Q6zS3b3Xj5MiLpYKsLu
© déclaration de droits d'auteur
Article copyright Cercle de partage de l'IA Tous, prière de ne pas reproduire sans autorisation.
Articles connexes
Pas de commentaires...