def test_autoreject(): """Some basic tests for autoreject.""" event_id = {'Visual/Left': 3} tmin, tmax = -0.2, 0.5 events = mne.find_events(raw) include = [u'EEG %03d' % i for i in range(1, 15)] picks = mne.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=False, include=include, exclude=[]) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), decim=8, reject=None, add_eeg_ref=False, preload=True) X = epochs.get_data() n_epochs, n_channels, n_times = X.shape X = X.reshape(n_epochs, -1) ar = GlobalAutoReject() assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_channels=n_channels) assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_times=n_times) assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_channels=n_channels, n_times=n_times, thresh=40e-6) ar.fit(X) reject = get_rejection_threshold(epochs) assert_true(reject, isinstance(reject, dict)) param_name = 'thresh' param_range = np.linspace(40e-6, 200e-6, 10) assert_raises(ValueError, validation_curve, ar, X, None, param_name, param_range) ar = LocalAutoReject() assert_raises(NotImplementedError, validation_curve, ar, epochs, None, param_name, param_range) ar = LocalAutoRejectCV() assert_raises(ValueError, ar.fit, X) assert_raises(ValueError, ar.transform, X) assert_raises(ValueError, ar.transform, epochs) epochs.load_data() assert_raises(ValueError, compute_thresholds, epochs, 'dfdfdf') for method in ['random_search', 'bayesian_optimization']: compute_thresholds(epochs, method=method)
def create_epochs_from_raw(raw, events, metadata=None, meg_channels=True, tmin=-0.1, tmax=0.4, decim=10, reject=None, baseline=(None, 0)): """ Create epochs for decoding :param raw: :type raw: mne.io.BaseRaw :param reject: Either of: 'auto_global': Automatically compute rejection threshold based on all data 'auto_channel': Automatically compute rejection threshold for each channel 'default': Use default values None: no rejection A dict with the entries 'mag'/'grad'/both: set these rejection parameters (if mag/grad unspecified: no rejection for these channels) :param events: The definition of epochs and their event IDs (#epochs x 3 matrix) """ events = np.array(events) picks_meg = mne.pick_types(raw.info, meg=meg_channels, eeg=False, eog=False, stim=False, exclude='bads') if reject == 'auto_global': epochs = mne.Epochs(raw, events=events, tmin=tmin, tmax=tmax, proj=True, picks=picks_meg, baseline=baseline) ep_reject = get_rejection_threshold(epochs, decim=2) elif reject == 'auto_channel': print('Auto-detecting rejection thresholds per channel...') epochs = mne.Epochs(raw, events=events, tmin=tmin, tmax=tmax, proj=True, picks=picks_meg, baseline=baseline) ep_reject = compute_thresholds(epochs, picks=picks_meg, method='random_search', augment=False, verbose='progressbar') else: ep_reject = _get_rejection_thresholds(reject, meg_channels) epochs = mne.Epochs(raw, events=events, metadata=metadata, tmin=tmin, tmax=tmax, proj=True, decim=decim, picks=picks_meg, reject=ep_reject, preload=True, baseline=baseline) # print("\nEvenr IDs:") # for cond, eid in epochs.event_id.items(): # print("Condition '%s' (event_id = %d): %d events" % (cond, eid, len(epochs[cond]))) return epochs
def test_autoreject(): """Test basic LocalAutoReject functionality.""" event_id = None tmin, tmax = -0.2, 0.5 events = mne.find_events(raw) ########################################################################## # picking epochs include = [u'EEG %03d' % i for i in range(1, 45, 3)] picks = mne.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=True, include=include, exclude=[]) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), decim=10, reject=None, preload=False)[:10] ar = LocalAutoReject() assert_raises(ValueError, ar.fit, epochs) epochs.load_data() ar.fit(epochs) assert_true(len(ar.picks) == len(picks) - 1) # epochs with no picks. epochs = mne.Epochs(raw, events, event_id, tmin, tmax, baseline=(None, 0), decim=10, reject=None, preload=True)[:20] # let's drop some channels to speed up pre_picks = mne.pick_types(epochs.info, meg=True, eeg=True) pre_picks = np.r_[ mne.pick_types(epochs.info, meg='mag', eeg=False)[::15], mne.pick_types(epochs.info, meg='grad', eeg=False)[::60], mne.pick_types(epochs.info, meg=False, eeg=True)[::16], mne.pick_types(epochs.info, meg=False, eeg=False, eog=True)] pick_ch_names = [epochs.ch_names[pp] for pp in pre_picks] epochs.pick_channels(pick_ch_names) epochs_fit = epochs[:10] epochs_new = epochs[10:] X = epochs_fit.get_data() n_epochs, n_channels, n_times = X.shape X = X.reshape(n_epochs, -1) ar = GlobalAutoReject() assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_channels=n_channels) assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_times=n_times) assert_raises(ValueError, ar.fit, X) ar_global = GlobalAutoReject(n_channels=n_channels, n_times=n_times, thresh=40e-6) ar_global.fit(X) param_name = 'thresh' param_range = np.linspace(40e-6, 200e-6, 10) assert_raises(ValueError, validation_curve, ar_global, X, None, param_name, param_range) ########################################################################## # picking AutoReject picks = mne.pick_types(epochs.info, meg='mag', eeg=True, stim=False, eog=False, include=[], exclude=[]) ch_types = ['mag', 'eeg'] ar = LocalAutoReject(picks=picks) assert_raises(NotImplementedError, validation_curve, ar, epochs, None, param_name, param_range) thresh_func = partial(compute_thresholds, method='bayesian_optimization', random_state=42) ar = LocalAutoRejectCV(cv=3, picks=picks, thresh_func=thresh_func, n_interpolates=[1, 2], consensus_percs=[0.5, 1]) assert_raises(AttributeError, ar.fit, X) assert_raises(ValueError, ar.transform, X) assert_raises(ValueError, ar.transform, epochs) ar.fit(epochs_fit) fix_log = ar.fix_log bad_epochs_idx = ar.local_reject_.bad_epochs_idx_ good_epochs_idx = ar.local_reject_.good_epochs_idx_ for ch_type in ch_types: # test that kappa & rho are selected assert_true(ar.n_interpolate_[ch_type] in ar.n_interpolates) assert_true(ar.consensus_perc_[ch_type] in ar.consensus_percs) # test that local autoreject is synced with AR-CV instance assert_equal(ar.n_interpolate_[ch_type], ar.local_reject_.n_interpolate[ch_type]) assert_equal(ar.consensus_perc_[ch_type], ar.local_reject_.consensus_perc[ch_type]) # test complementarity of goods and bads assert_array_equal(np.sort(np.r_[bad_epochs_idx, good_epochs_idx]), np.arange(len(epochs_fit))) # test that transform does not change state of ar epochs_fit.fit_ = True epochs_clean = ar.transform(epochs_fit) # apply same data assert_array_equal(fix_log, ar.fix_log) assert_array_equal(bad_epochs_idx, ar.local_reject_.bad_epochs_idx_) assert_array_equal(good_epochs_idx, ar.local_reject_.good_epochs_idx_) epochs_new_clean = ar.transform(epochs_new) # apply to new data assert_array_equal(fix_log, ar.fix_log) assert_array_equal(bad_epochs_idx, ar.local_reject_.bad_epochs_idx_) assert_array_equal(good_epochs_idx, ar.local_reject_.good_epochs_idx_) is_same = epochs_new_clean.get_data() == epochs_new.get_data() if not np.isscalar(is_same): is_same = np.isscalar(is_same) assert_true(not is_same) assert_equal(epochs_clean.ch_names, epochs_fit.ch_names) # Now we test that the .bad_segments has the shape # of n_trials, n_sensors, such that n_sensors is the # the full number sensors, before picking. We, hence, # expect nothing to be rejected outside of our picks # but rejections can occur inside our picks. assert_equal(ar.bad_segments.shape[1], len(epochs_fit.ch_names)) assert_true(np.any(ar.bad_segments[:, picks])) non_picks = np.ones(len(epochs_fit.ch_names), dtype=bool) non_picks[picks] = False assert_true(not np.any(ar.bad_segments[:, non_picks])) assert_true(isinstance(ar.threshes_, dict)) assert_true(len(ar.picks) == len(picks)) assert_true(len(ar.threshes_.keys()) == len(ar.picks)) pick_eog = mne.pick_types(epochs.info, meg=False, eeg=False, eog=True) assert_true(epochs.ch_names[pick_eog] not in ar.threshes_.keys()) assert_raises( IndexError, ar.transform, epochs.copy().pick_channels([epochs.ch_names[pp] for pp in picks[:3]])) epochs.load_data() assert_raises(ValueError, compute_thresholds, epochs, 'dfdfdf') index, ch_names = zip(*[(ii, epochs_fit.ch_names[pp]) for ii, pp in enumerate(picks)]) threshes_a = compute_thresholds(epochs_fit, picks=picks, method='random_search') assert_equal(set(threshes_a.keys()), set(ch_names)) threshes_b = compute_thresholds(epochs_fit, picks=picks, method='bayesian_optimization') assert_equal(set(threshes_b.keys()), set(ch_names))
for ix, tr in enumerate(tr_ranges): if any([(tr[0] < fb) and (fb < tr[1]) for fb in fdb[:,0]]): fdb_ixs.append(ix) fdb_ixs = np.array(fdb_ixs) fdb_ixs = np.intersect1d(fix_ixs, fdb_ixs) ixs = [] if "motor" in epo: ixs = fdb_ixs elif "visual" in epo: ixs = dots_ixs ch_thr = compute_thresholds( epochs, random_state=42, method="bayesian_optimization", verbose="progressbar", n_jobs=-1, augment=False ) # save the thresholds in JSON ch_list = list(ch_thr.keys()) ch_list.sort() results = np.zeros((len(ch_list), 56)) results = results - 1 for ix, ch in enumerate(ch_list): thr = ch_thr[ch] ch_tr = epochs.copy().pick_channels([ch]).get_data() res = [np.where(ch_tr[i][0] > thr)[0].shape[0] for i in range(len(epochs))] res = np.array(res) # res = np.sign(res) mask = np.zeros(56)
def test_autoreject(): """Test basic LocalAutoReject functionality.""" event_id = None tmin, tmax = -0.2, 0.5 events = mne.find_events(raw) ########################################################################## # picking epochs include = [u'EEG %03d' % i for i in range(1, 45, 3)] picks = mne.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=True, include=include, exclude=[]) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), decim=10, reject=None, preload=False)[:10] ar = LocalAutoReject() assert_raises(ValueError, ar.fit, epochs) epochs.load_data() ar.fit(epochs) assert_true(len(ar.picks_) == len(picks) - 1) # epochs with no picks. epochs = mne.Epochs(raw, events, event_id, tmin, tmax, baseline=(None, 0), decim=10, reject=None, preload=True)[:20] # let's drop some channels to speed up pre_picks = mne.pick_types(epochs.info, meg=True, eeg=True) pre_picks = np.r_[ mne.pick_types(epochs.info, meg='mag', eeg=False)[::15], mne.pick_types(epochs.info, meg='grad', eeg=False)[::60], mne.pick_types(epochs.info, meg=False, eeg=True)[::16], mne.pick_types(epochs.info, meg=False, eeg=False, eog=True)] pick_ch_names = [epochs.ch_names[pp] for pp in pre_picks] epochs.pick_channels(pick_ch_names) epochs_fit = epochs[:12] # make sure to use different size of epochs epochs_new = epochs[12:] X = epochs_fit.get_data() n_epochs, n_channels, n_times = X.shape X = X.reshape(n_epochs, -1) ar = GlobalAutoReject() assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_channels=n_channels) assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_times=n_times) assert_raises(ValueError, ar.fit, X) ar_global = GlobalAutoReject(n_channels=n_channels, n_times=n_times, thresh=40e-6) ar_global.fit(X) param_name = 'thresh' param_range = np.linspace(40e-6, 200e-6, 10) assert_raises(ValueError, validation_curve, ar_global, X, None, param_name, param_range) ########################################################################## # picking AutoReject picks = mne.pick_types(epochs.info, meg='mag', eeg=True, stim=False, eog=False, include=[], exclude=[]) non_picks = mne.pick_types(epochs.info, meg='grad', eeg=False, stim=False, eog=False, include=[], exclude=[]) ch_types = ['mag', 'eeg'] ar = LocalAutoReject(picks=picks) # XXX : why do we need this?? assert_raises(NotImplementedError, validation_curve, ar, epochs, None, param_name, param_range) thresh_func = partial(compute_thresholds, method='bayesian_optimization', random_state=42) ar = LocalAutoRejectCV(cv=3, picks=picks, thresh_func=thresh_func, n_interpolate=[1, 2], consensus=[0.5, 1]) assert_raises(AttributeError, ar.fit, X) assert_raises(ValueError, ar.transform, X) assert_raises(ValueError, ar.transform, epochs) ar.fit(epochs_fit) reject_log = ar.get_reject_log(epochs_fit) for ch_type in ch_types: # test that kappa & rho are selected assert_true(ar.n_interpolate_[ch_type] in ar.n_interpolate) assert_true(ar.consensus_[ch_type] in ar.consensus) assert_true(ar.n_interpolate_[ch_type] == ar.local_reject_[ch_type].n_interpolate_[ch_type]) assert_true(ar.consensus_[ch_type] == ar.local_reject_[ch_type].consensus_[ch_type]) # test complementarity of goods and bads assert_array_equal(len(reject_log.bad_epochs), len(epochs_fit)) # test that transform does not change state of ar epochs_clean = ar.transform(epochs_fit) # apply same data reject_log2 = ar.get_reject_log(epochs_fit) assert_array_equal(reject_log.labels, reject_log2.labels) assert_array_equal(reject_log.bad_epochs, reject_log2.bad_epochs) assert_array_equal(reject_log.ch_names, reject_log2.ch_names) epochs_new_clean = ar.transform(epochs_new) # apply to new data reject_log_new = ar.get_reject_log(epochs_new) assert_array_equal(len(reject_log_new.bad_epochs), len(epochs_new)) assert_true(len(reject_log_new.bad_epochs) != len(reject_log.bad_epochs)) picks_by_type = _get_picks_by_type(epochs.info, ar.picks) # test correct entries in fix log assert_true(np.isnan(reject_log_new.labels[:, non_picks]).sum() > 0) assert_true(np.isnan(reject_log_new.labels[:, picks]).sum() == 0) assert_equal(reject_log_new.labels.shape, (len(epochs_new), len(epochs_new.ch_names))) # test correct interpolations by type for ch_type, this_picks in picks_by_type: interp_counts = np.sum(reject_log_new.labels[:, this_picks] == 2, axis=1) labels = reject_log_new.labels.copy() not_this_picks = np.setdiff1d(np.arange(labels.shape[1]), this_picks) labels[:, not_this_picks] = np.nan interp_channels = _get_interp_chs(labels, reject_log.ch_names, this_picks) assert_array_equal(interp_counts, [len(cc) for cc in interp_channels]) is_same = epochs_new_clean.get_data() == epochs_new.get_data() if not np.isscalar(is_same): is_same = np.isscalar(is_same) assert_true(not is_same) assert_equal(epochs_clean.ch_names, epochs_fit.ch_names) assert_true(isinstance(ar.threshes_, dict)) assert_true(len(ar.picks) == len(picks)) assert_true(len(ar.threshes_.keys()) == len(ar.picks)) pick_eog = mne.pick_types(epochs.info, meg=False, eeg=False, eog=True)[0] assert_true(epochs.ch_names[pick_eog] not in ar.threshes_.keys()) assert_raises( IndexError, ar.transform, epochs.copy().pick_channels([epochs.ch_names[pp] for pp in picks[:3]])) epochs.load_data() assert_raises(ValueError, compute_thresholds, epochs, 'dfdfdf') index, ch_names = zip(*[(ii, epochs_fit.ch_names[pp]) for ii, pp in enumerate(picks)]) threshes_a = compute_thresholds(epochs_fit, picks=picks, method='random_search') assert_equal(set(threshes_a.keys()), set(ch_names)) threshes_b = compute_thresholds(epochs_fit, picks=picks, method='bayesian_optimization') assert_equal(set(threshes_b.keys()), set(ch_names))
picks = mne.pick_types(epochs.info, meg='grad', eeg=False, stim=False, eog=False, exclude='bads') ############################################################################### # Now, we compute the channel-level thresholds using # :func:`autoreject.compute_thresholds`. The `method` parameter will determine # how we will search for thresholds over a range of potential candidates. import numpy as np # noqa from autoreject import compute_thresholds # noqa # Get a dictionary of rejection thresholds threshes = compute_thresholds(epochs, picks=picks, method='random_search', random_state=42, augment=False, verbose=True) ############################################################################### # Finally, let us plot a histogram of the channel-level thresholds to verify # that the thresholds are indeed different for different sensors. import matplotlib.pyplot as plt # noqa from autoreject import set_matplotlib_defaults # noqa set_matplotlib_defaults(plt) unit = r'fT/cm' scaling = 1e13 plt.figure(figsize=(6, 5)) plt.tick_params(axis='x', which='both', bottom='off', top='off')
def test_autoreject(): """Test basic LocalAutoReject functionality.""" event_id = None tmin, tmax = -0.2, 0.5 events = mne.find_events(raw) ########################################################################## # picking epochs include = [u'EEG %03d' % i for i in range(1, 45, 3)] picks = mne.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=True, include=include, exclude=[]) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), decim=10, reject=None, preload=False)[:10] ar = LocalAutoReject() assert_raises(ValueError, ar.fit, epochs) epochs.load_data() ar.fit(epochs) assert_true(len(ar.picks) == len(picks) - 1) # epochs with no picks. epochs = mne.Epochs(raw, events, event_id, tmin, tmax, baseline=(None, 0), decim=10, reject=None, preload=True)[:20] # let's drop some channels to speed up pre_picks = mne.pick_types(epochs.info, meg=True, eeg=True) pre_picks = np.r_[ mne.pick_types(epochs.info, meg='mag', eeg=False)[::15], mne.pick_types(epochs.info, meg='grad', eeg=False)[::60], mne.pick_types(epochs.info, meg=False, eeg=True)[::16], mne.pick_types(epochs.info, meg=False, eeg=False, eog=True)] pick_ch_names = [epochs.ch_names[pp] for pp in pre_picks] epochs.pick_channels(pick_ch_names) epochs_fit = epochs[:10] epochs_new = epochs[10:] X = epochs_fit.get_data() n_epochs, n_channels, n_times = X.shape X = X.reshape(n_epochs, -1) ar = GlobalAutoReject() assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_channels=n_channels) assert_raises(ValueError, ar.fit, X) ar = GlobalAutoReject(n_times=n_times) assert_raises(ValueError, ar.fit, X) ar_global = GlobalAutoReject( n_channels=n_channels, n_times=n_times, thresh=40e-6) ar_global.fit(X) param_name = 'thresh' param_range = np.linspace(40e-6, 200e-6, 10) assert_raises(ValueError, validation_curve, ar_global, X, None, param_name, param_range) ########################################################################## # picking AutoReject picks = mne.pick_types( epochs.info, meg='mag', eeg=True, stim=False, eog=False, include=[], exclude=[]) ch_types = ['mag', 'eeg'] ar = LocalAutoReject(picks=picks) assert_raises(NotImplementedError, validation_curve, ar, epochs, None, param_name, param_range) thresh_func = partial(compute_thresholds, method='bayesian_optimization', random_state=42) ar = LocalAutoRejectCV(cv=3, picks=picks, thresh_func=thresh_func, n_interpolates=[1, 2], consensus_percs=[0.5, 1]) assert_raises(AttributeError, ar.fit, X) assert_raises(ValueError, ar.transform, X) assert_raises(ValueError, ar.transform, epochs) ar.fit(epochs_fit) fix_log = ar.fix_log bad_epochs_idx = ar.local_reject_.bad_epochs_idx_ good_epochs_idx = ar.local_reject_.good_epochs_idx_ for ch_type in ch_types: # test that kappa & rho are selected assert_true( ar.n_interpolate_[ch_type] in ar.n_interpolates) assert_true( ar.consensus_perc_[ch_type] in ar.consensus_percs) # test that local autoreject is synced with AR-CV instance assert_equal( ar.n_interpolate_[ch_type], ar.local_reject_.n_interpolate[ch_type]) assert_equal( ar.consensus_perc_[ch_type], ar.local_reject_.consensus_perc[ch_type]) # test complementarity of goods and bads assert_array_equal( np.sort(np.r_[bad_epochs_idx, good_epochs_idx]), np.arange(len(epochs_fit))) # test that transform does not change state of ar epochs_fit.fit_ = True epochs_clean = ar.transform(epochs_fit) # apply same data assert_array_equal(fix_log, ar.fix_log) assert_array_equal(bad_epochs_idx, ar.local_reject_.bad_epochs_idx_) assert_array_equal(good_epochs_idx, ar.local_reject_.good_epochs_idx_) epochs_new_clean = ar.transform(epochs_new) # apply to new data assert_array_equal(fix_log, ar.fix_log) assert_array_equal(bad_epochs_idx, ar.local_reject_.bad_epochs_idx_) assert_array_equal(good_epochs_idx, ar.local_reject_.good_epochs_idx_) is_same = epochs_new_clean.get_data() == epochs_new.get_data() if not np.isscalar(is_same): is_same = np.isscalar(is_same) assert_true(not is_same) assert_equal(epochs_clean.ch_names, epochs_fit.ch_names) # Now we test that the .bad_segments has the shape # of n_trials, n_sensors, such that n_sensors is the # the full number sensors, before picking. We, hence, # expect nothing to be rejected outside of our picks # but rejections can occur inside our picks. assert_equal(ar.bad_segments.shape[1], len(epochs_fit.ch_names)) assert_true(np.any(ar.bad_segments[:, picks])) non_picks = np.ones(len(epochs_fit.ch_names), dtype=bool) non_picks[picks] = False assert_true(not np.any(ar.bad_segments[:, non_picks])) assert_true(isinstance(ar.threshes_, dict)) assert_true(len(ar.picks) == len(picks)) assert_true(len(ar.threshes_.keys()) == len(ar.picks)) pick_eog = mne.pick_types(epochs.info, meg=False, eeg=False, eog=True) assert_true(epochs.ch_names[pick_eog] not in ar.threshes_.keys()) assert_raises( IndexError, ar.transform, epochs.copy().pick_channels( [epochs.ch_names[pp] for pp in picks[:3]])) epochs.load_data() assert_raises(ValueError, compute_thresholds, epochs, 'dfdfdf') index, ch_names = zip(*[(ii, epochs_fit.ch_names[pp]) for ii, pp in enumerate(picks)]) threshes_a = compute_thresholds( epochs_fit, picks=picks, method='random_search') assert_equal(set(threshes_a.keys()), set(ch_names)) threshes_b = compute_thresholds( epochs_fit, picks=picks, method='bayesian_optimization') assert_equal(set(threshes_b.keys()), set(ch_names))
def test_autoreject(): """Test basic _AutoReject functionality.""" event_id = None tmin, tmax = -0.2, 0.5 events = mne.find_events(raw) ########################################################################## # picking epochs include = [u'EEG %03d' % i for i in range(1, 45, 3)] picks = mne.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=True, include=include, exclude=[]) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), decim=10, reject=None, preload=False)[:10] ar = _AutoReject() pytest.raises(ValueError, ar.fit, epochs) epochs.load_data() ar.fit(epochs) assert len(ar.picks_) == len(picks) - 1 # epochs with no picks. epochs = mne.Epochs(raw, events, event_id, tmin, tmax, baseline=(None, 0), decim=10, reject=None, preload=True)[:20] # let's drop some channels to speed up pre_picks = mne.pick_types(epochs.info, meg=True, eeg=True) pre_picks = np.r_[ mne.pick_types(epochs.info, meg='mag', eeg=False)[::15], mne.pick_types(epochs.info, meg='grad', eeg=False)[::60], mne.pick_types(epochs.info, meg=False, eeg=True)[::16], mne.pick_types(epochs.info, meg=False, eeg=False, eog=True)] pick_ch_names = [epochs.ch_names[pp] for pp in pre_picks] bad_ch_names = [ epochs.ch_names[ix] for ix in range(len(epochs.ch_names)) if ix not in pre_picks ] epochs_with_bads = epochs.copy() epochs_with_bads.info['bads'] = bad_ch_names epochs.pick_channels(pick_ch_names) epochs_fit = epochs[:12] # make sure to use different size of epochs epochs_new = epochs[12:] epochs_with_bads_fit = epochs_with_bads[:12] X = epochs_fit.get_data() n_epochs, n_channels, n_times = X.shape X = X.reshape(n_epochs, -1) ar = _GlobalAutoReject() pytest.raises(ValueError, ar.fit, X) ar = _GlobalAutoReject(n_channels=n_channels) pytest.raises(ValueError, ar.fit, X) ar = _GlobalAutoReject(n_times=n_times) pytest.raises(ValueError, ar.fit, X) ar_global = _GlobalAutoReject(n_channels=n_channels, n_times=n_times, thresh=40e-6) ar_global.fit(X) param_range = np.linspace(40e-6, 200e-6, 10) train_scores, test_scores = \ validation_curve(epochs_fit, param_range=param_range) assert len(train_scores) == len(test_scores) train_scores, test_scores, param_range = \ validation_curve(epochs_fit, return_param_range=True) assert len(train_scores) == len(test_scores) == len(param_range) pytest.raises(ValueError, validation_curve, X, param_range=param_range) ########################################################################## # picking AutoReject picks = mne.pick_types(epochs.info, meg='mag', eeg=True, stim=False, eog=False, include=[], exclude=[]) non_picks = mne.pick_types(epochs.info, meg='grad', eeg=False, stim=False, eog=False, include=[], exclude=[]) ch_types = ['mag', 'eeg'] ar = _AutoReject(picks=picks) # XXX : why do we need this?? ar = AutoReject(cv=3, picks=picks, random_state=42, n_interpolate=[1, 2], consensus=[0.5, 1]) pytest.raises(AttributeError, ar.fit, X) pytest.raises(ValueError, ar.transform, X) pytest.raises(ValueError, ar.transform, epochs) epochs_nochs = epochs_fit.copy() # just one channel loc is nan or all channel locs are 0. # Should raise error in both cases epochs_nochs.info['chs'][1]['loc'][:] = np.nan pytest.raises(RuntimeError, ar.fit, epochs_nochs) for ch in epochs_nochs.info['chs']: ch['loc'] = np.zeros(9) pytest.raises(RuntimeError, ar.fit, epochs_nochs) ar2 = AutoReject(cv=3, picks=picks, random_state=42, n_interpolate=[1, 2], consensus=[0.5, 1], verbose='blah') pytest.raises(ValueError, ar2.fit, epochs_fit) ar.fit(epochs_fit) reject_log = ar.get_reject_log(epochs_fit) for ch_type in ch_types: # test that kappa & rho are selected assert ar.n_interpolate_[ch_type] in ar.n_interpolate assert ar.consensus_[ch_type] in ar.consensus assert (ar.n_interpolate_[ch_type] == ar.local_reject_[ch_type].n_interpolate_[ch_type]) assert (ar.consensus_[ch_type] == ar.local_reject_[ch_type].consensus_[ch_type]) # test complementarity of goods and bads assert_array_equal(len(reject_log.bad_epochs), len(epochs_fit)) # test that transform does not change state of ar epochs_clean = ar.transform(epochs_fit) # apply same data assert repr(ar) assert repr(ar.local_reject_) reject_log2 = ar.get_reject_log(epochs_fit) assert_array_equal(reject_log.labels, reject_log2.labels) assert_array_equal(reject_log.bad_epochs, reject_log2.bad_epochs) assert_array_equal(reject_log.ch_names, reject_log2.ch_names) epochs_new_clean = ar.transform(epochs_new) # apply to new data reject_log_new = ar.get_reject_log(epochs_new) assert_array_equal(len(reject_log_new.bad_epochs), len(epochs_new)) assert len(reject_log_new.bad_epochs) != len(reject_log.bad_epochs) picks_by_type = _get_picks_by_type(epochs.info, ar.picks) # test correct entries in fix log assert np.isnan(reject_log_new.labels[:, non_picks]).sum() > 0 assert np.isnan(reject_log_new.labels[:, picks]).sum() == 0 assert (reject_log_new.labels.shape == (len(epochs_new), len(epochs_new.ch_names))) # test correct interpolations by type for ch_type, this_picks in picks_by_type: interp_counts = np.sum(reject_log_new.labels[:, this_picks] == 2, axis=1) labels = reject_log_new.labels.copy() not_this_picks = np.setdiff1d(np.arange(labels.shape[1]), this_picks) labels[:, not_this_picks] = np.nan interp_channels = _get_interp_chs(labels, reject_log.ch_names, this_picks) assert_array_equal(interp_counts, [len(cc) for cc in interp_channels]) is_same = epochs_new_clean.get_data() == epochs_new.get_data() if not np.isscalar(is_same): is_same = np.isscalar(is_same) assert not is_same # test that transform ignores bad channels epochs_with_bads_fit.pick_types(meg='mag', eeg=True, eog=True, exclude=[]) ar_bads = AutoReject(cv=3, random_state=42, n_interpolate=[1, 2], consensus=[0.5, 1]) ar_bads.fit(epochs_with_bads_fit) epochs_with_bads_clean = ar_bads.transform(epochs_with_bads_fit) good_w_bads_ix = mne.pick_types(epochs_with_bads_clean.info, meg='mag', eeg=True, eog=True, exclude='bads') good_wo_bads_ix = mne.pick_types(epochs_clean.info, meg='mag', eeg=True, eog=True, exclude='bads') assert_array_equal(epochs_with_bads_clean.get_data()[:, good_w_bads_ix, :], epochs_clean.get_data()[:, good_wo_bads_ix, :]) bad_ix = [ epochs_with_bads_clean.ch_names.index(ch) for ch in epochs_with_bads_clean.info['bads'] ] epo_ix = ~ar_bads.get_reject_log(epochs_with_bads_fit).bad_epochs assert_array_equal( epochs_with_bads_clean.get_data()[:, bad_ix, :], epochs_with_bads_fit.get_data()[epo_ix, :, :][:, bad_ix, :]) assert epochs_clean.ch_names == epochs_fit.ch_names assert isinstance(ar.threshes_, dict) assert len(ar.picks) == len(picks) assert len(ar.threshes_.keys()) == len(ar.picks) pick_eog = mne.pick_types(epochs.info, meg=False, eeg=False, eog=True)[0] assert epochs.ch_names[pick_eog] not in ar.threshes_.keys() pytest.raises( IndexError, ar.transform, epochs.copy().pick_channels([epochs.ch_names[pp] for pp in picks[:3]])) epochs.load_data() pytest.raises(ValueError, compute_thresholds, epochs, 'dfdfdf') index, ch_names = zip(*[(ii, epochs_fit.ch_names[pp]) for ii, pp in enumerate(picks)]) threshes_a = compute_thresholds(epochs_fit, picks=picks, method='random_search') assert set(threshes_a.keys()) == set(ch_names) threshes_b = compute_thresholds(epochs_fit, picks=picks, method='bayesian_optimization') assert set(threshes_b.keys()) == set(ch_names)
preload=True) epochs.pick_types(meg='grad', eeg=False, stim=False, eog=False, include=include, exclude='bads') ############################################################################### # Now, we can define a threshold range over which the threshold must be found # and then compute the channel-level thresholds using # :func:`autoreject.compute_thresholds`. ############################################################################### from autoreject import compute_thresholds import numpy as np thresh_range = dict(grad=(4e-13, 900e-13)) threshes = np.array(compute_thresholds(epochs, thresh_range)['meg']) ############################################################################### # Finally, let us plot a histogram of the channel-level thresholds to verify # that the thresholds are indeed different for different sensors. ############################################################################### import matplotlib.pyplot as plt from autoreject import set_matplotlib_defaults set_matplotlib_defaults(plt) unit = r'fT/cm' scaling = 1e13 plt.figure(figsize=(6, 5)) plt.tick_params(axis='x', which='both', bottom='off', top='off')
eeg=False, stim=False, eog=False, exclude='bads') ############################################################################### # Now, we can define a threshold range over which the threshold must be found # and then compute the channel-level thresholds using # :func:`autoreject.compute_thresholds`. import numpy as np # noqa from autoreject import compute_thresholds # noqa threshes = compute_thresholds(epochs, picks=picks, method='random_search', random_state=42, verbose='progressbar') ############################################################################### # Finally, let us plot a histogram of the channel-level thresholds to verify # that the thresholds are indeed different for different sensors. import matplotlib.pyplot as plt # noqa from autoreject import set_matplotlib_defaults # noqa set_matplotlib_defaults(plt) unit = r'fT/cm' scaling = 1e13 plt.figure(figsize=(6, 5))
picks=picks, baseline=(None, 0), reject=None, verbose=False, preload=True) epochs.pick_types(meg='grad', eeg=False, stim=False, eog=False, include=include, exclude='bads') ############################################################################### # Now, we can define a threshold range over which the threshold must be found # and then compute the channel-level thresholds using # :func:`autoreject.compute_thresholds`. ############################################################################### from autoreject import compute_thresholds import numpy as np threshes = compute_thresholds(epochs, method='random_search', random_state=42, verbose='tqdm')['meg'] ############################################################################### # Finally, let us plot a histogram of the channel-level thresholds to verify # that the thresholds are indeed different for different sensors. ############################################################################### import matplotlib.pyplot as plt from autoreject import set_matplotlib_defaults set_matplotlib_defaults(plt) unit = r'fT/cm' scaling = 1e13 plt.figure(figsize=(6, 5)) plt.tick_params(axis='x', which='both', bottom='off', top='off')