def main():
app = QtGui.QApplication(sys.argv)
app.setApplicationName('Mes jolies images')
#Get frame file names
root_dir = '/home/laurent.lejeune/medical-labeling'
dataset_dir = 'Dataset03'
save_dir = os.path.join(root_dir, dataset_dir, 'results')
# Used to compute coverage
ref_frame = 0
frame_dir = os.path.join(root_dir, dataset_dir, 'input-frames')
gt_dir = os.path.join(root_dir, dataset_dir, 'ground_truth-frames')
dir_clicks = os.path.join('.')
sorted_frames = sorted(glob.glob(os.path.join(frame_dir, '*.png')))
sorted_gt = sorted(glob.glob(os.path.join(gt_dir, '*.png')))
gts = [utls.imread(sorted_gt[i]) for i in range(len(sorted_gt))]
gts = [(g[..., 0] > 0)[..., np.newaxis] for g in gts]
gts = np.concatenate(gts, axis=2)
#Tweezer
label_contour_path = 'precomp_descriptors/'
label_contour_fname = 'sp_labels_tsp_contours'
npzfile = np.load(os.path.join(root_dir, dataset_dir, label_contour_path,
label_contour_fname) + '.npz',
fix_imports=True,
encoding='bytes')
labelContourMask = npzfile['labelContourMask']
labels = np.load(
os.path.join(root_dir, dataset_dir, 'input-frames',
'sp_labels.npz'))['sp_labels']
pos_sps = vutls.get_pos_sps(labels[..., ref_frame], gts[..., ref_frame])
my_window = Window(frame_dir, dataset_dir, save_dir, sorted_frames,
sorted_gt, ref_frame, pos_sps, dir_clicks,
labelContourMask, labels)
#Make event on click
my_window.window.getImageItem().mousePressEvent = my_window.on_click
#Mouse move coordinates
#app.installEventFilter(my_window)
my_window.show()
app.exec_()
def getColorDesc(frameFileNames, labels, dense_step=1, normCst=1):
"""
normCst : pixel values are normalized w.r.t that. Default = 1
"""
keyFramesIdx = np.arange(0, len(frameFileNames))
desc = [] # average histogram (descriptor) of keypoint
for keyFrame in keyFramesIdx:
desc.append([])
img = utils.imread(frameFileNames[keyFrame])
img = color.rgb2hsv(img)
for i in np.unique(labels[:, :, keyFrame]):
mask = (labels[:, :, keyFrame] == i)
this_region = np.zeros((img.shape[2], np.sum(mask)))
for j in range(img.shape[2]):
this_channel = img[:, :, j]
this_region[j, :] = np.ravel(this_channel[mask])
this_mean = np.mean(this_region, axis=1) / np.tile(normCst, 3)
desc[keyFrame].append((i, this_mean))
return (desc)
def run_on_dset(dataset_dir):
# read image
labelMatPath = 'EE/sp_labels_ml.mat'
data_root_dir = '/home/laurent.lejeune/medical-labeling/'
frame_extension = '.png'
frame_dir = 'input-frames'
frame_prefix = 'frame_'
frame_digits = 4
wide = True
patch_size = 231
if (wide):
feat_out_dir = 'EE/overfeat_wide'
else:
feat_out_dir = 'EE/overfeat'
labels = scipy.io.loadmat(
os.path.join(data_root_dir, dataset_dir, labelMatPath))['labels']
filenames = utls.makeFrameFileNames(frame_prefix, frame_digits, frame_dir,
data_root_dir, dataset_dir,
frame_extension)
# initialize overfeat. Note that this takes time, so do it only once if possible
overfeat_dir = '/home/laurent.lejeune/Documents/OverFeat'
overfeat_extr = OverfeatFeatureExtractor(
os.path.join(overfeat_dir, 'data', 'default'),
os.path.join(overfeat_dir, 'bin', 'linux_64', 'cuda',
'overfeatcmd_cuda'))
out_path = os.path.join(data_root_dir, dataset_dir, feat_out_dir)
if not os.path.exists(out_path):
os.makedirs(out_path)
selem = square(2)
for i in range(len(filenames)):
patches = []
this_filename = os.path.splitext(os.path.basename(filenames[i]))[0]
outfile = os.path.join(data_root_dir, dataset_dir, feat_out_dir,
this_filename)
if (not os.path.isfile(outfile + '.npz')):
print('frame {}/{}'.format(i + 1, len(filenames)))
features = []
image = utls.imread(filenames[i])
if (image.shape[2] > 3): image = image[:, :, 0:3]
for j in np.unique(labels[:, :, i]):
if (wide):
this_mask = labels[:, :, i] == j
this_mask = binary_dilation(this_mask, selem)
this_mask_idx = np.where(this_mask)
this_mask_labels = np.unique(labels[this_mask_idx[0],
this_mask_idx[1], i])
this_mask = np.in1d(labels[:, :, i],
this_mask_labels).reshape(
image.shape[0], image.shape[1])
else:
this_mask = labels[:, :, i] == j
i_mask, j_mask = np.where(this_mask)
w = max(j_mask) - min(j_mask)
h = max(i_mask) - min(i_mask)
if (w < h):
cols_to_add = h - w + 1
idx_i = np.arange(min(i_mask), max(i_mask) + 1).astype(int)
idx_j = np.arange(
min(j_mask) - np.floor(cols_to_add / 2),
max(j_mask) + np.ceil(cols_to_add / 2)).astype(int)
elif (w > h):
rows_to_add = w - h + 1
idx_i = np.arange(
min(i_mask) - np.floor(rows_to_add / 2),
max(i_mask) + np.ceil(rows_to_add / 2)).astype(int)
idx_j = np.arange(min(j_mask), max(j_mask) + 1).astype(int)
else:
idx_i = np.arange(min(i_mask), max(i_mask) + 1)
idx_j = np.arange(min(j_mask), max(j_mask) + 1)
patches.append(
resize(
image.take(idx_i, mode='wrap',
axis=0).take(idx_j, mode='wrap', axis=1),
(patch_size, patch_size)).astype(np.float32))
X = np.asarray(patches)
features = overfeat_extr.get_feats_overfeat(
X, np.unique(labels[:, :, i]), '/tmp')
data = dict()
data['features'] = features
np.savez_compressed(outfile + '.npz', **data)
scipy.io.savemat(outfile + '.mat', data)
else:
print("File: " + outfile + " exists. Delete to recompute...")
dir_root = '/home/laurent.lejeune/medical-labeling/'
ds_dir = ['Dataset12']
feat_path = 'precomp_descriptors/unet/feat.h5'
for i in range(len(ds_dir)):
print('Interpolating Unet features on:')
print(ds_dir[i])
labels = np.load(os.path.join(dir_root, ds_dir[i],'input-frames', 'sp_labels.npz'))['sp_labels']
frameFileNames = utls.makeFrameFileNames(
'frame_', 4, 'input-frames',
dir_root, ds_dir[i], 'png')
im = utls.imread(frameFileNames[0])
img_height = im.shape[0]
img_width = im.shape[1]
# initialize hdf5 files
hdInFile = h5py.File(os.path.join(dir_root,ds_dir[i],feat_path), 'r')
feats_arr = hdInFile['raw_feat'][...]
hdInFile.close()
modelDepth = 4
# get feat properties
feat_h = feats_arr.shape[1]
feat_w = feats_arr.shape[2]
feat_d = feats_arr.shape[3]
def main(confs,
confunet,
out_dir=None,
train=True,
pred=True,
score=True,
resume_model=None):
n_points = 2000
if (out_dir is None):
now = datetime.datetime.now()
dateTime = now.strftime("%Y-%m-%d_%H-%M-%S")
out_dir = os.path.join(
confs[0].dataOutRoot, 'learning_exps',
'learning_' + confs[0].seq_type + '_' + dateTime)
dir_in = [c.dataOutDir for c in confs]
if (not os.path.exists(out_dir)):
os.mkdir(out_dir)
with open(os.path.join(out_dir, 'cfg.yml'), 'w') as outfile:
yaml.dump(confunet, outfile, default_flow_style=True)
datasets = []
utls.setup_logging(out_dir)
logger = logging.getLogger('learning_exp_unet')
logger.info('Starting learning experiment on:')
logger.info(dir_in)
logger.info('Gaze file: ' + str(confs[0].csvFileName_fg))
logger.info('')
if (not os.path.exists(os.path.join(out_dir, 'datasets.npz'))):
logger.info('Building target vectors')
for i in range(len(dir_in)):
with open(os.path.join(dir_in[i], 'cfg.yml'), 'r') as outfile:
conf = yaml.load(outfile)
logger.info('Dataset: ' + str(i + 1) + '/' + str(len(dir_in)))
dataset = learning_dataset.LearningDataset(conf)
npz_file = np.load(os.path.join(dir_in[i], 'results.npz'))
#seeds = np.asarray(utls.get_node_list_tracklets(npz_file['list_ksp'][-1]))
dataset.scores = npz_file['ksp_scores_mat'].astype(bool)
datasets.append(dataset)
if (not os.path.exists(out_dir)):
os.mkdir(out_dir)
logger.info('saving datasets to: ' + out_dir)
np.savez(os.path.join(out_dir, 'datasets.npz'),
**{'datasets': datasets})
dir_my_root = os.path.join(out_dir, 'my')
dir_true_root = os.path.join(out_dir, 'true')
n_folds = 4
if (train):
from nets import UNetBasic
logger.info('Loading datasets...')
datasets = np.load(os.path.join(out_dir, 'datasets.npz'))['datasets']
fold_ids = np.arange(0, 4)[::-1]
for i in range(n_folds):
logger.info('-----------------')
pred_fold = i
train_folds = np.asarray([
fold_ids[j] for j in range(n_folds)
if (fold_ids[j] != pred_fold)
])
logger.info('train_folds: ' + str(train_folds))
logger.info('pred_folds: ' + str(pred_fold))
logger.info('-----------------')
logger.info('Extracting X')
X = (resize_datasets([
datasets[train_folds[j]].X_all_images
for j in range(train_folds.shape[0])
], confunet.unet_im_size) * 255).astype(np.uint8)
logger.info('Extracting y')
y = (resize_datasets([
np.tile(
datasets[train_folds[j]].scores[:, :, np.newaxis, :].
astype(np.uint8) * 255, (1, 1, 3, 1))
for j in range(train_folds.shape[0])
], confunet.unet_im_size) * 255).astype(np.uint8)
# Set dirs
dir_my = os.path.join(dir_my_root, 'fold_' + str(pred_fold))
dir_my_train = os.path.join(dir_my, 'train')
logger.info('Writing _my_ train images/gts to disk...')
ims_my, gts_my = write_frames_train(X, y, dir_my_train, logger)
logger.info('Training U-Net on my segmentation...')
unet_my = UNetBasic.UNetBasic(confunet, dir_my_train, ims_my[0])
if (resume_model is not None):
model_path_my = get_model_path(dir_my_train,
take_min_loss=False)
initial_epoch_my = 0
if (len(model_path_my) == 0):
n_epochs_my = confunet.n_epochs
model_path_my = None
initial_epoch_my = 0
else:
n_epochs_my = confunet.n_epochs
initial_epoch_my = int(
os.path.split(model_path_my)[-1][6:8])
else:
model_path_my = None
n_epochs_my = confunet.n_epochs
initial_epoch_my = 0
unet_my.train(confunet,
ims_my,
gts_my,
dir_my_train,
n_epochs_my,
initial_epoch=initial_epoch_my,
dir_eval_clbk=dir_my,
resume_model=model_path_my)
logger.info('Extracting y')
y = (resize_datasets([
np.tile(
datasets[train_folds[j]].gt[:, :, np.newaxis, :].astype(
np.uint8) * 255, (1, 1, 3, 1))
for j in range(train_folds.shape[0])
], confunet.unet_im_size) * 255).astype(np.uint8)
dir_true = os.path.join(dir_true_root, 'fold_' + str(pred_fold))
dir_true_train = os.path.join(dir_true, 'train')
logger.info('Writing _true_ train images/gts to disk...')
ims_true, gts_true = write_frames_train(X, y, dir_true_train,
logger)
logger.info('Training U-Net on true segmentation...')
unet_true = UNetBasic.UNetBasic(confunet, dir_true_train,
ims_true[0])
if (resume_model is not None):
model_path_true = get_model_path(dir_true_train,
take_min_loss=False)
initial_epoch_true = 0
if (len(model_path_true) == 0):
n_epochs_true = confunet.n_epochs
model_path_true = None
initial_epoch_true = 0
else:
n_epochs_true = confunet.n_epochs
initial_epoch_true = int(
os.path.split(model_path_true)[-1][6:8])
else:
model_path_true = None
n_epochs_true = confunet.n_epochs
initial_epoch_true = 0
unet_true.train(confunet,
ims_true,
gts_true,
dir_true_train,
n_epochs_true,
initial_epoch=initial_epoch_true,
dir_eval_clbk=dir_true,
resume_model=model_path_true)
else:
logger.info('Results directory')
logger.info(dir_my_root)
logger.info(dir_true_root)
logger.info('Exist. Delete and re-compute')
logger.info('-----------------')
logger.info('Loading datasets...')
datasets = np.load(os.path.join(out_dir, 'datasets.npz'))['datasets']
if (pred):
from nets import UNetBasic
fold_ids = np.arange(0, 4)[::-1]
for i in range(n_folds):
pred_fold = i
logger.info('Predicting on fold_' + str(pred_fold))
dir_my = os.path.join(dir_my_root, 'fold_' + str(pred_fold))
dir_true = os.path.join(dir_true_root, 'fold_' + str(pred_fold))
#model_path_my = get_best_model_path(os.path.join(dir_my, 'train'))
model_path_my = get_model_path(os.path.join(dir_my, 'train'),
take_min_loss=False)
#model_path_true = get_best_model_path(os.path.join(dir_true,'train'))
model_path_true = get_model_path(os.path.join(dir_true, 'train'),
take_min_loss=False)
dir_true_pred = os.path.join(dir_true, 'pred')
dir_my_pred = os.path.join(dir_my, 'pred')
dir_true_pred_res = os.path.join(dir_true, 'pred_res')
dir_my_pred_res = os.path.join(dir_my, 'pred_res')
logger.info('Will use models:')
logger.info(model_path_my)
logger.info(model_path_true)
logger.info('Extracting y_my/y_true')
X = datasets[pred_fold].X_all_images
X = resize_stack(X, confunet.unet_im_size)
logger.info('Writing _my_ pred images to disk...')
ims_my = write_frames_pred(X, dir_my_pred, logger)
logger.info('Writing _true_ pred images to disk...')
ims_true = write_frames_pred(X, dir_true_pred, logger)
X = X.transpose((3, 0, 1, 2))
mean = np.mean(X.reshape(-1, 3), axis=0)
std = np.std(X.reshape(-1, 3), axis=0)
unet_true = UNetBasic.UNetBasic(confunet, dir_true_pred,
ims_true[0])
unet_my = UNetBasic.UNetBasic(confunet, dir_my_pred, ims_my[0])
# Get normalization parameters of training set
logger.info('Extracting X (train) normalization factors')
train_folds = np.asarray([
fold_ids[j] for j in range(n_folds)
if (fold_ids[j] != pred_fold)
])
im_list_train = [
datasets[train_folds[j]].conf.frameFileNames
for j in range(train_folds.shape[0])
]
im_list_train = [
item for sublist in im_list_train for item in sublist
]
input_y = unet_my.inputDimY
input_x = unet_my.inputDimX
n_chans = unet_my.nbrChannels
ims_train = UNetImpl.preprocess_imgs(unet_my, im_list_train,
input_y, input_x, n_chans)
#mean = np.mean(ims_train.reshape(-1,3), axis = 0)
#std = np.std(ims_train.reshape(-1,3), axis = 0)
#ims_train = utls.normalize_imgs(ims_train, mean, std)
logger.info('Predicting on my segmentation...')
preds_my = unet_my.eval(confunet, model_path_my, ims_my, mean, std)
logger.info('Predicting on true segmentation...')
preds_true = unet_true.eval(confunet, model_path_true, ims_true,
mean, std)
logger.info('Writing _my_ pred results images to disk...')
ims_my = write_frames_pred(preds_my,
dir_my_pred_res,
logger,
nchans=1)
logger.info('Writing _true_ pred results images to disk...')
ims_true = write_frames_pred(preds_true,
dir_true_pred_res,
logger,
nchans=1)
if (score):
for i in range(n_folds):
score_dict = dict()
pred_fold = i
logger.info('Scoring on fold_' + str(pred_fold))
dir_my = os.path.join(dir_my_root, 'fold_' + str(pred_fold))
dir_true = os.path.join(dir_true_root, 'fold_' + str(pred_fold))
dir_true_pred_res = os.path.join(dir_true, 'pred_res', 'img')
dir_my_pred_res = os.path.join(dir_my, 'pred_res', 'img')
fnames_true_pred_res = glob.glob(
os.path.join(dir_true_pred_res, '*.png'))
fnames_true_pred_res = sorted(fnames_true_pred_res)
fnames_my_pred_res = glob.glob(
os.path.join(dir_my_pred_res, '*.png'))
fnames_my_pred_res = sorted(fnames_my_pred_res)
my_preds = np.asarray([utls.imread(f) for f in fnames_my_pred_res
]).transpose(1, 2, 3, 0) / 255
true_preds = np.asarray(
[utls.imread(f)
for f in fnames_true_pred_res]).transpose(1, 2, 3, 0) / 255
gts = (resize_datasets([
np.tile(datasets[pred_fold].gt[:, :, np.newaxis, :],
(1, 1, 3, 1))
], confunet.unet_im_size) > 0).astype(np.uint8)
vals_gt = gts.ravel()
vals_my = my_preds.ravel()
vals_true = true_preds.ravel()
logger.info('Calculating metrics on my... ')
all_scores = get_all_scores(vals_gt, vals_my, n_points)
score_dict['conf'] = datasets[pred_fold].conf
score_dict['fold'] = pred_fold
score_dict['fpr_my'] = all_scores[0]
score_dict['tpr_my'] = all_scores[1]
score_dict['auc_my'] = all_scores[2]
score_dict['pr_my'] = all_scores[3]
score_dict['rc_my'] = all_scores[4]
score_dict['f1_my'] = all_scores[5]
score_dict['thr_my'] = all_scores[6]
logger.info('Calculating metrics on true... ')
all_scores = get_all_scores(vals_gt, vals_true, n_points)
score_dict['fpr_true'] = all_scores[0]
score_dict['tpr_true'] = all_scores[1]
score_dict['auc_true'] = all_scores[2]
score_dict['pr_true'] = all_scores[3]
score_dict['rc_true'] = all_scores[4]
score_dict['f1_true'] = all_scores[5]
score_dict['thr_true'] = all_scores[6]
score_dict['my_preds'] = my_preds
score_dict['true_preds'] = true_preds
logger.info('Saving results on fold: ' + str(pred_fold))
file_out = os.path.join(out_dir,
'scores_' + str(pred_fold) + '.npz')
np.savez(file_out, **score_dict)
preds_my.append([])
preds_true.append([])
path_ = os.path.join(rd.root_dir,
'learning_exps',
rd.learning_dirs_dict[key])
print('Loading: ' + path_)
dset = np.load(os.path.join(path_, 'datasets.npz'))['datasets']
folds = rd.best_folds_learning[key][0:2]
for fold in folds:
conf = dset[fold].conf
f = rd.self_frames_dict[key][fold]
cont_gt = segmentation.find_boundaries(
dset[fold].gt[..., f], mode='thick')
idx_cont_gt = np.where(cont_gt)
im = utls.imread(conf.frameFileNames[f])
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
ims[-1].append(im)
im_shape = im.shape
path_my = os.path.join(path_,
'my',
'fold_'+str(fold),
'pred_res',
'img',
'frame'+str(f)+'.png')
path_true = os.path.join(path_,
'true',
'fold_'+str(fold),
'pred_res',
'img',
'frame'+str(f)+'.png')
print('Deleting ' + out_dir_ims)
shutil.rmtree(out_dir_ims)
if(not os.path.exists(out_dir_gts)):
os.mkdir(out_dir_gts)
else:
print('Deleting ' + out_dir_gts)
shutil.rmtree(out_dir_gts)
ims_cropped = []
gts_cropped = []
print('Cropping:')
with progressbar.ProgressBar(maxval=len(ims)) as bar:
for i in range(len(ims)):
bar.update(i)
im = utls.imread(ims[i])
gt = utls.imread(gts[i])
new_im = im[top_left[0]:bot_right[0],top_left[1]:bot_right[1],:]
new_gt = gt[top_left[0]:bot_right[0],top_left[1]:bot_right[1],:]
ims_cropped.append(new_im)
gts_cropped.append(new_gt)
ims_resized = []
gts_resized = []
print('Resizing:')
with progressbar.ProgressBar(maxval=len(ims_cropped)) as bar:
for i in range(len(ims_cropped)):
bar.update(i)
new_im = resize(ims_cropped[i],out_size)
conf = rd.confs_dict_ksp[type_][dset_num][0]
dataset = ld.LearningDataset(conf)
dataset.load_labels_contours_if_not_exist()
dataset.load_labels_if_not_exist()
labels = dataset.labels
labels_contours = dataset.labelContourMask
colors_ = [
color_dict['red'], color_dict['green'], color_dict['blue'],
color_dict['magenta'], color_dict['white']
]
path_ = os.path.join(rd.root_dir, rd.res_dirs_dict_ksp_cov_ref[dset][20])
df_labels_ref = pd.read_csv(os.path.join(path_, 'labels_ref.csv'))
ref_frame = df_labels_ref.as_matrix()[0, 0]
im = utls.imread(conf.frameFileNames[ref_frame])
gt = dataset.gt
cont_gt = segmentation.find_boundaries(gt[..., ref_frame], mode='thick')
idx_cont_gt = np.where(cont_gt)
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
im = im.astype(float) / 255
ims_list.append(im)
for c in covs:
if (rd.res_dirs_dict_ksp_cov_ref[dset][c] is not None):
path_ = os.path.join(rd.root_dir,
rd.res_dirs_dict_ksp_cov_ref[dset][c])
print('Loading: ' + path_)
df_coverage = pd.read_csv(os.path.join(path_, 'coverage.csv'))
covs_list.append(df_coverage.iloc[0][1])
def main(conf, plot_fname='metrics.pdf', csv_fname='score.csv', logger=None):
logger = logging.getLogger('plot_results_vilar')
logger.info('--------')
logger.info('Self-learning on: ' + conf.dataOutDir)
logger.info('--------')
if (not os.path.exists(os.path.join(conf.dataOutDir, 'metrics.npz'))):
my_dataset = ds.DatasetVilar(conf)
my_dataset.load_labels_if_not_exist()
#l_dataset = learning_dataset.Dataset(conf)
l_dataset = learning_dataset.LearningDataset(conf)
logger.info('[1/4] Loading predicted frames... ')
pred_frames = np.asarray([
my_dataset.get_pred_frame(f)
for f in range(len(conf.frameFileNames))
]).transpose(1, 2, 0)
logger.info('[2/4] Extracting seeds... ')
seeds = utls.make_y_array_true(pred_frames, my_dataset.labels)
l_dataset.make_y_array_true(l_dataset.gt)
seeds_true = l_dataset.y_true
logger.info('[3/4] Calculating metrics... ')
f1 = f1_score(seeds_true[:, 2], seeds[:, 2])
logger.info('f1 score: ' + str(f1))
logger.info('[4/4] Calculating maps... ')
# Saving metrics
data = dict()
data['f1'] = f1
data['seeds'] = seeds
data['seeds_true'] = seeds_true
np.savez(os.path.join(conf.dataOutDir, 'metrics.npz'), **data)
else:
logger.info('Loading metrics.npz...')
metrics = np.load(os.path.join(conf.dataOutDir, 'metrics.npz'))
f1 = metrics['f1']
seeds = metrics['seeds']
seeds_true = metrics['seeds_true']
my_dataset = ds.DatasetVilar(conf)
my_dataset.load_labels_if_not_exist()
l_dataset = learning_dataset.LearningDataset(conf, pos_thr=0.5)
csv_out = os.path.join(conf.dataOutDir, csv_fname)
logger.info('Saving f1 scores to: ' + csv_fname)
C = pd.Index(["F1"], name="columns")
data = np.asarray(f1).reshape(1, 1)
df = pd.DataFrame(data=data, columns=C)
df.to_csv(path_or_buf=csv_out)
# Plot all iterations of PM
# Make plots
logger.info('Saving frames...')
gt = l_dataset.gt
frame_dir = 'vilar_frames'
frame_path = os.path.join(conf.dataOutDir, frame_dir)
if (os.path.exists(frame_path)):
logger.info('[!!!] Frame dir: ' + frame_path +
' exists. Delete to rerun.')
else:
os.mkdir(frame_path)
seeds_true = seeds_true[np.where(seeds_true[:, 2])[0], 0:2]
seeds = seeds[np.where(seeds[:, 2])[0], 0:2]
scores_true = utls.seeds_to_scores(my_dataset.labels, seeds_true)
scores = utls.seeds_to_scores(my_dataset.labels, seeds)
with progressbar.ProgressBar(maxval=len(conf.frameFileNames)) as bar:
for f in range(len(conf.frameFileNames)):
cont_gt = segmentation.find_boundaries(gt[..., f],
mode='thick')
idx_cont_gt = np.where(cont_gt)
im = utls.imread(conf.frameFileNames[f])
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
im = gaze.drawGazePoint(conf.myGaze_fg, f, im, radius=7)
pred_frame = my_dataset.get_pred_frame(f)
bar.update(f)
plt.subplot(321)
plt.imshow(scores_true[..., f])
plt.title('True')
plt.subplot(322)
plt.imshow(scores[..., f])
plt.title('Vilarino')
plt.subplot(323)
plt.imshow(im)
plt.title('image')
plt.subplot(324)
plt.imshow(pred_frame)
plt.title('pixel prediction')
plt.suptitle('frame: ' + str(f))
plt.savefig(os.path.join(frame_path, 'f_' + str(f) + '.png'),
dpi=200)
from sklearn.metrics import (f1_score,roc_curve,auc,precision_recall_curve)
import warnings, itertools, _pickle, progressbar, sys, os, datetime, yaml, hashlib
import my_utils as utls
import logging
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import learning_dataset as ld
from skimage import (color, segmentation, util, transform, io)
import gazeCsv as gaze
import results_dirs as rd
import shutil as sh
from PIL import Image, ImageFont, ImageDraw
n_decs = 2
dsets_per_type = 1
out_result_dir = os.path.join(rd.root_dir, 'plots_results')
im_path = '/home/laurent.lejeune/medical-labeling/Dataset00/input-frames/frame_0400.png'
unet_out_path = '/home/laurent.lejeune/medical-labeling/Dataset00/precomp_descriptors/gaze_out_example.npz'
unet_out = np.load(unet_out_path)['out']
import pdb; pdb.set_trace()
im = utls.imread(im_path)
#print('Saving to: ' + file_out)
#img.save(file_out)
def main(out_dir,
confs,
plot_fname='metrics',
metrics_fname='metrics.csv',
logger=None):
logger = logging.getLogger('plot_results_ksp')
out_dirs = [c.dataOutDir for c in confs]
logger.info('--------')
logger.info('Self-learning on: ')
logger.info(out_dirs)
logger.info('out_dir: ')
logger.info(out_dir)
logger.info('--------')
l_dataset = learning_dataset.LearningDataset(confs[0], pos_thr=0.5)
plot_curves(out_dir, confs, plot_fname, metrics_fname, logger)
l_ksp_scores = list()
l_ksp_ss_scores = list()
l_ksp_ss_thr_scores = list()
for i in range(len(confs)):
file_ = os.path.join(confs[i].dataOutDir, 'metrics.npz')
logger.info('Loading ' + file_)
npzfile = np.load(file_)
l_ksp_scores.append(npzfile['ksp_scores'])
l_ksp_ss_scores.append(npzfile['ksp_ss_scores'])
l_ksp_ss_thr_scores.append(npzfile['ksp_ss_thr_scores'])
# Make plots
mean_ksp_scores = np.mean(np.asarray(l_ksp_scores), axis=0)
mean_ksp_ss_scores = np.mean(np.asarray(l_ksp_ss_scores), axis=0)
mean_ksp_ss_thr_scores = np.mean(np.asarray(l_ksp_ss_thr_scores), axis=0)
std_ksp_scores = np.std(np.asarray(l_ksp_scores), axis=0)
std_ksp_ss_scores = np.std(np.asarray(l_ksp_ss_scores), axis=0)
std_ksp_ss_thr_scores = np.std(np.asarray(l_ksp_ss_thr_scores), axis=0)
path_ = os.path.join(out_dir, 'dataset.npz')
data = dict()
data['mean_ksp_scores'] = mean_ksp_scores
data['mean_ksp_ss_scores'] = mean_ksp_ss_scores
data['mean_ksp_ss_thr_scores'] = mean_ksp_ss_thr_scores
data['std_ksp_scores'] = std_ksp_scores
data['std_ksp_ss_scores'] = std_ksp_ss_scores
data['std_ksp_ss_thr_scores'] = std_ksp_ss_thr_scores
np.savez(path_, **data)
logger.info('Saving KSP, PM and SS merged frames...')
gt = l_dataset.gt
frame_dir = 'ksp_pm_frames'
frame_path = os.path.join(out_dir, frame_dir)
if (os.path.exists(frame_path)):
logger.info('[!!!] Frame dir: ' + frame_path +
' exists. Delete to rerun.')
else:
os.mkdir(frame_path)
c0 = confs[0]
with progressbar.ProgressBar(maxval=len(c0.frameFileNames)) as bar:
for f in range(len(c0.frameFileNames)):
cont_gt = segmentation.find_boundaries(gt[..., f],
mode='thick')
idx_cont_gt = np.where(cont_gt)
im = utls.imread(c0.frameFileNames[f])
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
for c in confs:
im = gaze.drawGazePoint(c.myGaze_fg, f, im, radius=7)
bar.update(f)
plt.subplot(241)
plt.imshow(mean_ksp_scores[..., f])
plt.title('mean KSP')
plt.subplot(242)
plt.imshow(std_ksp_scores[..., f])
plt.title('std KSP')
plt.subplot(243)
plt.imshow(mean_ksp_ss_scores[..., f])
plt.title('mean KSP+SS')
plt.subplot(244)
plt.imshow(std_ksp_ss_scores[..., f])
plt.title('std KSP+SS')
plt.subplot(245)
plt.imshow(mean_ksp_ss_thr_scores[..., f])
plt.title('mean KSP+SS -> PM -> (thr = %0.2f)' % (c.pm_thr))
plt.subplot(246)
plt.imshow(std_ksp_ss_thr_scores[..., f])
plt.title('std KSP+SS -> PM -> (thr = %0.2f)' % (c.pm_thr))
plt.subplot(247)
plt.imshow(im)
plt.title('image')
plt.suptitle('frame: ' + str(f))
plt.savefig(os.path.join(frame_path, 'f_' + str(f) + '.png'),
dpi=200)
def __init__(self,
frame_dir,
dataset_dir,
save_dir,
frames,
gts,
ref_frame,
pos_sps,
dir_clicks,
label_contours=None,
labels=None,
parent=None):
super(Window, self).__init__(parent)
self.setWindowTitle('Mes jolies images')
self.window = pg.ImageView(view=pg.PlotItem())
self.slider_text = vutls.SliderWithText()
self.label_contours = label_contours
self.labels = labels
self.setCentralWidget(self.window)
self.slider_text.slider.setMinimum(0)
self.slider_text.slider.setMaximum(len(frames))
self.slider_text.slider.setTickInterval(1)
self.slider_text.slider.setSingleStep(1)
self.label = QtGui.QLabel(self)
#self.label.setGeometry(160, 40, 80, 30)
self.savebutton = QtGui.QPushButton("Save")
self.frames = frames
self.ref_frame = ref_frame
self.frame_dir = frame_dir
self.dataset_dir = dataset_dir
self.save_dir = save_dir
self.gts = gts
self.pos_sps = pos_sps
self.dir_clicks = dir_clicks
self.curr_img = utls.imread(
os.path.join(self.frame_dir, self.frames[0]))
self.mouse_list_ref = []
self.mouse_list = []
self.labels_list_ref = []
self.labels_list = []
# add the menubar with the method createMenuBar()
self.createMenuBar()
# add the dock widget with the method createDockWidget()
self.createDockWidget()
#
# first set the default value to a
self.curr_idx = 0
self.max_idx = len(self.frames)
self.slider_text.slider.setValue(self.curr_idx)
self.drawFrame(self.curr_idx)
self.sliderValueChanged(0)
# Connect widgets to functions
self.slider_text.slider.valueChanged.connect(self.sliderValueChanged)
self.savebutton.clicked.connect(self.savebuttonClick)
def main(conf, logger=None):
logger = logging.getLogger('plot_results_ksp')
logger.info('--------')
logger.info('Self-learning on: ' + conf.dataOutDir)
logger.info('--------')
conf.pm_thr = 0.8
if (not os.path.exists(os.path.join(conf.dataOutDir, 'metrics.npz'))):
list_ksp = np.load(os.path.join(conf.dataOutDir,
'results.npz'))['list_ksp']
gt_dir = os.path.join(conf.root_path, conf.ds_dir, conf.truth_dir)
my_dataset = ds.Dataset(conf)
my_dataset.load_labels_if_not_exist()
my_dataset.load_pm_fg_from_file()
my_dataset.load_ss_from_file()
l_dataset = learning_dataset.LearningDataset(conf, pos_thr=0.5)
l_dataset.make_y_array_true(l_dataset.gt)
logger.info('[1/8] Calculating metrics on KSP+SS PM... ')
#probas_thr = np.linspace(0,1,20)
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[-1]))
new_seeds = ss.thr_all_graphs(my_dataset.g_ss, seeds, conf.ss_thr)
my_dataset.fg_marked = new_seeds
l_dataset.set_seeds(new_seeds)
l_dataset.make_y_array(l_dataset.seeds)
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
feat_fields=['desc'],
T=conf.T,
bag_max_depth=conf.bag_max_depth,
bag_n_feats=conf.bag_n_feats)
probas_ksp_ss_pm = my_dataset.fg_pm_df['proba'].as_matrix()
fpr_pm_ss, tpr_pm_ss, _ = roc_curve(l_dataset.y_true[:, 2],
probas_ksp_ss_pm)
pr_pm_ss, rc_pm_ss, _ = precision_recall_curve(l_dataset.y_true[:, 2],
probas_ksp_ss_pm)
probas_thr = np.unique(probas_ksp_ss_pm)
f1_pm_ss = [
f1_score(l_dataset.y_true[:, 2], probas_ksp_ss_pm > p)
for p in probas_thr
]
fpr_ksp = [0.]
tpr_ksp = [0.]
pr_ksp = [1.]
rc_ksp = [0.]
f1_ksp = []
logger.info('[2/8] Calculating metrics on KSP... ')
for i in range(len(list_ksp)):
logger.info('iter: ' + str(i + 1) + '/' + str(len(list_ksp)))
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[i]))
l_dataset.set_seeds(seeds)
l_dataset.make_y_array(l_dataset.seeds)
fpr, tpr, _ = roc_curve(l_dataset.y_true[:, 2], l_dataset.y[:, 2])
precision, recall, _ = precision_recall_curve(
l_dataset.y_true[:, 2], l_dataset.y[:, 2])
f1_ksp.append(f1_score(l_dataset.y_true[:, 2], l_dataset.y[:, 2]))
fpr_ksp.append(fpr[1])
tpr_ksp.append(tpr[1])
pr_ksp.append(precision[1])
rc_ksp.append(recall[1])
fpr_ksp.append(1.)
tpr_ksp.append(1.)
pr_ksp.append(0.)
rc_ksp.append(1.)
fpr_ksp_ss = [0.]
tpr_ksp_ss = [0.]
pr_ksp_ss = [1.]
rc_ksp_ss = [0.]
f1_ksp_ss = []
logger.info('[3/8] Calculating metrics on KSP+SS... ')
for i in range(len(list_ksp)):
logger.info('iter: ' + str(i + 1) + '/' + str(len(list_ksp)))
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[i]))
new_seeds = ss.thr_all_graphs(my_dataset.g_ss, seeds, conf.ss_thr)
l_dataset.set_seeds(new_seeds)
l_dataset.make_y_array(l_dataset.seeds)
fpr, tpr, _ = roc_curve(l_dataset.y_true[:, 2], l_dataset.y[:, 2])
precision, recall, _ = precision_recall_curve(
l_dataset.y_true[:, 2], l_dataset.y[:, 2])
f1_ksp_ss.append(
f1_score(l_dataset.y_true[:, 2], l_dataset.y[:, 2]))
fpr_ksp_ss.append(fpr[1])
tpr_ksp_ss.append(tpr[1])
pr_ksp_ss.append(precision[1])
rc_ksp_ss.append(recall[1])
fpr_ksp_ss.append(1.)
tpr_ksp_ss.append(1.)
pr_ksp_ss.append(0.)
rc_ksp_ss.append(1.)
#Will append thresholded values to old
fpr_ksp_ss_thr = list(fpr_ksp_ss)
tpr_ksp_ss_thr = list(tpr_ksp_ss)
pr_ksp_ss_thr = list(pr_ksp_ss)
rc_ksp_ss_thr = list(rc_ksp_ss)
f1_ksp_ss_thr = list(f1_ksp_ss)
#probas_ksp_ss_pm = my_dataset.fg_pm_df['proba'].as_matrix()
logger.info('[4/8] Calculating metrics on KSP+SS thresholded... ')
y_ksp_ss_thr = probas_ksp_ss_pm > conf.pm_thr
fpr, tpr, _ = roc_curve(l_dataset.y_true[:, 2],
y_ksp_ss_thr.astype(float))
precision, recall, _ = precision_recall_curve(
l_dataset.y_true[:, 2], y_ksp_ss_thr.astype(float))
f1_ksp_ss_thr.append(
f1_score(l_dataset.y_true[:, 2], y_ksp_ss_thr.astype(float)))
fpr_ksp_ss_thr.append(fpr[1])
tpr_ksp_ss_thr.append(tpr[1])
rc_ksp_ss_thr.append(recall[1])
pr_ksp_ss_thr.append(precision[1])
logger.info('[5/8] Calculating metrics on PM... ')
#probas_thr = np.linspace(0,1,20)
fpr_pm = []
tpr_pm = []
pr_pm = []
rc_pm = []
f1_pm = []
for i in range(len(list_ksp)):
logger.info('iter: ' + str(i + 1) + '/' + str(len(list_ksp)))
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[i]))
my_dataset.fg_marked = seeds
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
bag_n_feats=conf.max_feats_ratio,
feat_fields=['desc'])
probas = my_dataset.fg_pm_df['proba'].as_matrix()
fpr, tpr, _ = roc_curve(l_dataset.y_true[:, 2], probas)
precision, recall, _ = precision_recall_curve(
l_dataset.y_true[:, 2], probas)
probas_thr = np.unique(probas)
f1_pm_ = [
f1_score(l_dataset.y_true[:, 2], probas > p)
for p in probas_thr
]
f1_pm.append(f1_pm_)
fpr_pm.append(fpr)
tpr_pm.append(tpr)
pr_pm.append(precision)
rc_pm.append(recall)
logger.info('[6/8] Calculating metrics on true ground-truth... ')
seeds_gt = l_dataset.y_true[l_dataset.y_true[:, 2] == 1, :]
my_dataset.fg_marked = seeds_gt
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
bag_n_feats=conf.max_feats_ratio,
feat_fields=['desc'])
probas = my_dataset.fg_pm_df['proba'].as_matrix()
fpr_gt, tpr_gt, _ = roc_curve(l_dataset.y_true[:, 2], probas)
pr_gt, rc_gt, _ = precision_recall_curve(l_dataset.y_true[:, 2],
probas)
probas_thr = np.unique(probas)
f1_gt = [
f1_score(l_dataset.y_true[:, 2], probas > p) for p in probas_thr
]
#Make PM and KSP frames on SS
logger.info('[7/8] Making prediction maps of KSP and KSP+SS PM... ')
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[-1]))
ksp_scores = utls.get_scores_from_sps(seeds, my_dataset.labels)
new_seeds = ss.thr_all_graphs(my_dataset.g_ss, seeds, conf.ss_thr)
ksp_ss_scores = utls.get_scores_from_sps(new_seeds, my_dataset.labels)
my_dataset.fg_marked = np.asarray(
utls.get_node_list_tracklets(list_ksp[-1]))
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
bag_n_feats=conf.max_feats_ratio,
feat_fields=['desc'])
pm_ksp = my_dataset.get_pm_array(mode='foreground')
my_dataset.fg_marked = new_seeds
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
bag_n_feats=conf.max_feats_ratio,
feat_fields=['desc'])
pm_ksp_ss = my_dataset.get_pm_array(mode='foreground')
#Make PM and KSP frames on SS
f1_pm_thr = []
fpr_pm_thr = []
tpr_pm_thr = []
rc_pm_thr = []
pr_pm_thr = []
logger.info(
'[8/8] Making prediction maps and metrics of KSP+SS PM thresholded... '
)
new_seeds_thr_frames = my_dataset.fg_pm_df.loc[y_ksp_ss_thr,
'frame'].as_matrix()
new_seeds_thr_labels = my_dataset.fg_pm_df.loc[y_ksp_ss_thr,
'sp_label'].as_matrix()
new_seeds_thr = np.concatenate((new_seeds_thr_frames.reshape(
-1, 1), new_seeds_thr_labels.reshape(-1, 1)),
axis=1)
ksp_ss_thr_scores = utls.get_scores_from_sps(new_seeds_thr,
my_dataset.labels)
my_dataset.fg_marked = new_seeds_thr
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
bag_n_feats=conf.max_feats_ratio,
feat_fields=['desc'])
pm_ksp_ss_thr = my_dataset.get_pm_array(mode='foreground')
probas = my_dataset.fg_pm_df['proba'].as_matrix()
fpr, tpr, _ = roc_curve(l_dataset.y_true[:, 2], probas)
precision, recall, _ = precision_recall_curve(l_dataset.y_true[:, 2],
probas)
probas_thr = np.unique(probas)
f1_pm_thr_ = [
f1_score(l_dataset.y_true[:, 2], probas > p) for p in probas_thr
]
f1_pm_thr.append(f1_pm_thr_)
fpr_pm_thr.append(fpr)
tpr_pm_thr.append(tpr)
pr_pm_thr.append(precision)
rc_pm_thr.append(recall)
##Saving metrics
data = dict()
data['probas_thr'] = probas_thr
data['fpr_pm'] = fpr_pm
data['tpr_pm'] = tpr_pm
data['pr_pm'] = pr_pm
data['rc_pm'] = rc_pm
data['f1_pm'] = f1_pm
data['fpr_pm_thr'] = fpr_pm_thr
data['tpr_pm_thr'] = tpr_pm_thr
data['pr_pm_thr'] = pr_pm_thr
data['rc_pm_thr'] = rc_pm_thr
data['f1_pm_thr'] = f1_pm_thr
data['fpr_ksp'] = fpr_ksp
data['tpr_ksp'] = tpr_ksp
data['pr_ksp'] = pr_ksp
data['rc_ksp'] = rc_ksp
data['f1_ksp'] = f1_ksp
data['fpr_ksp_ss'] = fpr_ksp_ss
data['tpr_ksp_ss'] = tpr_ksp_ss
data['pr_ksp_ss'] = pr_ksp_ss
data['rc_ksp_ss'] = rc_ksp_ss
data['f1_ksp_ss'] = f1_ksp_ss
data['fpr_ksp_ss_thr'] = fpr_ksp_ss_thr
data['tpr_ksp_ss_thr'] = tpr_ksp_ss_thr
data['pr_ksp_ss_thr'] = pr_ksp_ss_thr
data['rc_ksp_ss_thr'] = rc_ksp_ss_thr
data['f1_ksp_ss_thr'] = f1_ksp_ss_thr
data['fpr_pm_ss'] = fpr_pm_ss
data['tpr_pm_ss'] = tpr_pm_ss
data['pr_pm_ss'] = pr_pm_ss
data['rc_pm_ss'] = rc_pm_ss
data['f1_pm_ss'] = f1_pm_ss
data['fpr_gt'] = fpr_gt
data['tpr_gt'] = tpr_gt
data['pr_gt'] = pr_gt
data['rc_gt'] = rc_gt
data['f1_gt'] = f1_gt
#ksp_ss_thr_scores
data['seeds'] = seeds
data['ksp_scores'] = ksp_scores
data['new_seeds'] = seeds_gt
data['ksp_ss_scores'] = ksp_ss_scores
data['ksp_ss_thr_scores'] = ksp_ss_thr_scores
data['pm_ksp'] = pm_ksp
data['pm_ksp_ss'] = pm_ksp_ss
data['pm_ksp_ss_thr'] = pm_ksp_ss_thr
np.savez(os.path.join(conf.dataOutDir, 'metrics.npz'), **data)
else:
logger.info('Loading metrics.npz...')
metrics = np.load(os.path.join(conf.dataOutDir, 'metrics.npz'))
probas_thr = metrics['probas_thr']
fpr_pm = metrics['fpr_pm']
tpr_pm = metrics['tpr_pm']
pr_pm = metrics['pr_pm']
rc_pm = metrics['rc_pm']
f1_pm = metrics['f1_pm']
fpr_pm_thr = metrics['fpr_pm_thr']
tpr_pm_thr = metrics['tpr_pm_thr']
pr_pm_thr = metrics['pr_pm_thr']
rc_pm_thr = metrics['rc_pm_thr']
f1_pm_thr = metrics['f1_pm_thr']
fpr_ksp = metrics['fpr_ksp']
tpr_ksp = metrics['tpr_ksp']
pr_ksp = metrics['pr_ksp']
rc_ksp = metrics['rc_ksp']
f1_ksp = metrics['f1_ksp']
fpr_ksp_ss = metrics['fpr_ksp_ss']
tpr_ksp_ss = metrics['tpr_ksp_ss']
pr_ksp_ss = metrics['pr_ksp_ss']
rc_ksp_ss = metrics['rc_ksp_ss']
f1_ksp_ss = metrics['f1_ksp_ss']
fpr_ksp_ss_thr = metrics['fpr_ksp_ss_thr']
tpr_ksp_ss_thr = metrics['tpr_ksp_ss_thr']
pr_ksp_ss_thr = metrics['pr_ksp_ss_thr']
rc_ksp_ss_thr = metrics['rc_ksp_ss_thr']
f1_ksp_ss_thr = metrics['f1_ksp_ss_thr']
fpr_pm_ss = metrics['fpr_pm_ss']
tpr_pm_ss = metrics['tpr_pm_ss']
pr_pm_ss = metrics['pr_pm_ss']
rc_pm_ss = metrics['rc_pm_ss']
f1_pm_ss = metrics['f1_pm_ss']
fpr_gt = metrics['fpr_gt']
tpr_gt = metrics['tpr_gt']
pr_gt = metrics['pr_gt']
rc_gt = metrics['rc_gt']
f1_gt = metrics['f1_gt']
seeds = metrics['seeds']
ksp_scores = metrics['ksp_scores']
seeds_gt = metrics['new_seeds']
ksp_ss_scores = metrics['ksp_ss_scores']
ksp_ss_thr_scores = metrics['ksp_ss_thr_scores']
pm_ksp = metrics['pm_ksp']
pm_ksp_ss = metrics['pm_ksp_ss']
pm_ksp_ss_thr = metrics['pm_ksp_ss_thr']
my_dataset = ds.Dataset(conf)
my_dataset.load_labels_if_not_exist()
my_dataset.load_pm_fg_from_file()
my_dataset.load_ss_from_file()
l_dataset = learning_dataset.LearningDataset(conf, pos_thr=0.5)
list_ksp = np.load(os.path.join(conf.dataOutDir,
'results.npz'))['list_ksp']
#Plot all iterations of PM
plt.clf()
conf.roc_xlim = [0, 0.4]
conf.pr_rc_xlim = [0.6, 1.]
colors = cycle([
'brown', 'indigo', 'seagreen', 'yellow', 'blue', 'darkorange',
'slateblue', 'lightpink', 'darkmagenta'
])
lw = 1
#PM curves
for i, color in zip(range(len(tpr_pm)), colors):
auc_ = auc(fpr_pm[i], tpr_pm[i])
max_f1 = np.max(f1_pm[i])
plt.subplot(121)
plt.plot(fpr_pm[i],
tpr_pm[i],
'-',
lw=lw,
color=color,
label='KSP/PM iter. %d (area = %0.4f, max(F1) = %0.4f)' %
(i + 1, auc_, max_f1))
auc_ = auc(rc_pm[i], pr_pm[i])
plt.subplot(122)
plt.plot(rc_pm[i],
pr_pm[i],
'-',
lw=lw,
color=color,
label='KSP/PM iter. %d (area = %0.4f, max(F1) = %0.4f)' %
(i + 1, auc_, max_f1))
#Plot true groundtruth
#auc_ = auc(fpr_gt, tpr_gt)
#max_f1 = np.max(f1_gt)
#plt.subplot(121)
#plt.plot(fpr_gt, tpr_gt,'r-', lw=lw,
# label='GT (area = %0.4f, max(F1) = %0.4f)' % (auc_,max_f1))
#plt.subplot(122)
#auc_ = auc(rc_gt, pr_gt)
#plt.plot(rc_gt, pr_gt,'r-', lw=lw,
# label='GT (area = %0.4f, max(F1) = %0.4f)' % (auc_,max_f1))
#Plot KSP
auc_ = auc(fpr_ksp, tpr_ksp, reorder=True)
max_f1 = np.max(f1_ksp)
plt.subplot(121)
plt.plot(fpr_ksp,
tpr_ksp,
'go--',
lw=lw,
label='KSP (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
plt.subplot(122)
auc_ = auc(rc_ksp, pr_ksp, reorder=True)
plt.plot(rc_ksp,
pr_ksp,
'go--',
lw=lw,
label='KSP (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
#Plot KSP+SS
auc_ = auc(fpr_ksp_ss, tpr_ksp_ss, reorder=True)
max_f1 = np.max(f1_ksp_ss)
plt.subplot(121)
plt.plot(fpr_ksp_ss,
tpr_ksp_ss,
'ro--',
lw=lw,
label='KSP+SS (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
plt.subplot(122)
auc_ = auc(rc_ksp_ss, pr_ksp_ss, reorder=True)
plt.plot(rc_ksp_ss,
pr_ksp_ss,
'ro--',
lw=lw,
label='KSP+SS (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
#Plot KSP+SS thresholded
auc_ = auc(fpr_ksp_ss_thr, tpr_ksp_ss_thr, reorder=True)
max_f1 = np.max(f1_ksp_ss_thr)
plt.subplot(121)
plt.plot(np.sort(fpr_ksp_ss_thr),
np.sort(tpr_ksp_ss_thr),
'ko--',
lw=lw,
label='KSP+SS (thr = %0.2f) (area = %0.4f, max(F1) = %0.4f)' %
(conf.pm_thr, auc_, max_f1))
plt.subplot(122)
auc_ = auc(np.asarray(rc_ksp_ss_thr).ravel(),
np.asarray(pr_ksp_ss_thr).ravel(),
reorder=True)
plt.plot(np.sort(rc_ksp_ss_thr)[::-1],
np.sort(pr_ksp_ss_thr[::-1]),
'ko--',
lw=lw,
label='KSP+SS (thr = %0.2f) (area = %0.4f, max(F1) = %0.4f)' %
(conf.pm_thr, auc_, max_f1))
#Plot KSP+SS PM
auc_ = auc(fpr_pm_ss, tpr_pm_ss)
max_f1 = np.max(f1_pm_ss)
plt.subplot(121)
plt.plot(np.asarray(fpr_pm_ss).ravel(),
np.asarray(tpr_pm_ss).ravel(),
'm-',
lw=lw,
label='KSP+SS/PM (area = %0.4f, max(F1) = %0.4f)' %
(auc_, max_f1))
plt.subplot(122)
auc_ = auc(rc_pm_ss, pr_pm_ss)
plt.plot(rc_pm_ss,
pr_pm_ss,
'm-',
lw=lw,
label='KSP+SS/PM (area = %0.4f, max(F1) = %0.4f)' %
(auc_, max_f1))
#Plot KSP+SS PM thresholded
auc_ = auc(np.asarray(fpr_pm_thr).ravel(), np.asarray(tpr_pm_thr).ravel())
max_f1 = np.max(f1_pm_thr)
plt.subplot(121)
plt.plot(
np.asarray(fpr_pm_thr).ravel(),
np.asarray(tpr_pm_thr).ravel(),
'c-',
lw=lw,
label='KSP+SS/PM (thr = %0.2f)/PM (area = %0.4f, max(F1) = %0.4f)' %
(conf.pm_thr, auc_, max_f1))
plt.subplot(122)
auc_ = auc(np.asarray(rc_pm_thr).ravel(), np.asarray(pr_pm_thr).ravel())
plt.plot(np.asarray(rc_pm_thr).ravel(),
np.asarray(pr_pm_thr).ravel(),
'c-',
lw=lw,
label='KSP+SS/PM (thr = %0.2f) (area = %0.4f, max(F1) = %0.4f)' %
(conf.pm_thr, auc_, max_f1))
plt.subplot(121)
plt.legend()
plt.xlim(conf.roc_xlim)
plt.xlabel('fpr')
plt.ylabel('tpr')
plt.subplot(122)
plt.legend()
plt.xlim(conf.pr_rc_xlim)
plt.xlabel('recall')
plt.ylabel('precision')
plt.suptitle(conf.seq_type + ', ' + conf.ds_dir + '\n' + 'T: ' +
str(conf.T))
fig = plt.gcf()
fig.set_size_inches(18.5, 10.5)
fig.savefig(os.path.join(conf.dataOutDir, 'metrics.eps'), dpi=200)
###Make plots
logger.info('Saving KSP, PM and SS merged frames...')
gt = l_dataset.gt
frame_dir = 'ksp_pm_frames'
frame_path = os.path.join(conf.dataOutDir, frame_dir)
if (os.path.exists(frame_path)):
logger.info('[!!!] Frame dir: ' + frame_path +
' exists. Delete to rerun.')
else:
n_iters_ksp = len(list_ksp)
os.mkdir(frame_path)
with progressbar.ProgressBar(maxval=len(conf.frameFileNames)) as bar:
for f in range(len(conf.frameFileNames)):
cont_gt = segmentation.find_boundaries(gt[..., f],
mode='thick')
idx_cont_gt = np.where(cont_gt)
im = utls.imread(conf.frameFileNames[f])
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
im = gaze.drawGazePoint(conf.myGaze_fg, f, im, radius=7)
bar.update(f)
plt.subplot(231)
plt.imshow(ksp_scores[..., f])
plt.title('KSP')
plt.subplot(232)
plt.imshow(pm_ksp[..., f])
plt.title('KSP -> PM')
plt.subplot(233)
plt.imshow(ksp_ss_scores[..., f])
plt.title('KSP+SS')
plt.subplot(234)
plt.imshow(ksp_ss_thr_scores[..., f])
plt.title('KSP+SS -> PM -> (thr = %0.2f)' % (conf.pm_thr))
plt.subplot(235)
plt.imshow(pm_ksp_ss_thr[..., f])
plt.title('KSP+SS -> PM -> (thr = %0.2f) -> PM' %
(conf.pm_thr))
plt.subplot(236)
plt.imshow(im)
plt.title('image')
plt.suptitle('frame: ' + str(f) + ', n_iters_ksp: ' +
str(n_iters_ksp))
plt.savefig(os.path.join(frame_path, 'f_' + str(f) + '.png'),
dpi=200)
logger.info('Saving SPs per iterations plot...')
n_sps = []
for i in range(len(list_ksp)):
n = np.asarray(utls.get_node_list_tracklets(list_ksp[i])).shape[0]
n_sps.append((i + 1, n))
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[-1]))
n = ss.thr_all_graphs(my_dataset.g_ss, seeds, conf.ss_thr).shape[0]
n_sps.append((len(list_ksp) + 1, n))
n_sps = np.asarray(n_sps)
plt.clf()
plt.plot(n_sps[:, 0], n_sps[:, 1], 'bo-')
plt.plot(n_sps[-1, 0], n_sps[-1, 1], 'ro')
plt.xlabel('iterations')
plt.ylabel('num. of superpixels')
plt.title('num of superpixels vs. iterations. SS threshold: ' +
str(conf.ss_thr))
plt.savefig(os.path.join(conf.dataOutDir, 'sps_iters.eps'), dpi=200)
def getMeanSPs(sp, feature2d, frameFileNames, denseStep, sp_num_iterations):
"""
Computes mean descriptors inside superpixel segmentation for a set of images
Parameters
----------
sp : Superpixel object
feature2d : OpenCV object to compute keypoints and descriptors
frameFileNames : list of strings
Complete path to set of images
denseStep : Step size of grid in which keypoints are generated
sp_num_iterations : Number of iterations for superpixel method
Returns
-------
avgDesc : list of list
Average descriptor of each superpixel
kps : list of list
Keypoints (all of them)
desc : list of list
Descriptors (all of them)
labels : list of arrays
Superpixel labels of each image
spLabelContourMask : list of arrays
Superpixel contour mask of each image
"""
keyFramesIdx = np.arange(0, len(frameFileNames))
labels = []
spLabelContourMask = []
kpKeyFrame = []
avgDesc = []
kps = []
desc = []
for keyFrame in keyFramesIdx:
sys.stdout.write("Processing frame %i/%i \n" %
(keyFrame, len(keyFramesIdx) - 1))
img = utils.imread(frameFileNames[keyFrame])
sp.iterate(cv2.cvtColor(img, cv2.COLOR_RGB2HSV), sp_num_iterations)
spLabelToCheck = sp.getLabels()
while (True):
detectedEmpty = False
kpDense = [
cv2.KeyPoint(x, y, denseStep)
for y in range(0, img.shape[0], denseStep)
for x in range(0, img.shape[1], denseStep)
]
mask = np.zeros(img.shape)
for i in range(sp.getNumberOfSuperpixels()):
mask = (spLabelToCheck == i)
thisSPkps, thisSPkpsIdx = maskKeypoints(kpDense, mask)
if len(thisSPkps) == 0:
detectedEmpty = True
denseStep -= 1
#print denseStep
break
#print "A region without keypoints was detected, reducing keypoint step size by 1 on this image"
if detectedEmpty == False:
break
labels.append(spLabelToCheck)
spLabelContourMask.append(sp.getLabelContourMask())
kptmp, destmp = feature2d.compute(img, kpDense)
kps.append(kptmp)
desc.append(destmp)
#Average descriptors contained in superpixels
thisFrameAvgDesc = []
for i in range(sp.getNumberOfSuperpixels()):
mask = (labels[-1] == i)
thisSPkps, thisSPkpsIdx = maskKeypoints(kps[-1], mask)
thisSPDesc = desc[-1][thisSPkpsIdx]
#print thisSPDesc
#print "thisSPDesc.shape: ", thisSPDesc.shape
#thisFrameAvgDesc.append(np.mean(thisSPDesc,axis=0))
thisFrameAvgDesc.append(np.mean(thisSPDesc, axis=0))
avgDesc.append(thisFrameAvgDesc)
avgDesc = np.asarray(avgDesc)
#return(avgDesc,kps,desc,labels,spLabelContourMask)
return (np.asarray(avgDesc), kps, desc, labels, spLabelContourMask)
rd.out_dirs_dict_ksp[key][dset])
# Make images/gts/gaze-point
ims.append([])
ksp_means.append([])
l_dataset = ld.LearningDataset(rd.confs_dict_ksp[key][dset][0],
pos_thr=0.5)
confs = rd.confs_dict_ksp[key][dset]
gt = l_dataset.gt
ksp_mean_all = np.load(os.path.join(
path_, 'dataset.npz'))['mean_ksp_scores']
for f in rd.all_frames_dict[key][dset]:
cont_gt = segmentation.find_boundaries(gt[..., f],
mode='thick')
idx_cont_gt = np.where(cont_gt)
im = utls.imread(confs[0].frameFileNames[f])
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
for key_conf in confs.keys():
im = gaze.drawGazePoint(confs[key_conf].myGaze_fg,
f,
im,
radius=7)
ims[-1].append(im)
ksp_means[-1].append(ksp_mean_all[..., f])
data = {'ims': ims, 'ksp_means': ksp_means}
np.savez(file_out, **data)
else:
print('Loading: ' + file_out)
npzfile = np.load(file_out)
def calc_training_patches(self, save=False):
ps = self.conf.patch_size
my_gaze = self.conf.myGaze_fg
scale_factor = self.conf.scale_factor
seen_patches = list()
unseen_patches = list()
selem = morphology.square(5)
print('Getting seen patches')
with progressbar.ProgressBar(maxval=len(self.conf.frameFileNames)) as bar:
for i in range(len(self.conf.frameFileNames)):
bar.update(i)
img = utls.imread(self.conf.frameFileNames[i])
img = (color.rgb2gray(img)*255).astype(np.uint8)
img = median(img, selem=selem) # Uses square of size 3
ci_seen, cj_seen = gaze.gazeCoord2Pixel(
my_gaze[i, 3], my_gaze[i, 4], img.shape[1], img.shape[0])
i_, j_ = self.get_centers_negatives(ci_seen, cj_seen, ps,
self.conf.overlap_ratio,
img.shape)
img_padded = pad(img,((ps,ps),),mode='symmetric')
seen_patch = img_padded[int(ci_seen + ps/2):int(ci_seen + 3*ps/2),int(cj_seen + ps/2):int(cj_seen + 3*ps/2)]
seen_patch_mean = np.mean(seen_patch)
seen_patch_std = np.std(seen_patch)
if(seen_patch_std == 0): seen_patch_std = 1
seen_patch = (seen_patch - seen_patch_mean) / seen_patch_std
seen_patch = rescale(
seen_patch,
scale=scale_factor,
order=1,
mode='reflect',
preserve_range=True)
seen_patches.append((i,
ci_seen,
cj_seen,
seen_patch.ravel()))
for k in range(i_.shape[0]):
unseen_patch = img[int(i_[k]- ps / 2):int(i_[k] + ps / 2), int(
j_[k]- ps / 2):int(j_[k]+ ps / 2)]
unseen_patch_mean = np.mean(unseen_patch)
unseen_patch_std = np.std(unseen_patch)
if(unseen_patch_std == 0): unseen_patch_std = 1
unseen_patch = (unseen_patch - unseen_patch_mean) / unseen_patch_std
unseen_patch = rescale(
unseen_patch,
scale=scale_factor,
order=1,
mode='reflect',
preserve_range=True)
unseen_patches.append((i,
i_[k],
j_[k],
unseen_patch.ravel()))
if(save):
seen_patches_df = pd.DataFrame(seen_patches,
columns=['frame',
'c_i',
'c_j',
'patch'])
unseen_patches_df = pd.DataFrame(unseen_patches,
columns=['frame',
'c_i',
'c_j',
'patch'])
save_path = os.path.join(self.conf.dataOutDir,
'vilar')
if(not os.path.exists(save_path)):
os.mkdir(save_path)
seen_patches_df.to_pickle(os.path.join(save_path,
'vilar_seen_patches_df.p'))
unseen_patches_df.to_pickle(
os.path.join(save_path,
'vilar_unseen_patches_df.p'))
return True
def make_frame(idx,
ref_idx,
frames,
labels,
label_contours,
gts,
labels_clicked,
mouse_clicks,
mode='right',
highlight_idx=None):
if (mode == 'right'):
the_idx = idx
else:
the_idx = ref_idx
shape = labels[:, :, 0].shape
colors_ = [
color_dict['red'], color_dict['green'], color_dict['blue'],
color_dict['magenta'], color_dict['white']
]
mask = np.zeros(shape, dtype=np.uint8)
img = utls.imread(frames[the_idx])
if (img.shape[2] > 3): img = img[:, :, 0:3]
if (label_contours is not None):
idx_contours = np.where(label_contours[the_idx, :, :])
img[idx_contours[0], idx_contours[1], :] = (255, 255, 255)
l_ = (utls.imread(gts[the_idx]) > 0)[..., 0].astype(np.uint8)
l_idx = np.where(l_)
mask[l_idx[0], l_idx[1]] = 1
#Draw set of tracked labels
if (mode == 'right'):
labels_to_draw = [l[-1] for l in labels_clicked if (l[1] == idx)]
else:
print('labels_clicked: ' + str(labels_clicked))
print('idx: ' + str(idx))
labels_to_draw = [l[-1] for l in labels_clicked if (l[0] == ref_idx)]
print('labels_to_draw: ' + str(labels_to_draw))
if (len(labels_to_draw) > 0):
#print(self.curr_idx)
for i in range(len(labels_to_draw)):
this_label = labels_to_draw[i]
mask_tmp = labels[:, :, the_idx] == this_label
l_ = mask_tmp.astype(np.uint8)
l_idx = np.where(l_)
mask[l_idx[0], l_idx[1]] = 2
if (mode == 'right'):
mouse_clicks_to_draw = [r for r in mouse_clicks if (r[1] == idx)]
#print(mouse_clicks_to_draw)
else:
mouse_clicks_to_draw = [r for r in mouse_clicks if (r[0] == ref_idx)]
#mouse_clicks_to_draw = mouse_clicks
if (len(mouse_clicks_to_draw) > 0):
for i in range(len(mouse_clicks_to_draw)):
x = mouse_clicks_to_draw[i][-2]
y = mouse_clicks_to_draw[i][-1]
g_i, g_j = gaze.gazeCoord2Pixel(x, y, mask.shape[1], mask.shape[0])
rr, cc = circle(g_i, g_j, radius=7)
mask[rr, cc] = 3
#mask = np.zeros(shape, dtype=np.uint8)
#if(highlight_idx is not None):
# mouse_clicks_to_draw = [r for r in mouse_clicks if(r[0] in highlight_idx)]
# for i in range(len(mouse_clicks_to_draw)):
# x = mouse_clicks_to_draw[i][3]
# y = mouse_clicks_to_draw[i][4]
# g_i, g_j = gaze.gazeCoord2Pixel(x,
# y,
# mask.shape[1],
# mask.shape[0])
# rr, cc = circle(g_i, g_j, radius=7)
# mask[rr, cc] = 4
img = color.label2rgb(mask, img, alpha=.2, bg_label=0, colors=colors_)
img = np.rot90(img)[::-1, :, :]
return img
def main(confs, out_dir=None):
alpha = 0.3
n_points = 2000
seq_type = confs[0].seq_type
if (out_dir is None):
now = datetime.datetime.now()
dateTime = now.strftime("%Y-%m-%d_%H-%M-%S")
out_dir = os.path.join(
confs[0].dataOutRoot, 'learning_exps',
'learning_' + confs[0].seq_type + '_' + dateTime)
dir_in = [c.dataOutDir for c in confs]
if (not os.path.exists(out_dir)):
os.mkdir(out_dir)
datasets = []
utls.setup_logging(out_dir)
logger = logging.getLogger('learning_exp')
logger.info('Starting learning experiment on:')
logger.info(dir_in)
logger.info('Gaze file: ' + str(confs[0].csvFileName_fg))
logger.info('')
if (not os.path.exists(os.path.join(out_dir, 'datasets.npz'))):
logger.info('Building target vectors')
for i in range(len(dir_in)):
with open(os.path.join(dir_in[i], 'cfg.yml'), 'r') as outfile:
conf = yaml.load(outfile)
logger.info('Dataset: ' + str(i + 1) + '/' + str(len(dir_in)))
files = sorted(
glob.glob(os.path.join(dir_in[i], 'pm_scores_iter*')))[-1]
#logger.info('Init. learner')
dataset = learning_dataset.LearningDataset(conf)
npz_file = np.load(os.path.join(dir_in[i], 'results.npz'))
seeds = np.asarray(
utls.get_node_list_tracklets(npz_file['list_ksp'][-1]))
if (confs[0].use_ss):
dataset.load_ss_from_file()
seeds = ss.thr_all_graphs(dataset.g_ss, seeds, conf.ss_thr)
dataset.set_seeds(seeds)
dataset.make_y_array(seeds)
dataset.make_y_array_true(dataset.gt)
datasets.append(dataset)
if (not os.path.exists(out_dir)):
os.mkdir(out_dir)
logger.info('saving datasets to: ' + out_dir)
np.savez(os.path.join(out_dir, 'datasets.npz'),
**{'datasets': datasets})
else:
logger.info('Loading datasets...')
datasets = np.load(os.path.join(out_dir, 'datasets.npz'))['datasets']
n_folds = 4
fold_ids = np.arange(0, 4)[::-1]
res_list = []
n_e = 150
if (not os.path.exists(os.path.join(out_dir, 'results.npz'))):
for i in range(n_folds):
logger.info('-----------------')
pred_fold = i
train_folds = np.asarray([
fold_ids[j] for j in range(n_folds)
if (fold_ids[j] != pred_fold)
])
logger.info('train_folds: ' + str(train_folds))
logger.info('pred_folds: ' + str(pred_fold))
logger.info('-----------------')
X_train = utls.concat_arr(
np.concatenate([
datasets[train_folds[j]].X
for j in range(train_folds.shape[0])
]))
y_train_my = np.concatenate([
datasets[train_folds[j]].y[:, 2]
for j in range(train_folds.shape[0])
])
y_train_true = np.concatenate([
datasets[train_folds[j]].y_true[:, 2]
for j in range(train_folds.shape[0])
])
logger.info('Extracting X_test')
X_test = utls.concat_arr(datasets[pred_fold].X)
logger.info('Extracting y_test')
y_test = datasets[pred_fold].y_true[:, 2]
logger.info('Fitting...')
bag_n_feats = confs[0].bag_n_feats_rf
bag_max_depth = confs[0].bag_max_depth_rf
logger.info('bag_n_feats: ' + str(bag_n_feats))
logger.info('bag_max_depth: ' + str(bag_max_depth))
n_trees = datasets[0].conf.T
clf_my = RandomForestClassifier(max_features=bag_n_feats,
class_weight='balanced',
n_estimators=n_trees)
clf_true = RandomForestClassifier(max_features=bag_n_feats,
class_weight='balanced',
n_estimators=n_trees)
clf_my.fit(X_train, y_train_my)
clf_true.fit(X_train, y_train_true)
logger.info('Predicting...')
probas_my = clf_my.predict_proba(X_test)[:, 1]
probas_true = clf_true.predict_proba(X_test)[:, 1]
#probas_my = rf.run(X_train,y_train_my,X_test,150)
#probas_true = rf.run(X_train,y_train_true,X_test,150)
logger.info('Computing ROC curves on true model')
fpr_true, tpr_true, thresholds_true = roc_curve(
y_test, probas_true)
auc_true = auc(fpr_true, tpr_true)
logger.info('auc_true: ' + str(auc_true))
logger.info('Computing ROC curves on my model')
fpr_my, tpr_my, thresholds_my = roc_curve(y_test,
probas_my,
pos_label=1)
auc_my = auc(fpr_my, tpr_my)
logger.info('auc_my: ' + str(auc_my))
logger.info('Computing prec-recall curves on true model')
precision_true, recall_true, _ = precision_recall_curve(
y_test, probas_true)
logger.info('Computing prec-recall curves on my model')
precision_my, recall_my, _ = precision_recall_curve(
y_test, probas_my)
dict_ = dict()
dict_['train_folds'] = train_folds
dict_['pred_fold'] = pred_fold
dict_['n_estimators'] = n_e
dict_['fpr_true'] = fpr_true
dict_['tpr_true'] = tpr_true
dict_['fpr_my'] = fpr_my
dict_['tpr_my'] = tpr_my
dict_['auc_true'] = auc_true
dict_['precision_true'] = precision_true
dict_['recall_true'] = recall_true
dict_['auc_true'] = auc_true
dict_['auc_my'] = auc_my
dict_['precision_my'] = precision_my
dict_['recall_my'] = recall_my
dict_['probas_my'] = probas_my
dict_['probas_true'] = probas_true
dict_['y_test'] = y_test
res_list.append(dict_)
file_out = os.path.join(out_dir, 'results.npz')
logger.info('Saving metrics to ')
np.savez(file_out, **{'res_list': res_list})
else:
logger.info('Loading results...')
res_list = np.load(os.path.join(out_dir, 'results.npz'))['res_list']
#Plot folds
colors = ['blue', 'darkorange', 'seagreen', 'yellow', 'blue']
lw = 1
plt.clf()
l_fpr_true = []
l_tpr_true = []
l_pr_true = []
l_rc_true = []
l_fpr_my = []
l_tpr_my = []
l_pr_my = []
l_rc_my = []
for i in range(len(res_list)):
fpr_true = res_list[i]['fpr_true']
tpr_true = res_list[i]['tpr_true']
#fpr_true, tpr_true = utls.my_interp(fpr_true, tpr_true, n_points)
l_fpr_true.append(fpr_true)
l_tpr_true.append(tpr_true)
fpr_my = res_list[i]['fpr_my']
tpr_my = res_list[i]['tpr_my']
#fpr_my, tpr_my = utls.my_interp(fpr_my, tpr_my, n_points)
l_fpr_my.append(fpr_my)
l_tpr_my.append(tpr_my)
pr_true = res_list[i]['precision_true']
rc_true = res_list[i]['recall_true']
#rc_true, pr_true = utls.my_interp(rc_true, pr_true, n_points)
l_rc_true.append(rc_true)
l_pr_true.append(pr_true)
pr_my = res_list[i]['precision_my']
rc_my = res_list[i]['recall_my']
#rc_my, pr_my = utls.my_interp(rc_my, pr_my, n_points)
l_rc_my.append(rc_my)
l_pr_my.append(pr_my)
rc_range_my = [
np.min([np.min(l_rc_my[i]) for i in range(len(l_rc_my))]),
np.max([np.max(l_rc_my[i]) for i in range(len(l_rc_my))])
]
rc_range_true = [
np.min([np.min(l_rc_true[i]) for i in range(len(l_rc_true))]),
np.max([np.max(l_rc_true[i]) for i in range(len(l_rc_true))])
]
rc_range = [
np.min((rc_range_my[0], rc_range_true[0])),
np.max((rc_range_my[1], rc_range_true[1]))
]
fpr_range_my = [
np.min([np.min(l_fpr_my[i]) for i in range(len(l_fpr_my))]),
np.max([np.max(l_fpr_my[i]) for i in range(len(l_fpr_my))])
]
fpr_range_true = [
np.min([np.min(l_fpr_true[i]) for i in range(len(l_fpr_true))]),
np.max([np.max(l_fpr_true[i]) for i in range(len(l_fpr_true))])
]
fpr_range = [
np.min((fpr_range_my[0], fpr_range_true[0])),
np.max((fpr_range_my[1], fpr_range_true[1]))
]
l_fpr_tpr_my_interp = np.asarray([
utls.my_interp(l_fpr_my[i], l_tpr_my[i], n_points, fpr_range)
for i in range(len(l_fpr_my))
]).transpose(1, 0, 2)
l_fpr_my = l_fpr_tpr_my_interp[0, ...]
l_tpr_my = l_fpr_tpr_my_interp[1, ...]
l_pr_rc_my_interp = np.asarray([
utls.my_interp(l_rc_my[i], l_pr_my[i], n_points, rc_range)
for i in range(len(l_rc_my))
]).transpose(1, 0, 2)
l_rc_my = l_pr_rc_my_interp[0, ...]
l_pr_my = l_pr_rc_my_interp[1, ...]
l_fpr_tpr_true_interp = np.asarray([
utls.my_interp(l_fpr_true[i], l_tpr_true[i], n_points, fpr_range)
for i in range(len(l_fpr_true))
]).transpose(1, 0, 2)
l_fpr_true = l_fpr_tpr_true_interp[0, ...]
l_tpr_true = l_fpr_tpr_true_interp[1, ...]
l_pr_rc_true_interp = np.asarray([
utls.my_interp(l_rc_true[i], l_pr_true[i], n_points, rc_range)
for i in range(len(l_rc_true))
]).transpose(1, 0, 2)
l_rc_true = l_pr_rc_true_interp[0, ...]
l_pr_true = l_pr_rc_true_interp[1, ...]
roc_xlim = [0, 1]
pr_rc_xlim = [0, 1]
logger.info('Concatenating results for scoring')
all_y_true = np.concatenate([r['y_test'] for r in res_list])
all_probas_my = np.concatenate([r['probas_my'] for r in res_list])
all_probas_true = np.concatenate([r['probas_true'] for r in res_list])
fpr_my_all, tpr_my_all, thresholds_my_all = roc_curve(all_y_true,
all_probas_my,
pos_label=1)
fpr_my_all, tpr_my_all = utls.my_interp(fpr_my_all, tpr_my_all, n_points)
fpr_true_all, tpr_true_all, thresholds_true_all = roc_curve(
all_y_true, all_probas_true, pos_label=1)
fpr_true_all, tpr_true_all = utls.my_interp(fpr_true_all, tpr_true_all,
n_points)
pr_my_all, rc_my_all, _ = precision_recall_curve(all_y_true, all_probas_my)
pr_my_all, rc_my_all = utls.my_interp(pr_my_all, rc_my_all, n_points)
pr_true_all, rc_true_all, _ = precision_recall_curve(
all_y_true, all_probas_true)
pr_true_all, rc_true_all = utls.my_interp(pr_true_all, rc_true_all,
n_points)
auc_my_all = auc(fpr_my_all, tpr_my_all)
probas_thr = np.linspace(0, 1, n_points)
f1_my = [f1_score(all_y_true, all_probas_my > p) for p in probas_thr]
probas_thr = np.linspace(0, 1, 200)
f1_true = [f1_score(all_y_true, all_probas_true > p) for p in probas_thr]
auc_true_all = auc(fpr_true_all, tpr_true_all)
# Plotting
lw = 3
plt.figure('tpr')
plt.plot(l_fpr_true.mean(axis=0),
l_tpr_true.mean(axis=0),
'-',
lw=lw,
color=colors[0],
label='all folds (true) (area = %0.4f, max_f1 = %0.4f)' %
(auc_true_all, np.max(f1_true)))
plt.fill_between(l_fpr_true.mean(axis=0),
l_tpr_true.mean(axis=0) + l_tpr_true.std(axis=0),
l_tpr_true.mean(axis=0) - l_tpr_true.std(axis=0),
facecolor=colors[0],
alpha=alpha)
plt.plot(l_fpr_my.mean(axis=0),
l_tpr_my.mean(axis=0),
'-',
lw=lw,
color=colors[1],
label='all folds (my) (area = %0.4f, max_f1 = %0.4f)' %
(auc_my_all, np.max(f1_my)))
plt.fill_between(l_fpr_my.mean(axis=0),
l_tpr_my.mean(axis=0) + l_tpr_my.std(axis=0),
l_tpr_my.mean(axis=0) - l_tpr_my.std(axis=0),
facecolor=colors[1],
alpha=alpha)
plt.legend()
plt.xlim(roc_xlim)
plt.xlabel('fpr')
plt.ylabel('tpr')
plt.suptitle('Sequence: ' + seq_type + '. Gaze: ' +
confs[0].csvFileName_fg)
plt.savefig(os.path.join(out_dir, 'folds_tpr_fpr.pdf'))
plt.figure('rc')
plt.plot(l_rc_true.mean(axis=0),
l_pr_true.mean(axis=0),
'-',
lw=lw,
color=colors[0],
label='all folds (true)')
plt.fill_between(l_rc_true.mean(axis=0),
l_pr_true.mean(axis=0) + l_pr_true.std(axis=0),
l_pr_true.mean(axis=0) - l_pr_true.std(axis=0),
facecolor=colors[0],
alpha=alpha)
plt.plot(l_rc_my.mean(axis=0),
l_pr_my.mean(axis=0),
'-',
lw=lw,
color=colors[1],
label='all folds (my)')
plt.fill_between(l_rc_my.mean(axis=0),
l_pr_my.mean(axis=0) + l_pr_my.std(axis=0),
l_pr_my.mean(axis=0) - l_pr_my.std(axis=0),
facecolor=colors[1],
alpha=alpha)
plt.legend()
plt.xlim(pr_rc_xlim)
plt.xlabel('recall')
plt.ylabel('precision')
plt.suptitle('Sequence: ' + seq_type + '. Gaze: ' +
confs[0].csvFileName_fg)
#plt.figure('rc').set_size_inches(18.5, 10.5)
plt.savefig(os.path.join(out_dir, 'folds_pr_rc.pdf'))
min_n_frames = np.min([len(d.conf.frameFileNames) for d in datasets])
dir_frames = os.path.join(out_dir, 'frames')
if (not os.path.exists(dir_frames)):
os.mkdir(dir_frames)
else:
logger.info('frames already exist, delete and re-run...')
#shutil.rmtree(dir_frames)
#os.mkdir(dir_frames)
logger.info('Generating prediction frames...')
#Plot by-frame predictions
for f in range(min_n_frames):
my = []
true = []
ims = []
for j in range(len(datasets)):
y_true = datasets[j].y
idx_y = np.where(y_true[:, 0] == f)[0]
y_true = y_true[idx_y]
probas_true = res_list[j]['probas_true'][idx_y]
probas_my = res_list[j]['probas_my'][idx_y]
scores_my = utls.get_scores_from_sps(y_true[:, 0:2],
datasets[j].get_labels(),
probas_my)[..., f]
my.append(scores_my)
scores_true = utls.get_scores_from_sps(y_true[:, 0:2],
datasets[j].get_labels(),
probas_true)[..., f]
true.append(scores_true)
cont_gt = segmentation.find_boundaries(datasets[j].gt[..., f],
mode='thick')
idx_cont_gt = np.where(cont_gt)
im = utls.imread(datasets[j].conf.frameFileNames[f])
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
im = gaze.drawGazePoint(datasets[j].conf.myGaze_fg,
f,
im,
radius=7)
ims.append(im)
gs = gridspec.GridSpec(3, 4)
for c in range(4):
ax = plt.subplot(gs[0, c])
ax.imshow(true[c])
plt.title('true')
ax = plt.subplot(gs[1, c])
ax.imshow(my[c])
plt.title('my')
ax = plt.subplot(gs[2, c])
ax.imshow(ims[c])
plt.title('image')
plt.suptitle('Sequence: ' + seq_type + '. Frame: ' + str(f))
fig = plt.gcf()
fig.set_size_inches(18.5, 10.5)
plt.savefig(os.path.join(dir_frames, 'frame_' + str(f) + '.png'))
def predict(conf, clf, out_dir=None, n_jobs=1):
"""
Parallel extraction and prediction of patches on every pixel
:imgs: list of images
:returns predictions
"""
# Set logger
if (out_dir is not None):
conf.dataOutDir = out_dir
save_path = os.path.join(conf.dataOutDir, 'vilar')
utls.setup_logging(conf.dataOutDir)
logger = logging.getLogger('vilar (predict)')
logger.info('---------------------------')
logger.info('Predicting on: ' + conf.ds_dir)
logger.info('type of sequence: ' + conf.seq_type)
logger.info('gaze filename: ' + conf.csvFileName_fg)
logger.info('Result dir:')
logger.info(conf.dataOutDir)
logger.info('---------------------------')
n_frames = conf.vilar_n_frames
if (n_frames == -1):
n_frames = len(conf.frameFileNames)
batch_size = n_frames
batch_idx = np.array_split(np.arange(0, n_frames), n_frames / n_jobs)
selem = morphology.square(5)
ims = []
for i in range(n_frames):
img = utls.imread(conf.frameFileNames[i])
img = (color.rgb2gray(img) * 255).astype(np.uint8)
#img = (color.rgb2gray(img)*255).astype(np.uint8)
#img = utls.imread(self.conf.frameFileNames[i])
img = median(img, selem=selem) # Uses square of size 3
ims.append(img) # make feat segment dictionary list
save_path = os.path.join(conf.dataOutDir, 'vilar')
if (not os.path.exists(save_path)):
os.mkdir(save_path)
for b in range(len(batch_idx)):
stack = list()
cnt = 0
for b_ in range(batch_idx[b].shape[0]):
i = batch_idx[b][b_]
stack.append(dict())
stack[cnt]['clf'] = clf
stack[cnt]['im'] = ims[i]
stack[cnt]['shape'] = ims[i].shape
stack[cnt]['f_num'] = i
stack[cnt]['ps'] = conf.patch_size
stack[cnt]['scale_factor'] = conf.scale_factor
stack[cnt]['save_path_patch'] = os.path.join(
save_path, 'all_patches_im_' + str(i) + '.npz')
stack[cnt]['save_path_pred'] = os.path.join(
save_path, 'pred_im_' + str(i) + '.npz')
cnt += 1
with Pool(processes=n_jobs) as pool:
pool.map(predict_job, stack)
return conf
def main(conf, plot_fname='metrics.pdf', logger=None):
logger = logging.getLogger('plot_results_ksp')
logger.info('--------')
logger.info('Self-learning on: ' + conf.dataOutDir)
logger.info('--------')
metrics_path = os.path.join(conf.dataOutDir, 'metrics.npz')
if (not os.path.exists(metrics_path)):
list_ksp = np.load(os.path.join(conf.dataOutDir,
'results.npz'))['list_ksp']
my_dataset = ds.Dataset(conf)
my_dataset.load_labels_if_not_exist()
my_dataset.load_pm_fg_from_file()
l_dataset = learning_dataset.LearningDataset(conf, pos_thr=0.5)
l_dataset.make_y_array_true(l_dataset.gt)
fpr_ksp = [0.]
tpr_ksp = [0.]
pr_ksp = [1.]
rc_ksp = [0.]
f1_ksp = []
logger.info('[1/4] Calculating metrics on KSP... ')
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[-1]))
l_dataset.set_seeds(seeds)
l_dataset.make_y_array(l_dataset.seeds)
fpr, tpr, _ = roc_curve(l_dataset.y_true[:, 2], l_dataset.y[:, 2])
precision, recall, _ = precision_recall_curve(l_dataset.y_true[:, 2],
l_dataset.y[:, 2])
f1_ksp.append(f1_score(l_dataset.y_true[:, 2], l_dataset.y[:, 2]))
fpr_ksp.append(fpr[1])
tpr_ksp.append(tpr[1])
pr_ksp.append(precision[1])
rc_ksp.append(recall[1])
fpr_ksp.append(1.)
tpr_ksp.append(1.)
pr_ksp.append(0.)
rc_ksp.append(1.)
logger.info('[2/4] Calculating metrics on PM... ')
fpr_pm = []
tpr_pm = []
pr_pm = []
rc_pm = []
f1_pm = []
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[-1]))
my_dataset.fg_marked = seeds
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
bag_n_feats=conf.bag_n_feats,
feat_fields=['desc'],
n_jobs=conf.bag_jobs)
probas = my_dataset.fg_pm_df['proba'].as_matrix()
fpr, tpr, _ = roc_curve(l_dataset.y_true[:, 2], probas)
precision, recall, _ = precision_recall_curve(l_dataset.y_true[:, 2],
probas)
probas_thr = np.unique(probas)
f1_pm_ = [
f1_score(l_dataset.y_true[:, 2], probas > p) for p in probas_thr
]
f1_pm.append(f1_pm_)
fpr_pm.append(fpr)
tpr_pm.append(tpr)
pr_pm.append(precision)
rc_pm.append(recall)
# Make PM and KSP frames on SS
logger.info('[3/4] Making prediction maps of KSP... ')
seeds = np.asarray(utls.get_node_list_tracklets(list_ksp[-1]))
ksp_scores = utls.get_scores_from_sps(seeds, my_dataset.labels)
my_dataset.fg_marked = np.asarray(
utls.get_node_list_tracklets(list_ksp[-1]))
my_dataset.calc_pm(my_dataset.fg_marked,
save=False,
marked_feats=None,
all_feats_df=my_dataset.sp_desc_df,
in_type='not csv',
mode='foreground',
bag_n_feats=conf.bag_n_feats,
feat_fields=['desc'],
n_jobs=conf.bag_jobs)
pm_ksp = my_dataset.get_pm_array(mode='foreground')
# Saving metrics
data = dict()
data['probas_thr'] = probas_thr
data['fpr_pm'] = fpr_pm
data['tpr_pm'] = tpr_pm
data['pr_pm'] = pr_pm
data['rc_pm'] = rc_pm
data['f1_pm'] = f1_pm
data['fpr_ksp'] = fpr_ksp
data['tpr_ksp'] = tpr_ksp
data['pr_ksp'] = pr_ksp
data['rc_ksp'] = rc_ksp
data['f1_ksp'] = f1_ksp
data['ksp_scores'] = ksp_scores
np.savez(os.path.join(conf.dataOutDir, 'metrics.npz'), **data)
else:
logger.info('Loading metrics.npz...')
metrics = np.load(os.path.join(conf.dataOutDir, 'metrics.npz'))
probas_thr = metrics['probas_thr']
fpr_pm = metrics['fpr_pm']
tpr_pm = metrics['tpr_pm']
pr_pm = metrics['pr_pm']
rc_pm = metrics['rc_pm']
f1_pm = metrics['f1_pm']
fpr_ksp = metrics['fpr_ksp']
tpr_ksp = metrics['tpr_ksp']
pr_ksp = metrics['pr_ksp']
rc_ksp = metrics['rc_ksp']
f1_ksp = metrics['f1_ksp']
ksp_scores = metrics['ksp_scores']
pm_ksp = metrics['pm_ksp']
my_dataset = ds.Dataset(conf)
my_dataset.load_labels_if_not_exist()
my_dataset.load_pm_fg_from_file()
l_dataset = learning_dataset.LearningDataset(conf, pos_thr=0.5)
list_ksp = np.load(os.path.join(conf.dataOutDir,
'results.npz'))['list_ksp']
# Plot all iterations of PM
plt.clf()
conf.roc_xlim = [0, 0.4]
conf.pr_rc_xlim = [0.6, 1.]
lw = 1
# PM curves
auc_ = auc(np.asarray(fpr_pm[-1]).ravel(), np.asarray(tpr_pm[-1]).ravel())
max_f1 = np.max(f1_pm[-1])
plt.subplot(121)
plt.plot(np.asarray(fpr_pm[-1]).ravel(),
np.asarray(tpr_pm[-1]).ravel(),
'r-',
lw=lw,
label='KSP/PM (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
auc_ = auc(np.asarray(rc_pm[-1]).ravel(), np.asarray(pr_pm[-1]).ravel())
plt.subplot(122)
plt.plot(np.asarray(rc_pm[-1]).ravel(),
np.asarray(pr_pm[-1]).ravel(),
'r-',
lw=lw,
label='KSP/PM (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
# Plot KSP
auc_ = auc(np.asarray(fpr_ksp).ravel(),
np.asarray(tpr_ksp).ravel(),
reorder=True)
max_f1 = np.max(f1_ksp)
plt.subplot(121)
plt.plot(np.asarray(fpr_ksp).ravel(),
np.asarray(tpr_ksp).ravel(),
'ro--',
lw=lw,
label='KSP (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
plt.subplot(122)
auc_ = auc(np.asarray(rc_ksp).ravel(),
np.asarray(pr_ksp).ravel(),
reorder=True)
plt.plot(np.asarray(rc_ksp).ravel(),
np.asarray(pr_ksp).ravel(),
'ro--',
lw=lw,
label='KSP (area = %0.4f, max(F1) = %0.4f)' % (auc_, max_f1))
plt.subplot(121)
plt.legend()
plt.xlim(conf.roc_xlim)
plt.xlabel('fpr')
plt.ylabel('tpr')
plt.subplot(122)
plt.legend()
plt.xlim(conf.pr_rc_xlim)
plt.xlabel('recall')
plt.ylabel('precision')
plt.suptitle(conf.seq_type + ', ' + conf.ds_dir + '\n' + 'T: ' +
str(conf.T))
fig = plt.gcf()
fig.set_size_inches(18.5, 10.5)
fig.savefig(os.path.join(conf.dataOutDir, plot_fname), dpi=200)
# Make plots
logger.info('Saving KSP, PM and SS merged frames...')
gt = l_dataset.gt
frame_dir = 'ksp_pm_frames'
frame_path = os.path.join(conf.dataOutDir, frame_dir)
if (os.path.exists(frame_path)):
logger.info('[!!!] Frame dir: ' + frame_path +
' exists. Delete to rerun.')
else:
n_iters_ksp = len(list_ksp)
os.mkdir(frame_path)
with progressbar.ProgressBar(maxval=len(conf.frameFileNames)) as bar:
for f in range(len(conf.frameFileNames)):
cont_gt = segmentation.find_boundaries(gt[..., f],
mode='thick')
idx_cont_gt = np.where(cont_gt)
im = utls.imread(conf.frameFileNames[f])
im[idx_cont_gt[0], idx_cont_gt[1], :] = (255, 0, 0)
im = csv.draw2DPoint(utls.pandas_to_std_csv(conf.myGaze_fg),
f,
im,
radius=7)
bar.update(f)
plt.subplot(221)
plt.imshow(ksp_scores[..., f])
plt.title('KSP')
plt.subplot(222)
plt.imshow(pm_ksp[..., f])
plt.title('KSP -> PM')
plt.subplot(223)
plt.imshow(im)
plt.title('image')
plt.suptitle('frame: ' + str(f) + ', n_iters_ksp: ' +
str(n_iters_ksp))
plt.savefig(os.path.join(frame_path, 'f_' + str(f) + '.png'),
dpi=200)
logger.info('Saving SPs per iterations plot...')
n_sps = []
for i in range(len(list_ksp)):
n = np.asarray(utls.get_node_list_tracklets(list_ksp[-1])).shape[0]
n_sps.append((i + 1, n))
n_sps.append((len(list_ksp) + 1, n))
n_sps = np.asarray(n_sps)
plt.clf()
plt.plot(n_sps[:, 0], n_sps[:, 1], 'bo-')
plt.plot(n_sps[-1, 0], n_sps[-1, 1], 'ro')
plt.xlabel('iterations')
plt.ylabel('num. of superpixels')
plt.title('num of superpixels vs. iterations. SS threshold: ' +
str(conf.ss_thr))
plt.savefig(os.path.join(conf.dataOutDir, 'sps_iters.eps'), dpi=200)
pr_pm, rc_pm, _ = precision_recall_curve(l_dataset.gt.ravel(),
pm_ksp.ravel())
ksp_pm_pix_f1 = np.max(2 * (pr_pm * rc_pm) / (pr_pm + rc_pm))
ksp_pix_f1 = f1_score(l_dataset.gt.ravel(), ksp_scores.ravel())
file_out = os.path.join(conf.dataOutDir, 'scores.csv')
C = pd.Index(["F1"], name="columns")
I = pd.Index(['KSP', 'KSP/PM'], name="Methods")
data = np.asarray([ksp_pix_f1, ksp_pm_pix_f1]).reshape(2, 1)
df = pd.DataFrame(data=data, index=I, columns=C)
df.to_csv(path_or_buf=file_out)
