def sample(self, iter_time):
if np.mod(iter_time, self.flags.sample_freq) == 0:
idx = np.random.choice(self.dataset.num_val, 2, replace=False)
x_imgs, y_imgs = self.dataset.val_imgs[
idx], self.dataset.val_vessels[idx]
samples = self.model.sample_imgs(x_imgs)
# masking
seg_samples = utils.remain_in_mask(samples,
self.dataset.val_masks[idx])
# crop to original image shape
x_imgs_ = utils.crop_to_original(x_imgs, self.dataset.ori_shape)
seg_samples_ = utils.crop_to_original(seg_samples,
self.dataset.ori_shape)
y_imgs_ = utils.crop_to_original(y_imgs, self.dataset.ori_shape)
# sampling
self.plot(x_imgs_,
seg_samples_,
y_imgs_,
iter_time,
idx=idx,
save_file=self.sample_out_dir,
phase='train')
def eval(self, iter_time=0, phase='train'):
total_time, auc_sum = 0., 0.
if np.mod(iter_time, self.flags.eval_freq) == 0:
num_data, imgs, vessels, masks = None, None, None, None
if phase == 'train':
num_data = self.dataset.num_val
imgs = self.dataset.val_imgs
vessels = self.dataset.val_vessels
masks = self.dataset.val_masks
elif phase == 'test':
num_data = self.dataset.num_test
imgs = self.dataset.test_imgs
vessels = self.dataset.test_vessels
masks = self.dataset.test_masks
generated = []
for iter_ in range(num_data):
x_img = imgs[iter_]
x_img = np.expand_dims(x_img,
axis=0) # (H, W, C) to (1, H, W, C)
# measure inference time
start_time = time.time()
generated_vessel = self.model.sample_imgs(x_img)
total_time += (time.time() - start_time)
generated.append(np.squeeze(
generated_vessel, axis=(0, 3))) # (1, H, W, 1) to (H, W)
generated = np.asarray(generated)
# calculate measurements
auc_sum = self.measure(generated, vessels, masks, num_data,
iter_time, phase, total_time)
if phase == 'test':
# save test images
segmented_vessel = utils.remain_in_mask(generated, masks)
# crop to original image shape
imgs_ = utils.crop_to_original(imgs, self.dataset.ori_shape)
cropped_vessel = utils.crop_to_original(
segmented_vessel, self.dataset.ori_shape)
vessels_ = utils.crop_to_original(vessels,
self.dataset.ori_shape)
for idx in range(num_data):
self.plot(np.expand_dims(imgs_[idx], axis=0),
np.expand_dims(cropped_vessel[idx], axis=0),
np.expand_dims(vessels_[idx], axis=0),
'test',
idx=[idx],
save_file=self.img_out_dir,
phase='test')
return auc_sum
# iterate all images
img_size = (640, 640) if dataset == "DRIVE" else (720, 720)
ori_shape = (1, 584, 565) if dataset == "DRIVE" else (1, 605,
700) # batchsize=1
fundus_files = utils.all_files_under(fundus_dir.format(dataset))
mask_files = utils.all_files_under(mask_dir.format(dataset))
for index, fundus_file in enumerate(fundus_files):
print("processing {}...".format(fundus_file))
# load imgs
img = utils.imagefiles2arrs([fundus_file])
mask = utils.imagefiles2arrs([mask_files[index]])
# z score with mean, std (batchsize=1)
mean = np.mean(img[0, ...][mask[0, ...] == 255.0], axis=0)
std = np.std(img[0, ...][mask[0, ...] == 255.0], axis=0)
img[0, ...] = (img[0, ...] - mean) / std
# run inference
padded_img = utils.pad_imgs(img, img_size)
#padded_img=utils.rescale_imgs(img, img_size)
vessel_img = model.predict(padded_img, batch_size=1) * 255
# rescaled_vessel = utils.rescale_to_original(vessel_img[...,0], ori_shape)
# final_result = utils.remain_in_mask(rescaled_vessel[0,...], mask[0,...])
cropped_vessel = utils.crop_to_original(vessel_img[..., 0], ori_shape)
final_result = utils.remain_in_mask(cropped_vessel[0, ...], mask[0,
...])
png_file = os.path.splitext(fundus_file)[0] + '.png'
Image.fromarray(final_result.astype(np.uint8)).save(
os.path.join(out_dir.format(dataset), os.path.basename(png_file)))
# G
gan_x_test, gan_y_test=utils.input2gan(val_imgs, val_vessels, d_out_shape)
loss,acc=gan.evaluate(gan_x_test,gan_y_test, batch_size=batch_size, verbose=0)
utils.print_metrics(n_round+1, acc=acc, loss=loss, type='GAN')
# save the weights
g.save_weights(os.path.join(model_out_dir,"g_{}_{}_{}.h5".format(n_round,FLAGS.discriminator,FLAGS.ratio_gan2seg)))
# update step sizes, learning rates
scheduler.update_steps(n_round)
K.set_value(d.optimizer.lr, scheduler.get_lr())
K.set_value(gan.optimizer.lr, scheduler.get_lr())
# evaluate on test images
if n_round in rounds_for_evaluation:
generated=g.predict(test_imgs,batch_size=batch_size)
generated=np.squeeze(generated, axis=3)
vessels_in_mask, generated_in_mask = utils.pixel_values_in_mask(test_vessels, generated , test_masks)
auc_roc=utils.AUC_ROC(vessels_in_mask,generated_in_mask,os.path.join(auc_out_dir,"auc_roc_{}.npy".format(n_round)))
auc_pr=utils.AUC_PR(vessels_in_mask, generated_in_mask,os.path.join(auc_out_dir,"auc_pr_{}.npy".format(n_round)))
binarys_in_mask=utils.threshold_by_otsu(generated,test_masks)
dice_coeff=utils.dice_coefficient_in_train(vessels_in_mask, binarys_in_mask)
acc, sensitivity, specificity=utils.misc_measures(vessels_in_mask, binarys_in_mask)
utils.print_metrics(n_round+1, auc_pr=auc_pr, auc_roc=auc_roc, dice_coeff=dice_coeff,
acc=acc, senstivity=sensitivity, specificity=specificity, type='TESTING')
# print test images
segmented_vessel=utils.remain_in_mask(generated, test_masks)
for index in range(segmented_vessel.shape[0]):
Image.fromarray((segmented_vessel[index,:,:]*255).astype(np.uint8)).save(os.path.join(img_out_dir,str(n_round)+"_{:02}_segmented.png".format(index+1)))
