def main(): parser = argparse.ArgumentParser() parser.add_argument('-mode') parser.add_argument('-model') parser.add_argument('-cfg', nargs='*') args = parser.parse_args() cfg.init_handler(args.model) if args.cfg: for pair in args.cfg: k, v = tuple(pair.split('=')) dtype = type(getattr(cfg, k)) if dtype == type(None): raise ValueError() if dtype is bool: v = False if v == 'False' else True else: v = dtype(v) setattr(cfg, k, v) logging.debug(str(cfg)) if cfg.cuda: torch.cuda.set_device(cfg.cuda_device) logging.debug('Device: {}'.format(torch.cuda.current_device())) cfg.mode = args.mode torch.manual_seed(cfg.seed) torch.cuda.manual_seed(cfg.seed) random.seed(cfg.seed) np.random.seed(cfg.seed) m = Model(args.model.split('-')[-1]) m.count_params() if args.mode == 'train': m.load_embeddings() m.train() elif args.mode == 'adjust': m.load_model() m.train() elif args.mode == 'test': m.load_model() m.eval() elif args.mode == 'rl': m.load_model() m.reinforce_tune() elif args.mode == 'iteract': m.load_model() print("Willkommen!") while True: input_text = input().lower() response, bspan = m.infer((input_text)) print("%s (%s)" % (response, bspan))
def main(): parser = argparse.ArgumentParser() parser.add_argument('-mode') parser.add_argument('-model') parser.add_argument('-cfg', nargs='*') args = parser.parse_args() cfg.init_handler(args.model) cfg.dataset = args.model.split('-')[-1] if args.cfg: for pair in args.cfg: k, v = tuple(pair.split('=')) dtype = type(getattr(cfg, k)) if dtype == type(None): raise ValueError() if dtype is bool: v = False if v == 'False' else True else: v = dtype(v) setattr(cfg, k, v) logging.info(str(cfg)) if cfg.cuda: torch.cuda.set_device(cfg.cuda_device) logging.info('Device: {}'.format(torch.cuda.current_device())) cfg.mode = args.mode torch.manual_seed(cfg.seed) torch.cuda.manual_seed(cfg.seed) random.seed(cfg.seed) np.random.seed(cfg.seed) m = Model(args.model.split('-')[-1]) m.count_params() if args.mode == 'train': m.load_glove_embedding() # m.load_model(cfg.start_epoch) # m.load_model_para(cfg.para_start_epoch) m.train() elif args.mode == 'adjust': m.load_model(cfg.start_epoch) m.load_model_para(cfg.para_start_epoch) m.train() elif args.mode == 'test': m.load_model(cfg.start_epoch) m.load_model_para(cfg.para_start_epoch) m.eval() elif args.mode == 'rl': m.load_model(cfg.start_epoch) m.load_model_para(cfg.para_start_epoch) m.reinforce_tune()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-mode') parser.add_argument('-dataset') parser.add_argument('-cfg', nargs='*') parser.add_argument('-seed', default=0, type=int) args = parser.parse_args() seed = args.seed torch.manual_seed(seed) torch.cuda.manual_seed(seed) random.seed(seed) np.random.seed(seed) cfg.init_handler(args.dataset) if args.cfg: for pair in args.cfg: k, v = tuple(pair.split('=')) dtype = type(getattr(cfg, k)) if dtype == type(None): raise ValueError() if dtype is bool: v = False if v == 'False' else True else: v = dtype(v) setattr(cfg, k, v) logging.debug(str(cfg)) if cfg.cuda: torch.cuda.set_device(cfg.cuda_device) logging.debug('Device: {}'.format(torch.cuda.current_device())) m = Model(args.dataset) if args.mode == 'train': m.load_glove_embedding() m.train() elif args.mode == 'adjust': m.load_model() m.train() elif args.mode == 'test': m.load_model() m.eval()
if match: match_result.append(db_ent) if not return_name: return match_result else: if domain == 'train': match_result = [e['id'] for e in match_result] else: match_result = [e['name'] for e in match_result] return match_result if __name__ == "__main__": from config import global_config as cfg cfg.init_handler('camrest') dataset = CamRest676(cfg) c0 = {'food': [], 'pricerange': [], 'area':[]} c1 = {'food': ['asian', 'oriental'], 'pricerange': [], 'area':[]} c2 = {'food': [], 'pricerange': ['cheap'], 'area':['centre']} c3 = {'food': ['modern', 'european'], 'pricerange': ['cheap'], 'area':['centre']} bgt = time.time() for i in range(10000): # dataset.db_search(c0) dataset.db_search(c1) dataset.db_search(c2) dataset.db_search(c3) print('sql time: ', time.time()-bgt) bgt = time.time() for i in range(10000): # dataset.db_json_search(c0)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-mode') parser.add_argument('-model') parser.add_argument('-cfg', nargs='*') args = parser.parse_args() cfg.init_handler(args.model) if args.cfg: for pair in args.cfg: k, v = tuple(pair.split('=')) dtype = type(getattr(cfg, k)) # ############################# # # print(k) # # print(v) # pdb.set_trace() # ############################# if dtype == type(None): raise ValueError() if dtype is bool: v = False if v == 'False' else True else: v = dtype(v) # v = v.replace('\t','').replace('\n','').split(',') # cfg.split = tuple([int(i) for i in cfg.split]) # cfg.mode = args.mode # if type(v) is list and len(v[0]) == 1: # v = "".join(v) # v = v.replace('\t','').replace('\n','').split(',') # ############################# # print(k) # print(v) # pdb.set_trace() # ############################# setattr(cfg, k, v) # cfg.mode = args.mode if args.cfg: cfg.split = tuple([int(i) for i in cfg.split]) cfg.mode = args.mode if type(cfg.data) is list and 'maml' not in cfg.mode: cfg.data = "".join(cfg.data) if type(cfg.db) is list and 'maml' not in cfg.mode: cfg.db = "".join(cfg.db) if type(cfg.entity) is list and 'maml' not in cfg.mode: cfg.entity = "".join(cfg.entity) logging.debug(str(cfg)) if 'train' not in args.mode: print(str(cfg)) if cfg.cuda: torch.cuda.set_device(cfg.cuda_device) logging.debug('Device: {}'.format(torch.cuda.current_device())) cfg.mode = args.mode torch.manual_seed(cfg.seed) torch.cuda.manual_seed(cfg.seed) random.seed(cfg.seed) np.random.seed(cfg.seed) m = Model(args.model.split('-')[-1]) m.count_params() if args.mode == 'train': m.load_glove_embedding() m.train() elif args.mode == 'adjust': m.load_model() m.train() elif args.mode == 'test': m.load_model() m.eval() elif args.mode == 'rl': m.load_model() m.reinforce_tune() elif args.mode == 'train_maml': m.load_glove_embedding() m.train_maml() elif args.mode == 'adjust_maml': m.load_model() m.adjust_maml() elif args.mode == 'test_maml': m.load_model() m.eval_maml() elif args.mode == 'rl_maml': m.load_model() m.reinforce_tune_maml()
_, ind = torch.min(mask, dim=1) def basic(r): for batch in r.mini_batch_iterator('train'): return for d in batch: # first is turn0, then turn1 print(len(d['user'])) # print(d.keys()) if __name__=='__main__': # cfg.init_handler('tsdf-kvret') # cfg.dataset = 'kvret' # r = reader.KvretReader() cfg.init_handler('tsdf-camrest') cfg.dataset = 'camrest' r = reader.CamRest676Reader() with_convert(r) # basic(r) # max_len(r) # ten = torch.zeros(5, 6) # ten[:,:2] = torch.rand(5, 2) # ten[1,2] = 1.243 # # ten[2,2] = 1.243 # ten[2,3] = 1.243 # print(ten) # # mask = ten == 0 # # ten = ten[:,:].nonzero() # print(ten.split(2))
def main_function(train_sequicity=True): cfg.init_handler('tsdf-camrest') cfg.dataset = 'camrest' r = reader.CamRest676Reader() params = get_params() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # use GPU or CPU embedding = nn.Embedding(params['ntoken'], params['ninp']) embedding = init_embedding(embedding, r) # def __init__(self, ntoken, ninp, nhead, nhid, nlayers, reader, params, dropout=0.5, embedding=None): encoder = Encoder( params['ntoken'],\ params['ninp'],\ params['nhead'],\ params['nhid'],\ params['nlayers'],\ params,\ params['dropout_encoder'],\ embedding).to(device) bspan_decoder = BSpanDecoder( params['ntoken'],\ params['ninp'],\ params['nhead'],\ # params['nhid'] - params['bspan_size'] - 1,\ params['bspan_size'],\ params['nlayers'],\ r,\ params,\ params['dropout_bdecoder'],\ embedding).to(device) response_decoder = ResponseDecoder( params['ntoken'],\ params['ninp'],\ params['nhead'],\ params['nhid'],\ params['nlayers'],\ r,\ params,\ params['dropout_rdecoder'],\ embedding).to(device) model = SequicityModel(encoder, bspan_decoder, response_decoder, params, r) optimizer = torch.optim.Adam(model.parameters(), lr=params['lr']) criterion = nn.CrossEntropyLoss() if train_sequicity: iterator = r.mini_batch_iterator('train') # bucketed by turn_num eval_iterator = r.mini_batch_iterator('dev') lowest_loss = 1000000000.0 if not os.path.exists("models"): os.makedirs("models") for epoch in range(cfg.epoch_num): model.train() print('Start epoch', epoch) for batch in iterator: prev_bspan = None # bspan from previous turn for user, bspan, response_, degree in convert_batch(batch, params): optimizer.zero_grad() out, _ = model(user, bspan, response_, degree) # TODO what about OOV? like name_SLOT r2 = torch.cat([response_, torch.zeros((22, out.size(1)), dtype=torch.int64)]) loss = criterion(out.view(-1, params['ntoken']), r2.view(-1)) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5) optimizer.step() print(loss) # TODO evaluate!!! model.eval() total_loss = 0.0 softmax = torch.nn.Softmax(-1) for batch in eval_iterator: prev_bspan = None # bspan from previous turn for user, bspan, response_, degree in convert_batch(batch, params): _, decoded = model(user, bspan, response_, degree) # TODO it just does not work for s in decoded: x = r.vocab.sentence_decode(np.array(s)) print(x) # print sentences # TODO save model if total_loss < lowest_loss: lowest_loss = total_loss torch.save(model.state_dict(), "models/best_model.pt") model_path = "models/sequicity_epoch_" + str(epoch + 1) + ".pt" torch.save(model.state_dict(), model_path) else: # test the best model model.load_state_dict(torch.load("models/best_model.pt")) model.eval() iterator = r.mini_batch_iterator('test') total_loss = 0.0 softmax = torch.nn.Softmax(-1) for batch in iterator: prev_bspan = None # bspan from previous turn for user, bspan, response_, degree in convert_batch(batch, params): _, decoded = model(user, bspan, response_, degree) # decoded are autoregressively decoded sentences # TODO it just does not work for s in decoded: x = r.vocab.sentence_decode(np.array(s)) print(x) # print sentences print("Total loss on test dataset:", total_loss)
def main(): if not os.path.exists('./experiments'): os.mkdir('./experiments') if not os.path.exists('./log'): os.mkdir('./log') parser = argparse.ArgumentParser() parser.add_argument('-mode') parser.add_argument('-method') parser.add_argument('-dataset') parser.add_argument('-cfg', nargs='*') args = parser.parse_args() if not os.path.exists('experiments/'+args.dataset): os.mkdir('experiments/'+args.dataset) if not os.path.exists('log/'+args.dataset): os.mkdir('log/'+args.dataset) cfg.mode, cfg.dataset, cfg.method = args.mode, args.dataset, args.method cfg.init_handler(cfg.dataset) if args.mode in ['test', 'adjust', 'rl_tune']: parse_arg_cfg(args) cfg_load = json.loads(open(os.path.join(cfg.eval_load_path, 'config.json'), 'r').read()) for k, v in cfg_load.items(): if k in ['mode', 'cuda', 'cuda_device', 'eval_load_path', 'log_time', 'model_path', 'result_path', 'model_parameters', 'beam_search', 'skip_unsup', 'sup_pretrain', 'lr', 'valid_type', 'seed', 'max_epoch']: continue setattr(cfg, k, v) cfg.model_path = os.path.join(cfg.eval_load_path, 'model.pkl') result_file = 'result_beam.csv' if cfg.beam_search else 'result_greedy.csv' # cfg.model_path = os.path.join(cfg.eval_load_path, 'model_rl.pkl') # result_file = 'result_beam_rl.csv' if cfg.beam_search else 'result_greedy_rl.csv' cfg.result_path = os.path.join(cfg.eval_load_path, result_file) cfg.vocab_path = os.path.join(cfg.eval_load_path, 'vocab') else: parse_arg_cfg(args) if cfg.exp_path in ['' , 'to be generated']: unsup_prop = 0 if cfg.skip_unsup else 100 - cfg.spv_proportion cfg.exp_path = 'experiments/{}/{}_{}_sd{}_sup{}un{}_zl{}_lr{}_dp{}/'.format( cfg.dataset, cfg.method, cfg.exp_no, cfg.seed, cfg.spv_proportion, unsup_prop, cfg.z_length, cfg.lr, cfg.dropout_rate) if cfg.save_log: os.mkdir(cfg.exp_path) cfg.model_path = os.path.join(cfg.exp_path, 'model.pkl') cfg.result_path = os.path.join(cfg.exp_path, 'result.csv') cfg.eval_load_path = cfg.exp_path cfg.init_logging_handler(args.mode) if cfg.cuda: torch.cuda.set_device(cfg.cuda_device) logging.info('Device: {}'.format(torch.cuda.current_device())) torch.manual_seed(cfg.seed) torch.cuda.manual_seed(cfg.seed) random.seed(cfg.seed) np.random.seed(cfg.seed) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True m = Model(args.dataset, args.method) logging.info(str(cfg)) m.count_params() if args.mode == 'train': if cfg.save_log: m.reader.vocab.save_vocab(os.path.join(cfg.exp_path, 'vocab')) with open(os.path.join(cfg.exp_path, 'config.json'), 'w') as f: json.dump(cfg.__dict__, f, indent=2) if cfg.glove_init: m.load_glove_embedding(freeze=cfg.freeze_emb) if unsup_prop>0: m.train(pretrain=True) logging.info('Start semi-supervised training') if cfg.changedp and not cfg.use_resp_dpout: cfg.use_resp_dpout = True m.train() else: m.train() elif args.mode == 'adjust': m.load_model(cfg.model_path) m.train() elif args.mode == 'rl_tune': m.load_model(cfg.model_path) cfg.model_path = cfg.model_path.replace('.pkl', '_rl.pkl') cfg.result_path = os.path.join(cfg.eval_load_path, 'result_rl.csv') for mod in [m.model.embedding, m.model.u_encoder, m.model.z_encoder, m.model.pz_decoder, m.model.u_encoder_q]: m.freeze_module(mod) m.train() elif args.mode == 'test': m.load_model(cfg.model_path) metric_results = m.eval(result_save_path=cfg.result_path) m.reader.save_result_report(metric_results, cfg.global_record_path)