【项目实战】FastSpeech 代码解析 —— dataset.py

FastSpeech 代码解析 —— dataset.py

  简介

       本项目一个基于 FastSpeech 模型的语音转换项目，它是使用 PyTorch 实现的(项目地址)。
       
        FastSpeech 基于 Transformer 的前馈网络，用于并行生成 TTS 梅尔谱图。 FastSpeech 模型与自回归 Transformer TTS 相比，梅尔谱图生成速度加快了 270 倍，端到端语音合成速度加快了 38 倍。(详情请参阅 FastSpeech 的详细介绍)。
       
       由于 FastSpeech 项目较大，代码较多，为了方便学习与整理，对主要代码进行依次介绍。
       
       本文将介绍项目中的 dataset.py 文件： FastSpeech 数据集相关处理
       

  函数解析

    get_data_to_buffer

          该函数的作用是： 加载训练数据，组装数据集

          输出参数：

		buffer	:	

          代码详解：

		def get_data_to_buffer():
		    # 创建列表
		    buffer = list()
		    # 将 LJSpeech 数据集语音文本列表从磁盘读取到内存
		    text = process_text(os.path.join("data", "train.txt"))
		
		    # 记录开始时间
		    start = time.perf_counter()
		    for i in tqdm(range(len(text))):
		        # 获取 mel 谱图文件名，并加载至内存
		        mel_gt_name = os.path.join(
		            hparams.mel_ground_truth, "ljspeech-mel-%05d.npy" % (i+1))
		        mel_gt_target = np.load(mel_gt_name)
		        # 加载音素持续时间文件
		        duration = np.load(os.path.join(
		            hparams.alignment_path, str(i)+".npy"))
		        # 加载语音文本
		        character = text[i][0:len(text[i])-1]
		        # 将文本与音素进行对应，转换为音素编号序列
		        character = np.array(
		            text_to_sequence(character, hparams.text_cleaners))
		
		        # 将音素序列、持续时间、mel谱图转为
		        character = torch.from_numpy(character)
		        duration = torch.from_numpy(duration)
		        mel_gt_target = torch.from_numpy(mel_gt_target)
		
		        # 将处理的数据组合成字典添加进列表
		        buffer.append({"text": character, "duration": duration,
		                       "mel_target": mel_gt_target})
		
		    # 记录结束时间，打印加载日志
		    end = time.perf_counter()
		    print("cost {:.2f}s to load all data into buffer.".format(end-start))
		
		    # 返回组装的训练数据
		    return buffer

    reprocess_tensor

          该函数的作用是： 处理数据，并将该批数据进行补齐，使序列长度保持一致

          输入参数：

		batch		:	从数据集中每批加载的数据
		cut_list	:	部分批数据列表

          输出参数：

		out		:	处理后的批输出

          代码详解：

		def reprocess_tensor(batch, cut_list):
		    # 获取部分批数据对应的音素序列
		    texts = [batch[ind]["text"] for ind in cut_list]
		    # 获取部分批数据对应的 mel 谱图
		    mel_targets = [batch[ind]["mel_target"] for ind in cut_list]
		    # 获取部分批数据对应的持续时间序列
		    durations = [batch[ind]["duration"] for ind in cut_list]
		
		    # 建立数组存储音素序列长度
		    length_text = np.array([])
		    for text in texts:
		        length_text = np.append(length_text, text.size(0))
		
		    # 以每批最长的序列为基准在末端补齐序列，并转换为 Tensor 数据
		    src_pos = list()
		    max_len = int(max(length_text))
		    for length_src_row in length_text:
		        src_pos.append(np.pad([i+1 for i in range(int(length_src_row))],
		                              (0, max_len-int(length_src_row)), 'constant'))
		    src_pos = torch.from_numpy(np.array(src_pos))
		
		    #  建立数组存储 mel 谱图长度
		    length_mel = np.array(list())
		    for mel in mel_targets:
		        length_mel = np.append(length_mel, mel.size(0))
		
		    # 以每批最长的谱图长度为基准在末端补齐，并转换为 Tensor 数据
		    mel_pos = list()
		    max_mel_len = int(max(length_mel))
		    for length_mel_row in length_mel:
		        mel_pos.append(np.pad([i+1 for i in range(int(length_mel_row))],
		                              (0, max_mel_len-int(length_mel_row)), 'constant'))
		    mel_pos = torch.from_numpy(np.array(mel_pos))
		
		    # 依次补齐音素序列、持续时间与梅尔谱图，并转换为 Tensor 数据
		    texts = pad_1D_tensor(texts)
		    durations = pad_1D_tensor(durations)
		    mel_targets = pad_2D_tensor(mel_targets)
		
		    # 将得到的数据组装为字典，作为输出结果返回
		    out = {"text": texts,
		           "mel_target": mel_targets,
		           "duration": durations,
		           "mel_pos": mel_pos,
		           "src_pos": src_pos,
		           "mel_max_len": max_mel_len}
		
		    return out

    collate_fn_tensor

          该函数的作用是： 处理从数据集中加载的数据，作为 DataLoader 的最终输出

          输入参数：

		batch		:	从数据集中每批加载的数据

          输出参数：

		output		:	最终DataLoader每批的输出

          代码详解：

		def collate_fn_tensor(batch):
		    # 使用数组为每段语音记录音素序列长度
		    len_arr = np.array([d["text"].size(0) for d in batch])
		    # 按从大到小的顺序记录音素序列长度排序
		    index_arr = np.argsort(-len_arr)
		    # 记录一整批数据的长度
		    batchsize = len(batch)
		    # 计算真正每批数据的长度
		    real_batchsize = batchsize // hparams.batch_expand_size
		
		    # 创建分割后的批数据列表
		    cut_list = list()
		    # 按真正批大小切分整批数据，添加至批数据列表
		    for i in range(hparams.batch_expand_size):
		        cut_list.append(index_arr[i*real_batchsize:(i+1)*real_batchsize])
		
		    # 创建输出列表
		    output = list()
		    # 为每一小批数据执行预处理，并添加至输出列表
		    for i in range(hparams.batch_expand_size):
		        output.append(reprocess_tensor(batch, cut_list[i]))
		
		    # 将输出列表返回
		    return output