def test(self, data, labels):
predictions = np.zeros(data.shape[0])
for i, row in enumerate(data):
predictions[i] = self.predict(row)
acc = accuracy(predictions.astype(int), labels.astype(int))
f1 = f1score(predictions.astype(int), labels.astype(int),
len(self.feature_names))
return acc, f1
def evaluate(tokens, instances, labels, write_result=False):
'''Evaluate and print results'''
prediction, target = sess.run(
[model.pred, model.output_y],
feed_dict={
model.input_x: np.asarray(instances),
model.output_y: np.asarray(labels),
model.dropout: 1.0
})
prec, recall, f1sc = f1score(2, prediction, target)
if write_result:
print("Found MAX")
print("--Tokenwise P:{:.5f}".format(prec),
"R:{:.5f}".format(recall), "F1:{:.5f}".format(f1sc))
prec, recall, f1sc = phrasalf1score(args, tokens, prediction,
target)
print("--Phrasal P:{:.5f}".format(prec),
"R:{:.5f}".format(recall), "F1:{:.5f}".format(f1sc))
write_results(tokens, prediction, target,
"runs/res_{:.5f}".format(f1sc) + ".txt")
return f1sc
st = time.time()
output_image = sess.run(network, feed_dict={input: input_image})
output_image = np.array(output_image[0, :, :, :])
output_image = helpers.reverse_one_hot(output_image)
out_eval_image = output_image[:, :, 0]
out_vis_image = helpers.colour_code_segmentation(output_image)
accuracy = utils.compute_avg_accuracy(out_eval_image, gt)
class_accuracies = utils.compute_class_accuracies(
out_eval_image, gt, num_classes)
prec = utils.precision(out_eval_image, gt)
rec = utils.recall(out_eval_image, gt)
f1 = utils.f1score(out_eval_image, gt)
iou = utils.compute_mean_iou(out_eval_image, gt)
file_name = utils.filepath_to_name(val_input_names[ind])
target.write("%s, %f, %f, %f, %f, %f" %
(file_name, accuracy, prec, rec, f1, iou))
for item in class_accuracies:
target.write(", %f" % (item))
target.write("\n")
scores_list.append(accuracy)
class_scores_list.append(class_accuracies)
precision_list.append(prec)
recall_list.append(rec)
f1_list.append(f1)
iou_list.append(iou)
gt = cv2.imread(val_output_names[ind],
-1)[:args.crop_height, :args.crop_width]
st = time.time()
output_image = sess.run(network, feed_dict={input: input_image})
output_image = np.array(output_image[0, :, :, :])
output_image = helpers.reverse_one_hot(output_image)
out_vis_image = helpers.colour_code_segmentation(output_image)
accuracy = utils.compute_avg_accuracy(output_image, gt)
class_accuracies = utils.compute_class_accuracies(
output_image, gt, num_classes)
prec = utils.precision(output_image, gt)
rec = utils.recall(output_image, gt)
f1 = utils.f1score(output_image, gt)
iou = utils.compute_mean_iou(output_image, gt)
file_name = utils.filepath_to_name(val_input_names[ind])
target.write("%s, %f, %f, %f, %f, %f" %
(file_name, accuracy, prec, rec, f1, iou))
for item in class_accuracies:
target.write(", %f" % (item))
target.write("\n")
scores_list.append(accuracy)
class_scores_list.append(class_accuracies)
precision_list.append(prec)
recall_list.append(rec)
f1_list.append(f1)
iou_list.append(iou)
st = time.time()
output_image = sess.run(network, feed_dict={z: input_image})
gt_map = cv2.imread(test_output_names[ind],
-1)[:args.crop_height, :args.crop_width]
output_image = np.array(output_image[0, :, :, :])
output_image = helpers.reverse_one_hot(output_image)
output_image = output_image[:, :, 0]
out_vis_image = helpers.colour_code_segmentation(output_image)
accuracy = utils.compute_avg_accuracy(output_image, gt_map)
class_accuracies = utils.compute_class_accuracies(output_image, gt_map)
prec = utils.precision(output_image, gt_map)
rec = utils.recall(output_image, gt_map)
f1 = utils.f1score(output_image, gt_map)
iou = utils.compute_mean_iou(output_image, gt_map)
file_name = utils.filepath_to_name(test_input_names[ind])
target.write("%s, %f, %f, %f, %f, %f" %
(file_name, accuracy, prec, rec, f1, iou))
for item in class_accuracies:
target.write(", %f" % (item))
target.write("\n")
scores_list.append(accuracy)
class_scores_list.append(class_accuracies)
precision_list.append(prec)
recall_list.append(rec)
f1_list.append(f1)
iou_list.append(iou)
def get_f1_acc_loss(true, preds, loss):
f1, acc = utils.f1score(true, preds, 'weighted')
return f1, acc, sum(loss)/len(loss)
