def decode(self, serializedInstance):
label = serializedInstance['label']
print("serializedInstance sentence : " +
serializedInstance["sentence"])
dataset = self.preprocess_dataset(serializedInstance, self.label2id,
self.word2id, self.feature2id)
batcher = Batcher(dataset["storage"], dataset["data"],
dataset["data"].shape[0], 10, self.id2vec)
context_data, mention_representation_data, target_data, feature_data = batcher.next(
)
scores = self.model.predict(context_data, mention_representation_data,
feature_data)
score = scores[0]
label_id, label_score = max(enumerate(list(score)), key=lambda x: x[1])
if label_score >= self.threshold:
predicted_label = self.id2label[label_id]
else:
predicted_label = "OTHER"
print("predicted_label: " + predicted_label + ", label_id: " +
str(label_id) + ", score: " + str(label_score))
return {'label': predicted_label, 'confidence': str(label_score)}
train_batcher.shuffle()
for epoch in range(num_epoch):
loss = 0.0
print "Epoch %d" % epoch
for i in range(step_per_epoch):
random_ = np.random.random_sample()
if not use_concepts:
input_x, y, targets, lengths = train_batcher.next()
else:
input_x, y, targets, lengths, cpts, cpts_len = train_batcher.next()
cpts = autograd.Variable(torch.from_numpy(cpts).long())
cpts_len = autograd.Variable(torch.from_numpy(cpts_len))
input_x = autograd.Variable(torch.from_numpy(input_x).long())
y = autograd.Variable(torch.from_numpy(y)).long()
targets = autograd.Variable(torch.from_numpy(targets).float())
args.context_length, dicts["id2vec"])
dev_batcher = Batcher(dev_dataset["storage"], dev_dataset["data"], 2202,
args.context_length, dicts["id2vec"]) #2202 10000
test_batcher = Batcher(test_dataset["storage"], test_dataset["data"], 8885,
args.context_length, dicts["id2vec"]) #8885 563
# saver
saver = tf.train.Saver()
# session
sess = tf.Session()
sess.run(init)
[x_context_data, x_target_mean_data, y_data,
feature_data] = test_batcher.next()
test_feed = {
y: y_data,
keep_prob_context: [1],
keep_prob_target: [1],
feature: feature_data
}
for i in range(args.context_length * 2 + 1):
test_feed[x_context[i]] = x_context_data[:, i, :]
test_feed[x_target] = x_target_mean_data
[x_context_data, x_target_mean_data, y_data, feature_data] = dev_batcher.next()
dev_feed = {
y: y_data,
keep_prob_context: [1],
keep_prob_target: [1],
dicts = joblib.load("../../data/dict_"+DATA)
print "obtaining batch..."
train_batcher = Batcher(train_dataset["storage"],train_data,BATCH_SIZE,args.context_length,dicts["id2vec"])
dev_batcher = Batcher(dev_dataset["storage"],dev_dataset["data"],2202,args.context_length,dicts["id2vec"]) #2202 10000
test_batcher = Batcher(test_dataset["storage"],test_dataset["data"],8885,args.context_length,dicts["id2vec"]) #8885 563
# saver
saver = tf.train.Saver()
# session
sess = tf.Session()
sess.run(init)
[x_context_data, x_target_mean_data, y_data, feature_data] = test_batcher.next()
test_feed = {y:y_data,keep_prob_context:[1],keep_prob_target:[1],feature:feature_data}
for i in range(args.context_length*2+1):
test_feed[x_context[i]] = x_context_data[:,i,:]
test_feed[x_target] = x_target_mean_data
[x_context_data, x_target_mean_data, y_data, feature_data] = dev_batcher.next()
dev_feed = {y:y_data,keep_prob_context:[1],keep_prob_target:[1],feature:feature_data}
for i in range(args.context_length*2+1):
dev_feed[x_context[i]] = x_context_data[:,i,:]
dev_feed[x_target] = x_target_mean_data
ite = 0
train_batcher.shuffle()
def main(args):
mini_str = '/mini' if args.mini else '' # path to mini dataset
version_suffix = '_v2.0' if args.squad_version == 2.0 else '' # gets proper dataset version (1.1 or 2.0)
# Prepare output directory under ./weights/ to store model-specific data including weights
out_dir = 'weights/%s' % args.experiment
if os.path.exists(out_dir):
print(
'Warning - you are overwriting previous experiment %s. Hit Ctrl Z to abort.\n'
% args.experiment)
shutil.rmtree(out_dir)
os.mkdir(out_dir)
logger = open(os.path.join(out_dir, 'log.txt'), 'w')
print_and_log(
'Timestamp = %s for %s\n' %
(datetime.strftime(datetime.now(), '%m/%d/%Y %H:%M'), args.experiment),
logger)
# Load Dev Data and save it to this model's weights dir
print_and_log('Loading v%s Dev Data...' % args.squad_version, logger)
dev_data = load_pk('preprocess/data%s/squad_dev_trees%s.npy' %
(mini_str, version_suffix))
dev_batcher = Batcher(dev_data,
is_train=False,
target_batch_size=args.batch_size)
save_as_pk(dev_batcher, os.path.join(out_dir, 'dev_batcher.npy'))
print_and_log('Loaded Dev Data...', logger)
# Load Train Data and save it to this model's weights dir
print_and_log('Loading v%s Train Data...' % args.squad_version, logger)
train_data = load_pk('preprocess/data%s/squad_train_trees%s.npy' %
(mini_str, version_suffix))
train_batcher = Batcher(train_data,
is_train=True,
target_batch_size=args.batch_size)
print_and_log('Loaded Train Data...', logger)
# Create models and optimizers
span_extractor = TreeLSTM(use_cuda=args.cuda)
answer_verifier = AnswerVerifier(use_cuda=args.cuda)
if args.cuda:
span_extractor.cuda()
answer_verifier.cuda()
span_extractor_grad_params = filter(lambda p: p.requires_grad,
span_extractor.parameters())
span_extractor_optimizer = optim.Adam(span_extractor_grad_params,
args.span_extractor_lr)
answer_verifier_grad_params = filter(lambda p: p.requires_grad,
answer_verifier.parameters())
answer_verifier_optimizer = optim.Adam(answer_verifier_grad_params,
args.answer_verifier_lr)
# Determines if question is answerable or not
answer_verifier_logistic_loss = BCEWithLogitsLoss(
pos_weight=span_extractor.cudify(torch.FloatTensor([0.5])))
best_span_f1 = -1 # Keep track of which epoch model achieves highest span level F1 on the dev set
best_answer_verifier_accuracy = -1
best_span_epoch = -1
best_answer_verifier_epoch = -1
for epoch_idx in range(args.epochs):
print_and_log('Starting Epoch %d...' % (epoch_idx + 1), logger)
train_evaluator = Evaluator(
'train'
) # Stores predictions and returns evaluation string at the end of epoch
dev_evaluator = Evaluator('dev')
start_time = time()
span_extractor.train()
answer_verifier.train()
while train_batcher.has_next():
# Clear gradients and get next batch
span_extractor_optimizer.zero_grad()
answer_verifier_optimizer.zero_grad()
joint_loss = _run_batch(
batch=train_batcher.next(),
span_extractor=span_extractor,
span_extractor_optimizer=span_extractor_optimizer,
answer_verifier=answer_verifier,
answer_verifier_optimizer=answer_verifier_optimizer,
answer_verifier_logistic_loss=answer_verifier_logistic_loss,
evaluator=train_evaluator)
joint_loss.backward()
# Make a gradient step
span_extractor_optimizer.step()
answer_verifier_optimizer.step()
print_and_log('Took %s.' % format_seconds(time() - start_time), logger)
print_and_log('\t' + train_evaluator.eval_string(), logger)
span_extractor.eval()
answer_verifier.eval()
while dev_batcher.has_next():
_run_batch(
batch=dev_batcher.next(),
span_extractor=span_extractor,
span_extractor_optimizer=span_extractor_optimizer,
answer_verifier=answer_verifier,
answer_verifier_optimizer=answer_verifier_optimizer,
answer_verifier_logistic_loss=answer_verifier_logistic_loss,
evaluator=dev_evaluator)
print_and_log('\t' + dev_evaluator.eval_string(), logger)
dev_f1 = dev_evaluator.span_f1()
if dev_f1 > best_span_f1:
best_span_f1 = dev_f1
best_span_epoch = epoch_idx + 1
torch.save(span_extractor,
os.path.join(out_dir, 'best_span_extractor.tar'))
dev_answer_verifier_accuracy = dev_evaluator.avg_answer_accuracy()
if dev_answer_verifier_accuracy > best_answer_verifier_accuracy:
best_answer_verifier_accuracy = dev_answer_verifier_accuracy
best_answer_verifier_epoch = epoch_idx + 1
torch.save(answer_verifier,
os.path.join(out_dir, 'best_answer_verifier.tar'))
print_and_log(
'\nBest span = %.4f F1 at %d epoch' % (best_span_f1, best_span_epoch),
logger)
print_and_log(
'\nBest answer verifier = %.4f accuracy at %d epoch' %
(best_answer_verifier_accuracy, best_answer_verifier_epoch), logger)
test_batcher = Batcher(test_dataset["storage"],test_dataset["data"],8963,args.context_length,dicts["id2vec"])
# saver
saver = tf.train.Saver()
# session
sess = tf.Session()
sess.run(init)
print "restoring..."
saver.restore(sess, args.model_name)
[x_context_data, x_target_mean_data, y_data] = test_batcher.next()
feed = {y:y_data,keep_prob_context:[1],keep_prob_target:[1]}
for i in range(args.context_length*2+1):
feed[x_context[i]] = x_context_data[:,i,:]
feed[x_target] = x_target_mean_data
scores = sess.run(output, feed_dict = feed)
for score,true_label in zip(scores,y_data):
for label_id,label_score in enumerate(list(true_label)):
if label_score > 0:
print dicts["id2label"][label_id],
print "\t",
lid,ls = max(enumerate(list(score)),key=lambda x: x[1])
print dicts["id2label"][lid],
for label_id,label_score in enumerate(list(score)):
if label_score > 0.5:
