def init_training_vars(self):
self.filterbands = generate_filterbank(min_freq=self.min_freq,
max_freq=self.max_freq, last_low_freq=self.last_low_freq,
low_width=self.low_width, low_overlap=self.low_overlap,
high_width=self.high_width, high_overlap=self.high_overlap,
low_bound=self.low_bound)
assert filterbank_is_stable(self.filterbands, self.filt_order,
self.cnt.fs), (
"Expect filter bank to be stable given filter order.")
n_classes = len(self.marker_def)
self.class_pairs = list(itertools.combinations(range(n_classes),2))
# use only number of clean trials to split folds
n_clean_trials = len(self.clean_trials)
if self.restricted_n_trials is not None:
n_clean_trials = int(n_clean_trials * self.restricted_n_trials)
if not self.shuffle:
folds = KFold(n_clean_trials, n_folds=self.n_folds,
shuffle=False)
else:
rng = RandomState(903372376)
folds = KFold(n_clean_trials, n_folds=self.n_folds,
shuffle=True, random_state=rng)
# remap to original indices in unclean set(!)
self.folds = map(lambda fold:
{'train': self.clean_trials[fold[0]],
'test': self.clean_trials[fold[1]]},
folds)
if self.only_last_fold:
self.folds = self.folds[-1:]
def init_training_vars(self):
self.filterbands = generate_filterbank(
min_freq=self.min_freq,
max_freq=self.max_freq,
last_low_freq=self.last_low_freq,
low_width=self.low_width,
low_overlap=self.low_overlap,
high_width=self.high_width,
high_overlap=self.high_overlap,
low_bound=self.low_bound)
assert filterbank_is_stable(
self.filterbands, self.filt_order, self.cnt.fs), (
"Expect filter bank to be stable given filter order.")
# check if number of selected features is not too large
if self.n_selected_features is not None:
n_spatial_filters = self.n_top_bottom_csp_filters
if n_spatial_filters is None:
n_spatial_filters = len(self.sensor_names)
n_max_features = len(self.filterbands) * n_spatial_filters
assert n_max_features >= self.n_selected_features, (
"Cannot select more features than will be originally created "
"Originally: {:d}, requested: {:d}".format(
n_max_features, self.n_selected_features))
n_classes = len(self.marker_def)
self.class_pairs = list(itertools.combinations(range(n_classes), 2))
# use only number of clean trials to split folds
n_clean_trials = len(self.clean_trials)
if self.restricted_n_trials is not None:
if self.restricted_n_trials <= 1:
n_clean_trials = int(n_clean_trials * self.restricted_n_trials)
else:
n_clean_trials = min(n_clean_trials, self.restricted_n_trials)
if not self.shuffle:
folds = KFold(n_clean_trials, n_folds=self.n_folds, shuffle=False)
else:
rng = RandomState(903372376)
folds = KFold(n_clean_trials,
n_folds=self.n_folds,
shuffle=True,
random_state=rng)
# remap to original indices in unclean set(!)
self.folds = map(
lambda fold: {
'train': self.clean_trials[fold[0]],
'test': self.clean_trials[fold[1]]
}, folds)
if self.only_last_fold:
self.folds = self.folds[-1:]
def init_training_vars(self):
assert self.n_folds is None, "Cannot use folds on train test split"
assert self.restricted_n_trials is None, "Not implemented yet"
self.filterbands = generate_filterbank(min_freq=self.min_freq,
max_freq=self.max_freq, last_low_freq=self.last_low_freq,
low_width=self.low_width, low_overlap=self.low_overlap,
high_width=self.high_width, high_overlap=self.high_overlap,
low_bound=self.low_bound)
assert filterbank_is_stable(self.filterbands, self.filt_order,
self.cnt.fs), (
"Expect filter bank to be stable given filter order.")
self.class_pairs = list(itertools.combinations([0,1,2,3],2))
train_fold = range(len(self.cnt.markers))
test_fold = np.arange(len(self.test_cnt.markers)) + len(train_fold)
self.folds = [{'train': train_fold, 'test': test_fold}]
assert np.intersect1d(self.folds[0]['test'],
self.folds[0]['train']).size == 0
# merge cnts!!
self.cnt = append_cnt(self.cnt, self.test_cnt)
def init_training_vars(self):
assert self.n_folds is None, "Cannot use folds on train test split"
assert self.restricted_n_trials is None, "Not implemented yet"
self.filterbands = generate_filterbank(
min_freq=self.min_freq,
max_freq=self.max_freq,
last_low_freq=self.last_low_freq,
low_width=self.low_width,
low_overlap=self.low_overlap,
high_width=self.high_width,
high_overlap=self.high_overlap,
low_bound=self.low_bound)
assert filterbank_is_stable(
self.filterbands, self.filt_order, self.cnt.fs), (
"Expect filter bank to be stable given filter order.")
# check if number of selected features is not too large
if self.n_selected_features is not None:
n_spatial_filters = self.n_top_bottom_csp_filters
if n_spatial_filters is None:
n_spatial_filters = len(self.sensor_names)
n_max_features = len(self.filterbands) * n_spatial_filters
assert n_max_features >= self.n_selected_features, (
"Cannot select more features than will be originally created "
"Originally: {:d}, requested: {:d}".format(
n_max_features, self.n_selected_features))
n_classes = len(self.marker_def)
self.class_pairs = list(itertools.combinations(range(n_classes), 2))
# check that markers are all for trials
for _, mrk_code in self.cnt.markers + self.test_cnt.markers:
assert mrk_code in list(itertools.chain(*self.marker_def.values()))
train_fold = range(len(self.cnt.markers))
test_fold = np.arange(len(self.test_cnt.markers)) + len(train_fold)
self.folds = [{'train': train_fold, 'test': test_fold}]
assert np.intersect1d(self.folds[0]['test'],
self.folds[0]['train']).size == 0
# merge cnts!!
self.cnt = append_cnt(self.cnt, self.test_cnt)
def create_filterbank(self):
log.info("Creating filterbank...")
# Create filterbands and array for holding
# filterband trials
self.filterbands = generate_filterbank(self.min_freq, self.max_freq,
self.last_low_freq, self.low_width, self.high_width)
segment_length = (self.signal_processor.segment_ival[1] -
self.signal_processor.segment_ival[0])
num_samples = segment_length * self.signal_processor.cnt.fs / 1000.0
assert num_samples.is_integer()
num_samples = int(num_samples)
full_epo_data = np.empty((len(self.clean_trials), num_samples,
len(self.sensor_names), len(self.filterbands)), dtype=np.float32)
# Fill filterbank
self.fill_filterbank_data(full_epo_data)
# Transform to wyrm epoched dataset
clean_markers = [m for i,m in enumerate(self.signal_processor.cnt.markers) \
if i not in self.rejected_trials]
del self.signal_processor.cnt
new_epo = Data(data=full_epo_data,
axes=self.filterband_axes, names=self.filterband_names,
units=self.filterband_names)
new_epo.markers = clean_markers
self.signal_processor.epo = new_epo
def envelope_filterbank():
filterbands = generate_filterbank(min_freq=1, max_freq=115,
last_low_freq=31, low_width=6, low_overlap=3,
high_width=8, high_overlap=4, low_bound=0.)
return filterbands
