patches_imgs_test, new_height, new_width, masks_test = get_data_testing_overlap(
DRIVE_test_imgs_original=DRIVE_test_imgs_original, # original
DRIVE_test_groudTruth=path_data +
config.get('data paths', 'test_groundTruth'), # masks
Imgs_to_test=int(config.get('testing settings',
'full_images_to_test')),
patch_height=patch_height,
patch_width=patch_width,
stride_height=stride_height,
stride_width=stride_width)
else:
patches_imgs_test, patches_masks_test = get_data_testing(
DRIVE_test_imgs_original=DRIVE_test_imgs_original, # original
DRIVE_test_groudTruth=path_data +
config.get('data paths', 'test_groundTruth'), # masks
Imgs_to_test=int(config.get('testing settings',
'full_images_to_test')),
patch_height=patch_height,
patch_width=patch_width,
)
# ================ Run the prediction of the patches ==================================
best_last = config.get('testing settings', 'best_last')
# Load the saved model
model = model_from_json(
open(path_experiment + name_experiment + '_architecture.json').read())
model.load_weights(path_experiment + name_experiment + '_' + best_last +
'_weights.h5')
# Calculate the predictions
predictions = model.predict(patches_imgs_test, batch_size=32, verbose=2)
print("predicted images size :")
new_width = None
masks_test = None
if average_mode == True:
patches_imgs_test, new_height, new_width = get_data_testing_overlap(
DRIVE_test_imgs_original=DRIVE_test_imgs_original, #original
Imgs_to_test=int(config.get('testing settings',
'full_images_to_test')),
patch_height=patch_height,
patch_width=patch_width,
stride_height=stride_height,
stride_width=stride_width)
else:
patches_imgs_test = get_data_testing(
DRIVE_test_imgs_original=DRIVE_test_imgs_original, #original
Imgs_to_test=int(config.get('testing settings',
'full_images_to_test')),
patch_height=patch_height,
patch_width=patch_width,
)
#================ Run the prediction of the patches ==================================
best_last = config.get('testing settings', 'best_last')
#Load the saved model
model = model_from_json(
open(path_experiment + name_experiment + '_architecture.json').read())
model.load_weights(path_experiment + name_experiment + '_' + 'best' +
'_weights.h5')
#Calculate the predictions
predictions = model.predict(patches_imgs_test, batch_size=32, verbose=2)
print("predicted images size :")
print(predictions.shape)
def testing(channels, height, width, img_dir, borderMasks_dir, path_data = "./dataset_training/"):
img = np.empty((height, width, channels))
border_mask = np.empty((height, width))
if not os.path.exists(path_data):
os.makedirs(path_data)
#with path, subdirs, file in os.walk(self.img_dir):
img = Image.open(img_dir)
b_mask = Image.open(borderMasks_dir)
#border_mask = np.reshape(border_mask,(1,height,width))
assert(np.max(border_masks)==255)
assert(np.min(border_masks)==0)
"""
img = np.transpose(img,(0,3,1,2))
assert(img.shape == (channels,height,width))
border_mask = np.reshape(border_masks,(1,height,width))
assert(border_mask.shape == (1,height,width))
"""
print ("saving train datasets")
write_hdf5(img, path_data + "img.hdf5")
write_hdf5(border_mask, path_data + "borderMask.hdf5")
#original test images (for FOV selection)
DRIVE_test_imgs_original = path_data + 'img.hdf5'
test_imgs_orig = load_hdf5(DRIVE_test_imgs_original)
full_img_height = test_imgs_orig.shape[2]
full_img_width = test_imgs_orig.shape[3]
#the border masks provided by the DRIVE
DRIVE_test_border_masks = path_data + 'borderMask.hdf5'
test_border_masks = load_hdf5(DRIVE_test_border_masks)
# dimension of the patches
patch_height = 64
patch_width = 64
#the stride in case output with average
stride_height = 5
stride_width = 5
assert (stride_height < patch_height and stride_width < patch_width)
#model name
name_experiment = 'test'
path_experiment = './' + name_experiment +'/'
#N full images to be predicted
Imgs_to_test = 2
#Grouping of the predicted images
N_visual = 1
#====== average mode ===========
average_mode = True
#============ Load the data and divide in patches
patches_imgs_test = None
new_height = None
new_width = None
masks_test = None
patches_masks_test = None
if average_mode == True:
patches_imgs_test, new_height, new_width, masks_test = get_data_testing_overlap(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + 'DRIVE_dataset_groundTruth_test.hdf5', #masks
Imgs_to_test = 20,
patch_height = patch_height,
patch_width = patch_width,
stride_height = stride_height,
stride_width = stride_width
)
else:
patches_imgs_test, patches_masks_test = get_data_testing(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + 'DRIVE_dataset_groundTruth_test.hdf5', #masks
Imgs_to_test = 20,
patch_height = patch_height,
patch_width = patch_width,
)
#================ Run the prediction of the patches ==================================
best_last = 'best'
patches_imgs_test = np.einsum('klij->kijl', patches_imgs_test)
model = M.BCDU_net_D3(input_size = (64,64,1))
model.summary()
model.load_weights('weight_lstm.hdf5')
predictions = model.predict(patches_imgs_test, batch_size=16, verbose=1)
predictions = np.einsum('kijl->klij', predictions)
print(patches_imgs_test.shape)
pred_patches = predictions
print ("predicted images size :")
print (predictions.shape)
#===== Convert the prediction arrays in corresponding images
#========== Elaborate and visualize the predicted images ====================
pred_imgs = None
orig_imgs = None
gtruth_masks = None
if average_mode == True:
pred_imgs = recompone_overlap(pred_patches, new_height, new_width, stride_height, stride_width)# predictions
orig_imgs = my_PreProc(test_imgs_orig[0:pred_imgs.shape[0],:,:,:]) #originals
gtruth_masks = masks_test #ground truth masks
else:
pred_imgs = recompone(pred_patches,13,12) # predictions
orig_imgs = recompone(patches_imgs_test,13,12) # originals
gtruth_masks = recompone(patches_masks_test,13,12) #masks
# apply the DRIVE masks on the repdictions #set everything outside the FOV to zero!!
print('killing border')
kill_border(pred_imgs, test_border_masks) #DRIVE MASK #only for visualization
## back to original dimensions
orig_imgs = orig_imgs[:,:,0:full_img_height,0:full_img_width]
pred_imgs = pred_imgs[:,:,0:full_img_height,0:full_img_width]
gtruth_masks = gtruth_masks[:,:,0:full_img_height,0:full_img_width]
np.save('pred_imgs',pred_imgs)
print ("Orig imgs shape: " +str(orig_imgs.shape))
print ("pred imgs shape: " +str(pred_imgs.shape))
print ("Gtruth imgs shape: " +str(gtruth_masks.shape))
np.save('resutls', pred_imgs)
np.save('origin', gtruth_masks)
assert (orig_imgs.shape[0]==pred_imgs.shape[0] and orig_imgs.shape[0]==gtruth_masks.shape[0])
N_predicted = orig_imgs.shape[0]
group = N_visual
assert (N_predicted%group==0)
#====== Evaluate the results
print ("\n\n======== Evaluate the results =======================")
#predictions only inside the FOV
y_scores, y_true = pred_only_FOV(pred_imgs,gtruth_masks, test_border_masks) #returns data only inside the FOV
print(y_scores.shape)
print ("Calculating results only inside the FOV:")
print ("y scores pixels: " +str(y_scores.shape[0]) +" (radius 270: 270*270*3.14==228906), including background around retina: " +str(pred_imgs.shape[0]*pred_imgs.shape[2]*pred_imgs.shape[3]) +" (584*565==329960)")
print ("y true pixels: " +str(y_true.shape[0]) +" (radius 270: 270*270*3.14==228906), including background around retina: " +str(gtruth_masks.shape[2]*gtruth_masks.shape[3]*gtruth_masks.shape[0])+" (584*565==329960)")
#Area under the ROC curve
fpr, tpr, thresholds = roc_curve((y_true), y_scores)
AUC_ROC = roc_auc_score(y_true, y_scores)
# test_integral = np.trapz(tpr,fpr) #trapz is numpy integration
print ("\nArea under the ROC curve: " +str(AUC_ROC))
roc_curve =plt.figure()
plt.plot(fpr,tpr,'-',label='Area Under the Curve (AUC = %0.4f)' % AUC_ROC)
plt.title('ROC curve')
plt.xlabel("FPR (False Positive Rate)")
plt.ylabel("TPR (True Positive Rate)")
plt.legend(loc="lower right")
plt.savefig(path_experiment+"ROC.png")
#Precision-recall curve
precision, recall, thresholds = precision_recall_curve(y_true, y_scores)
precision = np.fliplr([precision])[0] #so the array is increasing (you won't get negative AUC)
recall = np.fliplr([recall])[0] #so the array is increasing (you won't get negative AUC)
AUC_prec_rec = np.trapz(precision,recall)
print ("\nArea under Precision-Recall curve: " +str(AUC_prec_rec))
prec_rec_curve = plt.figure()
plt.plot(recall,precision,'-',label='Area Under the Curve (AUC = %0.4f)' % AUC_prec_rec)
plt.title('Precision - Recall curve')
plt.xlabel("Recall")
plt.ylabel("Precision")
plt.legend(loc="lower right")
plt.savefig(path_experiment+"Precision_recall.png")
#Confusion matrix
threshold_confusion = 0.5
print ("\nConfusion matrix: Custom threshold (for positive) of " +str(threshold_confusion))
y_pred = np.empty((y_scores.shape[0]))
for i in range(y_scores.shape[0]):
if y_scores[i]>=threshold_confusion:
y_pred[i]=1
else:
y_pred[i]=0
confusion = confusion_matrix(y_true, y_pred)
print (confusion)
accuracy = 0
if float(np.sum(confusion))!=0:
accuracy = float(confusion[0,0]+confusion[1,1])/float(np.sum(confusion))
print ("Global Accuracy: " +str(accuracy))
specificity = 0
if float(confusion[0,0]+confusion[0,1])!=0:
specificity = float(confusion[0,0])/float(confusion[0,0]+confusion[0,1])
print ("Specificity: " +str(specificity))
sensitivity = 0
if float(confusion[1,1]+confusion[1,0])!=0:
sensitivity = float(confusion[1,1])/float(confusion[1,1]+confusion[1,0])
print ("Sensitivity: " +str(sensitivity))
precision = 0
if float(confusion[1,1]+confusion[0,1])!=0:
precision = float(confusion[1,1])/float(confusion[1,1]+confusion[0,1])
print ("Precision: " +str(precision))
#Jaccard similarity index
jaccard_index = jaccard_similarity_score(y_true, y_pred, normalize=True)
print ("\nJaccard similarity score: " +str(jaccard_index))
#F1 score
F1_score = f1_score(y_true, y_pred, labels=None, average='binary', sample_weight=None)
print ("\nF1 score (F-measure): " +str(F1_score))
#Save the results
file_perf = open(path_experiment+'performances.txt', 'w')
file_perf.write("Area under the ROC curve: "+str(AUC_ROC)
+ "\nArea under Precision-Recall curve: " +str(AUC_prec_rec)
+ "\nJaccard similarity score: " +str(jaccard_index)
+ "\nF1 score (F-measure): " +str(F1_score)
+"\n\nConfusion matrix:"
+str(confusion)
+"\nACCURACY: " +str(accuracy)
+"\nSENSITIVITY: " +str(sensitivity)
+"\nSPECIFICITY: " +str(specificity)
+"\nPRECISION: " +str(precision)
)
file_perf.close()
# Visualize
fig,ax = plt.subplots(10,3,figsize=[15,15])
for idx in range(10):
ax[idx, 0].imshow(np.uint8(np.squeeze((orig_imgs[idx]))))
ax[idx, 1].imshow(np.squeeze(gtruth_masks[idx]), cmap='gray')
ax[idx, 2].imshow(np.squeeze(pred_imgs[idx]), cmap='gray')
plt.savefig(path_experiment+'sample_results.png')
patches_masks_test = None
if average_mode == True:
patches_imgs_test, new_height, new_width, masks_test = get_data_testing_overlap(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + 'DRIVE_dataset_groundTruth_test.hdf5', #masks
Imgs_to_test = 20,
patch_height = patch_height,
patch_width = patch_width,
stride_height = stride_height,
stride_width = stride_width
)
else:
patches_imgs_test, patches_masks_test = get_data_testing(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + 'DRIVE_dataset_groundTruth_test.hdf5', #masks
Imgs_to_test = 20,
patch_height = patch_height,
patch_width = patch_width,
)
#================ Run the prediction of the patches ==================================
best_last = 'best'
patches_imgs_test = np.einsum('klij->kijl', patches_imgs_test)
model = M.BCDU_net_D3(input_size = (64,64,1))
model.summary()
patches_masks_test = None
if average_mode == True:
patches_imgs_test, new_height, new_width, masks_test = get_data_testing_overlap(
DRIVE_test_imgs_original=DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth=path_local + test_groundTruth, #masks
Imgs_to_test=Imgs_to_test,
patch_height=patch_height,
patch_width=patch_width,
stride_height=stride_height,
stride_width=stride_width)
#masks_test = np.rollaxis(masks_test, 1, 2)
else:
patches_imgs_test, patches_masks_test = get_data_testing(
DRIVE_test_imgs_original=DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth=path_local + test_groundTruth, #masks
Imgs_to_test=Imgs_to_test,
patch_height=patch_height,
patch_width=patch_width,
)
#load model and weights here
pred_patches = pred_images
pred_imgs = None
orig_imgs = None
gtruth_masks = None
if average_mode == True:
pred_imgs = recompone_overlap(pred_patches, new_height, new_width,
stride_height, stride_width) # predictions
orig_imgs = my_PreProc(
test_imgs_orig[0:pred_imgs.shape[0], :, :, :]) #originals
path_experiment = './' +name_experiment +'/'
#Grouping of the predicted images
N_visual = int(config.get('testing settings', 'N_group_visual'))
#============ Load the data and divide in patches
patches_imgs_test = None
new_height = None
new_width = None
masks_test = None
patches_masks_test = None
if with_mash:
print("Using mask images.")
patches_imgs_test, patches_masks_test, test_border_masks = get_data_testing(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + config.get('data paths', 'test_groundTruth'), #masks
DRIVE_test_border = test_border_masks_path,
batch_h = patch_height,
batch_w = patch_width
)
else:
print("Without using mask images.")
patches_imgs_test, patches_masks_test = get_data_testing(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + config.get('data paths', 'test_groundTruth'), #masks
DRIVE_test_border = "",
batch_h = patch_height,
batch_w = patch_width
)
print("patches_imgs_test shape :", patches_imgs_test.shape)
print("patches_masks_test shape :", patches_masks_test.shape)
patches_masks_test = None
if average_mode == True:
patches_imgs_test, new_height, new_width, masks_test = get_data_testing_overlap(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + config.get('data paths', 'test_groundTruth'), #masks
Imgs_to_test = int(config.get('testing settings', 'full_images_to_test')),
patch_height = patch_height,
patch_width = patch_width,
stride_height = stride_height,
stride_width = stride_width
)
else:
patches_imgs_test, patches_masks_test = get_data_testing(
DRIVE_test_imgs_original = DRIVE_test_imgs_original, #original
DRIVE_test_groudTruth = path_data + config.get('data paths', 'test_groundTruth'), #masks
Imgs_to_test = int(config.get('testing settings', 'full_images_to_test')),
patch_height = patch_height,
patch_width = patch_width,
)
#================ Run the prediction of the patches ==================================
best_last = config.get('testing settings', 'best_last')
#Load the saved model
model = model_from_json(open(path_experiment+name_experiment +'_architecture.json').read())
model.load_weights(path_experiment+name_experiment + '_'+best_last+'_weights.h5')
#Calculate the predictions
predictions = model.predict(patches_imgs_test, batch_size=32, verbose=2)
print "predicted images size :"
print predictions.shape
new_width = None
masks_test = None
patches_masks_test = None
if average_mode == True:
patches_imgs_test, new_height, new_width, masks_test = get_data_testing_overlap(
test_imgs_original=test_imgs_original, # original
test_groudTruth=path_data + config.get('data paths', 'test_groundTruth'), # masks
patch_height=patch_height,
patch_width=patch_width,
stride_height=stride_height,
stride_width=stride_width
)
else:
patches_imgs_test, patches_masks_test = get_data_testing(
test_imgs_original=test_imgs_original, # original
test_groudTruth=path_data + config.get('data paths', 'test_groundTruth'), # masks
patch_height=patch_height,
patch_width=patch_width,
)
# ================ Run the prediction of the patches ==================================
batch_size = int(config.get('training settings', 'batch_size'))
model = MODELS[name_experiment](n_channels=1, n_classes=1)
weight_files = sorted(glob(join(TMP_DIR, 'checkpoint_epoch_*.pth')), reverse=True)
# weight_files = []
# weight_files.append(join(TMP_DIR, 'checkpoint_epoch_006.pth'))
print("loaded:" + weight_files[0])
if mode == 'cpu':
model.load_state_dict(torch.load(weight_files[0],
map_location={'cuda:0': 'cpu', 'cuda:1': 'cpu',
