生成式 AI 模型训练实践 | 使⽤ NVIDIA NeMo 框架实现 TTS 的训练和推理应用

随笔2个月前发布 飞鱼
56 0 0

NVIDIA NeMo 是一个端到端云原生框架,无论是在本地还是在云上,用户可以灵活地构建、定制和部署生成式 AI 模型,更多内容可点击查看:NVIDIA Nemo——用于构建和部署生成式 AI 模型的端到端云原生框架_nv生态下的模型部署、迁移、调试

本期旨在了解和探讨使⽤ NVIDIA NeMo 框架实现 TTS 的训练和推理应⽤。

NVIDIA NeMo 的 ASR (Automatic Speech Recognition)、NLP (Nature Language Processing) 和 TTS(Text-to-Speech) 预训练模型是在多数据集上训练的(包括⼀些语⾔,如中⽂普通话),针对准确性进⾏了优化,可以⽤于训练、微调新模型或在现有预训练模型上进⾏迁移学习

模型的每个模块(如编码器、解码器)的预训练权重有助于加速特定领域数据的模型训练,同时对于推理⽽⾔,训练好的模型可以很容易地转换为可部署推理的格式。NeMo 也提供了教程帮助⽤户训练或微调⽤中⽂普通话进⾏对话 AI 的模型。

现代 TTS 系统相当复杂,“端到端”(指从原始⽂本到⾳频输出)pipeline 由多个组件组成,每个组件都需要⾃⼰的模型或启发式⽅法。⼀个标准的 pipeline ⼀般包含以下步骤:

生成式 AI 模型训练实践 | 使⽤ NVIDIA NeMo 框架实现 TTS 的训练和推理应用

图片来源于NVIDIA

1. ⽂本规范化:将原始⽂本转换为⼝语⽂本。

2. 词素到⾳素转换(G2P):将规范后⽂本的基本单位(即词素/字符)转换为⼝语的基本单位(即⾳素)。

3. 谱图合成:将⽂本/⾳素转换为频谱图。

4. ⾳频合成:使⽤声码器将频谱图转换为⾳频,也称为频谱图反转。

对于后两步(谱图合成、⾳频合成),⽬前⽐较常⽤两步组合的 pipeline,⽐如 Tacotron2 + WaveGlow 的组合,前者是从⽂本⽣成梅尔频谱的模型,后者是从梅尔频谱⽣成⾳频的模型,NeMo的较新进展是基于 FastPitch + HiFi-GAN 的组合

FastPitch 是基于 FastSpeech 完全并⾏的⽂本到语⾳合成模型,以基频轮廓为条件。该模型在推理过程中预测⾳⾼轮廓,通过改变这些预测,⽣成的语⾳可以更具表现⼒,更符合语句的语义,最终更能吸引听众。

HiFi-GAN 专注于设计⼀种声码器模型,能有效地从中间旋律谱图合成原始波形⾳频。它由⼀个发⽣器和两个鉴别器(多尺度和多周期)组成。⽣成器和鉴别器采⽤对抗训练,并增加了两个损失,以提⾼训练稳定性和模型性能。

NeMo 的“端到端”的模型还在开发中,TTS 推理部署⽅案建议使⽤我们之前分享过的 Triton 的 Ensemble Model 功能以零代码的⽅式组合同时运⾏的多个模块,如⽂本规范化、G2P、编码器等预处理

Triton Ensemble 可以将它们⽆缝组合在⼀起,⽽⽆需编写任何串联代码,实现了零代码的模型串联功能。对于声学模型的解码器、vocoder 以及最后的 Chunk 拼接的 Blender,Triton ensemble 也能以零代码的⽅式将它们组合在⼀起。前述模型包括Mel-Spectrogram Generator和 Vocoder,都可以使⽤ TensorRT 来加速推理。

生成式 AI 模型训练实践 | 使⽤ NVIDIA NeMo 框架实现 TTS 的训练和推理应用

图⽚来源于NVIDIA

使⽤ NeMo 可以快速实现以上步骤集成 TTS pipeline,NeMo 对于 TTS 训练有完整的⽀持包括:

  • Model Recipes,模型配⽅包括⽤于训练和评估模型的步骤和⽅法

  • Configuration Files,训练配置⽂件

  • Pre-trained Model Checkpoints,预训练模型权重

接下来我们将使⽤ NVIDIA NeMo FrameWork 容器实践 TTS 的训练,特别是频谱模型⾳频合成器模型的训练和微调。

一、系统环境准备

⼿动安装可以参考 NeMo 的安装指南(https://github.com/NVIDIA/NeMo/blob/stable/docs/source/starthere/intro.rst#installation) ,这⾥采⽤更简便的官⽅容器⽅式(镜像查询和下载可能需要⼀定的权限,请⾃⾏检查NGC账号权限)。

  1. # pull latest NeMo Framework container

  2. docker pull nvcr.io/nvidia/nemo:24.01.framework

  3. docker run -it -d

  4. --cap-add=SYS_PTRACE --cap-add=SYS_ADMIN

  5. --security-opt seccomp=unconfined --gpus=all

  6. --shm-size=16g --privileged --ulimit memlock=-1

  7. --name=nemo_test -v /home/docker/mnt:/home

  8. -p 28888:8888 -p 16006:6006

  9. nvcr.io/nvidia/nemo:24.01.framework

NeMo 部分组件版本信息:

  • ndc 0.1.0

  • nemo_toolkit 1.23.0

  • megatron_core 0.5.0rc0

  • transformer-engine 1.4.0.dev0+da30634

  • nemo_aligner 0.1.0rc0

NeMo 容器环境准备好之后,我们看⼀下 FastPitch 和 HiFi-GAN 模型的训练,FastPitch 与⼤多数 NeMo 模型⼀样,是⼀种 LightningModule,⽀持使⽤PyTorch Lightning训练,通过YAML⽂件定义来参数化配置并使⽤Hydra加载。

  1. # NeMo中使用预训练模型生成频谱图

  2. from nemo.collections.tts.models.base import SpectrogramGenerator

  3. from nemo.collections.tts.models import FastPitchModel

  4. from matplotlib.pyplot import imshow

  5. from matplotlib import pyplot as plt

  6. # 查看可使用的 FastPitch pretrained models 列表

  7. print("FastPitch pretrained models:")

  8. print(FastPitchModel.list_available_models())

  9. # 加载 pre-trained Model

  10. pretrained_model = "tts_en_fastpitch"

  11. spec_gen = FastPitchModel.from_pretrained(pretrained_model)

  12. spec_gen.eval();

  13. assert isinstance(spec_gen, SpectrogramGenerator)

  14. if isinstance(spec_gen, FastPitchModel):

  15. tokens = spec_gen.parse(str_input="Hey, welcome to Nvidia NeMo TTS!")

  16. else:

  17. tokens = spec_gen.parse(text="Hey, welcome to Nvidia NeMo TTS")

  18. spectrogram = spec_gen.generate_spectrogram(tokens=tokens)

  19. %matplotlib inline

  20. # 可视化查看生成的频谱图

  21. imshow(spectrogram.cpu().detach().numpy()[0,...], origin="lower")

  22. plt.show()

生成式 AI 模型训练实践 | 使⽤ NVIDIA NeMo 框架实现 TTS 的训练和推理应用

如上代码,我们简单尝试了使⽤ NeMo 框架⼯具利⽤ FastPitch 预训练模型⽣成频谱图。接下来我们按照 NVIDIA 官⽅提供的教程,实现⽀持中英⽂双语的 FastPitch 和 HiFi-GAN 的训练和微调

二、开启 jupyter notebook

⾸先在docker容器内开启 jupyter notebook,host 主机上访问http://localhost:8888,通过token登⼊,之后的训练过程主要会在 jupyter notebook 上进⾏。

  1. # 开启 jupyter notebook

  2. root@f37a875dac31:/home# jupyter notebook > "jupyter-`date +"%Y%m%d%H%M%S"`.log" 2>&1

  3. [I 06:07:19.341 NotebookApp] Writing notebook server cookie secret to /root/.local/share/jupyter/runtime/notebook_cookie_secret

  4. [I 06:07:20.233 NotebookApp] jupyter_tensorboard extension loaded.

  5. [I 06:07:20.538 NotebookApp] JupyterLab extension loaded from /usr/local/lib/python3.10/dist-packages/jupyterlab

  6. [I 06:07:20.538 NotebookApp] JupyterLab application directory is /usr/local/share/jupyter/lab

  7. [I 06:07:20.540 NotebookApp] [Jupytext Server Extension] NotebookApp.contents_manager_class is (a subclass of) jupytext.TextFileContentsManager already - OK

  8. [I 06:07:20.544 NotebookApp] Serving notebooks from local directory: /home

  9. [I 06:07:20.544 NotebookApp] Jupyter Notebook 6.4.10 is running at:

  10. [I 06:07:20.544 NotebookApp] http://hostname:8888/?token=87aeab0595ef72111a234a28cc996da5f35d494707b2c8b0

  11. [I 06:07:20.544 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).

  12. [C 06:07:20.547 NotebookApp]

  13. To access the notebook, open this file in a browser:

  14. file:///root/.local/share/jupyter/runtime/nbserver-2068-open.html

  15. Or copy and paste this URL:

  16. http://hostname:8888/?token=87aeab0595ef72111a234a28cc996da5f35d494707b2c8b0

三、下载相关脚本和⽂件

  1. # 以下命令在容器shell内执行

  2. cd /home

  3. export BRANCH = 'main'

  4. mkdir -p NeMoChineseTTS

  5. cd NeMoChineseTTS

  6. wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/scripts/tts_dataset_files/zh/24finals/pinyin_dict_nv_22.10.txt

  7. wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/scripts/dataset_processing/tts/sfbilingual/get_data.py

  8. wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/scripts/dataset_processing/tts/sfbilingual/ds_conf/ds_for_fastpitch_align.yaml

  9. wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/examples/tts/fastpitch.py

  10. wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/examples/tts/hifigan_finetune.py

  11. wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/scripts/dataset_processing/tts/extract_sup_data.py

  12. wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/scripts/dataset_processing/tts/generate_mels.py

  13. wget https://raw.githubusercontent.com/NVIDIA/NeMo/$BRANCH/examples/tts/conf/zh/fastpitch_align_22050.yaml

  14. wget https://raw.githubusercontent.com/NVIDIA/NeMo/$BRANCH/examples/tts/conf/hifigan/hifigan.yaml

  15. mkdir -p model/train_ds && cd model/train_ds && wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/examples/tts/conf/hifigan/model/train_ds/train_ds_finetune.yaml

  16. mkdir -p model/validation_ds && cd model/validation_ds && wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/examples/tts/conf/hifigan/model/validation_ds/val_ds_finetune.yaml

  17. mkdir -p model/generator && cd model/generator && wget https://raw.githubusercontent.com/nvidia/NeMo/$BRANCH/examples/tts/conf/hifigan/model/generator/v1.yaml

四、数据准备

FastPitch的原⽣训练相关代码和资料可查看DeepLearningExample,下⾯我们需要完成本次训练的数据准备⼯作,主要分4步。

1. 下载 SFSpeech 数据集

  1. # 第一步:下载 SFSpeech 数据集

  2. # 依赖 NGC ,请提前安装好 NGC CLI 工具

  3. mkdir DataChinese && cd DataChinese

  4. ngc registry resource download-version "nvidia/sf_bilingual_speech_zh_en:v1" &&

  5. cd sf_bilingual_speech_zh_en_vv1 &&

  6. unzip SF_bilingual.zip

SFSpeech 双语数据集发布在NGC,包含约2,740个单⼀⼥性发⾔者的双语⾳频样本及其相应的⽂本转录,每个样本的⾳频时⻓约为5-6秒,总时⻓约为4.5⼩时。

对于⾃定义数据的规范,官⽅给出的相关建议是:

  • 最好以22050赫兹的采样率获取语⾳数据,或者以更⾼的采样率获取数据,然后将其降采样⾄22050赫兹。

    > 如果低于22050赫兹且⾼于16000赫兹:

  • 请在⾃⼰的数据集上重新训练WaveGlow。

  • 调整频谱图⽣成参数,即窗⼝⼤⼩和傅⽴叶变换的窗⼝跨度。

    > 对于16000赫兹以下的频率,请考虑获取新数据。

  • 在⽐特率/量化⽅⾯,⼀般建议越⾼越好。我们还没有进⾏⾜够的实验来说明这对质量有多⼤影响。

  • 对于数据量,同样是越多越好,⽽且在⾳素⽅⾯越多样化越好。在过滤静⾳和⾮语⾳⾳频后,⽬标是⼤约20⼩时的语⾳。

  • ⼤多数开放语⾳数据集的格式约为10秒,可以认为⽤于训练Tacotron 2的⾳频数据⻓度10秒⾄20秒的是有效的。语⾳样本越⻓,训练就越困难。

  • ⾳频⽂件应该是⼲净的,背景噪⾳或⾳乐要少。使⽤⼯作室⻨克⻛录制的数据⽐使⽤⼿机捕获的数据更容易训练。

  • 为确保单词的发⾳准确;训练效果与数据集⾮常相关,需要进⾏⽂本到⾳标拼写,使⽤正确发⾳的⾳标字⺟(符号)。

2. 创建数据清单

借助前述下载好的脚本 get_data.py 读取数据集中提供的 DataChinese/SF_bilingual/text_SF.txt为每个数据点⽣成以下字段:

  • audio_filepath: wav⽂件的位置;

  • duration: wav⽂件的时⻓;

  • text: 原始⽂本;

  • normalized_text: 规范化后⽂本。

运⾏以下命令获取最终的清单:train_manifest.json , val_manifest.json 和 test_manifest.json 。命令将 1% 的数据分为验证集,1% 分为测试集,剩余的 98% 分为训练集。这个过程包含了拆分数据集处理和规范化数据两种操作。

  1. cd /home/NeMoChineseTTS

  2. python get_data.py

  3. --data-root ./DataChinese/sf_bilingual_speech_zh_en_vv1/SF_bilingual/

  4. --manifests-path ./

  5. --val-size 0.005

  6. --test-size 0.01

3. 音素化

⼀个中⽂句⼦的发⾳可以表示为⼀串⾳素,⾸先使⽤ pypinyin 库将句⼦转换为拼⾳序列,然后使⽤预定义的拼⾳到⾳素字典将它们转换为⾳素。对于句⼦中的英⽂单词,我们直接使⽤字⺟作为输⼊单位。例如:

  1. print("text: 我今天去了Central Park逛了逛。")

  2. print("pinyin: 'wo3', 'jin1', 'tian1', 'qu4', 'le5', 'C', 'e', 'n', 't', 'r', 'a', 'l', ' ', 'P', 'a', 'r', 'k', 'guang4', 'le1', 'guang4')

从 get_data.py ⽣成的原始 json 数据集拆分仅包含⽂本/字形输⼊,使⽤⾳素可以获得更⾼质量的合成⾳频。根据教程这⾥默认使⽤中⽂⾳素和英⽂字⺟作训练。

4. 创建补充数据

为了优化训练,还需要为每个⾳频提取⾳⾼,估计⾳⾼统计数据(均值、标准差、最⼩值和最⼤值),这⾥通过 extract_sup_data.py 脚本对数据进⾏⼀次迭代完成。注意:这是⼀个可选步骤,如果跳过,将在训练 FastPitch 的第⼀个 epoch ⾃动执⾏。

  1. cd /home/NeMoChineseTTS

  2. python extract_sup_data.py

  3. --config-path .

  4. --config-name ds_for_fastpitch_align.yaml

  5. manifest_filepath=train_manifest.json

  6. sup_data_path=sup_data

  7. phoneme_dict_path=pinyin_dict_nv_22.10.txt

  8. ++dataloader_params.num_workers=4

五、模型训练

1. 训练FastPitch模型

在训练模型之前先定义模型配置,配置⽂件:fastpitch_align_22050.yaml ,⼤部分模型配置保持不变,此外有两处改动:

  • phoneme_dict_path ⽂件路径指向 pinyin_dict_nv_22.10.txt ;

  • pitch_mean 和 pitch_std 使⽤上述 extract_sup_data.py 脚本估算出的值进⾏更新:

              PITCH_MEAN=226.75924682617188,

              PITCH_STD=58.773109436035156,

              PITCH_MIN=65.4063949584961,

              PITCH_MAX=1986.977294921875.

  1. # 单卡训练

  2. cd NeMoChineseTTS

  3. CUDA_VISIBLE_DEVICES=0 python fastpitch.py

  4. --config-path .

  5. --config-name fastpitch_align_22050

  6. model.train_ds.dataloader_params.batch_size=32

  7. model.validation_ds.dataloader_params.batch_size=32

  8. train_dataset=train_manifest.json

  9. validation_datasets=val_manifest.json

  10. sup_data_path=sup_data

  11. exp_manager.exp_dir=resultChineseTTS

  12. trainer.max_epochs=1500

  13. trainer.check_val_every_n_epoch=1

  14. pitch_mean=226.75924682617188

  15. pitch_std=58.773109436035156

  16. phoneme_dict_path=pinyin_dict_nv_22.10.txt

注意:

> 使⽤ CUDA_VISIBLE_DEVICES=0 来限制训练仅在单个GPU上进⾏;

> 添加FLAGS:HYDRA_FULL_ERROR=1, CUDA_LAUNCH_BLOCKING=1 开启debug模式;

> 从头开始训练,建议使⽤⾄少5000个epochs。

2. 评估:训练好的 FastPitch + 预训练 HiFi-GAN

  1. import IPython.display as ipd

  2. from nemo.collections.tts.models import HifiGanModel, FastPitchModel

  3. from matplotlib.pyplot import imshow

  4. from matplotlib import pyplot as plt

  5. test = "Hotmail会以资料夹方式区分不同邮件来源"

  6. test_id = "com_SF_ce438"

  7. data_path = "NeMoChineseTTS/DataChinese/sf_bilingual_speech_zh_en_vv1/SF_bilingual/wavs/"

  8. seed = 1104

  9. def evaluate_spec_fastpitch_ckpt(spec_gen_model, v_model, test):

  10. with torch.no_grad():

  11. torch.manual_seed(seed)

  12. torch.cuda.manual_seed(seed)

  13. torch.backends.cudnn.enabled = True

  14. torch.backends.cudnn.benchmark = False

  15. parsed = spec_gen_model.parse(str_input=test, normalize=True)

  16. spectrogram = spec_gen_model.generate_spectrogram(tokens=parsed)

  17. print(spectrogram.size())

  18. audio = v_model.convert_spectrogram_to_audio(spec=spectrogram)

  19. spectrogram = spectrogram.to('cpu').numpy()[0]

  20. audio = audio.to('cpu').numpy()[0]

  21. audio = audio / np.abs(audio).max()

  22. return audio, spectrogram

  23. # 加载 fastpitch 和 hifigan 模型

  24. import glob, os

  25. # fastpitch_nemo_or_ckpt文件路径

  26. fastpitch_model_path = sorted(glob.glob("NeMoChineseTTS/resultChineseTTS/FastPitch/*/checkpoints/*.*"),key=os.path.getmtime)[-1]

  27. # 预训练模型 hifigan, 来源:https://api.ngc.nvidia.com/v2/models/nvidia/nemo/tts_en_lj_hifigan/versions/1.6.0/files/tts_en_lj_hifigan_ft_mixerttsx.nemo

  28. hfg_ngc = "tts_en_lj_hifigan_ft_mixerttsx"

  29. vocoder_model = HifiGanModel.from_pretrained(hfg_ngc, strict=False).eval().cuda()

  30. if ".nemo" in fastpitch_model_path:

  31. spec_gen_model = FastPitchModel.restore_from(fastpitch_model_path).eval().cuda()

  32. else:

  33. spec_gen_model = FastPitchModel.load_from_checkpoint(checkpoint_path=fastpitch_model_path).eval().cuda()

  34. %matplotlib inline

  35. audio, spectrogram = evaluate_spec_fastpitch_ckpt(spec_gen_model, vocoder_model, test)

  36. # 播放音频

  37. print("原始音频")

  38. ipd.display(ipd.Audio(filename=data_path+test_id+'.wav', rate=22050))

  39. print("预测音频")

  40. ipd.display(ipd.Audio(audio, rate=22050))

  • 原始⾳频:hotmail-orig.wav

  • 预测⾳频(62 epoches): hotmail-generate-62epoches.wav

  • 预测⾳频(1594 epoches):hotmail-generate-1594epoches.wav

基于以上代码,我们⼀共⽐较了三个训练模型,分别迭代62、1594、5000 epochs,迭代 62 次合成的⾳频质量是⽐较糟糕的,在训练1594个epochs后有所改善但仍然不理想。因为上述⽐较使⽤的是预训练HiFi-GAN模型,为了进⼀步提⾼质量下⾯我们依照微调 FastPitch 的⽅式对 HiFi-GAN 进⾏微调。

3. 微调预训练 HiFi-GAN 模型

微调数据准备

我们运⾏以下代码使⽤ generate_spectrogram 中定义的⽅法从FastPitch⽣成梅尔频谱图,然⽽⽣成的频谱图与原始⾳频的mel频谱图不同,如下所示:

  1. test_audio_filepath = "NeMoChineseTTS/DataChinese/sf_bilingual_speech_zh_en_vv1/SF_bilingual/wavs/com_SF_ce1.wav"

  2. test_audio_text = "NTHU對面有一條宵夜街。"

  3. from matplotlib.pyplot import imshow

  4. from nemo.collections.tts.models import FastPitchModel

  5. from matplotlib import pyplot as plt

  6. import librosa

  7. import librosa.display

  8. import torch

  9. import soundfile as sf

  10. import numpy as np

  11. from nemo.collections.tts.parts.utils.tts_dataset_utils import BetaBinomialInterpolator

  12. def load_wav(audio_file):

  13. with sf.SoundFile(audio_file, 'r') as f:

  14. samples = f.read(dtype='float32')

  15. return samples.transpose()

  16. def plot_logspec(spec, axis=None):

  17. librosa.display.specshow(

  18. librosa.amplitude_to_db(spec, ref=np.max),

  19. y_axis='linear',

  20. x_axis="time",

  21. fmin=0,

  22. fmax=8000,

  23. ax=axis

  24. )

  25. spec_model = FastPitchModel.load_from_checkpoint(fastpitch_model_path).eval().cuda()

  26. print("加载原始音频梅尔频谱")

  27. y, sr = librosa.load(test_audio_filepath)

  28. # change n_fft, win_length, hop_length parameters below based on your specific config file

  29. spectrogram2 = np.log(librosa.feature.melspectrogram(y=y, sr=sr, n_fft=1024, win_length=1024, hop_length=256))

  30. spectrogram = spectrogram2[ :80, :]

  31. print("spectrogram shape = ", spectrogram.shape)

  32. plot_logspec(spectrogram)

  33. plt.show()

  34. print("加载预测的梅尔频谱")

  35. with torch.no_grad():

  36. text = spec_model.parse(test_audio_text, normalize=False)

  37. spectrogram = spec_model.generate_spectrogram(

  38. tokens=text,

  39. speaker=None,

  40. )

  41. spectrogram = spectrogram.to('cpu').numpy()[0]

  42. plot_logspec(spectrogram)

  43. print("spectrogram shape = ", spectrogram.shape)

  44. plt.show()

生成式 AI 模型训练实践 | 使⽤ NVIDIA NeMo 框架实现 TTS 的训练和推理应用

原始⾳频梅尔频谱

生成式 AI 模型训练实践 | 使⽤ NVIDIA NeMo 框架实现 TTS 的训练和推理应用

预测⽣成的梅尔频谱

从上图⽐较来看,我们需要将FastPitch预测的梅尔频谱图与真实数据对⻬包括持续时间。为什么不使⽤原始数据的梅尔频谱图呢?使⽤原始数据的梅尔频谱图进⾏微调会引⼊原始⾳频中的噪声伪影,这些噪声伪影会作为输⼊传递到模型,从⽽导致声码器输出中带有噪声。对⻬了的预测梅尔频谱图可以使HiFi-GAN能够不产⽣噪声⼜更接近真实。

具体实现:从FastPitch训练中获取最新的checkpoint,并预测每个输⼊记录的频谱图,这些记录分别位于train_manifest.json , test_manifest.json 和 val_manifest.json 中。

NeMo提供了⼀个⾼效的脚本,在⽬录NeMoChineseTTS/mels中⽣成梅尔频谱,并通过添加新字段 “mel_filepath” 创建具有后缀“_mel” 的新清单。例如, train_manifest.json 对应 train_manifest_mel.json 。值得⼀提的是,此脚本借助于NeMo提供的⼯具,利⽤真实频谱⻓度和插值后数据来⽣成对⻬的预测频谱图。

  1. # 运行以下命令来获取新清单

  2. cd /home/NeMoChineseTTS

  3. python generate_mels.py --cpu

  4. --fastpitch-model-ckpt {fastpitch_model_path}

  5. --input-json-manifests train_manifest.json val_manifest.json test_manifest.json

  6. --output-json-manifest-root ./

开始微调

  1. cd /home/NeMoChineseTTS

  2. CUDA_VISIBLE_DEVICES=0 python hifigan_finetune.py

  3. --config-path .

  4. --config-name hifigan.yaml

  5. trainer.max_steps=10

  6. model.optim.lr=0.00001

  7. ~model.optim.sched

  8. train_dataset=train_manifest_mel.json

  9. validation_datasets=val_manifest_mel.json

  10. exp_manager.exp_dir=resultChineseTTS

  11. +init_from_pretrained_model={hfg_ngc}

  12. +trainer.val_check_interval=5

  13. trainer.check_val_every_n_epoch=null

  14. model/train_ds=train_ds_finetune

  15. model/validation_ds=val_ds_finetune

4. 评估:训练好的 FastPitch + 微调的预训练HiFi-GAN

  1. hfg_path = sorted(glob.glob("NeMoChineseTTS/resultChineseTTS/HifiGan/*/checkpoints/HifiGan.nemo"), key=os.path.getmtime)[-1]

  2. if ".nemo" in hfg_path:

  3. vocoder_model_pt = HifiGanModel.restore_from(hfg_path).eval().cuda()

  4. else:

  5. vocoder_model_pt = HifiGanModel.load_from_checkpoint(checkpoint_path=hfg_path).eval().cuda()

  6. if ".nemo" in fastpitch_model_path:

  7. spec_gen_model = FastPitchModel.restore_from(fastpitch_model_path).eval().cuda()

  8. else:

  9. spec_gen_model = FastPitchModel.load_from_checkpoint(checkpoint_path=fastpitch_model_path).eval().cuda()

  10. %matplotlib inline

  11. audio, spectrogram = evaluate_spec_fastpitch_ckpt(spec_gen_model, vocoder_model_pt, test)

  12. # 播放音频

  13. print("原始音频")

  14. ipd.display(ipd.Audio(data_path+test_id+'.wav', rate=22050))

  15. print("预测音频")

  16. ipd.display(ipd.Audio(audio, rate=22050))

  • 原始⾳频:hotmail-orig.wav

  • 微调后预测⾳频:hotmail-generate-finetune.wav

至此,我们使⽤ NVIDIA NeMo 框架实现了 TTS 的训练和推理应⽤,接下来,我们还将实践更多模型的训练及推理。欢迎关注我们!

© 版权声明

相关文章

暂无评论

您必须登录才能参与评论!
立即登录
暂无评论...