def split_events_by_trialtype(events):
devsA, devsB = range(111,117), range(211,217)
VS_eve = mne.pick_events(events, include=range(100,220))
VS_eve = mne.merge_events(VS_eve, [100], 10, replace_events=True)
VS_eve = mne.merge_events(VS_eve, [200], 20, replace_events=True)
VS_eve = mne.merge_events(VS_eve, devsA, 11, replace_events=True)
VS_eve = mne.merge_events(VS_eve, devsB, 21, replace_events=True)
FB_eve = mne.pick_events(events, include=range(10,22))
eve_dict = dict(VS=VS_eve, FB=FB_eve)
id_dict = dict(stdA=10, stdB=20, devA=11, devB=21) # now same for VS and FB
return eve_dict, id_dict
def generate_ERPs(self, filenames, montage, gen_mode = True, save = True):
self.evokeds = dict()
self.epochs_dict = dict()
for filename in filenames:
self.load_data(filename)
info = self.construct_info(montage)
erp_subject_key = re.split(r'[./]', filename)[1] + '_erp'
epoch_subject_key = re.split(r'[./]', filename)[1] + '_epoch'
events = self.construct_events(self.trigs)
m_events = mne.merge_events(events, [1,5], 15)
if gen_mode:
self.epochs_dict[epoch_subject_key] = self.construct_epoch_array(-0.2, m_events)
self.evokeds[erp_subject_key] = self.construct_trigger_wise_evoked_array(self.epochs_dict[epoch_subject_key], self.epochs_dict[epoch_subject_key].event_id, 'mean')
else:
epoch_path = 'epochs/' + epoch_subject_key + '.fif'
erp_folder_path = 'ERPs/' + erp_subject_key
self.epochs_dict[epoch_subject_key] = self.load_epochs(epoch_path)
self.evokeds[erp_subject_key] = self.load_trigger_wise_evokeds(erp_folder_path, self.epochs_dict[epoch_subject_key].event_id)
if save:
self.save_trigger_wise_evokeds(self.evokeds)
self.save_epochs(self.epochs_dict)
return self.evokeds, self.epochs_dict
def test_cov_estimation_with_triggers():
"""Test estimation from raw with triggers
"""
events = find_events(raw)
event_ids = [1, 2, 3, 4]
reject = dict(grad=10000e-13, mag=4e-12, eeg=80e-6, eog=150e-6)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
epochs = Epochs(raw, events_merged, 1234, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True,
reject=reject, preload=True)
cov = compute_covariance(epochs, keep_sample_mean=True)
cov_mne = read_cov(cov_km_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 0.005)
# Test with tmin and tmax (different but not too much)
cov_tmin_tmax = compute_covariance(epochs, tmin=-0.19, tmax=-0.01)
assert_true(np.all(cov.data != cov_tmin_tmax.data))
assert_true((linalg.norm(cov.data - cov_tmin_tmax.data, ord='fro')
/ linalg.norm(cov_tmin_tmax.data, ord='fro')) < 0.05)
# cov using a list of epochs and keep_sample_mean=True
epochs = [Epochs(raw, events, ev_id, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject)
for ev_id in event_ids]
cov2 = compute_covariance(epochs, keep_sample_mean=True)
assert_array_almost_equal(cov.data, cov2.data)
assert_true(cov.ch_names == cov2.ch_names)
# cov with keep_sample_mean=False using a list of epochs
cov = compute_covariance(epochs, keep_sample_mean=False)
cov_mne = read_cov(cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 0.005)
# test IO when computation done in Python
cov.save('test-cov.fif') # test saving
cov_read = read_cov('test-cov.fif')
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_true((linalg.norm(cov.data - cov_read.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 1e-5)
# cov with list of epochs with different projectors
epochs = [Epochs(raw, events[:4], event_ids[0], tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject),
Epochs(raw, events[:4], event_ids[0], tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=False, reject=reject)]
# these should fail
assert_raises(ValueError, compute_covariance, epochs)
assert_raises(ValueError, compute_covariance, epochs, projs=None)
# these should work, but won't be equal to above
cov = compute_covariance(epochs, projs=epochs[0].info['projs'])
cov = compute_covariance(epochs, projs=[])
def run_evoked(subject_id):
subject = "sub%03d" % subject_id
print("processing subject: %s" % subject)
data_path = op.join(meg_dir, subject)
for run in range(1, 7):
run_fname = op.join(data_path, 'run_%02d_filt_sss_raw.fif' % run)
if not os.path.exists(run_fname):
continue
raw = mne.io.Raw(run_fname)
events = mne.find_events(raw, stim_channel='STI101', consecutive='increasing',
min_duration=0.003, verbose=True)
for key in all_events_id:
events = mne.merge_events(events, all_events_id[key], events_id[key])
mask = (events[:, 2] == 1) | (events[:, 2] == 2) | (events[:, 2] == 3)
events = events[mask]
# df = pd.read_csv(data_path + '/Trials/run_%02d_trldef.txt' % run, sep='\t', header=None)
# ev = np.c_[df[1], np.zeros_like(df[0]), le.transform(df[3])]
# ev[:, 0] = np.round(ev[:, 0] / 3.) # decimation by 3
# ev[:, 0] += raw.first_samp
# ev[:, 0] -= 452
# ev[ev[:, 2] == 3, 2] = 4
# ev[ev[:, 2] == 2, 2] = 3
# ev[ev[:, 2] == 4, 2] = 2
# print events - ev
print "S %s - R %s" % (subject, run)
# print (events - ev)[:, 2]
# assert not np.any((events - ev)[:, 1:])
# assert np.max(np.abs((events - ev)[:, 0])) == 1
mne.write_events(op.join(data_path, 'run_%02d_filt_sss-eve.fif' % run), events)
def create_new_events_from_metadata(epochs: Epochs) -> Epochs:
# container for new events
new_events_all = [np.zeros(3)]
new_event_ids = {}
event_counter = 0
for triplet in epochs.metadata["triplet"].unique().tolist():
for epoch in epochs.metadata["epoch"].unique().tolist():
event_counter += 1
epochs_filt = epochs[
f"epoch == {int(epoch)} & triplet == '{triplet}'"]
old_ids = list(epochs_filt.event_id.values())
new_events = merge_events(
events=epochs_filt.events,
ids=old_ids,
new_id=event_counter,
replace_events=True,
)
new_event_ids[f"e{int(epoch)}_{triplet}"] = int(event_counter)
new_events_all = np.concatenate([new_events_all, new_events],
axis=0)
new_events_all = new_events_all[1:]
epochs.event_id = new_event_ids
epochs.events = new_events_all
return epochs
def test_compute_covariance_auto_reg():
"""Test automated regularization."""
raw = read_raw_fif(raw_fname, preload=True, add_eeg_ref=False)
raw.resample(100, npad='auto') # much faster estimation
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
# we need a few channels for numerical reasons in PCA/FA
picks = pick_types(raw.info, meg='mag', eeg=False)[:10]
raw.pick_channels([raw.ch_names[pick] for pick in picks])
raw.info.normalize_proj()
epochs = Epochs(raw,
events_merged,
1234,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject,
preload=True,
add_eeg_ref=False)
epochs = epochs.crop(None, 0)[:10]
method_params = dict(factor_analysis=dict(iter_n_components=[3]),
pca=dict(iter_n_components=[3]))
covs = compute_covariance(epochs,
method='auto',
method_params=method_params,
projs=True,
return_estimators=True)
logliks = [c['loglik'] for c in covs]
assert_true(np.diff(logliks).max() <= 0) # descending order
methods = ['empirical', 'factor_analysis', 'ledoit_wolf', 'pca']
cov3 = compute_covariance(epochs,
method=methods,
method_params=method_params,
projs=None,
return_estimators=True)
assert_equal(set([c['method'] for c in cov3]), set(methods))
# invalid prespecified method
assert_raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
assert_raises(ValueError,
compute_covariance,
epochs,
method='shrunk',
scalings=dict(misc=123))
def triple_to_epochs(self, triple):
# pull events from raw meeg_file
meeg_file = triple[0]
raw = self.mne_open(meeg_file, preload=True)
raw.drop_channels(['EEG061', 'EEG062', 'EEG063']) # drop mistakenly labeled HEOG, VEOG, ECG channels
events = mne.find_events(raw, stim_channel='STI101', min_duration=.01, verbose=False)
events = mne.merge_events(events, [5, 6, 7], 5)
events = mne.merge_events(events, [13, 14, 15], 13)
events = mne.merge_events(events, [17, 18, 19], 17)
# pull conditions and images from truth file
# pull automatically detected bad channels from sss_log_file
truth_file = triple[1]
sss_log_file = triple[2]
conditions, images = self.truth_file_to_conditions_and_images(truth_file)
bad_channels = self.sss_log_file_to_bad_channels(sss_log_file)
# split raw meeg_file into Epochs
epochs = mne.Epochs(raw, events, [5, 13, 17], -.5, +1.2, preload=True, verbose=False)
# check that the epoch conditions match the truth conditions. if the number of detected events and truth events don't match, try to align and make sure the results look legit.
event_conditions = [x[2] for x in epochs.events]
if len(event_conditions) != len(conditions):
print("Aligning automatically detected conditions with truth conditions of file {}".format(meeg_file))
events_aligned = self.align(conditions, event_conditions)
# the detected events were too short to properly align with the truth conditions. ignoring file.
if len(events_aligned) != len(conditions):
num_different = len(conditions) - len(events_aligned)
else:
num_similar, num_different = self.compare_conditions(conditions, events_aligned)
else:
num_similar, num_different = self.compare_conditions(conditions, event_conditions)
# Sub1 Run3 only has 59 automatically detected conditions, but 146 truth conditions, so the alignment library just chops off the difference.
if num_different != 0:
print("File {} conditions (len: {}) could not be properly aligned with truth conditions (len: {}). Ignoring file.".format(meeg_file, len(event_conditions), len(conditions)))
return None
# at this stage, epochs is a list of legit epochs with legit conditions.
# run epochs through 32 Hz low-pass filter to remove environmental noise and crop 400ms from either end to remove filter artifacts
epochs.savgol_filter(32.)
epochs.crop(tmin= -.1, tmax=+.8, copy=False)
return epochs
def test_compute_covariance_auto_reg():
"""Test automated regularization"""
raw = Raw(raw_fname, preload=False)
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
picks = pick_types(raw.info, meg='mag', eeg=False)
epochs = Epochs(raw, events_merged, 1234, tmin=-0.2, tmax=0,
picks=picks[:5], baseline=(-0.2, -0.1), proj=True,
reject=reject, preload=True)
epochs.crop(None, 0)[:10]
method_params = dict(factor_analysis=dict(iter_n_components=[30]),
pca=dict(iter_n_components=[30]))
with warnings.catch_warnings(record=True) as w:
covs = compute_covariance(epochs, method='auto',
method_params=method_params,
projs=True,
return_estimators=True)
warnings.simplefilter('always')
assert_equal(len(w), 1)
logliks = [c['loglik'] for c in covs]
assert_true(np.diff(logliks).max() <= 0) # descending order
methods = ['empirical',
'factor_analysis',
'ledoit_wolf',
# 'pca', XXX FAILS
]
with warnings.catch_warnings(record=True) as w:
cov3 = compute_covariance(epochs, method=methods,
method_params=method_params, projs=False,
return_estimators=True)
warnings.simplefilter('always')
assert_equal(len(w), 1)
assert_equal(set([c['method'] for c in cov3]),
set(methods))
# projs not allowed with FA or PCA
assert_raises(ValueError, compute_covariance, epochs, method='pca',
projs=True)
# invalid prespecified method
assert_raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
assert_raises(ValueError, compute_covariance, epochs, method='shrunk',
scalings=dict(misc=123))
def test_compute_covariance_auto_reg():
"""Test automated regularization"""
raw = Raw(raw_fname, preload=False)
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
picks = pick_types(raw.info, meg='mag', eeg=False)
epochs = Epochs(raw, events_merged, 1234, tmin=-0.2, tmax=0,
picks=picks[:5], baseline=(-0.2, -0.1), proj=True,
reject=reject, preload=True)
epochs.crop(None, 0)[:10]
method_params = dict(factor_analysis=dict(iter_n_components=[30]),
pca=dict(iter_n_components=[30]))
with warnings.catch_warnings(record=True) as w:
covs = compute_covariance(epochs, method='auto',
method_params=method_params,
projs=True,
return_estimators=True)
warnings.simplefilter('always')
assert_equal(len(w), 1)
logliks = [c['loglik'] for c in covs]
assert_true(np.diff(logliks).max() <= 0) # descending order
with warnings.catch_warnings(record=True) as w:
cov3 = compute_covariance(epochs, method=['empirical',
'factor_analysis'],
method_params=method_params, projs=False,
return_estimators=True)
warnings.simplefilter('always')
assert_equal(len(w), 1)
assert_equal(set([c['method'] for c in cov3]),
set(['empirical', 'factor_analysis']))
# projs not allowed with FA or PCA
assert_raises(ValueError, compute_covariance, epochs, method='pca',
projs=True)
# invalid prespecified method
assert_raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
assert_raises(ValueError, compute_covariance, epochs, method='shrunk',
scalings=dict(misc=123))
def test_cov_estimation_with_triggers():
"""Estimate raw with triggers
"""
raw = Raw(raw_fname)
events = find_events(raw)
event_ids = [1, 2, 3, 4]
reject = dict(grad=10000e-13, mag=4e-12, eeg=80e-6, eog=150e-6)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
epochs = Epochs(raw, events_merged, 1234, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True,
reject=reject, preload=True)
cov = compute_covariance(epochs, keep_sample_mean=True)
cov_mne = read_cov(cov_km_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 0.005)
# Test with tmin and tmax (different but not too much)
cov_tmin_tmax = compute_covariance(epochs, tmin=-0.19, tmax=-0.01)
assert_true(np.all(cov.data != cov_tmin_tmax.data))
assert_true((linalg.norm(cov.data - cov_tmin_tmax.data, ord='fro')
/ linalg.norm(cov_tmin_tmax.data, ord='fro')) < 0.05)
# cov using a list of epochs and keep_sample_mean=True
epochs = [Epochs(raw, events, ev_id, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject)
for ev_id in event_ids]
cov2 = compute_covariance(epochs, keep_sample_mean=True)
assert_array_almost_equal(cov.data, cov2.data)
assert_true(cov.ch_names == cov2.ch_names)
# cov with keep_sample_mean=False using a list of epochs
cov = compute_covariance(epochs, keep_sample_mean=False)
cov_mne = read_cov(cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 0.005)
# test IO when computation done in Python
cov.save('test-cov.fif') # test saving
cov_read = read_cov('test-cov.fif')
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_true((linalg.norm(cov.data - cov_read.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 1e-5)
def test_compute_covariance_auto_reg():
"""Test automated regularization"""
raw = read_raw_fif(raw_fname, preload=True)
raw.resample(100, npad='auto') # much faster estimation
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
# we need a few channels for numerical reasons in PCA/FA
picks = pick_types(raw.info, meg='mag', eeg=False)[:10]
raw.pick_channels([raw.ch_names[pick] for pick in picks])
raw.info.normalize_proj()
epochs = Epochs(
raw, events_merged, 1234, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject, preload=True)
epochs = epochs.crop(None, 0)[:10]
method_params = dict(factor_analysis=dict(iter_n_components=[3]),
pca=dict(iter_n_components=[3]))
covs = compute_covariance(epochs, method='auto',
method_params=method_params,
projs=True,
return_estimators=True)
logliks = [c['loglik'] for c in covs]
assert_true(np.diff(logliks).max() <= 0) # descending order
methods = ['empirical',
'factor_analysis',
'ledoit_wolf',
'pca']
cov3 = compute_covariance(epochs, method=methods,
method_params=method_params, projs=None,
return_estimators=True)
assert_equal(set([c['method'] for c in cov3]),
set(methods))
# invalid prespecified method
assert_raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
assert_raises(ValueError, compute_covariance, epochs, method='shrunk',
scalings=dict(misc=123))
def test_cov_estimation_with_triggers():
"""Test estimation from raw with triggers
"""
raw = Raw(raw_fname, preload=False)
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(grad=10000e-13, mag=4e-12, eeg=80e-6, eog=150e-6)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
epochs = Epochs(raw,
events_merged,
1234,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject,
preload=True)
cov = compute_covariance(epochs, keep_sample_mean=True)
cov_mne = read_cov(cov_km_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro') /
linalg.norm(cov.data, ord='fro')) < 0.005)
# Test with tmin and tmax (different but not too much)
cov_tmin_tmax = compute_covariance(epochs, tmin=-0.19, tmax=-0.01)
assert_true(np.all(cov.data != cov_tmin_tmax.data))
assert_true((linalg.norm(cov.data - cov_tmin_tmax.data, ord='fro') /
linalg.norm(cov_tmin_tmax.data, ord='fro')) < 0.05)
# cov using a list of epochs and keep_sample_mean=True
epochs = [
Epochs(raw,
events,
ev_id,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject) for ev_id in event_ids
]
cov2 = compute_covariance(epochs, keep_sample_mean=True)
assert_array_almost_equal(cov.data, cov2.data)
assert_true(cov.ch_names == cov2.ch_names)
# cov with keep_sample_mean=False using a list of epochs
cov = compute_covariance(epochs, keep_sample_mean=False)
cov_mne = read_cov(cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro') /
linalg.norm(cov.data, ord='fro')) < 0.005)
# test IO when computation done in Python
cov.save(op.join(tempdir, 'test-cov.fif')) # test saving
cov_read = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_true((linalg.norm(cov.data - cov_read.data, ord='fro') /
linalg.norm(cov.data, ord='fro')) < 1e-5)
# cov with list of epochs with different projectors
epochs = [
Epochs(raw,
events[:4],
event_ids[0],
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject),
Epochs(raw,
events[:4],
event_ids[0],
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=False,
reject=reject)
]
# these should fail
assert_raises(ValueError, compute_covariance, epochs)
assert_raises(ValueError, compute_covariance, epochs, projs=None)
# these should work, but won't be equal to above
with warnings.catch_warnings(record=True) as w: # too few samples warning
warnings.simplefilter('always')
cov = compute_covariance(epochs, projs=epochs[0].info['projs'])
cov = compute_covariance(epochs, projs=[])
assert_true(len(w) == 2)
# test new dict support
epochs = Epochs(raw,
events,
dict(a=1, b=2, c=3, d=4),
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject)
compute_covariance(epochs)
def test_cov_estimation_with_triggers():
"""Test estimation from raw with triggers."""
tempdir = _TempDir()
raw = read_raw_fif(raw_fname)
raw.set_eeg_reference(projection=True).load_data()
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(grad=10000e-13, mag=4e-12, eeg=80e-6, eog=150e-6)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
epochs = Epochs(raw, events_merged, 1234, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True,
reject=reject, preload=True)
cov = compute_covariance(epochs, keep_sample_mean=True)
_assert_cov(cov, read_cov(cov_km_fname))
# Test with tmin and tmax (different but not too much)
cov_tmin_tmax = compute_covariance(epochs, tmin=-0.19, tmax=-0.01)
assert_true(np.all(cov.data != cov_tmin_tmax.data))
err = (linalg.norm(cov.data - cov_tmin_tmax.data, ord='fro') /
linalg.norm(cov_tmin_tmax.data, ord='fro'))
assert_true(err < 0.05, msg=err)
# cov using a list of epochs and keep_sample_mean=True
epochs = [Epochs(raw, events, ev_id, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject)
for ev_id in event_ids]
cov2 = compute_covariance(epochs, keep_sample_mean=True)
assert_array_almost_equal(cov.data, cov2.data)
assert_true(cov.ch_names == cov2.ch_names)
# cov with keep_sample_mean=False using a list of epochs
cov = compute_covariance(epochs, keep_sample_mean=False)
_assert_cov(cov, read_cov(cov_fname), nfree=False)
method_params = {'empirical': {'assume_centered': False}}
assert_raises(ValueError, compute_covariance, epochs,
keep_sample_mean=False, method_params=method_params)
assert_raises(ValueError, compute_covariance, epochs,
keep_sample_mean=False, method='factor_analysis')
# test IO when computation done in Python
cov.save(op.join(tempdir, 'test-cov.fif')) # test saving
cov_read = read_cov(op.join(tempdir, 'test-cov.fif'))
_assert_cov(cov, cov_read, 1e-5)
# cov with list of epochs with different projectors
epochs = [Epochs(raw, events[:1], None, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True),
Epochs(raw, events[:1], None, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=False)]
# these should fail
assert_raises(ValueError, compute_covariance, epochs)
assert_raises(ValueError, compute_covariance, epochs, projs=None)
# these should work, but won't be equal to above
with warnings.catch_warnings(record=True) as w: # too few samples warning
warnings.simplefilter('always')
cov = compute_covariance(epochs, projs=epochs[0].info['projs'])
cov = compute_covariance(epochs, projs=[])
assert_equal(len(w), 2)
# test new dict support
epochs = Epochs(raw, events, dict(a=1, b=2, c=3, d=4), tmin=-0.01, tmax=0,
proj=True, reject=reject, preload=True)
with warnings.catch_warnings(record=True): # samples
compute_covariance(epochs)
# projs checking
compute_covariance(epochs, projs=[])
assert_raises(TypeError, compute_covariance, epochs, projs='foo')
assert_raises(TypeError, compute_covariance, epochs, projs=['foo'])
def test_compute_covariance_auto_reg():
"""Test automated regularization."""
raw = read_raw_fif(raw_fname, preload=True)
raw.resample(100, npad='auto') # much faster estimation
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
# we need a few channels for numerical reasons in PCA/FA
picks = pick_types(raw.info, meg='mag', eeg=False)[:10]
raw.pick_channels([raw.ch_names[pick] for pick in picks])
raw.info.normalize_proj()
epochs = Epochs(
raw, events_merged, 1234, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject, preload=True)
epochs = epochs.crop(None, 0)[:10]
method_params = dict(factor_analysis=dict(iter_n_components=[3]),
pca=dict(iter_n_components=[3]))
covs = compute_covariance(epochs, method='auto',
method_params=method_params,
return_estimators=True)
# make sure regularization produces structured differencess
diag_mask = np.eye(len(epochs.ch_names)).astype(bool)
off_diag_mask = np.invert(diag_mask)
for cov_a, cov_b in itt.combinations(covs, 2):
if (cov_a['method'] == 'diagonal_fixed' and
# here we have diagnoal or no regularization.
cov_b['method'] == 'empirical'):
assert_true(not np.any(
cov_a['data'][diag_mask] ==
cov_b['data'][diag_mask]))
# but the rest is the same
assert_array_equal(
cov_a['data'][off_diag_mask],
cov_b['data'][off_diag_mask])
else:
# and here we have shrinkage everywhere.
assert_true(not np.any(
cov_a['data'][diag_mask] ==
cov_b['data'][diag_mask]))
assert_true(not np.any(
cov_a['data'][diag_mask] ==
cov_b['data'][diag_mask]))
logliks = [c['loglik'] for c in covs]
assert_true(np.diff(logliks).max() <= 0) # descending order
methods = ['empirical', 'factor_analysis', 'ledoit_wolf', 'oas', 'pca',
'shrunk', 'shrinkage']
cov3 = compute_covariance(epochs, method=methods,
method_params=method_params, projs=None,
return_estimators=True)
method_names = [cov['method'] for cov in cov3]
for method in ['factor_analysis', 'ledoit_wolf', 'oas', 'pca',
'shrinkage']:
this_lik = cov3[method_names.index(method)]['loglik']
assert -55 < this_lik < -45
this_lik = cov3[method_names.index('empirical')]['loglik']
assert -110 < this_lik < -100
this_lik = cov3[method_names.index('shrunk')]['loglik']
assert -45 < this_lik < -35
assert_equal(set([c['method'] for c in cov3]), set(methods))
cov4 = compute_covariance(epochs, method=methods,
method_params=method_params, projs=None,
return_estimators=False)
assert cov3[0]['method'] == cov4['method'] # ordering
# invalid prespecified method
assert_raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
assert_raises(ValueError, compute_covariance, epochs, method='shrunk',
scalings=dict(misc=123))
def load_epochs_from_file(file, reject_bad_segments="auto", mask=None):
"""Load epochs from a header file.
Args:
file: path to a header file (.vhdr)
reject_bad_segments: 'auto' | 'annot' | 'peak-to-peak'
Whether the epochs with overlapping bad segments are rejected by default.
'auto' means that bad segments are rejected automatically.
'annot' rejection based on annotations and reject only channels annotated in .vmrk file as
'bad'.
'peak-to-peak' rejection based on peak-to-peak amplitude of channels.
Rejected with 'annot' and 'amplitude' channels are zeroed.
Returns:
mne Epochs
"""
# Import the BrainVision data into an MNE Raw object
raw = mne.io.read_raw_brainvision(file)
# Construct annotation filename
annot_file = file[:-4] + "vmrk"
# Read in the event information as MNE annotations
annotations = mne.read_annotations(annot_file)
# Add the annotations to our raw object so we can use them with the data
raw.set_annotations(annotations)
# Map with response markers only
event_dict = {
"Stimulus/RE*ex*1_n*1_c_1*R*FB": 10004,
"Stimulus/RE*ex*1_n*1_c_1*R*FG": 10005,
"Stimulus/RE*ex*1_n*1_c_2*R": 10006,
"Stimulus/RE*ex*1_n*2_c_1*R": 10007,
"Stimulus/RE*ex*2_n*1_c_1*R": 10008,
"Stimulus/RE*ex*2_n*2_c_1*R*FB": 10009,
"Stimulus/RE*ex*2_n*2_c_1*R*FG": 10010,
"Stimulus/RE*ex*2_n*2_c_2*R": 10011,
}
# Map for merged correct/error response markers
merged_event_dict = {"correct_response": 0, "error_response": 1}
# Reconstruct the original events from Raw object
events, event_ids = mne.events_from_annotations(raw, event_id=event_dict)
# Merge correct/error response events
merged_events = mne.merge_events(
events,
[10004, 10005, 10009, 10010],
merged_event_dict["correct_response"],
replace_events=True,
)
merged_events = mne.merge_events(
merged_events,
[10006, 10007, 10008, 10011],
merged_event_dict["error_response"],
replace_events=True,
)
epochs = []
bads = []
this_reject_by_annotation = True
if reject_bad_segments != "auto":
this_reject_by_annotation = False
# Read epochs
temp_epochs = mne.Epochs(
raw=raw,
events=merged_events,
event_id=merged_event_dict,
tmin=tmin,
tmax=tmax,
baseline=None,
reject_by_annotation=this_reject_by_annotation,
preload=True,
)
if reject_bad_segments == "annot":
custom_annotations = get_annotations(annot_file)
bads = get_bads_by_annotation(custom_annotations)
elif reject_bad_segments == "peak-to-peak":
bads = get_bads_by_peak_to_peak_amplitude(temp_epochs)
else:
epochs = temp_epochs
return epochs
if mask is None:
epochs = clear_bads(temp_epochs, bads)
elif len(mask) == 64:
epochs = reject_with_mask(temp_epochs, mask, bads)
else:
print(
"Given mask has wrong shape. Expected len of 64 but got {}".format(
len(mask)))
return epochs
# Just like `~mne.pick_events`, `~mne.read_events` also has ``include`` # and ``exclude`` parameters. # # If some of those events are not of interest, you can easily subselect events # using :func:`mne.pick_events`, which has parameters ``include`` and # ``exclude``. For example, in the sample data Event ID 32 corresponds to a # subject button press, which could be excluded as: events_no_button = mne.pick_events(events, exclude=32) ############################################################################### # It is also possible to combine two Event IDs using :func:`mne.merge_events`; # the following example will combine Event IDs 1, 2 and 3 into a single event # labelled ``1``: merged_events = mne.merge_events(events, [1, 2, 3], 1) print(np.unique(merged_events[:, -1])) ############################################################################### # Note, however, that merging events is not necessary if you simply want to # pool trial types for analysis; the next section describes how MNE-Python uses # *event dictionaries* to map integer Event IDs to more descriptive label # strings. # # # Mapping Event IDs to trial descriptors # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # # So far in this tutorial we've only been dealing with integer Event IDs, which # were assigned based on DC voltage pulse magnitude (which is ultimately # determined by the experimenter's choices about what signals to send to the
def test_cov_estimation_with_triggers(rank, tmpdir):
"""Test estimation from raw with triggers."""
raw = read_raw_fif(raw_fname)
raw.set_eeg_reference(projection=True).load_data()
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(grad=10000e-13, mag=4e-12, eeg=80e-6, eog=150e-6)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
epochs = Epochs(raw,
events_merged,
1234,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject,
preload=True)
cov = compute_covariance(epochs, keep_sample_mean=True)
cov_km = read_cov(cov_km_fname)
# adjust for nfree bug
cov_km['nfree'] -= 1
_assert_cov(cov, cov_km)
# Test with tmin and tmax (different but not too much)
cov_tmin_tmax = compute_covariance(epochs, tmin=-0.19, tmax=-0.01)
assert np.all(cov.data != cov_tmin_tmax.data)
err = (linalg.norm(cov.data - cov_tmin_tmax.data, ord='fro') /
linalg.norm(cov_tmin_tmax.data, ord='fro'))
assert err < 0.05
# cov using a list of epochs and keep_sample_mean=True
epochs = [
Epochs(raw,
events,
ev_id,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject) for ev_id in event_ids
]
cov2 = compute_covariance(epochs, keep_sample_mean=True)
assert_array_almost_equal(cov.data, cov2.data)
assert cov.ch_names == cov2.ch_names
# cov with keep_sample_mean=False using a list of epochs
cov = compute_covariance(epochs, keep_sample_mean=False)
assert cov_km.nfree == cov.nfree
_assert_cov(cov, read_cov(cov_fname), nfree=False)
method_params = {'empirical': {'assume_centered': False}}
pytest.raises(ValueError,
compute_covariance,
epochs,
keep_sample_mean=False,
method_params=method_params)
pytest.raises(ValueError,
compute_covariance,
epochs,
keep_sample_mean=False,
method='shrunk',
rank=rank)
# test IO when computation done in Python
cov.save(tmpdir.join('test-cov.fif')) # test saving
cov_read = read_cov(tmpdir.join('test-cov.fif'))
_assert_cov(cov, cov_read, 1e-5)
# cov with list of epochs with different projectors
epochs = [
Epochs(raw,
events[:1],
None,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True),
Epochs(raw,
events[:1],
None,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=False)
]
# these should fail
pytest.raises(ValueError, compute_covariance, epochs)
pytest.raises(ValueError, compute_covariance, epochs, projs=None)
# these should work, but won't be equal to above
with pytest.warns(RuntimeWarning, match='Too few samples'):
cov = compute_covariance(epochs, projs=epochs[0].info['projs'])
with pytest.warns(RuntimeWarning, match='Too few samples'):
cov = compute_covariance(epochs, projs=[])
# test new dict support
epochs = Epochs(raw,
events,
dict(a=1, b=2, c=3, d=4),
tmin=-0.01,
tmax=0,
proj=True,
reject=reject,
preload=True)
with pytest.warns(RuntimeWarning, match='Too few samples'):
compute_covariance(epochs)
with pytest.warns(RuntimeWarning, match='Too few samples'):
compute_covariance(epochs, projs=[])
pytest.raises(TypeError, compute_covariance, epochs, projs='foo')
pytest.raises(TypeError, compute_covariance, epochs, projs=['foo'])
def test_compute_covariance_auto_reg(rank):
"""Test automated regularization."""
raw = read_raw_fif(raw_fname, preload=True)
raw.resample(100, npad='auto') # much faster estimation
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
# we need a few channels for numerical reasons in PCA/FA
picks = pick_types(raw.info, meg='mag', eeg=False)[:10]
raw.pick_channels([raw.ch_names[pick] for pick in picks])
raw.info.normalize_proj()
epochs = Epochs(raw,
events_merged,
1234,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject,
preload=True)
epochs = epochs.crop(None, 0)[:5]
method_params = dict(factor_analysis=dict(iter_n_components=[3]),
pca=dict(iter_n_components=[3]))
covs = compute_covariance(epochs,
method='auto',
method_params=method_params,
return_estimators=True,
rank=rank)
# make sure regularization produces structured differencess
diag_mask = np.eye(len(epochs.ch_names)).astype(bool)
off_diag_mask = np.invert(diag_mask)
for cov_a, cov_b in itt.combinations(covs, 2):
if (cov_a['method'] == 'diagonal_fixed' and
# here we have diagnoal or no regularization.
cov_b['method'] == 'empirical' and rank == 'full'):
assert not np.any(
cov_a['data'][diag_mask] == cov_b['data'][diag_mask])
# but the rest is the same
assert_allclose(cov_a['data'][off_diag_mask],
cov_b['data'][off_diag_mask],
rtol=1e-12)
else:
# and here we have shrinkage everywhere.
assert not np.any(
cov_a['data'][diag_mask] == cov_b['data'][diag_mask])
assert not np.any(
cov_a['data'][diag_mask] == cov_b['data'][diag_mask])
logliks = [c['loglik'] for c in covs]
assert np.diff(logliks).max() <= 0 # descending order
methods = ['empirical', 'ledoit_wolf', 'oas', 'shrunk', 'shrinkage']
if rank == 'full':
methods.extend(['factor_analysis', 'pca'])
with catch_logging() as log:
cov3 = compute_covariance(epochs,
method=methods,
method_params=method_params,
projs=None,
return_estimators=True,
rank=rank,
verbose=True)
log = log.getvalue().split('\n')
if rank is None:
assert ' Setting small MAG eigenvalues to zero (without PCA)' in log
assert 'Reducing data rank from 10 -> 7' in log
else:
assert 'Reducing' not in log
method_names = [cov['method'] for cov in cov3]
best_bounds = [-45, -35]
bounds = [-55, -45] if rank == 'full' else best_bounds
for method in set(methods) - {'empirical', 'shrunk'}:
this_lik = cov3[method_names.index(method)]['loglik']
assert bounds[0] < this_lik < bounds[1]
this_lik = cov3[method_names.index('shrunk')]['loglik']
assert best_bounds[0] < this_lik < best_bounds[1]
this_lik = cov3[method_names.index('empirical')]['loglik']
bounds = [-110, -100] if rank == 'full' else best_bounds
assert bounds[0] < this_lik < bounds[1]
assert_equal({c['method'] for c in cov3}, set(methods))
cov4 = compute_covariance(epochs,
method=methods,
method_params=method_params,
projs=None,
return_estimators=False,
rank=rank)
assert cov3[0]['method'] == cov4['method'] # ordering
# invalid prespecified method
pytest.raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
pytest.raises(ValueError,
compute_covariance,
epochs,
method='shrunk',
scalings=dict(misc=123))
def process_raw(self, raw, dataset, return_epochs=False):
# find the events, first check stim_channels then annotations
stim_channels = mne.utils._get_stim_channel(None,
raw.info,
raise_error=False)
if len(stim_channels) > 0:
events = mne.find_events(raw, shortest_event=0, verbose=False)
else:
events, _ = mne.events_from_annotations(raw, verbose=False)
channels = () if self.channels is None else self.channels
# picks channels
picks = mne.pick_types(raw.info,
eeg=True,
stim=False,
include=channels)
# get event id
event_id = self.used_events(dataset)
# pick events, based on event_id
try:
if type(event_id["Target"]) is list and type(
event_id["NonTarget"]) == list:
event_id_new = dict(Target=1, NonTarget=0)
events = mne.merge_events(events, event_id["Target"], 1)
events = mne.merge_events(events, event_id["NonTarget"], 0)
event_id = event_id_new
events = mne.pick_events(events, include=list(event_id.values()))
except RuntimeError:
# skip raw if no event found
return
# get interval
tmin = self.tmin + dataset.interval[0]
if self.tmax is None:
tmax = dataset.interval[1]
else:
tmax = self.tmax + dataset.interval[0]
X = []
for bandpass in self.filters:
fmin, fmax = bandpass
# filter data
raw_f = raw.copy().filter(fmin,
fmax,
method="iir",
picks=picks,
verbose=False)
# epoch data
baseline = self.baseline
if baseline is not None:
baseline = (
self.baseline[0] + dataset.interval[0],
self.baseline[1] + dataset.interval[0],
)
bmin = baseline[0] if baseline[0] < tmin else tmin
bmax = baseline[1] if baseline[1] > tmax else tmax
else:
bmin = tmin
bmax = tmax
epochs = mne.Epochs(
raw_f,
events,
event_id=event_id,
tmin=bmin,
tmax=bmax,
proj=False,
baseline=baseline,
preload=True,
verbose=False,
picks=picks,
on_missing="ignore",
)
if bmin < tmin or bmax > tmax:
epochs.crop(tmin=tmin, tmax=tmax)
if self.resample is not None:
epochs = epochs.resample(self.resample)
# rescale to work with uV
if return_epochs:
X.append(epochs)
else:
X.append(dataset.unit_factor * epochs.get_data())
inv_events = {k: v for v, k in event_id.items()}
labels = np.array([inv_events[e] for e in epochs.events[:, -1]])
# if only one band, return a 3D array, otherwise return a 4D
if len(self.filters) == 1:
X = X[0]
else:
X = np.array(X).transpose((1, 2, 3, 0))
metadata = pd.DataFrame(index=range(len(labels)))
return X, labels, metadata
# identical part of the label.
event_id = {'A': 70, 'B/1': 71, 'B/2': 72, 'B/3': 73, 'B/4': 74, 'B/5': 75}
epochs = mne.Epochs(raw, events=events, event_id=event_id, tmin=-0.2, tmax=1,
baseline=(0, None), picks=picks, preload=True)
# If you now epoch the data with these assignments, the same code can be applied
# to refer to the all epochs locked to cue 'B'.
epochs['A']
epochs['B']
# 2) The second solution utilizes mne.merge_events(). This function requires
# an mne event numpy array, a list of codes that you want to merge, and another
# code you wish to adapt for each code in the list. So if we pick all codes
# for 'B' and replace them with, for instance, 71, all 'B' epochs are
# represented by 71.
mne.merge_events(events, [71, 72, 73, 74, 75], 71, replace_events=True)
# As described above, there are also probes in the paradigm. These elicit
# a large P3, which is sensitive to expectancy violations, because subjects
# needed to adapt their behavior if an ambiguous cue was followed by an
# unexpected probe (Y) instead of the more frequent probe (X). There are
# four different types which should all be epoched: AX, BX, AY, and BY.
# In order to so, we need to epoch a sequence of events. An additional
# difficulty is that 'Y' is represented the same way 'B' is. There is multiple
# codes for 'Y' (77-81).
# The most starightforward solution, in my opinion, is to re-write
# the event array with a for loop and assign new codes. This can be
# written shorter, but for clarity's sake I'll be more detailed.
# The new assignment of event_ids shall be: {AX: 1, BX: 2, AY: 3, BY: 4}.
def test_cov_estimation_with_triggers():
"""Test estimation from raw with triggers
"""
tempdir = _TempDir()
raw = Raw(raw_fname, preload=False)
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(grad=10000e-13, mag=4e-12, eeg=80e-6, eog=150e-6)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
epochs = Epochs(raw, events_merged, 1234, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True,
reject=reject, preload=True)
cov = compute_covariance(epochs, keep_sample_mean=True)
cov_mne = read_cov(cov_km_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 0.005)
# Test with tmin and tmax (different but not too much)
cov_tmin_tmax = compute_covariance(epochs, tmin=-0.19, tmax=-0.01)
assert_true(np.all(cov.data != cov_tmin_tmax.data))
assert_true((linalg.norm(cov.data - cov_tmin_tmax.data, ord='fro')
/ linalg.norm(cov_tmin_tmax.data, ord='fro')) < 0.05)
# cov using a list of epochs and keep_sample_mean=True
epochs = [Epochs(raw, events, ev_id, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject)
for ev_id in event_ids]
cov2 = compute_covariance(epochs, keep_sample_mean=True)
assert_array_almost_equal(cov.data, cov2.data)
assert_true(cov.ch_names == cov2.ch_names)
# cov with keep_sample_mean=False using a list of epochs
cov = compute_covariance(epochs, keep_sample_mean=False)
cov_mne = read_cov(cov_fname)
assert_true(cov_mne.ch_names == cov.ch_names)
assert_true((linalg.norm(cov.data - cov_mne.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 0.005)
# test IO when computation done in Python
cov.save(op.join(tempdir, 'test-cov.fif')) # test saving
cov_read = read_cov(op.join(tempdir, 'test-cov.fif'))
assert_true(cov_read.ch_names == cov.ch_names)
assert_true(cov_read.nfree == cov.nfree)
assert_true((linalg.norm(cov.data - cov_read.data, ord='fro')
/ linalg.norm(cov.data, ord='fro')) < 1e-5)
# cov with list of epochs with different projectors
epochs = [Epochs(raw, events[:4], event_ids[0], tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject),
Epochs(raw, events[:4], event_ids[0], tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=False, reject=reject)]
# these should fail
assert_raises(ValueError, compute_covariance, epochs)
assert_raises(ValueError, compute_covariance, epochs, projs=None)
# these should work, but won't be equal to above
with warnings.catch_warnings(record=True) as w: # too few samples warning
warnings.simplefilter('always')
cov = compute_covariance(epochs, projs=epochs[0].info['projs'])
cov = compute_covariance(epochs, projs=[])
assert_true(len(w) == 2)
# test new dict support
epochs = Epochs(raw, events, dict(a=1, b=2, c=3, d=4), tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject)
compute_covariance(epochs)
def test_compute_covariance_auto_reg(rank):
"""Test automated regularization."""
raw = read_raw_fif(raw_fname, preload=True)
raw.resample(100, npad='auto') # much faster estimation
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
# we need a few channels for numerical reasons in PCA/FA
picks = pick_types(raw.info, meg='mag', eeg=False)[:10]
raw.pick_channels([raw.ch_names[pick] for pick in picks])
raw.info.normalize_proj()
epochs = Epochs(
raw, events_merged, 1234, tmin=-0.2, tmax=0,
baseline=(-0.2, -0.1), proj=True, reject=reject, preload=True)
epochs = epochs.crop(None, 0)[:5]
method_params = dict(factor_analysis=dict(iter_n_components=[3]),
pca=dict(iter_n_components=[3]))
covs = compute_covariance(epochs, method='auto',
method_params=method_params,
return_estimators=True, rank=rank)
# make sure regularization produces structured differencess
diag_mask = np.eye(len(epochs.ch_names)).astype(bool)
off_diag_mask = np.invert(diag_mask)
for cov_a, cov_b in itt.combinations(covs, 2):
if (cov_a['method'] == 'diagonal_fixed' and
# here we have diagnoal or no regularization.
cov_b['method'] == 'empirical' and rank == 'full'):
assert not np.any(cov_a['data'][diag_mask] ==
cov_b['data'][diag_mask])
# but the rest is the same
assert_array_equal(cov_a['data'][off_diag_mask],
cov_b['data'][off_diag_mask])
else:
# and here we have shrinkage everywhere.
assert not np.any(cov_a['data'][diag_mask] ==
cov_b['data'][diag_mask])
assert not np.any(cov_a['data'][diag_mask] ==
cov_b['data'][diag_mask])
logliks = [c['loglik'] for c in covs]
assert np.diff(logliks).max() <= 0 # descending order
methods = ['empirical', 'ledoit_wolf', 'oas', 'shrunk', 'shrinkage']
if rank == 'full':
methods.extend(['factor_analysis', 'pca'])
with catch_logging() as log:
cov3 = compute_covariance(epochs, method=methods,
method_params=method_params, projs=None,
return_estimators=True, rank=rank,
verbose=True)
log = log.getvalue().split('\n')
if rank is None:
assert ' Setting small MAG eigenvalues to zero (without PCA)' in log
assert 'Reducing data rank from 10 -> 7' in log
else:
assert 'Reducing' not in log
method_names = [cov['method'] for cov in cov3]
best_bounds = [-45, -35]
bounds = [-55, -45] if rank == 'full' else best_bounds
for method in set(methods) - {'empirical', 'shrunk'}:
this_lik = cov3[method_names.index(method)]['loglik']
assert bounds[0] < this_lik < bounds[1]
this_lik = cov3[method_names.index('shrunk')]['loglik']
assert best_bounds[0] < this_lik < best_bounds[1]
this_lik = cov3[method_names.index('empirical')]['loglik']
bounds = [-110, -100] if rank == 'full' else best_bounds
assert bounds[0] < this_lik < bounds[1]
assert_equal({c['method'] for c in cov3}, set(methods))
cov4 = compute_covariance(epochs, method=methods,
method_params=method_params, projs=None,
return_estimators=False, rank=rank)
assert cov3[0]['method'] == cov4['method'] # ordering
# invalid prespecified method
pytest.raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
pytest.raises(ValueError, compute_covariance, epochs, method='shrunk',
scalings=dict(misc=123))
def test_cov_estimation_with_triggers():
"""Test estimation from raw with triggers."""
tempdir = _TempDir()
raw = read_raw_fif(raw_fname)
raw.set_eeg_reference(projection=True).load_data()
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(grad=10000e-13, mag=4e-12, eeg=80e-6, eog=150e-6)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
epochs = Epochs(raw,
events_merged,
1234,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject,
preload=True)
cov = compute_covariance(epochs, keep_sample_mean=True)
_assert_cov(cov, read_cov(cov_km_fname))
# Test with tmin and tmax (different but not too much)
cov_tmin_tmax = compute_covariance(epochs, tmin=-0.19, tmax=-0.01)
assert_true(np.all(cov.data != cov_tmin_tmax.data))
err = (linalg.norm(cov.data - cov_tmin_tmax.data, ord='fro') /
linalg.norm(cov_tmin_tmax.data, ord='fro'))
assert_true(err < 0.05, msg=err)
# cov using a list of epochs and keep_sample_mean=True
epochs = [
Epochs(raw,
events,
ev_id,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject) for ev_id in event_ids
]
cov2 = compute_covariance(epochs, keep_sample_mean=True)
assert_array_almost_equal(cov.data, cov2.data)
assert_true(cov.ch_names == cov2.ch_names)
# cov with keep_sample_mean=False using a list of epochs
cov = compute_covariance(epochs, keep_sample_mean=False)
_assert_cov(cov, read_cov(cov_fname), nfree=False)
method_params = {'empirical': {'assume_centered': False}}
assert_raises(ValueError,
compute_covariance,
epochs,
keep_sample_mean=False,
method_params=method_params)
assert_raises(ValueError,
compute_covariance,
epochs,
keep_sample_mean=False,
method='factor_analysis')
# test IO when computation done in Python
cov.save(op.join(tempdir, 'test-cov.fif')) # test saving
cov_read = read_cov(op.join(tempdir, 'test-cov.fif'))
_assert_cov(cov, cov_read, 1e-5)
# cov with list of epochs with different projectors
epochs = [
Epochs(raw,
events[:1],
None,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True),
Epochs(raw,
events[:1],
None,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=False)
]
# these should fail
assert_raises(ValueError, compute_covariance, epochs)
assert_raises(ValueError, compute_covariance, epochs, projs=None)
# these should work, but won't be equal to above
with warnings.catch_warnings(record=True) as w: # too few samples warning
warnings.simplefilter('always')
cov = compute_covariance(epochs, projs=epochs[0].info['projs'])
cov = compute_covariance(epochs, projs=[])
assert_equal(len(w), 2)
# test new dict support
epochs = Epochs(raw,
events,
dict(a=1, b=2, c=3, d=4),
tmin=-0.01,
tmax=0,
proj=True,
reject=reject,
preload=True)
with warnings.catch_warnings(record=True): # samples
compute_covariance(epochs)
# projs checking
compute_covariance(epochs, projs=[])
assert_raises(TypeError, compute_covariance, epochs, projs='foo')
assert_raises(TypeError, compute_covariance, epochs, projs=['foo'])
def test_compute_covariance_auto_reg():
"""Test automated regularization."""
raw = read_raw_fif(raw_fname, preload=True)
raw.resample(100, npad='auto') # much faster estimation
events = find_events(raw, stim_channel='STI 014')
event_ids = [1, 2, 3, 4]
reject = dict(mag=4e-12)
# cov with merged events and keep_sample_mean=True
events_merged = merge_events(events, event_ids, 1234)
# we need a few channels for numerical reasons in PCA/FA
picks = pick_types(raw.info, meg='mag', eeg=False)[:10]
raw.pick_channels([raw.ch_names[pick] for pick in picks])
raw.info.normalize_proj()
epochs = Epochs(raw,
events_merged,
1234,
tmin=-0.2,
tmax=0,
baseline=(-0.2, -0.1),
proj=True,
reject=reject,
preload=True)
epochs = epochs.crop(None, 0)[:10]
method_params = dict(factor_analysis=dict(iter_n_components=[3]),
pca=dict(iter_n_components=[3]))
covs = compute_covariance(epochs,
method='auto',
method_params=method_params,
return_estimators=True)
# make sure regularization produces structured differencess
diag_mask = np.eye(len(epochs.ch_names)).astype(bool)
off_diag_mask = np.invert(diag_mask)
for cov_a, cov_b in itt.combinations(covs, 2):
if (cov_a['method'] == 'diagonal_fixed' and
# here we have diagnoal or no regularization.
cov_b['method'] == 'empirical'):
assert_true(not np.any(
cov_a['data'][diag_mask] == cov_b['data'][diag_mask]))
# but the rest is the same
assert_array_equal(cov_a['data'][off_diag_mask],
cov_b['data'][off_diag_mask])
else:
# and here we have shrinkage everywhere.
assert_true(not np.any(
cov_a['data'][diag_mask] == cov_b['data'][diag_mask]))
assert_true(not np.any(
cov_a['data'][diag_mask] == cov_b['data'][diag_mask]))
logliks = [c['loglik'] for c in covs]
assert_true(np.diff(logliks).max() <= 0) # descending order
methods = ['empirical', 'factor_analysis', 'ledoit_wolf', 'pca']
cov3 = compute_covariance(epochs,
method=methods,
method_params=method_params,
projs=None,
return_estimators=True)
assert_equal(set([c['method'] for c in cov3]), set(methods))
# invalid prespecified method
assert_raises(ValueError, compute_covariance, epochs, method='pizza')
# invalid scalings
assert_raises(ValueError,
compute_covariance,
epochs,
method='shrunk',
scalings=dict(misc=123))
i_primer_evento += 1 # imagen-neutro
# El primer evento es la primera imagen de analisis
# Imagen + neutro
for t in range(i_primer_evento, len(events), 2):
arr_t = []
arr_t.append(events[t][0] / 128) # Inicio
arr_t.append(events[t + 1][0] / 128) # Fin
arr_event_time.append(arr_t)
arr_event_merge.append(
events[t][2]) # Obtener ID de los eventos y agregar a la lista
# Cambiar ID de los eventos
events_raw_clean = mne.merge_events(
events_raw_clean, arr_event_merge,
2) # events = events_raw_clean | ids = arr_event_merge | new_id = 2
print('Eventos raw_clean modificados')
print(events_raw_clean)
print("Matriz de tiempos creada")
# Prueba con primer evento
run_ica('infomax',
arr_event_time[0][0],
arr_event_time[0][1],
fit_params=dict(extended=True))
# Prueba de segmentos por tiempo