Spaces:
Running
Running
| import torch | |
| from torch.utils.data import Dataset | |
| import numpy as np | |
| from pathlib import Path | |
| from synthesizer.utils.text import text_to_sequence | |
| class SynthesizerDataset(Dataset): | |
| def __init__(self, metadata_fpath: Path, mel_dir: Path, embed_dir: Path, hparams): | |
| print("Using inputs from:\n\t%s\n\t%s\n\t%s" % (metadata_fpath, mel_dir, embed_dir)) | |
| with metadata_fpath.open("r") as metadata_file: | |
| metadata = [line.split("|") for line in metadata_file] | |
| mel_fnames = [x[1] for x in metadata if int(x[4])] | |
| mel_fpaths = [mel_dir.joinpath(fname) for fname in mel_fnames] | |
| embed_fnames = [x[2] for x in metadata if int(x[4])] | |
| embed_fpaths = [embed_dir.joinpath(fname) for fname in embed_fnames] | |
| self.samples_fpaths = list(zip(mel_fpaths, embed_fpaths)) | |
| self.samples_texts = [x[5].strip() for x in metadata if int(x[4])] | |
| self.metadata = metadata | |
| self.hparams = hparams | |
| print("Found %d samples" % len(self.samples_fpaths)) | |
| def __getitem__(self, index): | |
| # Sometimes index may be a list of 2 (not sure why this happens) | |
| # If that is the case, return a single item corresponding to first element in index | |
| if index is list: | |
| index = index[0] | |
| mel_path, embed_path = self.samples_fpaths[index] | |
| mel = np.load(mel_path).T.astype(np.float32) | |
| # Load the embed | |
| embed = np.load(embed_path) | |
| # Get the text and clean it | |
| text = text_to_sequence(self.samples_texts[index], self.hparams.tts_cleaner_names) | |
| # Convert the list returned by text_to_sequence to a numpy array | |
| text = np.asarray(text).astype(np.int32) | |
| return text, mel.astype(np.float32), embed.astype(np.float32), index | |
| def __len__(self): | |
| return len(self.samples_fpaths) | |
| def collate_synthesizer(batch, r, hparams): | |
| # Text | |
| x_lens = [len(x[0]) for x in batch] | |
| max_x_len = max(x_lens) | |
| chars = [pad1d(x[0], max_x_len) for x in batch] | |
| chars = np.stack(chars) | |
| # Mel spectrogram | |
| spec_lens = [x[1].shape[-1] for x in batch] | |
| max_spec_len = max(spec_lens) + 1 | |
| if max_spec_len % r != 0: | |
| max_spec_len += r - max_spec_len % r | |
| # WaveRNN mel spectrograms are normalized to [0, 1] so zero padding adds silence | |
| # By default, SV2TTS uses symmetric mels, where -1*max_abs_value is silence. | |
| if hparams.symmetric_mels: | |
| mel_pad_value = -1 * hparams.max_abs_value | |
| else: | |
| mel_pad_value = 0 | |
| mel = [pad2d(x[1], max_spec_len, pad_value=mel_pad_value) for x in batch] | |
| mel = np.stack(mel) | |
| # Speaker embedding (SV2TTS) | |
| embeds = np.array([x[2] for x in batch]) | |
| # Index (for vocoder preprocessing) | |
| indices = [x[3] for x in batch] | |
| # Convert all to tensor | |
| chars = torch.tensor(chars).long() | |
| mel = torch.tensor(mel) | |
| embeds = torch.tensor(embeds) | |
| return chars, mel, embeds, indices | |
| def pad1d(x, max_len, pad_value=0): | |
| return np.pad(x, (0, max_len - len(x)), mode="constant", constant_values=pad_value) | |
| def pad2d(x, max_len, pad_value=0): | |
| return np.pad(x, ((0, 0), (0, max_len - x.shape[-1])), mode="constant", constant_values=pad_value) | |