218 lines
8.6 KiB
Python
218 lines
8.6 KiB
Python
import os
|
|
import os
|
|
import random
|
|
|
|
import torch
|
|
import torch.nn.functional as F
|
|
import torch.utils.data
|
|
import torchaudio
|
|
from munch import munchify
|
|
from tqdm import tqdm
|
|
from transformers import GPT2TokenizerFast
|
|
|
|
from data.audio.unsupervised_audio_dataset import load_audio, UnsupervisedAudioDataset
|
|
from data.text.hf_datasets_wrapper import HfDataset
|
|
from data.util import find_files_of_type, is_audio_file
|
|
from models.tacotron2.taco_utils import load_filepaths_and_text
|
|
from models.tacotron2.text import text_to_sequence
|
|
from utils.util import opt_get
|
|
|
|
|
|
def build_paired_voice_dataset(args):
|
|
from data.audio.paired_voice_audio_dataset import TextWavLoader as D
|
|
from models.tacotron2.hparams import create_hparams
|
|
default_params = create_hparams()
|
|
default_params.update(args)
|
|
dataset_opt = munchify(default_params)
|
|
return D(dataset_opt)
|
|
|
|
|
|
def clamp(x, minimum, maximum):
|
|
return max(minimum, min(x, maximum))
|
|
|
|
|
|
class GrandConjoinedDataset(torch.utils.data.Dataset):
|
|
"""
|
|
A joint text & speech dataset that joins three separate datasets into a single batch:
|
|
1. Unpaired text
|
|
2. Unpaired speech
|
|
3. Paired speech & text
|
|
|
|
Supports situations where the underlying data sources for these three elements are differently sized, e.g. you can
|
|
have a massive text corpus of 1B elements, a smaller unpaired speech corpus, and a small paired speech<->text corpus.
|
|
|
|
Performs tokenization at this level, ignoring any tokenization performed by upstream datasets.
|
|
"""
|
|
def __init__(self, opt):
|
|
sample_rate = 22050 # Fixed.
|
|
paired_dataset_args = opt['paired_dataset_args']
|
|
self.only_paired = opt_get(opt, ['only_paired'], False)
|
|
if not self.only_paired:
|
|
unsupervised_audio_args = opt['unsupervised_audio_args']
|
|
text_corpus_args = opt['text_corpus_args']
|
|
|
|
self.max_paired_audio_length = opt['max_paired_audio_length']
|
|
self.max_paired_text_length = opt['max_paired_text_length']
|
|
self.max_solo_audio_length = opt['max_solo_audio_length']
|
|
self.max_solo_text_length = opt['max_solo_text_length']
|
|
self.collate = opt_get(opt, ['needs_collate'], False)
|
|
self.sample_rate = sample_rate
|
|
|
|
# Set some sane arguments for all three datasets.
|
|
paired_dataset_args['needs_collate'] = self.collate
|
|
paired_dataset_args['load_conditioning'] = False
|
|
paired_dataset_args['sample_rate'] = sample_rate
|
|
paired_dataset_args['max_wav_length'] = self.max_paired_audio_length
|
|
paired_dataset_args['max_text_length'] = self.max_paired_text_length
|
|
self.speech_and_text = build_paired_voice_dataset(paired_dataset_args)
|
|
|
|
if not self.only_paired:
|
|
unsupervised_audio_args['sampling_rate'] = sample_rate
|
|
unsupervised_audio_args['do_augmentation'] = False
|
|
unsupervised_audio_args['resample_clip'] = False
|
|
if self.collate:
|
|
unsupervised_audio_args['pad_to_samples'] = self.max_solo_audio_length
|
|
self.speech = UnsupervisedAudioDataset(unsupervised_audio_args)
|
|
self.text = HfDataset(**text_corpus_args)
|
|
|
|
def fetch_text_at(self, i):
|
|
try:
|
|
txt = self.text[i % len(self.text)]['text']
|
|
assert '*' not in txt # This is a hack to get around the use of '*' to mask expletives in some text-only datasets. There really isn't a linguistic use for this character anyways.
|
|
tok = self.speech_and_text.get_text(txt)
|
|
padding_required = self.max_solo_text_length - tok.shape[0]
|
|
if padding_required < 0:
|
|
# Just truncate since there is no conditioning required.
|
|
tok = tok[:self.max_solo_text_length]
|
|
elif padding_required > 0:
|
|
tok = F.pad(tok, (0, padding_required))
|
|
return txt, tok
|
|
except:
|
|
# This is fully expected: there are a lot of text strings we intentionally do not
|
|
# handle (e.g. ones with emojis, or other languages). Just return another one.
|
|
return self.fetch_text_at((i+1) % len(self.text))
|
|
|
|
def fetch_snt_at(self, i):
|
|
fetched = self.speech_and_text[i % len(self.speech_and_text)]
|
|
if self.collate:
|
|
tseq, wav, path, text, cond = fetched
|
|
return {
|
|
'real_text': text,
|
|
'padded_text': tseq,
|
|
'text_lengths': torch.tensor(tseq.shape[0], dtype=torch.long),
|
|
'wav': wav,
|
|
'wav_lengths': torch.tensor(wav.shape[-1], dtype=torch.long),
|
|
'filenames': path
|
|
}
|
|
else:
|
|
return fetched
|
|
|
|
def __getitem__(self, i):
|
|
snt = self.fetch_snt_at(i)
|
|
if self.only_paired:
|
|
return {
|
|
'paired_audio': snt['wav'],
|
|
'paired_audio_lengths': snt['wav_lengths'],
|
|
'paired_text': snt['real_text'],
|
|
'paired_text_tokens': snt['padded_text'],
|
|
'paired_file': snt['filenames'],
|
|
'speech_audio': snt['wav'],
|
|
'speech_audio_lengths': snt['wav_lengths'],
|
|
'speech_file': snt['filenames'],
|
|
'text_text': snt['real_text'],
|
|
'text_tokens': snt['padded_text'],
|
|
}
|
|
else:
|
|
txt, txt_tok = self.fetch_text_at(i % len(self.text))
|
|
sp = self.speech[i % len(self.speech)]
|
|
# Set upper bound on solo speech lengths. This is handled automatically when collation is turned off, but needs to be done otherwise.
|
|
sp['clip'] = sp['clip'][:, :self.max_solo_audio_length]
|
|
sp['clip_lengths'] = clamp(sp['clip_lengths'], 0, self.max_solo_audio_length)
|
|
return {
|
|
'paired_audio': snt['wav'],
|
|
'paired_audio_lengths': snt['wav_lengths'],
|
|
'paired_text': snt['real_text'],
|
|
'paired_text_tokens': snt['padded_text'],
|
|
'paired_file': snt['filenames'],
|
|
'speech_audio': sp['clip'],
|
|
'speech_audio_lengths': sp['clip_lengths'],
|
|
'speech_file': sp['path'],
|
|
'text_text': txt,
|
|
'text_tokens': txt_tok,
|
|
}
|
|
|
|
def __len__(self):
|
|
if self.only_paired:
|
|
return len(self.speech_and_text)
|
|
else:
|
|
return max(len(self.speech), len(self.speech_and_text), len(self.text))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
batch_sz = 8
|
|
train_params = {
|
|
'mode': 'grand_conjoined_voice',
|
|
'phase': 'train',
|
|
'n_workers': 0,
|
|
'batch_size': batch_sz,
|
|
|
|
'max_paired_audio_length': 255995,
|
|
'max_paired_text_length': 200,
|
|
'max_solo_text_length': 330,
|
|
'max_solo_audio_length': 300000,
|
|
'needs_collate': True,
|
|
'paired_dataset_args': {
|
|
'path': ['Z:\\bigasr_dataset\\libritts\\test-clean_list.txt'],
|
|
'fetcher_mode': ['libritts'],
|
|
'use_bpe_tokenizer': False,
|
|
},
|
|
'unsupervised_audio_args': {
|
|
'path': ['Z:\\bigasr_dataset\\librispeech\\test_clean'],
|
|
'cache_path': 'test_cache_delete_me.pth',
|
|
},
|
|
'text_corpus_args': {
|
|
'corpi': [['bookcorpus', '']],
|
|
'cache_path': 'Z:\\huggingface_datasets\\cache',
|
|
},
|
|
}
|
|
val_params = {
|
|
'mode': 'grand_conjoined_voice',
|
|
'phase': 'val',
|
|
'n_workers': 0,
|
|
'batch_size': batch_sz,
|
|
|
|
'max_paired_audio_length': 255995,
|
|
'max_paired_text_length': 200,
|
|
'max_solo_text_length': 330,
|
|
'max_solo_audio_length': 300000,
|
|
'only_paired': True,
|
|
'needs_collate': True,
|
|
'paired_dataset_args': {
|
|
'path': ['Z:\\bigasr_dataset\\libritts\\test-clean_list.txt'],
|
|
'fetcher_mode': ['libritts'],
|
|
'use_bpe_tokenizer': False,
|
|
},
|
|
}
|
|
from data import create_dataset, create_dataloader
|
|
|
|
ds, c = create_dataset(train_params, return_collate=True)
|
|
dl = create_dataloader(ds, train_params, collate_fn=c)
|
|
|
|
def save(b, i, ib, key):
|
|
torchaudio.save(f'{i}_clip_{ib}_{key}.wav', b[key][ib], 22050)
|
|
|
|
def decode(b, ib, key):
|
|
return ds.speech_and_text.tokenizer.decode(b[key][ib].cpu().numpy())
|
|
|
|
i = 0
|
|
m = None
|
|
for i, b in tqdm(enumerate(dl)):
|
|
for ib in range(batch_sz):
|
|
#save(b, i, ib, 'paired_audio')
|
|
print(f'Paired text: {b["paired_text"][ib]}')
|
|
print(f'Paired text decoded: {decode(b, ib, "paired_text_tokens")}')
|
|
#save(b, i, ib, 'speech_audio')
|
|
print(f'Text: {b["text_text"][ib]}')
|
|
print(f'Text decoded: {decode(b, ib, "text_tokens")}')
|
|
|