def Datset_Generate(self):
train_Dataset = Train_Dataset()
dev_Dataset = Dev_Dataset()
logging.info('The number of train files = {}.'.format(
len(train_Dataset)))
logging.info('The number of development files = {}.'.format(
len(dev_Dataset)))
train_Collater = Train_Collater()
dev_Collater = Dev_Collater()
inference_Collater = Inference_Collater()
self.dataLoader_Dict = {}
self.dataLoader_Dict['Train'] = torch.utils.data.DataLoader(
dataset=train_Dataset,
shuffle=True,
collate_fn=train_Collater,
batch_size=hp_Dict['Train']['Batch']['Train']['Speaker'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
self.dataLoader_Dict['Dev'] = torch.utils.data.DataLoader(
dataset=dev_Dataset,
shuffle=True,
collate_fn=dev_Collater,
batch_size=hp_Dict['Train']['Batch']['Eval']['Speaker'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
self.dataLoader_Dict['Inference'] = torch.utils.data.DataLoader(
dataset=dev_Dataset,
shuffle=True,
collate_fn=inference_Collater,
batch_size=hp_Dict['Train']['Batch']['Eval']['Speaker'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
def Datset_Generate(self):
token_dict = yaml.load(open(self.hp.Token_Path), Loader=yaml.Loader)
train_dataset = Dataset(
token_dict=token_dict,
pattern_path=self.hp.Train.Train_Pattern.Path,
metadata_file=self.hp.Train.Train_Pattern.Metadata_File)
dev_dataset = Dataset(
token_dict=token_dict,
pattern_path=self.hp.Train.Eval_Pattern.Path,
metadata_file=self.hp.Train.Eval_Pattern.Metadata_File)
inference_dataset = Inference_Dataset(
token_dict=token_dict,
pattern_paths=self.hp.Train.Inference_Pattern_in_Train)
if self.gpu_id == 0:
logging.info('The number of train patterns = {}.'.format(
len(train_dataset)))
logging.info('The number of development patterns = {}.'.format(
len(dev_dataset)))
logging.info('The number of inference patterns = {}.'.format(
len(inference_dataset)))
collater = Collater(token_dict=token_dict)
inference_collater = Inference_Collater(token_dict=token_dict)
self.dataloader_dict = {}
self.dataloader_dict['Train'] = torch.utils.data.DataLoader(
dataset= train_dataset,
sampler= torch.utils.data.DistributedSampler(train_dataset, shuffle= True) \
if self.hp.Use_Multi_GPU else \
torch.utils.data.RandomSampler(train_dataset),
collate_fn= collater,
batch_size= self.hp.Train.Batch_Size,
num_workers= self.hp.Train.Num_Workers,
pin_memory= True
)
self.dataloader_dict['Dev'] = torch.utils.data.DataLoader(
dataset= dev_dataset,
sampler= torch.utils.data.DistributedSampler(dev_dataset, shuffle= True) \
if self.num_gpus > 1 else \
torch.utils.data.RandomSampler(dev_dataset),
collate_fn= collater,
batch_size= self.hp.Train.Batch_Size,
num_workers= self.hp.Train.Num_Workers,
pin_memory= True
)
self.dataloader_dict['Inference'] = torch.utils.data.DataLoader(
dataset=inference_dataset,
sampler=torch.utils.data.SequentialSampler(inference_dataset),
collate_fn=inference_collater,
batch_size=self.hp.Inference_Batch_Size
or self.hp.Train.Batch_Size,
num_workers=self.hp.Train.Num_Workers,
pin_memory=True)
def Dataset_Generate(self):
train_dataset = Dataset(
pattern_path=self.hp.Train.Train_Pattern.Path,
metadata_file=self.hp.Train.Train_Pattern.Metadata_File,
pattern_per_speaker=self.hp.Train.Batch.Train.Pattern_per_Speaker)
dev_dataset = Dataset(
pattern_path=self.hp.Train.Eval_Pattern.Path,
metadata_file=self.hp.Train.Eval_Pattern.Metadata_File,
pattern_per_speaker=self.hp.Train.Batch.Eval.Pattern_per_Speaker)
inference_dataset = Dataset(
pattern_path=self.hp.Train.Eval_Pattern.Path,
metadata_file=self.hp.Train.Eval_Pattern.Metadata_File,
pattern_per_speaker=self.hp.Train.Batch.Eval.Pattern_per_Speaker,
num_speakers=50, #Maximum number by tensorboard.
)
logging.info('The number of train speakers = {}.'.format(
len(train_dataset)))
logging.info('The number of development speakers = {}.'.format(
len(dev_dataset)))
collater = Collater(min_frame_length=self.hp.Train.Frame_Length.Min,
max_frame_length=self.hp.Train.Frame_Length.Max)
inference_collater = Inference_Collater(
samples=self.hp.Train.Inference.Samples,
frame_length=self.hp.Train.Inference.Frame_Length,
overlap_length=self.hp.Train.Inference.Overlap_Length)
self.dataloader_dict = {}
self.dataloader_dict['Train'] = torch.utils.data.DataLoader(
dataset= train_dataset,
sampler= torch.utils.data.DistributedSampler(train_dataset, shuffle= True) \
if self.hp.Use_Multi_GPU else \
torch.utils.data.RandomSampler(train_dataset),
collate_fn= collater,
batch_size= self.hp.Train.Batch.Train.Speaker,
num_workers= self.hp.Train.Num_Workers,
pin_memory= True
)
self.dataloader_dict['Dev'] = torch.utils.data.DataLoader(
dataset= dev_dataset,
sampler= torch.utils.data.DistributedSampler(dev_dataset, shuffle= True) \
if self.num_gpus > 1 else \
torch.utils.data.RandomSampler(dev_dataset),
collate_fn= collater,
batch_size= self.hp.Train.Batch.Eval.Speaker,
num_workers= self.hp.Train.Num_Workers,
pin_memory= True
)
self.dataloader_dict['Inference'] = torch.utils.data.DataLoader(
dataset=inference_dataset,
shuffle=True,
collate_fn=inference_collater,
batch_size=self.hp.Train.Batch.Eval.Speaker,
num_workers=self.hp.Train.Num_Workers,
pin_memory=True)
def Datset_Generate(self, paths, labels):
self.dataLoader = torch.utils.data.DataLoader(
dataset= Dataset(paths, labels),
shuffle= False,
collate_fn= Inference_Collater(
samples= hp.Train.Inference.Samples,
frame_length= hp.Train.Inference.Frame_Length,
overlap_length= hp.Train.Inference.Overlap_Length
),
batch_size= hp.Train.Batch.Eval.Speaker,
num_workers= hp.Train.Num_Workers,
pin_memory= True
)
def Datset_Generate(self):
train_Dataset = Train_Dataset()
accumulation_Dataset = Accumulation_Dataset()
dev_Dataset = Dev_Dataset()
inference_Dataset = Inference_Dataset()
logging.info('The number of base train files = {}.'.format(
len(train_Dataset) //
hp_Dict['Train']['Train_Pattern']['Accumulated_Dataset_Epoch']))
logging.info('The number of development patterns = {}.'.format(
len(dev_Dataset)))
logging.info('The number of inference patterns = {}.'.format(
len(inference_Dataset)))
collater = Collater()
accumulation_Collater = Accumulation_Collater()
inference_Collater = Inference_Collater()
self.dataLoader_Dict = {}
self.dataLoader_Dict['Train'] = torch.utils.data.DataLoader(
dataset=train_Dataset,
shuffle=True,
collate_fn=collater,
batch_size=hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
self.dataLoader_Dict['Accumulation'] = torch.utils.data.DataLoader(
dataset=accumulation_Dataset,
shuffle=False,
collate_fn=accumulation_Collater,
batch_size=hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
self.dataLoader_Dict['Dev'] = torch.utils.data.DataLoader(
dataset=dev_Dataset,
shuffle=True, # to write tensorboard.
collate_fn=collater,
batch_size=hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
self.dataLoader_Dict['Inference'] = torch.utils.data.DataLoader(
dataset=inference_Dataset,
shuffle=False, # to write tensorboard.
collate_fn=inference_Collater,
batch_size=hp_Dict['Inference_Batch_Size']
or hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
def Datset_Generate(self):
train_Dataset = Train_Dataset(is_Eval=False)
dev_Dataset = Train_Dataset(is_Eval=True)
inference_Dataset = Inference_Dataset()
logging.info('The number of train patterns = {}.'.format(
len(train_Dataset)))
logging.info('The number of development patterns = {}.'.format(
len(dev_Dataset)))
logging.info('The number of inference patterns = {}.'.format(
len(inference_Dataset)))
try:
upsample_Pad = hp_Dict['Generator']['Upsample']['Pad']
except:
upsample_Pad = 0
collater = Train_Collater(upsample_Pad=upsample_Pad)
inference_Collater = Inference_Collater(upsample_Pad=upsample_Pad)
self.dataLoader_Dict = {}
self.dataLoader_Dict['Train'] = torch.utils.data.DataLoader(
dataset=train_Dataset,
shuffle=True,
collate_fn=collater,
batch_size=hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
self.dataLoader_Dict['Dev'] = torch.utils.data.DataLoader(
dataset=dev_Dataset,
shuffle=False,
collate_fn=collater,
batch_size=hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
self.dataLoader_Dict['Inference'] = torch.utils.data.DataLoader(
dataset=inference_Dataset,
shuffle=False,
collate_fn=inference_Collater,
batch_size=hp_Dict['Inference_Batch_Size']
or hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
def Inference(self, mel_Path, result_Path='./results'):
logging.info('Mel-spectrogram path: {}'.format(mel_Path))
logging.info('Result save path: {}'.format(result_Path))
logging.info('Start inference.')
os.makedirs(result_Path, exist_ok=True)
dataLoader = torch.utils.data.DataLoader(
dataset=InferenceDataset(mel_path=mel_Path),
shuffle=False,
collate_fn=Inference_Collater(
frame_Shift=hp_Dict['Sound']['Frame_Shift'],
upsample_Pad=hp_Dict['WaveNet']['Upsample']['Pad'],
max_Abs_Mel=hp_Dict['Sound']['Max_Abs_Mel']),
batch_size=hp_Dict['Train']['Batch_Size'],
num_workers=hp_Dict['Train']['Num_Workers'],
pin_memory=True)
for files, mels, noises in tqdm(dataLoader, desc='[Inference]'):
self.Inference_Step(files, mels, noises, result_Path)
def Datset_Generate(self):
train_Dataset = Dataset(
pattern_path=hp.Train.Train_Pattern.Path,
metadata_file=hp.Train.Train_Pattern.Metadata_File,
accumulated_dataset_epoch=hp.Train.Train_Pattern.
Accumulated_Dataset_Epoch,
mel_length_min=hp.Train.Train_Pattern.Mel_Length.Min,
mel_length_max=hp.Train.Train_Pattern.Mel_Length.Max,
text_length_min=hp.Train.Train_Pattern.Text_Length.Min,
text_length_max=hp.Train.Train_Pattern.Text_Length.Max,
use_cache=hp.Train.Use_Pattern_Cache)
dev_Dataset = Dataset(
pattern_path=hp.Train.Eval_Pattern.Path,
metadata_file=hp.Train.Eval_Pattern.Metadata_File,
mel_length_min=hp.Train.Eval_Pattern.Mel_Length.Min,
mel_length_max=hp.Train.Eval_Pattern.Mel_Length.Max,
text_length_min=hp.Train.Eval_Pattern.Text_Length.Min,
text_length_max=hp.Train.Eval_Pattern.Text_Length.Max,
use_cache=hp.Train.Use_Pattern_Cache)
inference_Dataset = Inference_Dataset(
pattern_path=hp.Train.Inference_Pattern_File_in_Train)
logging.info('The number of train patterns = {}.'.format(
len(train_Dataset) //
hp.Train.Train_Pattern.Accumulated_Dataset_Epoch))
logging.info('The number of development patterns = {}.'.format(
len(dev_Dataset)))
logging.info('The number of inference patterns = {}.'.format(
len(inference_Dataset)))
collater = Collater()
inference_Collater = Inference_Collater()
self.dataLoader_Dict = {}
self.dataLoader_Dict['Train'] = torch.utils.data.DataLoader(
dataset=train_Dataset,
shuffle=True,
collate_fn=collater,
batch_size=hp.Train.Batch_Size,
num_workers=hp.Train.Num_Workers,
pin_memory=True)
self.dataLoader_Dict['Dev'] = torch.utils.data.DataLoader(
dataset=dev_Dataset,
shuffle=True,
collate_fn=collater,
batch_size=hp.Train.Batch_Size,
num_workers=hp.Train.Num_Workers,
pin_memory=True)
self.dataLoader_Dict['Inference'] = torch.utils.data.DataLoader(
dataset=inference_Dataset,
shuffle=False,
collate_fn=inference_Collater,
batch_size=hp.Inference_Batch_Size or hp.Train.Batch_Size,
num_workers=hp.Train.Num_Workers,
pin_memory=True)
if hp.Mode in ['PE', 'GR']:
self.dataLoader_Dict[
'Prosody_Check'] = torch.utils.data.DataLoader(
dataset=Prosody_Check_Dataset(
pattern_path=hp.Train.Train_Pattern.Path,
metadata_file=hp.Train.Train_Pattern.Metadata_File,
mel_length_min=hp.Train.Train_Pattern.Mel_Length.Min,
mel_length_max=hp.Train.Train_Pattern.Mel_Length.Max,
use_cache=hp.Train.Use_Pattern_Cache),
shuffle=False,
collate_fn=Prosody_Check_Collater(),
batch_size=hp.Train.Batch_Size,
num_workers=hp.Train.Num_Workers,
pin_memory=True)