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(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)
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_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_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_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
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(port=4218) as stim_server: # The channels to be used while decoding picks = mne.pick_types(raw.info, meg='grad', eeg=False, eog=False, stim=False, exclude=raw.info['bads']) rt_client = MockRtClient(raw) # Constructing the pipeline for classification # don't highpass filter because of short signal length of epochs filt = FilterEstimator( raw.info, None, 40, # keep all channels that are picked from the # RtClient picks=np.arange(len(picks), dtype=int)) scaler = preprocessing.StandardScaler() vectorizer = Vectorizer() clf = SVC(C=1, kernel='linear') concat_classifier = Pipeline([('filter', filt), ('vector', vectorizer),