def run(self, train_reader=None, valid_reader=None, test_reader=None, pretrained_model_dir=None, layers2load=None,
isTrain=False, img_mean=np.array((0, 0, 0), dtype=np.float32), verb_step=100, save_epoch=5, gpu=None,
tile_size=(5000, 5000), patch_size=(572, 572), truth_val=1, continue_dir=None, load_epoch_num=None,
fineTune=False, valid_iou=False, best_model=True):
if gpu is not None:
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu)
if isTrain:
coord = tf.train.Coordinator()
with tf.Session(config=self.config) as sess:
# init model
init = [tf.global_variables_initializer(), tf.local_variables_initializer()]
sess.run(init)
saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=1)
# load model
if pretrained_model_dir is not None:
if layers2load is not None:
self.load_weights(pretrained_model_dir, layers2load)
else:
if not fineTune:
restore_var = [v for v in tf.global_variables() if 'resnet_v1' in v.name and
not 'Adam' in v.name]
loader = tf.train.Saver(var_list=restore_var)
self.load(pretrained_model_dir, sess, loader, epoch=load_epoch_num)
else:
self.load(pretrained_model_dir, sess, saver, epoch=load_epoch_num)
threads = tf.train.start_queue_runners(coord=coord, sess=sess)
try:
train_summary_writer = tf.summary.FileWriter(self.ckdir, sess.graph)
self.train('X', 'Y', self.n_train, sess, train_summary_writer,
n_valid=self.n_valid, train_reader=train_reader, valid_reader=valid_reader,
image_summary=util_functions.image_summary, img_mean=img_mean,
verb_step=verb_step, save_epoch=save_epoch, continue_dir=continue_dir,
valid_iou=valid_iou)
finally:
coord.request_stop()
coord.join(threads)
saver.save(sess, '{}/model.ckpt'.format(self.ckdir), global_step=self.global_step)
else:
pad = self.crop_pixel * 2 + self.get_overlap()
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
self.load(pretrained_model_dir, sess, epoch=load_epoch_num, best_model=best_model)
self.model_name = pretrained_model_dir.split('/')[-1]
result = self.test('X', sess, test_reader)
image_pred = uabUtilreader.un_patchify_shrink(result,
[tile_size[0] + pad, tile_size[1] + pad],
tile_size,
patch_size,
[patch_size[0] - pad, patch_size[1] - pad],
overlap=pad)
return util_functions.get_pred_labels(image_pred) * truth_val
# run algo
os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu)
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
model.load(sp_model_dir, sess)
result = model.test('X', sess, test_reader)
image_pred = uabUtilreader.un_patchify_shrink(result,
[tile_size[0] + model.get_overlap(),
tile_size[1] + model.get_overlap()],
tile_size, input_size,
[input_size[0] - model.get_overlap(),
input_size[1] - model.get_overlap()],
overlap=model.get_overlap())
pred = util_functions.get_pred_labels(image_pred)
mask_img = np.copy(orig_img)
mask_img = draw_contour(mask_img, pred, truth_val=1)
# mask_img = util_functions.add_mask(mask_img, pred, [255, None, None], mask_1=1)
region = [250, 450, 450, 650]
save_dir = r'/media/ei-edl01/user/bh163/figs/2018.03.15.gbdx/blog_figures'
plt.figure(figsize=(8, 8))
plt.imshow(mask_img[region[0]:region[1], region[2]:region[3], :])
plt.tight_layout()
plt.show()
imageio.imsave(os.path.join(save_dir, 'IN_2.png'), mask_img[region[0]:region[1], region[2]:region[3], :])
'''for i in range(0, 2541-1000, 200):
for j in range(0, 2541-600, 120):
def evaluate(self,
rgb_list,
gt_list,
rgb_dir,
gt_dir,
input_size,
tile_size,
batch_size,
img_mean,
model_dir,
gpu=None,
save_result=True,
save_result_parent_dir=None,
show_figure=False,
verb=True,
ds_name='default',
load_epoch_num=None,
best_model=True):
from PIL import Image
Image.MAX_IMAGE_PIXELS = None
if show_figure:
import matplotlib.pyplot as plt
if save_result:
self.model_name = model_dir.split('/')[-1]
if save_result_parent_dir is None:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
self.model_name, ds_name)
else:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
save_result_parent_dir,
self.model_name, ds_name)
if not os.path.exists(score_save_dir):
os.makedirs(score_save_dir)
with open(os.path.join(score_save_dir, 'result.txt'), 'w'):
pass
iou_record = []
iou_return = {}
for file_name, file_name_truth in zip(rgb_list, gt_list):
tile_name = file_name_truth.split('_')[0]
if verb:
print('Evaluating {} ... '.format(tile_name))
start_time = time.time()
truth_label_img = imageio.imread(
os.path.join(gt_dir, file_name_truth))
if tile_size is None:
tile_size_temp = truth_label_img.shape[:2]
else:
tile_size_temp = tile_size
# prepare the reader
pred_all = []
for aug_cnt in range(8):
reader = ImageLabelReader(gtInds=[0],
dataInds=[0],
nChannels=3,
parentDir=rgb_dir,
chipFiles=[file_name],
chip_size=input_size,
tile_size=tile_size_temp,
batchSize=batch_size,
block_mean=img_mean,
overlap=self.get_overlap(),
padding=np.array(
(self.get_overlap() / 2,
self.get_overlap() / 2)),
isTrain=False,
aug=aug_cnt)
rManager = reader.readManager
# run the model
pred = self.run(pretrained_model_dir=model_dir,
test_reader=rManager,
tile_size=tile_size_temp,
patch_size=input_size,
gpu=gpu,
load_epoch_num=load_epoch_num,
best_model=best_model)
pred_all.append(pred)
# average results
pred_all = _rotate_mirror_undo(pred_all)
pred = util_functions.get_pred_labels(pred_all) * 1
iou = util_functions.iou_metric(truth_label_img,
pred,
divide_flag=True)
iou_record.append(iou)
iou_return[tile_name] = iou
duration = time.time() - start_time
if verb:
print('{} mean IoU={:.3f}, duration: {:.3f}'.format(
tile_name, iou[0] / iou[1], duration))
# save results
if save_result:
pred_save_dir = os.path.join(score_save_dir, 'pred')
if not os.path.exists(pred_save_dir):
os.makedirs(pred_save_dir)
imageio.imsave(os.path.join(pred_save_dir, tile_name + '.png'),
pred.astype(np.uint8))
with open(os.path.join(score_save_dir, 'result.txt'),
'a+') as file:
file.write('{} {}\n'.format(tile_name, iou))
if show_figure:
plt.figure(figsize=(12, 6))
ax1 = plt.subplot(121)
ax1.imshow(truth_label_img)
plt.title('Truth')
ax2 = plt.subplot(122, sharex=ax1, sharey=ax1)
ax2.imshow(pred)
plt.title('pred')
plt.suptitle('{} Results on {} IoU={:3f}'.format(
self.model_name,
file_name_truth.split('_')[0], iou[0] / iou[1]))
plt.tight_layout()
plt.show()
iou_record = np.array(iou_record)
mean_iou = np.sum(iou_record[:, 0]) / np.sum(iou_record[:, 1])
print('Overall mean IoU={:.3f}'.format(mean_iou))
if save_result:
if save_result_parent_dir is None:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
self.model_name, ds_name)
else:
score_save_dir = os.path.join(uabRepoPaths.evalPath,
save_result_parent_dir,
self.model_name, ds_name)
with open(os.path.join(score_save_dir, 'result.txt'),
'a+') as file:
file.write('{}'.format(mean_iou))
return iou_return
isTrain=False,
shift=slide_step)
rManager = reader.readManager
with tf.Session() as sess:
init = tf.global_variables_initializer()
sess.run(init)
model.load(model_dir, sess, epoch=None, best_model=True)
model.model_name = model_dir.split('/')[-1]
result = model.test('X', sess, rManager)
pad = model.get_overlap()
image_pred = uabUtilreader.un_patchify_shrink(
result, [tile_size[0] + pad, 4576 + pad], [5000, 4576],
input_size, [input_size[0] - pad, input_size[1] - pad],
overlap=pad)
pred_overall = util_functions.get_pred_labels(image_pred) * 1
pred_overall = np.roll(pred_overall, shift=slide_step, axis=1)
pred_overall = pred_overall[:, 1000:-1000]
#pred_overall = pred_overall[:, shift_max-slide_step:-slide_step-1]
truth_label_img = imageio.imread(
os.path.join(parent_dir_truth, file_name_truth))
#truth_label_img = np.roll(truth_label_img, -slide_step, axis=1)
truth_label_img = truth_label_img[:, :4576]
truth_label_img = truth_label_img[:, 1000:-1000]
iou = util_functions.iou_metric(truth_label_img,
pred_overall,
divide_flag=True)
duration = time.time() - start_time
if iou[1] != 0:
print('{} mean IoU={:.3f}, duration: {:.3f}'.format(
tile_name, iou[0] / iou[1], duration))
result2 = model.test('X', sess, test_reader2)
image_pred = uabUtilreader.un_patchify_shrink(
result1,
[tile_size[0] + model.get_overlap(), tile_size[1] + model.get_overlap()],
tile_size,
input_size,
[input_size[0] - model.get_overlap(), input_size[1] - model.get_overlap()],
overlap=model.get_overlap())
image_pred_ct = uabUtilreader.un_patchify_shrink(
result2,
[tile_size[0] + model.get_overlap(), tile_size[1] + model.get_overlap()],
tile_size,
input_size,
[input_size[0] - model.get_overlap(), input_size[1] - model.get_overlap()],
overlap=model.get_overlap())
pred = util_functions.get_pred_labels(image_pred) * 255
pred_ct = util_functions.get_pred_labels(image_pred_ct) * 255
iou = iou_metric(pred_ct, pred, truth_val=255)
# view result
lt = imageio.imread(os.path.join(data_path, large_tile[0]))
plt.figure(figsize=(15, 6))
ax1 = plt.subplot(131)
plt.axis('off')
plt.imshow(lt)
ax2 = plt.subplot(132, sharex=ax1, sharey=ax1)
plt.imshow(pred)
plt.title('Pred IoU={:.3f}'.format(iou))
plt.axis('off')
ax3 = plt.subplot(133, sharex=ax1, sharey=ax1)
