def test_get_event_data():
"""Test emulation of realtime data stream."""
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
picks = pick_types(raw.info,
meg='grad',
eeg=False,
eog=True,
stim=True,
exclude=raw.info['bads'])
event_id, tmin, tmax = 2, -0.1, 0.3
epochs = Epochs(raw,
events,
event_id=event_id,
tmin=tmin,
tmax=tmax,
picks=picks,
baseline=None,
preload=True,
proj=False)
data = epochs.get_data()[0, :, :]
rt_client = MockRtClient(raw)
rt_data = rt_client.get_event_data(event_id=event_id,
tmin=tmin,
tmax=tmax,
picks=picks,
stim_channel='STI 014')
assert_array_equal(rt_data, data)
def test_mockclient():
"""Test the RtMockClient."""
event_id, tmin, tmax = 1, -0.2, 0.5
epochs = Epochs(raw,
events[:7],
event_id=event_id,
tmin=tmin,
tmax=tmax,
picks=picks,
baseline=(None, 0),
preload=True)
data = epochs.get_data()
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_data = rt_epochs.get_data()
assert_true(rt_data.shape == data.shape)
assert_array_equal(rt_data, data)
def test_mockclient():
"""Test the RtMockClient."""
raw = mne.io.read_raw_fif(raw_fname, preload=True, verbose=False,
add_eeg_ref=False)
picks = mne.pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id, tmin, tmax = 1, -0.2, 0.5
epochs = Epochs(raw, events[:7], event_id=event_id, tmin=tmin, tmax=tmax,
picks=picks, baseline=(None, 0), preload=True,
add_eeg_ref=False)
data = epochs.get_data()
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
isi_max=0.5, add_eeg_ref=False)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_data = rt_epochs.get_data()
assert_true(rt_data.shape == data.shape)
assert_array_equal(rt_data, data)
def test_events_long():
"""Test events."""
data_path = testing.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_trunc_raw.fif'
raw = read_raw_fif(raw_fname, preload=True)
raw_tmin, raw_tmax = 0, 90
tmin, tmax = -0.2, 0.5
event_id = dict(aud_l=1, vis_l=3)
# select gradiometers
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
# load data with usual Epochs for later verification
raw = concatenate_raws([raw, raw.copy(), raw.copy(), raw.copy(),
raw.copy(), raw.copy()])
assert 110 < raw.times[-1] < 130
raw_cropped = raw.copy().crop(raw_tmin, raw_tmax)
events_offline = find_events(raw_cropped)
epochs_offline = Epochs(raw_cropped, events_offline, event_id=event_id,
tmin=tmin, tmax=tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6),
baseline=None)
epochs_offline.drop_bad()
# create the mock-client object
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6), baseline=None,
isi_max=1.)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=raw_tmin, tmax=raw_tmax,
buffer_size=1000)
expected_events = epochs_offline.events.copy()
expected_events[:, 0] = expected_events[:, 0] - raw_cropped.first_samp
assert np.all(expected_events[:, 0] <=
(raw_tmax - tmax) * raw.info['sfreq'])
assert_array_equal(rt_epochs.events, expected_events)
assert len(rt_epochs) == len(epochs_offline)
data_picks = pick_types(epochs_offline.info, meg='grad', eeg=False,
eog=True,
stim=False, exclude=raw.info['bads'])
for ev_num, ev in enumerate(rt_epochs.iter_evoked()):
if ev_num == 0:
X_rt = ev.data[None, data_picks, :]
y_rt = int(ev.comment) # comment attribute contains the event_id
else:
X_rt = np.concatenate((X_rt, ev.data[None, data_picks, :]), axis=0)
y_rt = np.append(y_rt, int(ev.comment))
X_offline = epochs_offline.get_data()[:, data_picks, :]
y_offline = epochs_offline.events[:, 2]
assert_array_equal(X_rt, X_offline)
assert_array_equal(y_rt, y_offline)
def test_mockclient(tmpdir):
"""Test the RtMockClient."""
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
picks = pick_types(raw.info,
meg='grad',
eeg=False,
eog=True,
stim=True,
exclude=raw.info['bads'])
event_id, tmin, tmax = 1, -0.2, 0.5
epochs = Epochs(raw,
events[:7],
event_id=event_id,
tmin=tmin,
tmax=tmax,
picks=picks,
baseline=(None, 0),
preload=True)
data = epochs.get_data()
rt_client = MockRtClient(raw)
# choose "large" value, should always be longer than execution time of
# get_data()
isi_max = 0.5
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
isi_max=isi_max)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
# get_data() should return immediately and not wait for the timeout
start_time = time.time()
rt_data = rt_epochs.get_data()
retrieval_time = time.time() - start_time
assert retrieval_time < isi_max
assert rt_data.shape == data.shape
assert_array_equal(rt_data, data)
assert len(rt_epochs) == len(epochs)
# iteration over epochs should block until timeout
rt_iter_data = list()
start_time = time.time()
for cur_epoch in rt_epochs:
rt_iter_data.append(cur_epoch)
retrieval_time = time.time() - start_time
assert retrieval_time >= isi_max
rt_iter_data = np.array(rt_iter_data)
assert rt_iter_data.shape == data.shape
assert_array_equal(rt_iter_data, data)
assert len(rt_epochs) == len(epochs)
_call_base_epochs_public_api(rt_epochs, tmpdir)
def test_events_sampledata():
""" based on examples/realtime/plot_compute_rt_decoder.py"""
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
raw = read_raw_fif(raw_fname, preload=True)
raw_tmin, raw_tmax = 0, 90
tmin, tmax = -0.2, 0.5
event_id = dict(aud_l=1, vis_l=3)
# select gradiometers
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
# load data with usual Epochs for later verification
raw_cropped = raw.copy().crop(raw_tmin, raw_tmax)
events_offline = find_events(raw_cropped)
epochs_offline = Epochs(raw_cropped, events_offline, event_id=event_id,
tmin=tmin, tmax=tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6),
baseline=None)
epochs_offline.drop_bad()
# create the mock-client object
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6), baseline=None,
isi_max=1.)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=raw_tmin, tmax=raw_tmax,
buffer_size=1000)
expected_events = epochs_offline.events.copy()
expected_events[:, 0] = expected_events[:, 0] - raw_cropped.first_samp
assert np.all(expected_events[:, 0] <=
(raw_tmax - tmax) * raw.info['sfreq'])
assert_array_equal(rt_epochs.events, expected_events)
assert len(rt_epochs) == len(epochs_offline)
data_picks = pick_types(epochs_offline.info, meg='grad', eeg=False,
eog=True,
stim=False, exclude=raw.info['bads'])
for ev_num, ev in enumerate(rt_epochs.iter_evoked()):
if ev_num == 0:
X_rt = ev.data[None, data_picks, :]
y_rt = int(ev.comment) # comment attribute contains the event_id
else:
X_rt = np.concatenate((X_rt, ev.data[None, data_picks, :]), axis=0)
y_rt = np.append(y_rt, int(ev.comment))
X_offline = epochs_offline.get_data()[:, data_picks, :]
y_offline = epochs_offline.events[:, 2]
assert_array_equal(X_rt, X_offline)
assert_array_equal(y_rt, y_offline)
def test_rejection(buffer_size):
"""Test rejection."""
event_id, tmin, tmax = 1, 0.0, 0.5
sfreq = 1000
ch_names = ['Fz', 'Cz', 'Pz', 'STI 014']
raw_tmax = 5
info = create_info(ch_names=ch_names, sfreq=sfreq,
ch_types=['eeg', 'eeg', 'eeg', 'stim'])
raw_array = np.random.randn(len(ch_names), raw_tmax * sfreq)
raw_array[-1, :] = 0
epoch_start_samples = np.arange(raw_tmax) * sfreq
raw_array[-1, epoch_start_samples] = event_id
reject_threshold = np.max(raw_array) - np.min(raw_array) + 1
reject = {'eeg': reject_threshold}
epochs_to_reject = [1, 3]
epochs_to_keep = np.setdiff1d(np.arange(len(epoch_start_samples)),
epochs_to_reject)
expected_drop_log = [list() for _ in range(len(epoch_start_samples))]
for cur_epoch in epochs_to_reject:
raw_array[1, epoch_start_samples[cur_epoch]] = reject_threshold + 1
expected_drop_log[cur_epoch] = [ch_names[1]]
raw = RawArray(raw_array, info)
events = find_events(raw, shortest_event=1, initial_event=True)
picks = pick_types(raw.info, eeg=True)
epochs = Epochs(raw, events, event_id=event_id, tmin=tmin, tmax=tmax,
baseline=None, picks=picks, preload=True,
reject=reject)
epochs_data = epochs.get_data()
assert len(epochs) == len(epoch_start_samples) - len(epochs_to_reject)
assert_array_equal(epochs_data[:, 1, 0],
raw_array[1, epoch_start_samples[epochs_to_keep]])
assert_array_equal(epochs.drop_log, expected_drop_log)
assert_array_equal(epochs.selection, epochs_to_keep)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
baseline=None, isi_max=0.5,
find_events=dict(initial_event=True),
reject=reject)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=raw_tmax,
buffer_size=buffer_size)
assert len(rt_epochs) == len(epochs_to_keep)
assert_array_equal(rt_epochs.drop_log, expected_drop_log)
assert_array_equal(rt_epochs.selection, epochs_to_keep)
rt_data = rt_epochs.get_data()
assert rt_data.shape == epochs_data.shape
assert_array_equal(rt_data, epochs_data)
def test_rejection(buffer_size):
event_id, tmin, tmax = 1, 0.0, 0.5
sfreq = 1000
ch_names = ['Fz', 'Cz', 'Pz', 'STI 014']
raw_tmax = 5
info = create_info(ch_names=ch_names, sfreq=sfreq,
ch_types=['eeg', 'eeg', 'eeg', 'stim'])
raw_array = np.random.randn(len(ch_names), raw_tmax * sfreq)
raw_array[-1, :] = 0
epoch_start_samples = np.arange(raw_tmax) * sfreq
raw_array[-1, epoch_start_samples] = event_id
reject_threshold = np.max(raw_array) - np.min(raw_array) + 1
reject = {'eeg': reject_threshold}
epochs_to_reject = [1, 3]
epochs_to_keep = np.setdiff1d(np.arange(len(epoch_start_samples)),
epochs_to_reject)
expected_drop_log = [list() for _ in range(len(epoch_start_samples))]
for cur_epoch in epochs_to_reject:
raw_array[1, epoch_start_samples[cur_epoch]] = reject_threshold + 1
expected_drop_log[cur_epoch] = [ch_names[1]]
raw = RawArray(raw_array, info)
events = find_events(raw, shortest_event=1, initial_event=True)
picks = pick_types(raw.info, eeg=True)
epochs = Epochs(raw, events, event_id=event_id, tmin=tmin, tmax=tmax,
baseline=None, picks=picks, preload=True,
reject=reject)
epochs_data = epochs.get_data()
assert len(epochs) == len(epoch_start_samples) - len(epochs_to_reject)
assert_array_equal(epochs_data[:, 1, 0],
raw_array[1, epoch_start_samples[epochs_to_keep]])
assert_array_equal(epochs.drop_log, expected_drop_log)
assert_array_equal(epochs.selection, epochs_to_keep)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
baseline=None, isi_max=0.5,
find_events=dict(initial_event=True),
reject=reject)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=raw_tmax,
buffer_size=buffer_size)
assert len(rt_epochs) == len(epochs_to_keep)
assert_array_equal(rt_epochs.drop_log, expected_drop_log)
assert_array_equal(rt_epochs.selection, epochs_to_keep)
rt_data = rt_epochs.get_data()
assert rt_data.shape == epochs_data.shape
assert_array_equal(rt_data, epochs_data)
def test_get_event_data():
"""Test emulation of realtime data stream."""
event_id, tmin, tmax = 2, -0.1, 0.3
epochs = Epochs(
raw, events, event_id=event_id, tmin=tmin, tmax=tmax, picks=picks, baseline=None, preload=True, proj=False
)
data = epochs.get_data()[0, :, :]
rt_client = MockRtClient(raw)
rt_data = rt_client.get_event_data(event_id=event_id, tmin=tmin, tmax=tmax, picks=picks, stim_channel="STI 014")
assert_array_equal(rt_data, data)
def test_get_event_data():
"""Test emulation of realtime data stream."""
raw = mne.io.Raw(raw_fname, preload=True, verbose=False)
picks = mne.pick_types(raw.info, meg="grad", eeg=False, eog=True, stim=True, exclude=raw.info["bads"])
event_id, tmin, tmax = 2, -0.1, 0.3
epochs = Epochs(
raw, events, event_id=event_id, tmin=tmin, tmax=tmax, picks=picks, baseline=None, preload=True, proj=False
)
data = epochs.get_data()[0, :, :]
rt_client = MockRtClient(raw)
rt_data = rt_client.get_event_data(event_id=event_id, tmin=tmin, tmax=tmax, picks=picks, stim_channel="STI 014")
assert_array_equal(rt_data, data)
def test_mockclient(tmpdir):
"""Test the RtMockClient."""
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id, tmin, tmax = 1, -0.2, 0.5
epochs = Epochs(raw, events[:7], event_id=event_id, tmin=tmin, tmax=tmax,
picks=picks, baseline=(None, 0), preload=True)
data = epochs.get_data()
rt_client = MockRtClient(raw)
# choose "large" value, should always be longer than execution time of
# get_data()
isi_max = 0.5
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
isi_max=isi_max)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
# get_data() should return immediately and not wait for the timeout
start_time = time.time()
rt_data = rt_epochs.get_data()
retrieval_time = time.time() - start_time
assert retrieval_time < isi_max
assert rt_data.shape == data.shape
assert_array_equal(rt_data, data)
assert len(rt_epochs) == len(epochs)
# iteration over epochs should block until timeout
rt_iter_data = list()
start_time = time.time()
for cur_epoch in rt_epochs:
rt_iter_data.append(cur_epoch)
retrieval_time = time.time() - start_time
assert retrieval_time >= isi_max
rt_iter_data = np.array(rt_iter_data)
assert rt_iter_data.shape == data.shape
assert_array_equal(rt_iter_data, data)
assert len(rt_epochs) == len(epochs)
_call_base_epochs_public_api(rt_epochs, tmpdir)
def test_mockclient():
"""Test the RtMockClient."""
event_id, tmin, tmax = 1, -0.2, 0.5
epochs = Epochs(raw, events[:7], event_id=event_id, tmin=tmin, tmax=tmax,
picks=picks, baseline=(None, 0), preload=True)
data = epochs.get_data()
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_data = rt_epochs.get_data()
assert_true(rt_data.shape == data.shape)
assert_array_equal(rt_data, data)
def test_get_event_data():
"""Test emulation of realtime data stream."""
event_id, tmin, tmax = 2, -0.1, 0.3
epochs = Epochs(raw,
events,
event_id=event_id,
tmin=tmin,
tmax=tmax,
picks=picks,
baseline=None,
preload=True,
proj=False)
data = epochs.get_data()[0, :, :]
rt_client = MockRtClient(raw)
rt_data = rt_client.get_event_data(event_id=event_id,
tmin=tmin,
tmax=tmax,
picks=picks,
stim_channel='STI 014')
assert_array_equal(rt_data, data)
ax.set(xlabel='Trials',
ylabel='Classification score (% correct)',
title='Real-time feedback')
isi = 0.01 # this is unrealistic, but will make the example run quickly
n_trials = 40 # number of trials to simulate
n_start = 5 # number of trials to run before decoding
rng = np.random.RandomState(0)
# Instantiating stimulation server
# The with statement is necessary to ensure a clean exit
with StimServer(port=4218) as stim_server:
# The channels to be used while decoding
picks = mne.pick_types(raw.info, meg='grad')
rt_client = MockRtClient(raw)
# Constructing the pipeline for classification
# don't highpass filter because of short signal length of epochs
scaler = preprocessing.StandardScaler()
vectorizer = Vectorizer()
clf = SVC(C=1, kernel='linear')
concat_classifier = Pipeline([('vector', vectorizer), ('scaler', scaler),
('svm', clf)])
ev_list = list(rng.randint(3, 5, n_start)) # some random starting events
score_lv, score_rv, score_x = [], [], []
command = [sys.executable, 'rt_feedback_client.py']
with running_subprocess(command,
after='kill',
stdout=subprocess.PIPE,
def test_find_events():
"""Test find_events in rt_epochs."""
raw = mne.io.Raw(raw_fname, preload=True, verbose=False)
picks = mne.pick_types(raw.info,
meg='grad',
eeg=False,
eog=True,
stim=True,
exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=stim_channel)
# Reset some data for ease of comparison
raw.first_samp = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 1)
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 3)
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 0)
# ouput='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 5)
def test_find_events():
"""Test find_events in rt_epochs."""
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel])
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
raw._update_times()
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
# make sure next() works even if no iter-method has been called before
rt_epochs.next()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 1
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 3
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# output='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 5
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events at the beginning of the buffer
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 1000:1005] = 5
raw._update_times()
# Check that we find events that start at the beginning of the buffer
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events over different buffers
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 997:1003] = 5
raw._update_times()
for min_dur in [0.002, 0.004]:
find_events = dict(consecutive=False, min_duration=min_dur)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10,
buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
print(__doc__)
# Load fiff file to simulate data
data_path = sample.data_path()
raw_fname = data_path + "/MEG/sample/sample_audvis_filt-0-40_raw.fif"
raw = mne.io.read_raw_fif(raw_fname, preload=True)
# Instantiating stimulation server
# The with statement is necessary to ensure a clean exit
with StimServer("localhost", port=4218) as stim_server:
# The channels to be used while decoding
picks = mne.pick_types(raw.info, meg="grad", eeg=False, eog=True, stim=True, exclude=raw.info["bads"])
rt_client = MockRtClient(raw)
# Constructing the pipeline for classification
filt = FilterEstimator(raw.info, 1, 40)
scaler = preprocessing.StandardScaler()
vectorizer = EpochsVectorizer()
clf = SVC(C=1, kernel="linear")
concat_classifier = Pipeline([("filter", filt), ("vector", vectorizer), ("scaler", scaler), ("svm", clf)])
stim_server.start(verbose=True)
# Just some initially decided events to be simulated
# Rest will decided on the fly
ev_list = [4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4]
def test_find_events():
"""Test find_events in rt_epochs."""
raw = mne.io.read_raw_fif(raw_fname, preload=True, verbose=False)
picks = mne.pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel])
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
raw._update_times()
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 1)
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 3)
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 0)
# ouput='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 5)
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
raw = mne.io.read_raw_fif(raw_fname, preload=True)
tmin, tmax = -0.2, 0.5
event_id = dict(aud_l=1, vis_l=3)
tr_percent = 60 # Training percentage
min_trials = 10 # minimum trials after which decoding should start
# select gradiometers
picks = mne.pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
# create the mock-client object
rt_client = MockRtClient(raw)
# create the real-time epochs object
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6))
# start the acquisition
rt_epochs.start()
# send raw buffers
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=90, buffer_size=1000)
# Decoding in sensor space using a linear SVM
n_times = len(rt_epochs.times)
from sklearn import preprocessing # noqa
tmin, tmax = -0.2, 0.5
event_id = dict(aud_l=1, vis_l=3)
tr_percent = 60 # Training percentage
min_trials = 10 # minimum trials after which decoding should start
# select gradiometers
picks = mne.pick_types(raw.info,
meg='grad',
eeg=False,
eog=True,
stim=True,
exclude=raw.info['bads'])
# create the mock-client object
rt_client = MockRtClient(raw)
# create the real-time epochs object
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
decim=1,
reject=dict(grad=4000e-13, eog=150e-6),
baseline=None,
isi_max=4.)
# start the acquisition
rt_epochs.start()
def test_find_events():
"""Test find_events in rt_epochs."""
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel])
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
raw._update_times()
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 1
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 3
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# output='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 5
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events at the beginning of the buffer
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 1000:1005] = 5
raw._update_times()
# Check that we find events that start at the beginning of the buffer
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events over different buffers
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 997:1003] = 5
raw._update_times()
for min_dur in [0.002, 0.004]:
find_events = dict(consecutive=False, min_duration=min_dur)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10,
buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
