def save_predictions(self):
"""
Saves model predicted images in results directory
"""
print("Save image predictions")
# Prepare model for inference
self.model.eval()
inference_agent = UNetInferenceAgent(model=self.model, device=self.device)
# Get first test data volume
first_test_data = self.test_data[0]
# Get the model predictions
pred_label = inference_agent.single_volume_inference(first_test_data["image"])
# Calculate middle slice indice
axial_middle_index = int(pred_label.shape[0] / 2)
# Create middle slice images for these volumes for mri image, target and predictions for this epoch
image = (first_test_data["image"][axial_middle_index] * 255).astype(np.uint8)
label = (first_test_data["seg"][axial_middle_index] * 255).astype(np.uint8)
prediction = (pred_label[axial_middle_index] * 255).astype(np.uint8)
# Convert from numpy array to image objects
image = Image.fromarray(image)
label = Image.fromarray(label)
prediction = Image.fromarray(prediction)
# Save images
image.save(self.out_images_dir + '/Epoch' + str(self.epoch) + '-image.png', cmap='Greys')
label.save(self.out_images_dir + '/Epoch' + str(self.epoch) + '-label.png', cmap='Greys')
prediction.save(self.out_images_dir + '/Epoch' + str(self.epoch) + '-prediction.png', cmap='Greys')
def run_test(self):
"""
This runs test cycle on the test dataset.
Note that process and evaluations are quite different
Here we are computing a lot more metrics and returning
a dictionary that could later be persisted as JSON
"""
print("Testing...")
self.model.eval()
# In this method we will be computing metrics that are relevant to the task of 3D volume
# segmentation. Therefore, unlike train and validation methods, we will do inferences
# on full 3D volumes, much like we will be doing it when we deploy the model in the
# clinical environment.
inference_agent = UNetInferenceAgent(model=self.model, device=self.device)
out_dict = {}
out_dict["volume_stats"] = []
dc_list = []
jc_list = []
# for every in test set
for i, x in enumerate(self.test_data):
pred_label = inference_agent.single_volume_inference(x["image"])
# We compute and report Dice and Jaccard similarity coefficients which
# assess how close our volumes are to each other
# on Wikipedia. If you completed it
# correctly (and if you picked your train/val/test split right ;)),
# your average Jaccard on your test set should be around 0.80
dc = Dice3d(pred_label, x["seg"])
jc = Jaccard3d(pred_label, x["seg"])
dc_list.append(dc)
jc_list.append(jc)
# STAND-OUT SUGGESTION: By way of exercise, consider also outputting:
# * Sensitivity and specificity (and explain semantic meaning in terms of
# under/over segmenting)
# * Dice-per-slice and render combined slices with lowest and highest DpS
# * Dice per class (anterior/posterior)
out_dict["volume_stats"].append({
"filename": x['filename'],
"dice": dc,
"jaccard": jc
})
print(f"{x['filename']} Dice {dc:.4f}. {100*(i+1)/len(self.test_data):.2f}% complete")
out_dict["overall"] = {
"mean_dice": np.mean(dc_list),
"mean_jaccard": np.mean(jc_list)}
print("\nTesting complete.")
return out_dict
def run_test(self):
"""
This runs test cycle on the test dataset.
Note that process and evaluations are quite different
Here we are computing a lot more metrics and returning
a dictionary that could later be persisted as JSON
"""
print("Testing...")
self.model.eval()
# In this method we will be computing metrics that are relevant to the task of 3D volume
# segmentation. Therefore, unlike train and validation methods, we will do inferences
# on full 3D volumes, much like we will be doing it when we deploy the model in the
# clinical environment.
# Instantiate inference agent
inference_agent = UNetInferenceAgent(model=self.model, device=self.device)
out_dict = {}
out_dict["volume_stats"] = []
dc_list = []
jc_list = []
# for every in test set
for i, x in enumerate(self.test_data):
pred_label = inference_agent.single_volume_inference(x["image"])
# We compute and report Dice and Jaccard similarity coefficients which
# assess how close our volumes are to each other
dc = Dice3d(pred_label, x["seg"])
jc = Jaccard3d(pred_label, x["seg"])
dc_list.append(dc)
jc_list.append(jc)
out_dict["volume_stats"].append({
"filename": x['filename'],
"dice": dc,
"jaccard": jc
})
print(f"{x['filename']} Dice {dc:.4f} Jaccard {dc:.4f} {100*(i+1)/len(self.test_data):.2f}% complete")
mean_dice = np.mean(dc_list)
mean_jaccard = np.mean(jc_list)
print(f" Mean Dice {mean_dice:.4f} Mean Jaccard {mean_jaccard:.4f}")
out_dict["overall"] = {
"mean_dice": mean_dice,
"mean_jaccard": mean_jaccard}
print("\nTesting complete.")
return out_dict
def run_test(self):
"""
This runs test cycle on the test dataset.
Note that process and evaluations are quite different
Here we are computing a lot more metrics and returning
a dictionary that could later be persisted as JSON
"""
print("Testing...")
self.model.eval()
inference_agent = UNetInferenceAgent(model=self.model,
device=self.device)
out_dict = {}
out_dict["volume_stats"] = []
dc_list = []
jc_list = []
# for every in test set
for i, x in enumerate(self.test_data):
pred_label = inference_agent.single_volume_inference(x["image"])
# We compute and report Dice and Jaccard similarity coefficients which
# assess how close our volumes are to each other
dc = Dice3d(pred_label, x["seg"])
jc = Jaccard3d(pred_label, x["seg"])
dc_list.append(dc)
jc_list.append(jc)
# STAND-OUT SUGGESTION: By way of exercise, consider also outputting:
# * Sensitivity and specificity (and explain semantic meaning in terms of
# under/over segmenting)
# * Dice-per-slice and render combined slices with lowest and highest DpS
# * Dice per class (anterior/posterior)
out_dict["volume_stats"].append({
"filename": x['filename'],
"dice": dc,
"jaccard": jc
})
print(
f"{x['filename']} Dice {dc:.4f}. {100*(i+1)/len(self.test_data):.2f}% complete"
)
out_dict["overall"] = {
"mean_dice": np.mean(dc_list),
"mean_jaccard": np.mean(jc_list)
}
print("\nTesting complete.")
return out_dict
def run_test(self):
"""
This runs test cycle on the test dataset.
Note that process and evaluations are quite different
Here we are computing a lot more metrics and returning
a dictionary that could later be persisted as JSON
"""
print("Testing...")
# load_model_parameters('/home/dev/Documents/github/nd320-c3-3d-imaging-starter/section2/src/2020-06-08_1647_Basic_unet/model.pth')
self.model.eval()
# In this method we will be computing metrics that are relevant to the task of 3D volume
# segmentation. Therefore, unlike train and validation methods, we will do inferences
# on full 3D volumes, much like we will be doing it when we deploy the model in the
# clinical environment.
# TASK: Inference Agent is not complete. Go and finish it. Feel free to test the class
# in a module of your own by running it against one of the data samples
inference_agent = UNetInferenceAgent(model=self.model,
device=self.device)
out_dict = {}
out_dict["volume_stats"] = []
dc_list = []
jc_list = []
# print('self.test_data.shape: ', self.test_data.shape)
# for every in test set
for i, x in enumerate(self.test_data):
print('filename being tested: ', x["filename"])
if (x["filename"] == 'hippocampus_150.nii.gz'):
print('1')
pred_label = inference_agent.single_volume_inference(
x["image"])
pickle.dump(x["image"], open("image_150.p", "wb"))
pickle.dump(pred_label, open("label_150.p", "wb"))
# We compute and report Dice and Jaccard similarity coefficients which
# assess how close our volumes are to each other
# TASK: Dice3D and Jaccard3D functions are not implemented.
# Complete the implementation as we discussed
# in one of the course lessons, you can look up definition of Jaccard index
# on Wikipedia. If you completed it
# correctly (and if you picked your train/val/test split right ;)),
# your average Jaccard on your test set should be around 0.80
dc = Dice3d(pred_label, x["seg"])
jc = Jaccard3d(pred_label, x["seg"])
dc_list.append(dc)
jc_list.append(jc)
# STAND-OUT SUGGESTION: By way of exercise, consider also outputting:
# * Sensitivity and specificity (and explain semantic meaning in terms of
# under/over segmenting)
# * Dice-per-slice and render combined slices with lowest and highest DpS
# * Dice per class (anterior/posterior)
out_dict["volume_stats"].append({
"filename": x['filename'],
"dice": dc,
"jaccard": jc
})
print(
f"{x['filename']} Dice {dc:.4f} and Jaccard: {jc:.4f} . {100*(i+1)/len(self.test_data):.2f}% complete"
)
#break
out_dict["overall"] = {
"mean_dice": np.mean(dc_list),
"mean_jaccard": np.mean(jc_list)
}
print("\nTesting complete.")
return out_dict
def run_test(self):
"""
This runs test cycle on the test dataset.
Note that process and evaluations are quite different
Here we are computing a lot more metrics and returning
a dictionary that could later be persisted as JSON
"""
print("Testing...")
self.model.eval()
# In this method we will be computing metrics that are relevant to the task of 3D volume
# segmentation. Therefore, unlike train and validation methods, we will do inferences
# on full 3D volumes, much like we will be doing it when we deploy the model in the
# clinical environment.
# TASK: Inference Agent is not complete. Go and finish it. Feel free to test the class
# in a module of your own by running it against one of the data samples
param_file_path = self.weights_name if self.weights_name else self.model_name
if self.weights_name:
param_file_path = self.weights_name
elif self.model_name:
param_file_path = self.model_name + ".pth"
inference_agent = UNetInferenceAgent(parameter_file_path=os.path.join(
self.out_dir, param_file_path),
model=self.model,
device=self.device)
out_dict = {}
out_dict["volume_stats"] = []
dice_list = []
jaccard_list = []
sensitivity_list = []
specificity_list = []
# for every in test set
for i, x in enumerate(self.test_data):
pred_label = inference_agent.single_volume_inference(x["image"])
# We compute and report Dice and Jaccard similarity coefficients which
# assess how close our volumes are to each other
# TASK: Dice3D and Jaccard3D functions are not implemented.
# Complete the implementation as we discussed
# in one of the course lessons, you can look up definition of Jaccard index
# on Wikipedia. If you completed it
# correctly (and if you picked your train/val/test split right ;)),
# your average Jaccard on your test set should be around 0.80
results = perf_metrics(pred_label, x["seg"])
dice = results["dice"]
jaccard = results["jaccard"]
sens = results["sens"]
spec = results["spec"]
dice_list.append(dice)
jaccard_list.append(jaccard)
sensitivity_list.append(sens)
specificity_list.append(spec)
out_dict["volume_stats"].append({
"filename": x['filename'],
"dice": dice,
"jaccard": jaccard,
"sensitivty": sens,
"specificity": spec
})
print(
f"{x['filename']} Dice {dice:.4f}. {100*(i+1)/len(self.test_data):.2f}% complete"
)
out_dict["overall"] = {
"mean_dice": np.mean(dice_list),
"mean_jaccard": np.mean(jaccard_list),
"mean_sensitivity": np.mean(sensitivity_list),
"mean_specificity": np.mean(specificity_list)
}
print("\nTesting complete.")
return out_dict
def run_test(self):
"""
This runs test cycle on the test dataset.
Note that process and evaluations are quite different
Here we are computing a lot more metrics and returning
a dictionary that could later be persisted as JSON
"""
self.model.eval()
# In this method we will be computing metrics that are relevant to the task of 3D volume
# segmentation. Therefore, unlike train and validation methods, we will do inferences
# on full 3D volumes, much like we will be doing it when we deploy the model in the
# clinical environment.
# TASK: Inference Agent is not complete. Go and finish it. Feel free to test the class
# in a module of your own by running it against one of the data samples
inference_agent = UNetInferenceAgent(model=self.model,
device=self.device)
out_dict = {}
out_dict["volume_stats"] = []
dc_list = []
jc_list = []
sens_list = []
spec_list = []
# f1_list = []
# for every in test set
for i, x in enumerate(self.test_data):
gt = x["seg"] # test image ground truth
ti = x["image"] # test image data
original_filename = x['filename'] # test image file name
pred_filename = 'predicted_' + x[
'filename'] # test image file name
file_path = os.path.join("..\data", "images", original_filename)
original_images = nib.load(file_path)
mask3d = np.zeros(ti.shape)
pred = inference_agent.single_volume_inference(ti)
mask3d = np.array(torch.argmax(pred, dim=1))
# Save predicted labels to local environment for further verification
# with the original image NIFTI coordinate system
pred_coord = nib.Nifti1Image(mask3d, original_images.affine)
pred_out_path = os.path.join("..\data", "preds")
pred_out_file = os.path.join(pred_out_path, pred_filename)
if not os.path.exists(pred_out_path):
os.makedirs(pred_out_path)
nib.save(pred_coord, pred_out_file)
# We compute and report Dice and Jaccard similarity coefficients which
# assess how close our volumes are to each other
# TASK: Dice3D and Jaccard3D functions are not implemented.
# Complete the implementation as we discussed
# in one of the course lessons, you can look up definition of Jaccard index
# on Wikipedia. If you completed it
# correctly (and if you picked your train/val/test split right ;)),
# your average Jaccard on your test set should be around 0.80
# a - prediction
# b - ground truth
dc = Dice3d(mask3d, gt)
dc_list.append(dc)
jc = Jaccard3d(mask3d, gt)
jc_list.append(jc)
sens = Sensitivity(mask3d, gt)
sens_list.append(sens)
spec = Specificity(mask3d, gt)
spec_list.append(spec)
# f1 = F1_score(mask3d, gt)
# f1_list.append(f1)
# STAND-OUT SUGGESTION: By way of exercise, consider also outputting:
# * Sensitivity and specificity (and explain semantic meaning in terms of
# under/over segmenting)
# * Dice-per-slice and render combined slices with lowest and highest DpS
# * Dice per class (anterior/posterior)
out_dict["volume_stats"].append({
"filename": x['filename'],
"dice": dc,
"jaccard": jc,
"sensitivity": sens,
"specificity": spec,
# "f1": f1,
})
print(
f"{x['filename']} Dice {dc:.4f}, Jaccard {jc:.4f}, Sensitivity {sens:.4f}, and Specificity {spec:.4f}. {100*(i+1)/len(self.test_data):.2f}% complete"
)
avg_dc = np.mean(dc_list)
avg_jc = np.mean(jc_list)
avg_sens = np.mean(sens_list)
avg_spec = np.mean(spec_list)
# avg_f1 = np.mean(f1_list)
out_dict["overall"] = {
"mean_dice": avg_dc,
"mean_jaccard": avg_jc,
"mean_sensitivity": avg_sens,
"mean_specificity": avg_spec,
# "mean_f1": avg_f1,
}
print("\nTesting complete.")
print("------------------------------")
print(
f"Average Dice {avg_dc:.4f}, Average Jaccard {avg_jc:.4f}, Average Sensitivity {avg_sens:.4f}, and Average Specificity {avg_spec:.4f}"
)
return out_dict
def run_test(self):
"""
This runs test cycle on the test dataset.
Note that process and evaluations are quite different
Here we are computing a lot more metrics and returning
a dictionary that could later be persisted as JSON
"""
print("Testing...")
model_dir = "C://Data"
self.load_model_parameters(path=model_dir)
self.model.eval()
# In this method we will be computing metrics that are relevant to the task of 3D volume
# segmentation. Therefore, unlike train and validation methods, we will do inferences
# on full 3D volumes, much like we will be doing it when we deploy the model in the
# clinical environment.
# TASK: Inference Agent is not complete. Go and finish it. Feel free to test the class
# in a module of your own by running it against one of the data samples
inference_agent = UNetInferenceAgent(model=self.model,
device=self.device)
print("Testing...2")
out_dict = {}
out_dict["volume_stats"] = []
dc_list = []
jc_list = []
lr_list = []
print(len((self.test_data)))
# for every in test set
for i, x in enumerate(self.test_data):
print("Testing...loop")
pred_label = inference_agent.single_volume_inference(x["image"])
#print(np.nonzero(x["seg"]))
#print(np.nonzero(pred_label))
# We compute and report Dice and Jaccard similarity coefficients which
# assess how close our volumes are to each other
# TASK: Dice3D and Jaccard3D functions are not implemented.
# Complete the implementation as we discussed
# in one of the course lessons, you can look up definition of Jaccard index
# on Wikipedia. If you completed it
# correctly (and if you picked your train/val/test split right ;)),
# your average Jaccard on your test set should be around 0.80
dc = Dice3d(pred_label, x["seg"])
jc = Jaccard3d(pred_label, x["seg"])
lr = Likelihoodratio(pred_label, x["seg"])
dc_list.append(dc)
jc_list.append(jc)
lr_list.append(lr)
# STAND-OUT SUGGESTION: By way of exercise, consider also outputting:
# * Sensitivity and specificity (and explain semantic meaning in terms of
# under/over segmenting)
# * Dice-per-slice and render combined slices with lowest and highest DpS
# * Dice per class (anterior/posterior)
out_dict["volume_stats"].append({
"filename": x['filename'],
"dice": dc,
"jaccard": jc,
"likelihood": lr
})
print(
f"{x['filename']} Dice {dc:.4f}. {100*(i+1)/len(self.test_data):.2f}% complete"
)
out_dict["overall"] = {
"mean_dice": np.mean(dc_list),
"mean_jaccard": np.mean(jc_list),
"mean_likelihood": np.mean(lr_list)
}
print("\nTesting complete.")
return out_dict