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 load_train_valid_test(train_filename,
test_filename,
low_cut_hz,
debug=False):
log.info("Loading train...")
full_train_set = load_bbci_data(train_filename,
low_cut_hz=low_cut_hz,
debug=debug)
log.info("Loading test...")
test_set = load_bbci_data(test_filename,
low_cut_hz=low_cut_hz,
debug=debug)
valid_set_fraction = 0.8
train_set, valid_set = split_into_two_sets(full_train_set,
valid_set_fraction)
log.info("Train set with {:4d} trials".format(len(train_set.X)))
if valid_set is not None:
log.info("Valid set with {:4d} trials".format(len(valid_set.X)))
log.info("Test set with {:4d} trials".format(len(test_set.X)))
return train_set, valid_set, test_set
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):
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
#####Combine training data#####
features_v = v_data[vowel_indices[j]]
features = np.concatenate((features_w, features_v)).astype(np.float32)
w_labels = np.zeros(features_w.shape[0])
v_labels = np.ones(features_v.shape[0])
labels = np.concatenate((w_labels, v_labels)).astype(np.int64)
valid_set_fraction = 0.3
X_Train, X_Test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)
y_train = (y_train).astype(np.int64)
train_set = SignalAndTarget(X_Train, y_train)
test_set = SignalAndTarget(X_Test, y_test)
train_set, valid_set = split_into_two_sets(train_set, first_set_fraction=1-valid_set_fraction)
run_model = network_model(model, train_set, test_set, valid_set, n_chans, input_time_length, cuda)
log.info('Last 10 epochs')
log.info("\n" + str(run_model.epochs_df.iloc[-10:]))
vowels_results.append(run_model.epochs_df.iloc[-10:])
#vowels_results = vowels_results.append(pd.DataFrame())
#print(vowels_results)
#run_model.epochs_df.iloc[-10:].to_excel(writer,'sheet%s' %str(j+1))
print(f"Saving classification results for Subject: {sbj}")
vowels_results.to_excel(writer) # saving results for one word vs all 5 vowels
def load_train_valid_test(train_filename,
test_filename,
n_folds,
i_test_fold,
valid_set_fraction,
use_validation_set,
low_cut_hz,
debug=False):
# we loaded all sensors to always get same cleaning results independent of sensor selection
# There is an inbuilt heuristic that tries to use only EEG channels and that definitely
# works for datasets in our paper
if test_filename is None:
assert n_folds is not None
assert i_test_fold is not None
assert valid_set_fraction is None
else:
assert n_folds is None
assert i_test_fold is None
assert use_validation_set == (valid_set_fraction is not None)
train_folder = '/home/schirrmr/data/BBCI-without-last-runs/'
log.info("Loading train...")
full_train_set = load_bbci_data(os.path.join(train_folder, train_filename),
low_cut_hz=low_cut_hz,
debug=debug)
if test_filename is not None:
test_folder = '/home/schirrmr/data/BBCI-only-last-runs/'
log.info("Loading test...")
test_set = load_bbci_data(os.path.join(test_folder, test_filename),
low_cut_hz=low_cut_hz,
debug=debug)
if use_validation_set:
assert valid_set_fraction is not None
train_set, valid_set = split_into_two_sets(full_train_set,
valid_set_fraction)
else:
train_set = full_train_set
valid_set = None
# Split data
if n_folds is not None:
fold_inds = get_balanced_batches(len(full_train_set.X),
None,
shuffle=False,
n_batches=n_folds)
fold_sets = [
select_examples(full_train_set, inds) for inds in fold_inds
]
test_set = fold_sets[i_test_fold]
train_folds = np.arange(n_folds)
train_folds = np.setdiff1d(train_folds, [i_test_fold])
if use_validation_set:
i_valid_fold = (i_test_fold - 1) % n_folds
train_folds = np.setdiff1d(train_folds, [i_valid_fold])
valid_set = fold_sets[i_valid_fold]
assert i_valid_fold not in train_folds
assert i_test_fold != i_valid_fold
else:
valid_set = None
assert i_test_fold not in train_folds
train_fold_sets = [fold_sets[i] for i in train_folds]
train_set = concatenate_sets(train_fold_sets)
# Some checks
if valid_set is None:
assert len(train_set.X) + len(test_set.X) == len(full_train_set.X)
else:
assert len(train_set.X) + len(valid_set.X) + len(
test_set.X) == len(full_train_set.X)
log.info("Train set with {:4d} trials".format(len(train_set.X)))
if valid_set is not None:
log.info("Valid set with {:4d} trials".format(len(valid_set.X)))
log.info("Test set with {:4d} trials".format(len(test_set.X)))
return train_set, valid_set, test_set
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 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
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
def test_experiment_class():
import mne
from mne.io import concatenate_raws
# 5,6,7,10,13,14 are codes for executed and imagined hands/feet
subject_id = 1
event_codes = [5, 6, 9, 10, 13, 14]
# This will download the files if you don't have them yet,
# and then return the paths to the files.
physionet_paths = mne.datasets.eegbci.load_data(subject_id, event_codes)
# Load each of the files
parts = [mne.io.read_raw_edf(path, preload=True, stim_channel='auto',
verbose='WARNING')
for path in physionet_paths]
# Concatenate them
raw = concatenate_raws(parts)
# Find the events in this dataset
events, _ = mne.events_from_annotations(raw)
# Use only EEG channels
eeg_channel_inds = mne.pick_types(raw.info, meg=False, eeg=True, stim=False,
eog=False,
exclude='bads')
# Extract trials, only using EEG channels
epoched = mne.Epochs(raw, events, dict(hands=2, feet=3), tmin=1, tmax=4.1,
proj=False, picks=eeg_channel_inds,
baseline=None, preload=True)
import numpy as np
from braindecode.datautil.signal_target import SignalAndTarget
from braindecode.datautil.splitters import split_into_two_sets
# Convert data from volt to millivolt
# Pytorch expects float32 for input and int64 for labels.
X = (epoched.get_data() * 1e6).astype(np.float32)
y = (epoched.events[:, 2] - 2).astype(np.int64) # 2,3 -> 0,1
train_set = SignalAndTarget(X[:60], y=y[:60])
test_set = SignalAndTarget(X[60:], y=y[60:])
train_set, valid_set = split_into_two_sets(train_set,
first_set_fraction=0.8)
from braindecode.models.shallow_fbcsp import ShallowFBCSPNet
from torch import nn
from braindecode.torch_ext.util import set_random_seeds
from braindecode.models.util import to_dense_prediction_model
# Set if you want to use GPU
# You can also use torch.cuda.is_available() to determine if cuda is available on your machine.
cuda = False
set_random_seeds(seed=20170629, cuda=cuda)
# This will determine how many crops are processed in parallel
input_time_length = 450
n_classes = 2
in_chans = train_set.X.shape[1]
# final_conv_length determines the size of the receptive field of the ConvNet
model = ShallowFBCSPNet(in_chans=in_chans, n_classes=n_classes,
input_time_length=input_time_length,
final_conv_length=12).create_network()
to_dense_prediction_model(model)
if cuda:
model.cuda()
from torch import optim
optimizer = optim.Adam(model.parameters())
from braindecode.torch_ext.util import np_to_var
# determine output size
test_input = np_to_var(
np.ones((2, in_chans, input_time_length, 1), dtype=np.float32))
if cuda:
test_input = test_input.cuda()
out = model(test_input)
n_preds_per_input = out.cpu().data.numpy().shape[2]
print("{:d} predictions per input/trial".format(n_preds_per_input))
from braindecode.experiments.experiment import Experiment
from braindecode.datautil.iterators import CropsFromTrialsIterator
from braindecode.experiments.monitors import RuntimeMonitor, LossMonitor, \
CroppedTrialMisclassMonitor, MisclassMonitor
from braindecode.experiments.stopcriteria import MaxEpochs
import torch.nn.functional as F
import torch as th
from braindecode.torch_ext.modules import Expression
# Iterator is used to iterate over datasets both for training
# and evaluation
iterator = CropsFromTrialsIterator(batch_size=32,
input_time_length=input_time_length,
n_preds_per_input=n_preds_per_input)
# Loss function takes predictions as they come out of the network and the targets
# and returns a loss
loss_function = lambda preds, targets: F.nll_loss(
th.mean(preds, dim=2, keepdim=False), targets)
# Could be used to apply some constraint on the models, then should be object
# with apply method that accepts a module
model_constraint = None
# Monitors log the training progress
monitors = [LossMonitor(), MisclassMonitor(col_suffix='sample_misclass'),
CroppedTrialMisclassMonitor(input_time_length),
RuntimeMonitor(), ]
# Stop criterion determines when the first stop happens
stop_criterion = MaxEpochs(4)
exp = Experiment(model, train_set, valid_set, test_set, iterator,
loss_function, optimizer, model_constraint,
monitors, stop_criterion,
remember_best_column='valid_misclass',
run_after_early_stop=True, batch_modifier=None, cuda=cuda)
# need to setup python logging before to be able to see anything
import logging
import sys
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG, stream=sys.stdout)
exp.run()
import pandas as pd
from io import StringIO
compare_df = pd.read_csv(StringIO(
'train_loss,valid_loss,test_loss,train_sample_misclass,valid_sample_misclass,'
'test_sample_misclass,train_misclass,valid_misclass,test_misclass\n'
'14.167170524597168,13.910758018493652,15.945781707763672,0.5,0.5,'
'0.5333333333333333,0.5,0.5,0.5333333333333333\n'
'1.1735659837722778,1.4342904090881348,1.8664429187774658,0.4629567736185384,'
'0.5120320855614973,0.5336007130124778,0.5,0.5,0.5333333333333333\n'
'1.3168460130691528,1.60431969165802,1.9181344509124756,0.49298128342245995,'
'0.5109180035650625,0.531729055258467,0.5,0.5,0.5333333333333333\n'
'0.8465543389320374,1.280307412147522,1.439755916595459,0.4413435828877005,'
'0.5461229946524064,0.5283422459893048,0.47916666666666663,0.5,'
'0.5333333333333333\n0.6977059841156006,1.1762590408325195,1.2779350280761719,'
'0.40290775401069523,0.588903743315508,0.5307486631016043,0.5,0.5,0.5\n'
'0.7934166193008423,1.1762590408325195,1.2779350280761719,0.4401069518716577,'
'0.588903743315508,0.5307486631016043,0.5,0.5,0.5\n0.5982189178466797,'
'0.8581563830375671,0.9598925113677979,0.32032085561497325,0.47660427807486627,'
'0.4672905525846702,0.31666666666666665,0.5,0.4666666666666667\n0.5044312477111816,'
'0.7133197784423828,0.8164243102073669,0.2591354723707665,0.45699643493761144,'
'0.4393048128342246,0.16666666666666663,0.41666666666666663,0.43333333333333335\n'
'0.4815250039100647,0.6736412644386292,0.8016976714134216,0.23413547237076648,'
'0.39505347593582885,0.42932263814616756,0.15000000000000002,0.41666666666666663,0.5\n'))
for col in compare_df:
np.testing.assert_allclose(np.array(compare_df[col]),
exp.epochs_df[col],
rtol=1e-3, atol=1e-4)
def test_experiment_class():
import mne
from mne.io import concatenate_raws
# 5,6,7,10,13,14 are codes for executed and imagined hands/feet
subject_id = 1
event_codes = [5, 6, 9, 10, 13, 14]
# This will download the files if you don't have them yet,
# and then return the paths to the files.
physionet_paths = mne.datasets.eegbci.load_data(subject_id, event_codes)
# Load each of the files
parts = [
mne.io.read_raw_edf(path,
preload=True,
stim_channel='auto',
verbose='WARNING') for path in physionet_paths
]
# Concatenate them
raw = concatenate_raws(parts)
# Find the events in this dataset
events = mne.find_events(raw, shortest_event=0, stim_channel='STI 014')
# Use only EEG channels
eeg_channel_inds = mne.pick_types(raw.info,
meg=False,
eeg=True,
stim=False,
eog=False,
exclude='bads')
# Extract trials, only using EEG channels
epoched = mne.Epochs(raw,
events,
dict(hands=2, feet=3),
tmin=1,
tmax=4.1,
proj=False,
picks=eeg_channel_inds,
baseline=None,
preload=True)
import numpy as np
from braindecode.datautil.signal_target import SignalAndTarget
from braindecode.datautil.splitters import split_into_two_sets
# Convert data from volt to millivolt
# Pytorch expects float32 for input and int64 for labels.
X = (epoched.get_data() * 1e6).astype(np.float32)
y = (epoched.events[:, 2] - 2).astype(np.int64) # 2,3 -> 0,1
train_set = SignalAndTarget(X[:60], y=y[:60])
test_set = SignalAndTarget(X[60:], y=y[60:])
train_set, valid_set = split_into_two_sets(train_set,
first_set_fraction=0.8)
from braindecode.models.shallow_fbcsp import ShallowFBCSPNet
from torch import nn
from braindecode.torch_ext.util import set_random_seeds
from braindecode.models.util import to_dense_prediction_model
# Set if you want to use GPU
# You can also use torch.cuda.is_available() to determine if cuda is available on your machine.
cuda = False
set_random_seeds(seed=20170629, cuda=cuda)
# This will determine how many crops are processed in parallel
input_time_length = 450
n_classes = 2
in_chans = train_set.X.shape[1]
# final_conv_length determines the size of the receptive field of the ConvNet
model = ShallowFBCSPNet(in_chans=in_chans,
n_classes=n_classes,
input_time_length=input_time_length,
final_conv_length=12).create_network()
to_dense_prediction_model(model)
if cuda:
model.cuda()
from torch import optim
optimizer = optim.Adam(model.parameters())
from braindecode.torch_ext.util import np_to_var
# determine output size
test_input = np_to_var(
np.ones((2, in_chans, input_time_length, 1), dtype=np.float32))
if cuda:
test_input = test_input.cuda()
out = model(test_input)
n_preds_per_input = out.cpu().data.numpy().shape[2]
print("{:d} predictions per input/trial".format(n_preds_per_input))
from braindecode.experiments.experiment import Experiment
from braindecode.datautil.iterators import CropsFromTrialsIterator
from braindecode.experiments.monitors import RuntimeMonitor, LossMonitor, \
CroppedTrialMisclassMonitor, MisclassMonitor
from braindecode.experiments.stopcriteria import MaxEpochs
import torch.nn.functional as F
import torch as th
from braindecode.torch_ext.modules import Expression
# Iterator is used to iterate over datasets both for training
# and evaluation
iterator = CropsFromTrialsIterator(batch_size=32,
input_time_length=input_time_length,
n_preds_per_input=n_preds_per_input)
# Loss function takes predictions as they come out of the network and the targets
# and returns a loss
loss_function = lambda preds, targets: F.nll_loss(
th.mean(preds, dim=2, keepdim=False), targets)
# Could be used to apply some constraint on the models, then should be object
# with apply method that accepts a module
model_constraint = None
# Monitors log the training progress
monitors = [
LossMonitor(),
MisclassMonitor(col_suffix='sample_misclass'),
CroppedTrialMisclassMonitor(input_time_length),
RuntimeMonitor(),
]
# Stop criterion determines when the first stop happens
stop_criterion = MaxEpochs(4)
exp = Experiment(model,
train_set,
valid_set,
test_set,
iterator,
loss_function,
optimizer,
model_constraint,
monitors,
stop_criterion,
remember_best_column='valid_misclass',
run_after_early_stop=True,
batch_modifier=None,
cuda=cuda)
# need to setup python logging before to be able to see anything
import logging
import sys
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
exp.run()
import pandas as pd
from io import StringIO
compare_df = pd.read_csv(
StringIO(
u'train_loss,valid_loss,test_loss,train_sample_misclass,valid_sample_misclass,'
'test_sample_misclass,train_misclass,valid_misclass,test_misclass\n'
'0,0.8692976435025532,0.7483791708946228,0.6975634694099426,'
'0.5389371657754011,0.47103386809269165,0.4425133689839572,'
'0.6041666666666667,0.5,0.4\n1,2.3362590074539185,'
'2.317707061767578,2.1407743096351624,0.4827874331550802,'
'0.5,0.4666666666666667,0.5,0.5,0.4666666666666667\n'
'2,0.5981490015983582,0.785034716129303,0.7005959153175354,'
'0.3391822638146168,0.47994652406417115,0.41996434937611404,'
'0.22916666666666663,0.41666666666666663,0.43333333333333335\n'
'3,0.6355261653661728,0.785034716129303,'
'0.7005959153175354,0.3673351158645276,0.47994652406417115,'
'0.41996434937611404,0.2666666666666667,0.41666666666666663,'
'0.43333333333333335\n4,0.625280424952507,'
'0.802731990814209,0.7048938572406769,0.3367201426024955,'
'0.43137254901960786,0.4229946524064171,0.3666666666666667,'
'0.5833333333333333,0.33333333333333337\n'))
for col in compare_df:
np.testing.assert_allclose(np.array(compare_df[col]),
exp.epochs_df[col],
rtol=1e-4,
atol=1e-5)
from braindecode.datautil.signal_target import SignalAndTarget
from braindecode.datautil.splitters import split_into_two_sets
from patient import all_X, all_y
#Split the X and Y into training and testing sets
dummy_X = all_X
dummy_y = all_y
whole_set = SignalAndTarget(dummy_X,
dummy_y) #Just an object which includes X and Y
train_set, test_set = split_into_two_sets(whole_set, 0.5)
train_set, valid_set = split_into_two_sets(train_set, 0.7)
# print(train_set)
