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')