def get_attention_per_path(self, source_strings, path_strings, target_strings, attention_weights):
attention_weights = np.squeeze(attention_weights) # (max_contexts, )
attention_per_context = {}
for source, path, target, weight in zip(source_strings, path_strings, target_strings, attention_weights):
string_triplet = (
common.binary_to_string(source), common.binary_to_string(path), common.binary_to_string(target))
attention_per_context[string_triplet] = weight
return attention_per_context
def _get_embed_per_context(
self, path_source_strings: Iterable[str], path_strings: Iterable[str], path_target_strings: Iterable[str],
embeddings: Iterable[np.ndarray]) -> Dict[Tuple[str, str, str], np.ndarray]:
embed_per_context: Dict[Tuple[str, str, str], np.ndarray] = {}
# iterate over contexts
for path_source, path, path_target, embed in \
zip(path_source_strings, path_strings, path_target_strings, embeddings):
string_context_triplet = (common.binary_to_string(path_source),
common.binary_to_string(path),
common.binary_to_string(path_target))
embed_per_context[string_context_triplet] = embed
return embed_per_context
def _get_attention_weight_per_context(
self, path_source_strings: Iterable[str], path_strings: Iterable[str], path_target_strings: Iterable[str],
attention_weights: Iterable[float]) -> Dict[Tuple[str, str, str], float]:
attention_weights = np.squeeze(attention_weights, axis=-1) # (max_contexts, )
attention_per_context: Dict[Tuple[str, str, str], float] = {}
# shape of path_source_strings, path_strings, path_target_strings, attention_weights is (max_contexts, )
# iterate over contexts
for path_source, path, path_target, weight in \
zip(path_source_strings, path_strings, path_target_strings, attention_weights):
string_context_triplet = (common.binary_to_string(path_source),
common.binary_to_string(path),
common.binary_to_string(path_target))
attention_per_context[string_context_triplet] = weight
return attention_per_context
def predict(self, predict_data_rows: Iterable[str]) -> List[ModelPredictionResults]:
predict_input_reader = self._create_data_reader(estimator_action=EstimatorAction.Predict)
input_iterator = predict_input_reader.process_and_iterate_input_from_data_lines(predict_data_rows)
all_model_prediction_results = []
for input_row in input_iterator:
# perform the actual prediction and get raw results.
input_for_predict = input_row[0][:4] # we want only the relevant input vectors (w.o. the targets).
prediction_results = self.keras_model_predict_function(input_for_predict)
# make `input_row` and `prediction_results` easy to read (by accessing named fields).
prediction_results = KerasPredictionModelOutput(
*common.squeeze_single_batch_dimension_for_np_arrays(prediction_results))
input_row = _KerasModelInputTensorsFormer(
estimator_action=EstimatorAction.Predict).from_model_input_form(input_row)
input_row = ReaderInputTensors(*common.squeeze_single_batch_dimension_for_np_arrays(input_row))
# calculate the attention weight for each context
attention_per_context = self._get_attention_weight_per_context(
path_source_strings=input_row.path_source_token_strings,
path_strings=input_row.path_strings,
path_target_strings=input_row.path_target_token_strings,
attention_weights=prediction_results.attention_weights
)
# store the calculated prediction results in the wanted format.
model_prediction_results = ModelPredictionResults(
original_name=common.binary_to_string(input_row.target_string.item()),
topk_predicted_words=common.binary_to_string_list(prediction_results.topk_predicted_words),
topk_predicted_words_scores=prediction_results.topk_predicted_words_scores,
attention_per_context=attention_per_context,
code_vector=prediction_results.code_vectors)
all_model_prediction_results.append(model_prediction_results)
return all_model_prediction_results
def _get_embed_per_path(self, path_strings: Iterable[str],
embeddings: Iterable[np.ndarray]) -> Dict[str, np.ndarray]:
embed_per_path: Dict[str, np.ndarray] = {}
# iterate over contexts
for path, embed in zip(path_strings, embeddings):
embed_per_path[common.binary_to_string(path)] = embed
return embed_per_path
def predict(self, predict_data_lines: Iterable[str]) -> List[ModelPredictionResults]:
if self.predict_reader is None:
self.predict_reader = PathContextReader(vocabs=self.vocabs,
model_input_tensors_former=_TFEvaluateModelInputTensorsFormer(),
config=self.config, estimator_action=EstimatorAction.Predict)
self.predict_placeholder = tf.compat.v1.placeholder(tf.string)
reader_output = self.predict_reader.process_input_row(self.predict_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_tf_test_graph(reader_output, normalize_scores=True)
self._initialize_session_variables()
self.saver = tf.compat.v1.train.Saver()
self._load_inner_model(sess=self.sess)
prediction_results: List[ModelPredictionResults] = []
for line in predict_data_lines:
batch_top_words, batch_top_scores, batch_original_name, batch_attention_weights, batch_path_source_strings,\
batch_path_strings, batch_path_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: line})
# shapes:
# batch_top_words, top_scores: (batch, top_k)
# batch_original_name: (batch, )
# batch_attention_weights: (batch, max_context, 1)
# batch_path_source_strings, batch_path_strings, batch_path_target_strings: (batch, max_context)
# batch_code_vectors: (batch, code_vector_size)
# remove first axis: (batch=1, ...)
assert all(tensor.shape[0] == 1 for tensor in (batch_top_words, batch_top_scores, batch_original_name,
batch_attention_weights, batch_path_source_strings,
batch_path_strings, batch_path_target_strings,
batch_code_vectors))
top_words = np.squeeze(batch_top_words, axis=0)
top_scores = np.squeeze(batch_top_scores, axis=0)
original_name = batch_original_name[0]
attention_weights = np.squeeze(batch_attention_weights, axis=0)
path_source_strings = np.squeeze(batch_path_source_strings, axis=0)
path_strings = np.squeeze(batch_path_strings, axis=0)
path_target_strings = np.squeeze(batch_path_target_strings, axis=0)
code_vectors = np.squeeze(batch_code_vectors, axis=0)
top_words = common.binary_to_string_list(top_words)
original_name = common.binary_to_string(original_name)
attention_per_context = self._get_attention_weight_per_context(
path_source_strings, path_strings, path_target_strings, attention_weights)
prediction_results.append(ModelPredictionResults(
original_name=original_name,
topk_predicted_words=top_words,
topk_predicted_words_scores=top_scores,
attention_per_context=attention_per_context,
code_vector=(code_vectors if self.config.EXPORT_CODE_VECTORS else None)
))
return prediction_results
