def get_training_parameters(opt): train = DD() static = DD() static.exp = opt.exp static.seed = opt.random_seed # weight decay static.l2 = opt.l2 static.vl2 = True static.lrsched = opt.learning_rate_schedule # 'warmup_linear' static.lrwarm = opt.learning_rate_warmup # 0.002 # gradient clipping static.clip = opt.clip # what loss function to use static.loss = opt.loss dynamic = DD() dynamic.lr = opt.learning_rate # learning rate dynamic.bs = opt.batch_size # batch size # optimizer to use {adam, rmsprop, etc.} dynamic.optim = opt.optimizer # rmsprop # alpha is interpolation average static.update(opt[dynamic.optim]) train.static = static train.dynamic = dynamic return train
def get_parameters(opt, exp_type="model"): params = DD() params.net = DD() params.mle = 0 params.dataset = opt.dataset params.net = get_net_parameters(opt) params.train = get_training_parameters(opt) params.model = params.net.model params.exp = opt.exp params.data = get_data_parameters(opt, params.exp, params.dataset) params.eval = get_eval_parameters(opt, params.data.get("categories", None)) #params.n_per_node = opt.n_per_node #params.max_path_len = opt.max_path_len #params.n_train = opt.n_train #params.n_dev = opt.n_dev #params.n_test = opt.n_test meta = DD() params.trainer = opt.trainer meta.iterations = int(opt.iterations) meta.cycle = opt.cycle params.cycle = opt.cycle params.iters = int(opt.iterations) global toy toy = opt.toy global do_gen do_gen = opt.do_gen global save save = opt.save global test_save test_save = opt.test_save global save_strategy save_strategy = opt.save_strategy print(params) return params, meta
def get_eval_parameters(opt, force_categories=None): evaluate = DD() if opt.eval_sampler == "beam": evaluate.bs = opt.beam_size elif opt.eval_sampler == "greedy": evaluate.bs = 1 elif opt.eval_sampler == "topk": evaluate.k = opt.topk_size evaluate.smax = opt.gen_seqlength evaluate.sample = opt.eval_sampler evaluate.numseq = opt.num_sequences evaluate.gs = opt.generate_sequences evaluate.es = opt.evaluate_sequences if opt.dataset == "atomic": if "eval_categories" in opt and force_categories is None: evaluate.categories = opt.eval_categories else: evaluate.categories = force_categories return evaluate
def get_data_parameters(opt, experiment, dataset):#####opt.exp & opt.data used for data loader path data = DD() ################## if dataset == "atomic": data.categories = sorted(opt.categories) #ORIGINAL CODE # hard-coded data.maxe1 = 17 data.maxe2 = 35 data.maxr = 1 #ADRIAN ADDED ################THIS IS WHERE YOU CHANGE PARAMETERS FOR NAME OF LOADER YOU'RE USING ##############MAXE1 == MAX EVENT ############MAXE2 == MAX EFFECT data.maxe1 = 50 data.maxe2 = 35 data.maxr = 1 ### elif dataset == "conceptnet": data.rel = opt.relation_format data.trainsize = opt.training_set_size data.devversion = opt.development_set_versions_to_use data.maxe1 = opt.max_event_1_size data.maxe2 = opt.max_event_2_size if data.rel == "language": # hard-coded data.maxr = 5 else: # hard-coded data.maxr = 1 return data############
def get_data_parameters(opt, experiment, dataset): data = DD() if dataset == "atomic": data.categories = sorted(opt.categories) # hard-coded data.maxe1 = 17 data.maxe2 = 35 data.maxr = 1 elif dataset == "conceptnet": data.rel = opt.relation_format data.trainsize = opt.training_set_size data.devversion = opt.development_set_versions_to_use data.maxe1 = opt.max_event_1_size data.maxe2 = opt.max_event_2_size if data.rel == "language": # hard-coded data.maxr = 5 else: # hard-coded data.maxr = 1 elif dataset == "motiv_sent": data.categories = sorted(opt.categories) data.maxe1 = 100 data.maxe2 = 67 data.maxr = 1 return data
def load_default(): with open(abs_path("config_default.json"), 'r') as f: config = json.load(f) config = DD(config) config.net = DD(config.net) config.train = DD(config.train) config.train.static = DD(config.train.static) config.train.dynamic = DD(config.train.dynamic) config.data = DD(config.data) config.eval = DD(config.eval) config.train.dynamic.epoch = 0 return DD(config)
def read_config(file_): config = DD() print(file_) for k, v in file_.items(): if v == "True" or v == "T" or v == "true": config[k] = True elif v == "False" or v == "F" or v == "false": config[k] = False elif type(v) == dict: config[k] = read_config(v) else: config[k] = v return config
def get_net_parameters(opt): net = DD() net.model = opt.model net.nL = opt.num_layers net.nH = opt.num_heads net.hSize = opt.hidden_dim net.edpt = opt.embedding_dropout net.adpt = opt.attention_dropout net.rdpt = opt.residual_dropout net.odpt = opt.output_dropout net.pt = opt.pretrain net.afn = opt.activation # how to intialize parameters # format is gauss+{}+{}.format(mean, std) # n = the default initialization pytorch net.init = opt.init return net
data_params[case.split("_")[0]] = case.split("_")[1].split("#") else: data_params[case.split("_")[0]] = case.split("_")[1] return data_params gens_file = args.gens_file split = gens_file.split("/")[-1].split(".")[0] n = args.n def flatten(outer): return [el for key in outer for el in key] opt = DD() opt.data = DD() opt.dataset = "atomic" opt.exp = "generation" data_params = get_data_params(gens_file) categories = data_params[ "categories"] #sorted(["oReact", "oEffect", "oWant", "xAttr", "xEffect", "xIntent", "xNeed", "xReact", "xWant"]) opt.data.categories = data_params["categories"] if "maxe1" in data_params: opt.data.maxe1 = data_params["maxe1"] opt.data.maxe2 = data_params["maxe2"] opt.data.maxr = data_params["maxr"]
def get_meta(config): meta = DD() meta.iterations = int(config.iters) meta.cycle = config.cycle return meta