def test_filter_picks():
"""Test filtering default channel picks"""
ch_types = ['mag', 'grad', 'eeg', 'seeg', 'misc', 'stim']
info = create_info(ch_names=ch_types, ch_types=ch_types, sfreq=256)
raw = RawArray(data=np.zeros((len(ch_types), 1000)), info=info)
# -- Deal with meg mag grad exception
ch_types = ('misc', 'stim', 'meg', 'eeg', 'seeg')
# -- Filter data channels
for ch_type in ('mag', 'grad', 'eeg', 'seeg'):
picks = dict((ch, ch == ch_type) for ch in ch_types)
picks['meg'] = ch_type if ch_type in ('mag', 'grad') else False
raw_ = raw.pick_types(copy=True, **picks)
# Avoid RuntimeWarning due to Attenuation
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw_.filter(10, 30)
assert_true(len(w) == 1)
# -- Error if no data channel
for ch_type in ('misc', 'stim'):
picks = dict((ch, ch == ch_type) for ch in ch_types)
raw_ = raw.pick_types(copy=True, **picks)
assert_raises(RuntimeError, raw_.filter, 10, 30)
def test_filter_picks():
"""Test filtering default channel picks"""
ch_types = ['mag', 'grad', 'eeg', 'seeg', 'misc', 'stim']
info = create_info(ch_names=ch_types, ch_types=ch_types, sfreq=256)
raw = RawArray(data=np.zeros((len(ch_types), 1000)), info=info)
# -- Deal with meg mag grad exception
ch_types = ('misc', 'stim', 'meg', 'eeg', 'seeg')
# -- Filter data channels
for ch_type in ('mag', 'grad', 'eeg', 'seeg'):
picks = dict((ch, ch == ch_type) for ch in ch_types)
picks['meg'] = ch_type if ch_type in ('mag', 'grad') else False
raw_ = raw.pick_types(copy=True, **picks)
# Avoid RuntimeWarning due to Attenuation
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw_.filter(10, 30)
assert_true(len(w) == 1)
# -- Error if no data channel
for ch_type in ('misc', 'stim'):
picks = dict((ch, ch == ch_type) for ch in ch_types)
raw_ = raw.pick_types(copy=True, **picks)
assert_raises(RuntimeError, raw_.filter, 10, 30)
def _update(self):
mne_info = self.traverse_back_and_find('mne_info')
input_array = self.input_node.output
if self.mode == 'train':
raw_array = RawArray(input_array, mne_info, verbose='ERROR')
raw_array.pick_types(eeg=True,
meg=False,
stim=False,
exclude='bads')
if (self.PortalWorker.params.preproc == 'adafreq'):
self.PortalWorker.params.setWinSizeAndStep(winSize=2, step=1)
[comps, diaps] = autoSelectComps(self.PortalWorker.params,
list([raw_array]),
self.trainTriggersAllClasses,
self.trainOnsetsAllClasses,
self.trainFinOnsetsAllClasses,
compThresh=0.65,
minCompsNum=5)
self.PortalWorker.params.winSize = self.PortalParams.winSize
self.PortalWorker.params.step = self.PortalParams.step
self.PortalWorker.params.channelSelect = comps
self.PortalWorker.params.fDiaps = diaps
self.PortalWorker.train(list([raw_array]),
self.trainTriggers,
self.trainOnsets,
self.finTrainOnsets,
doBalanceLabels=True)
if (self.mode == 'test'):
self.output = self.PortalWorker.processChunk(input_array)
def test_picks_by_channels():
"""Test creating pick_lists."""
rng = np.random.RandomState(909)
test_data = rng.random_sample((4, 2000))
ch_names = ['MEG %03d' % i for i in [1, 2, 3, 4]]
ch_types = ['grad', 'mag', 'mag', 'eeg']
sfreq = 250.0
info = create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
_assert_channel_types(info)
raw = RawArray(test_data, info)
pick_list = _picks_by_type(raw.info)
assert_equal(len(pick_list), 3)
assert_equal(pick_list[0][0], 'mag')
pick_list2 = _picks_by_type(raw.info, meg_combined=False)
assert_equal(len(pick_list), len(pick_list2))
assert_equal(pick_list2[0][0], 'mag')
pick_list2 = _picks_by_type(raw.info, meg_combined=True)
assert_equal(len(pick_list), len(pick_list2) + 1)
assert_equal(pick_list2[0][0], 'meg')
test_data = rng.random_sample((4, 2000))
ch_names = ['MEG %03d' % i for i in [1, 2, 3, 4]]
ch_types = ['mag', 'mag', 'mag', 'mag']
sfreq = 250.0
info = create_info(ch_names=ch_names, sfreq=sfreq, ch_types=ch_types)
raw = RawArray(test_data, info)
# This acts as a set, not an order
assert_array_equal(pick_channels(info['ch_names'], ['MEG 002', 'MEG 001']),
[0, 1])
# Make sure checks for list input work.
pytest.raises(ValueError, pick_channels, ch_names, 'MEG 001')
pytest.raises(ValueError, pick_channels, ch_names, ['MEG 001'], 'hi')
pick_list = _picks_by_type(raw.info)
assert_equal(len(pick_list), 1)
assert_equal(pick_list[0][0], 'mag')
pick_list2 = _picks_by_type(raw.info, meg_combined=True)
assert_equal(len(pick_list), len(pick_list2))
assert_equal(pick_list2[0][0], 'mag')
# pick_types type check
with pytest.raises(ValueError, match='must be of type'):
raw.pick_types(eeg='string')
# duplicate check
names = ['MEG 002', 'MEG 002']
assert len(pick_channels(raw.info['ch_names'], names)) == 1
assert len(raw.copy().pick_channels(names)[0][0]) == 1
def test_find_events():
"""Test find events in raw file."""
events = read_events(fname)
raw = read_raw_fif(raw_fname, preload=True)
# let's test the defaulting behavior while we're at it
extra_ends = ['', '_1']
orig_envs = [os.getenv('MNE_STIM_CHANNEL%s' % s) for s in extra_ends]
os.environ['MNE_STIM_CHANNEL'] = 'STI 014'
if 'MNE_STIM_CHANNEL_1' in os.environ:
del os.environ['MNE_STIM_CHANNEL_1']
events2 = find_events(raw)
assert_array_almost_equal(events, events2)
# now test with mask
events11 = find_events(raw, mask=3, mask_type='not_and')
with pytest.warns(RuntimeWarning, match='events masked'):
events22 = read_events(fname, mask=3, mask_type='not_and')
assert_array_equal(events11, events22)
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel])
# test digital masking
raw._data[stim_channel_idx, :5] = np.arange(5)
raw._data[stim_channel_idx, 5:] = 0
# 1 == '0b1', 2 == '0b10', 3 == '0b11', 4 == '0b100'
pytest.raises(TypeError, find_events, raw, mask="0", mask_type='and')
pytest.raises(ValueError, find_events, raw, mask=0, mask_type='blah')
# testing mask_type. default = 'not_and'
assert_array_equal(
find_events(raw, shortest_event=1, mask=1, mask_type='not_and'),
[[2, 0, 2], [4, 2, 4]])
assert_array_equal(
find_events(raw, shortest_event=1, mask=2, mask_type='not_and'),
[[1, 0, 1], [3, 0, 1], [4, 1, 4]])
assert_array_equal(
find_events(raw, shortest_event=1, mask=3, mask_type='not_and'),
[[4, 0, 4]])
assert_array_equal(
find_events(raw, shortest_event=1, mask=4, mask_type='not_and'),
[[1, 0, 1], [2, 1, 2], [3, 2, 3]])
# testing with mask_type = 'and'
assert_array_equal(
find_events(raw, shortest_event=1, mask=1, mask_type='and'),
[[1, 0, 1], [3, 0, 1]])
assert_array_equal(
find_events(raw, shortest_event=1, mask=2, mask_type='and'),
[[2, 0, 2]])
assert_array_equal(
find_events(raw, shortest_event=1, mask=3, mask_type='and'),
[[1, 0, 1], [2, 1, 2], [3, 2, 3]])
assert_array_equal(
find_events(raw, shortest_event=1, mask=4, mask_type='and'),
[[4, 0, 4]])
# test empty events channel
raw._data[stim_channel_idx, :] = 0
assert_array_equal(find_events(raw), np.empty((0, 3), dtype='int32'))
raw._data[stim_channel_idx, :4] = 1
assert_array_equal(find_events(raw), np.empty((0, 3), dtype='int32'))
raw._data[stim_channel_idx, -1:] = 9
assert_array_equal(find_events(raw), [[14399, 0, 9]])
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, 10:20] = 5
raw._data[stim_channel_idx, 20:30] = 6
raw._data[stim_channel_idx, 30:32] = 5
raw._data[stim_channel_idx, 40] = 6
assert_array_equal(find_events(raw, consecutive=False),
[[10, 0, 5], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(
find_events(raw, consecutive=True),
[[10, 0, 5], [20, 5, 6], [30, 6, 5], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(find_events(raw),
[[10, 0, 5], [20, 5, 6], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(find_events(raw, output='offset', consecutive=False),
[[31, 0, 5], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(
find_events(raw, output='offset', consecutive=True),
[[19, 6, 5], [29, 5, 6], [31, 0, 5], [40, 0, 6], [14399, 0, 9]])
pytest.raises(ValueError,
find_events,
raw,
output='step',
consecutive=True)
assert_array_equal(
find_events(raw, output='step', consecutive=True, shortest_event=1),
[[10, 0, 5], [20, 5, 6], [30, 6, 5], [32, 5, 0], [40, 0, 6],
[41, 6, 0], [14399, 0, 9], [14400, 9, 0]])
assert_array_equal(find_events(raw, output='offset'),
[[19, 6, 5], [31, 0, 6], [40, 0, 6], [14399, 0, 9]])
assert_array_equal(find_events(raw, consecutive=False, min_duration=0.002),
[[10, 0, 5]])
assert_array_equal(find_events(raw, consecutive=True, min_duration=0.002),
[[10, 0, 5], [20, 5, 6], [30, 6, 5]])
assert_array_equal(
find_events(raw,
output='offset',
consecutive=False,
min_duration=0.002), [[31, 0, 5]])
assert_array_equal(
find_events(raw, output='offset', consecutive=True,
min_duration=0.002), [[19, 6, 5], [29, 5, 6], [31, 0, 5]])
assert_array_equal(find_events(raw, consecutive=True, min_duration=0.003),
[[10, 0, 5], [20, 5, 6]])
# test find_stim_steps merge parameter
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 0] = 1
raw._data[stim_channel_idx, 10] = 4
raw._data[stim_channel_idx, 11:20] = 5
assert_array_equal(
find_stim_steps(raw, pad_start=0, merge=0, stim_channel=stim_channel),
[[0, 0, 1], [1, 1, 0], [10, 0, 4], [11, 4, 5], [20, 5, 0]])
assert_array_equal(
find_stim_steps(raw, merge=-1, stim_channel=stim_channel),
[[1, 1, 0], [10, 0, 5], [20, 5, 0]])
assert_array_equal(
find_stim_steps(raw, merge=1, stim_channel=stim_channel),
[[1, 1, 0], [11, 0, 5], [20, 5, 0]])
# put back the env vars we trampled on
for s, o in zip(extra_ends, orig_envs):
if o is not None:
os.environ['MNE_STIM_CHANNEL%s' % s] = o
# Test with list of stim channels
raw._data[stim_channel_idx, 1:101] = np.zeros(100)
raw._data[stim_channel_idx, 10:11] = 1
raw._data[stim_channel_idx, 30:31] = 3
stim_channel2 = 'STI 015'
stim_channel2_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel2])
raw._data[stim_channel2_idx, :] = 0
raw._data[stim_channel2_idx, :100] = raw._data[stim_channel_idx, 5:105]
events1 = find_events(raw, stim_channel='STI 014')
events2 = events1.copy()
events2[:, 0] -= 5
events = find_events(raw, stim_channel=['STI 014', stim_channel2])
assert_array_equal(events[::2], events2)
assert_array_equal(events[1::2], events1)
# test initial_event argument
info = create_info(['MYSTI'], 1000, 'stim')
data = np.zeros((1, 1000))
raw = RawArray(data, info)
data[0, :10] = 100
data[0, 30:40] = 200
assert_array_equal(find_events(raw, 'MYSTI'), [[30, 0, 200]])
assert_array_equal(find_events(raw, 'MYSTI', initial_event=True),
[[0, 0, 100], [30, 0, 200]])
# test error message for raw without stim channels
raw = read_raw_fif(raw_fname, preload=True)
raw.pick_types(meg=True, stim=False)
# raw does not have annotations
with pytest.raises(ValueError, match="'stim_channel'"):
find_events(raw)
# if raw has annotations, we show a different error message
raw.set_annotations(Annotations(0, 2, "test"))
with pytest.raises(ValueError, match="mne.events_from_annotations"):
find_events(raw)
def main():
print "Using MNE", mne.__version__
opts = parse_args()
verbose = opts.debug
# constants
sfreq = 125.0
class_labels = {'left': 2, 'right': 3}
# files
train_fname = "data/custom/trials/motor-imagery-subject-A-train-1.csv"
test_fname = "data/custom/trials/motor-imagery-subject-A-test-1.csv"
#train_fname = "data/custom/trials/motor-imagery-trial-subject-A-10-26-2016_01-54-59.csv"
#train_fname = "data/custom/bci4/train/ds1g.txt"
#test_fname = "data/custom/bci4/test/ds1g.txt"
#train_fname = "data/custom/bci4/active_train/ds1b.txt"
#test_fname = "data/custom/bci4/active_test/ds1b.txt"
#################
# LOAD DATA
eval_start = time.clock()
# load train data from training file
[train_nparray, train_info] = file_to_nparray(train_fname,
sfreq=sfreq,
verbose=verbose)
end = time.clock()
print "train dataset", train_fname, "loaded in ", str(
end - eval_start), "seconds"
eval_start = time.clock()
# load test data from test file
[test_nparray, test_info] = file_to_nparray(test_fname,
sfreq=sfreq,
verbose=verbose)
end = time.clock()
print "test dataset", test_fname, "loaded in ", str(end -
eval_start), "seconds"
total_start = time.clock()
##################
# CLASSIFY DATA
# pick a subset of total electrodes, or else just get all of the channels of type 'eeg'
picks = getPicks('openbci16') or pick_types(train_info, eeg=True)
# hyperparam 1
bandpass_filters = get_bandpass_ranges()
# hyperparam 2
epoch_bounds = get_window_ranges()
# extract X,y from train data
train_raw = RawArray(train_nparray, train_info, verbose=verbose)
train_events = mne.find_events(train_raw,
shortest_event=0,
consecutive=True,
verbose=verbose)
train_epochs = Epochs(raw=train_raw,
events=train_events,
event_id=class_labels,
tmin=-0.5,
tmax=3.5,
proj=False,
picks=picks,
baseline=None,
preload=True,
add_eeg_ref=False,
verbose=verbose)
train_X = train_epochs.get_data()
train_y = train_epochs.events[:, -1] - 2 # convert classes [2,3] to [0,1]
# extract X,y from test data
test_raw = RawArray(test_nparray, test_info, verbose=verbose)
test_events = mne.find_events(test_raw,
shortest_event=0,
consecutive=True,
verbose=verbose)
test_epochs = Epochs(raw=test_raw,
events=test_events,
event_id=class_labels,
tmin=-0.5,
tmax=3.5,
proj=False,
picks=picks,
baseline=None,
preload=True,
add_eeg_ref=False,
verbose=verbose)
test_X = test_epochs.get_data()
test_y = test_epochs.events[:, -1] - 2 # convert classes [2,3] to [0,1]
# custom grid search
estimator1 = CSPEstimator(bandpass_filters=bandpass_filters,
epoch_bounds=epoch_bounds,
num_spatial_filters=6,
class_labels=class_labels,
sfreq=sfreq,
picks=picks,
num_votes=6,
consecutive=True)
estimator1.fit(train_X, train_y)
#
exit()
print
# print
print "-------------------------------------------"
print "-------------------------------------------"
print "-------------------------------------------"
print "-------------------------------------------"
print
time.sleep(10)
# custom grid search
estimator2 = CSPEstimator(bandpass_filters=bandpass_filters,
epoch_bounds=epoch_bounds,
num_spatial_filters=6,
class_labels=class_labels,
sfreq=sfreq,
picks=picks,
num_votes=6,
consecutive=True)
estimator2.fit(train_X, train_y, type="lr")
#
print "-------------------------------------------"
print "LDA"
score = estimator1.score(test_X, test_y)
print "average estimator score", score
print "-------------------------------------------"
print "LOGISTIC REGRESSION"
score = estimator2.score(test_X, test_y)
print "average estimator score", score
print "training run time", round(time.clock() - total_start, 1), "sec"
exit()
# just a pause here to allow visual inspection of top classifiers picked by grid search
time.sleep(15)
# now we go into predict mode, in which we are going over the test data using sliding windows
# this is a simulation of what would happen if we were in "online" mode with live data
# for each window, a prediction is given by the ensemble of top classifiers
# next to this, we see the actual labels from the real data (i.e. the y vector)
print "-------------------------------------------"
print "PREDICT"
print
####################################################
# looping over test data in windows
online_data = test_raw._data[picks]
online_labels = test_raw.pick_types(stim=True)._data
print "test_X", test_X.shape
print "test RAW data", online_data.shape
print "test RAW labels", online_labels.shape
window_size = 150 # 50 sample = 0.5 s
window_overlap = 150 #
np.set_printoptions(suppress=True)
for i in xrange(0, online_data.shape[1] - window_size, window_overlap):
start = i
end = i + window_size
window = online_data[:, start:end]
class_labels = online_labels[:, start:end]
#print window.shape
#print class_labels
estimator.predict(window, class_labels)
#print i,":",i+window_size
exit()
estimator.predict(test_X[0:10], test_y[0:10])
print
print "total run time", round(time.clock() - total_start, 1), "sec"
exit()
def main():
print "Using MNE", mne.__version__
opts = parse_args()
verbose = opts.debug
# constants
sfreq = 100.0
class_labels = {'left': 2, 'right': 3}
# files
train_fname = "data/custom/bci4/train/ds1g.txt"
test_fname = "data/custom/bci4/test/ds1g.txt"
#train_fname = "data/custom/bci4/active_train/ds1g.txt"
#test_fname = "data/custom/bci4/active_test/ds1g.txt"
#################
# LOAD DATA
eval_start = time.clock()
# load train data from training file
[train_nparray, train_info] = file_to_nparray(train_fname,
sfreq=sfreq,
verbose=verbose)
end = time.clock()
print "train dataset", train_fname, "loaded in ", str(
end - eval_start), "seconds"
eval_start = time.clock()
# load test data from test file
[test_nparray, test_info] = file_to_nparray(test_fname,
sfreq=sfreq,
verbose=verbose)
end = time.clock()
print "test dataset", test_fname, "loaded in ", str(end -
eval_start), "seconds"
total_start = time.clock()
##################
# CLASSIFY DATA
# pick a subset of total electrodes, or else just get all of the channels of type 'eeg'
picks = getPicks('motor16') or pick_types(train_info, eeg=True)
# hyperparam 1
bandpass_filters = get_bandpass_ranges()
# hyperparam 2
epoch_bounds = get_window_ranges()
# extract X,y from train data
train_raw = RawArray(train_nparray, train_info, verbose=verbose)
train_events = mne.find_events(train_raw,
shortest_event=0,
consecutive=True,
verbose=verbose)
train_epochs = Epochs(raw=train_raw,
events=train_events,
event_id=class_labels,
tmin=-0.5,
tmax=3.5,
proj=False,
picks=picks,
baseline=None,
preload=True,
add_eeg_ref=False,
verbose=verbose)
train_X = train_epochs.get_data()
train_y = train_epochs.events[:, -1] - 2 # convert classes [2,3] to [0,1]
# extract X,y from test data
test_raw = RawArray(test_nparray, test_info, verbose=verbose)
test_events = mne.find_events(test_raw,
shortest_event=0,
consecutive=True,
verbose=verbose)
test_epochs = Epochs(raw=test_raw,
events=test_events,
event_id=class_labels,
tmin=-0.5,
tmax=3.5,
proj=False,
picks=picks,
baseline=None,
preload=True,
add_eeg_ref=False,
verbose=verbose)
test_X = test_epochs.get_data()
test_y = test_epochs.events[:, -1] - 2 # convert classes [2,3] to [0,1]
# custom grid search
estimator = CSPEstimator(bandpass_filters=bandpass_filters,
epoch_bounds=epoch_bounds,
num_spatial_filters=6,
class_labels=class_labels,
sfreq=sfreq,
picks=picks,
num_votes=6,
consecutive=True)
estimator.fit(train_X, train_y)
#
print "-------------------------------------------"
score = estimator.score(test_X, test_y)
print "-------------------------------------------"
print "average estimator score", score
print
# print
print "-------------------------------------------"
print
print "training run time", round(time.clock() - total_start, 1), "sec"
exit()
# just a pause here to allow visual inspection of top classifiers picked by grid search
time.sleep(15)
# """
# Riemannian estimations
# """
# # preprocess
#
# # trim vars
# epoch_trim_start = 1.0
# epoch_trim_end = 2.0
# # bandpass filter coefficients
# b, a = butter(5, np.array([7.0,35.0])/(100*0.5), 'bandpass')
# # cross validation
# cv = KFold(len(train_y), 10, shuffle=True, random_state=42)
#
# # filter and crop TRAINING SET
# train_X = preprocess_X(train_X, b, a, epoch_trim_start, epoch_trim_end, sfreq)
#
# # filter and crop TEST SET
# test_X = preprocess_X(test_X, b, a, epoch_trim_start, epoch_trim_end, sfreq)
#
#
# """
# Covariance computation
# """
# # compute covariance matrices
# cov_data_train = covariances(X=train_X)
# cov_data_test = covariances(X=test_X)
#
# """
# Classification with Minimum distance to mean (MDM)
# """
# mdm = MDM(metric=dict(mean='riemann', distance='riemann'))
# # Use scikit-learn Pipeline with cross_val_score function
# scores = cross_val_score(mdm, cov_data_train, train_y, cv=cv, n_jobs=1)
# # Printing the results
# print "MDM Classification accuracy:",np.mean(scores)
# print scores
#
# """
# Classification with Tangent Space Logistic Regression
# """
# clf = TSclassifier()
# # Use scikit-learn Pipeline with cross_val_score function
# scores = cross_val_score(clf, cov_data_train, train_y, cv=cv, n_jobs=1)
# # Printing the results
# print "Tangent space Classification accuracy:",np.mean(scores)
# print scores
#
# print "--------------------------------------"
# print
#
# clf1 = MDM(metric=dict(mean='riemann', distance='riemann'))
# clf1.fit(cov_data_train, train_y)
# score1 = clf1.score(cov_data_test, test_y)
# print "MDM prediction score:",score1
#
# clf2 = TSclassifier()
# clf2.fit(cov_data_train, train_y)
# score2 = clf2.score(cov_data_test, test_y)
# print "Tangent space w/LR score:", score2
#
# clf3 = Potato()
# clf3.fit(cov_data_train[np.where(train_y==0)])
# score3 = clf3.score(cov_data_test, test_y)
# print "Potato score:", score3
#
#
# exit()
# now we go into predict mode, in which we are going over the test data using sliding windows
# this is a simulation of what would happen if we were in "online" mode with live data
# for each window, a prediction is given by the ensemble of top classifiers
# next to this, we see the actual labels from the real data (i.e. the y vector)
print "-------------------------------------------"
print "PREDICT"
print
####################################################
# looping over test data in windows
online_data = test_raw._data[picks]
online_labels = test_raw.pick_types(stim=True)._data
print "test_X", test_X.shape
print "test RAW data", online_data.shape
print "test RAW labels", online_labels.shape
window_size = 150 # 50 sample = 0.5 s
window_overlap = 50 #
np.set_printoptions(suppress=True)
for i in xrange(0, online_data.shape[1] - window_size, window_overlap):
start = i
end = i + window_size
window = online_data[:, start:end]
class_labels = online_labels[:, start:end]
#print window.shape
#print class_labels
estimator.predict(window, class_labels)
#print i,":",i+window_size
exit()
estimator.predict(test_X[0:10], test_y[0:10])
print
print "total run time", round(time.clock() - total_start, 1), "sec"
exit()
def main():
print "Using MNE", mne.__version__
opts = parse_args()
verbose = opts.debug
# constants
sfreq = 100.0
class_labels = {'left':2, 'right':3}
# files
train_fname = "data/custom/bci4/train/ds1g.txt"
test_fname = "data/custom/bci4/test/ds1g.txt"
#train_fname = "data/custom/bci4/active_train/ds1b.txt"
#test_fname = "data/custom/bci4/active_test/ds1b.txt"
#################
# LOAD DATA
eval_start = time.clock()
# load train data from training file
[train_nparray, train_info] = file_to_nparray(train_fname, sfreq=sfreq, verbose=verbose)
end = time.clock()
print "train dataset", train_fname, "loaded in ", str(end - eval_start),"seconds"
eval_start = time.clock()
# load test data from test file
[test_nparray, test_info] = file_to_nparray(test_fname, sfreq=sfreq, verbose=verbose)
end = time.clock()
print "test dataset", test_fname, "loaded in ", str(end - eval_start),"seconds"
total_start = time.clock()
##################
# CLASSIFY DATA
# pick a subset of total electrodes, or else just get all of the channels of type 'eeg'
picks = getPicks('motor16') or pick_types(train_info, eeg=True)
# hyperparam 1
bandpass_filters = get_bandpass_ranges()
# hyperparam 2
epoch_bounds = get_window_ranges()
# extract X,y from train data
train_raw = RawArray(train_nparray, train_info, verbose=verbose)
train_events = mne.find_events(train_raw, shortest_event=0, consecutive=True, verbose=verbose)
train_epochs = Epochs(raw=train_raw, events=train_events, event_id=class_labels,
tmin=-0.5, tmax=3.5, proj=False, picks=picks, baseline=None,
preload=True, add_eeg_ref=False, verbose=verbose)
train_X = train_epochs.get_data()
train_y = train_epochs.events[:, -1] - 2 # convert classes [2,3] to [0,1]
# extract X,y from test data
test_raw = RawArray(test_nparray, test_info, verbose=verbose)
test_events = mne.find_events(test_raw, shortest_event=0, consecutive=True, verbose=verbose)
test_epochs = Epochs(raw=test_raw, events=test_events, event_id=class_labels,
tmin=-0.5, tmax=3.5, proj=False, picks=picks, baseline=None,
preload=True, add_eeg_ref=False, verbose=verbose)
test_X = test_epochs.get_data()
test_y = test_epochs.events[:, -1] - 2 # convert classes [2,3] to [0,1]
# custom grid search
estimator = CSPEstimator(bandpass_filters=bandpass_filters,
epoch_bounds=epoch_bounds,
num_spatial_filters=6,
class_labels=class_labels,
sfreq=sfreq,
picks=picks,
num_votes=6,
consecutive=True)
estimator.fit(train_X,train_y)
#
print "-------------------------------------------"
score = estimator.score(test_X,test_y)
print "-------------------------------------------"
print "average estimator score",score
print
# print
print "-------------------------------------------"
print
print "training run time", round(time.clock() - total_start,1),"sec"
#exit()
# just a pause here to allow visual inspection of top classifiers picked by grid search
time.sleep(15)
# now we go into predict mode, in which we are going over the test data using sliding windows
# this is a simulation of what would happen if we were in "online" mode with live data
# for each window, a prediction is given by the ensemble of top classifiers
# next to this, we see the actual labels from the real data (i.e. the y vector)
print "-------------------------------------------"
print "PREDICT"
print
####################################################
# looping over test data in windows
online_data = test_raw._data[picks]
online_labels = test_raw.pick_types(stim=True)._data
print "test_X", test_X.shape
print "test RAW data",online_data.shape
print "test RAW labels",online_labels.shape
window_size = 150 # 50 sample = 0.5 s
window_overlap = 50 #
np.set_printoptions(suppress=True)
for i in xrange(0, online_data.shape[1]-window_size, window_overlap):
start = i
end = i + window_size
window = online_data[:,start:end]
class_labels = online_labels[:,start:end]
#print window.shape
#print class_labels
estimator.predict(window, class_labels)
#print i,":",i+window_size
exit()
estimator.predict(test_X[0:10], test_y[0:10])
print
print "total run time", round(time.clock() - total_start,1),"sec"
exit()
