Introdução geral
O MaskGCT (Masked Generative Codec Transformer) é um modelo de conversão de texto em fala (TTS) totalmente não-autoregressivo introduzido em conjunto pela Funky Maru Technology e pela Universidade Chinesa de Hong Kong. O modelo elimina a necessidade de informações explícitas de alinhamento de texto para fala e adota uma abordagem de geração de duas fases, primeiro prevendo a codificação semântica a partir do texto e, em seguida, gerando a codificação acústica a partir da codificação semântica. O MaskGCT tem bom desempenho na tarefa de TTS de amostra zero, fornecendo saída de fala de alta qualidade, semelhante e fácil de entender.
Produto Beta Público: Funmaru Chiyo, ferramenta de tradução multilíngue de clonagem de voz e vídeo
Tese: https://arxiv.org/abs/2409.00750
Demonstração on-line: https://huggingface.co/spaces/amphion/maskgct
Lista de funções
- Conversão de texto em fala (TTS)Texto de entrada: converte o texto de entrada em saída de fala.
- codificação semânticaCodificação semântica: converte a fala em codificação semântica para processamento subsequente.
- código acústicoCodificação semântica: converta a codificação semântica em codificação acústica e reconstrua a forma de onda de áudio.
- aprendizado de amostra zeroSíntese de fala de alta qualidade sem informações de alinhamento explícitas.
- Modelo de pré-treinamentoUma ampla variedade de modelos pré-treinados está disponível para dar suporte à implantação e ao uso rápidos.
Usando a Ajuda
Processo de instalação
- projeto de clonagem::
git clone https://github.com/open-mmlab/Amphion.git - Criação de um ambiente e instalação de dependências::
bash . /models/tmaskgct/env.sh
Processo de uso
- Download do modelo pré-treinadoOs modelos pré-treinados necessários podem ser baixados do HuggingFace:
from huggingface_hub import hf_hub_download Modelo de codificação semântica de download do # semantic_code_ckpt = hf_hub_download("amphion/MaskGCT", filename="semantic_codec/model.safetensors") # Download do modelo de codificação acústica 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") # Faça o download do modelo TTS t2s_model_ckpt = hf_hub_download("amphion/MaskGCT", filename="t2s_model/model.safetensors") - Gerar discursoUse o código a seguir para gerar fala a partir de texto:
# Importe as bibliotecas necessárias from amphion.models.tts.maskgct import MaskGCT # Inicialize o modelo model = MaskGCT() # Insira o texto text = "Olá e bem-vindo ao modelo MaskGCT". # Gerar fala audio = model.text_to_speech(text) # Salve a fala gerada com open("output.wav", "wb") as f. f.write(audio) - treinamento de modelosSe você precisar treinar seu próprio modelo, poderá consultar os scripts de treinamento e os arquivos de configuração do projeto para a preparação de dados e o treinamento do modelo.
advertência
- Configuração do ambienteVerifique se todas as bibliotecas dependentes necessárias estão instaladas e se as variáveis de ambiente estão configuradas corretamente.
- Preparação de dadosTreinamento com dados de fala de alta qualidade para uma melhor síntese de fala.
- Otimização de modelosAjuste os parâmetros do modelo e as estratégias de treinamento para obter o desempenho ideal de acordo com cenários de aplicativos específicos.
Tutorial de implantação local (com instalador local de um clique)
Há alguns dias, outro modelo de IA de conversão de texto em fala não autorregressivo, o MaskGCT, abriu seu código-fonte. Assim como o modelo F5-TTS, que também é não autorregressivo, o modelo MaskGCT é treinado no conjunto de dados Emilia de 100.000 horas e é proficiente na síntese entre idiomas de seis idiomas, a saber, chinês, inglês, japonês, coreano, francês e alemão. O conjunto de dados Emilia é um dos maiores e mais diversificados conjuntos de dados de fala multilíngue de alta qualidade do mundo.
Desta vez, compartilharemos como implantar o projeto MaskGCT localmente para que sua placa de vídeo volte a funcionar.
Instalação de dependências básicas
Antes de mais nada, certifique-se de que o Python 3.11 esteja instalado localmente, e você pode fazer o download do pacote no site oficial do Python.
python.org
Clonagem subsequente de projetos oficiais.
git clone https://github.com/open-mmlab/Amphion.git
São fornecidos scripts oficiais de shell de instalação baseados em Linux:
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
Aqui o autor converte o arquivo de dependência requirements.txt para Windows:
ferramentas de configuração
ruamel.yaml
tqdm
transformers===4.41.1
codec
black==24.1.1
oss2
fonemizador
g2p_pt
accelerate==0.31.0
funasr
zhconv
zhon
modelscope
timm
jieba
unidecode
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
Executar comando:
pip3 install -r requirements.txt
Basta instalar as dependências.
Instale o onnxruntime-gpu.
pip3 install onnxruntime-gpu
Instalação do conjunto de três peças da tocha.
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
Configuração do Windows espeak-ng
Como o projeto MaskGCT depende do software espeak para seu back-end, ele precisa ser configurado localmente. O eSpeak é um sintetizador de texto para fala (TTS) compacto e de código aberto que suporta vários idiomas e sotaques. Ele usa uma abordagem de "síntese de pico de ressonância" que permite que vários idiomas sejam fornecidos em um espaço reduzido. A fala é clara e pode ser usada em altas velocidades, mas não é tão natural e suave quanto a de sintetizadores maiores baseados em gravações de fala humana, e o MaskGCT se baseia na síntese do espeak com raciocínio secundário.
Primeiro, execute o comando para instalar o espeak:
winget install espeak
Se não for possível instalá-lo, você também pode fazer o download do instalador e instalá-lo manualmente:
https://sourceforge.net/projects/espeak/files/espeak/espeak-1.48/setup_espeak-1.48.04.exe/download
Em seguida, faça o download do instalador do espeak-ng:
https://github.com/espeak-ng/espeak-ng/releases
Faça o download e clique duas vezes para instalar.
Em seguida, copie C:\Program Files\eSpeak NG\libespeak-ng.dll para o diretório C:\Program Files (x86)\eSpeak\command_line.
Em seguida, renomeie libespeak-ng.dll para espeak-ng.dll
Por fim, basta configurar o diretório C:\Program Files (x86)\eSpeak\command_line para a variável de ambiente.
Raciocínio local do MaskGCT
Com tudo isso configurado, escreva o script de inferência local_test.py:
de models.tts.maskgct.maskgct_utils import *
from huggingface_hub import hf_hub_download
importar 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="Fale como se eu tivesse me saído bem no exame algumas vezes desde que você me levou")
parser.add_argument("-a", "--audio", type=str, default=". /disse como se eu tivesse me saído bem algumas vezes desde que você me pegou.wav")
parser.add_argument("-t", "--text", type=str, default="Hello")
parser.add_argument("-l", "--language", type=str, default="zh")
parser.add_argument("-lt", "---target_language", type=str, default="zh")
args = parser.parse_args()
se __name__ == "__main__".
# download do ckpt do codec semântico
semantic_code_ckpt = hf_hub_download("amphion/MaskGCT", filename="semantic_codec/model.safetensors")
# download do codec acústico 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 do modelo s2a 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")
Modelo de construção #
dispositivo = torch.device("cuda")
cfg_path = ". /models/tmaskgct/config/maskgct.json"
cfg = load_config(cfg_path)
# 1. Criar modelo semântico (w2v-bert-2.0)
semantic_model, semantic_mean, semantic_std = build_semantic_model(device)
# 2. Criar codec semântico
semantic_codec = build_semantic_codec(cfg.model.semantic_codec, device)
# 3. Criar codec acústico
codec_encoder, codec_decoder = build_acoustic_codec(cfg.model.acoustic_codec, device)
# 4. Criar o modelo t2s
t2s_model = build_t2s_model(cfg.model.t2s_model, device)
# 5. Construir o modelo s2a
s2a_model_1layer = build_s2a_model(cfg.model.s2a_model.s2a_1layer, dispositivo)
s2a_model_full = build_s2a_model(cfg.model.s2a_model.s2a_full, dispositivo)
# carrega o codec semântico
safetensors.torch.load_model(semantic_codec, semantic_code_ckpt)
# carregar codec acústico
safetensors.torch.load_model(codec_encoder, codec_encoder_ckpt)
safetensors.torch.load_model(codec_decoder, codec_decoder_ckpt)
# carrega o modelo t2s
safetensors.torch.load_model(t2s_model, t2s_model_ckpt)
# carregar modelo s2a
safetensors.torch.load_model(s2a_model_1layer, s2a_1layer_ckpt)
safetensors.torch.load_model(s2a_model_full, s2a_full_ckpt)
Inferência #
prompt_wav_path = args.audio
save_path = "output.wav"
prompt_text = args.prompt_text
target_text = args.text
# Especifique a duração do alvo (em segundos). Se target_len = None, usamos uma regra simples para prever a duração do alvo. target_len = None, usamos uma regra simples para prever a duração do alvo.
Se target_len = None, usamos uma regra simples para prever a duração do alvo. 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,
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)
A primeira inferência fará o download de 10 Gs de modelos no diretório hf_download.
O processo de raciocínio ocupa 11 G de memória de vídeo:
Se você tiver menos de 11 G de memória de vídeo, certifique-se de ativar a política de fallback da memória do sistema no painel de controle da Nvidia para aumentar a memória de vídeo por meio da memória do sistema:
Se desejar, você também pode escrever uma interface webui simples com base no gradio, app.py:.
importar os
importar 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')
# Configuração da variável de ambiente HF_ENDPOINT
os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
reference_wavs = ["Selecione o áudio de referência ou faça o upload você mesmo"]
for name in os.listdir(". /Reference_Audio/"):: reference_wavs.
reference_wavs.append(name)
def change_choices(): reference_wavs = [reference_wavs.append(name)
reference_wavs = ["Escolha o áudio de referência ou carregue-o você mesmo"]
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". /referência de áudio/{caminho_do_áudio}",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_ texto_de_escolha} '
print(cmd)
res = subprocess.Popen(cmd)
res.wait()
return "output.wav"
com gr.Blocks() as app_demo.
gr.Markdown(
"""
Endereço do projeto: https://github.com/open-mmlab/Amphion/tree/main/models/tts/maskgct
Produção do pacote de integração: blog de tecnologia de Liu Yue https://space.bilibili.com/3031494
"""
)
gen_text_input = gr.Textbox(label="Generate Text", lines=4)
model_choice_text = gr.Radio(
choices=["zh", "en"], label="Generate Text Language", value="zh",interactive=True)
wavs_dropdown = gr.Dropdown(label="Reference Audio List", choices=reference_wavs, value="Choose reference audio or upload yourself", interactive=True)
refresh_button = gr.Button("Refresh Reference Audio")
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 transcript")
info="Deixe em branco para transcrever automaticamente o áudio de referência. Se você inserir um texto, ele substituirá a transcrição automática.", lines=2, ref_text_input = gr.
Se você inserir texto, ele substituirá a transcrição automática.", lines=2, )
)
model_choice_re = gr.Radio(
choices=["zh", "en"], label="Reference audio language", 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="Synthesised 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 "Iniciando o aplicativo...")
app_demo.launch(inbrowser=True)
if __name__ == "__main__": main(): if __name__ == "__main__".
main()
E, é claro, não se esqueça de instalar a dependência do gradio:
pip3 install -U gradio
O efeito de execução é parecido com o seguinte:
observações finais
A vantagem do modelo MaskGCT é que o nível de tom e ritmo é excelente, comparável à voz real; a desvantagem também é muito óbvia, o custo de operação é alto, a otimização do nível de engenharia é insuficiente. A página inicial do projeto MaskGCT tem sua versão comercial do modelo de entrada, de acordo com essa inferência, o funcionário não deve ter muita força na versão de código aberto e, por fim, o pacote de integração de uma chave é apresentado com todas as pessoas para aproveitar o mesmo.
Português do Brasil 
简体中文 
English 
日本語 
Deutsch (Sie)