def main(save_path, params):
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
dataset = params['dataset']
nlayers = params['nlayers']
train_emb = params['train_emb']
char_dim = params['char_dim']
use_feat = params['use_feat']
gating_fn = params['gating_fn']
out = 'out'
# save settings
shutil.copyfile('config.py', '%s/config.py' % save_path)
use_chars = char_dim > 0
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(dataset, no_training_set=False, use_chars=use_chars)
word_dictionary = data.dictionary[0]
the_index = word_dictionary['the']
#print('the index : {}'.format(word_dictionary['the']))
idx_to_word = dict([(v, k) for (k, v) in word_dictionary.iteritems()])
words = [idx_to_word[i] for i in sorted(idx_to_word.keys())]
print("building minibatch loaders ...")
batch_loader_train = MiniBatchLoader.MiniBatchLoader(data.training,
BATCH_SIZE,
sample=1.0)
batch_loader_val = MiniBatchLoader.MiniBatchLoader(data.validation,
BATCH_SIZE)
print("building network ...")
W_init, embed_dim, = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
#print('the embedding : {}'.format(W_init[the_index]))
#print(W_init[0:5])
print("running GAReader ...")
m = GAReader.Model(nlayers, data.vocab_size, data.num_chars, W_init,
nhidden, embed_dim, dropout, train_emb, char_dim,
use_feat, gating_fn, words).build_network()
m.compile(optimizer=tf.keras.optimizers.Adam(lr=LEARNING_RATE,
clipnorm=GRAD_CLIP),
loss=tf.keras.losses.categorical_crossentropy,
metrics=[tf.keras.metrics.categorical_accuracy])
#tf.enable_eager_execution(config=tf.ConfigProto(allow_soft_placement = True))
with tf.Graph().as_default():
with tf.Session(config=tf.ConfigProto(
allow_soft_placement=True)) as sess:
K.set_session(sess)
#with tf.device('/gpu:0:'):
tensorboard = TensorBoardCustom(log_dir="logs", words=words)
modelcheckpoint = tf.keras.callbacks.ModelCheckpoint(
'output/weights.{epoch:02d}-{val_loss:.2f}.hdf5')
writer = tf.summary.FileWriter("logs")
def schedule(epoch, lr):
if epoch >= 3:
return lr * 0.5
else:
return lr
lrate = LearningRateScheduler(schedule, verbose=1)
for epoch in xrange(NUM_EPOCHS):
for (inputs, a) in batch_loader_train:
[dw, qw, m_dw, m_qw, c, m_c, cl] = inputs
m = GAReader.Model(nlayers, data.vocab_size,
data.num_chars, W_init, nhidden,
embed_dim, dropout, train_emb, char_dim,
use_feat, gating_fn,
words).build_network()
m.compile(optimizer=tf.keras.optimizers.Adam(
lr=LEARNING_RATE, clipnorm=GRAD_CLIP),
loss=tf.keras.losses.categorical_crossentropy,
metrics=[tf.keras.metrics.categorical_accuracy])
#print(dw.shape)
#print('dw : {}'.format(dw))
#print('qw : {}'.format(qw))
#print('m_dw : {}'.format(m_dw))
#print('m_qw : {}'.format(m_qw))
#print('c : {}'.format(c))
#print([idx_to_word[i] for i in dw[0, :, 0].tolist()])
train_summary = m.train_on_batch(
inputs,
to_categorical(a, batch_loader_train.max_num_cand))
print(m.get_weights()[0])
print('epoch: {}, train loss: {}, train acc: {}'.format(
epoch, train_summary[0], train_summary[1]))
lr = tf.summary.scalar('learning_rate', LEARNING_RATE)
summary = tf.summary.merge_all()
s = sess.run(summary)
writer.add_summary(s)
writer.close()
def main(save_path, params):
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
dataset = params['dataset']
nlayers = params['nlayers']
train_emb = params['train_emb']
char_dim = params['char_dim']
use_feat = params['use_feat']
gating_fn = params['gating_fn']
ent_setup = params['ent_setup'] # ent, ent-anonym, no-ent
data_path = params['data_path']
# save settings
shutil.copyfile('config.py', '%s/config.py' % save_path)
use_chars = char_dim > 0
if dataset == "clicr":
dp = DataPreprocessor.DataPreprocessorClicr()
data = dp.preprocess(
#"/mnt/b5320167-5dbd-4498-bf34-173ac5338c8d/Datasets/bmj_case_reports_data/dataset_json_concept_annotated/",
data_path,
ent_setup=ent_setup,
no_training_set=False,
use_chars=use_chars)
elif dataset == "clicr_novice":
dp = DataPreprocessor.DataPreprocessorNovice()
data = dp.preprocess(data_path,
ent_setup=ent_setup,
no_training_set=False,
use_chars=use_chars)
else:
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(data_path,
no_training_set=False,
use_chars=use_chars)
print("building minibatch loaders ...")
batch_loader_train = MiniBatchLoader.MiniBatchLoader(data.training,
BATCH_SIZE,
sample=1.0)
batch_loader_val = MiniBatchLoader.MiniBatchLoader(data.validation,
BATCH_SIZE)
print("building network ...")
W_init, embed_dim, = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
m = GAReader.Model(nlayers, data.vocab_size, data.num_chars, W_init,
nhidden, embed_dim, dropout, train_emb, char_dim,
use_feat, gating_fn)
print("training ...")
num_iter = 0
max_acc = 0.
deltas = []
logger = open(save_path + '/log', 'a')
if os.path.isfile('%s/best_model.p' % save_path):
print('loading previously saved model')
m.load_model('%s/best_model.p' % save_path)
else:
print('saving init model')
m.save_model('%s/model_init.p' % save_path)
print('loading init model')
m.load_model('%s/model_init.p' % save_path)
for epoch in range(NUM_EPOCHS):
estart = time.time()
new_max = False
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames in batch_loader_train:
loss, tr_acc, probs = m.train(dw, dt, qw, qt, c, a, m_dw, m_qw, tt,
tm, m_c, cl)
message = "Epoch %d TRAIN loss=%.4e acc=%.4f elapsed=%.1f" % (
epoch, loss, tr_acc, time.time() - estart)
print(message)
logger.write(message + '\n')
num_iter += 1
if num_iter % VALIDATION_FREQ == 0:
total_loss, total_acc, n, n_cand = 0., 0., 0, 0.
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames in batch_loader_val:
outs = m.validate(dw, dt, qw, qt, c, a, m_dw, m_qw, tt, tm,
m_c, cl)
loss, acc, probs = outs[:3]
bsize = dw.shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
n += bsize
val_acc = total_acc / n
if val_acc > max_acc:
max_acc = val_acc
m.save_model('%s/best_model.p' % save_path)
new_max = True
message = "Epoch %d VAL loss=%.4e acc=%.4f max_acc=%.4f" % (
epoch, total_loss / n, val_acc, max_acc)
print(message)
logger.write(message + '\n')
# m.save_model('%s/model_%d.p'%(save_path,epoch))
message = "After Epoch %d: Train acc=%.4f, Val acc=%.4f" % (
epoch, tr_acc, val_acc)
print(message)
logger.write(message + '\n')
# learning schedule
if epoch >= 2:
m.anneal()
# stopping criterion
if not new_max:
break
logger.close()
def main(load_path, params, mode='test'):
regularizer = params['regularizer']
rlambda = params['lambda']
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
dataset = params['dataset']
nlayers = params['nlayers']
train_emb = params['train_emb']
subsample = params['subsample']
base_model = params['model']
char_dim = params['char_dim']
use_feat = params['use_feat']
gating_fn = params['gating_fn']
# load settings
shutil.copyfile('%s/config.py' % load_path, 'config.py')
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(dataset)
inv_vocab = data.inv_dictionary
print("building minibatch loaders ...")
if mode == 'test':
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.test, BATCH_SIZE, data.dictionary)
else:
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.validation, BATCH_SIZE, data.dictionary)
print("building network ...")
W_init, embed_dim = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
m = eval(base_model).Model(nlayers, data.vocab_size, data.num_chars,
W_init, regularizer, rlambda, nhidden,
embed_dim, dropout, train_emb, subsample,
char_dim, use_feat, data.dictionary[4])
m.load_model('%s/best_model.p' % load_path)
print("testing ...")
pr = np.zeros((len(batch_loader_test.questions),
batch_loader_test.max_num_cand)).astype('float32')
fids, attns = [], []
total_loss, total_acc, n = 0., 0., 0
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames, match_feat, use_char, use_char_q in batch_loader_test:
outs = m.validate(dw, dt, qw, qt, c, a, m_dw, m_qw, tt, tm, m_c, cl,
match_feat, use_char, use_char_q)
loss, acc, probs = outs[:3]
attns += [[fnames[0], probs[0, :]] + [o[0, :, :] for o in outs[3:]]
] # store one attention
bsize = dw.shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
pr[n:n + bsize, :] = probs
fids += fnames
n += bsize
logger = open(load_path + '/log', 'a', 0)
message = '%s Loss %.4e acc=%.4f' % (mode.upper(), total_loss / n,
total_acc / n)
print message
logger.write(message + '\n')
logger.close()
np.save('%s/%s.probs' % (load_path, mode), np.asarray(pr))
pkl.dump(attns, open('%s/%s.attns' % (load_path, mode), 'w'))
f = open('%s/%s.ids' % (load_path, mode), 'w')
for item in fids:
f.write(item + '\n')
f.close()
def main(load_path, params, mode='test'):
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
dataset = params['data']
nlayers = params['nlayers']
sub2vec = params['sub2vec']
train_emb = params['train_emb']
sub_dim = params['sub_dim']
use_feat = params['use_feat']
gating_fn = params['gating_fn']
use_subs = sub_dim > 0
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(dataset, no_training_set=True, use_subs=use_subs)
inv_vocab = data.inv_dictionary
print("building minibatch loaders ...")
if mode == 'test':
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.test, BATCH_SIZE)
else:
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.validation, BATCH_SIZE)
print("building network ...")
W_init, embed_dim = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
S_init, sub_dim = Helpers.load_sub_embeddings(data.dictionary[1], sub2vec)
m = model.Model(nlayers,
data.vocab_size,
data.num_chars,
W_init,
S_init,
nhidden,
embed_dim,
dropout,
train_emb,
sub_dim,
use_feat,
gating_fn,
save_attn=True)
m.load_model('%s/best_model.p' % load_path)
print("testing ...")
pr = np.zeros((len(batch_loader_test.questions),
batch_loader_test.max_num_cand)).astype('float32')
fids, attns = [], []
total_loss, total_acc, n = 0., 0., 0
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames in batch_loader_test:
outs = m.validate(dw, dt, qw, qt, c, a, m_dw, m_qw, tt, tm, m_c, cl)
loss, acc, probs = outs[:3]
attns += [[fnames[0], probs[0, :]] + [o[0, :, :] for o in outs[3:]]
] # store one attention
bsize = dw.shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
fids += fnames
n += bsize
print("step" + str(n) + ",acc" + str(acc))
logger = open(load_path + '/log', 'a', 0)
message = '%s Loss %.4e acc=%.4f' % (mode.upper(), total_loss / n,
total_acc / n)
print message
logger.write(message + '\n')
logger.close()
np.save('%s/%s.probs' % (load_path, mode), np.asarray(pr))
pkl.dump(attns, open('%s/%s.attns' % (load_path, mode), 'w'))
f = open('%s/%s.ids' % (load_path, mode), 'w')
for item in fids:
f.write(item + '\n')
f.close()
def main(save_path, params):
regularizer = params['regularizer']
rlambda = params['lambda']
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
dataset = params['dataset']
nlayers = params['nlayers']
train_emb = params['train_emb']
subsample = params['subsample']
base_model = params['model']
char_dim = params['char_dim']
use_feat = params['use_feat']
train_cut = params['train_cut']
gating_fn = params['gating_fn']
# save settings
shutil.copyfile('config.py','%s/config.py'%save_path)
use_chars = char_dim>0
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(dataset, use_chars=use_chars)
print("building minibatch loaders ...")
batch_loader_train = MiniBatchLoader.MiniBatchLoader(data.training, BATCH_SIZE, data.dictionary,
sample=train_cut, max_qry_len=85)
batch_loader_val = MiniBatchLoader.MiniBatchLoader(data.validation, BATCH_SIZE, data.dictionary, max_qry_len=85)
batch_loader_test = MiniBatchLoader.MiniBatchLoader(data.test, BATCH_SIZE, data.dictionary)
print("building network ...")
W_init, embed_dim, = Helpers.load_word2vec_embeddings(data.dictionary[0], word2vec)
m = eval(base_model).Model(nlayers, data.vocab_size, data.num_chars, W_init,
regularizer, rlambda, nhidden, embed_dim, dropout, train_emb, subsample,
char_dim, use_feat, data.dictionary[4])
print("training ...")
num_iter = 0
max_acc = 0.
deltas = []
test_acc = 0.
logger = open(save_path+'/log','a',0)
# if os.path.isfile('%s/best_model.p'%save_path):
# print('loading previously saved model')
# m.load_model('%s/best_model.p'%save_path)
# else:
# print('saving init model')
# m.save_model('%s/model_init.p'%save_path)
# print('loading init model')
# m.load_model('%s/model_init.p'%save_path)
for epoch in xrange(NUM_EPOCHS):
estart = time.time()
new_max = False
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames, match_feat, use_char, use_char_q in batch_loader_train:
loss, tr_acc, probs = m.train(dw, dt, qw, qt, c, a, m_dw, m_qw, tt, tm, m_c, cl, match_feat, use_char, use_char_q)
# message = "Epoch %d TRAIN loss=%.4e acc=%.4f elapsed=%.1f" % (
# epoch, loss, tr_acc, time.time()-estart)
# print message
# logger.write(message+'\n')
if num_iter % VALIDATION_FREQ == 0:
total_loss, total_acc, n, n_cand = 0., 0., 0, 0.
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames, match_feat, use_char, use_char_q in batch_loader_val:
outs = m.validate(dw, dt, qw, qt, c, a,
m_dw, m_qw, tt, tm, m_c, cl, match_feat, use_char, use_char_q)
loss, acc, probs = outs[:3]
bsize = dw.shape[0]
total_loss += bsize*loss
total_acc += bsize*acc
n += bsize
val_acc = total_acc/n
if val_acc > max_acc:
max_acc = val_acc
m.save_model('%s/best_model.p'%save_path)
temp_acc, temp_n = 0.0, 0
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames, match_feat, use_char, use_char_q in batch_loader_test:
outs = m.validate(dw, dt, qw, qt, c, a,
m_dw, m_qw, tt, tm, m_c, cl, match_feat, use_char, use_char_q)
_, acc, _ = outs[:3]
bsize = dw.shape[0]
temp_acc += bsize * acc
temp_n += bsize
test_acc = temp_acc / temp_n
new_max = True
message = "Epoch %d VAL loss=%.4e acc=%.4f max_acc=%.4f test=%.4f" % (
epoch, total_loss/n, val_acc, max_acc, test_acc)
print message
logger.write(message+'\n')
num_iter += 1
m.save_model('%s/model_%d.p'%(save_path,epoch))
message = "After Epoch %d: Train acc=%.4f, Val acc=%.4f" % (epoch, tr_acc, val_acc)
print message
logger.write(message+'\n')
# learning schedule
if epoch >=2:
m.anneal()
# stopping criterion
if not new_max:
break
logger.close()
def main(load_path, params, mode='test'):
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
dataset = params['dataset']
nlayers = params['nlayers']
train_emb = params['train_emb']
char_dim = params['char_dim']
use_feat = params['use_feat']
gating_fn = params['gating_fn']
ent_setup = params['ent_setup']
data_path = params['data_path']
# save settings
shutil.copyfile('config.py', '%s/config_test.py' % load_path)
use_chars = char_dim > 0
if dataset == "clicr":
dp = DataPreprocessor.DataPreprocessorClicr()
#dataset_path = "/mnt/b5320167-5dbd-4498-bf34-173ac5338c8d/Datasets/bmj_case_reports_data/dataset_json_concept_annotated/"
#dataset_path = "data/"
data = dp.preprocess(data_path,
ent_setup=ent_setup,
no_training_set=True)
elif dataset == "clicr_novice":
dp = DataPreprocessor.DataPreprocessorNovice()
data = dp.preprocess(data_path,
ent_setup=ent_setup,
no_training_set=True)
else:
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(data_path, no_training_set=True)
inv_vocab = data.inv_dictionary
assert os.path.exists(params["test_file"] if mode ==
"test" else params["validation_file"])
print("building minibatch loaders ...")
if mode == 'test':
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.test, BATCH_SIZE)
else:
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.validation, BATCH_SIZE)
f_to_cand = {i[-1]: i[3] for i in batch_loader_test.questions}
print("building network ...")
W_init, embed_dim = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
m = GAReader.Model(nlayers,
data.vocab_size,
data.num_chars,
W_init,
nhidden,
embed_dim,
dropout,
train_emb,
char_dim,
use_feat,
gating_fn,
save_attn=False)
print("model load path")
print('%s/best_model.p' % load_path)
m.load_model('%s/best_model.p' % load_path)
print("testing ...")
pr = np.zeros((len(batch_loader_test.questions),
batch_loader_test.max_num_cand)).astype('float32')
fids, attns = [], []
pred_ans = {}
total_loss, total_acc, n = 0., 0., 0
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames in batch_loader_test:
outs = m.validate(dw, dt, qw, qt, c, a, m_dw, m_qw, tt, tm, m_c, cl)
loss, acc, probs = outs[:3]
attns += [[fnames[0], probs[0, :]] + [o[0, :, :] for o in outs[3:]]
] # store one attention
for f in range(len(fnames)):
pred_cand = probs[f].argmax()
pred_a_ids = f_to_cand[fnames[f]][pred_cand]
pred_a = " ".join([inv_vocab[i] for i in pred_a_ids])
if ent_setup == "ent-anonym" and (dataset == "clicr"
or dataset == "clicr_novice"):
relabeling_dicts = data.test_relabeling_dicts if mode == 'test' else data.val_relabeling_dicts
pred_a = relabeling_dicts[fnames[f]][pred_a]
pred_ans[fnames[f]] = pred_a
bsize = dw.shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
pr[n:n + bsize, :] = probs
fids += fnames
n += bsize
if (params["dataset"] == "clicr" or params["dataset"] == "clicr_plain" or params["dataset"] == "clicr_novice") \
and (mode == 'test' or mode == 'validation'):
print("writing predictions")
preds_data = utils.to_output_preds(pred_ans)
preds_filepath = load_path + '/{}.preds'.format(mode)
utils.write_preds(preds_data, file_name=preds_filepath)
utils.external_eval(preds_filepath,
preds_filepath + ".scores",
params["test_file"]
if mode == "test" else params["validation_file"],
extended=True)
logger = open(load_path + '/log.test', 'a')
message = '%s Loss %.4e acc=%.4f' % (mode.upper(), total_loss / n,
total_acc / n)
print(message)
logger.write(message + '\n')
logger.close()
np.save('%s/%s.probs' % (load_path, mode), np.asarray(pr))
pickle.dump(attns, open('%s/%s.attns' % (load_path, mode), 'wb'))
f = open('%s/%s.ids' % (load_path, mode), 'w')
for item in fids:
f.write(item + '\n')
f.close()
def main(save_path, params):
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
sub2vec = params['sub2vec']
subdict = params['subdic']
dataset = params['data']
nlayers = params['nlayers']
train_emb = params['train_emb']
sub_dim = params['sub_dim']
use_feat = params['use_feat']
gating_fn = params['gating_fn']
# save settings
shutil.copyfile('config.py', '%s/config.py' % save_path)
use_subs = sub_dim > 0
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(dataset,
no_training_set=False,
use_subs=use_subs,
subdict=subdict)
print "building minibatch loaders ...", datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
batch_loader_train = MiniBatchLoader.MiniBatchLoader(data.training,
BATCH_SIZE,
sample=1)
batch_loader_val = MiniBatchLoader.MiniBatchLoader(data.validation,
BATCH_SIZE)
print "building network ...", datetime.now().strftime('%Y-%m-%d %H:%M:%S')
W_init, embed_dim, = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
S_init, sub_dim = Helpers.load_sub_embeddings(data.dictionary[1], sub2vec)
m = model.Model(nlayers, data.vocab_size, data.num_chars, W_init, S_init,
nhidden, embed_dim, dropout, train_emb, sub_dim, use_feat,
gating_fn)
print "training ...", datetime.now().strftime('%Y-%m-%d %H:%M:%S')
num_iter = 0
max_acc = 0.
deltas = []
logger = open(save_path + '/log', 'a', 0)
if os.path.isfile('%s/best_model.p' % save_path):
print 'loading previously saved model', datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
m.load_model('%s/best_model.p' % save_path)
print "model loaded"
else:
print 'saving init model', datetime.now().strftime('%Y-%m-%d %H:%M:%S')
m.save_model('%s/model_init.p' % save_path)
print 'loading init model', datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
m.load_model('%s/model_init.p' % save_path)
for epoch in xrange(NUM_EPOCHS):
print "epochs training ...", datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
estart = time.time()
new_max = False
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames in batch_loader_train:
loss, tr_acc, probs = m.train(dw, dt, qw, qt, c, a, m_dw, m_qw, tt,
tm, m_c, cl)
message = "Epoch %d TRAIN loss=%.4e acc=%.4f elapsed=%.1f" % (
epoch, loss, tr_acc, time.time() - estart)
print message
logger.write(message + '\n')
num_iter += 1
if num_iter % VALIDATION_FREQ == 0:
total_loss, total_acc, n, n_cand = 0., 0., 0, 0.
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames in batch_loader_val:
outs = m.validate(dw, dt, qw, qt, c, a, m_dw, m_qw, tt, tm,
m_c, cl)
loss, acc, probs = outs[:3]
bsize = dw.shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
n += bsize
print('validate on ', str(n) + 'validation data')
val_acc = total_acc / n
if val_acc > max_acc:
max_acc = val_acc
m.save_model('%s/best_model.p' % save_path)
new_max = True
message = "Epoch %d VAL loss=%.4e acc=%.4f max_acc=%.4f" % (
epoch, total_loss / n, val_acc, max_acc)
print message
logger.write(message + '\n')
m.save_model('%s/model_%d.p' % (save_path, epoch))
message = "After Epoch %d: Train acc=%.4f, Val acc=%.4f" % (
epoch, tr_acc, val_acc)
print message
logger.write(message + '\n')
# learning schedule
if epoch >= 2:
m.anneal()
# stopping criterion
if not new_max:
break
logger.close()
def main(save_path, params, mode='train'):
word2vec = params['word2vec']
dataset = params['dataset']
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess_rc(params, dataset)
print("building minibatch loaders ...")
batch_loader_train = MiniBatchLoader.MiniBatchLoaderMention(
params, data.training, params['batch_size'])
batch_loader_val = MiniBatchLoader.MiniBatchLoaderMention(
params,
data.validation,
params['batch_size'],
shuffle=False,
ensure_answer=False)
batch_loader_test = MiniBatchLoader.MiniBatchLoaderMention(
params,
data.test,
params['batch_size'],
shuffle=False,
ensure_answer=False)
print("building network ...")
W_init, embed_dim, = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
m = GA.Model(params, W_init, embed_dim)
print("training ...")
num_iter = 0
max_acc = 0.0
min_loss = 1e5
logger = open(save_path + '/log', 'a', 0)
train_writer = tf.summary.FileWriter(os.path.join(save_path, 'train'))
val_writer = tf.summary.FileWriter(os.path.join(save_path, 'val'))
if params['reload_']:
print('loading previously saved model')
saves = pkl.load(open('%s/checkpoints.p' % save_path))
m.load_model('%s/best_model.p' % save_path, saves[-1])
# train
if mode == 'train':
saves = []
for epoch in xrange(params['num_epochs']):
estart = time.time()
stop_flag = False
for example in batch_loader_train:
loss, tr_acc, probs, summary = m.train(*example[:-2])
if num_iter % params['logging_frequency'] == 0:
message = (
"Epoch %d TRAIN loss=%.4e acc=%.4f elapsed=%.1f" %
(epoch, loss, tr_acc, time.time() - estart))
print(message)
logger.write(message + '\n')
train_writer.add_summary(summary, num_iter)
num_iter += 1
if num_iter % params['validation_frequency'] == 0:
total_loss, total_acc, n = 0., 0., 0.
for example in batch_loader_val:
outs = m.validate(*example[:-2])
loss, acc, probs = outs[:3]
bsize = example[0].shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
n += bsize
val_acc = total_acc / n
print("11111111111 ", val_acc)
if val_acc > max_acc:
max_acc = val_acc
save_id = num_iter
print("111111111111111111111111111111")
sv = m.save_model('%s/best_model.p' % save_path,
save_id)
saves.append(save_id)
new_max = True
val_loss = total_loss / n
message = "Epoch %d VAL loss=%.4e acc=%.4f max_acc=%.4f" % (
epoch, val_loss, val_acc, max_acc)
print(message)
logger.write(message + '\n')
_add_summary(val_writer, val_loss, "loss", num_iter)
_add_summary(val_writer, val_acc, "accuracy", num_iter)
# stopping
if val_loss < min_loss: min_loss = val_loss
if params['stopping_criterion'] and (
val_loss - min_loss) / min_loss > 0.3:
stop_flag = True
break
if num_iter % params["anneal_frequency"] == 0:
m.anneal()
#m.save_model('%s/model_%d.p'%(save_path,epoch))
message = "After Epoch %d: Train acc=%.4f, Val acc=%.4f" % (
epoch, tr_acc, max_acc)
print(message)
logger.write(message + '\n')
if stop_flag: break
# record all saved models
pkl.dump(saves, open('%s/checkpoints.p' % save_path, 'w'))
# test
mode = 'test' if mode in ['train', 'test'] else 'val'
print("testing ...")
try:
saves = pkl.load(open('%s/checkpoints.p' % save_path))
print('%s/checkpoints.p' % save_path)
except IOError:
def _to_num(foo):
try:
num = int(foo)
except ValueError:
return None
return num
saves = []
for directory in os.listdir(save_path):
if not os.path.isdir(os.path.join(save_path, directory)): continue
num = _to_num(directory)
if num is None: continue
saves.append(num)
saves = sorted(saves)
print("saves111111", saves)
if not saves:
print("No models saved during training!")
return
print('loading model')
m.load_model('%s/best_model.p' % save_path, saves[-1])
total_loss, total_acc, n = 0., 0., 0
answer_structure = {}
idict = data.inv_dictionary
for example in batch_loader_val:
outs = m.validate(*example[:-2])
loss, acc, probs = outs[:3]
pred_indices = np.argmax(probs, axis=1)
for i in range(len(example[-1])):
cname = str(example[-1][i]).strip()
gt_answer = example[10][i]
answer_structure[cname] = (pred_indices[i], gt_answer, probs[i, :])
bsize = example[0].shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
n += bsize
test_acc = total_acc / n
test_loss = total_loss / n
message = "TEST loss=%.4e acc=%.4f" % (test_loss, test_acc)
print(message)
logger.write(message + '\n')
pkl.dump(answer_structure,
open(os.path.join(save_path, "test_answer_structure.p"), "w"))
logger.close()
# clean up
print("Cleaning up saved models ...")
def main(load_path, params, mode='test'):
nhidden = params['nhidden']
dropout = params['dropout']
word2vec = params['word2vec']
dataset = params['dataset']
nlayers = params['nlayers']
train_emb = params['train_emb']
char_dim = params['char_dim']
use_feat = params['use_feat']
gating_fn = params['gating_fn']
dp = DataPreprocessor.DataPreprocessor()
data = dp.preprocess(dataset, no_training_set=True)
inv_vocab = data.inv_dictionary
print("building minibatch loaders ...")
if mode == 'test':
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.test, BATCH_SIZE)
else:
batch_loader_test = MiniBatchLoader.MiniBatchLoader(
data.validation, BATCH_SIZE)
print("building network ...")
W_init, embed_dim = Helpers.load_word2vec_embeddings(
data.dictionary[0], word2vec)
m = Reader.Model(nlayers,
data.vocab_size,
data.num_chars,
W_init,
nhidden,
embed_dim,
dropout,
train_emb,
char_dim,
use_feat,
gating_fn,
save_attn=True)
m.load_model('%s/best_model.p' % load_path)
print("testing ...")
pr = np.zeros((len(batch_loader_test.questions),
batch_loader_test.max_num_cand)).astype('float32')
fids, attns = [], []
total_loss, total_acc, n = 0., 0., 0
result = {}
for dw, dt, qw, qt, a, m_dw, m_qw, tt, tm, c, m_c, cl, fnames in batch_loader_test:
outs = m.validate(dw, dt, qw, qt, c, a, m_dw, m_qw, tt, tm, m_c, cl)
loss, acc, probs = outs[:3]
attns += [[fnames[0], probs[0, :]] + [o[0, :, :] for o in outs[3:]]
] # store one attention
bsize = dw.shape[0]
total_loss += bsize * loss
total_acc += bsize * acc
pr[n:n + bsize, :] = probs
fids += fnames
n += bsize
answer = probs.argmax(1)
for it in range(len(fnames)):
tid = fnames[it].split('/')[-1].split('.')[0].strip()
result[eval(tid)] = answer[it]
print tid, answer[it]
print('probs----', probs)
#print('a----', a)
print('fnames----', fnames)
print len(result)
with open('raw.txt', 'w') as ff:
for i in range(1, 2501):
ff.write(str(result[i]) + '\n')
logger = open(load_path + '/log', 'a', 0)
message = '%s Loss %.4e acc=%.4f' % (mode.upper(), total_loss / n,
total_acc / n)
print message
logger.write(message + '\n')
logger.close()
np.save('%s/%s.probs' % (load_path, mode), np.asarray(pr))
pkl.dump(attns, open('%s/%s.attns' % (load_path, mode), 'w'))
f = open('%s/%s.ids' % (load_path, mode), 'w')
for item in fids:
f.write(item + '\n')
f.close()