| 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 |
| from module import commons |
|
|
|
|
|
|
| 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'] |
| phonemes = cleaned_text_to_sequence(phoneme.split(' ')) |
| phonemes = commons.intersperse(phonemes, 0) |
|
|
| spk_emb = row['spk_emb'] |
|
|
| quantization = np.array(row['codes'])[:,-1] |
| length = quantization.shape[0] |
|
|
|
|
| bert_path = dataname.replace('.wav', '.bert.pt') |
| phones_length = len(phonemes) |
| bert_feature = torch.load(bert_path) |
| bert_feature = F.interpolate(bert_feature.unsqueeze(0), scale_factor=2, mode='nearest') |
| bert_feature = F.pad(bert_feature, (0, 1), value=0).squeeze(0) |
| assert bert_feature.shape[-1] == phones_length |
|
|
| assert length == len(phonemes) |
| return quantization, phonemes, dataname, spk_emb, bert_feature, length |
|
|
| def seqCollate(self, batch): |
| output = { |
| 'phone': [], |
| 'length': [], |
| 'quantization': [], |
| 'spk_emb': [], |
| } |
| |
| max_len = 0 |
| for q_s, ph, _, spk_emb, bert,l in batch: |
| if l > max_len: |
| max_len = l |
| output['spk_emb'].append(spk_emb) |
|
|
| bert_padded = torch.FloatTensor(len(batch), 1024, max_len) |
| bert_padded.zero_() |
| |
| for idx, (q, phone, _, _, bert, l) in enumerate(batch): |
| phone = np.pad(phone, [0, max_len - len(phone)], constant_values=0) |
| q = np.pad(q, [0, max_len - len(q)], constant_values=0) |
| output['phone'].append(phone) |
| output['length'].append(l) |
| output['quantization'].append(q) |
| bert_padded[idx, :, :bert.shape[-1]] = bert |
|
|
| for k in output.keys(): |
| output[k] = np.array(output[k]) |
| if k in ['phone', 'length', 'quantization']: |
| output[k] = torch.LongTensor(output[k]) |
| elif k in ['spk_emb']: |
| output[k] = torch.FloatTensor(output[k]) |
| else: |
| raise ValueError(f"Unknown key {k}") |
| output['bert_feature'] = bert_padded |
| return output |
|
|
|
|
