def predict(self, predict_data_lines):
if self.predict_queue is None:
self.predict_queue = PathContextReader.PathContextReader(word_to_index=self.word_to_index,
path_to_index=self.path_to_index,
target_word_to_index=self.target_word_to_index,
config=self.config, is_evaluating=True)
self.predict_placeholder = self.predict_queue.get_input_placeholder()
self.predict_top_words_op, self.predict_top_values_op, self.predict_original_names_op, \
self.attention_weights_op, self.predict_source_string, self.predict_path_string, self.predict_path_target_string, self.predict_code_vectors = \
self.build_test_graph(self.predict_queue.get_filtered_batches(), normalize_scores=True)
self.initialize_session_variables(self.sess)
self.saver = tf.train.Saver()
self.load_model(self.sess)
code_vectors = []
results = []
for batch in common.split_to_batches(predict_data_lines, 1):
top_words, top_scores, original_names, attention_weights, source_strings, path_strings, target_strings, batch_code_vectors = self.sess.run(
[self.predict_top_words_op, self.predict_top_values_op, self.predict_original_names_op,
self.attention_weights_op, self.predict_source_string, self.predict_path_string,
self.predict_path_target_string, self.predict_code_vectors],
feed_dict={self.predict_placeholder: batch})
top_words, original_names = common.binary_to_string_matrix(top_words), common.binary_to_string_matrix(
original_names)
# Flatten original names from [[]] to []
attention_per_path = self.get_attention_per_path(source_strings, path_strings, target_strings,
attention_weights)
original_names = [w for l in original_names for w in l]
results.append((original_names[0], top_words[0], top_scores[0], attention_per_path))
if self.config.EXPORT_CODE_VECTORS:
code_vectors.append(batch_code_vectors)
if len(code_vectors) > 0:
code_vectors = np.vstack(code_vectors)
return results, code_vectors
def predict_dataset(self):
if self.predict_queue is None:
self.predict_queue = PathContextReader.PathContextReader(word_to_index=self.word_to_index,
path_to_index=self.path_to_index,
target_word_to_index=self.target_word_to_index,
config=self.config, is_evaluating=True)
self.predict_placeholder = self.predict_queue.get_input_placeholder()
self.predict_top_words_op, self.predict_top_values_op, self.predict_original_names_op, \
self.attention_weights_op, self.predict_source_string, self.predict_path_string, self.predict_path_target_string = \
self.build_test_graph(self.predict_queue.get_filtered_batches(), normalize_scores=True)
self.initialize_session_variables(self.sess)
self.saver = tf.train.Saver()
self.load_model(self.sess)
self.predict_data_lines = common.load_file_lines(self.config.TEST_PATH)
with open(self.config.OUTPUT_FILE, 'a+') as output_file:
batch_num = 0
for batch in common.split_to_batches(self.predict_data_lines, self.config.TEST_BATCH_SIZE):
batch_num += 1
top_words, top_scores, original_names, attention_weights, source_strings, path_strings, target_strings = self.sess.run(
[self.predict_top_words_op, self.predict_top_values_op, self.predict_original_names_op,
self.attention_weights_op, self.predict_source_string, self.predict_path_string,
self.predict_path_target_string],
feed_dict={self.predict_placeholder: batch})
top_words, original_names = common.binary_to_string_matrix(top_words), common.binary_to_string_matrix(original_names)
original_names = [w for l in original_names for w in l]
for res_index in range(len(original_names)):
output_file.write("%s;" % (original_names[res_index],))
output_file.write(";".join(top_words[res_index]))
output_file.write("\n")
print("Finished batch %s with %s elements" % (batch_num, len(original_names)))
def train(self):
print('Starting training')
start_time = time.time()
batch_num = 0
sum_loss = 0
multi_batch_start_time = time.time()
num_batches_to_evaluate = max(int(
self.config.NUM_EXAMPLES / self.config.BATCH_SIZE * self.config.SAVE_EVERY_EPOCHS), 1)
self.queue_thread = PathContextReader.PathContextReader(word_to_index=self.word_to_index,
path_to_index=self.path_to_index,
target_word_to_index=self.target_word_to_index,
config=self.config)
optimizer, train_loss = self.build_training_graph(self.queue_thread.input_tensors())
self.saver = tf.train.Saver(max_to_keep=self.config.MAX_TO_KEEP)
self.initialize_session_variables(self.sess)
print('Initalized variables')
if self.config.LOAD_PATH:
self.load_model(self.sess)
with self.queue_thread.start(self.sess):
time.sleep(1)
print('Started reader...')
try:
while True:
batch_num += 1
_, batch_loss = self.sess.run([optimizer, train_loss])
sum_loss += batch_loss
if batch_num % self.num_batches_to_log == 0:
self.trace(sum_loss, batch_num, multi_batch_start_time)
print('Number of waiting examples in queue: %d' % self.sess.run(
"shuffle_batch/random_shuffle_queue_Size:0"))
sum_loss = 0
multi_batch_start_time = time.time()
if batch_num % num_batches_to_evaluate == 0:
epoch_num = int((batch_num / num_batches_to_evaluate) * self.config.SAVE_EVERY_EPOCHS)
save_target = self.config.SAVE_PATH + '_iter' + str(epoch_num)
self.save_model(self.sess, save_target)
print('Saved after %d epochs in: %s' % (epoch_num, save_target))
results, precision, recall, f1 = self.evaluate()
print('Accuracy after %d epochs: %s' % (epoch_num, results[:5]))
print('After ' + str(epoch_num) + ' epochs: Precision: ' + str(precision) + ', recall: ' + str(
recall) + ', F1: ' + str(f1))
except tf.errors.OutOfRangeError:
print('Done training')
if self.config.SAVE_PATH:
self.save_model(self.sess, self.config.SAVE_PATH)
print('Model saved in file: %s' % self.config.SAVE_PATH)
elapsed = int(time.time() - start_time)
print("Training time: %sH:%sM:%sS\n" % ((elapsed // 60 // 60), (elapsed // 60) % 60, elapsed % 60))
def train(self):
with self.logger:
print('Starting training')
start_time = time.time()
multi_batch_start_time = time.time()
num_batches_per_epoch = max(int(self.config.NUM_EXAMPLES / self.config.BATCH_SIZE), 1)
num_batches_to_evaluate = num_batches_per_epoch * self.config.SAVE_EVERY_EPOCHS
self.queue_thread = PathContextReader.PathContextReader(word_to_index=self.word_to_index,
path_to_index=self.path_to_index,
target_word_to_index=self.target_word_to_index,
config=self.config)
optimizer, train_loss = self.build_training_graph(self.queue_thread.input_tensors())
self.saver = tf.train.Saver(max_to_keep=self.config.MAX_TO_KEEP)
self.initialize_session_variables(self.sess)
print('Initalized variables')
if self.config.LOAD_PATH:
self.load_model(self.sess)
with self.queue_thread.start(self.sess):
time.sleep(1)
print('Started reader...')
try:
while True:
_, batch_loss = self.sess.run([optimizer, train_loss])
self.logger.increment_batch()
self.logger.log_loss(batch_loss)
if self.logger.eval_and_log():
epoch_num = int((self.logger.current_batch / num_batches_to_evaluate) * self.config.SAVE_EVERY_EPOCHS)
save_target = self.config.SAVE_PATH + '_iter' + str(epoch_num)
self.save_model(self.sess, save_target)
print('Saved after %d epochs in: %s' % (epoch_num, save_target))
except tf.errors.OutOfRangeError:
print('Done training')
if self.config.SAVE_PATH:
self.save_model(self.sess, self.config.SAVE_PATH)
print('Model saved in file: %s' % self.config.SAVE_PATH)
elapsed = int(time.time() - start_time)
print("Training time: %sH:%sM:%sS\n" % ((elapsed // 60 // 60), (elapsed // 60) % 60, elapsed % 60))
def evaluate(self):
eval_start_time = time.time()
if self.eval_queue is None:
self.eval_queue = PathContextReader.PathContextReader(word_to_index=self.word_to_index,
path_to_index=self.path_to_index,
target_word_to_index=self.target_word_to_index,
config=self.config, is_evaluating=True)
self.eval_placeholder = self.eval_queue.get_input_placeholder()
self.eval_top_words_op, self.eval_top_values_op, self.eval_original_names_op, _, _, _, _, self.eval_code_vectors = \
self.build_test_graph(self.eval_queue.get_filtered_batches())
self.saver = tf.train.Saver()
if self.config.LOAD_PATH and not self.config.TRAIN_PATH:
self.initialize_session_variables(self.sess)
self.load_model(self.sess)
if self.config.RELEASE:
release_name = self.config.LOAD_PATH + '.release'
print('Releasing model, output model: %s' % release_name )
self.saver.save(self.sess, release_name )
return None
if self.eval_data_lines is None:
print('Loading test data from: ' + self.config.TEST_PATH)
self.eval_data_lines = common.load_file_lines(self.config.TEST_PATH)
print('Done loading test data')
with open('log.txt', 'w') as output_file:
if self.config.EXPORT_CODE_VECTORS:
code_vectors_file = open(self.config.TEST_PATH + '.vectors', 'w')
num_correct_predictions = np.zeros(self.topk)
total_predictions = 0
total_prediction_batches = 0
true_positive, false_positive, false_negative = 0, 0, 0
start_time = time.time()
for batch in common.split_to_batches(self.eval_data_lines, self.config.TEST_BATCH_SIZE):
top_words, top_scores, original_names, code_vectors = self.sess.run(
[self.eval_top_words_op, self.eval_top_values_op, self.eval_original_names_op, self.eval_code_vectors],
feed_dict={self.eval_placeholder: batch})
top_words, original_names = common.binary_to_string_matrix(top_words), common.binary_to_string_matrix(
original_names)
# Flatten original names from [[]] to []
original_names = [w for l in original_names for w in l]
num_correct_predictions = self.update_correct_predictions(num_correct_predictions, output_file,
zip(original_names, top_words))
true_positive, false_positive, false_negative = self.update_per_subtoken_statistics(
zip(original_names, top_words),
true_positive, false_positive, false_negative)
total_predictions += len(original_names)
total_prediction_batches += 1
if self.config.EXPORT_CODE_VECTORS:
self.write_code_vectors(code_vectors_file, code_vectors)
if total_prediction_batches % self.num_batches_to_log == 0:
elapsed = time.time() - start_time
# start_time = time.time()
self.trace_evaluation(output_file, num_correct_predictions, total_predictions, elapsed, len(self.eval_data_lines))
print('Done testing, epoch reached')
output_file.write(str(num_correct_predictions / total_predictions) + '\n')
if self.config.EXPORT_CODE_VECTORS:
code_vectors_file.close()
elapsed = int(time.time() - eval_start_time)
precision, recall, f1 = self.calculate_results(true_positive, false_positive, false_negative)
print("Evaluation time: %sH:%sM:%sS" % ((elapsed // 60 // 60), (elapsed // 60) % 60, elapsed % 60))
del self.eval_data_lines
self.eval_data_lines = None
return num_correct_predictions / total_predictions, precision, recall, f1
