def ComputeScores(list_rgb,
dic_gt,
dic_prob,
p1,
p2,
keep_memory=False,
path_save='./tmp'):
res_AJI = []
res_F1 = []
res_DSB = []
res_ps = []
res_TP = []
res_FN = []
res_FP = []
for path in list_rgb:
GT = imread(dic_gt[path])
GT = PostProcess(GT, 1, 0)
DImg = dic_prob[path]
DImg[DImg < 0] = 0
DImg = DImg.astype("uint8")
S = PostProcess(DImg, p1, p2)
res_AJI.append(AJI_fast(GT, S))
res_F1.append(ComputeF1(GT, S))
scores, p_s, TP, FN, FP = DataScienceBowlMetrics(GT, S)
res_DSB.append(scores)
res_ps.append(p_s)
res_TP.append(TP)
res_FN.append(FN)
res_FP.append(FP)
if keep_memory:
img_mean = np.mean(imread(path)[:, :, 0:3])
if img_mean < 125:
color_cont = False
else:
color_cont = True
OUT = join(path_save, basename(path).replace('.png', ''))
CheckOrCreate(OUT)
os.symlink(abspath(path), join(OUT, "rgb.png"))
os.symlink(abspath(dic_gt[path]), join(OUT, "bin.png"))
imsave(join(OUT, "colored_bin.png"), color_bin(label(GT)))
imsave(join(OUT, "colored_pred.png"), color_bin(S))
imsave(join(OUT, "output_DNN.png"), DImg)
imsave(join(OUT, "contours_gt.png"),
Overlay_with_pred(path, GT, color_cont).astype('uint8'))
imsave(join(OUT, "contours_pred.png"),
Overlay_with_pred(path, S, color_cont).astype('uint8'))
# pdb.set_trace()
if keep_memory:
return res_AJI, res_F1, res_DSB, res_ps, res_TP, res_FN, res_FP
else:
return np.mean(res_AJI), np.mean(res_F1), np.mean(res_DSB)
def ComputeScores(list_rgb,
dic_gt,
dic_prob,
p2,
keep_memory=False,
path_save='./tmp'):
res_AJI = []
res_F1 = []
res_DSB = []
res_ps = []
res_TP = []
res_FN = []
res_FP = []
for path in list_rgb:
GT = imread(dic_gt[path])
GT = Label3(GT)
S = MultiClassToBinMap(dic_prob[path], p2)
res_AJI.append(AJI_fast(GT, S))
res_F1.append(ComputeF1(GT, S))
scores, p_s, TP, FN, FP = DataScienceBowlMetrics(GT, S)
res_DSB.append(scores)
res_ps.append(p_s)
res_TP.append(TP)
res_FN.append(FN)
res_FP.append(FP)
if keep_memory:
img_mean = np.mean(imread(path)[:, :, 0:3])
if img_mean < 125:
color_cont = False
else:
color_cont = True
OUT = join(path_save, basename(path).replace('.png', ''))
CheckOrCreate(OUT)
os.symlink(abspath(path), join(OUT, "rgb.png"))
os.symlink(abspath(dic_gt[path]), join(OUT, "bin.png"))
imsave(join(OUT, "colored_bin.png"), color_bin(label(GT)))
imsave(join(OUT, "colored_pred.png"), color_bin(S.astype(int)))
imsave(join(OUT, "contours_gt.png"),
Overlay(path, dic_gt[path], color_cont).astype('uint8'))
imsave(join(OUT, "output_class0.png"),
img_as_ubyte(dic_prob[path][:, :, 0]))
imsave(join(OUT, "output_class1.png"),
img_as_ubyte(dic_prob[path][:, :, 1]))
imsave(join(OUT, "output_class2.png"),
img_as_ubyte(dic_prob[path][:, :, 2]))
# imsave(join(OUT, "contours_pred.png"), Overlay_with_pred(path, S, color_cont).astype('uint8'))
# pdb.set_trace()
if keep_memory:
return res_AJI, res_F1, res_DSB, res_ps, res_TP, res_FN, res_FP
else:
return np.mean(res_AJI), np.mean(res_F1), np.mean(res_DSB)
pbar = ProgressBar()
for img_test_path in pbar(test_images):
dic_pred[img_test_path] = model.pred(img_test_path)[0]
tf.reset_default_graph(
) # so that it can restore properly the next model
HP_dic = {}
for p1 in P1_List:
for p2 in P2_list:
HP_dic[(p1, p2)] = ComputeScores(test_img_all, dic_test_gt_all,
dic_pred, p1, p2)
tab = pd.DataFrame.from_dict(HP_dic, orient='index')
tab.columns = ['AJI', 'F1', 'DSB']
tab.to_csv('Hyper_parameter_selection.csv')
P1, P2 = tab["DSB"].idxmax()
CheckOrCreate(options.output)
aji__, f1__, DSB__, ps__, tp__, fn__, fp__ = ComputeScores(
test_img_all, dic_test_gt_all, dic_pred, p1, p2, True, options.output)
ps__, tp__, fn__, fp__ = [np.array(el) for el in [ps__, tp__, fn__, fp__]]
pathsss = [
join(options.output,
basename(path).replace('.png', '')) for path in test_img_all
]
df_dic = {'path': pathsss, 'F1': f1__, 'AJI': aji__, 'DSB': DSB__}
for k, t in enumerate(np.arange(0.5, 1, 0.05)):
df_dic['precision_t_{}'.format(t)] = ps__[:, k]
df_dic['tp_t_{}'.format(t)] = tp__[:, k]
df_dic['fn_t_{}'.format(t)] = fn__[:, k]
df_dic['fp_t_{}'.format(t)] = fp__[:, k]
tab_values = pd.DataFrame.from_dict(df_dic)
IMAGE_SIZE=(212, 212),
NUM_LABELS=2,
NUM_CHANNELS=4,
LOG=LOG,
N_FEATURES=N_FEATURES,
N_THREADS=50,
MEAN_FILE=MEAN_FILE)
for __ in FILES:
prediction = model.pred(__)
dic[__].append(prediction)
tf.reset_default_graph(
) # so that it can restore properly the next model
dic_final_pred = {}
dic_prob = {}
CheckOrCreate(options.output_sample)
for key in dic.keys():
OUT_ID = join(options.output_sample, basename(key).replace('.png', ''))
CheckOrCreate(OUT_ID)
dic_prob[key] = np.mean(np.concatenate(dic[key]), axis=0)[:, :, 1]
dic_final_pred[key] = PostProcess(dic_prob[key], P1, P2)
# dic_final_pred[key] = (dic_prob[key] > P2).astype('uint8')
dic_final_pred[key] = label(dic_final_pred[key])
dic_final_pred[key] = remove_small_objects(dic_final_pred[key], 32)
img_mean = np.mean(imread(key)[:, :, 0:3])
if img_mean < 125:
color_cont = False
else:
color_cont = True
#put rgb image
os.symlink(abspath(key), join(OUT_ID, "rgb.png"))
colorout[:,:,i] = normalize_single_channel(temp, maxval=255, minval=0, inv=False)
imout = colorout.astype(np.uint8)
return(imout)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('--input', dest="input", type="str")
parser.add_option('--output', dest="output", type="str")
(options, args) = parser.parse_args()
input_folder = options.input
if not os.path.isdir(input_folder):
raise ValueError("folder %s does not exist" % input_folder)
output_folder = options.output
CheckOrCreate(output_folder)
for root, dirs, files in os.walk(input_folder):
local_output_folder = root.replace(input_folder, output_folder)
CheckOrCreate(local_output_folder)
for filename in files:
if filename[0] == ".":
continue
if filename.endswith('_mask.png'):
shutil.copy(os.path.join(root, filename), local_output_folder)
else:
imin = skimage.io.imread(os.path.join(root, filename))
imout = normalize_multi_channel(imin)
skimage.io.imsave(os.path.join(local_output_folder, filename), imout)
print 'DONE'
from optparse import OptionParser
import pdb
def GRN():
return str(uuid.uuid4()).replace("-", "")
parser = OptionParser()
parser.add_option('--input', dest="input", type="str")
(options, args) = parser.parse_args()
TNBC = options.input
OUT = "."
PNG = glob(TNBC + "/Slide_*/*.png")
for png in PNG:
mask = png.replace('/Slide_', '/GT_')
name = GRN()
CheckOrCreate(join(OUT, name))
CheckOrCreate(join(OUT, name, 'images'))
CheckOrCreate(join(OUT, name, 'masks'))
os.symlink(os.path.abspath(png), join(OUT, name, 'images', name + ".png"))
labels = label(imread(mask))
for i in range(1, labels.max() + 1):
single = np.zeros_like(labels, dtype='uint8')
single[labels == i] = 255
name_sing = GRN()
imsave(join(OUT, name, 'masks', name_sing + ".png"), single)
def save_path(output, rgb, original):
out = rgb.replace(original, output)
f = os.path.abspath(os.path.join(out, os.pardir))
CheckOrCreate(f)
return out
mask[line > 0] = 0
mask = distance_transform_cdt(mask)
imsave(join(dst_mask, basename(mask_name)), mask)
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('--input', dest="input", type="str")
parser.add_option('--output', dest="output", type="str")
parser.add_option('--splits', dest="splits", type="int")
(options, args) = parser.parse_args()
table = pd.read_csv(options.input, index_col=0)
train = table[table["train"] == 1]
test = table[table["train"] == 0]
CheckOrCreate(options.output)
Create_Key_PerGroup(train, DOMAIN_VARIABLE)
skf = StratifiedKFold(n_splits=options.splits)
k = 0
Fold_k_S = join(options.output, 'Slide_{}')
Fold_k_M = join(options.output, 'GT_{}')
for train_index, test_index in skf.split(train, train['group']):
test_fold = train.ix[test_index]
CheckOrCreate(Fold_k_S.format(k))
CheckOrCreate(Fold_k_M.format(k))
test_fold.apply(lambda row: Symlink_Mask(row, Fold_k_S.format(k),
Fold_k_M.format(k)),
axis=1)
k += 1
def train(self, list_img, dic, output_csv):
data_res = pd.DataFrame()
epoch = self.STEPS * self.BATCH_SIZE // self.N_EPOCH
self.LearningRateSchedule(self.LEARNING_RATE, self.K, epoch)
trainable_var = tf.trainable_variables()
self.regularize_model()
self.optimization(trainable_var)
self.ExponentialMovingAverage(trainable_var, self.DECAY_EMA)
self.summary_test_writer = tf.summary.FileWriter(self.LOG + '/test',
graph=self.sess.graph)
self.summary_writer = tf.summary.FileWriter(self.LOG + '/train',
graph=self.sess.graph)
self.merged_summary = tf.summary.merge_all()
steps = self.STEPS
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
self.sess.run(init_op)
#self.sess.run(self.init_data)
early_finish = False
CheckOrCreate("./confusion_matrix_train")
CheckOrCreate("./confusion_matrix_test")
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
for step in range(steps):
# print "saving images"
# self.optimizer is replaced by self.training_op for the exponential moving decay
_, l, lr, predictions, batch_labels, s = self.sess.run([
self.training_op, self.loss, self.learning_rate,
self.train_prediction, self.train_labels_node,
self.merged_summary
])
if step % self.N_PRINT == 0:
if step != 0:
i = datetime.now()
print i.strftime('%Y/%m/%d %H:%M:%S: \n ')
self.summary_writer.add_summary(s, step)
error, acc, cm_train = self.error_rate(
predictions, batch_labels, step)
print(' Step %d of %d' % (step, steps))
print(' Learning rate: %.5f \n') % lr
print(
' Mini-batch loss: %.5f \n Accuracy: %.1f%% \n'
% (l, acc))
l, acc, cm, wgt_path = self.Validation(list_img, dic, step)
data_res.loc[step, "loss"] = l
data_res.loc[step, "acc"] = acc
data_res.loc[step, "wgt_path"] = abspath(wgt_path)
np.save(
"./confusion_matrix_train" + "/cm_{}.npy".format(step),
cm_train)
np.save(
"./confusion_matrix_test" + "/cm_{}.npy".format(step),
cm)
if self.early_stopping(data_res, "acc"):
best_wgt = np.array(
data_res["wgt_path"])[-(self.early_stopping_max +
1)]
make_it_seem_new = self.LOG + '/' + "model.ckpt-{}".format(
step + 10)
os.symlink(best_wgt + ".data-00000-of-00001",
make_it_seem_new + ".data-00000-of-00001")
os.symlink(best_wgt + ".index",
make_it_seem_new + ".index")
os.symlink(best_wgt + ".meta",
make_it_seem_new + ".meta")
early_finish = True
break
if not early_finish:
best_wgt = np.array(
data_res["wgt_path"])[-(self.early_stopping_max + 1)]
make_it_seem_new = self.LOG + '/' + "model.ckpt-{}".format(step +
10)
os.symlink(best_wgt + ".data-00000-of-00001",
make_it_seem_new + ".data-00000-of-00001")
os.symlink(best_wgt + ".index", make_it_seem_new + ".index")
os.symlink(best_wgt + ".meta", make_it_seem_new + ".meta")
coord.request_stop()
coord.join(threads)
data_res.to_csv(output_csv)
def ComputeScore(list_csv, var_name):
scores = np.zeros(len(list_csv), dtype="float")
epoch_number = np.zeros(len(list_csv), dtype="float")
for i, csv in enumerate(list_csv):
tables = pd.read_csv(csv, index_col=0)
scores[i] = tables[[var_name]].max()
epoch_number[i] = tables.shape[0] - 10
return np.concatenate([scores, epoch_number])
if __name__ == '__main__':
hyper_param_test = GetNames()
dic = {}
try:
for key in hyper_param_test.keys():
dic[key] = ComputeScore(hyper_param_test[key], "F1")
except:
for key in hyper_param_test.keys():
dic[key] = ComputeScore(hyper_param_test[key], "acc")
n = len(hyper_param_test[key])
tab = pd.DataFrame.from_dict(dic, orient='index')
mean = tab[[i for i in range(n)]].mean(axis=1)
std = tab[[i for i in range(n)]].std(axis=1)
tab["mean"] = mean
tab["std"] = std
best = mean.argmax()
CheckOrCreate(best)
tab.to_csv('test_tables.csv')
return res.astype('uint8')
def PostProcessGuess(name, img):
if "Dist" in name:
return PostProcess(img, 0, 0.5)
else:
img = img.astype('float')
img = img / 255.
return PostProcess(img, 14, 0.5)
if __name__ == '__main__':
list_models = ["UNetHistogramTW2", "UNetDistHistogramTW2", "Test"]
OUTPUT = join(PATH, "Sum")
CheckOrCreate(OUTPUT)
general_dic = GatherMultipleModels(list_models, "Test")
out_tag = "output_DNN_mean"
for name, dic in Model_gen(general_dic,
tags=[out_tag, "colored_pred", "rgb"]):
OUTPUT_img = join(OUTPUT, name)
CheckOrCreate(OUTPUT_img)
# for el in dic["output_DNN_mean"].keys():
# imsave(join(OUTPUT_img, "output_DNN__" + el + ".png"), dic["output_DNN_mean"][el])
list_pred = []
for el in dic[out_tag].keys():
colored_bin = PostProcessGuess(el, dic[out_tag][el])
colored_bin[colored_bin > 0] = 255
list_pred.append(colored_bin)
# pdb.set_trace()
from patch_img import Contours
def GenerateGT(input, output):
files_GT = os.path.join(input, "GT_*", "*.png")
for gt_path in glob(files_GT):
out_path = gt_path.replace(input, output)
yield gt_path, out_path
def PutContoursTo2(gt, size=3):
gt = imread(gt)
if len(gt.shape) > 2:
gt = gt[:, :, 0]
gt[gt > 0] = 1
contours = Contours(gt, size)
gt[contours > 0] = 2
return gt
if __name__ == '__main__':
parser = OptionParser()
parser.add_option('--input', dest="input", type="str")
parser.add_option('--output', dest="output", type="str")
(options, args) = parser.parse_args()
#CheckOrCreate(options.output)
for gt_, out_ in GenerateGT(options.input, options.output):
CheckOrCreate(os.path.dirname(out_))
result = PutContoursTo2(gt_)
imsave(out_, result)
parser.add_option('--train', action='store_true')
# actions: predict yes/no
parser.add_option('--predict_train', action='store_true')
# actions: predict yes/no
parser.add_option('--predict_test', action='store_true')
(options, args) = parser.parse_args()
input_folder = options.input
if not os.path.isdir(input_folder):
raise ValueError("folder %s does not exist" % input_folder)
output_folder = options.output
CheckOrCreate(output_folder)
model_folder = options.modelfolder
CheckOrCreate(model_folder)
show_folder = options.showfolder
CheckOrCreate(show_folder)
nn_names = [x.strip() for x in options.nn_names.split(',')]
ec = EdgeClassifier(input_folder, output_folder, model_folder, show_folder,
nn_names)
if options.feature_extraction:
# feature extraction
ts = ec.make_edge_training_set()