def load_bbci_data(filename, low_cut_hz):
load_sensor_names = None
loader = BBCIDataset(filename, load_sensor_names=load_sensor_names)
log.info("Loading data...")
cnt = loader.load()
# Cleaning: First find all trials that have absolute microvolt values
# larger than +- 800 inside them and remember them for removal later
log.info("Cutting trials...")
marker_def = OrderedDict([('Right Hand', [1]), ('Left Hand', [2],),
('Rest', [3]), ('Feet', [4])])
clean_ival = [0, 4000]
set_for_cleaning = create_signal_target_from_raw_mne(cnt, marker_def,
clean_ival)
clean_trial_mask = np.max(np.abs(set_for_cleaning.X), axis=(1, 2)) < 800
log.info("Clean trials: {:3d} of {:3d} ({:5.1f}%)".format(
np.sum(clean_trial_mask),
len(set_for_cleaning.X),
np.mean(clean_trial_mask) * 100))
# now pick only sensors with C in their name
# as they cover motor cortex
C_sensors = ['FC5', 'FC1', 'FC2', 'FC6', 'C3', 'C4', 'CP5',
'CP1', 'CP2', 'CP6', 'FC3', 'FCz', 'FC4', 'C5', 'C1', 'C2',
'C6',
'CP3', 'CPz', 'CP4', 'FFC5h', 'FFC3h', 'FFC4h', 'FFC6h',
'FCC5h',
'FCC3h', 'FCC4h', 'FCC6h', 'CCP5h', 'CCP3h', 'CCP4h', 'CCP6h',
'CPP5h',
'CPP3h', 'CPP4h', 'CPP6h', 'FFC1h', 'FFC2h', 'FCC1h', 'FCC2h',
'CCP1h',
'CCP2h', 'CPP1h', 'CPP2h']
cnt = cnt.pick_channels(C_sensors)
# Further preprocessings
log.info("Resampling...")
cnt = resample_cnt(cnt, 250.0)
print("REREFERENCING")
log.info("Highpassing...")
cnt = mne_apply(lambda a: highpass_cnt(a, low_cut_hz, cnt.info['sfreq'], filt_order=3, axis=1),cnt)
log.info("Standardizing...")
cnt = mne_apply(lambda a: exponential_running_standardize(a.T, factor_new=1e-3,init_block_size=1000,eps=1e-4).T,cnt)
# Trial interval, start at -500 already, since improved decoding for networks
ival = [-500, 4000]
dataset = create_signal_target_from_raw_mne(cnt, marker_def, ival)
dataset.X = dataset.X[clean_trial_mask]
dataset.y = dataset.y[clean_trial_mask]
return dataset.X, dataset.y
def load_bbci_data(filename, low_cut_hz, debug=False):
load_sensor_names = None
if debug:
load_sensor_names = ['C3', 'C4', 'C2']
loader = BBCIDataset(filename, load_sensor_names=load_sensor_names)
log.info("Loading data...")
cnt = loader.load()
log.info("Cutting trials...")
marker_def = OrderedDict([('Right Hand', [1]), (
'Left Hand',
[2],
), ('Rest', [3]), ('Feet', [4])])
clean_ival = [0, 4000]
set_for_cleaning = create_signal_target_from_raw_mne(
cnt, marker_def, clean_ival)
clean_trial_mask = np.max(np.abs(set_for_cleaning.X), axis=(1, 2)) < 800
log.info("Clean trials: {:3d} of {:3d} ({:5.1f}%)".format(
np.sum(clean_trial_mask), len(set_for_cleaning.X),
np.mean(clean_trial_mask) * 100))
# lets convert to millivolt for numerical stability of next operations
C_sensors = [
'FC5', 'FC1', 'FC2', 'FC6', 'C3', 'C4', 'CP5', 'CP1', 'CP2', 'CP6',
'FC3', 'FCz', 'FC4', 'C5', 'C1', 'C2', 'C6', 'CP3', 'CPz', 'CP4',
'FFC5h', 'FFC3h', 'FFC4h', 'FFC6h', 'FCC5h', 'FCC3h', 'FCC4h', 'FCC6h',
'CCP5h', 'CCP3h', 'CCP4h', 'CCP6h', 'CPP5h', 'CPP3h', 'CPP4h', 'CPP6h',
'FFC1h', 'FFC2h', 'FCC1h', 'FCC2h', 'CCP1h', 'CCP2h', 'CPP1h', 'CPP2h'
]
if debug:
C_sensors = load_sensor_names
cnt = cnt.pick_channels(C_sensors)
cnt = mne_apply(lambda a: a * 1e6, cnt)
log.info("Resampling...")
cnt = resample_cnt(cnt, 250.0)
log.info("Highpassing...")
cnt = mne_apply(
lambda a: highpass_cnt(
a, low_cut_hz, cnt.info['sfreq'], filt_order=3, axis=1), cnt)
log.info("Standardizing...")
cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, factor_new=1e-3, init_block_size=1000, eps=1e-4).T, cnt)
ival = [-500, 4000]
dataset = create_signal_target_from_raw_mne(cnt, marker_def, ival)
return dataset
def load_data(filenames, sensor_names, name_to_start_codes,
name_to_stop_codes, trial_ival, break_ival,
min_break_length_ms, max_break_length_ms, input_time_length,
filename_to_extra_args):
all_sets = []
original_args = locals()
for filename in filenames:
kwargs = deepcopy(original_args)
if filename in filename_to_extra_args:
kwargs.update(filename_to_extra_args[filename])
log.info("Loading {:s}...".format(filename))
cnt = BBCIDataset(filename, load_sensor_names=sensor_names).load()
cnt = cnt.drop_channels(['STI 014'])
log.info("Resampling...")
cnt = resample_cnt(cnt, 100)
log.info("Standardizing...")
cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, init_block_size=50).T, cnt)
log.info("Transform to set...")
full_set = (create_signal_target_with_breaks_from_mne(
cnt,
kwargs['name_to_start_codes'],
kwargs['trial_ival'],
kwargs['name_to_stop_codes'],
kwargs['min_break_length_ms'],
kwargs['max_break_length_ms'],
kwargs['break_ival'],
prepad_trials_to_n_samples=kwargs['input_time_length'],
))
all_sets.append(full_set)
return all_sets
def get_data():
import os
os.sys.path.append('/home/schirrmr/braindecode/code/braindecode/')
from braindecode.datautil.trial_segment import create_signal_target_from_raw_mne
from braindecode.datasets.bbci import BBCIDataset
from braindecode.mne_ext.signalproc import mne_apply, resample_cnt
from braindecode.datautil.signalproc import exponential_running_standardize
subject_id = 4 # 1-14
loader = BBCIDataset(
'/data/schirrmr/schirrmr/HGD-public/reduced/train/{:d}.mat'.format(
subject_id),
load_sensor_names=['C3'])
cnt = loader.load()
cnt = cnt.drop_channels(['STI 014'])
from collections import OrderedDict
marker_def = OrderedDict([('Right Hand', [1]), (
'Left Hand',
[2],
), ('Rest', [3]), ('Feet', [4])])
# Here you can choose a larger sampling rate later
# Right now chosen very small to allow fast initial experiments
cnt = resample_cnt(cnt, new_fs=500)
cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, factor_new=1e-3, init_block_size=1000, eps=1e-4).T, cnt)
ival = [0, 2000] # ms to cut trial
dataset = create_signal_target_from_raw_mne(cnt, marker_def, ival)
return dataset.X, dataset.y
def bandpass_mne(cnt, low_cut_hz, high_cut_hz, filt_order=3, axis=0):
return mne_apply(
lambda data: bandpass_cnt(data.T,
low_cut_hz,
high_cut_hz,
fs=cnt.info['sfreq'],
filt_order=filt_order,
axis=axis).T, cnt)
def _create_examples(self):
name_to_code = OrderedDict([('Right', 1), ('Left', 2), ('Rest', 3),
('Feet', 4)])
data_list_list = []
for file_name in self.file_names:
cnt = BBCIDataset(file_name,
load_sensor_names=self.load_sensor_names).load()
cnt = cnt.drop_channels(['STI 014'])
cnt = resample_cnt(cnt, self.sampling_freq)
if self.normalization_type == 'exponential':
cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, init_block_size=1000, factor_new=0.001, eps=1e-4).
T, cnt)
data = create_signal_target_from_raw_mne(cnt, name_to_code,
self.segment_ival_ms)
data_list = [(d, l) for d, l in zip(data.X, data.y)]
data_list = self.cv_split(data_list)
# Normalize the data
if self.normalization_type == 'standard':
running_statistics = RunningStatistics(
dim=data_list[0][0].shape[0], time_dimension_first=False)
for data, label in data_list:
running_statistics.append(data)
mean = running_statistics.mean_vector()
sdev = np.clip(np.sqrt(running_statistics.var_vector()), 1e-5,
None)
logger.info('Normalize with \n mean: %s, \n sdev: %s' %
(mean, sdev))
for i in range(len(data_list)):
data_list[i] = ((data_list[i][0] - mean) / sdev,
data_list[i][1])
data_list_list.append(data_list)
# Create examples for 4 classes
for i, data_list in enumerate(data_list_list):
for label in range(4):
class_data_list = [
data for data in data_list if data[1] == label
]
self.examples.append([
BBCIDataReaderMulti.ExampleInfo(
example_id=str((i, label, j)),
random_mode=self.random_mode,
offset_size=self.offset_size,
label=label,
data=data,
context=i)
for (j, (data, label)) in enumerate(class_data_list)
])
def load_file(filename, car=True, load_sensor_names=None):
cnt = BBCIDataset(filename, load_sensor_names=load_sensor_names).load()
cnt = cnt.drop_channels(["STI 014"])
if car:
def car(a):
return a - np.mean(a, keepdims=True, axis=0)
cnt = mne_apply(car, cnt)
return cnt
def processing_data(data_folder, subject_id, low_cut_hz, high_cut_hz, factor_new, init_block_size, ival, valid_set_fraction):
train_filename = 'A{:02d}T.gdf'.format(subject_id)
test_filename = 'A{:02d}E.gdf'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace('.gdf', '.mat')
test_label_filepath = test_filepath.replace('.gdf', '.mat')
train_loader = BCICompetition4Set2A(
train_filepath, labels_filename=train_label_filepath)
test_loader = BCICompetition4Set2A(
test_filepath, labels_filename=test_label_filepath)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
# Preprocessing
train_cnt = train_cnt.drop_channels(['STI 014', 'EOG-left',
'EOG-central', 'EOG-right'])
assert len(train_cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(a, low_cut_hz, high_cut_hz,
train_cnt.info['sfreq'],
filt_order=3,
axis=1), train_cnt)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T, factor_new=factor_new,
init_block_size=init_block_size,
eps=1e-4).T,
train_cnt)
test_cnt = test_cnt.drop_channels(['STI 014', 'EOG-left',
'EOG-central', 'EOG-right'])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(a, low_cut_hz, high_cut_hz,
test_cnt.info['sfreq'],
filt_order=3,
axis=1), test_cnt)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T, factor_new=factor_new,
init_block_size=init_block_size,
eps=1e-4).T,
test_cnt)
marker_def = OrderedDict([('Left Hand', [1]), ('Right Hand', [2],),
('Foot', [3]), ('Tongue', [4])])
train_set = create_signal_target_from_raw_mne(
train_cnt, marker_def, ival)
test_set = create_signal_target_from_raw_mne(
test_cnt, marker_def, ival)
train_set, valid_set = split_into_two_sets(
train_set, first_set_fraction=1 - valid_set_fraction)
return train_set, valid_set, test_set
def preprocessing(data_folder, subject_id, low_cut_hz):
global train_set, test_set, valid_set, n_classes, n_chans
global n_iters, input_time_length
# def run_exp(data_folder, subject_id, low_cut_hz, model, cuda):
train_filename = 'A{:02d}T.gdf'.format(subject_id)
test_filename = 'A{:02d}E.gdf'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace('.gdf', '.mat')
test_label_filepath = test_filepath.replace('.gdf', '.mat')
train_loader = BCICompetition4Set2A(
train_filepath, labels_filename=train_label_filepath)
test_loader = BCICompetition4Set2A(
test_filepath, labels_filename=test_label_filepath)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
train_cnt = train_cnt.drop_channels(['STI 014', 'EOG-left',
'EOG-central', 'EOG-right'])
assert len(train_cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(a, low_cut_hz, 38, train_cnt.info['sfreq'],
filt_order=3,
axis=1), train_cnt)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T, factor_new=1e-3,
init_block_size=1000,
eps=1e-4).T,
train_cnt)
test_cnt = test_cnt.drop_channels(['STI 014', 'EOG-left',
'EOG-central', 'EOG-right'])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(a, low_cut_hz, 38, test_cnt.info['sfreq'],
filt_order=3,
axis=1), test_cnt)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T, factor_new=1e-3,
init_block_size=1000,
eps=1e-4).T,
test_cnt)
marker_def = OrderedDict([('Left Hand', [1]), ('Right Hand', [2],),
('Foot', [3]), ('Tongue', [4])])
ival = [-500, 4000]
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def, ival)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def, ival)
train_set, valid_set = split_into_two_sets(train_set,
first_set_fraction=0.8)
set_random_seeds(seed=20190706, cuda=cuda)
n_classes = 4
n_chans = int(train_set.X.shape[1])
input_time_length=1000
def preprocess_cnt(cnt, final_hz, half_before):
log.info("Resampling...")
cnt = resample_cnt(cnt, 250.0)
log.info("Standardizing...")
cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, factor_new=1e-3, init_block_size=1000, eps=1e-4
).T,
cnt,
)
if half_before:
cnt = resample_cnt(cnt, final_hz / 2.0)
cnt = resample_cnt(cnt, final_hz)
return cnt
def standardize_cnt(cnt, standardize_mode=0):
# computing frequencies
sampling_freq = cnt.info['sfreq']
init_freq = 0.1
stop_freq = sampling_freq / 2 - 0.1
filt_order = 3
axis = 0
filtfilt = False
# filtering DC and frequencies higher than the nyquist one
cnt = mne_apply(
lambda x: bandpass_cnt(data=x,
low_cut_hz=init_freq,
high_cut_hz=stop_freq,
fs=sampling_freq,
filt_order=filt_order,
axis=axis,
filtfilt=filtfilt), cnt)
# removing mean and normalizing in 3 different ways
if standardize_mode == 0:
# x - mean
cnt = mne_apply(lambda x: x - mean(x, axis=0, keepdims=True), cnt)
elif standardize_mode == 1:
# (x - mean) / std
cnt = mne_apply(
lambda x: (x - mean(x, axis=0, keepdims=True)) / std(
x, axis=0, keepdims=True), cnt)
elif standardize_mode == 2:
# parsing to milli volt for numerical stability of next operations
cnt = mne_apply(lambda a: a * 1e6, cnt)
# applying exponential_running_standardize (Schirrmeister)
cnt = mne_apply(
lambda x: exponential_running_standardize(
x.T, factor_new=1e-3, init_block_size=1000, eps=1e-4).T, cnt)
return cnt
def process_bbci_data(filename, labels_filename, low_cut_hz):
ival = [-500, 4000]
high_cut_hz = 38
factor_new = 1e-3
init_block_size = 1000
loader = BCICompetition4Set2A(filename, labels_filename=labels_filename)
cnt = loader.load()
# Preprocessing
cnt = cnt.drop_channels(
['STI 014', 'EOG-left', 'EOG-central', 'EOG-right'])
assert len(cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
cnt = mne_apply(lambda a: a * 1e6, cnt)
cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
cnt.info['sfreq'],
filt_order=3,
axis=1), cnt)
cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, cnt)
marker_def = OrderedDict([('Left Hand', [1]), (
'Right Hand',
[2],
), ('Foot', [3]), ('Tongue', [4])])
dataset = create_signal_target_from_raw_mne(cnt, marker_def, ival)
return dataset
def import_EEGData_test(start=0, end=9, dir='../data_HGD/test/'):
X, y = [], []
for i in range(start, end):
dataFile = str(dir + str(i + 1) + '.mat')
print("File:", dataFile, " loading...")
cnt = BBCIDataset(filename=dataFile, load_sensor_names=None).load()
marker_def = OrderedDict([('Right Hand', [1]), (
'Left Hand',
[2],
), ('Rest', [3]), ('Feet', [4])])
clean_ival = [0, 4000]
set_for_cleaning = create_signal_target_from_raw_mne(
cnt, marker_def, clean_ival)
clean_trial_mask = np.max(np.abs(set_for_cleaning.X),
axis=(1, 2)) < 800
C_sensors = [
'FC5', 'FC1', 'FC2', 'FC6', 'C3', 'C4', 'CP5', 'CP1', 'CP2', 'CP6',
'FC3', 'FCz', 'FC4', 'C5', 'C1', 'C2', 'C6', 'CP3', 'CPz', 'CP4',
'FFC5h', 'FFC3h', 'FFC4h', 'FFC6h', 'FCC5h', 'FCC3h', 'FCC4h',
'FCC6h', 'CCP5h', 'CCP3h', 'CCP4h', 'CCP6h', 'CPP5h', 'CPP3h',
'CPP4h', 'CPP6h', 'FFC1h', 'FFC2h', 'FCC1h', 'FCC2h', 'CCP1h',
'CCP2h', 'CPP1h', 'CPP2h'
]
cnt = cnt.pick_channels(C_sensors)
cnt = resample_cnt(cnt, 250.0)
cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, factor_new=1e-3, init_block_size=1000, eps=1e-4).T, cnt)
ival = [-500, 4000]
dataset = create_signal_target_from_raw_mne(cnt, marker_def, ival)
dataset.X = dataset.X[clean_trial_mask]
dataset.X = dataset.X[:, :, np.newaxis, :]
dataset.y = dataset.y[clean_trial_mask]
dataset.y = dataset.y[:, np.newaxis]
X.extend(dataset.X)
y.extend(dataset.y)
X = data_in_one(np.array(X))
y = np.array(y)
print("X:", X.shape)
print("y:", y.shape)
dataset = EEGDataset(X, y)
return dataset
def run_exp(data_folder, subject_id, low_cut_hz, test_model, model_PATH, model, cuda):
ival = [-500, 4000]
high_cut_hz = 38
factor_new = 1e-3
init_block_size = 1000
test_filename = "A{:02d}E.gdf".format(subject_id)
test_filepath = os.path.join(data_folder, test_filename)
test_label_filepath = test_filepath.replace(".gdf", ".mat")
test_loader = BCICompetition4Set2A(
test_filepath, labels_filename=test_label_filepath
)
test_cnt = test_loader.load()
# Preprocessing
test_cnt = test_cnt.drop_channels(["EOG-left", "EOG-central", "EOG-right"])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(
a,
low_cut_hz,
high_cut_hz,
test_cnt.info["sfreq"],
filt_order=3,
axis=1,
),
test_cnt,
)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T,
factor_new=factor_new,
init_block_size=init_block_size,
eps=1e-4,
).T,
test_cnt,
)
marker_def = OrderedDict(
[
("Left Hand", [1]),
("Right Hand", [2]),
("Foot", [3]),
("Tongue", [4]),
]
)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def, ival)
test_set = data_all_chan_cwtandraw(test_set)
set_random_seeds(seed=20200104, cuda=cuda)
model = SelfShallow()
if test_model:
model.load_state_dict(torch.load(model_PATH))
if cuda:
model.cuda()
model.eval()
log.info("Model: \n{:s}".format(str(model)))
all_test_labels = test_set.y
all_test_data = torch.from_numpy(test_set.X).cuda()
preds,feature1,feature2,raw,guide = model(all_test_data)
preds = preds.cpu()
preds = preds.detach().numpy()
all_preds = np.argmax(preds, axis=1).squeeze()
accury = np.mean(all_test_labels==all_preds)
print('accury:',accury)
def run_exp(data_folder, subject_id, low_cut_hz, model, cuda):
train_filename = 'A{:02d}T.gdf'.format(subject_id)
test_filename = 'A{:02d}E.gdf'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace('.gdf', '.mat')
test_label_filepath = test_filepath.replace('.gdf', '.mat')
train_loader = BCICompetition4Set2A(train_filepath,
labels_filename=train_label_filepath)
test_loader = BCICompetition4Set2A(test_filepath,
labels_filename=test_label_filepath)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
# Preprocessing
train_cnt = train_cnt.drop_channels(
['STI 014', 'EOG-left', 'EOG-central', 'EOG-right'])
assert len(train_cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(
a, low_cut_hz, 38, train_cnt.info['sfreq'], filt_order=3, axis=1),
train_cnt)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, factor_new=1e-3, init_block_size=1000, eps=1e-4).T, train_cnt)
test_cnt = test_cnt.drop_channels(
['STI 014', 'EOG-left', 'EOG-central', 'EOG-right'])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(
a, low_cut_hz, 38, test_cnt.info['sfreq'], filt_order=3, axis=1),
test_cnt)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, factor_new=1e-3, init_block_size=1000, eps=1e-4).T, test_cnt)
marker_def = OrderedDict([('Left Hand', [1]), (
'Right Hand',
[2],
), ('Foot', [3]), ('Tongue', [4])])
ival = [-500, 4000]
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def, ival)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def, ival)
train_set, valid_set = split_into_two_sets(train_set,
first_set_fraction=0.8)
set_random_seeds(seed=20190706, cuda=cuda)
n_classes = 4
n_chans = int(train_set.X.shape[1])
input_time_length = train_set.X.shape[2]
if model == 'shallow':
model = ShallowFBCSPNet(n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length='auto').create_network()
elif model == 'deep':
model = Deep4Net(n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length='auto').create_network()
if cuda:
model.cuda()
log.info("Model: \n{:s}".format(str(model)))
optimizer = optim.Adam(model.parameters())
iterator = BalancedBatchSizeIterator(batch_size=60)
stop_criterion = Or([MaxEpochs(1600), NoDecrease('valid_misclass', 160)])
monitors = [LossMonitor(), MisclassMonitor(), RuntimeMonitor()]
model_constraint = MaxNormDefaultConstraint()
exp = Experiment(model,
train_set,
valid_set,
test_set,
iterator=iterator,
loss_function=F.nll_loss,
optimizer=optimizer,
model_constraint=model_constraint,
monitors=monitors,
stop_criterion=stop_criterion,
remember_best_column='valid_misclass',
run_after_early_stop=True,
cuda=cuda)
exp.run()
return exp
def run_exp(data_folder, subject_id, low_cut_hz, model, cuda):
ival = [-500, 4000]
input_time_length = 1000
max_epochs = 800
max_increase_epochs = 80
batch_size = 60
high_cut_hz = 38
factor_new = 1e-3
init_block_size = 1000
valid_set_fraction = 0.2
train_filename = 'A{:02d}T.gdf'.format(subject_id)
test_filename = 'A{:02d}E.gdf'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace('.gdf', '.mat')
test_label_filepath = test_filepath.replace('.gdf', '.mat')
train_loader = BCICompetition4Set2A(train_filepath,
labels_filename=train_label_filepath)
test_loader = BCICompetition4Set2A(test_filepath,
labels_filename=test_label_filepath)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
# Preprocessing
train_cnt = train_cnt.drop_channels(
['STI 014', 'EOG-left', 'EOG-central', 'EOG-right'])
assert len(train_cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
train_cnt.info['sfreq'],
filt_order=3,
axis=1), train_cnt)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, train_cnt)
test_cnt = test_cnt.drop_channels(
['STI 014', 'EOG-left', 'EOG-central', 'EOG-right'])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
test_cnt.info['sfreq'],
filt_order=3,
axis=1), test_cnt)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, test_cnt)
marker_def = OrderedDict([('Left Hand', [1]), (
'Right Hand',
[2],
), ('Foot', [3]), ('Tongue', [4])])
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def, ival)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def, ival)
train_set, valid_set = split_into_two_sets(train_set,
first_set_fraction=1 -
valid_set_fraction)
set_random_seeds(seed=20190706, cuda=cuda)
n_classes = 4
n_chans = int(train_set.X.shape[1])
if model == 'shallow':
model = ShallowFBCSPNet(n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length=30).create_network()
elif model == 'deep':
model = Deep4Net(n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length=2).create_network()
to_dense_prediction_model(model)
if cuda:
model.cuda()
log.info("Model: \n{:s}".format(str(model)))
dummy_input = np_to_var(train_set.X[:1, :, :, None])
if cuda:
dummy_input = dummy_input.cuda()
out = model(dummy_input)
n_preds_per_input = out.cpu().data.numpy().shape[2]
optimizer = optim.Adam(model.parameters())
iterator = CropsFromTrialsIterator(batch_size=batch_size,
input_time_length=input_time_length,
n_preds_per_input=n_preds_per_input)
stop_criterion = Or([
MaxEpochs(max_epochs),
NoDecrease('valid_misclass', max_increase_epochs)
])
monitors = [
LossMonitor(),
MisclassMonitor(col_suffix='sample_misclass'),
CroppedTrialMisclassMonitor(input_time_length=input_time_length),
RuntimeMonitor()
]
model_constraint = MaxNormDefaultConstraint()
loss_function = lambda preds, targets: F.nll_loss(
th.mean(preds, dim=2, keepdim=False), targets)
exp = Experiment(model,
train_set,
valid_set,
test_set,
iterator=iterator,
loss_function=loss_function,
optimizer=optimizer,
model_constraint=model_constraint,
monitors=monitors,
stop_criterion=stop_criterion,
remember_best_column='valid_misclass',
run_after_early_stop=True,
cuda=cuda)
exp.run()
return exp
def concat_prepare_cnn(input_signal):
# In this particular data set
# it was required by the author of it,
# that for preventing the algorithm
# to pick on data of the eye movement,
# a high band filter of Hz had to
# be implimented.
low_cut_hz = 1
# The authors prove both configuration >38 an 38< frequenzy
# in the current experiment, we see that band pass filter will take
# Theta to part of Gamma frequenzy band
# whihch what Filter Bank Commun spatial patters would do.
# This value is a hiperpartemer that should be ajusted
# per data set... In my opinion.
high_cut_hz = 40
# factor for exponential smothing
# are this numbers usually setup used
# on neuro sciencie?
factor_new = 1e-3
# initianlization values for the the mean and variance,
# see prior discussion
init_block_size = 1000
# model = "shallow" #'shallow' or 'deep'
# GPU support
# cuda = True
# It was stated in the paper [1] that
# "trial window for later experiments with convolutional
# networks, that is, from 0.5 to 4 s."
# 0- 20s?
# so "ival" variable simple states what milisecond interval to analize
# per trial.
ival = [0, 20000]
# An epoch increase every time the whole training data point
# had been input to the network. An epoch is not a batch
# example, if we have 100 training data points
# and we use batch_size 10, it will take 10 iterations of
# batch_size to reach 1 epoch.
# max_epochs = 1600
# max_increase_epochs = 160
# 60 data point per forward-backwards propagation
# batch_size = 60
# pertecentage of data to be used as test-set
valid_set_fraction = 0.2
gdf_events = mne.find_events(input_signal)
input_signal = input_signal.drop_channels(["stim"])
raw_training_signal = input_signal.get_data()
print("data shape:", raw_training_signal.shape)
for i_chan in range(raw_training_signal.shape[0]):
# first set to nan, than replace nans by nanmean.
this_chan = raw_training_signal[i_chan]
raw_training_signal[i_chan] = np.where(this_chan == np.min(this_chan),
np.nan, this_chan)
mask = np.isnan(raw_training_signal[i_chan])
chan_mean = np.nanmean(raw_training_signal[i_chan])
raw_training_signal[i_chan, mask] = chan_mean
# Reconstruct
input_signal = mne.io.RawArray(raw_training_signal,
input_signal.info,
verbose="WARNING")
# append the extracted events
# raw_gdf_training_signal
# raw_gdf_training_signal
input_signal.info["events"] = gdf_events
train_cnt = input_signal
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(
a,
low_cut_hz,
high_cut_hz,
train_cnt.info["sfreq"],
filt_order=3,
axis=1,
),
train_cnt,
)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T,
factor_new=factor_new,
init_block_size=init_block_size,
eps=1e-4,
).T,
train_cnt,
)
marker_def = OrderedDict([("ec", [30])])
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def, ival)
return train_set
def data_gen(subject, high_cut_hz=38, low_cut_hz=0):
data_sub = {}
for i in range(len(subject)):
subject_id = subject[i]
data_folder = r'D:\li\=.=\eeg\hw\nn-STFT\dataset\BCICIV_2a_gdf'
ival = [-500, 4000]
factor_new = 1e-3
init_block_size = 1000
train_filename = 'A{:02d}T.gdf'.format(subject_id)
test_filename = 'A{:02d}E.gdf'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace('.gdf', '.mat')
test_label_filepath = test_filepath.replace('.gdf', '.mat')
train_loader = BCICompetition4Set2A(
train_filepath, labels_filename=train_label_filepath)
test_loader = BCICompetition4Set2A(test_filepath,
labels_filename=test_label_filepath)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
# train_loader = BCICompetition4Set2A(
# train_filepath, labels_filename=train_label_filepath)
# test_loader = BCICompetition4Set2A(
# test_filepath, labels_filename=test_label_filepath)
# train_cnt = train_loader.load()
# test_cnt = test_loader.load()
# train set process
train_cnt = train_cnt.drop_channels(
['EOG-left', 'EOG-central', 'EOG-right'])
assert len(train_cnt.ch_names) == 22
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
train_cnt.info['sfreq'],
filt_order=3,
axis=1), train_cnt)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, train_cnt)
# test set process
test_cnt = test_cnt.drop_channels(
['EOG-left', 'EOG-central', 'EOG-right'])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
test_cnt.info['sfreq'],
filt_order=3,
axis=1), test_cnt)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, test_cnt)
marker_def = OrderedDict([('Left Hand', [1]), (
'Right Hand',
[2],
), ('Foot', [3]), ('Tongue', [4])])
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def,
ival)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def,
ival)
data_sub[str(subject_id)] = concatenate_sets([train_set, test_set])
if i == 0:
dataset = data_sub[str(subject_id)]
else:
dataset = concatenate_sets([dataset, data_sub[str(subject_id)]])
assert len(data_sub) == len(subject)
return dataset
# Remove stimulus channel
cnt = cnt.drop_channels(['STI 014'])
# for now, remove also robot,ecg and respiration channels
#cnt = cnt.drop_channels(sensor_names_robot_aux)
# resample if wrong sf
resampleToHz = samplingRate
cnt = resample_cnt(cnt, resampleToHz)
# mne apply will apply the function to the data (a 2d-numpy-array)
# have to transpose data back and forth, since
# exponential_running_standardize expects time x chans order
# while mne object has chans x time order
cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, init_block_size=1000, factor_new=0.001, eps=1e-4).T,
cnt)
name_to_start_codes = OrderedDict([('ScoreExp', 1)])
name_to_stop_codes = OrderedDict([('ScoreExp', 2)])
train_set = create_signal_target_from_raw_mne(
cnt, name_to_start_codes, [0, 0], name_to_stop_codes)
train_set.y = Score[:, :-1]
# Outer added axis is the trial axis (size one always...)
#from braindecode.datautil.signal_target import SignalAndTarget
#datasets = SignalAndTarget(train_set.X[0].astype(np.float32), train_set.y.astype(np.float32))
# split data and test set
def get_bci_iv_2a_train_val_test(data_folder, subject_id, low_cut_hz):
ival = [
-500, 4000
] # this is the window around the event from which we will take data to feed to the classifier
high_cut_hz = 38 # cut off parts of signal higher than 38 hz
factor_new = 1e-3 # ??? has to do with exponential running standardize
init_block_size = 1000 # ???
train_filename = 'A{:02d}T.gdf'.format(subject_id)
test_filename = 'A{:02d}E.gdf'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace('.gdf', '.mat')
test_label_filepath = test_filepath.replace('.gdf', '.mat')
train_loader = BCICompetition4Set2A(train_filepath,
labels_filename=train_label_filepath)
test_loader = BCICompetition4Set2A(test_filepath,
labels_filename=test_label_filepath)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
train_cnt = train_cnt.drop_channels(
['EOG-left', 'EOG-central', 'EOG-right'])
if len(train_cnt.ch_names) > 22:
train_cnt = train_cnt.drop_channels(['STI 014'])
assert len(train_cnt.ch_names) == 22
# convert measurements to millivolt
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply( # signal processing procedure that I don't understand
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
train_cnt.info['sfreq'],
filt_order=3,
axis=1), train_cnt)
train_cnt = mne_apply( # signal processing procedure that I don't understand
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, train_cnt)
test_cnt = test_cnt.drop_channels(['EOG-left', 'EOG-central', 'EOG-right'])
if len(test_cnt.ch_names) > 22:
test_cnt = test_cnt.drop_channels(['STI 014'])
assert len(test_cnt.ch_names) == 22
# convert measurements to millivolt
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
test_cnt.info['sfreq'],
filt_order=3,
axis=1), test_cnt)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, test_cnt)
marker_def = OrderedDict([('Left Hand', [1]), (
'Right Hand',
[2],
), ('Foot', [3]), ('Tongue', [4])])
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def, ival)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def, ival)
train_set, valid_set = split_into_two_sets(
train_set,
first_set_fraction=1 - global_vars.get('valid_set_fraction'))
return train_set, valid_set, test_set
train_loader = BCICompetition4Set2A(
train_filepath, labels_filename=train_label_filepath
)
test_loader = BCICompetition4Set2A(
test_filepath, labels_filename=test_label_filepath
)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
# Preprocessing
train_cnt = train_cnt.drop_channels(["EOG-left", "EOG-central", "EOG-right"])
assert len(train_cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(
a,
low_cut_hz,
high_cut_hz,
train_cnt.info["sfreq"],
filt_order=3,
axis=1,
),
train_cnt,
)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T, factor_new=factor_new, init_block_size=init_block_size, eps=1e-4
).T,
def run_exp(data_folder, session_id, subject_id, low_cut_hz, model, cuda):
ival = [-500, 4000]
max_epochs = 1600
max_increase_epochs = 160
batch_size = 10
high_cut_hz = 38
factor_new = 1e-3
init_block_size = 1000
valid_set_fraction = .2
''' # BCIcompetition
train_filename = 'A{:02d}T.gdf'.format(subject_id)
test_filename = 'A{:02d}E.gdf'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace('.gdf', '.mat')
test_label_filepath = test_filepath.replace('.gdf', '.mat')
train_loader = BCICompetition4Set2A(
train_filepath, labels_filename=train_label_filepath)
test_loader = BCICompetition4Set2A(
test_filepath, labels_filename=test_label_filepath)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
'''
# GIGAscience
filename = 'sess{:02d}_subj{:02d}_EEG_MI.mat'.format(
session_id, subject_id)
filepath = os.path.join(data_folder, filename)
train_variable = 'EEG_MI_train'
test_variable = 'EEG_MI_test'
train_loader = GIGAscience(filepath, train_variable)
test_loader = GIGAscience(filepath, test_variable)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
# Preprocessing
''' channel
['Fp1', 'Fp2', 'F7', 'F3', 'Fz', 'F4', 'F8', 'FC5', 'FC1', 'FC2', 'FC6', 'T7', 'C3', 'Cz', 'C4', 'T8', 'TP9', 'CP5',
'CP1', 'CP2', 'CP6', 'TP10', 'P7', 'P3', 'Pz', 'P4', 'P8', 'PO9', 'O1', 'Oz', 'O2', 'PO10', 'FC3', 'FC4', 'C5',
'C1', 'C2', 'C6', 'CP3', 'CPz', 'CP4', 'P1', 'P2', 'POz', 'FT9', 'FTT9h', 'TTP7h', 'TP7', 'TPP9h', 'FT10',
'FTT10h', 'TPP8h', 'TP8', 'TPP10h', 'F9', 'F10', 'AF7', 'AF3', 'AF4', 'AF8', 'PO3', 'PO4']
'''
train_cnt = train_cnt.pick_channels([
'FC5', 'FC3', 'FC1', 'Fz', 'FC2', 'FC4', 'FC6', 'C5', 'C3', 'C1', 'Cz',
'C2', 'C4', 'C6', 'CP5', 'CP3', 'CP1', 'CPz', 'CP2', 'CP4', 'CP6', 'Pz'
])
train_cnt, train_cnt.info['events'] = train_cnt.copy().resample(
250, npad='auto', events=train_cnt.info['events'])
assert len(train_cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
train_cnt.info['sfreq'],
filt_order=3,
axis=1), train_cnt)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, train_cnt)
test_cnt = test_cnt.pick_channels([
'FC5', 'FC3', 'FC1', 'Fz', 'FC2', 'FC4', 'FC6', 'C5', 'C3', 'C1', 'Cz',
'C2', 'C4', 'C6', 'CP5', 'CP3', 'CP1', 'CPz', 'CP2', 'CP4', 'CP6', 'Pz'
])
test_cnt, test_cnt.info['events'] = test_cnt.copy().resample(
250, npad='auto', events=test_cnt.info['events'])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(a,
low_cut_hz,
high_cut_hz,
test_cnt.info['sfreq'],
filt_order=3,
axis=1), test_cnt)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(a.T,
factor_new=factor_new,
init_block_size=
init_block_size,
eps=1e-4).T, test_cnt)
marker_def = OrderedDict([('Right Hand', [1]), ('Left Hand', [2])])
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def, ival)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def, ival)
train_set, valid_set = split_into_two_sets(train_set,
first_set_fraction=1 -
valid_set_fraction)
set_random_seeds(seed=20190706, cuda=cuda)
n_classes = 2
n_chans = int(train_set.X.shape[1])
input_time_length = train_set.X.shape[2]
if model == 'shallow':
model = ShallowFBCSPNet(n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length='auto').create_network()
elif model == 'deep':
model = Deep4Net(n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length='auto').create_network()
if cuda:
model.cuda()
log.info("Model: \n{:s}".format(str(model)))
optimizer = optim.Adam(model.parameters())
iterator = BalancedBatchSizeIterator(batch_size=batch_size)
stop_criterion = Or([
MaxEpochs(max_epochs),
NoDecrease('valid_misclass', max_increase_epochs)
])
monitors = [LossMonitor(), MisclassMonitor(), RuntimeMonitor()]
model_constraint = MaxNormDefaultConstraint()
exp = Experiment(model,
train_set,
valid_set,
test_set,
iterator=iterator,
loss_function=F.nll_loss,
optimizer=optimizer,
model_constraint=model_constraint,
monitors=monitors,
stop_criterion=stop_criterion,
remember_best_column='valid_misclass',
run_after_early_stop=True,
cuda=cuda)
exp.run()
return exp
def run_exp(data_folder, subject_id, low_cut_hz, model, cuda):
ival = [-500, 4000]
max_epochs = 1600
max_increase_epochs = 160
batch_size = 60
high_cut_hz = 38
factor_new = 1e-3
init_block_size = 1000
valid_set_fraction = 0.2
train_filename = "A{:02d}T.gdf".format(subject_id)
test_filename = "A{:02d}E.gdf".format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
train_label_filepath = train_filepath.replace(".gdf", ".mat")
test_label_filepath = test_filepath.replace(".gdf", ".mat")
train_loader = BCICompetition4Set2A(
train_filepath, labels_filename=train_label_filepath
)
test_loader = BCICompetition4Set2A(
test_filepath, labels_filename=test_label_filepath
)
train_cnt = train_loader.load()
test_cnt = test_loader.load()
# Preprocessing
train_cnt = train_cnt.drop_channels(
["EOG-left", "EOG-central", "EOG-right"]
)
assert len(train_cnt.ch_names) == 22
# lets convert to millvolt for numerical stability of next operations
train_cnt = mne_apply(lambda a: a * 1e6, train_cnt)
train_cnt = mne_apply(
lambda a: bandpass_cnt(
a,
low_cut_hz,
high_cut_hz,
train_cnt.info["sfreq"],
filt_order=3,
axis=1,
),
train_cnt,
)
train_cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T,
factor_new=factor_new,
init_block_size=init_block_size,
eps=1e-4,
).T,
train_cnt,
)
test_cnt = test_cnt.drop_channels(["EOG-left", "EOG-central", "EOG-right"])
assert len(test_cnt.ch_names) == 22
test_cnt = mne_apply(lambda a: a * 1e6, test_cnt)
test_cnt = mne_apply(
lambda a: bandpass_cnt(
a,
low_cut_hz,
high_cut_hz,
test_cnt.info["sfreq"],
filt_order=3,
axis=1,
),
test_cnt,
)
test_cnt = mne_apply(
lambda a: exponential_running_standardize(
a.T,
factor_new=factor_new,
init_block_size=init_block_size,
eps=1e-4,
).T,
test_cnt,
)
marker_def = OrderedDict(
[
("Left Hand", [1]),
("Right Hand", [2]),
("Foot", [3]),
("Tongue", [4]),
]
)
train_set = create_signal_target_from_raw_mne(train_cnt, marker_def, ival)
test_set = create_signal_target_from_raw_mne(test_cnt, marker_def, ival)
train_set, valid_set = split_into_two_sets(
train_set, first_set_fraction=1 - valid_set_fraction
)
set_random_seeds(seed=20190706, cuda=cuda)
n_classes = 4
n_chans = int(train_set.X.shape[1])
input_time_length = train_set.X.shape[2]
if model == "shallow":
model = ShallowFBCSPNet(
n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length="auto",
).create_network()
elif model == "deep":
model = Deep4Net(
n_chans,
n_classes,
input_time_length=input_time_length,
final_conv_length="auto",
).create_network()
if cuda:
model.cuda()
log.info("Model: \n{:s}".format(str(model)))
optimizer = optim.Adam(model.parameters())
iterator = BalancedBatchSizeIterator(batch_size=batch_size)
stop_criterion = Or(
[
MaxEpochs(max_epochs),
NoDecrease("valid_misclass", max_increase_epochs),
]
)
monitors = [LossMonitor(), MisclassMonitor(), RuntimeMonitor()]
model_constraint = MaxNormDefaultConstraint()
exp = Experiment(
model,
train_set,
valid_set,
test_set,
iterator=iterator,
loss_function=F.nll_loss,
optimizer=optimizer,
model_constraint=model_constraint,
monitors=monitors,
stop_criterion=stop_criterion,
remember_best_column="valid_misclass",
run_after_early_stop=True,
cuda=cuda,
)
exp.run()
return exp
