def test_chunk_duration():
"""Test chunk_duration."""
# create dummy raw
raw = RawArray(data=np.empty([10, 10], dtype=np.float64),
info=create_info(ch_names=10, sfreq=1.),
first_samp=0)
raw.info['meas_date'] = 0
raw.set_annotations(Annotations(description='foo', onset=[0],
duration=[10], orig_time=None))
# expected_events = [[0, 0, 1], [0, 0, 1], [1, 0, 1], [1, 0, 1], ..
# [9, 0, 1], [9, 0, 1]]
expected_events = np.atleast_2d(np.repeat(range(10), repeats=2)).T
expected_events = np.insert(expected_events, 1, 0, axis=1)
expected_events = np.insert(expected_events, 2, 1, axis=1)
events, events_id = events_from_annotations(raw, chunk_duration=.5,
use_rounding=False)
assert_array_equal(events, expected_events)
# test chunk durations that do not fit equally in annotation duration
expected_events = np.zeros((3, 3))
expected_events[:, -1] = 1
expected_events[:, 0] = np.arange(0, 9, step=3)
events, events_id = events_from_annotations(raw, chunk_duration=3.)
assert_array_equal(events, expected_events)
def test_gdf_data():
"""Test reading raw GDF 1.x files."""
raw = read_raw_edf(gdf1_path + '.gdf', eog=None, misc=None, preload=True)
picks = pick_types(raw.info, meg=False, eeg=True, exclude='bads')
data, _ = raw[picks]
# Test Status is added as event
EXPECTED_EVS_ONSETS = raw._raw_extras[0]['events'][1]
evs, evs_id = events_from_annotations(raw)
assert_array_equal(evs[:, 0], EXPECTED_EVS_ONSETS)
assert evs_id == {'Unknown': 1}
# this .npy was generated using the official biosig python package
raw_biosig = np.load(gdf1_path + '_biosig.npy')
raw_biosig = raw_biosig * 1e-6 # data are stored in microvolts
data_biosig = raw_biosig[picks]
# Assert data are almost equal
assert_array_almost_equal(data, data_biosig, 8)
# Test for events
assert len(raw.annotations.duration == 963)
# gh-5604
assert raw.info['meas_date'] == DATE_NONE
def get_epochs(system):
"""Find, load and process the epoched data."""
cfg_local = get_cfg_local(system)
raw_data = get_raw_data(system)
if cfg_local['eventtype'] in raw_data.ch_names:
stim_channel = cfg_local['eventtype']
else:
stim_channel = 'STI 014'
if system == 'CNT':
events, event_id = mne.events_from_annotations(raw_data)
events[:, 0] = events[:, 0] + 1
else:
events = mne.find_events(raw_data, stim_channel=stim_channel,
shortest_event=1)
if isinstance(cfg_local['eventvalue'], np.ndarray):
event_id = list(cfg_local['eventvalue'].astype('int'))
else:
event_id = [int(cfg_local['eventvalue'])]
event_id = [id for id in event_id if id in events[:, 2]]
epochs = mne.Epochs(raw_data, events=events,
event_id=event_id,
tmin=-cfg_local['prestim'],
tmax=cfg_local['poststim'], baseline=None)
return epochs
def test_event_id_function_using_custom_function():
"""Test [unit_test] arbitrary function to create the ids."""
def _constant_id(*args, **kwargs):
return 42
description = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
expected_event_id = dict(zip(description, repeat(42)))
expected_events = np.repeat([[0, 0, 42]], len(description), axis=0)
raw = _create_annotation_based_on_descr(description)
events, event_id = events_from_annotations(raw, event_id=_constant_id)
assert_array_equal(events, expected_events)
assert event_id == expected_event_id
def test_events_from_annot_onset_alingment():
"""Test events and annotations onset are the same."""
raw = _raw_annot(meas_date=1, orig_time=1.5)
# sec 0 1 2 3
# raw . |--------XXXXXXXXX
# annot . |---XX
# raw.annot . |--------XX
# latency . 0 1 2
# . 0 0
assert raw.annotations.orig_time == 1
assert raw.annotations.onset[0] == 1
assert raw.first_samp == 10
event_latencies, event_id = events_from_annotations(raw)
assert event_latencies[0, 0] == 10
assert raw.first_samp == event_latencies[0, 0]
def test_event_id_function_default():
"""Test[unit_test] for event_id_function default in event_from_annotations.
The expected behavior is give numeric label for all those annotations not
present in event_id, starting at 1.
"""
# No event_id given
description = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
expected_event_id = dict(zip(description, range(1, 100)))
expected_events = np.array([[3, 3, 3, 3, 3, 3, 3],
[0, 0, 0, 0, 0, 0, 0],
[1, 2, 3, 4, 5, 6, 7]]).T
raw = _create_annotation_based_on_descr(description,
annotation_start_sampl=3,
duration=100)
events, event_id = events_from_annotations(raw, event_id=None)
assert_array_equal(events, expected_events)
assert event_id == expected_event_id
def read_gdf(filenames, subject, mint, maxt):
f1 = open("testdata/" + subject + "-left.csv", 'w', newline='')
f2 = open("testdata/" + subject + "-right.csv", 'w', newline='')
wleft = csv.writer(f1)
wright = csv.writer(f2)
lefthands = []
righthands = []
for filename in filenames:
raw = mne.io.read_raw_gdf(filename)
events_A, event_id_A = mne.events_from_annotations(raw)
#print(event_id_A)
# rejected 되어야 하는 event 찾기
myrejectid = np.where(events_A[:, 2] == event_id_A['1023'])
myjejectedevent = []
for i in myrejectid:
myjejectedevent.append(i + 1)
# # rejected trials 제거
events = []
for j in range(0, events_A.shape[0]):
if j in myjejectedevent[0]:
print("제거됨")
else:
events.append(events_A[j])
events = np.asarray(events)
picks = mne.pick_channels(raw.info["ch_names"],
["EEG:C3", "EEG:Cz", "EEG:C4"])
# #큐 사인 이후 0.5에서 3.5초 데이터 저장
tmin = mint
tmax = maxt
event_ids = dict(handsleft=event_id_A['769'],
handsright=event_id_A['770'])
epochs = mne.Epochs(raw,
events,
event_ids,
tmin,
tmax,
picks=picks,
baseline=None,
preload=True)
# 파일에 저장하기 // 3초 이므로 250*3 ==> 750개 씩 저장
for i in range(0, epochs['handsleft'].get_data().shape[0]):
data = epochs['handsleft'].get_data()[i].T
count = 0
for j in data:
if count >= 750:
break
else:
count = count + 1
wleft.writerow(np.asarray(j))
for i in range(0, epochs['handsright'].get_data().shape[0]):
data = epochs['handsright'].get_data()[i].T
count = 0
for j in data:
if count >= 750:
break
else:
count = count + 1
wright.writerow(np.asarray(np.asarray(j)))
f1.close()
f2.close()
def get_data(subj_num=FNAMES, l_freq=13, h_freq=55, tmin=0.0, tmax=4.0):
""" Extract EEG time series and class labels from edf files
All T1, T2 events have duration 4.1 or 4.2 s, use 0~4s for epoching
:param subj_num:
:param l_freq: low frequency for bandpass filter
:param h_freq: high frequency for bandpass filter
:param tmin:
:param tmax:
:return: Xs, ys: list (Ni, nc, T), (Ni, )
"""
run_type_0 = ['02']
run_type_1 = ['04', '08', '12']
run_type_2 = ['06', '10', '14']
run_types = run_type_0 + run_type_1 + run_type_2
# fixed parameters
nc = 64 # number of channels
sfreq = 160
n_type0 = 22 # each subject has 21~24 fist or feet events, set to use the same number of data points for baseline
event_id = {'T1': 2, 'T2': 3} # T0:0 rest event, not interested
T = round(tmax * sfreq)
print('Sub, (N, nc, T)')
Xs, ys = [], []
# Iterate over subjects: S001, S002, S003 ...
for i, subj in enumerate(subj_num):
freq_flag = False
# Get file names for motor imagery data
fnames = glob.glob(os.path.join(PATH, subj, subj + 'R*.edf'))
fnames = sorted([name for name in fnames if name[-6:-4] in run_types])
subject_trials, subject_labels = [], []
# Iterate over subject's experiment runs
for i, fname in enumerate(fnames):
run = fname[-6:-4]
# Load data into MNE raw object
raw = mne.io.read_raw_edf(fname, preload=True, verbose=False)
if raw.info['sfreq'] != 160:
freq_flag = True
print('{} is sampled at {}Hz so will be excluded.'.format(
subj, raw.info['sfreq']))
break
# By default picks all 64 channels
picks = mne.pick_types(raw.info, eeg=True)
assert len(picks) == nc
# Apply notch filter and bandpass filter
raw.notch_filter([60.])
raw.filter(l_freq=l_freq,
h_freq=h_freq,
picks=picks,
method='iir',
verbose=False)
if run == '02':
# Baseline, eye closed
# There is only the rest event, randomly slice n_type0=22 snippets of length T for this class
data = raw.get_data() * 1e6
X = np.zeros((n_type0, nc, T))
y = np.zeros((n_type0, ), dtype=int) # eye closed
for i in range(n_type0):
offset = np.random.randint(0, data.shape[1] - T)
X[i] = data[:, offset:offset + T]
else:
# Epoching
events, _ = mne.events_from_annotations(raw, verbose=False)
epochs = mne.Epochs(
raw,
events=events,
event_id=event_id,
tmin=tmin,
tmax=tmax,
baseline=None,
# reject={'eeg': reject_threshold*1e-6},
picks=picks,
preload=True,
verbose=False,
on_missing='warning')
# Data
X = epochs.get_data(
) * 1e6 # converts to uV, the L503 in epochs.py makes T=641
X = X[:, :, :-1] # make T = sfeq * (tmax-tmin)
# specific treatment of classes/labels
y = epochs.events[:, -1]
if run in run_type_1:
y[y == 2] = 1 # left fist
y[y == 3] = 2 # right fist
else: # run_type_2
y[y == 3] = 4 # both feet
y[y == 2] = 3 # both fists
subject_trials.append(X)
subject_labels.append(y)
if freq_flag:
continue
subject_trials = np.concatenate(subject_trials,
axis=0) # (None, nc=64, T=640)
subject_labels = np.concatenate(subject_labels)
# print({i: sum(subject_labels == i) for i in range(5)})
print(subj, subject_trials.shape)
Xs.append(subject_trials)
ys.append(subject_labels)
return Xs, ys
def test_psd_class():
mne_version = version.parse(mne.__version__)
# get data
data_dir = _get_test_data_dir()
download_test_data()
# read data
raw_fname = op.join(data_dir, 'DiamSar_023_rest_raw.fif')
raw = mne.io.read_raw_fif(raw_fname, preload=True)
# compute psd
event_id = {'S 11': 11}
events, _ = mne.events_from_annotations(raw, event_id=event_id)
psd = compute_psd(raw, tmin=0.5, tmax=20.5, winlen=2.,
step=0.5, events=events, event_id=[11])
# make sure plotting does not error
if mne_version > version.parse('0.18'):
psd.plot(dB=False, fmax=40, show=False)
psd.plot(fmax=40, average=True, show=False)
else:
with pytest.raises(ImportError):
psd.plot(dB=False, fmax=40, show=False)
topo = psd.plot_topomap(freqs=[11], show=False)
assert isinstance(topo.axes, plt.Axes)
topo = psd.plot_topomap(freqs=[6, 11], show=False)
assert len(topo.axes) == 2
topo = psd.plot_topomap(freqs=[8, 10, 12], show=False)
assert len(topo.axes) == 3
plt.close('all')
# data shape checks
assert len(psd.ch_names) == len(raw.ch_names)
assert psd.data.shape[-1] == len(psd.freqs)
assert psd.data.shape[-2] == len(raw.ch_names)
psd_orig = psd.copy()
psd2 = psd.average()
assert (psd.data == psd2.data).all()
psd.crop(fmin=10, fmax=15)
assert (psd.freqs[0] - 10) < 0.5
assert (psd.freqs[-1] - 15) < 0.5
# test for (deep)copy
psd2 = psd.copy()
psd2.data[0, 0] = 23
assert not (psd._data[0, 0] == 23)
# test to_evoked
psd2 = psd_orig.copy().average()
evoked = psd_orig.to_evoked()
assert isinstance(evoked, mne.Evoked)
assert (evoked.data == psd2.data).all()
# test plot_joint()
psd_orig.plot_joint()
plt.close('all')
# psd with Epochs
# ---------------
epochs = mne.Epochs(raw, events, event_id, tmin=0., tmax=23.,
baseline=None, preload=True)
psd_epo = compute_psd(epochs, tmin=0.5, tmax=20.5, winlen=2.,
step=0.5, events=events, event_id=[11])
if mne_version > version.parse('0.18'):
psd_epo.plot(show=False)
psd_avg = psd_epo.copy().average()
assert psd_epo.data.ndim == 3
assert psd_avg.data.ndim == 2
arr = np.random.randn(23, 48)
with pytest.raises(TypeError, match='works only with Raw or Epochs'):
psd_epo = compute_psd(arr, tmin=0.5, tmax=20.5, winlen=2.,
step=0.5, events=events, event_id=[11])
# psd construction
with pytest.raises(ValueError, match='has to be 3d'):
use_data = psd_epo.data[..., np.newaxis]
psd = PSD(use_data, psd_epo.freqs, raw.info)
with pytest.raises(ValueError, match='or 2d'):
use_data = psd_epo.data[0, :, 0]
psd = PSD(use_data, psd_epo.freqs, raw.info)
# test for __repr__
psd_epo2 = psd_epo.copy().crop(fmin=8, fmax=12)
rpr = '<borsar.freq.PSD (2 epochs, 64 channels, 9 frequencies), 8 - 12 Hz>'
assert str(psd_epo2) == rpr
# test chaining
psd_epo3 = psd_epo.copy().crop(fmin=8, fmax=12).average()
rpr = '<borsar.freq.PSD (64 channels, 9 frequencies), 8 - 12 Hz>'
assert str(psd_epo3) == rpr
# test channel picking
psd2 = psd_epo.copy().pick_channels(['Fz', 'Pz'])
assert psd2.data.shape[1] == 2
# missing:
# compute_rest_psd when events is None
# Epochs with metadata
# --------------------
# read data
epochs_fname = op.join(data_dir, 'GabCon-48_epo.fif')
epochs = mne.read_epochs(epochs_fname, preload=True)
assert epochs.metadata is not None
psd = compute_psd(epochs, tmin=0.5, tmax=1.)
assert psd.data.ndim == 3
assert psd.data.shape[0] == epochs._data.shape[0]
psd_slow = psd['RT > 0.65']
epochs_slow = epochs['RT > 0.65']
# TODO: later use len(psd_slow) here
assert len(epochs_slow) == psd_slow.data.shape[0]
update_path=False)
# Load each of the files
raws = [
mne.io.read_raw_edf(path,
preload=True,
stim_channel="auto",
verbose="WARNING") for path in physionet_paths
]
# Concatenate them
raw = concatenate_raws(raws)
del raws
# Find the events in this dataset
events, _ = mne.events_from_annotations(raw)
# Use only EEG channels
picks = mne.pick_types(raw.info, meg=False, eeg=True, exclude="bads")
# Extract trials, only using EEG channels
epochs = mne.Epochs(
raw,
events,
event_id=dict(hands_or_left=2, feet_or_right=3),
tmin=1,
tmax=4.1,
proj=False,
picks=picks,
baseline=None,
preload=True,
def test_annotations_from_events():
"""Test events to annotations conversion."""
raw = read_raw_fif(fif_fname)
events = mne.find_events(raw)
# 1. Automatic event description
# -------------------------------------------------------------------------
annots = annotations_from_events(events, raw.info['sfreq'],
first_samp=raw.first_samp,
orig_time=None)
assert len(annots) == events.shape[0]
# Convert back to events
raw.set_annotations(annots)
events_out, _ = events_from_annotations(raw, event_id=int)
assert_array_equal(events, events_out)
# 2. Explicit event mapping
# -------------------------------------------------------------------------
event_desc = {1: 'one', 2: 'two', 3: 'three', 32: None}
annots = annotations_from_events(events, sfreq=raw.info['sfreq'],
event_desc=event_desc,
first_samp=raw.first_samp,
orig_time=None)
assert np.all([a in ['one', 'two', 'three'] for a in annots.description])
assert len(annots) == events[events[:, 2] <= 3].shape[0]
# 3. Pass list
# -------------------------------------------------------------------------
event_desc = [1, 2, 3]
annots = annotations_from_events(events, sfreq=raw.info['sfreq'],
event_desc=event_desc,
first_samp=raw.first_samp,
orig_time=None)
assert np.all([a in ['1', '2', '3'] for a in annots.description])
assert len(annots) == events[events[:, 2] <= 3].shape[0]
# 4. Try passing callable
# -------------------------------------------------------------------------
event_desc = lambda d: 'event{}'.format(d) # noqa:E731
annots = annotations_from_events(events, sfreq=raw.info['sfreq'],
event_desc=event_desc,
first_samp=raw.first_samp,
orig_time=None)
assert np.all(['event' in a for a in annots.description])
assert len(annots) == events.shape[0]
# 5. Pass numpy array
# -------------------------------------------------------------------------
event_desc = np.array([[1, 2, 3], [1, 2, 3]])
with pytest.raises(ValueError, match='event_desc must be 1D'):
annots = annotations_from_events(events, sfreq=raw.info['sfreq'],
event_desc=event_desc,
first_samp=raw.first_samp,
orig_time=None)
with pytest.raises(ValueError, match='Invalid type for event_desc'):
annots = annotations_from_events(events, sfreq=raw.info['sfreq'],
event_desc=1,
first_samp=raw.first_samp,
orig_time=None)
event_desc = np.array([1, 2, 3])
annots = annotations_from_events(events, sfreq=raw.info['sfreq'],
event_desc=event_desc,
first_samp=raw.first_samp,
orig_time=None)
assert np.all([a in ['1', '2', '3'] for a in annots.description])
assert len(annots) == events[events[:, 2] <= 3].shape[0]
fig = raw_haemo.plot_psd(average=True)
fig.suptitle('After filtering', weight='bold', size='x-large')
fig.subplots_adjust(top=0.88)
# %%
# Extract epochs
# --------------
#
# Now that the signal has been converted to relative haemoglobin concentration,
# and the unwanted heart rate component has been removed, we can extract epochs
# related to each of the experimental conditions.
#
# First we extract the events of interest and visualise them to ensure they are
# correct.
events, event_dict = mne.events_from_annotations(raw_haemo)
fig = mne.viz.plot_events(events, event_id=event_dict,
sfreq=raw_haemo.info['sfreq'])
fig.subplots_adjust(right=0.7) # make room for the legend
# %%
# Next we define the range of our epochs, the rejection criteria,
# baseline correction, and extract the epochs. We visualise the log of which
# epochs were dropped.
reject_criteria = dict(hbo=80e-6)
tmin, tmax = -5, 15
epochs = mne.Epochs(raw_haemo, events, event_id=event_dict,
tmin=tmin, tmax=tmax,
'70': 5,
'71': 6,
'72': 7,
'73': 8,
'74': 9,
'75': 10,
'76': 11,
'77': 12,
'78': 13,
'79': 14,
'80': 15,
'81': 16,
'EDGE boundary': 17
}
# extract events
events = events_from_annotations(raw, event_id=ev_id, regexp=None)
###############################################################################
# 3) Recode events into respective conditions and add information about valid
# and invalid responses
# copy of events
new_evs = events[0].copy()
# global variables
trial = 0
broken = []
sfreq = raw.info['sfreq']
block_end = events[0][events[0][:, 2] == 17, 0] / sfreq
# place holders for results
block = []
# =============================================================================
ica = mne.preprocessing.ICA( n_components=20, random_state=97, method='fastica')
ica.fit(raw)
if plot_steps_preproc==True:
ica.plot_components()
ica.exclude=[0, 1 ,2]
ica.apply(raw)
# Interpolate
raw.interpolate_bads()
# Add Triggers
# =============================================================================
triggers = mne.read_annotations(raw_dir+'\\'+eeg_partic+'.vmrk')
raw.set_annotations(triggers)
events, event_ids = mne.events_from_annotations(raw)
if plot_steps_preproc==True:
mne.viz.plot_events(events)
# Identify unimodal auditory (16 preceded by 1)
for this_event in range(1,len(events)):
if events[this_event][2]==16 and events[this_event-1][2]==1:
events[this_event][2]=161
# Epoch (& Reject)
# =============================================================================
reject_criteria=dict(eeg=50e-6)
epochs = mne.Epochs(raw, events, event_id=161, tmin=-0.1, tmax=0.5,baseline=(-0.1, 0),preload=True,reject=reject_criteria)
if plot_steps_preproc==True:
epochs.plot_image()
epochs.plot_topo_image()
def format_session(list_paths,
save_path,
extraction_settings,
preprocess_settings,
marker_encodings,
is_game,
balance=False):
session_eeg, session_labels = [], []
assert len(list_paths) > 0, 'No subsession to format'
logging.info(f'Decoding: {extraction_settings["marker_decodings"]}')
for subsession_path in list_paths:
if subsession_path.suffix == '.vhdr':
raw = load_vhdr(subsession_path, **preprocess_settings)
# Extract events in format (ts, ?, marker_id)
events, _ = mne.events_from_annotations(raw, verbose=False)
eeg, labels = extract_data(raw,
events,
**extraction_settings,
ignore_multi=is_game)
elif subsession_path.suffix == '.h5':
raw, events = load_h5(subsession_path, **preprocess_settings)
eeg, labels = extract_data(raw,
events,
**extraction_settings,
ignore_multi=is_game)
# Stack trials
if len(session_eeg) == 0:
session_eeg = eeg
session_labels = labels
else:
session_eeg = np.vstack([session_eeg, eeg])
session_labels = np.concatenate([session_labels, labels])
# Balance rest sessions
if balance:
count_dict = dict(Counter(session_labels))
rest_marker = extraction_settings['marker_decodings']['Rest']
n_delete = count_dict[rest_marker] - min(count_dict.values())
# Randomly pick rest ids to delete
rest_ids = np.where(session_labels == rest_marker)[0]
ids_to_remove = np.random.choice(rest_ids, n_delete, replace=False)
session_eeg = np.delete(session_eeg, ids_to_remove, axis=0)
session_labels = np.delete(session_labels, ids_to_remove, axis=0)
# Remap labels
session_labels = np.array([marker_encodings[l] for l in session_labels])
logging.info(f'Encoding: {marker_encodings}')
logging.info(f'Output labels: {Counter(session_labels)}')
# Save as .npy file
info = raw.info
save_folder = f'formatted'
save_folder += '_filt' if preprocess_settings['preprocess'] else '_raw'
save_folder += f"_{int(info['sfreq'])}Hz"
save_folder += '_game' if is_game else ''
save_session(session_eeg, session_labels, info, save_path, save_folder)
template=(0, 0),
threshold=0.85,
label='blink_up',
plot=False)
corrmap(icas=[temp_icas[0], ica],
template=(0, 7),
threshold=0.85,
label='blink_side',
plot=False)
###############################################################################
# 4) Create summary plots to show signal correction on main experimental
# condition
# create target epochs
target_evs = events_from_annotations(raw, regexp='(11)|(12)|(21)|(22)')[0]
target_epo = Epochs(raw,
target_evs,
tmin=-1.5,
tmax=1.5,
reject_by_annotation=True,
proj=False,
preload=True)
target_epo.apply_baseline(baseline=(-0.3, -0.05))
target_evo = target_epo.average()
# loop over identified "bad" components
bad_components = []
for label in ica.labels_:
bad_components.extend(ica.labels_[label])
def test_experiment_class():
# 5,6,7,10,13,14 are codes for executed and imagined hands/feet
subject_id = 1
event_codes = [5, 6, 9, 10, 13, 14]
# This will download the files if you don't have them yet,
# and then return the paths to the files.
physionet_paths = mne.datasets.eegbci.load_data(subject_id, event_codes)
# Load each of the files
parts = [
mne.io.read_raw_edf(path,
preload=True,
stim_channel='auto',
verbose='WARNING') for path in physionet_paths
]
# Concatenate them
raw = concatenate_raws(parts)
# Find the events in this dataset
events, _ = mne.events_from_annotations(raw)
# Use only EEG channels
eeg_channel_inds = mne.pick_types(raw.info,
meg=False,
eeg=True,
stim=False,
eog=False,
exclude='bads')
# Extract trials, only using EEG channels
epoched = mne.Epochs(raw,
events,
dict(hands=2, feet=3),
tmin=1,
tmax=4.1,
proj=False,
picks=eeg_channel_inds,
baseline=None,
preload=True)
# Convert data from volt to millivolt
# Pytorch expects float32 for input and int64 for labels.
X = (epoched.get_data() * 1e6).astype(np.float32)
y = (epoched.events[:, 2] - 2).astype(np.int64) # 2,3 -> 0,1
train_set = SignalAndTarget(X[:60], y=y[:60])
test_set = SignalAndTarget(X[60:], y=y[60:])
train_set, valid_set = split_into_two_sets(train_set,
first_set_fraction=0.8)
# Set if you want to use GPU
# You can also use torch.cuda.is_available() to determine if cuda is available on your machine.
cuda = False
set_random_seeds(seed=20170629, cuda=cuda)
# This will determine how many crops are processed in parallel
input_time_length = 450
n_classes = 2
in_chans = train_set.X.shape[1]
# final_conv_length determines the size of the receptive field of the ConvNet
model = ShallowFBCSPNet(in_chans=in_chans,
n_classes=n_classes,
input_time_length=input_time_length,
final_conv_length=12).create_network()
to_dense_prediction_model(model)
if cuda:
model.cuda()
optimizer = optim.Adam(model.parameters())
# determine output size
test_input = np_to_var(
np.ones((2, in_chans, input_time_length, 1), dtype=np.float32))
if cuda:
test_input = test_input.cuda()
out = model(test_input)
n_preds_per_input = out.cpu().data.numpy().shape[2]
print("{:d} predictions per input/trial".format(n_preds_per_input))
# Iterator is used to iterate over datasets both for training
# and evaluation
iterator = CropsFromTrialsIterator(batch_size=32,
input_time_length=input_time_length,
n_preds_per_input=n_preds_per_input)
# Loss function takes predictions as they come out of the network and the targets
# and returns a loss
def loss_function(preds, targets):
return F.nll_loss(th.mean(preds, dim=2, keepdim=False), targets)
# Could be used to apply some constraint on the models, then should be object
# with apply method that accepts a module
model_constraint = None
# Monitors log the training progress
monitors = [
LossMonitor(),
MisclassMonitor(col_suffix='sample_misclass'),
CroppedTrialMisclassMonitor(input_time_length),
RuntimeMonitor(),
]
# Stop criterion determines when the first stop happens
stop_criterion = MaxEpochs(4)
exp = Experiment(model,
train_set,
valid_set,
test_set,
iterator,
loss_function,
optimizer,
model_constraint,
monitors,
stop_criterion,
remember_best_column='valid_misclass',
run_after_early_stop=True,
batch_modifier=None,
cuda=cuda)
# need to setup python logging before to be able to see anything
logging.basicConfig(format='%(asctime)s %(levelname)s : %(message)s',
level=logging.DEBUG,
stream=sys.stdout)
exp.run()
compare_df = pd.read_csv(
StringIO(
'train_loss,valid_loss,test_loss,train_sample_misclass,valid_sample_misclass,'
'test_sample_misclass,train_misclass,valid_misclass,test_misclass\n'
'14.167170524597168,13.910758018493652,15.945781707763672,0.5,0.5,'
'0.5333333333333333,0.5,0.5,0.5333333333333333\n'
'1.1735659837722778,1.4342904090881348,1.8664429187774658,0.4629567736185384,'
'0.5120320855614973,0.5336007130124778,0.5,0.5,0.5333333333333333\n'
'1.3168460130691528,1.60431969165802,1.9181344509124756,0.49298128342245995,'
'0.5109180035650625,0.531729055258467,0.5,0.5,0.5333333333333333\n'
'0.8465543389320374,1.280307412147522,1.439755916595459,0.4413435828877005,'
'0.5461229946524064,0.5283422459893048,0.47916666666666663,0.5,'
'0.5333333333333333\n0.6977059841156006,1.1762590408325195,1.2779350280761719,'
'0.40290775401069523,0.588903743315508,0.5307486631016043,0.5,0.5,0.5\n'
'0.7934166193008423,1.1762590408325195,1.2779350280761719,0.4401069518716577,'
'0.588903743315508,0.5307486631016043,0.5,0.5,0.5\n0.5982189178466797,'
'0.8581563830375671,0.9598925113677979,0.32032085561497325,0.47660427807486627,'
'0.4672905525846702,0.31666666666666665,0.5,0.4666666666666667\n0.5044312477111816,'
'0.7133197784423828,0.8164243102073669,0.2591354723707665,0.45699643493761144,'
'0.4393048128342246,0.16666666666666663,0.41666666666666663,0.43333333333333335\n'
'0.4815250039100647,0.6736412644386292,0.8016976714134216,0.23413547237076648,'
'0.39505347593582885,0.42932263814616756,0.15000000000000002,0.41666666666666663,0.5\n'
))
for col in compare_df:
np.testing.assert_allclose(np.array(compare_df[col]),
exp.epochs_df[col],
rtol=1e-3,
atol=1e-4)
def preproc(self, event_dict, baseline_start, stim_dur, montage, out_dir='preproc', subjects='all', tasks='all',
hp_cutoff=1, lp_cutoff=50, line_noise=60, seed=42, eog_chan='none'):
'''Preprocesses a single EEG file. Assigns a list of epoched data to Dataset instance,
where each entry in the list is a subject with concatenated task data. Here is the basic
structure of the preprocessing workflow:
- Set the montage
- Band-pass filter (high-pass filter by default)
- Automatically detect bad channels
- Notch filter out line-noise
- Reference data to average of all EEG channels
- Automated removal of eye-related artifacts using ICA
- Spherical interpolation of detected bad channels
- Extract events and epoch the data accordingly
- Align the events based on type (still need to implement this!)
- Create a list of epoched data, with subject as the element concatenated across tasks
Parameters
----------
event_dict: dict
Maps integers to semantic labels for events within the experiment
baseline_start: int or float
Specify start of the baseline period (in seconds)
stim_dur: int or float
Stimulus duration (in seconds)
Note: may need to make more general to allow various durations
montage: mne.channels.montage.DigMontage
Maps sensor locations to coordinates
subjects: list or 'all'
Specify which subjects to iterate through
tasks: list or 'all'
Specify which tasks to iterate through
hp_cutoff: int or float
The low frequency bound for the highpass filter in Hz
line_noise: int or float
The frequency of electrical noise to filter out in Hz
seed: int
Set the seed for replicable results
eog_chan: str
If there are no EOG channels present, select an EEG channel
near the eyes for eye-related artifact detection
'''
missing = [] # initialize missing file list
subj_iter = self.gen_iter(subjects, self.n_subj) # get subject iterator
task_iter = self.gen_iter(tasks, self.n_task) # get task iterator
# Iterate through subjects (initialize subject epoch list)
epochs_subj = []
for subj in subj_iter:
# Iterate through tasks (initialize within-subject task epoch list)
epochs_task = []
for task in task_iter:
# Specify the file format
self.get_file_format(subj, task)
try: # Handles missing files
raw = self.wget_raw_edf() # read
except:
print(f'---\nThis file does not exist: {self.file_path}\n---')
# Need to write the missing file list out
missing.append(self.file_path)
break
# Standardize montage
mne.datasets.eegbci.standardize(raw)
# Set montage and strip channel names of "." characters
raw.set_montage(montage)
raw.rename_channels(lambda x: x.strip('.'))
# Apply high-pass filter
np.random.seed(seed)
raw.filter(l_freq=hp_cutoff, h_freq=lp_cutoff, picks=['eeg', 'eog'])
# Instantiate NoisyChannels object
noise_chans = NoisyChannels(raw, do_detrend=False)
# Detect bad channels through multiple methods
noise_chans.find_bad_by_nan_flat()
noise_chans.find_bad_by_deviation()
noise_chans.find_bad_by_SNR()
# Set the bad channels in the raw object
raw.info['bads'] = noise_chans.get_bads()
print(f'Bad channels detected: {noise_chans.get_bads()}')
# Define the frequencies for the notch filter (60Hz and its harmonics)
#notch_filt = np.arange(line_noise, raw.info['sfreq'] // 2, line_noise)
# Apply notch filter
#print(f'Apply notch filter at {line_noise} Hz and its harmonics')
#raw.notch_filter(notch_filt, picks=['eeg', 'eog'], verbose=False)
# Reference to the average of all the good channels
# Automatically excludes raw.info['bads']
raw.set_eeg_reference(ref_channels='average')
# Instantiate ICA object
ica = mne.preprocessing.ICA(max_iter=1000)
# Run ICA
ica.fit(raw)
# Find which ICs match the EOG pattern
if eog_chan == 'none':
eog_indices, eog_scores = ica.find_bads_eog(raw, verbose=False)
else:
eog_indices, eog_scores = ica.find_bads_eog(raw, eog_chan, verbose=False)
# Apply the IC blink removals (if any)
ica.apply(raw, exclude=eog_indices)
print(f'Removed IC index {eog_indices}')
# Interpolate bad channels
raw.interpolate_bads()
# Specify pre-processing directory
preproc_dir = Path(f'{out_dir}/ {subj}')
# If directory does not exist, one will be created.
if not os.path.isdir(preproc_dir):
os.makedirs(preproc_dir)
# raw.save(Path(preproc_dir, f'subj{subj}_task{task}_raw.fif'),
# overwrite=True)
# Find events
events = mne.events_from_annotations(raw)[0]
# Epoch the data
preproc_epoch = mne.Epochs(raw, events, tmin=baseline_start, tmax=stim_dur,
event_id=event_dict, event_repeated='error',
on_missing='ignore', preload=True)
# Equalize event counts
preproc_epoch.equalize_event_counts(event_dict.keys())
# Rearrange and align the epochs
align = [preproc_epoch[i] for i in event_dict.keys()]
align_epoch = mne.concatenate_epochs(align)
# Add to epoch list
epochs_task.append(align_epoch)
# Assuming some data exists for a subject
# Concatenate epochs within subject
concat_epoch = mne.concatenate_epochs(epochs_task)
epochs_subj.append(concat_epoch)
# Attaches a list with each entry corresponding to epochs for a subject
self.epoch_list = epochs_subj
fig.subplots_adjust(top=0.88)
###############################################################################
# Extract epochs
# --------------
#
# Now that the signal has been converted to relative haemoglobin concentration,
# and the unwanted heart rate component has been removed, we can extract epochs
# related to each of the experimental conditions.
#
# First we extract the events of interest and visualise them to ensure they are
# correct.
events, _ = mne.events_from_annotations(raw_haemo,
event_id={
'1.0': 1,
'2.0': 2,
'3.0': 3
})
event_dict = {'Control': 1, 'Tapping/Left': 2, 'Tapping/Right': 3}
fig = mne.viz.plot_events(events,
event_id=event_dict,
sfreq=raw_haemo.info['sfreq'])
fig.subplots_adjust(right=0.7) # make room for the legend
###############################################################################
# Next we define the range of our epochs, the rejection criteria,
# baseline correction, and extract the epochs. We visualise the log of which
# epochs were dropped.
reject_criteria = dict(hbo=80e-6)
tmin, tmax = -5, 15
'EEG 022': 'P4',
'EEG 023': 'P8',
'EEG 024': 'PO7',
'EEG 025': 'PO3',
'EEG 026': 'POz',
'EEG 027': 'PO4',
'EEG 028': 'PO8',
'EEG 029': 'O1',
'EEG 030': 'Oz',
'EEG 031': 'O2'
}
raw.rename_channels(mapping)
raw.set_channel_types({"EOG1": 'eog', "EOG2": 'eog'})
raw.set_montage('standard_1020') # Standard placement of channels
events = mne.events_from_annotations(raw, event_id)[0]
"""
EEGLab Data set with the following specifications
- 32 channels pr frame
- 30504 frames pr epoch
- 1 epoch
- 154 events (square and rt)
- 128 Hz sample rate
- 0 - 238,305 sec epoch
"""
# =============================================================================
# Dividing the EEG Data into Epochs
# =============================================================================
epochs = mne.Epochs(raw,
events=events,
tmin=-1,
###############################################################################
# avoid classification of evoked responses by using epochs that start 1s after
# cue onset.
tmin, tmax = 1., 3.
event_id = dict(hands=2, feet=3)
subject = 1
runs = [6, 10, 14] # motor imagery: hands vs feet
raw_files = [
read_raw_edf(f, preload=True, verbose=False)
for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)
events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))
picks = pick_types(raw.info,
meg=False,
eeg=True,
stim=False,
eog=False,
exclude='bads')
# Read epochs (train will be done only between 1 and 2s)
# Testing will be done with a running classifier
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=True,
import mne
import numpy as np
import matplotlib.pyplot as plt
data_path = 'C:/Users/oo/Desktop/EEG/Hypnosis/Data'
fname = data_path + '/Hypnosis_S1_POST_ACTIVE_a.set'
data = mne.io.read_raw_eeglab(fname)
data.plot()
# events=mne.find_events(data)
events = mne.events_from_annotations(data) #소리 들려주는거
epochs = mne.Epochs(data,events[0],tmin=-0.2, tmax=0.5) #신호발생 전후 구간
print(epochs)
print(epochs.event_id)
event_dict = {'dev': 1, 'std': 2} #dev - 높은소리?,60개 std 기본소리,420개
epochs = mne.Epochs(data, events[0], tmin=-0.2, tmax=0.5,
event_id=event_dict, preload=True)
del data #원래 데이터 삭제 -용량이 크니까
epochs.plot(n_epochs=10);
#%%
print(epochs['dev'])
print(epochs['std'])
#evoked = epochs.average() # 480개 평균
def _get_single_subject_data(self, dataset, subject_id, verbose=False):
"""Return data in micro-volt.
"""
if not self.is_valid(dataset):
raise TypeError(
"Dataset {:s} is not valid for the current paradigm. Check your events and channels settings"
.format(dataset.dataset_code))
# data = dataset.get_data(subjects)
# # events, interval checking
used_events, used_intervals = self._map_events_intervals(dataset)
Xs = {}
ys = {}
metas = {}
data = dataset.get_data([subject_id])
for subject, sessions in data.items():
for session, runs in sessions.items():
for run, raw in runs.items():
# do raw hook either self-implemented or dataset inherited
caches = {}
if self._raw_hook:
raw, caches = self._raw_hook(raw, caches)
elif hasattr(dataset, 'raw_hook'):
raw, caches = dataset.raw_hook(raw, caches)
# pick selected channels by order
channels = dataset.channels if self.select_channels is None else self.select_channels
# picks = mne.pick_channels(raw.ch_names, channels, ordered=True)
picks = pick_channels(raw.ch_names, channels, ordered=True)
# find available 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,
initial_event=True)
else:
# convert event_id to its number type instead of default auto-renaming in 0.19.2
events, _ = mne.events_from_annotations(
raw, event_id=(lambda x: int(x)))
for event_name in used_events.keys():
# mne.pick_events returns any matching events in include
# only raise Runtime Error when nothing is found
# then we just skip this event
try:
selected_events = mne.pick_events(
events, include=used_events[event_name])
except RuntimeError:
continue
# transform Raw to Epochs
epochs = mne.Epochs(
raw,
selected_events,
event_id={event_name: used_events[event_name]},
event_repeated='drop',
tmin=used_intervals[event_name][0],
tmax=used_intervals[event_name][1] -
1. / raw.info['sfreq'],
picks=picks,
proj=False,
baseline=None,
preload=True)
# skip invalid time intervals
if len(epochs) == 0:
continue
# do epochs hook
if self._epochs_hook:
epochs, caches = self._epochs_hook(epochs, caches)
elif hasattr(dataset, 'epochs_hook'):
epochs, caches = dataset.epochs_hook(
epochs, caches)
# FIXME: is this resample reasonable?
if self.srate:
# as MNE suggested, decimate after extract epochs
# low-pass raw object in raw_hook to prevent aliasing problem
epochs = epochs.resample(self.srate)
# epochs = epochs.decimate(dataset.srate//self.srate)
# retrieve X, y and meta
X = epochs.get_data() * 1e6 # micro-volt default
y = epochs.events[:, -1]
trial_ids = np.argwhere(events[:, -1] == list(
epochs.event_id.values())[0]).reshape((-1))
meta = pd.DataFrame({
"subject": [subject] * len(epochs),
"session": [session] * len(epochs),
"run": [run] * len(epochs),
"event": [event_name] * len(epochs),
"trial_id":
trial_ids,
"dataset": [dataset.dataset_code] * len(epochs)
})
# do data hook
if self._data_hook:
X, y, meta, caches = self._data_hook(
X, y, meta, caches)
elif hasattr(dataset, 'data_hook'):
X, y, meta, caches = dataset.data_hook(
X, y, meta, caches)
# collecting data
pre_X = Xs.get(event_name)
if pre_X is not None:
Xs[event_name] = np.concatenate((pre_X, X), axis=0)
else:
Xs[event_name] = X
pre_y = ys.get(event_name)
if pre_y is not None:
ys[event_name] = np.concatenate((pre_y, y), axis=0)
else:
ys[event_name] = y
pre_meta = metas.get(event_name)
if pre_meta is not None:
metas[event_name] = pd.concat((pre_meta, meta),
axis=0,
ignore_index=True)
else:
metas[event_name] = meta
return Xs, ys, metas
label='blink_up',
plot=False)
corrmap(icas=[temp_icas[0], ica],
template=(0, 1),
threshold=threshold_side,
label='blink_side',
plot=False)
# corrmap(icas=[temp_icas[1], ica],
# template=(0, 2), threshold=0.80, label='blink_weird', plot=False)
###############################################################################
# 4) Create summary plots to show signal correction on main experimental
# condition
# create a-cue epochs
a_evs = events_from_annotations(raw, regexp='^fix')[0]
a_epo = Epochs(raw,
a_evs,
tmin=-2,
tmax=2,
reject_by_annotation=True,
proj=False,
preload=True)
a_epo.apply_baseline(baseline=(-0.3, -0.05))
a_evo = a_epo.average()
# loop over identified "bad" components
bad_components = []
for label in ica.labels_:
bad_components.extend(ica.labels_[label])
def get_data(self, dataset, subjects=None, verbose=False):
"""Get data from dataset with selected subjects.
Parameters
----------
dataset : Dataset instance.
Dataset.
subjects : None|list of int, optional
Selected subject ids, if None, use all subjects in dataset.
verbose : bool, optional
Print processing information.
Returns
-------
Xs : dict
An dict of selected events data X.
ys : dict
An dict of selected events label y.
metas : dict
An dict of selected events metainfo meta.
"""
if not self.is_valid(dataset):
raise TypeError(
"Dataset {:s} is not valid for the current paradigm. Check your events and channels settings"
.format(dataset.code))
data = dataset.get_data(subjects)
# # events, interval checking
used_events, used_intervals = self._map_events_intervals(dataset)
Xs = {}
ys = {}
metas = {}
for subject, sessions in data.items():
for session, runs in sessions.items():
for run, raw in runs.items():
# do raw hook
caches = {}
if self._raw_hook:
raw, caches = self._raw_hook(raw, caches)
# pick selected channels by order
channels = dataset.channels if self.select_channels is None else self.select_channels
# picks = mne.pick_channels(raw.ch_names, channels, ordered=True)
picks = pick_channels(raw.ch_names, channels, ordered=True)
# find available 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,
initial_event=True)
else:
# convert event_id to its number type instead of default auto-renaming in 0.19.2
events, _ = mne.events_from_annotations(
raw, event_id=(lambda x: int(x)))
for event_name in used_events.keys():
# mne.pick_events returns any matching events in include
# only raise Runtime Error when nothing is found
# then we just skip this event
try:
selected_events = mne.pick_events(
events, include=used_events[event_name])
except RuntimeError:
continue
# transform Raw to Epochs
epochs = mne.Epochs(
raw,
selected_events,
event_id={event_name: used_events[event_name]},
event_repeated='drop',
tmin=used_intervals[event_name][0],
tmax=used_intervals[event_name][1] -
1. / raw.info['sfreq'],
picks=picks,
proj=False,
baseline=None,
preload=True)
# do epochs hook
if self._epochs_hook:
epochs, caches = self._epochs_hook(epochs, caches)
# FIXME: is this resample reasonable?
if self.srate:
# as MNE suggested, decimate after extract epochs
# low-pass raw object in raw_hook to prevent aliasing problem
epochs = epochs.resample(self.srate)
# epochs = epochs.decimate(dataset.srate//self.srate)
# retrieve X, y and meta
X = epochs.get_data()
y = epochs.events[:, -1]
meta = pd.DataFrame({
"subject": [subject] * len(epochs),
"session": [session] * len(epochs),
"run": [run] * len(epochs),
})
# do data hook
if self._data_hook:
X, y, meta, caches = self._data_hook(
X, y, meta, caches)
# collecting data
pre_X = Xs.get(event_name)
if pre_X is not None:
Xs[event_name] = np.concatenate((pre_X, X), axis=0)
else:
Xs[event_name] = X
pre_y = ys.get(event_name)
if pre_y is not None:
ys[event_name] = np.concatenate((pre_y, y), axis=0)
else:
ys[event_name] = y
pre_meta = metas.get(event_name)
if pre_meta is not None:
metas[event_name] = pd.concat((pre_meta, meta),
axis=0,
ignore_index=True)
else:
metas[event_name] = meta
return Xs, ys, metas
def test_events_from_annot_in_raw_objects():
"""Test basic functionality of events_fron_annot for raw objects."""
raw = read_raw_fif(fif_fname)
events = mne.find_events(raw)
event_id = {
'Auditory/Left': 1,
'Auditory/Right': 2,
'Visual/Left': 3,
'Visual/Right': 4,
'Visual/Smiley': 32,
'Motor/Button': 5
}
event_map = {v: k for k, v in event_id.items()}
annot = Annotations(onset=raw.times[events[:, 0] - raw.first_samp],
duration=np.zeros(len(events)),
description=[event_map[vv] for vv in events[:, 2]],
orig_time=None)
raw.set_annotations(annot)
events2, event_id2 = \
events_from_annotations(raw, event_id=event_id, regexp=None)
assert_array_equal(events, events2)
assert_equal(event_id, event_id2)
events3, event_id3 = \
events_from_annotations(raw, event_id=None, regexp=None)
assert_array_equal(events[:, 0], events3[:, 0])
assert set(event_id.keys()) == set(event_id3.keys())
# ensure that these actually got sorted properly
expected_event_id = {
desc: idx + 1 for idx, desc in enumerate(sorted(event_id.keys()))}
assert event_id3 == expected_event_id
first = np.unique(events3[:, 2])
second = np.arange(1, len(event_id) + 1, 1).astype(first.dtype)
assert_array_equal(first, second)
first = np.unique(list(event_id3.values()))
second = np.arange(1, len(event_id) + 1, 1).astype(first.dtype)
assert_array_equal(first, second)
events4, event_id4 =\
events_from_annotations(raw, event_id=None, regexp='.*Left')
expected_event_id4 = {k: v for k, v in event_id.items() if 'Left' in k}
assert_equal(event_id4.keys(), expected_event_id4.keys())
expected_events4 = events[(events[:, 2] == 1) | (events[:, 2] == 3)]
assert_array_equal(expected_events4[:, 0], events4[:, 0])
events5, event_id5 = \
events_from_annotations(raw, event_id=event_id, regexp='.*Left')
expected_event_id5 = {k: v for k, v in event_id.items() if 'Left' in k}
assert_equal(event_id5, expected_event_id5)
expected_events5 = events[(events[:, 2] == 1) | (events[:, 2] == 3)]
assert_array_equal(expected_events5, events5)
with pytest.raises(ValueError, match='not find any of the events'):
events_from_annotations(raw, regexp='not_there')
with pytest.raises(ValueError, match='Invalid type for event_id'):
events_from_annotations(raw, event_id='wrong')
# concat does not introduce BAD or EDGE
raw_concat = concatenate_raws([raw.copy(), raw.copy()])
_, event_id = events_from_annotations(raw_concat)
assert isinstance(event_id, dict)
assert len(event_id) > 0
for kind in ('BAD', 'EDGE'):
assert '%s boundary' % kind in raw_concat.annotations.description
for key in event_id.keys():
assert kind not in key
# remove all events
raw.set_annotations(None)
events7, _ = events_from_annotations(raw)
assert_array_equal(events7, np.empty((0, 3), dtype=int))
def events(raw=None,
merge=None,
proj=False,
name=None,
bads=None,
stim_channel=None,
events=None,
annotations=None,
**kwargs):
"""
Load events from a raw fiff file.
Parameters
----------
raw : str(path) | None | mne Raw
The raw fiff file from which to extract events (if raw and events are
both ``None``, a file dialog will be displayed to select a raw file).
merge : int
Merge steps occurring in neighboring samples. The integer value
indicates over how many samples events should be merged, and the sign
indicates in which direction they should be merged (negative means
towards the earlier event, positive towards the later event). By
default, this parameter is inferred from the data.
proj : bool | str
Path to the projections file that will be loaded with the raw file.
``'{raw}'`` will be expanded to the raw file's path minus extension.
With ``proj=True``, ``'{raw}_*proj.fif'`` will be used,
looking for any projection file starting with the raw file's name.
If multiple files match the pattern, a ValueError will be raised.
name : str | None
A name for the Dataset. If ``None``, the raw filename will be used.
bads : None | list
Specify additional bad channels in the raw data file (these are added
to the ones that are already defined in the raw file).
stim_channel : None | string | list of string
Name of the stim channel or all the stim channels
affected by the trigger. If None, the config variables
'MNE_STIM_CHANNEL', 'MNE_STIM_CHANNEL_1', 'MNE_STIM_CHANNEL_2',
etc. are read. If these are not found, it will default to
'STI 014'.
events : None | str
If events are stored in a fiff file separate from the Raw object, the
path to the events file can be supplied here. The events in the Dataset
will reflect the event sin the events file rather than the raw file.
annotations : bool
Generate events from annotations instead of the stim channel (by
default, annotations are used when present).
**
Keyword arguments for loading the raw file (see
:func:`mne.io.read_raw_kit` or :func:`mne.io.read_raw_kit`).
Returns
-------
events : Dataset
A Dataset with the following variables:
- *i_start*: the index of the event in the raw file.
- *trigger*: the event value.
The Dataset's info dictionary contains the following values:
- *raw*: the mne Raw object.
"""
if (raw is None and events is None) or isinstance(raw, str):
raw = mne_raw(raw, proj=proj, **kwargs)
if bads is not None and raw is not None:
raw.info['bads'].extend(bads)
if name is None and raw is not None:
raw_path = raw.filenames[0]
if isinstance(raw_path, str):
name = os.path.basename(raw_path)
else:
name = None
if events is None:
if annotations is None:
regex = re.compile('(bad|edge)', re.IGNORECASE)
index = [
not regex.match(desc) for desc in raw.annotations.description
]
if any(index):
annotations = raw.annotations[index]
if annotations:
evts, _ = mne.events_from_annotations(raw, int)
else:
raw.load_data()
if merge is None:
evts = mne.find_stim_steps(raw,
merge=-1,
stim_channel=stim_channel)
if len(evts) == 0:
evts = mne.find_stim_steps(raw,
merge=0,
stim_channel=stim_channel)
else:
evts = mne.find_stim_steps(raw,
merge=merge,
stim_channel=stim_channel)
evts = evts[np.flatnonzero(evts[:, 2])]
else:
evts = mne.read_events(events)
i_start = Var(evts[:, 0], name='i_start')
trigger = Var(evts[:, 2], name='trigger')
info = {'raw': raw}
return Dataset((trigger, i_start), name, info=info)
def test_cropped_decoding():
# 5,6,7,10,13,14 are codes for executed and imagined hands/feet
subject_id = 1
event_codes = [5, 6, 9, 10, 13, 14]
# This will download the files if you don't have them yet,
# and then return the paths to the files.
physionet_paths = mne.datasets.eegbci.load_data(subject_id,
event_codes,
update_path=False)
# Load each of the files
parts = [
mne.io.read_raw_edf(path,
preload=True,
stim_channel="auto",
verbose="WARNING") for path in physionet_paths
]
# Concatenate them
raw = concatenate_raws(parts)
# Find the events in this dataset
events, _ = mne.events_from_annotations(raw)
# Use only EEG channels
eeg_channel_inds = mne.pick_types(raw.info,
meg=False,
eeg=True,
stim=False,
eog=False,
exclude="bads")
# Extract trials, only using EEG channels
epoched = mne.Epochs(
raw,
events,
dict(hands=2, feet=3),
tmin=1,
tmax=4.1,
proj=False,
picks=eeg_channel_inds,
baseline=None,
preload=True,
)
# Convert data from volt to millivolt
# Pytorch expects float32 for input and int64 for labels.
X = (epoched.get_data() * 1e6).astype(np.float32)
y = (epoched.events[:, 2] - 2).astype(np.int64) # 2,3 -> 0,1
# Set if you want to use GPU
# You can also use torch.cuda.is_available() to determine if cuda is available on your machine.
cuda = False
set_random_seeds(seed=20170629, cuda=cuda)
# This will determine how many crops are processed in parallel
input_window_samples = 450
n_classes = 2
in_chans = X.shape[1]
# final_conv_length determines the size of the receptive field of the ConvNet
model = ShallowFBCSPNet(
in_chans=in_chans,
n_classes=n_classes,
input_window_samples=input_window_samples,
final_conv_length=12,
)
to_dense_prediction_model(model)
if cuda:
model.cuda()
# Perform forward pass to determine how many outputs per input
n_preds_per_input = get_output_shape(model, in_chans,
input_window_samples)[2]
train_set = create_from_X_y(X[:60],
y[:60],
drop_last_window=False,
window_size_samples=input_window_samples,
window_stride_samples=n_preds_per_input)
valid_set = create_from_X_y(X[60:],
y[60:],
drop_last_window=False,
window_size_samples=input_window_samples,
window_stride_samples=n_preds_per_input)
train_split = predefined_split(valid_set)
clf = EEGClassifier(
model,
cropped=True,
criterion=CroppedLoss,
criterion__loss_function=torch.nn.functional.nll_loss,
optimizer=optim.Adam,
train_split=train_split,
batch_size=32,
callbacks=['accuracy'],
)
clf.fit(train_set, y=None, epochs=4)
np.testing.assert_allclose(
clf.history[:, 'train_loss'],
np.array([1.455306, 1.455934, 1.210563, 1.065806]),
rtol=1e-3,
atol=1e-4,
)
np.testing.assert_allclose(
clf.history[:, 'valid_loss'],
np.array([2.547288, 1.51785, 1.394036, 1.064355]),
rtol=1e-3,
atol=1e-3,
)
np.testing.assert_allclose(
clf.history[:, 'train_accuracy'],
np.array([0.5, 0.5, 0.5, 0.533333]),
rtol=1e-3,
atol=1e-4,
)
np.testing.assert_allclose(
clf.history[:, 'valid_accuracy'],
np.array([0.533333, 0.466667, 0.533333, 0.5]),
rtol=1e-3,
atol=1e-4,
)
def find_false_spikes(path_to_eeg, path_tables):
file = mne.io.read_raw_eeglab(path_to_eeg, preload=True)
spikes_delays = mne.events_from_annotations(file)
paths = [f for f in sorted(os.listdir(path_tables))]
paths = paths[0:5]
fin_list, llll, all_spikes = [], 0, 0
for g, h in enumerate(paths):
j, ind_1 = 0, 0
path_to_table = path_tables + '/{0}'.format(paths[g])
datafile = pd.read_csv(path_to_table)
tms_sham_order = datafile['TMS'].tolist()
delays_table = datafile['SND_START'].tolist()
ind_stim = [
i for i, e in enumerate(tms_sham_order)
if e == 1 and math.isnan(delays_table[i]) == 0
]
new_l1 = [delays_table[index] for index in ind_stim]
min_del = min(([
round(new_l1[index + 1] * 2000 - new_l1[index] * 2000)
for index in range(len(new_l1) - 1)
]))
f = []
for i in range(len(tms_sham_order)):
f.append(int(tms_sham_order[i]))
number_spikes = f.count(1)
all_spikes += number_spikes
b = llll + number_spikes
order_table, ind_st_sham = func_c(f)
order_eeg, eeg_delays = func_a(spikes_delays, llll, b, min_del)
fin_list_1 = []
if len(order_eeg) < len(order_table):
#and g < (len(paths) - 1):
tau, _ = func_a(spikes_delays, b + 1,
b + 2 + len(order_table) - len(order_eeg), min_del)
order_eeg.extend(tau)
#elif len(order_eeg) < len(order_table) and g == (len(paths) - 1):
#order_eeg.append(1)
ind_f = [y for y, e in enumerate(order_table) if e == 2]
for i in range(len(order_table)):
if order_eeg[i] == 1 and order_table[i - j] == 1:
fin_list_1.append(1)
# check this
elif order_eeg[i] == 2 and order_table[i - j] == 1 and i == 1:
del fin_list_1[-1:]
fin_list_1.append(3)
j += 2
# new condition for false spike in group
elif order_eeg[i] == 1 and order_table[i - j] == 2:
hh = ind_f.index(i - j)
if (i - j) == order_table.index(2):
a3 = order_table[:i - j].count(1)
if a3 != 0:
del fin_list_1[-a3:]
fin_list_1.extend([3] + [1] * a3)
j += 1
else:
a1, a2 = ind_f[hh - 1], ind_f[hh]
del fin_list_1[-(a2 - a1 - 1):]
fin_list_1.extend([3] + [1] * (a2 - a1 - 1))
j += 1
# if all(i < 2 * min_del - 1000 for i in delays_table[a1 + 1:a2 - 1]):
# fin_list_1.extend([3] + [1] * (a2 - a1 - 2))
# j += 1
# else:
# print('false')
elif order_eeg[i] == 2 and order_table[i - j] == 1 and (0 == i):
j += 1
elif ((order_eeg[i] == 2 and order_eeg[i - 1] == 1) and
(i != 0)) and ((order_table[i - j] == 1) and func_b(
order_eeg, order_table, i, i - j)) != 0:
del fin_list_1[-1:]
fin_list_1.append(3)
j += 2
# check number of stim between two sham, its important!
elif ((order_eeg[i] == 2 and order_table[i - j] == 1) and
(i != 0)) and (order_table[i - j] == 1 and func_b(
order_eeg, order_table, i, i - j) == 0):
j += 1
# as a replacement for a global variable
ind_1 = i - j
llll = b
# we should add s1 instead of s!
# should correct this statement
if fin_list_1.count(1) != order_table.count(1):
s = order_table.count(1) - fin_list_1.count(1)
s1 = order_table[ind_1:].count(1) - order_eeg[ind_1 + j:].count(1)
fin_list_1.extend([1] * s)
llll += s1
fin_list.extend(fin_list_1)
ind_false_spikes = [i for i, e in enumerate(fin_list) if e == 3]
true_start_stim = []
ppf = spikes_delays[0][:, 0][0:]
# h = 0
# for i in range(1, (len(ppf)), 2):
# if h not in ind_false_spikes:
# true_start_stim.append(ppf[i])
# h += 1
return ind_false_spikes, true_start_stim
def _read_events(events_data, event_id, raw, bids_path=None):
"""Retrieve events (for use in *_events.tsv) from FIFF/array & Annotations.
Parameters
----------
events_data : path-like | np.ndarray | None
If a string, a path to an events file. If an array, an MNE events array
(shape n_events, 3). If None, events will be generated from
``raw.annotations``.
event_id : dict | None
The event id dict used to create a 'trial_type' column in events.tsv,
mapping a description key to an integer-valued event code.
raw : mne.io.Raw
The data as MNE-Python Raw object.
bids_path : BIDSPath | None
Can be used to determine if the data is a resting-state or empty-room
recording, and will suppress a warning about missing events in this
case.
Returns
-------
all_events : np.ndarray, shape = (n_events, 3)
The first column contains the event time in samples and the third
column contains the event id. The second column is ignored for now but
typically contains the value of the trigger channel either immediately
before the event or immediately after.
all_dur : np.ndarray, shape (n_events,)
The event durations in seconds.
all_desc : dict
A dictionary with the keys corresponding to the event descriptions and
the values to the event IDs.
"""
# get events from events_data
if isinstance(events_data, np.ndarray):
if events_data.ndim != 2:
raise ValueError('Events must have two dimensions, '
f'found {events_data.ndim}')
if events_data.shape[1] != 3:
raise ValueError('Events must have second dimension of length 3, '
f'found {events_data.shape[1]}')
events = events_data
elif events_data is None:
events = np.empty(shape=(0, 3), dtype=int)
else:
events = read_events(events_data).astype(int)
if events.size > 0:
# Only keep events for which we have an ID <> description mapping.
ids_without_desc = set(events[:, 2]) - set(event_id.values())
if ids_without_desc:
raise ValueError(
f'No description was specified for the following event(s): '
f'{", ".join([str(x) for x in sorted(ids_without_desc)])}. '
f'Please add them to the event_id dictionary, or drop them '
f'from the events_data array.')
del ids_without_desc
mask = [e in list(event_id.values()) for e in events[:, 2]]
events = events[mask]
# Append events to raw.annotations. All event onsets are relative to
# measurement beginning.
id_to_desc_map = dict(zip(event_id.values(), event_id.keys()))
# We don't pass `first_samp`, as set_annotations() below will take
# care of this shift automatically.
new_annotations = mne.annotations_from_events(
events=events,
sfreq=raw.info['sfreq'],
event_desc=id_to_desc_map,
orig_time=raw.annotations.orig_time)
raw = raw.copy() # Don't alter the original.
annotations = raw.annotations.copy()
# We use `+=` here because `Annotations.__iadd__()` does the right
# thing and also performs a sanity check on `Annotations.orig_time`.
annotations += new_annotations
raw.set_annotations(annotations)
del id_to_desc_map, annotations, new_annotations
# Now convert the Annotations to events.
all_events, all_desc = events_from_annotations(
raw,
event_id=event_id,
regexp=None # Include `BAD_` and `EDGE_` Annotations, too.
)
all_dur = raw.annotations.duration
# Warn about missing events if not rest or empty-room data
if ((all_events.size == 0 and bids_path.task is not None)
and (not bids_path.task.startswith('rest')
or not (bids_path.subject == 'emptyroom'
and bids_path.task == 'noise'))):
warn('No events found or provided. Please add annotations to the raw '
'data, or provide the events_data and event_id parameters. For '
'resting state data, BIDS recommends naming the task using '
'labels beginning with "rest".')
return all_events, all_dur, all_desc
#
# We will work only with 5 stages: Wake (W), Stage 1, Stage 2, Stage 3/4, and
# REM sleep (R). To do so, we use the ``event_id`` parameter in
# :func:`mne.events_from_annotations` to select which events are we
# interested in and we associate an event identifier to each of them.
annotation_desc_2_event_id = {
'Sleep stage W': 1,
'Sleep stage 1': 2,
'Sleep stage 2': 3,
'Sleep stage 3': 4,
'Sleep stage 4': 4,
'Sleep stage R': 5
}
events_train, _ = mne.events_from_annotations(
raw_train, event_id=annotation_desc_2_event_id, chunk_duration=30.)
# create a new event_id that unifies stages 3 and 4
event_id = {
'Sleep stage W': 1,
'Sleep stage 1': 2,
'Sleep stage 2': 3,
'Sleep stage 3/4': 4,
'Sleep stage R': 5
}
# plot events
mne.viz.plot_events(events_train,
event_id=event_id,
sfreq=raw_train.info['sfreq'])
import mne
from mne.event import define_target_events
from mne.channels import make_1020_channel_selections
print(__doc__)
###############################################################################
# Load EEGLAB example data (a small EEG dataset)
data_path = mne.datasets.testing.data_path()
fname = data_path + "/EEGLAB/test_raw.set"
montage = data_path + "/EEGLAB/test_chans.locs"
event_id = {"rt": 1, "square": 2} # must be specified for str events
eog = {"FPz", "EOG1", "EOG2"}
raw = mne.io.read_raw_eeglab(fname, eog=eog, montage=montage)
events = mne.events_from_annotations(raw, event_id)[0]
###############################################################################
# Create Epochs
# define target events:
# 1. find response times: distance between "square" and "rt" events
# 2. extract A. "square" events B. followed by a button press within 700 msec
tmax = .7
sfreq = raw.info["sfreq"]
reference_id, target_id = 2, 1
new_events, rts = define_target_events(events, reference_id, target_id, sfreq,
tmin=0., tmax=tmax, new_id=2)
epochs = mne.Epochs(raw, events=new_events, tmax=tmax + .1,
event_id={"square": 2})
# Rapid Eye Movement sleep, movement (M), and Stage (?) for any none scored
# segment.
#
# We will work only with 5 stages: Wake (W), Stage 1, Stage 2, Stage 3/4, and
# REM sleep (R). To do so, we use the ``event_id`` parameter in
# :func:`mne.events_from_annotations` to select which events are we
# interested in and we associate an event identifier to each of them.
annotation_desc_2_event_id = {'Sleep stage W': 1,
'Sleep stage 1': 2,
'Sleep stage 2': 3,
'Sleep stage 3': 4,
'Sleep stage 4': 4,
'Sleep stage R': 5}
events_train, _ = mne.events_from_annotations(
raw_train, event_id=annotation_desc_2_event_id, chunk_duration=30.)
# create a new event_id that unifies stages 3 and 4
event_id = {'Sleep stage W': 1,
'Sleep stage 1': 2,
'Sleep stage 2': 3,
'Sleep stage 3/4': 4,
'Sleep stage R': 5}
# plot events
mne.viz.plot_events(events_train, event_id=event_id,
sfreq=raw_train.info['sfreq'])
# keep the color-code for further plotting
stage_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
# cue onset.
tmin, tmax = -1., 4.
event_id = dict(hands=2, feet=3)
subject = 1
runs = [6, 10, 14] # motor imagery: hands vs feet
raw_fnames = eegbci.load_data(subject, runs)
raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames])
# strip channel names of "." characters
raw.rename_channels(lambda x: x.strip('.'))
# Apply band-pass filter
raw.filter(7., 30., fir_design='firwin', skip_by_annotation='edge')
events, _ = events_from_annotations(raw)
picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False,
exclude='bads')
# Read epochs (train will be done only between 1 and 2s)
# Testing will be done with a running classifier
epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,
baseline=None, preload=True)
epochs_train = epochs.copy().crop(tmin=1., tmax=2.)
labels = epochs.events[:, -1] - 2
###############################################################################
# Classification with linear discrimant analysis
# Define a monte-carlo cross-validation generator (reduce variance):
def test_events_from_annot_in_raw_objects():
"""Test basic functionality of events_fron_annot for raw objects."""
raw = read_raw_fif(fif_fname)
events = mne.find_events(raw)
event_id = {
'Auditory/Left': 1,
'Auditory/Right': 2,
'Visual/Left': 3,
'Visual/Right': 4,
'Visual/Smiley': 32,
'Motor/Button': 5
}
event_map = {v: k for k, v in event_id.items()}
annot = Annotations(onset=raw.times[events[:, 0] - raw.first_samp],
duration=np.zeros(len(events)),
description=[event_map[vv] for vv in events[:, 2]],
orig_time=None)
raw.set_annotations(annot)
events2, event_id2 = \
events_from_annotations(raw, event_id=event_id, regexp=None)
assert_array_equal(events, events2)
assert_equal(event_id, event_id2)
events3, event_id3 = \
events_from_annotations(raw, event_id=None, regexp=None)
assert_array_equal(events[:, 0], events3[:, 0])
assert set(event_id.keys()) == set(event_id3.keys())
# ensure that these actually got sorted properly
expected_event_id = {
desc: idx + 1 for idx, desc in enumerate(sorted(event_id.keys()))}
assert event_id3 == expected_event_id
first = np.unique(events3[:, 2])
second = np.arange(1, len(event_id) + 1, 1).astype(first.dtype)
assert_array_equal(first, second)
first = np.unique(list(event_id3.values()))
second = np.arange(1, len(event_id) + 1, 1).astype(first.dtype)
assert_array_equal(first, second)
events4, event_id4 =\
events_from_annotations(raw, event_id=None, regexp='.*Left')
expected_event_id4 = {k: v for k, v in event_id.items() if 'Left' in k}
assert_equal(event_id4.keys(), expected_event_id4.keys())
expected_events4 = events[(events[:, 2] == 1) | (events[:, 2] == 3)]
assert_array_equal(expected_events4[:, 0], events4[:, 0])
events5, event_id5 = \
events_from_annotations(raw, event_id=event_id, regexp='.*Left')
expected_event_id5 = {k: v for k, v in event_id.items() if 'Left' in k}
assert_equal(event_id5, expected_event_id5)
expected_events5 = events[(events[:, 2] == 1) | (events[:, 2] == 3)]
assert_array_equal(expected_events5, events5)
with pytest.raises(ValueError, match='not find any of the events'):
events_from_annotations(raw, regexp='not_there')
with pytest.raises(ValueError, match='Invalid input event_id'):
events_from_annotations(raw, event_id='wrong')
# concat does not introduce BAD or EDGE
raw_concat = concatenate_raws([raw.copy(), raw.copy()])
_, event_id = events_from_annotations(raw_concat)
assert isinstance(event_id, dict)
assert len(event_id) > 0
for kind in ('BAD', 'EDGE'):
assert '%s boundary' % kind in raw_concat.annotations.description
for key in event_id.keys():
assert kind not in key
# remove all events
raw.set_annotations(None)
events7, _ = events_from_annotations(raw)
assert_array_equal(events7, np.empty((0, 3), dtype=int))
def test_events_from_annot_in_raw_objects():
"""Test basic functionality of events_fron_annot for raw objects."""
raw = read_raw_fif(fif_fname)
events = mne.find_events(raw)
event_id = {
'Auditory/Left': 1,
'Auditory/Right': 2,
'Visual/Left': 3,
'Visual/Right': 4,
'Visual/Smiley': 32,
'Motor/Button': 5
}
event_map = {v: k for k, v in event_id.items()}
annot = Annotations(onset=raw.times[events[:, 0] - raw.first_samp],
duration=np.zeros(len(events)),
description=[event_map[vv] for vv in events[:, 2]],
orig_time=None)
raw.set_annotations(annot)
events2, event_id2 = \
events_from_annotations(raw, event_id=event_id, regexp=None)
assert_array_equal(events, events2)
assert_equal(event_id, event_id2)
events3, event_id3 = \
events_from_annotations(raw, event_id=None, regexp=None)
assert_array_equal(events[:, 0], events3[:, 0])
assert set(event_id.keys()) == set(event_id3.keys())
first = np.unique(events3[:, 2])
second = np.arange(1, len(event_id) + 1, 1).astype(first.dtype)
assert_array_equal(first, second)
first = np.unique(list(event_id3.values()))
second = np.arange(1, len(event_id) + 1, 1).astype(first.dtype)
assert_array_equal(first, second)
events4, event_id4 =\
events_from_annotations(raw, event_id=None, regexp='.*Left')
expected_event_id4 = {k: v for k, v in event_id.items() if 'Left' in k}
assert_equal(event_id4.keys(), expected_event_id4.keys())
expected_events4 = events[(events[:, 2] == 1) | (events[:, 2] == 3)]
assert_array_equal(expected_events4[:, 0], events4[:, 0])
events5, event_id5 = \
events_from_annotations(raw, event_id=event_id, regexp='.*Left')
expected_event_id5 = {k: v for k, v in event_id.items() if 'Left' in k}
assert_equal(event_id5, expected_event_id5)
expected_events5 = events[(events[:, 2] == 1) | (events[:, 2] == 3)]
assert_array_equal(expected_events5, events5)
with pytest.raises(ValueError, match='not find any of the events'):
events_from_annotations(raw, regexp='not_there')
raw.set_annotations(None)
events7, _ = events_from_annotations(raw)
assert_array_equal(events7, np.empty((0, 3), dtype=int))
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:
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
def process_raw(self, raw, dataset):
"""
Process one raw data file.
This function apply the preprocessing and eventual epoching on the
individual run, and return the data, labels and a dataframe with
metadata.
metadata is a dataframe with as many row as the length of the data
and labels.
Parameters
----------
raw: mne.Raw instance
the raw EEG data.
dataset : dataset instance
The dataset corresponding to the raw file. mainly use to access
dataset specific information.
returns
-------
X : np.ndarray
the data that will be used as features for the model
labels: np.ndarray
the labels for training / evaluating the model
metadata: pd.DataFrame
A dataframe containing the metadata
"""
# 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 events id
event_id = self.used_events(dataset)
# pick events, based on event_id
try:
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
epochs = mne.Epochs(raw_f, events, event_id=event_id,
tmin=tmin, tmax=tmax, proj=False,
baseline=None, preload=True,
verbose=False, picks=picks,
on_missing='ignore')
if self.resample is not None:
epochs = epochs.resample(self.resample)
# rescale to work with uV
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, epochs, raw_f
def run_epochs(subject, session=None):
"""Extract epochs for one subject."""
print("Processing subject: %s" % subject)
raw_list = list()
print(" Loading raw data")
# Construct the search path for the data file. `sub` is mandatory
subject_path = op.join('sub-{}'.format(subject))
# `session` is optional
if session is not None:
subject_path = op.join(subject_path, 'ses-{}'.format(session))
subject_path = op.join(subject_path, config.kind)
for run_idx, run in enumerate(config.runs):
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=run,
processing=config.proc,
recording=config.rec,
space=config.space)
# Prepare a name to save the data
fpath_deriv = op.join(config.bids_root, 'derivatives',
config.PIPELINE_NAME, subject_path)
raw_fname_in = \
op.join(fpath_deriv, bids_basename + '_filt_raw.fif')
print("Input: ", raw_fname_in)
raw = mne.io.read_raw_fif(raw_fname_in, preload=True)
raw_list.append(raw)
print(' Concatenating runs')
raw = mne.concatenate_raws(raw_list)
events, event_id = mne.events_from_annotations(raw)
if "eeg" in config.ch_types:
raw.set_eeg_reference(projection=True)
del raw_list
meg = False
if 'meg' in config.ch_types:
meg = True
elif 'grad' in config.ch_types:
meg = 'grad'
elif 'mag' in config.ch_types:
meg = 'mag'
eeg = 'eeg' in config.ch_types or config.kind == 'eeg'
picks = mne.pick_types(raw.info,
meg=meg,
eeg=eeg,
stim=True,
eog=True,
exclude=())
# Construct metadata from the epochs
# Add here if you need to attach a pandas dataframe as metadata
# to your epochs object:
# https://martinos.org/mne/dev/auto_tutorials/plot_metadata_epochs.html
# Epoch the data
print(' Epoching')
epochs = mne.Epochs(raw,
events,
event_id,
config.tmin,
config.tmax,
proj=True,
picks=picks,
baseline=config.baseline,
preload=False,
decim=config.decim,
reject=config.reject)
print(' Writing epochs to disk')
bids_basename = make_bids_basename(subject=subject,
session=session,
task=config.task,
acquisition=config.acq,
run=None,
processing=config.proc,
recording=config.rec,
space=config.space)
epochs_fname = \
op.join(fpath_deriv, bids_basename + '-epo.fif')
epochs.save(epochs_fname, overwrite=True)
if config.plot:
epochs.plot()
epochs.plot_image(combine='gfp',
group_by='type',
sigma=2.,
cmap="YlGnBu_r")
# cue onset.
tmin, tmax = -1., 4.
event_id = dict(hands=2, feet=3)
subject = 1
runs = [6, 10, 14] # motor imagery: hands vs feet
raw_fnames = eegbci.load_data(subject, runs)
raw = concatenate_raws([read_raw_edf(f, preload=True) for f in raw_fnames])
# strip channel names of "." characters
raw.rename_channels(lambda x: x.strip('.'))
# Apply band-pass filter
raw.filter(7., 30., fir_design='firwin', skip_by_annotation='edge')
events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))
picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False,
exclude='bads')
# Read epochs (train will be done only between 1 and 2s)
# Testing will be done with a running classifier
epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,
baseline=None, preload=True)
epochs_train = epochs.copy().crop(tmin=1., tmax=2.)
labels = epochs.events[:, -1] - 2
###############################################################################
# Classification with linear discrimant analysis
# Define a monte-carlo cross-validation generator (reduce variance):
# ica.exclude = [1, 2] # details on how we picked these are omitted here
# ica.plot_properties(raw_data, picks=ica.exclude)
mag_channels = mne.pick_types(raw_data.info, eeg=True)
print(mag_channels)
raw_data.plot(duration=60,
order=mag_channels,
proj=False,
n_channels=len(mag_channels),
remove_dc=False)
"""bandpass filter을 통해 Data filtering"""
raw_highpass = raw_data.load_data().filter(l_freq=10, h_freq=60)
print(raw_highpass.info)
"""이벤트 찾"""
# annotation이 있는경우
events, event_id = mne.events_from_annotations(raw_data)
print(events, event_id)
# stim_cahennel이 있는 경우
#events = mne.find_events(raw_data, stim_channel=None)
# print(events[:5]) # show the first 5
"""
def add_arrows(axes):
# add some arrows at 60 Hz and its harmonics
for ax in axes:
freqs = ax.lines[-1].get_xdata()
psds = ax.lines[-1].get_ydata()
idx = np.searchsorted(freqs, 60)
# get ymax of a small region around the freq. of interest
y = psds[(idx - 4):(idx + 5)].max()
from mne.time_frequency import tfr_multitaper
from mne.stats import permutation_cluster_1samp_test as pcluster_test
from mne.viz.utils import center_cmap
# load and preprocess data ####################################################
subject = 1 # use data from subject 1
runs = [6, 10, 14] # use only hand and feet motor imagery runs
fnames = eegbci.load_data(subject, runs)
raws = [read_raw_edf(f, preload=True) for f in fnames]
raw = concatenate_raws(raws)
raw.rename_channels(lambda x: x.strip('.')) # remove dots from channel names
events, _ = mne.events_from_annotations(raw)
picks = mne.pick_channels(raw.info["ch_names"], ["C3", "Cz", "C4"])
# epoch data ##################################################################
tmin, tmax = -1, 4 # define epochs around events (in s)
event_ids = dict(hands=2, feet=3) # map event IDs to tasks
epochs = mne.Epochs(raw, events, event_ids, tmin - 0.5, tmax + 0.5,
picks=picks, baseline=None, preload=True)
# compute ERDS maps ###########################################################
freqs = np.arange(2, 36, 1) # frequencies from 2-35Hz
n_cycles = freqs # use constant t/f resolution
vmin, vmax = -1, 1.5 # set min and max ERDS values in plot
baseline = [-1, 0] # baseline interval (in s)
raw = mne.io.read_raw_brainvision(bids_fname, preload=True, verbose=False)
raw.info['line_freq'] = 50.
# Set montage
montage = mne.channels.make_standard_montage('easycap-M1')
raw.set_montage(montage, verbose=False)
# Set common average reference
raw.set_eeg_reference('average', projection=False, verbose=False)
# Apply bandpass filter
raw.filter(l_freq=0.1, h_freq=None, fir_design='firwin', verbose=False)
# Construct epochs
event_id = {'12hz': 255, '15hz': 155}
events, _ = mne.events_from_annotations(raw, verbose=False)
raw.info["events"] = events
tmin, tmax = -1., 20. # in s
baseline = None
epochs = mne.Epochs(raw,
events=events,
event_id=[event_id['12hz'], event_id['15hz']],
tmin=tmin,
tmax=tmax,
baseline=baseline,
verbose=False)
###############################################################################
# Frequency analysis
# ------------------
# Now we compute the frequency spectrum of the EEG data.
