def __init__(self, hp_path, steps=0):
self.hp_Path = hp_path
self.gpu_id = int(os.getenv('RANK', '0'))
self.num_gpus = int(os.getenv("WORLD_SIZE", '1'))
self.hp = Recursive_Parse(
yaml.load(open(self.hp_Path, encoding='utf-8'),
Loader=yaml.Loader))
if not torch.cuda.is_available():
self.device = torch.device('cpu')
else:
self.device = torch.device('cuda:{}'.format(self.gpu_id))
torch.backends.cudnn.enabled = True
torch.backends.cudnn.benchmark = True
torch.cuda.set_device(self.gpu_id)
self.steps = steps
self.Datset_Generate()
self.Model_Generate()
self.Load_Checkpoint()
self._Set_Distribution()
self.scalar_dict = {
'Train': defaultdict(float),
'Evaluation': defaultdict(float),
}
self.writer_Dict = {
'Train': Logger(os.path.join(self.hp.Log_Path, 'Train')),
'Evaluation': Logger(os.path.join(self.hp.Log_Path, 'Evaluation')),
}
def __init__(self, hp_path: str, checkpoint_path: str):
super().__init__()
self.hp = Recursive_Parse(
yaml.load(open(hp_path, encoding='utf-8'), Loader=yaml.Loader))
self.model = GE2E(self.hp)
self.Load_Checkpoint(path=checkpoint_path)
self.model.eval()
for param in self.model.parameters():
param.requires_grad = False
matplotlib.use('agg')
import matplotlib.pyplot as plt
from scipy.io import wavfile
from random import sample
from Logger import Logger
from Modules import GlowTTS, MLE_Loss
from Datasets import Dataset, Inference_Dataset, Prosody_Check_Dataset, Collater, Inference_Collater, Prosody_Check_Collater
from Noam_Scheduler import Modified_Noam_Scheduler
from Radam import RAdam
from Speaker_Embedding.Modules import Encoder as Speaker_Embedding, Normalize
from Arg_Parser import Recursive_Parse
hp = Recursive_Parse(
yaml.load(open('Hyper_Parameters.yaml', encoding='utf-8'),
Loader=yaml.Loader))
if not hp.Device is None:
os.environ['CUDA_VISIBLE_DEVICES'] = hp.Device
if not torch.cuda.is_available():
device = torch.device('cpu')
else:
device = torch.device('cuda:0')
torch.backends.cudnn.benchmark = True
torch.cuda.set_device(0)
logging.basicConfig(
level=logging.INFO,
stream=sys.stdout,
except KeyboardInterrupt:
self.Save_Checkpoint()
exit(1)
self.tqdm.close()
logging.info('Finished training.')
if __name__ == '__main__':
argParser = argparse.ArgumentParser()
argParser.add_argument('-hp',
'--hyper_parameters',
required=True,
type=str)
argParser.add_argument('-s', '--steps', default=0, type=int)
argParser.add_argument('-p', '--port', default=54321, type=int)
argParser.add_argument('-r', '--local_rank', default=0, type=int)
args = argParser.parse_args()
hp = Recursive_Parse(
yaml.load(open(args.hyper_parameters, encoding='utf-8'),
Loader=yaml.Loader))
os.environ['CUDA_VISIBLE_DEVICES'] = hp.Device
if hp.Use_Multi_GPU:
init_distributed(rank=int(os.getenv('RANK', '0')),
num_gpus=int(os.getenv("WORLD_SIZE", '1')),
dist_backend='nccl',
dist_url='tcp://127.0.0.1:{}'.format(args.port))
new_Trainer = Trainer(hp_path=args.hyper_parameters, steps=args.steps)
new_Trainer.Train()
import torch
import numpy as np
import yaml, logging, math
from RPR_MHA import RPR_Multihead_Attention
from Gradient_Reversal_Layer import GRL
from Speaker_Embedding.Modules import Encoder as GE2E, Normalize as GE2E_Normalize
from Arg_Parser import Recursive_Parse
hp = Recursive_Parse(
yaml.load(open('Hyper_Parameters.yaml', encoding='utf-8'),
Loader=yaml.Loader))
class GlowTTS(torch.nn.Module):
def __init__(self):
super(GlowTTS, self).__init__()
self.layer_Dict = torch.nn.ModuleDict()
if hp.Mode.upper() in ['SE', 'GR']:
if hp.Speaker_Embedding.Type.upper() == 'LUT':
self.layer_Dict['LUT'] = torch.nn.Embedding(
num_embeddings=hp.Speaker_Embedding.Num_Speakers,
embedding_dim=hp.Speaker_Embedding.Embedding_Size,
)
torch.nn.init.uniform_(self.layer_Dict['LUT'].weight, -1.0,
1.0)
elif hp.Speaker_Embedding.Type.upper() == 'GE2E':
self.layer_Dict['GE2E'] = GE2E(
mel_dims=hp.Sound.Mel_Dim,
