def evaluate_fold(self, test_tensor, test_needs, idx_test):
# execute the rescal algorithm
useNeedTypeSlice = (self.args.rescalsim[2] == 'True')
useConnectionSlice = (self.args.rescalsim[3] == 'True')
A, R = execute_rescal(test_tensor, self.rank, useNeedTypeSlice, useConnectionSlice)
# use the most similar needs per need to predict connections
self.log1()
P_bin = predict_rescal_connections_by_need_similarity(A, self.threshold, self.offers, self.wants, test_needs)
binary_pred = matrix_to_array(P_bin, idx_test)
self.report.add_evaluation_data(self.ground_truth.getArrayFromSliceMatrix(
SparseTensor.CONNECTION_SLICE, idx_test), binary_pred)
if self.args.statistics:
S = similarity_ranking(A)
y_prop = [1.0 - i for i in np.nan_to_num(S[idx_test])]
precision, recall, threshold = m.precision_recall_curve(
self.ground_truth.getArrayFromSliceMatrix(SparseTensor.CONNECTION_SLICE, idx_test), y_prop)
write_precision_recall_curve_file(
self.output_folder + "/statistics/rescalsim_" + self.start_time,
"precision_recall_curve_fold%d.csv" % self.foldNumber, precision, recall, threshold)
TP, FP, threshold = m.roc_curve(self.ground_truth.getArrayFromSliceMatrix(
SparseTensor.CONNECTION_SLICE, idx_test), y_prop)
write_ROC_curve_file(self.output_folder + "/statistics/rescalsim_" + self.start_time,
"ROC_curve_fold%d.csv" % self.foldNumber, TP, FP, threshold)
self.evalDetails.add_statistic_details(self.ground_truth.getSliceMatrix(
SparseTensor.CONNECTION_SLICE), P_bin, idx_test)
def predict_intersect_cosine_rescal(self, input_tensor, test_needs, idx_test, rank,
rescal_threshold, cosine_threshold, useNeedTypeSlice):
wants = input_tensor.getWantIndices()
offers = input_tensor.getOfferIndices()
# execute the cosine algorithm
binary_pred_cosine = cosinus_link_prediciton(input_tensor, test_needs, cosine_threshold, 0.0, False)
# execute the rescal algorithm
A,R = execute_rescal(input_tensor, rank)
P_bin = predict_rescal_connections_by_threshold(A, R, rescal_threshold, offers, wants, test_needs)
# return the intersection of the prediction of both algorithms
binary_pred_cosine = matrix_to_array(binary_pred_cosine, idx_test)
binary_pred_rescal = matrix_to_array(P_bin, idx_test)
binary_pred = [min(binary_pred_cosine[i], binary_pred_rescal[i]) for i in range(len(binary_pred_cosine))]
return binary_pred, binary_pred_cosine, binary_pred_rescal
def evaluate_fold(self, test_tensor, test_needs, idx_test):
self.logEvaluationLine()
binary_pred = cosinus_link_prediciton(test_tensor, test_needs, self.threshold,
self.transitive_threshold, self.weighted)
self.report.add_evaluation_data(self.ground_truth.getArrayFromSliceMatrix(
SparseTensor.CONNECTION_SLICE, idx_test), matrix_to_array(binary_pred, idx_test))
if self.args.statistics:
self.evalDetails.add_statistic_details(
self.ground_truth.getSliceMatrix(SparseTensor.CONNECTION_SLICE),
binary_pred, idx_test)
def evaluate_fold(self, test_tensor, test_needs, idx_test):
# set transitive connections before execution
if (self.args.rescal[3] == 'True'):
self.logger.info('extend connections transitively to the next need for RESCAL learning')
test_tensor = extend_next_hop_transitive_connections(test_tensor)
# execute the rescal algorithm
useNeedTypeSlice = (self.args.rescal[2] == 'True')
A, R = execute_rescal(
test_tensor, self.rank, useNeedTypeSlice, init=self.args.rescal[4],
conv=float(self.args.rescal[5]), lambda_A=float(self.args.rescal[6]),
lambda_R=float(self.args.rescal[7]), lambda_V=float(self.args.rescal[8]))
# evaluate the predictions
self.logger.info('start predict connections ...')
prediction = np.round_(predict_rescal_connections_array(A, R, idx_test), decimals=5)
self.logger.info('stop predict connections')
precision, recall, threshold = m.precision_recall_curve(
self.ground_truth.getArrayFromSliceMatrix(SparseTensor.CONNECTION_SLICE, idx_test), prediction)
optimal_threshold = get_optimal_threshold(recall, precision, threshold, self.args.fbeta)
self.logger.info('optimal RESCAL threshold would be ' + str(optimal_threshold) +
' (for maximum F' + str(self.args.fbeta) + '-score)')
auc = m.auc(recall, precision)
self.AUC_test.append(auc)
self.logger.info('AUC test: ' + str(auc))
# use a fixed threshold to compute several measures
self.log1()
P_bin = predict_rescal_connections_by_threshold(A, R, self.threshold, self.offers, self.wants, test_needs)
binary_pred = matrix_to_array(P_bin, idx_test)
self.report.add_evaluation_data(self.ground_truth.getArrayFromSliceMatrix(
SparseTensor.CONNECTION_SLICE, idx_test), binary_pred)
if self.args.statistics:
write_precision_recall_curve_file(
self.output_folder + "/statistics/rescal_" + self.start_time,
"precision_recall_curve_fold%d.csv" % self.foldNumber, precision, recall, threshold)
TP, FP, threshold = m.roc_curve(self.ground_truth.getArrayFromSliceMatrix(
SparseTensor.CONNECTION_SLICE, idx_test), prediction)
write_ROC_curve_file(self.output_folder + "/statistics/rescal_" + self.start_time,
"ROC_curve_fold%d.csv" % self.foldNumber, TP, FP, threshold)
self.evalDetails.add_statistic_details(self.ground_truth.getSliceMatrix(
SparseTensor.CONNECTION_SLICE), P_bin, idx_test, prediction)
self.foldNumber += 1
def predict_combine_cosine_rescal(self, input_tensor, test_needs, idx_test, rank,
rescal_threshold, cosine_threshold, useNeedTypeSlice):
wants = input_tensor.getWantIndices()
offers = input_tensor.getOfferIndices()
# execute the cosine algorithm first
binary_pred_cosine = cosinus_link_prediciton(input_tensor, test_needs, cosine_threshold, 0.0, False)
# use the connection prediction of the cosine algorithm as input for rescal
temp_tensor = input_tensor.copy()
temp_tensor.addSliceMatrix(binary_pred_cosine, SparseTensor.CONNECTION_SLICE)
A,R = execute_rescal(temp_tensor, rank)
P_bin = predict_rescal_connections_by_threshold(A, R, rescal_threshold, offers, wants, test_needs)
# return both predictions the earlier cosine and the combined rescal
binary_pred_cosine = binary_pred_cosine[idx_test]
binary_pred_rescal = matrix_to_array(P_bin, idx_test)
return binary_pred_cosine, binary_pred_rescal