def evaluate(
src_cfg, tr_norms, te_norms, analytical_fim, pi_derivatives, sqrt_nr_descs,
do_plot=False, verbose=0):
outfile = os.path.join(
CACHE_PATH, "%s_%s_afim_%s_pi_%s_sqrt_nr_descs_%s.dat" % (
src_cfg, "%s", analytical_fim, pi_derivatives, sqrt_nr_descs))
dataset = Dataset(CFG[src_cfg]['dataset_name'], **CFG[src_cfg]['dataset_params'])
(tr_kernel, tr_labels,
te_kernel, te_labels) = load_kernels(
dataset, tr_norms=tr_norms, te_norms=te_norms,
analytical_fim=analytical_fim, pi_derivatives=pi_derivatives,
sqrt_nr_descs=sqrt_nr_descs, outfile=outfile, do_plot=do_plot,
verbose=verbose)
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, tr_labels)
scores = eval.score(te_kernel, te_labels)
if verbose > 0:
print 'Train normalizations:', ', '.join(map(str, tr_norms))
print 'Test normalizations:', ', '.join(map(str, te_norms))
if CFG[src_cfg]['metric'] == 'average_precision':
print_scores(scores)
if CFG[src_cfg]['metric'] == 'average_precision':
print "%.2f" % np.mean(scores)
elif CFG[src_cfg]['metric'] == 'accuracy':
print "%.2f" % scores
def test_bow(self):
model = Model('bow', self.gmm)
model.compute_kernels([self.tr_fn], [self.te_fn])
Kxx, Kyx = model.get_kernels()
evaluation = Evaluation(self.dataset.DATASET)
score = evaluation.fit(Kxx, self.cx).score(Kyx, self.cy)
assert_allclose(score, self.expected_scores['bow'], rtol=1e-4)
def test_bow(self):
model = Model('bow', self.gmm)
model.compute_kernels([self.tr_fn], [self.te_fn])
Kxx, Kyx = model.get_kernels()
evaluation = Evaluation(self.dataset.DATASET)
score = evaluation.fit(Kxx, self.cx).score(Kyx, self.cy)
assert_allclose(score, self.expected_scores['bow'], rtol=1e-4)
def evaluate(src_cfg, tr_kernel, tr_labels, te_kernel, te_labels):
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, tr_labels)
scores = eval.score(te_kernel, te_labels)
if CFG[src_cfg]['metric'] == 'average_precision':
print_scores(scores)
if CFG[src_cfg]['metric'] == 'average_precision':
print "%.2f" % np.mean(scores)
elif CFG[src_cfg]['metric'] == 'accuracy':
print "%.2f" % scores
def evaluate(src_cfg, tr_kernel, tr_labels, te_kernel, te_labels):
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, tr_labels)
scores = eval.score(te_kernel, te_labels)
if CFG[src_cfg]['metric'] == 'average_precision':
print_scores(scores)
if CFG[src_cfg]['metric'] == 'average_precision':
print "%.2f" % np.mean(scores)
elif CFG[src_cfg]['metric'] == 'accuracy':
print "%.2f" % scores
def evaluate(src_cfg,
tr_norms,
te_norms,
analytical_fim,
pi_derivatives,
sqrt_nr_descs,
do_plot=False,
verbose=0):
outfile = os.path.join(
CACHE_PATH, "%s_%s_afim_%s_pi_%s_sqrt_nr_descs_%s.dat" %
(src_cfg, "%s", analytical_fim, pi_derivatives, sqrt_nr_descs))
dataset = Dataset(CFG[src_cfg]['dataset_name'],
**CFG[src_cfg]['dataset_params'])
(tr_kernel, tr_labels, te_kernel,
te_labels) = load_kernels(dataset,
tr_norms=tr_norms,
te_norms=te_norms,
analytical_fim=analytical_fim,
pi_derivatives=pi_derivatives,
sqrt_nr_descs=sqrt_nr_descs,
outfile=outfile,
do_plot=do_plot,
verbose=verbose)
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, tr_labels)
scores = eval.score(te_kernel, te_labels)
if verbose > 0:
print 'Train normalizations:', ', '.join(map(str, tr_norms))
print 'Test normalizations:', ', '.join(map(str, te_norms))
if CFG[src_cfg]['metric'] == 'average_precision':
print_scores(scores)
if CFG[src_cfg]['metric'] == 'average_precision':
print "%.2f" % np.mean(scores)
elif CFG[src_cfg]['metric'] == 'accuracy':
print "%.2f" % scores
def evaluate_given_dataset(dataset, **kwargs):
model_type = kwargs.get('model_type', 'fv')
sstats_folder = dataset.SSTATS_DIR
tr_fn = os.path.join(sstats_folder, 'train.dat')
tr_labels_fn = os.path.join(sstats_folder, 'labels_train.info')
te_fn = os.path.join(sstats_folder, 'test.dat')
te_labels_fn = os.path.join(sstats_folder, 'labels_test.info')
gmm = load_gmm(dataset.GMM)
tr_labels = pickle.load(open(tr_labels_fn, 'r'))
te_labels = pickle.load(open(te_labels_fn, 'r'))
model = Model(model_type, gmm)
model.compute_kernels([tr_fn], [te_fn])
Kxx, Kyx = model.get_kernels()
evaluation = Evaluation(dataset.DATASET, **kwargs)
print evaluation.fit(Kxx, tr_labels).score(Kyx, te_labels)
def evaluate_given_dataset(dataset, **kwargs):
model_type = kwargs.get('model_type', 'fv')
sstats_folder = dataset.SSTATS_DIR
tr_fn = os.path.join(sstats_folder, 'train.dat')
tr_labels_fn = os.path.join(sstats_folder, 'labels_train.info')
te_fn = os.path.join(sstats_folder, 'test.dat')
te_labels_fn = os.path.join(sstats_folder, 'labels_test.info')
gmm = load_gmm(dataset.GMM)
tr_labels = pickle.load(open(tr_labels_fn, 'r'))
te_labels = pickle.load(open(te_labels_fn, 'r'))
model = Model(model_type, gmm)
model.compute_kernels([tr_fn], [te_fn])
Kxx, Kyx = model.get_kernels()
evaluation = Evaluation(dataset.DATASET, **kwargs)
print evaluation.fit(Kxx, tr_labels).score(Kyx, te_labels)
def predict_main(src_cfg,
sqrt_type,
empirical_standardizations,
l2_norm_type,
prediction_type,
analytical_fim,
part,
nr_slices_to_aggregate=1,
nr_threads=4,
verbose=0):
dataset = Dataset(CFG[src_cfg]['dataset_name'],
**CFG[src_cfg]['dataset_params'])
D, K = dataset.D, dataset.VOC_SIZE
if verbose:
print "Loading train data."
tr_outfile = os.path.join(
CACHE_PATH, "%s_train_afim_%s_pi_%s_sqrt_nr_descs_%s.dat" %
(src_cfg, analytical_fim, False, False))
tr_video_data, tr_video_labels, tr_scalers = load_normalized_tr_data(
dataset, nr_slices_to_aggregate, l2_norm_type,
empirical_standardizations, sqrt_type, analytical_fim, tr_outfile,
verbose)
# Computing kernel.
tr_kernel = np.dot(tr_video_data, tr_video_data.T)
if verbose > 1:
print '\tTrain data: %dx%d.' % tr_video_data.shape
print '\tTrain kernel: %dx%d.' % tr_kernel.shape
if verbose:
print "Training classifier."
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, tr_video_labels)
clfs = [
compute_weights(eval.get_classifier(cls), tr_video_data, tr_std=None)
for cls in xrange(eval.nr_classes)
]
if verbose:
print "Loading test data."
te_samples, _ = dataset.get_data('test')
visual_word_mask = build_visual_word_mask(D, K)
te_outfile = os.path.join(
CACHE_PATH, "%s_test_afim_%s_pi_%s_sqrt_nr_descs_%s_part_%s.dat" %
(src_cfg, analytical_fim, False, False, "%d"))
low = CFG[src_cfg]['samples_chunk'] * part
high = np.minimum(CFG[src_cfg]['samples_chunk'] * (part + 1),
len(te_samples))
if verbose:
print "\tPart %3d from %5d to %5d." % (part, low, high)
print "\tEvaluating on %d threads." % nr_threads
te_outfile_ii = te_outfile % part
fisher_vectors, counts, nr_descs, nr_slices, _, te_labels = load_slices(
dataset,
te_samples[low:high],
analytical_fim,
outfile=te_outfile_ii,
verbose=verbose)
slice_data = SliceData(fisher_vectors, counts, nr_descs)
agg_slice_data = slice_aggregator(slice_data, nr_slices,
nr_slices_to_aggregate)
agg_slice_data = agg_slice_data._replace(
fisher_vectors=(agg_slice_data.fisher_vectors *
agg_slice_data.nr_descriptors[:, np.newaxis]))
video_mask = build_aggregation_mask(
sum([[ii] * int(np.ceil(float(nn) / nr_slices_to_aggregate))
for ii, nn in enumerate(nr_slices)], []))
if verbose:
print "\tTest data: %dx%d." % agg_slice_data.fisher_vectors.shape
# Scale the FVs in the main program, to avoid blowing up the memory
# when doing multi-threading, since each thread will make a copy of the
# data when transforming the data.
if prediction_type == 'approx':
for tr_scaler in tr_scalers:
if tr_scaler is None:
continue
agg_slice_data = agg_slice_data._replace(
fisher_vectors=tr_scaler.transform(
agg_slice_data.fisher_vectors))
eval_args = [(ii, clfs[ii][0], clfs[ii][1], tr_scalers, agg_slice_data,
video_mask, visual_word_mask, prediction_type, verbose)
for ii in xrange(eval.nr_classes)]
evaluator = threads.ParallelIter(nr_threads, eval_args, evaluate_worker)
if verbose > 1:
print "\t\tClasses:",
true_labels = {}
predictions = {}
for ii, pd in evaluator:
tl = eval.lb.transform(te_labels)[:, ii]
true_labels[ii] = tl
predictions[ii] = pd
if verbose > 1:
print
preds_path = os.path.join(
CACHE_PATH,
"%s_predictions_afim_%s_pi_%s_sqrt_nr_descs_%s_nagg_%d_part_%d.dat" %
(src_cfg, analytical_fim, False, False, nr_slices_to_aggregate, part))
with open(preds_path, 'w') as ff:
cPickle.dump(true_labels, ff)
cPickle.dump(predictions, ff)
def evaluation(
algo_type, src_cfg, class_idx, stride, deltas, no_integral, containing,
rescore, timings_file, outfile=None, verbose=0):
dataset = Dataset(CFG[src_cfg]['dataset_name'], **CFG[src_cfg]['dataset_params'])
D, K = dataset.D, dataset.VOC_SIZE
visual_word_mask = build_visual_word_mask(D, K)
ALGO_PARAMS = {
'none': {
'train_params': {
'l2_norm_type': 'none',
'empirical_standardizations': [False, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'none'
},
},
'e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'none',
'empirical_standardizations': [True, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'none'
},
},
'e_std_1.fast': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'none',
'empirical_standardizations': [True, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window_no_sqrt_no_l2,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
},
},
'exact_L2': {
'train_params': {
'l2_norm_type': 'exact',
'empirical_standardizations': [False, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'none'
},
},
'exact_L2+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'exact',
'empirical_standardizations': [True, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'none'
},
},
'exact_sqrt': {
'train_params': {
'l2_norm_type': 'none',
'empirical_standardizations': [False, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'exact'
},
},
'exact_sqrt+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'none',
'empirical_standardizations': [True, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'exact'
},
},
'exact': {
'train_params': {
'l2_norm_type': 'exact',
'empirical_standardizations': [False, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'exact'
},
},
'exact+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'exact',
'empirical_standardizations': [True, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'exact'
},
},
'approx_sqrt_exact_L2': {
'train_params': {
'l2_norm_type': 'exact',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'approx'
},
},
'approx': {
'train_params': {
'l2_norm_type': 'approx',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': approx_sliding_window,
'sliding_window_params': {
'visual_word_mask': visual_word_mask
},
},
'approx+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'approx',
'empirical_standardizations': [True, True],
'sqrt_type': 'approx'
},
'sliding_window': approx_sliding_window,
'sliding_window_params': {
'visual_word_mask': visual_word_mask
},
},
'approx_ess': {
'train_params': {
'l2_norm_type': 'approx',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': approx_sliding_window_ess,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
'rescore': rescore,
},
},
'cy_approx_ess': {
'train_params': {
'l2_norm_type': 'approx',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': cy_approx_sliding_window_ess,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
'rescore': rescore,
'timings_file': timings_file,
},
},
'cy_approx_ess+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'approx',
'empirical_standardizations': [True, True],
'sqrt_type': 'approx'
},
'sliding_window': cy_approx_sliding_window_ess,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
'rescore': rescore,
'timings_file': timings_file,
},
},
}
chunk_size = CFG[src_cfg]['chunk_size']
base_chunk_size = mgcd(stride, *deltas)
tr_nr_agg = base_chunk_size / chunk_size
# For the old C&C features I have one FV for the entire sample for the
# train data, so I cannot aggregate.
if src_cfg == 'cc':
tr_nr_agg = 1
analytical_fim = ALGO_PARAMS[algo_type]['train_params'].pop('analytical_fim', True)
afim_suffix = '_no_afim' if not analytical_fim else ''
tr_outfile = '/scratch2/clear/oneata/tmp/joblib/%s_cls%d_train%s.dat' % (
src_cfg, class_idx, afim_suffix)
tr_video_data, tr_video_labels, tr_stds = load_normalized_tr_data(
dataset, tr_nr_agg, tr_outfile=tr_outfile, verbose=verbose,
analytical_fim=analytical_fim,
**ALGO_PARAMS[algo_type]['train_params'])
# Sub-sample data.
no_tuple_labels = np.array([ll[0] for ll in tr_video_labels])
idxs = (no_tuple_labels == class_idx) | (no_tuple_labels == NULL_CLASS_IDX)
binary_labels = (no_tuple_labels[idxs] == class_idx) * 2 - 1
class_tr_video_data = tr_video_data[idxs]
tr_kernel = np.dot(class_tr_video_data, class_tr_video_data.T)
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, binary_labels)
clf = compute_weights(eval.get_classifier(), class_tr_video_data)
results = {}
class_name = dataset.IDX2CLS[class_idx]
non_overlapping_selector = NonOverlappingSelector(base_chunk_size / chunk_size)
overlapping_selector = OverlappingSelector(
base_chunk_size, stride, containing,
integral=(not no_integral))
for movie in dataset.TE_MOVIES:
results[movie] = []
for part in xrange(len(dataset.CLASS_LIMITS[movie][class_name])):
te_outfile = (
'/scratch2/clear/oneata/tmp/joblib/%s_cls%d_movie%s_part%d%s_test.dat' %
(src_cfg, class_idx, movie, part, afim_suffix))
te_slice_data = SliceData(*load_data_delta_0(
dataset, movie, part, class_idx, delta_0=chunk_size,
analytical_fim=analytical_fim, outfile=te_outfile))
pdb.set_trace()
if verbose > 1:
print "Aggregating data."
# Aggregate data into non-overlapping chunks of size `base_chunk_size`.
N = te_slice_data.fisher_vectors.shape[0]
agg_slice_data = aggregate(
te_slice_data,
non_overlapping_selector.get_mask(N),
non_overlapping_selector.get_frame_idxs(N))
if verbose > 1:
print "Starting the sliding window", algo_type
results[movie] += ALGO_PARAMS[algo_type]['sliding_window'](
agg_slice_data, clf, deltas, overlapping_selector, tr_stds,
**ALGO_PARAMS[algo_type]['sliding_window_params'])
return [results]
def predict_main(
src_cfg, sqrt_type, empirical_standardizations, l2_norm_type,
prediction_type, analytical_fim, part, nr_slices_to_aggregate=1,
nr_threads=4, verbose=0):
dataset = Dataset(CFG[src_cfg]['dataset_name'], **CFG[src_cfg]['dataset_params'])
D, K = dataset.D, dataset.VOC_SIZE
if verbose:
print "Loading train data."
tr_outfile = os.path.join(
CACHE_PATH, "%s_train_afim_%s_pi_%s_sqrt_nr_descs_%s.dat" % (
src_cfg, analytical_fim, False, False))
tr_video_data, tr_video_labels, tr_scalers = load_normalized_tr_data(
dataset, nr_slices_to_aggregate, l2_norm_type,
empirical_standardizations, sqrt_type, analytical_fim, tr_outfile,
verbose)
# Computing kernel.
tr_kernel = np.dot(tr_video_data, tr_video_data.T)
if verbose > 1:
print '\tTrain data: %dx%d.' % tr_video_data.shape
print '\tTrain kernel: %dx%d.' % tr_kernel.shape
if verbose:
print "Training classifier."
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, tr_video_labels)
clfs = [
compute_weights(eval.get_classifier(cls), tr_video_data, tr_std=None)
for cls in xrange(eval.nr_classes)]
if verbose:
print "Loading test data."
te_samples, _ = dataset.get_data('test')
visual_word_mask = build_visual_word_mask(D, K)
te_outfile = os.path.join(
CACHE_PATH, "%s_test_afim_%s_pi_%s_sqrt_nr_descs_%s_part_%s.dat" % (
src_cfg, analytical_fim, False, False, "%d"))
low = CFG[src_cfg]['samples_chunk'] * part
high = np.minimum(CFG[src_cfg]['samples_chunk'] * (part + 1), len(te_samples))
if verbose:
print "\tPart %3d from %5d to %5d." % (part, low, high)
print "\tEvaluating on %d threads." % nr_threads
te_outfile_ii = te_outfile % part
fisher_vectors, counts, nr_descs, nr_slices, _, te_labels = load_slices(
dataset, te_samples[low: high], analytical_fim, outfile=te_outfile_ii,
verbose=verbose)
slice_data = SliceData(fisher_vectors, counts, nr_descs)
agg_slice_data = slice_aggregator(slice_data, nr_slices, nr_slices_to_aggregate)
agg_slice_data = agg_slice_data._replace(
fisher_vectors=(agg_slice_data.fisher_vectors *
agg_slice_data.nr_descriptors[:, np.newaxis]))
video_mask = build_aggregation_mask(
sum([[ii] * int(np.ceil(float(nn) / nr_slices_to_aggregate))
for ii, nn in enumerate(nr_slices)],
[]))
if verbose:
print "\tTest data: %dx%d." % agg_slice_data.fisher_vectors.shape
# Scale the FVs in the main program, to avoid blowing up the memory
# when doing multi-threading, since each thread will make a copy of the
# data when transforming the data.
if prediction_type == 'approx':
for tr_scaler in tr_scalers:
if tr_scaler is None:
continue
agg_slice_data = agg_slice_data._replace(
fisher_vectors=tr_scaler.transform(
agg_slice_data.fisher_vectors))
eval_args = [
(ii, clfs[ii][0], clfs[ii][1], tr_scalers, agg_slice_data, video_mask,
visual_word_mask, prediction_type, verbose)
for ii in xrange(eval.nr_classes)]
evaluator = threads.ParallelIter(nr_threads, eval_args, evaluate_worker)
if verbose > 1:
print "\t\tClasses:",
true_labels = {}
predictions = {}
for ii, pd in evaluator:
tl = eval.lb.transform(te_labels)[:, ii]
true_labels[ii] = tl
predictions[ii] = pd
if verbose > 1:
print
preds_path = os.path.join(
CACHE_PATH, "%s_predictions_afim_%s_pi_%s_sqrt_nr_descs_%s_nagg_%d_part_%d.dat" % (
src_cfg, analytical_fim, False, False, nr_slices_to_aggregate, part))
with open(preds_path, 'w') as ff:
cPickle.dump(true_labels, ff)
cPickle.dump(predictions, ff)
def evaluation(algo_type,
src_cfg,
class_idx,
stride,
deltas,
no_integral,
containing,
rescore,
timings_file,
outfile=None,
verbose=0):
dataset = Dataset(CFG[src_cfg]['dataset_name'],
**CFG[src_cfg]['dataset_params'])
D, K = dataset.D, dataset.VOC_SIZE
visual_word_mask = build_visual_word_mask(D, K)
ALGO_PARAMS = {
'none': {
'train_params': {
'l2_norm_type': 'none',
'empirical_standardizations': [False, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'none'
},
},
'e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'none',
'empirical_standardizations': [True, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'none'
},
},
'e_std_1.fast': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'none',
'empirical_standardizations': [True, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window_no_sqrt_no_l2,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
},
},
'exact_L2': {
'train_params': {
'l2_norm_type': 'exact',
'empirical_standardizations': [False, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'none'
},
},
'exact_L2+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'exact',
'empirical_standardizations': [True, False],
'sqrt_type': 'none'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'none'
},
},
'exact_sqrt': {
'train_params': {
'l2_norm_type': 'none',
'empirical_standardizations': [False, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'exact'
},
},
'exact_sqrt+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'none',
'empirical_standardizations': [True, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'none',
'sqrt_type': 'exact'
},
},
'exact': {
'train_params': {
'l2_norm_type': 'exact',
'empirical_standardizations': [False, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'exact'
},
},
'exact+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'exact',
'empirical_standardizations': [True, False],
'sqrt_type': 'exact'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'exact'
},
},
'approx_sqrt_exact_L2': {
'train_params': {
'l2_norm_type': 'exact',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': exact_sliding_window,
'sliding_window_params': {
'l2_norm_type': 'exact',
'sqrt_type': 'approx'
},
},
'approx': {
'train_params': {
'l2_norm_type': 'approx',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': approx_sliding_window,
'sliding_window_params': {
'visual_word_mask': visual_word_mask
},
},
'approx+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'approx',
'empirical_standardizations': [True, True],
'sqrt_type': 'approx'
},
'sliding_window': approx_sliding_window,
'sliding_window_params': {
'visual_word_mask': visual_word_mask
},
},
'approx_ess': {
'train_params': {
'l2_norm_type': 'approx',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': approx_sliding_window_ess,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
'rescore': rescore,
},
},
'cy_approx_ess': {
'train_params': {
'l2_norm_type': 'approx',
'empirical_standardizations': [False, True],
'sqrt_type': 'approx'
},
'sliding_window': cy_approx_sliding_window_ess,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
'rescore': rescore,
'timings_file': timings_file,
},
},
'cy_approx_ess+e_std_1': {
'train_params': {
'analytical_fim': False,
'l2_norm_type': 'approx',
'empirical_standardizations': [True, True],
'sqrt_type': 'approx'
},
'sliding_window': cy_approx_sliding_window_ess,
'sliding_window_params': {
'visual_word_mask': visual_word_mask,
'rescore': rescore,
'timings_file': timings_file,
},
},
}
chunk_size = CFG[src_cfg]['chunk_size']
base_chunk_size = mgcd(stride, *deltas)
tr_nr_agg = base_chunk_size / chunk_size
# For the old C&C features I have one FV for the entire sample for the
# train data, so I cannot aggregate.
if src_cfg == 'cc':
tr_nr_agg = 1
analytical_fim = ALGO_PARAMS[algo_type]['train_params'].pop(
'analytical_fim', True)
afim_suffix = '_no_afim' if not analytical_fim else ''
tr_outfile = '/scratch2/clear/oneata/tmp/joblib/%s_cls%d_train%s.dat' % (
src_cfg, class_idx, afim_suffix)
tr_video_data, tr_video_labels, tr_stds = load_normalized_tr_data(
dataset,
tr_nr_agg,
tr_outfile=tr_outfile,
verbose=verbose,
analytical_fim=analytical_fim,
**ALGO_PARAMS[algo_type]['train_params'])
# Sub-sample data.
no_tuple_labels = np.array([ll[0] for ll in tr_video_labels])
idxs = (no_tuple_labels == class_idx) | (no_tuple_labels == NULL_CLASS_IDX)
binary_labels = (no_tuple_labels[idxs] == class_idx) * 2 - 1
class_tr_video_data = tr_video_data[idxs]
tr_kernel = np.dot(class_tr_video_data, class_tr_video_data.T)
eval = Evaluation(CFG[src_cfg]['eval_name'], **CFG[src_cfg]['eval_params'])
eval.fit(tr_kernel, binary_labels)
clf = compute_weights(eval.get_classifier(), class_tr_video_data)
results = {}
class_name = dataset.IDX2CLS[class_idx]
non_overlapping_selector = NonOverlappingSelector(base_chunk_size /
chunk_size)
overlapping_selector = OverlappingSelector(base_chunk_size,
stride,
containing,
integral=(not no_integral))
for movie in dataset.TE_MOVIES:
results[movie] = []
for part in xrange(len(dataset.CLASS_LIMITS[movie][class_name])):
te_outfile = (
'/scratch2/clear/oneata/tmp/joblib/%s_cls%d_movie%s_part%d%s_test.dat'
% (src_cfg, class_idx, movie, part, afim_suffix))
te_slice_data = SliceData(
*load_data_delta_0(dataset,
movie,
part,
class_idx,
delta_0=chunk_size,
analytical_fim=analytical_fim,
outfile=te_outfile))
pdb.set_trace()
if verbose > 1:
print "Aggregating data."
# Aggregate data into non-overlapping chunks of size `base_chunk_size`.
N = te_slice_data.fisher_vectors.shape[0]
agg_slice_data = aggregate(
te_slice_data, non_overlapping_selector.get_mask(N),
non_overlapping_selector.get_frame_idxs(N))
if verbose > 1:
print "Starting the sliding window", algo_type
results[movie] += ALGO_PARAMS[algo_type]['sliding_window'](
agg_slice_data, clf, deltas, overlapping_selector, tr_stds,
**ALGO_PARAMS[algo_type]['sliding_window_params'])
return [results]
