def train(args, log_dir, hparams):
log('\n#############################################################\n')
log('Tacotron Train\n')
log('###########################################################\n')
checkpoint = tacotron_train(args, log_dir, hparams)
tf.reset_default_graph()
if checkpoint is None:
raise('Error occured while training Tacotron, Exiting!')
log('\n#############################################################\n')
log('Tacotron GTA Synthesis\n')
log('###########################################################\n')
input_path = tacotron_synthesize(args, hparams, checkpoint)
log('\n#############################################################\n')
log('Wavenet Train\n')
log('###########################################################\n')
wavenet_train(args, log_dir, hparams, input_path)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--base_dir', default='')
parser.add_argument('--hparams', default='',
help='Hyperparameter overrides as a comma-separated list of name=value pairs')
parser.add_argument('--tacotron_input', default='training_data/train.txt')
parser.add_argument('--wavenet_input', default='tacotron_output/gta/map.txt')
parser.add_argument('--name', help='Name of logging directory.')
parser.add_argument('--model', default='Tacotron-2')
parser.add_argument('--input_dir', default='training_data/', help='folder to contain inputs sentences/targets')
parser.add_argument('--output_dir', default='output/', help='folder to contain synthesized mel spectrograms')
parser.add_argument('--mode', default='synthesis', help='mode for synthesis of tacotron after training')
parser.add_argument('--GTA', default='True', help='Ground truth aligned synthesis, defaults to True, only considered in Tacotron synthesis mode')
parser.add_argument('--restore', type=bool, default=True, help='Set this to False to do a fresh training')
parser.add_argument('--summary_interval', type=int, default=250,
help='Steps between running summary ops')
parser.add_argument('--checkpoint_interval', type=int, default=5000,
help='Steps between writing checkpoints')
parser.add_argument('--eval_interval', type=int, default=10000,
help='Steps between eval on test data')
parser.add_argument('--tacotron_train_steps', type=int, default=160000, help='total number of tacotron training steps')
parser.add_argument('--wavenet_train_steps', type=int, default=360000, help='total number of wavenet training steps')
parser.add_argument('--tf_log_level', type=int, default=1, help='Tensorflow C++ log level.')
args = parser.parse_args()
accepted_models = ['Tacotron', 'WaveNet', 'Both', 'Tacotron-2']
if args.model not in accepted_models:
raise ValueError('please enter a valid model to train: {}'.format(accepted_models))
log_dir, hparams = prepare_run(args)
if args.model == 'Tacotron':
tacotron_train(args, log_dir, hparams)
elif args.model == 'WaveNet':
wavenet_train(args, log_dir, hparams, args.wavenet_input)
elif args.model in ('Both', 'Tacotron-2'):
train(args, log_dir, hparams)
else:
raise ValueError('Model provided {} unknown! {}'.format(args.model, accepted_models))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--base_dir', default='')
parser.add_argument(
'--hparams',
default='',
help=
'Hyperparameter overrides as a comma-separated list of name=value pairs'
)
parser.add_argument('--tacotron_input', default='training_data/train.txt')
parser.add_argument('--wavenet_input',
default='tacotron_output/gta/map.txt')
parser.add_argument('--name', help='Name of logging directory.')
parser.add_argument('--model', default='Tacotron')
parser.add_argument('--input_dir',
default='training_data',
help='folder to contain inputs sentences/targets')
parser.add_argument('--output_dir',
default='output',
help='folder to contain synthesized mel spectrograms')
parser.add_argument('--mode',
default='synthesis',
help='mode for synthesis of tacotron after training')
parser.add_argument(
'--GTA',
default='True',
help=
'Ground truth aligned synthesis, defaults to True, only considered in Tacotron synthesis mode'
)
parser.add_argument('--restore',
type=bool,
default=True,
help='Set this to False to do a fresh training')
parser.add_argument('--summary_interval',
type=int,
default=250,
help='Steps between running summary ops')
parser.add_argument(
'--embedding_interval',
type=int,
default=10000,
help='Steps between updating embeddings projection visualization')
parser.add_argument('--checkpoint_interval',
type=int,
default=1000,
help='Steps between writing checkpoints')
parser.add_argument('--eval_interval',
type=int,
default=1000,
help='Steps between eval on test data')
parser.add_argument('--tacotron_train_steps',
type=int,
default=150000,
help='total number of tacotron training steps')
parser.add_argument('--wavenet_train_steps',
type=int,
default=750000,
help='total number of wavenet training steps')
parser.add_argument('--tf_log_level',
type=int,
default=1,
help='Tensorflow C++ log level.')
parser.add_argument('--slack_url',
default=None,
help='slack webhook notification destination link')
args = parser.parse_args()
accepted_models = ['Tacotron', 'WaveNet', 'Tacotron-2']
if args.model not in accepted_models:
raise ValueError(
'please enter a valid model to train: {}'.format(accepted_models))
log_dir, hparams = prepare_run(args)
if args.model == 'Tacotron':
tacotron_train(args, log_dir, hparams)
elif args.model == 'WaveNet':
wavenet_train(args, log_dir, hparams, args.wavenet_input)
elif args.model == 'Tacotron-2':
train(args, log_dir, hparams)
else:
raise ValueError('Model provided {} unknown! {}'.format(
args.model, accepted_models))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--base_dir',
default='dataset/MultiSpeaker',
required=True)
parser.add_argument('--hparams',
default='',
help='Hyperparameter overrides from a json file')
parser.add_argument('--tacotron_input', default='training_data/train.txt')
parser.add_argument('--wavenet_input',
default='tacotron_output/gta/map.txt')
parser.add_argument('--name', help='Name of logging directory.')
parser.add_argument('--model', default='MultiSpeaker', required=True)
parser.add_argument('--input_dir',
default='training_data',
help='folder to contain inputs sentences/targets')
parser.add_argument('--output_dir',
default='output/',
help='folder to contain synthesized mel spectrograms')
parser.add_argument('--mode',
default='synthesis',
help='mode for synthesis of tacotron after training')
parser.add_argument(
'--GTA',
default='True',
help=
'Ground truth aligned synthesis, defaults to True, only considered in Tacotron synthesis mode'
)
parser.add_argument('--restore',
type=bool,
default=True,
help='Set this to False to do a fresh training')
parser.add_argument('--summary_interval',
type=int,
default=200,
help='Steps between running summary ops')
parser.add_argument('--checkpoint_interval',
type=int,
default=500,
help='Steps between writing checkpoints')
parser.add_argument('--eval_interval',
type=int,
default=200,
help='Steps between eval on test data')
parser.add_argument('--tacotron_train_steps',
type=int,
default=500000,
help='total number of tacotron training steps')
parser.add_argument('--wavenet_train_steps',
type=int,
default=360000,
help='total number of wavenet training steps')
parser.add_argument('--tf_log_level',
type=int,
default=2,
help='Tensorflow C++ log level.')
args = parser.parse_args()
accepted_models = [
'Tacotron', 'WaveNet', 'Both', 'Tacotron-2', 'MultiSpeaker'
]
if args.model not in accepted_models:
raise ValueError(
'please enter a valid model to train: {}'.format(accepted_models))
log_dir, hparams = prepare_run(args)
if args.model == 'Tacotron':
tacotron_train(args, log_dir, hparams)
elif args.model == 'WaveNet':
wavenet_train(args, log_dir, hparams, args.wavenet_input)
elif args.model == 'MultiSpeaker':
multispeaker_train(args, log_dir, hparams)
elif args.model in ('Both', 'Tacotron-2'):
train(args, log_dir, hparams)
else:
raise ValueError('Model provided {} unknown! {}'.format(
args.model, accepted_models))
parser.add_argument('--checkpoint_interval', type=int, default=500,
>>>>>>> f33090dba9ba4bc52db8367abdc48841d13c48f8
help='Steps between writing checkpoints')
parser.add_argument('--eval_interval', type=int, default=1000,
help='Steps between eval on test data')
parser.add_argument('--tacotron_train_steps', type=int, default=1000000, help='total number of tacotron training steps')
parser.add_argument('--wavenet_train_steps', type=int, default=750000, help='total number of wavenet training steps')
parser.add_argument('--tf_log_level', type=int, default=1, help='Tensorflow C++ log level.')
parser.add_argument('--slack_url', default=None, help='slack webhook notification destination link')
args = parser.parse_args()
accepted_models = ['Tacotron', 'WaveNet', 'Tacotron-2']
if args.model not in accepted_models:
raise ValueError('please enter a valid model to train: {}'.format(accepted_models))
log_dir, hparams = prepare_run(args)
if args.model == 'Tacotron':
tacotron_train(args, log_dir, hparams)
elif args.model == 'WaveNet':
wavenet_train(args, log_dir, hparams, args.wavenet_input)
elif args.model == 'Tacotron-2':
train(args, log_dir, hparams)
else:
raise ValueError('Model provided {} unknown! {}'.format(args.model, accepted_models))
if __name__ == '__main__':
main()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--base_dir', default=os.path.expanduser('~/tacotron'))
parser.add_argument('--log_dir', default=os.path.expanduser('~/tacotron'))
parser.add_argument('--tacotron_input', default='training/train.txt')
parser.add_argument('--wavenet_input',
default='tacotron_output/gta/map.txt')
parser.add_argument('--model', default='tacotron')
parser.add_argument('--variant', default='tacotron')
parser.add_argument(
'--name',
help='Name of the run. Used for logging. Defaults to model name.')
parser.add_argument(
'--hparams',
default='',
help=
'Hyperparameter overrides as a comma-separated list of name=value pairs'
)
parser.add_argument('--restore_step',
type=int,
help='Global step to restore from checkpoint.')
parser.add_argument('--summary_interval',
type=int,
default=100,
help='Steps between running summary ops.')
parser.add_argument('--checkpoint_interval',
type=int,
default=1000,
help='Steps between writing checkpoints.')
parser.add_argument('--slack_url',
help='Slack webhook URL to get periodic reports.')
parser.add_argument('--tf_log_level',
type=int,
default=1,
help='Tensorflow C++ log level.')
parser.add_argument('--git',
action='store_true',
help='If set, verify that the client is clean.')
parser.add_argument('--num_steps',
type=int,
default=100000,
help='Maximum number of steps to run training for.')
parser.add_argument(
'--wavenet_num_steps',
type=int,
default=500000,
help='Maximum number of steps to run wavenet training for')
parser.add_argument('--eal_dir', default='')
parser.add_argument('--eal_ckpt', default='')
parser.add_argument('--eal_ft',
default=False,
action='store_true',
help='load the weights, not Adam / BatchNorm history')
parser.add_argument('--eal_trainAlign',
default=False,
action='store_true',
help='train attention mechanism')
parser.add_argument('--eal_trainJoint',
default=False,
action='store_true',
help='train all weight in EAL mode with joint cost')
parser.add_argument('--eal_alignScale',
type=float,
default=1.0,
help='scaler for loss_align')
parser.add_argument('--eal_only_start',
type=int,
default=500000,
help='eal only from 500k iterations on')
args = parser.parse_args()
accepted_models = ['tacotron', 'wavenet']
if args.model not in accepted_models:
raise ValueError(
'please enter a valid model to train: {}'.format(accepted_models))
os.environ['TF_CPP_MIN_LOG_LEVEL'] = str(args.tf_log_level)
run_name = args.name or args.variant
log_dir = os.path.join(args.log_dir, 'logs-%s' % run_name)
os.makedirs(log_dir, exist_ok=True)
infolog.init(os.path.join(log_dir, 'train.log'), run_name, args.slack_url)
log('Initialised log file')
hparams.parse(args.hparams)
if args.model == 'tacotron':
# if args.eal_dir=='online':
# train_tacotron_online(log_dir, args, args.tacotron_input)
# else:
# train_tacotron(log_dir, args, args.tacotron_input)
train_tacotron_online(log_dir, args, args.tacotron_input)
elif args.model == 'wavenet':
wavenet_train(log_dir, args, hparams, args.wavenet_input)
else:
raise ValueError('Model provided {} unknown! {}'.format(
args.model, accepted_models))
def train(args, log_dir, hparams):
state_file = os.path.join(log_dir, 'state_log')
#Get training states
(taco_state, GTA_state, wave_state), input_path = read_seq(state_file)
if not taco_state:
print(
'\n#############################################################\n'
)
log('\n#############################################################\n'
)
print('Tacotron Train\n')
log('Tacotron Train\n')
print('###########################################################\n')
log('###########################################################\n')
checkpoint = tacotron_train(args, log_dir, hparams)
tf.reset_default_graph()
#Sleep 1/2 second to let previous graph close and avoid error messages while synthesis
sleep(0.5)
if checkpoint is None:
raise ('Error occured while training Tacotron, Exiting!')
taco_state = 1
save_seq(state_file, [taco_state, GTA_state, wave_state], input_path)
else:
checkpoint = os.path.join(log_dir, 'taco_pretrained/')
if not GTA_state:
print(
'\n#############################################################\n'
)
log('\n#############################################################\n'
)
print('Tacotron GTA Synthesis\n')
log('Tacotron GTA Synthesis\n')
print('###########################################################\n')
log('###########################################################\n')
input_path = tacotron_synthesize(args, hparams, checkpoint)
tf.reset_default_graph()
#Sleep 1/2 second to let previous graph close and avoid error messages while Wavenet is training
sleep(0.5)
GTA_state = 1
save_seq(state_file, [taco_state, GTA_state, wave_state], input_path)
else:
input_path = os.path.join('tacotron_' + args.output_dir, 'gta',
'map.txt')
if input_path == '' or input_path is None:
raise RuntimeError(
'input_path has an unpleasant value -> {}'.format(input_path))
if not wave_state:
print(
'\n#############################################################\n'
)
log('\n#############################################################\n'
)
print('Wavenet Train\n')
log('Wavenet Train\n')
print('###########################################################\n')
log('###########################################################\n')
checkpoint = wavenet_train(args, log_dir, hparams, input_path)
if checkpoint is None:
raise ('Error occured while training Wavenet, Exiting!')
wave_state = 1
save_seq(state_file, [taco_state, GTA_state, wave_state], input_path)
if wave_state and GTA_state and taco_state:
print('TRAINING IS ALREADY COMPLETE!!')
log('TRAINING IS ALREADY COMPLETE!!')
