| import os |
| from torch.utils import data |
| import torch |
| import numpy as np |
| import random |
|
|
| import torch.nn.functional as F |
|
|
| from text import cleaned_text_to_sequence |
|
|
|
|
|
|
| class QuantizeDataset(data.Dataset): |
| def __init__(self, hp, dataset): |
| self.hp = hp |
| self.dataset = dataset |
| l = len(self.dataset) |
| print(f'Total {l} examples') |
| self.lengths = dataset['length'] |
| avglen = sum(self.lengths) / len(self.lengths) |
| maxlen = max(self.lengths) |
| minlen = min(self.lengths) |
| print( |
| f"Average phoneme length of audio: {avglen}, Maximum phoneme length: {maxlen}, Minimum phoneme length: {minlen}") |
|
|
| def __len__(self): |
| return len(self.dataset) |
|
|
| def __getitem__(self, i): |
| i = int(i) |
| row = self.dataset[i] |
| dataname = row['item_name'] |
| phoneme = row['phoneme'] |
| phoneme_ids = cleaned_text_to_sequence(phoneme.split(' ')) |
|
|
|
|
| phonemes = [0] * (len(phoneme_ids) * 3) |
| phonemes[1::3] = phoneme_ids |
| |
|
|
|
|
| spk_emb = row['spk_emb'] |
|
|
| latent_path = dataname.replace('.wav', '.latent.pt') |
| latent = torch.load(latent_path, map_location='cpu').squeeze(0) |
|
|
| length = latent.shape[-1] |
|
|
|
|
| bert_path = dataname.replace('.wav', '.bert.pt') |
| phones_length = len(phonemes) |
| bert_feature = torch.load(bert_path, map_location='cpu') |
| bert_feature = F.interpolate(bert_feature.unsqueeze(0), scale_factor=3, mode='nearest') |
| assert bert_feature.shape[-1] == phones_length |
|
|
| assert length == len(phonemes) |
| return latent, phonemes, dataname, spk_emb, bert_feature, length |
|
|
| def seqCollate(self, batch): |
| |
| max_len = 0 |
| for _, _, _, spk_emb, bert,l in batch: |
| if l > max_len: |
| max_len = l |
|
|
| bert_padded = torch.FloatTensor(len(batch), 1024, max_len) |
| latent_padded = torch.FloatTensor(len(batch), 4, max_len) |
| phone_padded = torch.LongTensor(len(batch), max_len) |
| length_padded = torch.LongTensor(len(batch)) |
| spk_emb_padded = torch.FloatTensor(len(batch), 256) |
|
|
|
|
| bert_padded.zero_() |
| latent_padded.zero_() |
| phone_padded.zero_() |
| length_padded.zero_() |
| spk_emb_padded.zero_() |
|
|
| |
| |
| for idx, (latent, phone, _, spk_emb, bert, l) in enumerate(batch): |
| phone_padded[idx, :l] = torch.LongTensor(phone) |
| length_padded[idx] = l |
| spk_emb_padded[idx] = torch.FloatTensor(spk_emb) |
|
|
| bert_padded[idx, :, :bert.shape[-1]] = bert |
| latent_padded[idx, :, :latent.shape[-1]] = latent |
|
|
| return { |
| 'phone': phone_padded, |
| 'length': length_padded, |
| 'spk_emb': spk_emb_padded, |
| 'bert_feature': bert_padded, |
| 'latent': latent_padded |
| } |
|
|
|
|
