Amphion MaskGCT: Null-Sample Text-zu-Sprache-Klonmodell (lokales Ein-Klick-Bereitstellungspaket)

Allgemeine Einführung

MaskGCT (Masked Generative Codec Transformer) ist ein vollständig nicht-autoregressives Text-to-Speech (TTS)-Modell, das gemeinsam von Funky Maru Technology und der Chinese University of Hong Kong entwickelt wurde. Das Modell macht explizite Text-zu-Sprache-Ausrichtungsinformationen überflüssig und verwendet einen zweistufigen Generierungsansatz, bei dem zunächst die semantische Kodierung aus dem Text vorhergesagt und dann die akustische Kodierung aus der semantischen Kodierung generiert wird.MaskGCT erbringt gute Leistungen bei der TTS-Aufgabe mit Nullproben und liefert eine hochwertige, ähnliche und leicht verständliche Sprachausgabe.

Öffentliches Beta-Produkt: Funmaru Chiyo, Werkzeug zum Klonen von Stimmen und zur mehrsprachigen Übersetzung von Videos

Diplomarbeit: https://arxiv.org/abs/2409.00750

Online-Demo: https://huggingface.co/spaces/amphion/maskgct

Funktionsliste

• Text-zu-Sprache-Umwandlung (TTS)Konvertierung von Eingabetext in Sprachausgabe.
• semantische KodierungSprachkodierung: Wandelt Sprache in semantische Kodierung um, die anschließend verarbeitet wird.
• akustischer CodeSemantische Kodierung in akustische Kodierung umwandeln und die Audiowellenform rekonstruieren.
• Null-Proben-LernenHochwertige Sprachsynthese ohne explizite Ausrichtungsinformationen.
• Pre-Training ModellEine breite Palette an vortrainierten Modellen ist verfügbar, um eine schnelle Einführung und Nutzung zu ermöglichen.

Hilfe verwenden

Einbauverfahren

1. Klonprojekt::

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

2. Erstellen einer Umgebung und Installieren von Abhängigkeiten::

   bash ./models/tts/maskgct/env.sh
   

Verwendungsprozess

1. Herunterladen des vortrainierten ModellsDie benötigten vortrainierten Modelle können von HuggingFace heruntergeladen werden:

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

2. Sprache generieren: Verwenden Sie den folgenden Code, um Sprache aus Text zu erzeugen:

   # 导入必要的库
   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)
   

3. ModellschulungWenn Sie Ihr eigenes Modell trainieren müssen, können Sie die Trainingsskripte und Konfigurationsdateien im Projekt für die Datenvorbereitung und das Modelltraining verwenden.

caveat

• Umgebung KonfigurationVergewissern Sie sich, dass alle erforderlichen abhängigen Bibliotheken installiert und die Umgebungsvariablen korrekt konfiguriert sind.
• Vorbereitung der DatenTraining mit qualitativ hochwertigen Sprachdaten für eine bessere Sprachsynthese.
• Modell-OptimierungAnpassung von Modellparametern und Trainingsstrategien zur Erzielung einer optimalen Leistung je nach Anwendungsszenario.

Anleitung zur lokalen Bereitstellung (mit lokalem Ein-Klick-Installationsprogramm)

Vor einigen Tagen wurde der Quellcode eines weiteren nicht-autoregressiven Text-to-Speech-KI-Modells, MaskGCT, veröffentlicht. Wie das ebenfalls nicht-autoregressive F5-TTS-Modell wurde das MaskGCT-Modell auf dem 100.000-Stunden-Datensatz Emilia trainiert und beherrscht die sprachenübergreifende Synthese von sechs Sprachen, nämlich Chinesisch, Englisch, Japanisch, Koreanisch, Französisch und Deutsch. Der Datensatz Emilia ist einer der größten und vielfältigsten hochwertigen mehrsprachigen Sprachdatensätze der Welt.

Dieses Mal zeigen wir Ihnen, wie Sie das MaskGCT-Projekt lokal einsetzen, um Ihre Grafikkarte wieder zum Laufen zu bringen.

Installation der grundlegenden Abhängigkeiten

Stellen Sie zunächst sicher, dass Python 3.11 lokal installiert ist. Sie können das Paket von der offiziellen Python-Website herunterladen.

python.org

Nachträgliches Klonen von offiziellen Projekten.

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

Offizielle linuxbasierte Installationsshellskripte werden bereitgestellt:

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

Hier konvertiert der Autor die Abhängigkeitsdatei requirements.txt für 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

Befehl ausführen:

pip3 install -r requirements.txt

Installieren Sie einfach die Abhängigkeiten.

Installieren Sie onnxruntime-gpu.

pip3 install onnxruntime-gpu

Einbau des dreiteiligen Brennersets.

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

Windows-Konfiguration espeak-ng

Da sich das MaskGCT-Projekt auf die espeak-Software stützt, muss diese lokal konfiguriert werden. eSpeak ist ein kompakter, quelloffener Text-to-Speech (TTS)-Synthesizer, der mehrere Sprachen und Akzente unterstützt. Er verwendet einen "Resonanzspitzen-Synthese"-Ansatz, der es ermöglicht, mehrere Sprachen auf kleinstem Raum zu liefern. Die Sprache ist klar und kann bei hohen Geschwindigkeiten verwendet werden, aber sie ist nicht so natürlich und glatt wie größere Synthesizer, die auf Aufnahmen menschlicher Sprache basieren. MaskGCT baut auf der Synthese von espeak mit sekundären Argumenten auf.

Führen Sie zunächst den Befehl zur Installation von espeak aus:

winget install espeak

Wenn Sie es nicht installieren können, können Sie auch das Installationsprogramm herunterladen und es manuell installieren:

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

Laden Sie dann das espeak-ng-Installationsprogramm herunter:

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

Herunterladen und per Doppelklick installieren.

Kopieren Sie dann C:\Programme\eSpeak NG\libespeak-ng.dll in das Verzeichnis C:\Programme (x86)\eSpeak\command_line.

Benennen Sie dann libespeak-ng.dll in espeak-ng.dll um.

Schließlich konfigurieren Sie einfach das Verzeichnis C:\Programme (x86)\eSpeak\command_line für die Umgebungsvariable.

MaskeGCT Lokales Reasoning

Wenn Sie das alles konfiguriert haben, schreiben Sie das Inferenzskript 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)

Bei der ersten Inferenz werden 10 G Modelle in das Verzeichnis hf_download heruntergeladen.

Der Berechnungsprozess beansprucht 11 GB des Videospeichers:

Wenn Sie über weniger als 11 GB Videospeicher verfügen, sollten Sie die Fallback-Richtlinie für den Systemspeicher in der Nvidia-Systemsteuerung aktivieren, um den Videospeicher über den Systemspeicher aufzustocken:

Wenn Sie möchten, können Sie auch eine einfache Web-Benutzeroberfläche auf Basis von gradio, app.py: schreiben.

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()

Und natürlich dürfen Sie nicht vergessen, die gradio-Abhängigkeit zu installieren:

pip3 install -U gradio

Der Run-Effekt sieht folgendermaßen aus:

Schlussbemerkungen

Der Vorteil von MaskGCT Modell ist, dass der Ton und Rhythmus Ebene ist sehr hervorragend, vergleichbar mit der realen Stimme, der Nachteil ist auch sehr offensichtlich, die laufenden Kosten sind hoch, die Optimierung der Engineering-Ebene ist unzureichend.MaskGCT Projekt-Homepage hat seine kommerzielle Version des Modells der Eingang, nach dieser Schlussfolgerung, die offizielle sollte nicht zu viel Macht in der Open-Source-Version, und schließlich ist die One-Key-Integration-Paket mit allen Menschen zu genießen, die gleiche.

MaskGCT Ein-Klick-Installationskit

Dieser Inhalt wurde vom Autor versteckt, bitte geben Sie den Verifizierungscode ein, um den Inhalt zu sehen

Captcha:

Bitte achten Sie auf diese Website WeChat öffentliche Nummer, Antwort "CAPTCHA, eine Art von Challenge-Response-Test (Computertechnik)", um den Verifizierungscode zu erhalten. Suchen Sie in WeChat nach "Leiter des AI-Austauschkreises"oder"Looks-AI" oder WeChat Scannen der rechten Seite des QR-Codes kann die Aufmerksamkeit auf diese Website WeChat öffentliche Zahl zu zahlen.