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()