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 verfolgt 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 Null-Sample-TTS-Aufgabe 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
Ablauf der Installation
- Klonprojekt::
git clone https://github.com/open-mmlab/Amphion.git - Erstellen einer Umgebung und Installieren von Abhängigkeiten::
bash . /models/tts/maskgct/env.sh
Verwendung Prozess
- Download des vortrainierten ModellsDie benötigten vortrainierten Modelle können von HuggingFace heruntergeladen werden:
from huggingface_hub import hf_hub_download #-Download des semantischen Kodierungsmodells semantic_code_ckpt = hf_hub_download("amphion/MaskGCT", filename="semantic_codec/model.safetensors") # Download des akustischen Kodierungsmodells 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") # Herunterladen des TTS-Modells t2s_model_ckpt = hf_hub_download("amphion/MaskGCT", filename="t2s_model/model.safetensors") - Sprache generieren: Verwenden Sie den folgenden Code, um Sprache aus Text zu erzeugen:
# Importieren Sie die erforderlichen Bibliotheken aus amphion.models.tts.maskgct importieren MaskGCT # Initialisieren des Modells model = MaskGCT() # Text eingeben text = "Hallo und willkommen beim MaskGCT-Modell." # Sprache generieren audio = model.text_to_speech(text) # Speichern Sie die generierte Sprache with open("output.wav", "wb") as f. f.write(audio) - 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 wird das MaskGCT-Modell auf dem 100.000-Stunden-Datensatz Emilia trainiert und beherrscht die sprachü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 schwarz==24.1.1
pip install oss2
sudo apt-get install espeak-ng
pip install phonemizer
pip install g2p_de
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
schwarz==24.1.1
oss2
Phonemizer
g2p_de
beschleunigen==0.31.0
funasr
zhconv
zhon
modelscope
timm
jieba
cn2an
unidecode
cos-python-sdk-v5
cos-python-sdk-v5
cos-python-sdk
omegaconf
pyworld
py3langid==0.2.2
LangSegment
onnxruntime
pyopenjtalk
pykakasi
openai-whisper
json5
Befehl ausführen:
pip3 install -r anforderungen.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 installieren 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 importieren *
von huggingface_hub importieren hf_hub_download
importieren safetensors
importiere soundfile als sf
importieren os
importieren 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(Beschreibung="GPT-SoVITS api")
parser.add_argument("-p", "--prompt_text", type=str, default="Sprich so, als ob ich in der Prüfung ein paar Mal gut abgeschnitten hätte, seit du mich genommen hast")
parser.add_argument("-a", "--audio", type=str, default=". /said as if I've done well a few times since you took me.wav")
parser.add_argument("-t", "--text", type=str, default="Hallo")
parser.add_argument("-l", "--Sprache", type=str, Voreinstellung="zh")
parser.add_argument("-lt", "---Zielsprache", type=str, default="zh")
args = parser.parse_args()
if __name__ == "__main__".
# lädt semantischen Codec ckpt herunter
semantic_code_ckpt = hf_hub_download("amphion/MaskGCT", filename="semantic_codec/model.safetensors")
# Download akustischer 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")
# t2s-Modell ckpt herunterladen
t2s_model_ckpt = hf_hub_download("amphion/MaskGCT", filename="t2s_model/model.safetensors")
# Download s2a Modell 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")
#-Modell erstellen
Gerät = torch.device("cuda")
cfg_path = ". /models/tts/maskgct/config/maskgct.json"
cfg = load_config(cfg_path)
# 1. semantisches Modell erstellen (w2v-bert-2.0)
semantic_model, semantic_mean, semantic_std = build_semantic_model(device)
# 2. semantischen Codec erstellen
semantic_codec = build_semantic_codec(cfg.model.semantic_codec, device)
# 3. akustischen Codec erstellen
codec_encoder, codec_decoder = build_acoustic_codec(cfg.model.acoustic_codec, device)
# 4. t2s-Modell erstellen
t2s_model = build_t2s_model(cfg.model.t2s_model, Gerät)
# 5. s2a-Modell erstellen
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)
# semantischen Codec laden
safetensors.torch.load_model(semantischer_codec, semantischer_code_ckpt)
# lädt akustischen Codec
safetensors.torch.load_model(codec_encoder, codec_encoder_ckpt)
safetensors.torch.load_model(codec_decoder, codec_decoder_ckpt)
# lädt t2s Modell
safetensors.torch.load_model(t2s_model, t2s_model_ckpt)
# lädt s2a-Modell
safetensors.torch.load_model(s2a_model_1layer, s2a_1layer_ckpt)
safetensors.torch.load_model(s2a_model_full, s2a_full_ckpt)
#-Schlussfolgerung
prompt_wav_pfad = args.audio
save_path = "output.wav"
prompt_text = args.prompt_text
ziel_text = args.text
# Geben Sie die Zieldauer (in Sekunden) an. Ist target_len = None, wird eine einfache Regel zur Vorhersage der Zieldauer verwendet. target_len = None, wird eine einfache Regel zur Vorhersage der Zieldauer verwendet.
Ist target_len = None, wird eine einfache Regel zur Vorhersage der Zieldauer verwendet. target_len = None
maskgct_inference_pipeline = MaskGCT_Inference_Pipeline(
maskgct_inference_pipeline = MaskGCT_Inference_Pipeline(
semantic_model, semantic_codec, codec_encoder, codec_pipeline
codec_decoder, t2s_model, t2s_model
t2s_model,
s2a_model_1layer, s2a_model_full, s2a_model_1layer
s2a_model_full,
semantic_mean, semantic_std, s2a_model_full, semantic_mean
semantic_std,
Gerät,
)
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.
importieren os
importieren gc
importieren re
importiere gradio als gr
importiere numpy als np
importieren subprocess
os.environ['HF_HOME'] = os.path.join(os.path.dirname(__file__), 'hf_download')
# Setzen der Umgebungsvariablen HF_ENDPOINT
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
reference_wavs = ["Bitte wählen Sie Referenz-Audio aus oder laden Sie es selbst hoch"]
for name in os.listdir(". /Reference_Audio/"):: reference_wavs.
reference_wavs.append(name)
def change_choices(): reference_wavs = [reference_wavs.append(name)
reference_wavs = ["Bitte wählen Sie Referenz-Audio oder laden Sie es selbst hoch"]
for name in os.listdir(". /reference_wavs/"): reference_wavs.
reference_wavs.append(name)
return {"choices":reference_wavs, "__type__": "update"}
def change_wav(audio_path): text = audio_path.
text = audio_path.replace(".wav","").replace(".mp3","").replace(".WAV","")
# text = replace_speaker(text)
return f". /reference audio/{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(
"""
Projektadresse:https://github.com/open-mmlab/Amphion/tree/main/models/tts/maskgct
Produktion des Integrationspakets:Liu Yue's Technologie-Blog https://space.bilibili.com/3031494
"""
)
gen_text_input = gr.Textbox(label="Text generieren", lines=4)
model_choice_text = gr.Radio(
choices=["zh", "en"], label="Text generieren Sprache", value="zh",interactive=True)
wavs_dropdown = gr.Dropdown(label="Referenz-Audio-Liste", choices=reference_wavs, value="Referenz-Audio auswählen oder selbst hochladen", interactive=True)
refresh_button = gr.Button("Referenz-Audio aktualisieren")
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="Referenztext", info="Leer lassen, um automatisch zu transkribieren")
info="Leer lassen, um das Referenz-Audio automatisch zu transkribieren. Wenn Sie Text eingeben, wird die automatische Transkription außer Kraft gesetzt.", lines=2, ref_text_input = gr.Textbox
Wenn Sie Text eingeben, wird die automatische Transkription außer Kraft gesetzt.", lines=2, )
)
model_choice_re = gr.Radio(
choices=["zh", "en"], label="Referenz-Audiosprache", 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="Synthetisiertes 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
global app_demo
print(f "App starten...")
app_demo.launch(inbrowser=True)
if __name__ == "__main__": main(): 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
Das MaskGCT-Modell hat den Vorteil, dass es eine sehr ausgeprägte Ton- und Rhythmusebene hat, vergleichbar mit echter Sprache, aber die Nachteile sind auch offensichtlich, die laufenden Kosten sind hoch, und die technische Ebene ist nicht genug optimiert. die MaskGCT-Projekt-Homepage hat bereits einen Einstiegspunkt für die kommerzielle Version des Modells, und nach dieser Schlussfolgerung, die offizielle Regierung wird nicht zu viel Aufwand in der Open-Source-Version, und schließlich präsentieren wir eine Ein-Klick-Integration-Paket, mit dem Volk zu genießen das Fest:.
