def get_hparams(hparams):
return namedtuple('hparams', hparams.keys())(*hparams.values())
rank_id = 0
group_size = 1
speaker_id = int(args.speaker_id) if args.speaker_id != '' else None
if args.preset is not None:
with open(args.preset) as f:
hparams.parse_json(f.read())
assert hparams.name == "wavenet_vocoder"
print(hparams_debug_string())
fs = hparams.sample_rate
os.makedirs(args.checkpoint_dir, exist_ok=True)
output_json_path = join(args.checkpoint_dir, "hparams.json")
with open(output_json_path, "w") as f:
json.dump(hparams.values(), f, indent=2)
data_loaders = get_data_loaders(args.data_path,
args.speaker_id,
hparams=hparams,
rank_id=rank_id,
group_size=group_size)
step_size_per_epoch = data_loaders.get_dataset_size()
if is_mulaw_quantize(hparams.input_type):
if hparams.out_channels != hparams.quantize_channels:
raise RuntimeError(
"out_channels must equal to quantize_chennels if input_type is 'mulaw-quantize'"
)
if hparams.upsample_conditional_features and hparams.cin_channels < 0:
s = "Upsample conv layers were specified while local conditioning disabled. "
# coding: utf-8
"""
Dump hyper parameters to json file.
usage: tojson.py [options] <output_json_path>
options:
--hparams=<parmas> Hyper parameters [default: ].
-h, --help Show help message.
"""
from docopt import docopt
import sys
import os
from os.path import dirname, join, basename, splitext
import json
from hparams import hparams
if __name__ == "__main__":
args = docopt(__doc__)
output_json_path = args["<output_json_path>"]
hparams.parse(args["--hparams"])
j = hparams.values()
with open(output_json_path, "w") as f:
json.dump(j, f, indent=2)
sys.exit(0)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--base_dir',
default=os.path.expanduser(r'E:\data\logs'))
parser.add_argument('--input',
default=r'E:\data\biaobei\specs\train-blank.txt')
parser.add_argument('--model', default='tacotron')
parser.add_argument(
'--name',
default='biaobei-blank',
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',
default=6000,
type=int,
help='Global step to restore from checkpoint.')
parser.add_argument(
'--summary_interval',
type=int,
default=200, # 100,
help='Steps between running summary ops.')
parser.add_argument(
'--checkpoint_interval',
type=int,
default=2000, # 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.')
args = parser.parse_args()
os.environ['TF_CPP_MIN_LOG_LEVEL'] = str(args.tf_log_level)
run_name = args.name or args.model
log_dir = os.path.join(args.base_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)
hparams.parse(args.hparams)
json.dump(hparams.values(),
open(os.path.join(log_dir, 'hparams.json'),
'wt',
encoding='utf8'),
indent=4)
json.dump(args.__dict__,
open(os.path.join(log_dir, 'args.json'), 'wt', encoding='utf8'),
indent=4)
json.dump(symbols,
open(os.path.join(log_dir, 'symbols.json'),
'wt',
encoding='utf8'),
indent=4)
train(log_dir, args)
# Load preset if specified
if preset is not None:
load_hparams_from_preset(preset)
# Override hyper parameters
wavenet_hparams.parse(args["--hparams"])
assert wavenet_hparams.name == "wavenet_vocoder"
print(hparams_debug_string())
fs = wavenet_hparams.sample_rate
os.makedirs(checkpoint_dir, exist_ok=True)
output_json_path = join(checkpoint_dir, "wavenet_hparams.json")
with open(output_json_path, "w") as f:
json.dump(wavenet_hparams.values(), f, indent=2)
# Dataloader setup
data_loaders = get_data_loaders(dump_root, speaker_id, test_shuffle=True)
maybe_set_epochs_based_on_max_steps(wavenet_hparams,
len(data_loaders["train_no_dev"]))
device = torch.device("cuda" if use_cuda else "cpu")
# Model
model = build_model().to(device)
receptive_field = model.receptive_field
print("Receptive field (samples / ms): {} / {}".format(
receptive_field, receptive_field / fs * 1000))
import numpy as np
import shutil
import aukit
from aukit.audio_griffinlim import default_hparams, mel_spectrogram
from hparams import hparams
my_hp = {
"n_fft": 1024, "hop_size": 256, "win_size": 1024,
"sample_rate": 22050, "max_abs_value": 4.0,
"fmin": 0, "fmax": 8000,
"preemphasize": True,
'symmetric_mels': True,
}
default_hparams.update(hparams.values())
# default_hparams.update(my_hp)
a = {(k, v) for k, v in hparams.values().items() if type(v) in {str, int, float, tuple, bool, type(None)}}
b = {(k, v) for k, v in default_hparams.items() if type(v) in {str, int, float, tuple, bool, type(None)}}
print(a - b)
print(b - a)
_pad_len = (default_hparams.n_fft - default_hparams.hop_size) // 2
def wavs2mels(indir: Path, outdir: Path):
for fpath in tqdm(indir.glob("*.wav")):
wav = aukit.load_wav(fpath, sr=16000)
wav = np.pad(wav.flatten(), (_pad_len, _pad_len), mode="reflect")
mel = mel_spectrogram(wav, default_hparams)
def main(args, max_data_size=0):
vocab_dir = args.vocab_dir
log_file_handler = logging.FileHandler(os.path.join(vocab_dir, 'train.log'))
logger.addHandler(log_file_handler)
check_vocab(args, vocab_dir)
datasets = load_dataset(args, vocab_dir)
iterator = iterator_utils.get_iterator(hparams, datasets, max_rows=max_data_size)
src_vocab, tgt_vocab, _, _, src_vocab_size, tgt_vocab_size = datasets
hparams.add_hparam('is_training', True)
hparams.add_hparam('vocab_size_source', src_vocab_size)
hparams.add_hparam('vocab_size_target', tgt_vocab_size)
pprint(hparams.values())
sess, model = load_model(hparams, tf.contrib.learn.ModeKeys.TRAIN, iterator, src_vocab, tgt_vocab)
if args.restore_step > 0:
checkpoint_path = os.path.join(vocab_dir, 'nmt.ckpt')
ckpt = '%s-%d' % (checkpoint_path, hparams.restore_step)
else:
ckpt = tf.train.latest_checkpoint(vocab_dir)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=5)
if ckpt:
saver.restore(sess, ckpt)
else:
sess.run(tf.global_variables_initializer())
print("Created model with fresh parameters.")
sess.run(tf.tables_initializer())
with sess:
writer = tf.summary.FileWriter(vocab_dir, sess.graph)
logger.info("starting training...")
epochs = 1
step_in_epoch = 0
learning_rate = hparams.learning_rate
checkpoint_path = os.path.join(vocab_dir, "nmt.ckpt")
sess.run(iterator.initializer)
while epochs <= args.num_train_epochs:
start_time = time.time()
try:
loss, global_step, learning_rate, accuracy, summary = model.step(sess)
step_in_epoch += 1
if global_step % args.summary_per_steps == 0:
write_summary(writer, summary, global_step)
except tf.errors.OutOfRangeError:
logger.info('{} epochs finished'.format(epochs))
# saver.save(sess, checkpoint_path, global_step=global_step)
epochs += 1
step_in_epoch = 1
sess.run(iterator.initializer)
continue
sec_per_step = time.time() - start_time
logger.info("Epoch %-3d Step %-d - %-d [%.3f sec, loss=%.4f, acc=%.3f, lr=%f]" %
(epochs, global_step, step_in_epoch, sec_per_step, loss, accuracy, learning_rate))
if global_step % args.steps_per_checkpoint == 0:
model_checkpoint_path = saver.save(sess, checkpoint_path, global_step=global_step)
logger.info("Saved checkpoint to {}".format(model_checkpoint_path))
if math.isnan(loss) or math.isinf(loss):
raise Exception('loss overflow')
writer.close()
