Spaces:
Sleeping
Sleeping
File size: 4,448 Bytes
4ee33aa |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 |
import os
import random
import torch
import torch.nn.functional as F
import torch.utils.data
from torch import LongTensor
from tqdm import tqdm
import torchaudio
from pypinyin import Style, lazy_pinyin
from ttts.gpt.voice_tokenizer import VoiceBpeTokenizer
import json
import os
def read_jsonl(path):
with open(path, 'r') as f:
json_str = f.read()
data_list = []
for line in json_str.splitlines():
data = json.loads(line)
data_list.append(data)
return data_list
def write_jsonl(path, all_paths):
with open(path,'w', encoding='utf-8') as file:
for item in all_paths:
json.dump(item, file, ensure_ascii=False)
file.write('\n')
class GptTtsDataset(torch.utils.data.Dataset):
def __init__(self, opt):
self.tok = VoiceBpeTokenizer('ttts/gpt/gpt_tts_tokenizer.json')
self.jsonl_path = opt['dataset']['path']
self.audiopaths_and_text = read_jsonl(self.jsonl_path)
def __getitem__(self, index):
try:
# Fetch text and add start/stop tokens.
audiopath_and_text = self.audiopaths_and_text[index]
audiopath, text = audiopath_and_text['path'], audiopath_and_text['text']
text = ' '.join(lazy_pinyin(text, style=Style.TONE3, neutral_tone_with_five=True))
text = self.tok.encode(text)
text = LongTensor(text)
# Fetch quantized MELs
quant_path = audiopath + '.melvq.pth'
qmel = LongTensor(torch.load(quant_path)[0])
mel_path = audiopath + '.mel.pth'
mel = torch.load(mel_path)[0]
wav_length = mel.shape[1]*256
split = random.randint(int(mel.shape[1]//3), int(mel.shape[1]//3*2))
if random.random()>0.5:
mel = mel[:,:split]
else:
mel = mel[:,split:]
except:
return None
#load wav
# wav,sr = torchaudio.load(audiopath)
# wav = torchaudio.transforms.Resample(sr,24000)(wav)
if text.shape[0]>400 or qmel.shape[0]>600:
return None
return text, qmel, mel, wav_length
def __len__(self):
return len(self.audiopaths_and_text)
class GptTtsCollater():
def __init__(self,cfg):
self.cfg=cfg
def __call__(self, batch):
batch = [x for x in batch if x is not None]
if len(batch)==0:
return None
text_lens = [len(x[0]) for x in batch]
max_text_len = max(text_lens)
# max_text_len = self.cfg['gpt']['max_text_tokens']
qmel_lens = [len(x[1]) for x in batch]
max_qmel_len = max(qmel_lens)
# max_qmel_len = self.cfg['gpt']['max_mel_tokens']
raw_mel_lens = [x[2].shape[1] for x in batch]
max_raw_mel_len = max(raw_mel_lens)
wav_lens = [x[3] for x in batch]
max_wav_len = max(wav_lens)
texts = []
qmels = []
raw_mels = []
wavs = []
# This is the sequential "background" tokens that are used as padding for text tokens, as specified in the DALLE paper.
for b in batch:
text, qmel, raw_mel, wav = b
text = F.pad(text, (0, max_text_len-len(text)), value=0)
texts.append(text)
qmels.append(F.pad(qmel, (0, max_qmel_len-len(qmel)), value=0))
raw_mels.append(F.pad(raw_mel,(0, max_raw_mel_len-raw_mel.shape[1]), value=0))
padded_qmel = torch.stack(qmels)
padded_raw_mel = torch.stack(raw_mels)
padded_texts = torch.stack(texts)
return {
'padded_text': padded_texts,
'text_lengths': LongTensor(text_lens),
'padded_qmel': padded_qmel,
'qmel_lengths': LongTensor(qmel_lens),
'padded_raw_mel': padded_raw_mel,
'raw_mel_lengths': LongTensor(raw_mel_lens),
'wav_lens': LongTensor(wav_lens)
}
if __name__ == '__main__':
params = {
'mode': 'gpt_tts',
'path': 'E:\\audio\\LJSpeech-1.1\\ljs_audio_text_train_filelist.txt',
'phase': 'train',
'n_workers': 0,
'batch_size': 16,
'mel_vocab_size': 512,
}
cfg = json.load(open('ttts/gpt/config.json'))
ds = GptTtsDataset(cfg)
dl = torch.utils.data.DataLoader(ds, **cfg['dataloader'], collate_fn=GptTtsCollater(cfg))
i = 0
m = []
max_text = 0
max_mel = 0
for b in tqdm(dl):
break
|