def evaluate(object_folder):
test_images_list = os.path.join(object_folder, 'test_images_list.csv')
test_labels_list = os.path.join(object_folder, 'test_labels_list.csv')
test_image_filenames = KScsv.read_csv(test_images_list)
test_label_filenames = KScsv.read_csv(test_labels_list)
all_prediction = list()
all_label = list()
f1score_per_image = list()
all_score = list()
for i_image, (image_file, label_file) in enumerate(
zip(test_image_filenames, test_label_filenames)):
tick = time.time()
basename = os.path.basename(image_file[0])
basename = os.path.splitext(basename)[0]
image_file = os.path.join(object_folder, 'result', basename + '.mat')
# Read in result and label
mat_content = matlab.load(image_file)
score = mat_content['mask']
prediction = score > 0.5
prediction = prediction.astype('float')
label = KSimage.imread(label_file[0])
label = label.astype('float')
label = label / 255.0
label = label > 0.5
label = label.astype('float')
prediction = np.reshape(prediction, -1)
label = np.reshape(label, -1)
score = np.reshape(score, -1)
all_prediction.append(prediction)
all_label.append(label)
all_score.append(score)
f1score = metrics.f1_score(label, prediction, average='binary')
f1score_per_image.append(f1score)
duration = time.time() - tick
print('evaluate %d / %d (%.2f sec)' %
(i_image + 1, len(test_image_filenames), duration))
all_label = np.reshape(np.array(all_label), -1)
all_prediction = np.reshape(np.array(all_prediction), -1)
all_score = np.reshape(np.array(all_score), -1)
total_f1score = metrics.f1_score(all_label,
all_prediction,
average='binary')
avg_f1score = np.mean(f1score_per_image)
average_precision = metrics.average_precision_score(all_label,
all_score,
average='micro')
return total_f1score, avg_f1score, average_precision, f1score_per_image
def test(object_folder, model_path, filename_list, result_path, flags, igpu):
checkpoint_dir = os.path.join(object_folder, 'checkpoint')
mat_contents = matlab.load(
os.path.join(checkpoint_dir, 'network_stats.mat'))
mean_image = np.float32(mat_contents['mean_image'])
variance_image = np.float32(mat_contents['variance_image'])
###########################################################
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152
os.environ["CUDA_VISIBLE_DEVICES"] = igpu
###########################################################
with tf.Graph().as_default(), tf.device(flags['gpu']):
keep_prob = tf.placeholder(tf.float32)
# Place holder for patches
images_test = tf.placeholder(tf.float32,
shape=(np.hstack([
flags['test_batch_size'],
flags['size_input_patch']
])))
# Network
with tf.variable_scope("network") as scope:
logits_test, parameters = tf_model.inference(
images_test, keep_prob, flags)
# Saver and initialisation
saver = tf.train.Saver()
init = tf.initialize_all_variables()
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=flags['gpu_memory_fraction'])
config = tf.ConfigProto(allow_soft_placement=True,
gpu_options=gpu_options)
with tf.Session(config=config) as sess:
# Initialise and load variables
sess.run(init)
saver.restore(sess, model_path)
result_dir = result_path
routine.create_dir(result_dir)
for iImage, file in enumerate(filename_list):
start_time = time.time()
file = file[0]
basename = os.path.basename(file)
basename = os.path.splitext(basename)[0]
savename = os.path.join(result_dir, basename + '.png')
if not os.path.exists(savename):
result = batch_processing(file, sess, logits_test,
parameters, images_test,
keep_prob, mean_image,
variance_image, flags)
# matlab.save(savename,{'mask':result})
KSimage.imwrite(result, savename)
duration = time.time() - start_time
print(
'Finish segmenting DCIS regions on the H&E image of sample %d out of %d samples (%.2f sec)'
% (iImage + 1, len(filename_list), duration))
def testWSI(object_folder, model_path, directory, flags):
"""
testWSI segments all of the WSIs in a given directory
param: object_folder
param: model_path
param: directory
param: gpu
param: gpu_memory_fraction
param: test_batch_size
param: size_input_patch
return: writes segmentation result to corresponding segmentation result directory
"""
checkpoint_dir = os.path.join(object_folder, 'checkpoint')
mat_contents = matlab.load(os.path.join(checkpoint_dir, 'network_stats.mat'))
mean_image = np.float32(mat_contents['mean_image'])
variance_image = np.float32(mat_contents['variance_image'])
startTime = time.time()
with tf.Graph().as_default(), tf.device(flags['gpu']):
keep_prob = tf.placeholder(tf.float32)
# Place holder for patches
images_test = tf.placeholder(tf.float32, shape=(np.hstack([flags['test_batch_size'], flags['size_input_patch']])))
# Network
with tf.variable_scope("network") as scope:
logits_test, parameters = tf_model.inference(images_test, keep_prob, flags)
# Saver and initialisation
saver = tf.train.Saver()
init = tf.global_variables_initializer()
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=flags['gpu_memory_fraction'])
config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options)
with tf.Session(config = config) as sess:
# Initialise and load variables
sess.run(init)
saver.restore(sess, model_path)
print("Current directory: " + str(directory))
result_dir = os.path.join(directory +'_epiStromalSeg')
create_dir(result_dir)
filename_list = glob.glob(os.path.join(directory, '*.png')) #the main statement, returns all the files in the directory
print("Num Files: " + str(len(filename_list)))
for file in filename_list:
print(file)
basename = os.path.basename(file)
basename = os.path.splitext(basename)[0]
savename = os.path.join(result_dir, basename + '.png')
if not os.path.exists(savename) and not ('mask' in file or 'thumbnail' in file):
result = batch_processing(file, sess, logits_test, parameters, images_test, keep_prob, mean_image, variance_image, flags)
KSimage.imwrite(result, savename)
print("Total Time: " + str(time.time() - startTime))
def retouch_segmentation(file):
"""
retouch_segmentation uses binary morphological operations (erode and dilate)
to improve the segmentation result
param: segmentation result
return: retouched segmentation result
"""
matcontent = matlab.load(file)
mask = matcontent['mask']
mask = np.squeeze(mask)
# threshold
binary_mask = mask > 0.8
binary_mask_base = mask > 0.5
# define disk structure
radius = 5
[x, y] = np.meshgrid(range(-radius, radius + 1),
range(-radius, radius + 1))
z = np.sqrt(x**2 + y**2)
structure = z < radius
# imerosion
erode_mask = binary_erosion(binary_mask,
structure=structure,
border_value=1)
erode_mask = remove_small_objects(erode_mask, 100)
# watershed
distance = ndimage.distance_transform_edt(binary_mask_base)
markers = ndimage.label(erode_mask)[0]
labels = watershed(-distance, markers, mask=binary_mask_base)
return labels
def define_graph(object_folder, checkpoint_folder, flags):
# global step
global_step = tf.Variable(0, trainable=False, name='global_step')
# Epoch counter
curr_epoch = tf.Variable(0, trainable=False, name='curr_epoch')
update_curr_epoch = tf.assign(curr_epoch, tf.add(curr_epoch,
tf.constant(1)))
# drop out
keep_prob = tf.placeholder(tf.float32)
# network stats
# Load network stats
mat_contents = matlab.load(
os.path.join(checkpoint_folder, 'network_stats.mat'))
mean_img = np.float32(mat_contents['mean_image'])
variance_img = np.float32(mat_contents['variance_image'])
if mean_img.ndim == 2:
mean_img = np.expand_dims(mean_img, axis=2)
if variance_img.ndim == 2:
variance_img = np.expand_dims(variance_img, axis=2)
mean_image = tf.Variable(mean_img, trainable=False, name='mean_image')
variance_image = tf.Variable(variance_img,
trainable=False,
name='variance_image')
# Get images and labels.
out_content_train = tf_model_input.inputs(mean_image, variance_image,
object_folder, 'train', flags)
out_content_val = tf_model_input.inputs(mean_image, variance_image,
object_folder, 'val', flags)
images_train = out_content_train['images']
labels_train = out_content_train['labels']
weights_train = out_content_train['weights']
images_val = out_content_val['images']
labels_val = out_content_val['labels']
weights_val = out_content_val['weights']
# Build a Graph that computes the logits predictions from the inference model.
with tf.variable_scope("network") as scope:
sigmoid_all_train, parameters = tf_model.inference(
images_train, keep_prob, flags)
scope.reuse_variables()
sigmoid_all_val, _ = tf_model.inference(images_val, keep_prob, flags)
# Calculate loss.
loss_train = tf_model.loss(sigmoid_all_train, labels_train, weights_train,
curr_epoch)
loss_val = tf_model.loss(sigmoid_all_val, labels_val, weights_val,
curr_epoch)
# Accuracy train
predict_train = tf.squeeze(tf.to_float(sigmoid_all_train > 0.25))
actual_train = tf.squeeze(tf.to_float(labels_train > 0.25))
accuracy_train_output = tf_model.accuracy(predict_train, actual_train)
# Accuracy val
predict_val = tf.squeeze(tf.to_float(sigmoid_all_val > 0.25))
actual_val = tf.squeeze(tf.to_float(labels_val > 0.25))
accuracy_val_output = tf_model.accuracy(predict_val, actual_val)
# Build a Graph that trains the model with one batch of examples and
# updates the model parameters.
train_op = tf_model.train(loss_train['avg_cross_entropy_log_loss'],
global_step, parameters, flags)
return {
'global_step': global_step,
'curr_epoch': curr_epoch,
'update_curr_epoch': update_curr_epoch,
'keep_prob': keep_prob,
'loss_train': loss_train,
'loss_val': loss_val,
'predict_train': predict_train,
'actual_train': actual_train,
'predict_val': predict_val,
'actual_val': actual_val,
'train_op': train_op,
'accuracy_train_output': accuracy_train_output,
'accuracy_val_output': accuracy_val_output,
'parameters': parameters,
'out_content_train': out_content_train,
'out_content_val': out_content_val,
'sigmoid_all_train': sigmoid_all_train,
'sigmoid_all_val': sigmoid_all_val
}
def test(object_folder, model_path, filename_list, flags):
"""
test uses either whole image segmentation or patch based
segmentation to segment an entire directory of test images
param: object_folder
param: model_path
param: filename_list
param: gpu
param: gpu_memory_fraction
return: writes segmentation result to appropriate image file
"""
checkpoint_dir = os.path.join(object_folder, 'checkpoint')
mat_contents = matlab.load(
os.path.join(checkpoint_dir, 'network_stats.mat'))
mean_image = np.float32(mat_contents['mean_image'])
variance_image = np.float32(mat_contents['variance_image'])
startTime = time.time()
with tf.Graph().as_default(), tf.device(flags['gpu']):
keep_prob = tf.placeholder(tf.float32)
# Place holder for patches
images_test = tf.placeholder(tf.float32,
shape=(np.hstack([
flags['test_batch_size'],
flags['size_input_patch']
])))
# Network
with tf.variable_scope("network") as scope:
logits_test, parameters = tf_model.inference(
images_test, keep_prob, flags)
# Saver and initialisation
saver = tf.train.Saver()
init = tf.initialize_all_variables()
gpu_options = tf.GPUOptions(
per_process_gpu_memory_fraction=flags['gpu_memory_fraction'])
config = tf.ConfigProto(allow_soft_placement=True,
gpu_options=gpu_options)
with tf.Session(config=config) as sess:
# Initialise and load variables
sess.run(init)
saver.restore(sess, model_path)
result_dir = os.path.join(object_folder, 'result')
routine.create_dir(result_dir)
print("FILENAME LIST", filename_list)
for iImage, file in enumerate(filename_list):
file = file[0]
basename = os.path.basename(file)
basename = os.path.splitext(basename)[0]
savename = os.path.join(result_dir, basename + '.png')
if not os.path.exists(savename):
print('processing image %d/%d' %
(iImage + 1, len(filename_list)))
result = batch_processing(file, sess, logits_test,
parameters, images_test,
keep_prob, mean_image,
variance_image, flags)
KSimage.imwrite(result, savename)
print("Total Time: " + str(time.time() - startTime))
def define_graph(object_folder, checkpoint_folder, flags):
#keys = ['HE', 'DAPI', 'label']
keys = list(flags['dict_path'].keys())
keys.remove('group')
# global step
global_step = tf.Variable(0, trainable=False, name='global_step')
# Epoch counter
curr_epoch = tf.Variable(0, trainable=False, name='curr_epoch')
update_curr_epoch = tf.assign(curr_epoch, tf.add(curr_epoch, tf.constant(1)))
# drop out
keep_prob = tf.placeholder(tf.float32)
# random field brightness
# random_field = tf.placeholder_with_default(
# np.ones(shape = (flags['size_input_patch'][0],flags['size_input_patch'][1],1), dtype = np.float32),
# shape = (flags['size_input_patch'][0],flags['size_input_patch'][1],1))
# network stats
mat_contents = matlab.load(os.path.join(checkpoint_folder, 'network_stats.mat'))
# Get images
# out_content_train - dictionary containing 32,512,512,3
# labels - dictionary with pair containing 32,
out_content_train, train_labels = tf_model_input.inputs(object_folder, 'train', flags, mat_contents)
out_content_val, val_labels = tf_model_input.inputs(object_folder, 'val', flags, mat_contents)
images_train = out_content_train['HE']
#labels_train = out_content_train['labels']
#weights_train = out_content_train['weights']
images_val = out_content_val['HE']
#labels_val = out_content_val['labels']
#weights_val = out_content_val['weights']
# Build a Graph that computes the logits predictions from the inference model.
# sigmoid_all_train - 32,4 for 4 different classes with batch 32
with tf.variable_scope("network") as scope:
sigmoid_all_train, parameters = tf_model.inference(images_train, keep_prob, flags)
scope.reuse_variables()
sigmoid_all_val, _ = tf_model.inference(images_val, keep_prob, flags)
# Get model weights
counts = matlab.load(os.path.join(checkpoint_folder, 'counts.mat'))
# Calculate loss.
loss_train = tf_model.loss(sigmoid_all_train, train_labels, curr_epoch, flags, counts)
loss_val = tf_model.loss(sigmoid_all_val, val_labels, curr_epoch, flags, counts)
# Accuracy train
predict_train = tf.squeeze(tf.argmax(sigmoid_all_train, dimension=1))
actual_train = tf.squeeze(train_labels['HE'])
accuracy_train_output = tf_model.accuracy(predict_train, actual_train, flags)
# Accuracy val
predict_val = tf.squeeze(tf.argmax(sigmoid_all_val, dimension=1))
actual_val = tf.squeeze(train_labels['HE'])
accuracy_val_output = tf_model.accuracy(predict_val, actual_val, flags)
# Build a Graph that trains the model with one batch of examples and
# updates the model parameters.
train_op = tf_model.train(loss_train['avg_cross_entropy_log_loss'], global_step, parameters, flags)
return {'global_step': global_step,
'curr_epoch': curr_epoch,
'update_curr_epoch': update_curr_epoch,
'keep_prob': keep_prob,
'loss_train': loss_train,
'loss_val': loss_val,
'predict_train': predict_train,
'actual_train': actual_train,
'predict_val': predict_val,
'actual_val': actual_val,
'train_op': train_op,
'accuracy_train_output': accuracy_train_output,
'accuracy_val_output': accuracy_val_output,
'parameters': parameters,
'out_content_train': out_content_train,
'out_content_val': out_content_val,
'sigmoid_all_train': sigmoid_all_train,
'sigmoid_all_val': sigmoid_all_val
# 'random_field': random_field
}
def test(object_folder, model_path, filename_list, flags):
"""
test uses either whole image segmentation or patch based
segmentation to segment an entire directory of test images
param: object_folder
param: model_path
param: filename_list
param: gpu
param: gpu_memory_fraction
return: writes segmentation result to appropriate image file
"""
checkpoint_dir = os.path.join(object_folder, 'checkpoint')
mat_contents = matlab.load(os.path.join(checkpoint_dir, 'network_stats.mat'))
mean_image = np.float32(mat_contents['mean_image'])
variance_image = np.float32(mat_contents['variance_image'])
# turns 256 x 256 x 3 into 1 x 1 x 3
mean_image_new = np.array([mean_image[:, :, 0].mean(), mean_image[:, :, 1].mean(), mean_image[:, :, 2].mean()])
variance_image_new = np.array([variance_image[:, :, 0].mean(), variance_image[:, :, 1].mean(), variance_image[:, :, 2].mean()])
with tf.Graph().as_default(), tf.device(flags['gpu']):
keep_prob = tf.placeholder(tf.float32)
# Place holder for patches
images_test = tf.placeholder(tf.float32)
# Network
with tf.variable_scope("network") as scope:
logits_test, parameters = tf_model.inference(images_test, keep_prob, flags)
# Saver and initialisation
saver = tf.train.Saver()
init = tf.global_variables_initializer()
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=flags['gpu_memory_fraction'])
config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options)
with tf.Session(config=config) as sess:
# Initialise and load variables
sess.run(init)
saver.restore(sess, model_path)
result_dir = os.path.join(object_folder, 'result')
create_dir(result_dir)
start_time = time.time()
for iImage, file in enumerate(filename_list):
file = file[0]
basename = os.path.basename(file)
basename = os.path.splitext(basename)[0]
savename = os.path.join(result_dir, basename + '.png')
print('processing image %d/%d' % (iImage + 1, len(filename_list)))
print("FILE!!!!!!!!!!!" + str(file))
if (flags['use_patches'] == False):
result = whole_image_processing(file, sess, logits_test, parameters, images_test, keep_prob, mean_image_new, variance_image_new, flags)
else:
result = batch_processing(file, sess, logits_test, parameters, images_test, keep_prob mean_image, variance_image, flags)
print("Image processed")
KSimage.imwrite(result, savename) #Write result back to image once segmentation is fixed
print("TOTAL DURATION : " + str(time.time() - start_time))
def define_graph(object_folder, checkpoint_folder, flags):
"""
define_graph defines the computational graph in tensorflow
which represents the entire network
param: object_folder
param: checkpoint_folder
param: flags
return: train operation dictionary
"""
print("into define graph")
# global step
global_step = tf.Variable(0, trainable=False, name='global_step')
# epoch counter
curr_epoch = tf.Variable(0, trainable=False, name='curr_epoch')
update_curr_epoch = tf.assign(curr_epoch, tf.add(curr_epoch,
tf.constant(1)))
# drop out
keep_prob = tf.placeholder(tf.float32)
# load network stats
mat_contents = matlab.load(
os.path.join(checkpoint_folder, 'network_stats.mat'))
mean_img = np.float32(mat_contents['mean_image'])
variance_img = np.float32(mat_contents['variance_image'])
if mean_img.ndim == 2:
mean_img = np.expand_dims(mean_img, axis=2)
if variance_img.ndim == 2:
variance_img = np.expand_dims(variance_img, axis=2)
print("mean image success defined")
mean_image = tf.Variable(mean_img, trainable=False, name='mean_image')
print("variance image success defined")
variance_image = tf.Variable(variance_img,
trainable=False,
name='variance_image')
# get images and labels
print("out content train")
out_content_train = tf_model_input.inputs(mean_image, variance_image,
object_folder, 'train', flags)
print("done with out content train going into out content val")
out_content_val = tf_model_input.inputs(mean_image, variance_image,
object_folder, 'val', flags)
print("done with out content val")
images_train = out_content_train['images']
labels_train = out_content_train['labels']
weights_train = out_content_train['weights']
images_val = out_content_val['images']
labels_val = out_content_val['labels']
weights_val = out_content_val['weights']
# build a graph that computes the logits predictions from the inference model.
with tf.variable_scope("network") as scope:
sigmoid_all_train, parameters = tf_model.inference(
images_train, keep_prob, flags)
scope.reuse_variables()
sigmoid_all_val, _ = tf_model.inference(images_val, keep_prob, flags)
loss_train = tf_model.loss(sigmoid_all_train, labels_train, weights_train,
curr_epoch, flags)
loss_val = tf_model.loss(sigmoid_all_val, labels_val, weights_val,
curr_epoch, flags)
# accuracy train
predict_train = tf.squeeze(tf.argmax(
sigmoid_all_train,
axis=3)) #this is where the one-hot is turned back into the 256x256x3
print("Predict Train shape: ", tf.shape(predict_train))
actual_train = tf.squeeze(labels_train)
print("Actual train shape: ", tf.shape(actual_train))
accuracy_train_output = tf_model.accuracy(predict_train, actual_train,
flags)
# accuracy val
predict_val = tf.squeeze(tf.argmax(sigmoid_all_val, axis=3))
print("Predict Val shape:", tf.shape(predict_val))
actual_val = tf.squeeze(labels_val)
print("Actual val shape:", tf.shape(actual_val))
accuracy_val_output = tf_model.accuracy(predict_val, actual_val, flags)
# build a graph that trains the model with one batch of examples and updates the model parameters.
train_op = tf_model.train(loss_train['avg_cross_entropy_log_loss'],
global_step, parameters, flags)
print("out of define graph")
return {
'global_step': global_step,
'curr_epoch': curr_epoch,
'update_curr_epoch': update_curr_epoch,
'keep_prob': keep_prob,
'loss_train': loss_train,
'loss_val': loss_val,
'predict_train': predict_train,
'actual_train': actual_train,
'predict_val': predict_val,
'actual_val': actual_val,
'train_op': train_op,
'accuracy_train_output': accuracy_train_output,
'accuracy_val_output': accuracy_val_output,
'parameters': parameters,
'out_content_train': out_content_train,
'out_content_val': out_content_val,
'sigmoid_all_train': sigmoid_all_train,
'sigmoid_all_val': sigmoid_all_val,
'mean_image': mean_image,
'variance_image': variance_image
}