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)
