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: