def specific_default_hparams(cls): """Return default HParams""" hparams = HParams( num_layers=4, # number of Multihead Attn + ffn blocks d_model=128, # internal model dimension dff=512, num_heads=8, dropout_rate=0.1, lowerdim=256, attn_version=1, do_classification=True, # softmax classification class_weight=1.0, class_buffer_layers=0, # buffer FC layers before classifier class_dropout=0.1, # dropout rate for each class buffer layer do_reconstruction=True, # reconstruction recon_weight=1.0, blind_decoder_mask= True, # if True, the decoder knows padding location of the input # training params is_training=True, optimizer='Adam', # SGD, Adam, sgd, adam lr=0.01, # initial lr lr_scheduler='WarmupDecay', # defined in core.lr_scheduler_tf20 warmup_steps=10000, ) return hparams
def get_default_hparams(): return HParams(z_size=args.z_size, act_func=F.elu, has_flow=args.has_flow, n_flows=args.n_flows, wide_encoder=args.wide_encoder, cuda=args.cuda, hamiltonian_flow=False)
def get_default_hparams(): return HParams(dec_emb_size=128, dec_hidden_size=128, dec_dropout=0.1, dec_layers=1, dec_bidirectional=True, dec_use_deep_fusion=True, dec_use_shallow_fusion=False)
def get_default_hparams(): return HParams( tm_init = False, tm_overfitted = False, tm_bin_path = os.path.join(SE_DIR, "se.bin"), tm_top_size = 3, tm_train_dataset_path = os.path.join(DATASET_DIR, "he-en"), tm_50_50 = True )
def get_default_hparams(): return HParams( use_cuda=False, max_length=15, batch_size=128, n_epochs=40, clip=0.25, starting_learning_rate=1e-3, # todo learning_rate_strategy="constant_decay", # todo optimizer="Adam", # todo, prefix="", model_name="", logdir="", use_tm_on_test=False, n_tm_epochs=10, cuda_visible_devices=1, force_override=False)
def main(): # torch.multiprocessing.freeze_support() use_cuda = torch.cuda.is_available() parser = argparse.ArgumentParser() parser.add_argument('--seed', type=int, default=1) args = parser.parse_args() # load configuration from yaml file config = HParams.load( os.path.join(os.path.dirname(os.path.abspath(__file__)), "hparams.yaml")) data_config = config.data_io model_config = config.model exp_config = config.experiment # check asset dir and get logger root_dir = "/" if use_cuda else get_project_root("Deep-Generative-Model") asset_path = os.path.join(root_dir, "assets", "test") # change subdirectory check_asset_dir(asset_path, config) logger.logging_verbosity(1) logger.add_filehandler(os.path.join(asset_path, "log.txt")) tf_logger = get_tflogger(asset_path) # data_config['root_path'] = os.path.join(root_dir, data_config['root_path']) # seed if args.seed > 0: torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) np.random.seed(args.seed) random.seed(args.seed) logger.info("configuration complete") # get loader train_loader = get_loader(train=True, **data_config) test_loader = get_loader(train=False, **data_config) for batch in train_loader: print(batch['img'].size()) break
import logging import tensorflow as tf import numpy as np from pprint import pformat, pprint from datasets import get_dataset from models import get_model from utils.hparams import HParams import pickle parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--min_norm', type=float) parser.add_argument('--norm', type=float) args = parser.parse_args() params = HParams(args.cfg_file) params.min_norm = args.min_norm params.norm = args.norm os.environ['CUDA_VISIBLE_DEVICES'] = params.gpu np.random.seed(params.seed) tf.set_random_seed(params.seed) ############################################################ logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(message)s') logging.info(pformat(params.dict)) writer = tf.summary.FileWriter(params.exp_dir + '/summaries') ############################################################
hparams = HParams( # dataset parameters data_dir="./data/LJSpeech-1.1/", # directory to the data # directory to save all precomputed inputs save_data_dir="./data/LJSpeech-1.1/tacotron", # output variables in dataloader out_variables=["mel", "linear", "text"], n_frames=162, # number of frames in mel spectrogram text_len=188, # maximum text length sr=20000, # sampling rate used to read audios # length of windowed signal after padding with zeros n_fft=2048, n_mels=80, # number of mel filters # audio samples between adjacent STFT columns hop_length=250, win_length=1000, # window length ref_db=20, # reference decibel max_db=100, # maximum decibel mel_fmin=0.0, # minimum mel bank mel_fmax=None, # maximum mel bank preemphasis=0.97, # preemphasis factor # dictionary vocab="~ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!'(),-.:;?,_ ", r=5, # number of frames generated on each timestep n_iter=60, # number of iterations for Griffin-Lim power=1.5, # power used for Griffin-Lim # number of dimensions used for character embedding symbols_embedding_dim=256, prenet_channels=(256, 128), # number channels for prenet # number of dimensions used for encoder embedding encoder_embedding_dim=256, attention_dim=256, # dimension of attention # number of dimensions for decoder embedding postnet_embedding_dim=256, batch_size=32, # batch size epoch=1001, # number of epochs # number of iterations before printing to log file print_frequency=50, weight_decay=0.0, # weight decay max_norm=1.0, # maximum norm used in clip_grad_by_norm alpha=0.001, # learning rate warmup=4000, # number of iterations for warmup epochs_per_checkpoint=50, # number of epochs for each checkpoint output_path="./log/tacotron/", # directory to save results seed=123456, # random seed )
args.allow_growth, log_device_placement=args.verbose > 1) # Initial configuration epoch_offset = 0 meta = None if args.load: args_nondefault = utils.parse_nondefault_args(args, parser.parse_args([])) logger.info('Loading model...') model, meta = load_model(args.load, return_meta=True) logger.info('Loading parameters...') args = HParams(**meta['training_args']).update(vars(args_nondefault)) epoch_offset = len(meta['epochs']) logger.info('Current epoch: %d' % epoch_offset) if args_nondefault.lr: logger.info('Setting current learning rate to %f...' % args.lr) K.set_value(model.optimizer.lr, args.lr) else: logger.info('Creating model...') # Recovering all valid models model_fn = utils.get_from_module('core.models', args.model) # Loading model model = model_fn(**(HParams().parse(args.model_params).values()))
device = torch.device("cuda" if use_cuda else "cpu") parser = argparse.ArgumentParser() parser.add_argument('--index', type=int, help='Experiment Number', default='e') parser.add_argument('--kfold', type=int, help='5 fold (0,1,2,3,4)',default='e') parser.add_argument('--voca', type=bool, help='large voca is True', default=False) parser.add_argument('--model', type=str, default='crf') parser.add_argument('--pre_model', type=str, help='btc, cnn, crnn', default='e') parser.add_argument('--dataset1', type=str, help='Dataset', default='isophonic_221') parser.add_argument('--dataset2', type=str, help='Dataset', default='uspop_185') parser.add_argument('--dataset3', type=str, help='Dataset', default='robbiewilliams') parser.add_argument('--restore_epoch', type=int, default=1000) parser.add_argument('--early_stop', type=bool, help='no improvement during 10 epoch -> stop', default=True) args = parser.parse_args() config = HParams.load("run_config.yaml") if args.voca == True: config.feature['large_voca'] = True config.model['num_chords'] = 170 config.model['probs_out'] = True # Result save path asset_path = config.path['asset_path'] ckpt_path = config.path['ckpt_path'] result_path = config.path['result_path'] restore_epoch = args.restore_epoch experiment_num = str(args.index) ckpt_file_name = 'idx_'+experiment_num+'_%03d.pth.tar' tf_logger = TF_Logger(os.path.join(asset_path, 'tensorboard', 'idx_'+experiment_num)) logger.info("==== Experiment Number : %d " % args.index)
def main(args): # hack in ProgbarLogger: avoid printing the dummy losses keras.callbacks.ProgbarLogger = lambda: ProgbarLogger( show_metrics=['loss', 'decoder_ler', 'val_loss', 'val_decoder_ler']) # GPU configuration setup_gpu(args.gpu, args.allow_growth, log_device_placement=args.verbose > 1) # Initial configuration epoch_offset = 0 meta = None default_args = parser.parse_args([ args.mode, '--dataset', args.dataset, ]) args_nondefault = utils.parse_nondefault_args(args, default_args) if args.mode == 'eval': model, meta = load_model(args.load, return_meta=True, mode='eval') args = HParams(**meta['training_args']).update(vars(args_nondefault)) args.mode = 'eval' else: if args.load: print('Loading model...') model, meta = load_model(args.load, return_meta=True) print('Loading parameters...') args = HParams(**meta['training_args']).update( vars(args_nondefault)) epoch_offset = len(meta['epochs']) print('Current epoch: %d' % epoch_offset) if args_nondefault.lr: print('Setting current learning rate to %f...' % args.lr) K.set_value(model.optimizer.lr, args.lr) else: print('Creating model...') # Load model model = sbrt2017(num_hiddens=args.num_hiddens, var_dropout=args.var_dropout, dropout=args.dropout, weight_decay=args.weight_decay) print('Setting the optimizer...') # Optimization opt = Adam(lr=args.lr, clipnorm=args.clipnorm) # Compile with dummy loss model.compile(loss={ 'ctc': ctc_dummy_loss, 'decoder': decoder_dummy_loss }, optimizer=opt, metrics={'decoder': ler}, loss_weights=[1, 0]) print('Creating results folder...') if args.save is None: args.save = os.path.join('results', 'sbrt2017_%s' % (datetime.datetime.now())) if not os.path.isdir(args.save): os.makedirs(args.save) if args.mode == 'train': print('Adding callbacks') # Callbacks model_ckpt = MetaCheckpoint(os.path.join(args.save, 'model.h5'), training_args=args, meta=meta) best_ckpt = MetaCheckpoint(os.path.join(args.save, 'best.h5'), monitor='val_decoder_ler', save_best_only=True, mode='min', training_args=args, meta=meta) callback_list = [model_ckpt, best_ckpt] print('Getting the text parser...') # Recovering text parser label_parser = preprocessing.SimpleCharParser() print('Getting the data generator...') # Data generator data_gen = DatasetGenerator(None, label_parser, batch_size=args.batch_size, seed=args.seed) # iterators over datasets train_flow, valid_flow, test_flow = None, None, None num_val_samples = num_test_samples = 0 print(str(vars(args))) print('Generating flow...') if args.mode == 'train': train_flow, valid_flow, test_flow = data_gen.flow_from_fname( args.dataset, datasets=['train', 'valid', 'test']) num_val_samples = valid_flow.len print('Initialzing training...') # Fit the model model.fit_generator(train_flow, samples_per_epoch=train_flow.len, nb_epoch=args.num_epochs, validation_data=valid_flow, nb_val_samples=num_val_samples, max_q_size=10, nb_worker=1, callbacks=callback_list, verbose=1, initial_epoch=epoch_offset) del model model = load_model(os.path.join(args.save, 'best.h5'), mode='eval') else: test_flow = data_gen.flow_from_fname(args.dataset, datasets='test') print('Evaluating model on test set') metrics = model.evaluate_generator(test_flow, test_flow.len, max_q_size=10, nb_worker=1) msg = 'Total loss: %.4f\n\ CTC Loss: %.4f\nLER: %.2f%%' % (metrics[0], metrics[1], metrics[3] * 100) print(msg) K.clear_session()
help='Forces CPU-only training, even when in CUDA capable environment') parser.add_argument('--seed', type=int, default=3) parser.add_argument('--cfg', type=str, default=None) args = parser.parse_args() num_workers = args.num_workers batch_size = args.batch_size force_train = args.force_train train_gta = args.gta lr = args.lr if args.cfg is None: raise ValueError('Please specify a config file') hp = HParams(args.cfg) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if not args.force_cpu and torch.cuda.is_available(): device = torch.device('cuda') torch.cuda.manual_seed_all(args.seed) else: device = torch.device('cpu') print('Using device:', device) print('\nInitialising Model...\n') adaptnet = hp.conversion_mode == 1
import seaborn as sns; sns.set() import matplotlib.pyplot as plt from datasets import get_dataset from models import get_model from dfa_modules.cls_sfa import SFA from utils.hparams import HParams from utils.visualize import show_mask parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--batch_size', type=int, default=1024) parser.add_argument('--num_batches', type=int, default=-1) parser.add_argument('--num_steps', type=int, default=-1) args = parser.parse_args() params = HParams(args.cfg_file) setattr(params, 'batch_size', args.batch_size) setattr(params, 'num_batches', args.num_batches) setattr(params, 'num_steps', args.num_steps) pprint(params.dict) os.environ['CUDA_VISIBLE_DEVICES'] = params.gpu np.random.seed(params.seed) tf.set_random_seed(params.seed) save_dir = os.path.join(params.exp_dir, 'test_cls_sing') os.makedirs(save_dir, exist_ok=True) logging.basicConfig(filename=save_dir + '/test.log', filemode='w', level=logging.INFO, format='%(message)s')
from scipy.special import softmax from utils.hparams import HParams from models import get_model from datasets import get_cached_data from models.pc_metrics.metrics import distChamfer, distEMD parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--biased', action='store_true') parser.add_argument('--n_points', type=int, default=128) parser.add_argument('--seed', type=int, default=1234) parser.add_argument('--gpu', type=str, default='0') args = parser.parse_args() params = HParams(args.cfg_file) # modify config params.dataset = 'modelnet' params.mask_type = 'det_expand' os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu np.random.seed(args.seed) tf.set_random_seed(args.seed) # data if not args.biased: validset = get_cached_data(params, 'valid') elif os.path.isfile('.modelnet_airplane_biased'): with open('.modelnet_airplane_biased', 'rb') as f: validset = pickle.load(f) else:
default=True) parser.add_argument('--model', type=str, help='btc, cnn, crnn', default='btc') #----- parser.add_argument('--dataset1', type=str, help='Dataset', default='ce200') #----- #parser.add_argument('--dataset1', type=str, help='Dataset', default='isophonic') #parser.add_argument('--dataset2', type=str, help='Dataset', default='uspop') #parser.add_argument('--dataset3', type=str, help='Dataset', default='robbiewilliams') parser.add_argument('--restore_epoch', type=int, default=1) parser.add_argument('--early_stop', type=bool, help='no improvement during 10 epoch -> stop', default=True) args = parser.parse_args() config = HParams.load("config/run_config_idx0.yaml") if args.voca == True: config.feature['large_voca'] = True config.model['num_chords'] = 170 # Result save path asset_path = config.path['asset_path'] ckpt_path = config.path['ckpt_path'] result_path = config.path['result_path'] restore_epoch = args.restore_epoch experiment_num = str(args.index) ckpt_file_name = 'idx_' + experiment_num + '_%03d.pt' tf_logger = TF_Logger( os.path.join(asset_path, 'tensorboard', 'idx_' + experiment_num)) logger.info("==== Experiment Number : %d " % args.index)
from pprint import pformat, pprint from skimage.measure import compare_psnr import matplotlib.pyplot as plt from datasets import get_dataset from models import get_model from utils.hparams import HParams parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--num_samples', type=int, default=5) parser.add_argument('--sample_std', type=float, default=1.0) parser.add_argument('--num_vis', type=str, default=10) parser.add_argument('--num_batches', type=int, default=10) args = parser.parse_args() params = HParams(args.cfg_file) params.num_samples = args.num_samples params.sample_std = args.sample_std pprint(params.dict) os.environ['CUDA_VISIBLE_DEVICES'] = params.gpu np.random.seed(params.seed) tf.set_random_seed(params.seed) ############################################################ save_dir = os.path.join(params.exp_dir, f'test_{args.sample_std}') if not os.path.exists(save_dir): os.makedirs(save_dir) f = open(save_dir + '/test.txt', 'w') f.write(pformat(args))
help='Forces CPU-only training, even when in CUDA capable environment') parser.add_argument('--seed', type=int, default=3) parser.add_argument('--cfg', type=str, default=None) parser.add_argument('--cache', default=False, action='store_true') args = parser.parse_args() num_workers = args.num_workers batch_size = args.batch_size force_train = args.force_train lr = args.lr if args.cfg is None: raise ValueError('Please specify a config file') hp = HParams(args.cfg) random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) if not args.force_cpu and torch.cuda.is_available(): device = torch.device('cuda') torch.cuda.manual_seed_all(args.seed) else: device = torch.device('cpu') print('Using device:', device) print('\nInitialising Model...\n') # Instantiate WaveRNN Model
import torch import numpy as np import random import os if __name__ == '__main__': torch.multiprocessing.freeze_support() use_cuda = torch.cuda.is_available() parser = argparse.ArgumentParser() parser.add_argument('--seed', type=int, default=1) args = parser.parse_args() # load configuration from yaml file config = HParams.load( os.path.join(os.path.dirname(os.path.abspath(__file__)), "hparams.yaml")) data_config = config.data_io model_config = config.model exp_config = config.experiment # check asset dir and get logger root_dir = "/" if use_cuda else get_project_root("Deep-Generative-Model") asset_path = os.path.join(root_dir, "assets", "test") # change subdirectory check_asset_dir(asset_path, config) logger.logging_verbosity(1) logger.add_filehandler(os.path.join(asset_path, "log.txt")) tf_logger = get_tflogger(asset_path) data_config['root_path'] = os.path.join(root_dir, data_config['root_path'])
import tensorflow as tf from pprint import pformat from utils.hparams import HParams from models.runner import Runner from models import get_model from datasets import get_dataset parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--config', action='append', default=[]) parser.add_argument('--mode', type=str, default=None) parser.add_argument('--seed', type=int, default=1234) parser.add_argument('--gpu', type=str, default='0') args = parser.parse_args() params = HParams(args.cfg_file) # parse config for kv in args.config: k, v = kv.split('=', maxsplit=1) assert k, "Config item can't have empty key" assert v, "Config item can't have empty value" try: v = ast.literal_eval(v) except ValueError: v = str(v) params.update({k: v}) logging.basicConfig(filename=params.exp_dir + f'/{args.mode}.log', filemode='w', level=logging.INFO, format='%(asctime)-15s %(message)s')
import gzip from pprint import pformat, pprint import matplotlib.pyplot as plt from easydict import EasyDict as edict from datasets import get_dataset from models import get_model from utils.hparams import HParams parser = argparse.ArgumentParser() parser.add_argument('--seed', type=int, default=1234) parser.add_argument('--gpu', type=str, default='0') parser.add_argument('--cfg_file', type=str) parser.add_argument('--batch_size', type=int, default=100) args = parser.parse_args() params = HParams(args.cfg_file) params.seed = args.seed params.gpu = args.gpu params.batch_size = args.batch_size pprint(params.dict) os.environ['CUDA_VISIBLE_DEVICES'] = params.gpu np.random.seed(params.seed) tf.set_random_seed(params.seed) ############################################################ save_dir = os.path.join(params.exp_dir, 'test_joint') if not os.path.exists(save_dir): os.makedirs(save_dir) f = open(save_dir + '/test.txt', 'w')
parser.add_argument('--output_file', type=str, default=None) parser.add_argument('--input_parser', type=str, default=None) parser.add_argument('--input_parser_params', nargs='+', default=[]) parser.add_argument('--label_parser', type=str, default=None) parser.add_argument('--label_parser_params', nargs='+', default=[]) parser.add_argument('--override', action='store_true') args = parser.parse_args() parser = utils.get_from_module('datasets*', args.parser, regex=True) print('input args ', args.input_parser_params) input_parser = utils.get_from_module('preprocessing.audio', args.input_parser, params=args.input_parser_params) label_parser = utils.get_from_module('preprocessing.text', args.label_parser, params=args.label_parser_params) dataset = parser(args.dataset_dir, **HParams().parse(args.parser_params).values()) output_file = dataset.to_h5(fname=args.output_file, input_parser=input_parser, label_parser=label_parser, override=args.override) print('Dataset %s saved at %s' % (parser.name, output_file))
def get_default_hparams(): return HParams(enc_emb_size=128, enc_hidden_size=128, enc_dropout=0.1, enc_layers=1, enc_bidirectional=True)
parser.add_argument('--voca', type=bool, help='large voca is True', default=True) parser.add_argument('--model', type=str, help='btc, cnn, crnn', default='btc') #----- parser.add_argument('--dataset1', type=str, help='Dataset', default='ce200') parser.add_argument('--dataset2', type=str, help='Dataset', default='NA') parser.add_argument('--dataset3', type=str, help='Dataset', default='NA') #----- #parser.add_argument('--dataset1', type=str, help='Dataset', default='isophonic') #parser.add_argument('--dataset2', type=str, help='Dataset', default='uspop') #parser.add_argument('--dataset3', type=str, help='Dataset', default='robbiewilliams') parser.add_argument('--restore_epoch', type=int, default=1000) parser.add_argument('--early_stop', type=bool, help='no improvement during 10 epoch -> stop', default=True) args = parser.parse_args() experiment_num = str(args.index) config = HParams.load("config/run_config_idx"+experiment_num+".yaml") if args.voca == True: config.feature['large_voca'] = True config.model['num_chords'] = 170 # Result save path asset_path = config.path['asset_path'] ckpt_path = config.path['ckpt_path'] result_path = config.path['result_path'] restore_epoch = args.restore_epoch #experiment_num = str(args.index) ckpt_file_name = 'idx_'+experiment_num+'_%03d.pt' tf_logger = TF_Logger(os.path.join(asset_path, 'tensorboard', 'idx_'+experiment_num)) logger.info("==== Experiment Number : %d " % args.index)
type=int, default="0", help='GPU index') parser.add_argument('--ngpu', type=int, default=4, help='0 = CPU.') parser.add_argument('--optim_name', type=str, default='adam') parser.add_argument('--restore_epoch', type=int, default=-1) parser.add_argument('--load_rhythm', dest='load_rhythm', action='store_true') parser.add_argument('--seed', type=int, default=1) args = parser.parse_args() use_cuda = torch.cuda.is_available() device = torch.device("cuda:%d" % args.gpu_index if use_cuda else "cpu") hparam_file = os.path.join(os.getcwd(), "hparams.yaml") config = HParams.load(hparam_file) data_config = config.data_io model_config = config.model exp_config = config.experiment # configuration asset_root = config.asset_root asset_path = os.path.join(asset_root, 'idx%03d' % args.idx) make_save_dir(asset_path, config) logger.logging_verbosity(1) logger.add_filehandler(os.path.join(asset_path, "log.txt")) # seed if args.seed > 0: torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed)
from pprint import pformat, pprint import matplotlib.pyplot as plt from datasets import get_dataset from models import get_model from utils.hparams import HParams parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--batch_size', type=int, default=256) parser.add_argument('--num_batches', type=int, default=1) parser.add_argument('--num_samples', type=int, default=10) parser.add_argument('--num_vis', type=int, default=256) parser.add_argument('--sample_std', type=float, default=1.0) args = parser.parse_args() params = HParams(args.cfg_file) params.batch_size = args.batch_size params.num_samples = args.num_samples params.sample_std = args.sample_std pprint(params.dict) os.environ['CUDA_VISIBLE_DEVICES'] = params.gpu np.random.seed(params.seed) tf.set_random_seed(params.seed) ############################################################ save_dir = os.path.join(params.exp_dir, f'sample_{args.sample_std}') if not os.path.exists(save_dir): os.makedirs(save_dir) ############################################################
import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from utils.hparams import HParams from models import get_model from datasets import get_cached_data from models.pc_metrics.metrics import distChamfer, distEMD parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--n_context', type=int, default=256) parser.add_argument('--seed', type=int, default=1234) parser.add_argument('--gpu', type=str, default='0') args = parser.parse_args() params = HParams(args.cfg_file) # modify config params.mask_type = 'det_expand' os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu np.random.seed(args.seed) tf.set_random_seed(args.seed) # data validset = get_cached_data(params, 'valid') testset = get_cached_data(params, 'test') # model model = get_model(params) model.load()
['--model', args.model, '--dataset', args.dataset])) if args.dataset is None and args.file is None: raise ValueError('dataset or file args must be set.') if args.dataset and args.file: print('Both dataset and file args was set. Ignoring file args.') # GPU configuration setup_gpu(args.gpu, args.allow_growth) # Loading model model, meta = load_model(args.model, return_meta=True, mode='predict', decoder=(not args.no_decoder)) args = HParams(**meta['training_args']).update(vars(args_nondefault)) # Features extractor input_parser = utils.get_from_module('preprocessing.audio', args.input_parser, params=args.input_parser_params) # Recovering text parser label_parser = utils.get_from_module('preprocessing.text', args.label_parser, params=args.label_parser_params) if args.dataset is not None: data_gen = DatasetGenerator(input_parser, label_parser, batch_size=1, seed=0, mode='predict', shuffle=False)
from utils.files import get_files import json parser = argparse.ArgumentParser(description='Preprocessing for WaveRNN and Tacotron') parser.add_argument('--path', '-p', default=hp.wav_path, help='directly point to dataset path (overrides hparams.wav_path') parser.add_argument('--extension', '-e', default='.wav', help='file extension to search for in dataset folder') parser.add_argument('--cfg', type=str, default=None) parser.add_argument('--mel_guia', type=str, default=None) parser.add_argument('--wav_guia', type=str, default=None) args = parser.parse_args() extension = args.extension path = args.path hp = HParams(args.cfg) def convert_file(in_path, out_path): # load the output waveform to be predicted y = load_wav(out_path) if len(y) < hp.voc_seq_len * 3: # skip too short files return None, None peak = np.abs(y).max() if hp.peak_norm or peak > 1.0: y /= peak # load the input waveform from which melspec is computed x = load_wav(in_path) mel = melspectrogram(x) if hp.voc_mode == 'RAW':
sns.set() import matplotlib.pyplot as plt from scipy.stats import entropy from datasets import get_dataset from models import get_model from utils.hparams import HParams parser = argparse.ArgumentParser() parser.add_argument('--cfg_file', type=str) parser.add_argument('--gpu', type=str, default='0') parser.add_argument('--batch_size', type=int, default=1) parser.add_argument('--num_samples', type=int, default=100) args = parser.parse_args() params = HParams(args.cfg_file) params.gpu = args.gpu params.batch_size = args.batch_size params.num_samples = args.num_samples pprint(params.dict) os.environ['CUDA_VISIBLE_DEVICES'] = params.gpu np.random.seed(params.seed) tf.set_random_seed(params.seed) save_dir = os.path.join(params.exp_dir, 'cmi_greedy') os.makedirs(save_dir, exist_ok=True) ############################################################ logging.basicConfig(filename=save_dir + '/cmi_greedy.log', filemode='w',
# Model settings parser.add_argument('--num_hiddens', default=1024, type=int) parser.add_argument('--var_dropout', default=0.2, type=float) parser.add_argument('--dropout', default=0, type=float) parser.add_argument('--weight-decay', default=1e-4, type=float) # Hyper parameters parser.add_argument('--num_epochs', default=100, type=int) parser.add_argument('--lr', default=0.001, type=float) parser.add_argument('--momentum', default=0.9, type=float) parser.add_argument('--clipnorm', default=400, type=float) parser.add_argument('--batch_size', default=32, type=int) # End of hyper parameters # Dataset definitions parser.add_argument('--dataset', default=None, type=str, required='True') # Other configs parser.add_argument('--save', default=None, type=str) parser.add_argument('--gpu', default='0', type=str) parser.add_argument('--allow_growth', default=False, action='store_true') parser.add_argument('--verbose', default=0, type=int) parser.add_argument('--seed', default=None, type=float) args = parser.parse_args() args = HParams(**vars(args)) main(args)