def test_select_ival(self):
"""Selecting Intervals."""
# normal case
dat = select_ival(self.dat, [-500, 0])
self.assertEqual(dat.axes[1][0], -500)
self.assertEqual(dat.axes[1][-1],-100)
# the full dat interval
dat = select_ival(self.dat, [self.dat.axes[1][0], self.dat.axes[1][-1] + 1])
self.assertEqual(dat.axes[1][0], self.dat.axes[1][0])
self.assertEqual(dat.axes[1][-1], self.dat.axes[1][-1])
np.testing.assert_array_equal(dat.data, self.dat.data)
def test_select_ival(self):
"""Selecting Intervals."""
# normal case
dat = select_ival(self.dat, [-500, 0])
self.assertEqual(dat.axes[1][0], -500)
self.assertEqual(dat.axes[1][-1], -100)
# the full dat interval
dat = select_ival(self.dat,
[self.dat.axes[1][0], self.dat.axes[1][-1] + 1])
self.assertEqual(dat.axes[1][0], self.dat.axes[1][0])
self.assertEqual(dat.axes[1][-1], self.dat.axes[1][-1])
np.testing.assert_array_equal(dat.data, self.dat.data)
def test_select_ival_with_markers(self):
"""Selecting Intervals with markers."""
# normal case
good_markers = [[-499, 99, 'x'], [-500, 'x'], [-0.0001, 'x']]
bad_markers = [[501, 'y'], [0, 'y'], [1, 'y']]
self.dat.markers = good_markers[:]
self.dat.markers.extend(bad_markers)
dat = select_ival(self.dat, [-500, 0])
self.assertEqual(dat.markers, good_markers)
def test_select_ival_with_markers(self):
"""Selecting Intervals with markers."""
# normal case
good_markers = [[-499,99, 'x'], [-500, 'x'], [-0.0001, 'x']]
bad_markers = [[501, 'y'], [0, 'y'], [1, 'y']]
self.dat.markers = good_markers[:]
self.dat.markers.extend(bad_markers)
dat = select_ival(self.dat, [-500, 0])
self.assertEqual(dat.markers, good_markers)
def test_ival_checks(self):
"""Test for malformed ival parameter."""
with self.assertRaises(AssertionError):
select_ival(self.dat, [0, -1])
with self.assertRaises(AssertionError):
select_ival(self.dat, [self.dat.axes[1][0] - 1, 0])
with self.assertRaises(AssertionError):
select_ival(self.dat, [0, self.dat.axes[1][-1] + 1])
def test_ival_checks(self):
"""Test for malformed ival parameter."""
with self.assertRaises(AssertionError):
select_ival(self.dat, [0, -1])
with self.assertRaises(AssertionError):
select_ival(self.dat, [self.dat.axes[1][0]-1, 0])
with self.assertRaises(AssertionError):
select_ival(self.dat, [0, self.dat.axes[1][-1]+1])
def select_ival_with_markers(cnt, segment_ival):
"""Select the ival of the data that has markers inside.
Respect segment ival.
Keeps data from 2 sec before first marker + segment_ival[0] to
2 sec after last marker + segment_ival[1]"""
ms_first_marker = cnt.markers[0][0]
# allow 2 sec before first marker and after last marker
start = max(0, ms_first_marker + segment_ival[0] -2000)
ms_last_marker = cnt.markers[-1][0]
stop = ms_last_marker + segment_ival[1] + 2000
cnt = select_ival(cnt, [start,stop])
# possibly subtract first element of timeaxis so timeaxis starts at 0 again?
return cnt
def select_ival_with_markers(cnt, segment_ival):
"""Select the ival of the data that has markers inside.
Respect segment ival.
Keeps data from 2 sec before first marker + segment_ival[0] to
2 sec after last marker + segment_ival[1]"""
ms_first_marker = cnt.markers[0][0]
# allow 2 sec before first marker and after last marker
start = max(0, ms_first_marker + segment_ival[0] - 2000)
ms_last_marker = cnt.markers[-1][0]
stop = ms_last_marker + segment_ival[1] + 2000
cnt = select_ival(cnt, [start, stop])
# possibly subtract first element of timeaxis so timeaxis starts at 0 again?
return cnt
def test_select_ival_swapaxes(self):
"""select_ival must work with nonstandard timeaxis."""
dat = select_ival(swapaxes(self.dat, 0, 1), [-500, 0], timeaxis=0)
dat = swapaxes(dat, 0, 1)
dat2 = select_ival(self.dat, [-500, 0])
self.assertEqual(dat, dat2)
def test_select_ival_copy(self):
"""Select_ival must not modify the argument."""
cpy = self.dat.copy()
select_ival(cpy, [-500, 0])
self.assertEqual(cpy, self.dat)
def test_select_ival_swapaxes(self):
"""select_ival must work with nonstandard timeaxis."""
dat = select_ival(swapaxes(self.dat, 0, 1), [-500, 0], timeaxis=0)
dat = swapaxes(dat, 0, 1)
dat2 = select_ival(self.dat, [-500, 0])
self.assertEqual(dat, dat2)
def test_select_ival_copy(self):
"""Select_ival must not modify the argument."""
cpy = self.dat.copy()
select_ival(cpy, [-500, 0])
self.assertEqual(cpy, self.dat)
def run_pair(self, epo_train, epo_test, bp_nr, fold_nr, pair_nr):
class_pair = self.class_pairs[pair_nr]
self.print_class_pair(class_pair)
### Run Training
epo_train_pair = select_classes(epo_train, class_pair)
epo_test_pair = select_classes(epo_test, class_pair)
if self.ival_optimizer is not None:
best_segment_ival = self.ival_optimizer.optimize(epo_train_pair)
log.info("Ival {:.0f}ms - {:.0f}ms".format(*best_segment_ival))
epo_train_pair = select_ival(epo_train_pair, best_segment_ival)
epo_test_pair = select_ival(epo_test_pair, best_segment_ival)
epo_train = select_ival(epo_train, best_segment_ival)
epo_test = select_ival(epo_test, best_segment_ival)
self.train_labels[fold_nr][pair_nr] = epo_train_pair.axes[0]
self.test_labels[fold_nr][pair_nr] = epo_test_pair.axes[0]
## Calculate CSP
filters, patterns, variances = calculate_csp(epo_train_pair)
## Apply csp, calculate features
if self.n_filters is not None:
# take topmost and bottommost filters, e.g.
# for n_filters=3 0,1,2,-3,-2,-1
columns = range(0, self.n_filters) + \
range(-self.n_filters, 0)
else: # take all possible filters
columns = range(len(filters))
train_feature = apply_csp_var_log(epo_train_pair, filters, columns)
## Calculate LDA
clf = lda_train_scaled(train_feature, shrink=True)
assert not np.any(np.isnan(clf[0]))
assert not np.isnan(clf[1])
## Apply LDA to train
train_out = lda_apply(train_feature, clf)
correct_train = train_feature.axes[0] == class_pair[1]
predicted_train = train_out >= 0
train_accuracy = (sum(correct_train == predicted_train) /
float(len(predicted_train)))
### Feature Computation and LDA Application for test
test_feature = apply_csp_var_log(epo_test_pair, filters, columns)
test_out = lda_apply(test_feature, clf)
correct_test = test_feature.axes[0] == class_pair[1]
predicted_test = test_out >= 0
test_accuracy = (sum(correct_test == predicted_test) /
float(len(predicted_test)))
### Feature Computations for full fold (for later multiclass)
train_feature_full_fold = apply_csp_var_log(epo_train, filters,
columns)
test_feature_full_fold = apply_csp_var_log(epo_test, filters, columns)
### Store results
# only store used patterns filters variances
# to save memory space on disk
self.store_results(bp_nr, fold_nr, pair_nr, filters[:, columns],
patterns[:, columns], variances[columns],
train_feature, test_feature,
train_feature_full_fold, test_feature_full_fold,
clf, train_accuracy, test_accuracy)
if self.ival_optimizer is not None:
self.best_ival[bp_nr, fold_nr, pair_nr] = best_segment_ival
self.print_results(bp_nr, fold_nr, pair_nr)
def run_pair(self, epo_train, epo_test, bp_nr, fold_nr, pair_nr):
class_pair = self.class_pairs[pair_nr]
self.print_class_pair(class_pair)
### Run Training
epo_train_pair = select_classes(epo_train, class_pair)
epo_test_pair = select_classes(epo_test, class_pair)
if self.ival_optimizer is not None:
best_segment_ival = self.ival_optimizer.optimize(epo_train_pair)
log.info("Ival {:.0f}ms - {:.0f}ms".format(*best_segment_ival))
epo_train_pair = select_ival(epo_train_pair, best_segment_ival)
epo_test_pair = select_ival(epo_test_pair, best_segment_ival)
epo_train = select_ival(epo_train, best_segment_ival)
epo_test = select_ival(epo_test, best_segment_ival)
self.train_labels[fold_nr][pair_nr] = epo_train_pair.axes[0]
self.test_labels[fold_nr][pair_nr] = epo_test_pair.axes[0]
## Calculate CSP
filters, patterns, variances = calculate_csp(epo_train_pair)
## Apply csp, calculate features
if self.n_filters is not None:
# take topmost and bottommost filters, e.g.
# for n_filters=3 0,1,2,-3,-2,-1
columns = range(0, self.n_filters) + range(-self.n_filters, 0)
else: # take all possible filters
columns = range(len(filters))
train_feature = apply_csp_var_log(epo_train_pair, filters, columns)
## Calculate LDA
clf = lda_train_scaled(train_feature, shrink=True)
assert not np.any(np.isnan(clf[0]))
assert not np.isnan(clf[1])
## Apply LDA to train
train_out = lda_apply(train_feature, clf)
correct_train = train_feature.axes[0] == class_pair[1]
predicted_train = train_out >= 0
train_accuracy = sum(correct_train == predicted_train) / float(len(predicted_train))
### Feature Computation and LDA Application for test
test_feature = apply_csp_var_log(epo_test_pair, filters, columns)
test_out = lda_apply(test_feature, clf)
correct_test = test_feature.axes[0] == class_pair[1]
predicted_test = test_out >= 0
test_accuracy = sum(correct_test == predicted_test) / float(len(predicted_test))
### Feature Computations for full fold (for later multiclass)
train_feature_full_fold = apply_csp_var_log(epo_train, filters, columns)
test_feature_full_fold = apply_csp_var_log(epo_test, filters, columns)
### Store results
# only store used patterns filters variances
# to save memory space on disk
self.store_results(
bp_nr,
fold_nr,
pair_nr,
filters[:, columns],
patterns[:, columns],
variances[columns],
train_feature,
test_feature,
train_feature_full_fold,
test_feature_full_fold,
clf,
train_accuracy,
test_accuracy,
)
if self.ival_optimizer is not None:
self.best_ival[bp_nr, fold_nr, pair_nr] = best_segment_ival
self.print_results(bp_nr, fold_nr, pair_nr)
