def calc_score(conf):
dataset = ds.DatasetVilar(conf)
dir_ = os.path.join(conf.dataOutDir, 'vilar')
preds = np.asarray([
dataset.get_pred_frame(f, dir_)
for f in range(len(conf.frameFileNames))
]).transpose(1, 2, 0)
gts = dataset.gt
y_true = utls.make_y_array_true(gts, dataset.get_labels())
y_pred = utls.make_y_array_true(preds, dataset.get_labels())
f1_sp = f1_score(y_true[:, 2], y_pred[:, 2])
f1_px = f1_score(gts.ravel(), preds.ravel())
file_out = os.path.join(conf.dataOutDir, 'score.csv')
C = pd.Index(['F1_sp', 'F1_px'], name="columns")
data = np.asarray([f1_sp, f1_px]).reshape(1, 2)
df = pd.DataFrame(data=data, columns=C)
df.to_csv(path_or_buf=file_out)
def make_training_patches_and_fit(arg_cfg, out_dir=None):
data = dict()
# Update config
cfg_dict = cfg.cfg()
arg_cfg['seq_type'] = cfg.datasetdir_to_type(arg_cfg['ds_dir'])
cfg_dict.update(arg_cfg)
conf = cfg.Bunch(cfg_dict)
conf.out_dir_prefix = 'exp_vilar'
# Write config to result dir
if (out_dir is None):
if ('dataOutDir' not in arg_cfg):
conf.dataOutDir = utls.getDataOutDir(conf.dataOutRoot, conf.ds_dir,
conf.resultDir,
conf.out_dir_prefix,
conf.testing)
else:
conf.dataOutDir = out_dir
conf.myGaze_fg = utls.readCsv(
os.path.join(conf.root_path, conf.ds_dir, conf.locs_dir,
conf.csvFileName_fg))
# Set logger
utls.setup_logging(conf.dataOutDir)
logger = logging.getLogger('vilar')
logger.info('---------------------------')
logger.info('Extracting training a patches and fit 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 : ' + str(conf.vilar_n_frames))
logger.info('(gamma,C) = (' + str(conf.gamma) + ', ' + str(conf.C) + ')')
logger.info(conf.dataOutDir)
logger.info('---------------------------')
# Make frame file names
gt_dir = os.path.join(conf.root_path, conf.ds_dir, conf.truth_dir)
gtFileNames = utls.makeFrameFileNames(conf.frame_prefix, conf.frameDigits,
conf.truth_dir, conf.root_path,
conf.ds_dir, conf.frame_extension)
conf.frameFileNames = utls.makeFrameFileNames(conf.frame_prefix,
conf.frameDigits,
conf.frameDir,
conf.root_path, conf.ds_dir,
conf.frame_extension)
# conf.myGaze_fg = utls.readCsv(conf.csvName_fg)
conf.myGaze_fg = utls.readCsv(
os.path.join(conf.root_path, conf.ds_dir, conf.locs_dir,
conf.csvFileName_fg))
# conf.myGaze_bg = utls.readCsv(conf.csvName_bg)
gt_positives = utls.getPositives(gtFileNames)
conf.precomp_desc_path = os.path.join(conf.dataOutRoot, conf.ds_dir,
conf.feats_dir)
my_dataset = ds.DatasetVilar(conf)
with open(os.path.join(conf.dataOutDir, 'cfg.yml'), 'w') as outfile:
yaml.dump(conf, outfile, default_flow_style=True)
# Extract seen and unseen patches (to fit SVC)
if (os.path.exists(
os.path.join(conf.dataOutDir, 'vilar', 'vilar_seen_patches_df.p'))
& os.path.exists(
os.path.join(conf.dataOutDir, 'vilar',
'vilar_unseen_patches_df.p'))):
logger.info('seen and unseen patches already computed. Skipping.')
else:
my_dataset.calc_training_patches(save=True)
if (not os.path.exists(os.path.join(conf.dataOutDir, 'clf.p'))):
my_dataset.load_patches()
X_pos = df_to_mat(my_dataset.seen_patches_df)
X_neg = df_to_mat(my_dataset.unseen_patches_df)
X_train = np.concatenate((X_pos, X_neg))
y_pos = np.ones(df_to_mat(my_dataset.seen_patches_df).shape[0])
y_neg = np.zeros(df_to_mat(my_dataset.unseen_patches_df).shape[0])
y_train = np.concatenate((y_pos, y_neg))
clf = SVC(gamma=conf.gamma,
C=conf.C,
class_weight='balanced',
verbose=True)
logger.info('fitting')
clf.fit(X_train, y_train)
with open(os.path.join(conf.dataOutDir, 'clf.p'), 'wb') as f:
pk.dump(clf, f)
logger.info('Saved classifier.')
else:
with open(os.path.join(conf.dataOutDir, 'clf.p'), 'rb') as f:
clf = pk.load(f)
return conf, clf
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)