def run(ex, max_recording_mins, n_recordings, sec_to_cut,
duration_recording_mins, max_abs_val, shrink_val, sampling_freq,
divisor, n_folds, i_test_fold, model_constraint, batch_size,
max_epochs, final_conv_length, n_filters_time, n_filters_spat,
filter_time_length, conv_nonlin, pool_time_length, pool_time_stride,
pool_mode, pool_nonlin, split_first_layer, do_batch_norm, drop_prob,
input_time_length, time_cut_off_sec, start_time, only_return_exp):
i_test_fold = int(i_test_fold)
kwargs = locals()
kwargs.pop('ex')
import sys
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
ex.info['finished'] = False
exp = run_exp(**kwargs)
# in case of too large model
if exp is None:
ex.score = 1
return ex
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
if not only_return_exp:
last_row = exp.epochs_df.iloc[-1]
for key, val in last_row.iteritems():
ex.info[key] = float(val)
ex.info['runtime'] = run_time
if not only_return_exp:
save_pkl_artifact(ex, exp.epochs_df, 'epochs_df.pkl')
save_pkl_artifact(ex, exp.before_stop_df, 'before_stop_df.pkl')
ex.score = float(exp.epochs_df.iloc[-1]['test_misclass'])
return ex
def run(ex, max_recording_mins, n_recordings, sec_to_cut,
duration_recording_mins, max_abs_val, max_min_threshold,
max_min_expected, shrink_val, max_min_remove, batch_set_zero_val,
batch_set_zero_test, sampling_freq, low_cut_hz, high_cut_hz,
exp_demean, exp_standardize, moving_demean, moving_standardize,
channel_demean, channel_standardize, divisor, n_folds, i_test_fold,
input_time_length, final_conv_length, pool_stride, n_blocks_to_add,
sigmoid, model_constraint, batch_size, max_epochs, only_return_exp):
kwargs = locals()
kwargs.pop('ex')
import sys
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
start_time = time.time()
ex.info['finished'] = False
exp = run_exp(**kwargs)
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
if not only_return_exp:
last_row = exp.epochs_df.iloc[-1]
for key, val in last_row.iteritems():
ex.info[key] = float(val)
ex.info['runtime'] = run_time
if not only_return_exp:
save_pkl_artifact(ex, exp.epochs_df, 'epochs_df.pkl')
save_pkl_artifact(ex, exp.before_stop_df, 'before_stop_df.pkl')
save_torch_artifact(ex, exp.model.state_dict(), 'model_params.pkl')
def run(ex, train_filename, test_filename, n_folds, i_test_fold,
valid_set_fraction, use_validation_set, low_cut_hz, model_name,
optimizer_name, init_lr, scheduler_name, use_norm_constraint, restarts,
weight_decay, schedule_weight_decay, max_epochs, max_increase_epochs,
np_th_seed, debug):
kwargs = locals()
kwargs.pop('ex')
import sys
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
start_time = time.time()
ex.info['finished'] = False
# check that gpu is available -> should lead to crash if gpu not there
confirm_gpu_availability()
exp = run_4_sec_exp(**kwargs)
end_time = time.time()
last_row = exp.epochs_df.iloc[-1]
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
for key, val in last_row.iteritems():
ex.info[key] = float(val)
ex.info['runtime'] = run_time
save_pkl_artifact(ex, exp.epochs_df, 'epochs_df.pkl')
save_pkl_artifact(ex, exp.before_stop_df, 'before_stop_df.pkl')
def run(
ex,
debug,
subject_id,
constant_memory,
data_zero_init,
max_epochs,
set_distribution_to_empirical,
ot_on_class_dims,
independent_class_dists,
half_before,
n_sensors,
final_hz,
start_ms,
stop_ms,
model_name,
final_fft,
clf_loss,
save_model,
only_return_exp,
):
kwargs = locals()
kwargs.pop("ex")
kwargs.pop("only_return_exp")
kwargs.pop("save_model")
th.backends.cudnn.benchmark = True
import sys
logging.basicConfig(
format="%(asctime)s %(levelname)s : %(message)s",
level=logging.DEBUG,
stream=sys.stdout,
)
start_time = time.time()
ex.info["finished"] = False
confirm_gpu_availability()
epochs_df, feature_model, class_dist = run_exp(**kwargs)
end_time = time.time()
run_time = end_time - start_time
ex.info["finished"] = True
last_row = epochs_df.iloc[-1]
for key, val in last_row.iteritems():
ex.info[key] = float(val)
ex.info["runtime"] = run_time
save_pkl_artifact(ex, epochs_df, "epochs_df.pkl")
if save_model:
save_torch_artifact(ex, feature_model, "feature_model.pkl")
save_torch_artifact(ex, class_dist, "class_dist.pkl")
print("Finished!")
def run(
ex,
debug,
subject_id,
max_epochs,
n_sensors,
final_hz,
half_before,
start_ms,
stop_ms,
model,
save_model,
weight_decay,
only_return_exp,
final_fft,
add_bnorm,
act_norm,
):
kwargs = locals()
kwargs.pop("ex")
kwargs.pop("only_return_exp")
kwargs.pop("save_model")
th.backends.cudnn.benchmark = True
import sys
logging.basicConfig(
format="%(asctime)s %(levelname)s : %(message)s",
level=logging.DEBUG,
stream=sys.stdout,
)
start_time = time.time()
ex.info["finished"] = False
confirm_gpu_availability()
epochs_df, model = run_exp(**kwargs)
end_time = time.time()
run_time = end_time - start_time
ex.info["finished"] = True
last_row = epochs_df.iloc[-1]
for key, val in last_row.iteritems():
ex.info[key] = float(val)
ex.info["runtime"] = run_time
save_pkl_artifact(ex, epochs_df, "epochs_df.pkl")
if save_model:
save_torch_artifact(ex, model, "model.pkl")
print("Finished!")
def run(ex, filename, min_freq, max_freq, low_width, high_width, high_overlap,
last_low_freq, low_overlap, n_top_bottom_csp_filters,
n_selected_features, sensors):
import sys
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
start_time = time.time()
ex.info['finished'] = False
csp_experiment = run_exp(filename, min_freq, max_freq, low_width,
high_width, high_overlap, last_low_freq,
low_overlap, n_top_bottom_csp_filters,
n_selected_features, sensors)
end_time = time.time()
run_time = end_time - start_time
ex.info['train_misclass'] = 1 - np.mean(
csp_experiment.multi_class.train_accuracy)
ex.info['test_misclass'] = 1 - np.mean(
csp_experiment.multi_class.test_accuracy)
ex.info['runtime'] = run_time
ex.info['finished'] = True
results = dict()
results['binary_train_acc'] = csp_experiment.binary_csp.train_accuracy
results['binary_test_acc'] = csp_experiment.binary_csp.test_accuracy
results[
'filterbank_train_acc'] = csp_experiment.filterbank_csp.train_accuracy
results[
'filterbank_test_acc'] = csp_experiment.filterbank_csp.test_accuracy
results['multi_train_acc'] = csp_experiment.multi_class.train_accuracy
results['multi_test_acc'] = csp_experiment.multi_class.test_accuracy
results[
'train_pred_labels'] = csp_experiment.multi_class.train_predicted_labels
results['train_labels'] = csp_experiment.multi_class.train_labels
results[
'test_pred_labels'] = csp_experiment.multi_class.test_predicted_labels
results['test_labels'] = csp_experiment.multi_class.test_labels
save_pkl_artifact(ex, results, 'results.pkl')
def run(
ex,
max_epochs,
only_return_exp,
):
start_time = time.time()
ex.info['finished'] = False
exp = run_exp(max_epochs, only_return_exp)
if not only_return_exp:
last_row = exp.epochs_df.iloc[-1]
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
for key, val in last_row.iteritems():
ex.info[key] = float(val)
ex.info['runtime'] = run_time
save_torch_artifact(ex, exp.model.state_dict(), 'model_params.pkl')
save_torch_artifact(ex, exp.model, 'model.pkl')
save_torch_artifact(ex, exp.optimizer.state_dict(),
'trainer_params.pkl')
save_pkl_artifact(ex, exp.epochs_df, 'epochs_df.pkl')
save_pkl_artifact(ex, exp.before_stop_df, 'before_stop_df.pkl')
def run(ex, subject_id, with_breaks, min_freq, only_return_exp):
start_time = time.time()
ex.info['finished'] = False
window_len = 2000
window_stride = 500
marker_def = {
'1- Right Hand': [1],
'2 - Feet': [4],
'3 - Rotation': [8],
'4 - Words': [10]
}
segment_ival = [0, window_len]
n_selected_features = 20 # 20
all_start_marker_vals = [1, 4, 8, 10]
all_end_marker_vals, train_folders, test_folders = get_subject_config(
subject_id)
if with_breaks:
min_break_length_ms = 6000
max_break_length_ms = 8000
break_start_offset_ms = 1000
break_stop_offset_ms = -500
break_start_marker = 300
break_end_marker = 301
all_start_marker_vals.append(break_start_marker)
all_end_marker_vals.append(break_end_marker)
marker_def['5 - Break'] = [break_start_marker]
train_files_list = [
sorted(glob(os.path.join(folder, '*.BBCI.mat')))
for folder in train_folders
]
train_files = list(itertools.chain(*train_files_list))
test_files_list = [
sorted(glob(os.path.join(folder, '*.BBCI.mat')))
for folder in test_folders
]
test_files = list(itertools.chain(*test_files_list))
train_set = MultipleBBCIDataset(train_files)
test_set = MultipleBBCIDataset(test_files)
csp_exp = TwoFileCSPExperiment(train_set,
test_set,
NoCleaner(marker_def=marker_def,
segment_ival=segment_ival),
NoCleaner(marker_def=marker_def,
segment_ival=segment_ival),
resample_fs=250,
standardize_cnt=False,
min_freq=min_freq,
max_freq=34,
last_low_freq=10,
low_width=6,
low_overlap=3,
high_overlap=4,
high_width=8,
filt_order=3,
standardize_filt_cnt=False,
segment_ival=[0, 2000],
standardize_epo=False,
n_folds=None,
n_top_bottom_csp_filters=5,
n_selected_filterbands=None,
forward_steps=2,
backward_steps=1,
stop_when_no_improvement=False,
n_selected_features=n_selected_features,
only_last_fold=True,
restricted_n_trials=None,
common_average_reference=False,
ival_optimizer=None,
shuffle=False,
marker_def=marker_def,
set_cz_to_zero=False,
low_bound=0.)
if only_return_exp:
return csp_exp
log.info("Loading train set...")
csp_exp.load_bbci_set()
log.info("Loading test set...")
csp_exp.load_bbci_test_set()
csp_exp.cnt = select_channels(csp_exp.cnt, ['Cz'], invert=True)
assert len(csp_exp.cnt.axes[1]) == 63
csp_exp.test_cnt = select_channels(csp_exp.test_cnt, ['Cz'], invert=True)
assert len(csp_exp.test_cnt.axes[1]) == 63
if with_breaks:
add_break_start_stop_markers(csp_exp.cnt, all_start_marker_vals,
all_end_marker_vals, min_break_length_ms,
max_break_length_ms,
break_start_offset_ms,
break_stop_offset_ms, break_start_marker,
break_end_marker)
set_windowed_markers(
csp_exp.cnt,
all_start_marker_vals,
all_end_marker_vals,
window_len,
window_stride,
)
if with_breaks:
add_break_start_stop_markers(csp_exp.test_cnt, all_start_marker_vals,
all_end_marker_vals, min_break_length_ms,
max_break_length_ms,
break_start_offset_ms,
break_stop_offset_ms, break_start_marker,
break_end_marker)
set_windowed_markers(
csp_exp.test_cnt,
all_start_marker_vals,
all_end_marker_vals,
window_len,
window_stride,
)
log.info("Cleaning both sets...")
csp_exp.clean_both_sets()
log.info("Preprocessing train set...")
csp_exp.preprocess_set()
log.info("Preprocessing test set...")
csp_exp.preprocess_test_set()
csp_exp.remember_sensor_names()
csp_exp.init_training_vars()
log.info("Running Training...")
csp_exp.run_training()
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
result = CSPResult(csp_trainer=csp_exp,
parameters={},
training_time=run_time)
assert len(csp_exp.multi_class.test_accuracy) == 1
assert len(csp_exp.multi_class.train_accuracy) == 1
ex.info['train_misclass'] = 1 - csp_exp.multi_class.train_accuracy[0]
ex.info['test_misclass'] = 1 - csp_exp.multi_class.test_accuracy[0]
ex.info['runtime'] = run_time
save_pkl_artifact(ex, result, 'csp_result.pkl')
def run(
ex,
data_folder,
subject_id,
n_chans,
only_return_exp,
):
start_time = time.time()
assert (only_return_exp is False) or (n_chans is not None)
ex.info['finished'] = False
load_sensor_names = None
train_filename = 'A{:02d}T.mat'.format(subject_id)
test_filename = 'A{:02d}E.mat'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
# trial ivan in milliseconds
# these are the samples that will be predicted, so for a
# network with 2000ms receptive field
# 1500 means the first receptive field goes from -500 to 1500
segment_ival = [1500, 4000]
train_loader = BCICompetition4Set2A(train_filepath,
load_sensor_names=load_sensor_names)
test_loader = BCICompetition4Set2A(test_filepath,
load_sensor_names=load_sensor_names)
# Preprocessing pipeline in [(function, {args:values)] logic
cnt_preprocessors = [(resample_cnt, {
'newfs': 250.0
}), (bandpass_cnt, {
'low_cut_hz': 0,
'high_cut_hz': 38,
}), (exponential_standardize_cnt, {})]
marker_def = {
'1- Right Hand': [1],
'2 - Left Hand': [2],
'3 - Rest': [3],
'4 - Feet': [4]
}
train_signal_proc = SignalProcessor(set_loader=train_loader,
segment_ival=segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
train_set = CntSignalMatrix(signal_processor=train_signal_proc,
sensor_names='all')
test_signal_proc = SignalProcessor(set_loader=test_loader,
segment_ival=segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
test_set = CntSignalMatrix(signal_processor=test_signal_proc,
sensor_names='all')
from braindecode.mywyrm.clean import MaxAbsCleaner
train_cleaner = MaxAbsCleaner(segment_ival=[0, 4000],
threshold=800,
marker_def=marker_def)
test_cleaner = MaxAbsCleaner(segment_ival=[0, 4000],
threshold=800,
marker_def=marker_def)
combined_set = CombinedCleanedSet(train_set, test_set, train_cleaner,
test_cleaner)
if not only_return_exp:
combined_set.load()
in_chans = train_set.get_topological_view().shape[1]
input_time_length = 1000 # implies how many crops are processed in parallel, does _not_ determine receptive field size
# receptive field size is determined by model architecture
num_filters_time = 25
filter_time_length = 10
num_filters_spat = 25
pool_time_length = 3
pool_time_stride = 3
num_filters_2 = 50
filter_length_2 = 10
num_filters_3 = 100
filter_length_3 = 10
num_filters_4 = 200
filter_length_4 = 10
final_dense_length = 2
n_classes = 4
final_nonlin = softmax
first_nonlin = elu
first_pool_mode = 'max'
first_pool_nonlin = identity
later_nonlin = elu
later_pool_mode = 'max'
later_pool_nonlin = identity
drop_in_prob = 0.0
drop_prob = 0.5
batch_norm_alpha = 0.1
double_time_convs = False
split_first_layer = True
batch_norm = True
# ensure reproducibility by resetting lasagne/theano random generator
lasagne.random.set_rng(RandomState(34734))
d5net = Deep5Net(in_chans=in_chans,
input_time_length=input_time_length,
num_filters_time=num_filters_time,
filter_time_length=filter_time_length,
num_filters_spat=num_filters_spat,
pool_time_length=pool_time_length,
pool_time_stride=pool_time_stride,
num_filters_2=num_filters_2,
filter_length_2=filter_length_2,
num_filters_3=num_filters_3,
filter_length_3=filter_length_3,
num_filters_4=num_filters_4,
filter_length_4=filter_length_4,
final_dense_length=final_dense_length,
n_classes=n_classes,
final_nonlin=final_nonlin,
first_nonlin=first_nonlin,
first_pool_mode=first_pool_mode,
first_pool_nonlin=first_pool_nonlin,
later_nonlin=later_nonlin,
later_pool_mode=later_pool_mode,
later_pool_nonlin=later_pool_nonlin,
drop_in_prob=drop_in_prob,
drop_prob=drop_prob,
batch_norm_alpha=batch_norm_alpha,
double_time_convs=double_time_convs,
split_first_layer=split_first_layer,
batch_norm=batch_norm)
final_layer = d5net.get_layers()[-1]
print_layers(final_layer)
dataset_splitter = SeveralSetsSplitter(valid_set_fraction=0.2,
use_test_as_valid=False)
iterator = CntWindowTrialIterator(
batch_size=45,
input_time_length=input_time_length,
n_sample_preds=get_n_sample_preds(final_layer))
monitors = [
LossMonitor(),
CntTrialMisclassMonitor(input_time_length=input_time_length),
RuntimeMonitor()
]
#debug: n_no_decrease_max_epochs = 2
#debug: n_max_epochs = 4
n_no_decrease_max_epochs = 80
n_max_epochs = 800 #100
# real values for paper were 80 and 800
stop_criterion = Or([
NoDecrease('valid_misclass', num_epochs=n_no_decrease_max_epochs),
MaxEpochs(num_epochs=n_max_epochs)
])
dataset = combined_set
splitter = dataset_splitter
loss_expression = categorical_crossentropy
updates_expression = adam
updates_modifier = MaxNormConstraintWithDefaults({})
remember_best_chan = 'valid_misclass'
run_after_early_stop = True
exp = Experiment(final_layer,
dataset,
splitter,
None,
iterator,
loss_expression,
updates_expression,
updates_modifier,
monitors,
stop_criterion,
remember_best_chan,
run_after_early_stop,
batch_modifier=None)
if only_return_exp:
return exp
exp.setup()
exp.run()
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
ex.info['runtime'] = run_time
for key in exp.monitor_chans:
ex.info[key] = exp.monitor_chans[key][-1]
save_pkl_artifact(ex, exp.monitor_chans, 'monitor_chans.pkl')
def run(ex, data_folder, subject_id, n_chans, train_inds, test_inds,
sets_like_fbcsp_paper, clean_train, stop_chan, filt_order, low_cut_hz,
loss_expression, network, only_return_exp, run_after_early_stop):
start_time = time.time()
assert (only_return_exp is False) or (n_chans is not None)
ex.info['finished'] = False
# trial ival in milliseconds
# these are the samples that will be predicted, so for a
# network with 2000ms receptive field
# 1500 means the first receptive field goes from -500 to 1500
train_segment_ival = [1500, 4000]
test_segment_ival = [0, 4000]
if sets_like_fbcsp_paper:
if subject_id in [4, 5, 6, 7, 8, 9]:
train_inds = [3]
elif subject_id == 1:
train_inds = [1, 3]
else:
assert subject_id in [2, 3]
train_inds = [1, 2, 3]
train_loader = MultipleBCICompetition4Set2B(subject_id,
session_ids=train_inds,
data_folder=data_folder)
test_loader = MultipleBCICompetition4Set2B(subject_id,
session_ids=test_inds,
data_folder=data_folder)
# Preprocessing pipeline in [(function, {args:values)] logic
cnt_preprocessors = [(resample_cnt, {
'newfs': 250.0
}),
(bandpass_cnt, {
'low_cut_hz': low_cut_hz,
'high_cut_hz': 38,
'filt_order': filt_order,
}), (exponential_standardize_cnt, {})]
marker_def = {'1- Left Hand': [1], '2 - Right Hand': [2]}
train_signal_proc = SignalProcessor(set_loader=train_loader,
segment_ival=train_segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
train_set = CntSignalMatrix(signal_processor=train_signal_proc,
sensor_names='all')
test_signal_proc = SignalProcessor(set_loader=test_loader,
segment_ival=test_segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
test_set = CntSignalMatrix(signal_processor=test_signal_proc,
sensor_names='all')
if clean_train:
train_cleaner = BCICompetitionIV2ABArtefactMaskCleaner(
marker_def=marker_def)
else:
train_cleaner = NoCleaner()
test_cleaner = BCICompetitionIV2ABArtefactMaskCleaner(
marker_def=marker_def)
combined_set = CombinedCleanedSet(train_set, test_set, train_cleaner,
test_cleaner)
if not only_return_exp:
combined_set.load()
lasagne.random.set_rng(RandomState(34734))
in_chans = train_set.get_topological_view().shape[1]
input_time_length = 1000 # implies how many crops are processed in parallel, does _not_ determine receptive field size
# receptive field size is determined by model architecture
if network == 'deep':
final_layer = create_deep_net(in_chans, input_time_length)
else:
assert network == 'shallow'
final_layer = create_shallow_net(in_chans, input_time_length)
dataset_splitter = SeveralSetsSplitter(valid_set_fraction=0.2,
use_test_as_valid=False)
iterator = CntWindowTrialIterator(
batch_size=45,
input_time_length=input_time_length,
n_sample_preds=get_n_sample_preds(final_layer))
monitors = [
LossMonitor(),
CntTrialMisclassMonitor(input_time_length=input_time_length),
KappaMonitor(input_time_length=iterator.input_time_length, mode='max'),
RuntimeMonitor()
]
#debug: n_no_decrease_max_epochs = 2
#debug: n_max_epochs = 4
n_no_decrease_max_epochs = 80
n_max_epochs = 800 #100
# real values for paper were 80 and 800
remember_best_chan = 'valid_' + stop_chan
stop_criterion = Or([
NoDecrease(remember_best_chan, num_epochs=n_no_decrease_max_epochs),
MaxEpochs(num_epochs=n_max_epochs)
])
dataset = combined_set
splitter = dataset_splitter
updates_expression = adam
updates_modifier = MaxNormConstraintWithDefaults({})
exp = Experiment(final_layer,
dataset,
splitter,
None,
iterator,
loss_expression,
updates_expression,
updates_modifier,
monitors,
stop_criterion,
remember_best_chan,
run_after_early_stop,
batch_modifier=None)
if only_return_exp:
return exp
exp.setup()
exp.run()
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
for key in exp.monitor_chans:
ex.info[key] = exp.monitor_chans[key][-1]
ex.info['runtime'] = run_time
save_pkl_artifact(ex, exp.monitor_chans, 'monitor_chans.pkl')
def run(ex, test_on_eval, sensor_types, n_chans, max_recording_mins,
n_recordings, sec_to_cut_at_start, sec_to_cut_at_end,
duration_recording_mins, test_recording_mins, max_abs_val,
clip_before_resample, sampling_freq, divisor, n_folds, i_test_fold,
shuffle, merge_train_valid, model_name, input_time_length,
final_conv_length, stride_before_pool, n_start_chans, n_chan_factor,
optimizer, learning_rate, weight_decay, scheduler, model_constraint,
batch_size, max_epochs, save_predictions, save_crop_predictions,
np_th_seed, only_return_exp):
log_dir = ex.observers[0].dir
kwargs = locals()
kwargs.pop('ex')
kwargs.pop('save_predictions')
kwargs.pop('save_crop_predictions')
import sys
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
start_time = time.time()
ex.info['finished'] = False
confirm_gpu_availability()
exp = run_exp(**kwargs)
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
if not only_return_exp:
last_row = exp.epochs_df.iloc[-1]
for key, val in last_row.iteritems():
ex.info[key] = float(val)
ex.info['runtime'] = run_time
if not only_return_exp:
save_pkl_artifact(ex, exp.epochs_df, 'epochs_df.pkl')
save_pkl_artifact(ex, exp.before_stop_df, 'before_stop_df.pkl')
save_torch_artifact(ex, exp.model.state_dict(), 'model_params.pkl')
if save_predictions:
exp.model.eval()
for setname in ('train', 'valid', 'test'):
log.info(
"Compute and save predictions for {:s}...".format(setname))
dataset = exp.datasets[setname]
log.info("Save labels for {:s}...".format(setname))
save_npy_artifact(ex, dataset.y,
'{:s}_trial_labels.npy'.format(setname))
preds_per_batch = [
var_to_np(exp.model(np_to_var(b[0]).cuda()))
for b in exp.iterator.get_batches(dataset, shuffle=False)
]
preds_per_trial = compute_preds_per_trial(
preds_per_batch,
dataset,
input_time_length=exp.iterator.input_time_length,
n_stride=exp.iterator.n_preds_per_input)
mean_preds_per_trial = [
np.mean(preds, axis=(0, 2)) for preds in preds_per_trial
]
mean_preds_per_trial = np.array(mean_preds_per_trial)
log.info("Save trial predictions for {:s}...".format(setname))
save_npy_artifact(ex, mean_preds_per_trial,
'{:s}_trial_preds.npy'.format(setname))
if save_crop_predictions:
log.info(
"Save crop predictions for {:s}...".format(setname))
save_npy_artifact(ex, preds_per_trial,
'{:s}_crop_preds.npy'.format(setname))
else:
return exp
def run(ex, data_folder, subject_id, n_chans, clean_train,
low_cut_hz, train_start_ms,kappa_mode, loss_expression,
network,
filt_order,
only_return_exp,):
start_time = time.time()
assert (only_return_exp is False) or (n_chans is not None)
ex.info['finished'] = False
valid_subject_id = subject_
other_subject_ids = range(1,subject_id) + range(subject_id+1, 10)
other_sets = [create_dataset(
data_folder, other_sid, train_start_ms, low_cut_hz,
filt_order, clean_train) for other_sid in other_subject_ids]
test_set = create_dataset(
data_folder, subject_id, train_start_ms, low_cut_hz,
filt_order, clean_train)
combined_set = other_sets + [test_set]
def merge_train_test(single_combined_set):
return concatenate_sets(single_combined_set.train_set,
single_combined_set.test_set)
if not only_return_exp:
for i_set, this_set in enumerate(combined_set):
log.info("Loading {:d} of {:d}".format(i_set + 1,
len(combined_set)))
this_set.load()
merged_sets = [merge_train_test(s) for s in combined_set]
combined_set = CombinedSet(merged_sets)
in_chans = merged_sets[0].get_topological_view().shape[1]
else:
in_chans = n_chans
input_time_length = 1000 # implies how many crops are processed in parallel, does _not_ determine receptive field size
# receptive field size is determined by model architecture
# ensure reproducibility by resetting lasagne/theano random generator
lasagne.random.set_rng(RandomState(34734))
if network == 'deep':
final_layer = create_deep_net(in_chans, input_time_length)
else:
assert network == 'shallow'
final_layer = create_shallow_net(in_chans, input_time_length)
print_layers(final_layer)
dataset_splitter = SeveralSetsSplitter(valid_set_fraction=0.1, use_test_as_valid=False)
iterator = CntWindowTrialIterator(batch_size=45,input_time_length=input_time_length,
n_sample_preds=get_n_sample_preds(final_layer))
monitors = [LossMonitor(),
CntTrialMisclassMonitor(input_time_length=input_time_length),
KappaMonitor(input_time_length=iterator.input_time_length, mode=kappa_mode),
RuntimeMonitor(),]
#debug: n_no_decrease_max_epochs = 2
#debug: n_max_epochs = 4
n_no_decrease_max_epochs = 80
n_max_epochs = 800#100
# real values for paper were 80 and 800
stop_criterion = Or([NoDecrease('valid_misclass', num_epochs=n_no_decrease_max_epochs),
MaxEpochs(num_epochs=n_max_epochs)])
dataset = combined_set
splitter = dataset_splitter
updates_expression = adam
updates_modifier = MaxNormConstraintWithDefaults({})
remember_best_chan = 'valid_misclass'
run_after_early_stop=True
exp = Experiment(final_layer, dataset,splitter,None,iterator, loss_expression,updates_expression, updates_modifier, monitors,
stop_criterion, remember_best_chan, run_after_early_stop, batch_modifier=None)
if only_return_exp:
return exp
exp.setup()
exp.run()
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
for key in exp.monitor_chans:
ex.info[key] = exp.monitor_chans[key][-1]
ex.info['runtime'] = run_time
save_pkl_artifact(ex, exp.monitor_chans, 'monitor_chans.pkl')
save_npy_artifact(ex, lasagne.layers.get_all_param_values(exp.final_layer),
'model_params.npy')
def run(
ex,
data_folder,
subject_id,
n_chans,
clean_train,
low_cut_hz,
train_start_ms,
kappa_mode,
loss_expression,
filt_order,
only_return_exp,
):
start_time = time.time()
assert (only_return_exp is False) or (n_chans is not None)
ex.info['finished'] = False
load_sensor_names = None
train_filename = 'A{:02d}T.mat'.format(subject_id)
test_filename = 'A{:02d}E.mat'.format(subject_id)
train_filepath = os.path.join(data_folder, train_filename)
test_filepath = os.path.join(data_folder, test_filename)
# trial ivan in milliseconds
# these are the samples that will be predicted, so for a
# network with 2000ms receptive field
# 1500 means the first receptive field goes from -500 to 1500
train_segment_ival = [train_start_ms, 4000]
test_segment_ival = [0, 4000]
train_loader = BCICompetition4Set2A(train_filepath,
load_sensor_names=load_sensor_names)
test_loader = BCICompetition4Set2A(test_filepath,
load_sensor_names=load_sensor_names)
# Preprocessing pipeline in [(function, {args:values)] logic
cnt_preprocessors = [(resample_cnt, {
'newfs': 250.0
}),
(bandpass_cnt, {
'low_cut_hz': low_cut_hz,
'high_cut_hz': 38,
'filt_order': filt_order,
}), (exponential_standardize_cnt, {})]
marker_def = {
'1- Right Hand': [1],
'2 - Left Hand': [2],
'3 - Rest': [3],
'4 - Feet': [4]
}
train_signal_proc = SignalProcessor(set_loader=train_loader,
segment_ival=train_segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
train_set = CntSignalMatrix(signal_processor=train_signal_proc,
sensor_names='all')
test_signal_proc = SignalProcessor(set_loader=test_loader,
segment_ival=test_segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
test_set = CntSignalMatrix(signal_processor=test_signal_proc,
sensor_names='all')
if clean_train:
train_cleaner = BCICompetitionIV2ABArtefactMaskCleaner(
marker_def=marker_def)
else:
train_cleaner = NoCleaner()
test_cleaner = BCICompetitionIV2ABArtefactMaskCleaner(
marker_def=marker_def)
combined_set = CombinedCleanedSet(train_set, test_set, train_cleaner,
test_cleaner)
if not only_return_exp:
combined_set.load()
in_chans = train_set.get_topological_view().shape[1]
else:
in_chans = n_chans
input_time_length = 1000 # implies how many crops are processed in parallel, does _not_ determine receptive field size
# receptive field size is determined by model architecture
# ensure reproducibility by resetting lasagne/theano random generator
lasagne.random.set_rng(RandomState(34734))
final_layer = create_deep_net(in_chans, input_time_length)
print_layers(final_layer)
dataset_splitter = SeveralSetsSplitter(valid_set_fraction=0.2,
use_test_as_valid=False)
iterator = CntWindowTrialIterator(
batch_size=45,
input_time_length=input_time_length,
n_sample_preds=get_n_sample_preds(final_layer))
monitors = [
LossMonitor(),
CntTrialMisclassMonitor(input_time_length=input_time_length),
KappaMonitor(input_time_length=iterator.input_time_length,
mode=kappa_mode),
RuntimeMonitor(),
]
#debug: n_no_decrease_max_epochs = 2
#debug: n_max_epochs = 4
n_no_decrease_max_epochs = 80
n_max_epochs = 800 #100
# real values for paper were 80 and 800
stop_criterion = Or([
NoDecrease('valid_misclass', num_epochs=n_no_decrease_max_epochs),
MaxEpochs(num_epochs=n_max_epochs)
])
dataset = combined_set
splitter = dataset_splitter
updates_expression = adam
updates_modifier = MaxNormConstraintWithDefaults({})
remember_best_chan = 'valid_misclass'
run_after_early_stop = True
exp = Experiment(final_layer,
dataset,
splitter,
None,
iterator,
loss_expression,
updates_expression,
updates_modifier,
monitors,
stop_criterion,
remember_best_chan,
run_after_early_stop,
batch_modifier=None)
if only_return_exp:
return exp
exp.setup()
exp.run()
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
for key in exp.monitor_chans:
ex.info[key] = exp.monitor_chans[key][-1]
ex.info['runtime'] = run_time
save_pkl_artifact(ex, exp.monitor_chans, 'monitor_chans.pkl')
save_npy_artifact(ex, lasagne.layers.get_all_param_values(exp.final_layer),
'model_params.npy')
def run(ex, data_folder, subject_id, n_chans, stop_chan, filt_order,
low_cut_hz, loss_expression, only_return_exp, run_after_early_stop,
sets_like_fbcsp_paper):
start_time = time.time()
assert (only_return_exp is False) or (n_chans is not None)
ex.info['finished'] = False
# trial ivan in milliseconds
# these are the samples that will be predicted, so for a
# network with 2000ms receptive field
# 1500 means the first receptive field goes from -500 to 1500
train_segment_ival = [1500, 4000]
test_segment_ival = [1500, 4000]
add_additional_set = True
session_ids = [
1,
2,
]
if sets_like_fbcsp_paper:
if subject_id in [4, 5, 6, 7, 8, 9]:
session_ids = [3] # dummy
add_additional_set = False
elif subject_id == 1:
session_ids = [
1,
]
else:
assert subject_id in [2, 3]
session_ids = [1, 2]
train_loader = MultipleBCICompetition4Set2B(subject_id,
session_ids=session_ids,
data_folder=data_folder)
test_loader = MultipleBCICompetition4Set2B(subject_id,
session_ids=[3],
data_folder=data_folder)
# Preprocessing pipeline in [(function, {args:values)] logic
cnt_preprocessors = [(resample_cnt, {
'newfs': 250.0
}),
(bandpass_cnt, {
'low_cut_hz': low_cut_hz,
'high_cut_hz': 38,
'filt_order': filt_order,
}), (exponential_standardize_cnt, {})]
marker_def = {'1- Left Hand': [1], '2 - Right Hand': [2]}
train_signal_proc = SignalProcessor(set_loader=train_loader,
segment_ival=train_segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
train_set = CntSignalMatrix(signal_processor=train_signal_proc,
sensor_names='all')
test_signal_proc = SignalProcessor(set_loader=test_loader,
segment_ival=test_segment_ival,
cnt_preprocessors=cnt_preprocessors,
marker_def=marker_def)
test_set = CntSignalMatrix(signal_processor=test_signal_proc,
sensor_names='all')
train_cleaner = BCICompetitionIV2ABArtefactMaskCleaner(
marker_def=marker_def)
test_cleaner = BCICompetitionIV2ABArtefactMaskCleaner(
marker_def=marker_def)
combined_set = CombinedCleanedSet(train_set, test_set, train_cleaner,
test_cleaner)
if not only_return_exp:
combined_set.load()
# only need train set actually, split is done later per fold
combined_set = combined_set.test_set
if add_additional_set:
combined_set.additional_set = train_set
in_chans = train_set.get_topological_view().shape[1]
input_time_length = 1000 # implies how many crops are processed in parallel, does _not_ determine receptive field size
# receptive field size is determined by model architecture
num_filters_time = 25
filter_time_length = 10
num_filters_spat = 25
pool_time_length = 3
pool_time_stride = 3
num_filters_2 = 50
filter_length_2 = 10
num_filters_3 = 100
filter_length_3 = 10
num_filters_4 = 200
filter_length_4 = 10
final_dense_length = 2
n_classes = 2
final_nonlin = softmax
first_nonlin = elu
first_pool_mode = 'max'
first_pool_nonlin = identity
later_nonlin = elu
later_pool_mode = 'max'
later_pool_nonlin = identity
drop_in_prob = 0.0
drop_prob = 0.5
batch_norm_alpha = 0.1
double_time_convs = False
split_first_layer = True
batch_norm = True
def run_exp(i_fold):
# ensure reproducibility by resetting lasagne/theano random generator
lasagne.random.set_rng(RandomState(34734))
d5net = Deep5Net(in_chans=in_chans,
input_time_length=input_time_length,
num_filters_time=num_filters_time,
filter_time_length=filter_time_length,
num_filters_spat=num_filters_spat,
pool_time_length=pool_time_length,
pool_time_stride=pool_time_stride,
num_filters_2=num_filters_2,
filter_length_2=filter_length_2,
num_filters_3=num_filters_3,
filter_length_3=filter_length_3,
num_filters_4=num_filters_4,
filter_length_4=filter_length_4,
final_dense_length=final_dense_length,
n_classes=n_classes,
final_nonlin=final_nonlin,
first_nonlin=first_nonlin,
first_pool_mode=first_pool_mode,
first_pool_nonlin=first_pool_nonlin,
later_nonlin=later_nonlin,
later_pool_mode=later_pool_mode,
later_pool_nonlin=later_pool_nonlin,
drop_in_prob=drop_in_prob,
drop_prob=drop_prob,
batch_norm_alpha=batch_norm_alpha,
double_time_convs=double_time_convs,
split_first_layer=split_first_layer,
batch_norm=batch_norm)
final_layer = d5net.get_layers()[-1]
final_layer = ClipLayer(final_layer, 1e-4, 1 - 1e-4)
dataset_splitter = CntTrialSingleFoldSplitter(n_folds=10,
i_test_fold=i_fold,
shuffle=True)
iterator = CntWindowTrialIterator(
batch_size=45,
input_time_length=input_time_length,
n_sample_preds=get_n_sample_preds(final_layer))
monitors = [
LossMonitor(),
CntTrialMisclassMonitor(input_time_length=input_time_length),
KappaMonitor(input_time_length=iterator.input_time_length,
mode='max'),
RuntimeMonitor()
]
#n_no_decrease_max_epochs = 2
#n_max_epochs = 4
n_no_decrease_max_epochs = 80
n_max_epochs = 800
# real values for paper were 80 and 800
remember_best_chan = 'valid_' + stop_chan
stop_criterion = Or([
NoDecrease(remember_best_chan,
num_epochs=n_no_decrease_max_epochs),
MaxEpochs(num_epochs=n_max_epochs)
])
dataset = combined_set
splitter = dataset_splitter
updates_expression = adam
updates_modifier = MaxNormConstraintWithDefaults({})
preproc = None
exp = Experiment(final_layer,
dataset,
splitter,
preproc,
iterator,
loss_expression,
updates_expression,
updates_modifier,
monitors,
stop_criterion,
remember_best_chan,
run_after_early_stop,
batch_modifier=None)
if only_return_exp:
return exp
exp.setup()
exp.run()
return exp
all_monitor_chans = []
n_folds = 10
for i_fold in range(n_folds):
log.info("Running fold {:d} of {:d}".format(i_fold + 1, n_folds))
exp = run_exp(i_fold)
if only_return_exp:
return exp
all_monitor_chans.append(exp.monitor_chans)
end_time = time.time()
run_time = end_time - start_time
ex.info['finished'] = True
keys = all_monitor_chans[0].keys()
for key in keys:
ex.info[key] = np.mean(
[mchans[key][-1] for mchans in all_monitor_chans])
ex.info['runtime'] = run_time
save_pkl_artifact(ex, all_monitor_chans, 'all_monitor_chans.pkl')