def predict_outputs(self):
n_folds = len(self.binary_csp.folds)
n_class_pairs = len(self.binary_csp.class_pairs)
result_shape = (n_folds, n_class_pairs)
self.train_accuracy = np.empty(result_shape, dtype=float)
self.test_accuracy = np.empty(result_shape, dtype=float)
self.train_pred_full_fold = np.empty(result_shape, dtype=object)
self.test_pred_full_fold = np.empty(result_shape, dtype=object)
for fold_i in range(n_folds):
log.info("Fold Nr: {:d}".format(fold_i + 1))
for class_i, class_pair in enumerate(self.binary_csp.class_pairs):
clf = self.clf[fold_i, class_i]
class_pair_plus_one = (np.array(class_pair) + 1).tolist()
log.info("Class {:d} vs {:d}".format(*class_pair_plus_one))
train_feature = self.train_feature[fold_i, class_i]
train_out = lda_apply(train_feature, clf)
correct_train = train_feature.axes[0] == class_pair[1]
predicted_train = train_out >= 0
train_accuracy = (sum(correct_train == predicted_train) /
float(len(predicted_train)))
self.train_accuracy[fold_i, class_i] = train_accuracy
test_feature = self.test_feature[fold_i, class_i]
test_out = lda_apply(test_feature, clf)
correct_test = test_feature.axes[0] == class_pair[1]
predicted_test = test_out >= 0
test_accuracy = (sum(correct_test == predicted_test) /
float(len(predicted_test)))
self.test_accuracy[fold_i, class_i] = test_accuracy
train_feature_full_fold = self.train_feature_full_fold[fold_i,\
class_i]
train_out_full_fold = lda_apply(train_feature_full_fold, clf)
self.train_pred_full_fold[fold_i,
class_i] = train_out_full_fold
test_feature_full_fold = self.test_feature_full_fold[fold_i,\
class_i]
test_out_full_fold = lda_apply(test_feature_full_fold, clf)
self.test_pred_full_fold[fold_i, class_i] = test_out_full_fold
log.info("Train: {:4.2f}%".format(train_accuracy * 100))
log.info("Test: {:4.2f}%".format(test_accuracy * 100))
def cross_validate_lda(features):
folds = KFold(features.data.shape[0], n_folds=5, shuffle=False)
test_accuracies = []
for train_inds, test_inds in folds:
train_features = features.copy(data=features.data[train_inds], axes=[features.axes[0][train_inds]])
test_features = features.copy(data=features.data[test_inds], axes=[features.axes[0][test_inds]])
clf = lda_train_scaled(train_features, shrink=True)
test_out = lda_apply(test_features, clf)
second_class_test = test_features.axes[0] == np.max(test_features.axes[0])
predicted_2nd_class_test = test_out >= 0
test_accuracy = sum(second_class_test == predicted_2nd_class_test) / float(len(predicted_2nd_class_test))
test_accuracies.append(test_accuracy)
return np.mean(test_accuracies)
def predict_outputs(self):
n_folds = len(self.binary_csp.folds)
n_class_pairs = len(self.binary_csp.class_pairs)
result_shape = (n_folds, n_class_pairs)
self.train_accuracy = np.empty(result_shape, dtype=float)
self.test_accuracy = np.empty(result_shape, dtype=float)
self.train_pred_full_fold = np.empty(result_shape, dtype=object)
self.test_pred_full_fold = np.empty(result_shape, dtype=object)
for fold_i in range(n_folds):
log.info("Fold Nr: {:d}".format(fold_i + 1))
for class_i, class_pair in enumerate(self.binary_csp.class_pairs):
clf = self.clf[fold_i, class_i]
class_pair_plus_one = (np.array(class_pair) + 1).tolist()
log.info("Class {:d} vs {:d}".format(*class_pair_plus_one))
train_feature = self.train_feature[fold_i, class_i]
train_out = lda_apply(train_feature, clf)
correct_train = train_feature.axes[0] == class_pair[1]
predicted_train = train_out >= 0
train_accuracy = sum(correct_train == predicted_train) / float(len(predicted_train))
self.train_accuracy[fold_i, class_i] = train_accuracy
test_feature = self.test_feature[fold_i, class_i]
test_out = lda_apply(test_feature, clf)
correct_test = test_feature.axes[0] == class_pair[1]
predicted_test = test_out >= 0
test_accuracy = sum(correct_test == predicted_test) / float(len(predicted_test))
self.test_accuracy[fold_i, class_i] = test_accuracy
train_feature_full_fold = self.train_feature_full_fold[fold_i, class_i]
train_out_full_fold = lda_apply(train_feature_full_fold, clf)
self.train_pred_full_fold[fold_i, class_i] = train_out_full_fold
test_feature_full_fold = self.test_feature_full_fold[fold_i, class_i]
test_out_full_fold = lda_apply(test_feature_full_fold, clf)
self.test_pred_full_fold[fold_i, class_i] = test_out_full_fold
log.info("Train: {:4.2f}%".format(train_accuracy * 100))
log.info("Test: {:4.2f}%".format(test_accuracy * 100))
def test_lda_apply_w_shrinkage(self):
"""trivial lda application must work."""
# this is not a proper test for LDA
data = np.random.random((50, 100))
labels = np.zeros(50)
data[::2] += 1
labels[::2] += 1
fv = Data(data=data, axes=[labels, np.arange(100)], units=["x", "y"], names=["foo", "bar"])
clf = lda_train(fv, shrink=True)
out = lda_apply(fv, clf)
# map projections back to 0s and 1s
out[out > 0] = 1
out[out < 0] = 0
np.testing.assert_array_equal(out, labels)
def test_lda_apply_w_shrinkage(self):
"""trivial lda application must work."""
# this is not a proper test for LDA
data = np.random.random((50, 100))
labels = np.zeros(50)
data[::2] += 1
labels[::2] += 1
fv = Data(data=data,
axes=[labels, np.arange(100)],
units=['x', 'y'],
names=['foo', 'bar'])
clf = lda_train(fv, shrink=True)
out = lda_apply(fv, clf)
# map projections back to 0s and 1s
out[out > 0] = 1
out[out < 0] = 0
np.testing.assert_array_equal(out, labels)
def cross_validate_lda(features):
folds = KFold(features.data.shape[0], n_folds=5, shuffle=False)
test_accuracies = []
for train_inds, test_inds in folds:
train_features = features.copy(data=features.data[train_inds],
axes=[features.axes[0][train_inds]])
test_features = features.copy(data=features.data[test_inds],
axes=[features.axes[0][test_inds]])
clf = lda_train_scaled(train_features, shrink=True)
test_out = lda_apply(test_features, clf)
second_class_test = test_features.axes[0] == np.max(
test_features.axes[0])
predicted_2nd_class_test = test_out >= 0
test_accuracy = (
sum(second_class_test == predicted_2nd_class_test) /
float(len(predicted_2nd_class_test)))
test_accuracies.append(test_accuracy)
return np.mean(test_accuracies)
def offline_experiment(filename_, cfy_, true_labels_):
print("\n")
cnt = io.load_bcicomp3_ds2(filename_)
fs_n = cnt.fs / 2
b, a = proc.signal.butter(5, [HIGH_CUT / fs_n], btype='low')
cnt = proc.filtfilt(cnt, b, a)
b, a = proc.signal.butter(5, [LOWER_CUT / fs_n], btype='high')
cnt = proc.filtfilt(cnt, b, a)
cnt = proc.subsample(cnt, SUBSAMPLING)
epo = proc.segment_dat(cnt, MARKER_DEF_TEST, SEG_IVAL)
fv = proc.jumping_means(epo, JUMPING_MEANS_INTERVALS)
fv = proc.create_feature_vectors(fv)
lda_out = proc.lda_apply(fv, cfy_)
markers = [fv.class_names[cls_idx] for cls_idx in fv.axes[0]]
result = zip(markers, lda_out)
endresult = []
markers_processed = 0
letter_prob = {i: 0 for i in 'abcdefghijklmnopqrstuvwxyz123456789_'}
for s, score in result:
if markers_processed == 180:
endresult.append(
sorted(letter_prob.items(), key=lambda x: x[1])[-1][0])
letter_prob = {
i: 0
for i in 'abcdefghijklmnopqrstuvwxyz123456789_'
}
markers_processed = 0
for letter in s:
letter_prob[letter] += score
markers_processed += 1
print('Letras Encontradas-: %s' % "".join(endresult))
print('Letras Corretas----: %s' % true_labels_)
acc = np.count_nonzero(
np.array(endresult) == np.array(
list(true_labels_.lower()[:len(endresult)]))) / len(endresult)
print("Acertividade Final : %d" % (acc * 100))
def online_erp(fs, n_channels, subsample):
logger.debug('Running Online ERP with {fs}Hz, and {channels}channels'.format(fs=fs, channels=n_channels))
target_fs = 100
# blocklen in ms
blocklen = 1000 * 1 / target_fs
# blocksize given the original fs and blocklen
blocksize = fs * (blocklen / 1000)
MRK_DEF = {'target': 'm'}
SEG_IVAL = [0, 700]
JUMPING_MEANS_IVALS = [150, 220], [200, 260], [310, 360], [550, 660]
RING_BUFFER_CAP = 1000
cfy = [0, 0]
fs_n = fs / 2
b_l, a_l = proc.signal.butter(5, [30 / fs_n], btype='low')
b_h, a_h = proc.signal.butter(5, [.4 / fs_n], btype='high')
zi_l = proc.lfilter_zi(b_l, a_l, n_channels)
zi_h = proc.lfilter_zi(b_h, a_h, n_channels)
ax_channels = np.array([str(i) for i in range(n_channels)])
names = ['time', 'channel']
units = ['ms', '#']
blockbuf = BlockBuffer(blocksize)
ringbuf = RingBuffer(RING_BUFFER_CAP)
times = []
# time since the last data was acquired
t_last = time.time()
# time since the last marker
t_last_marker = time.time()
# time since the experiment started
t_start = time.time()
full_iterations = 0
while full_iterations < 500:
t0 = time.time()
dt = time.time() - t_last
samples = int(dt * fs)
if samples == 0:
continue
t_last = time.time()
# get data
data = np.random.random((samples, n_channels))
ax_times = np.linspace(0, 1000 * (samples / fs), samples, endpoint=False)
if t_last_marker + .01 < time.time():
t_last_marker = time.time()
markers = [[ax_times[-1], 'm']]
else:
markers = []
cnt = Data(data, axes=[ax_times, ax_channels], names=names, units=units)
cnt.fs = fs
cnt.markers = markers
# blockbuffer
blockbuf.append(cnt)
cnt = blockbuf.get()
if not cnt:
continue
# filter
cnt, zi_l = proc.lfilter(cnt, b_l, a_l, zi=zi_l)
cnt, zi_h = proc.lfilter(cnt, b_h, a_h, zi=zi_h)
# subsample
if subsample:
cnt = proc.subsample(cnt, target_fs)
newsamples = cnt.data.shape[0]
# ringbuffer
ringbuf.append(cnt)
cnt = ringbuf.get()
# epoch
epo = proc.segment_dat(cnt, MRK_DEF, SEG_IVAL, newsamples=newsamples)
if not epo:
continue
# feature vectors
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
rv = proc.create_feature_vectors(fv)
# classification
proc.lda_apply(fv, cfy)
# don't measure in the first second, where the ringbuffer is not
# full yet.
if time.time() - t_start < (RING_BUFFER_CAP / 1000):
continue
dt = time.time() - t0
times.append(dt)
full_iterations += 1
return np.array(times)
def online_experiment(amp, cfy):
amp_fs = amp.get_sampling_frequency()
amp_channels = amp.get_channels()
# buf = BlockBuffer(4)
rb = RingBuffer(5000)
fn = amp_fs / 2
b_low, a_low = proc.signal.butter(5, [38 / fn], btype='low')
b_high, a_high = proc.signal.butter(5, [.1 / fn], btype='high')
zi_low = proc.lfilter_zi(b_low, a_low, len(amp_channels))
zi_high = proc.lfilter_zi(b_high, a_high, len(amp_channels))
amp.start()
print("Iniciando simulacao em 5s...")
for x in xrange(4, 0, -1):
time.sleep(1)
print("%ds" % x)
pass
markers_processed = 0
current_letter_idx = 0
current_letter = TRUE_LABELS[current_letter_idx].lower()
letter_prob = {i: 0 for i in 'abcdefghijklmnopqrstuvwxyz123456789_'}
endresult = []
t0 = time.time()
while True:
t0 = time.time()
# get fresh data from the amp
data, markers = amp.get_data()
if len(data) == 0:
continue
# we should rather wait for a specific end-of-experiment marker
if len(data) == 0:
break
# convert to cnt
cnt = io.convert_mushu_data(data, markers, amp_fs, amp_channels)
# enter the block buffer
# buf.append(cnt)
# cnt = buf.get()
# if not cnt:
# continue
# band-pass and subsample
cnt, zi_low = proc.lfilter(cnt, b_low, a_low, zi=zi_low)
cnt, zi_high = proc.lfilter(cnt, b_high, a_high, zi=zi_high)
cnt = proc.subsample(cnt, 60)
newsamples = cnt.data.shape[0]
# enter the ringbuffer
rb.append(cnt)
cnt = rb.get()
# segment
epo = proc.segment_dat(cnt,
MARKER_DEF_TEST,
SEG_IVAL,
newsamples=newsamples)
if not epo:
continue
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
print("\n")
logger.info('Step : %d' % markers_processed)
lda_out = proc.lda_apply(fv, cfy)
markers = [fv.class_names[cls_idx] for cls_idx in fv.axes[0]]
result = zip(markers, lda_out)
for s, score in result:
if markers_processed == 180:
endresult.append(
sorted(letter_prob.items(), key=lambda x: x[1])[-1][0])
letter_prob = {
i: 0
for i in 'abcdefghijklmnopqrstuvwxyz123456789_'
}
markers_processed = 0
current_letter_idx += 1
current_letter = TRUE_LABELS[current_letter_idx].lower()
for letter in s:
letter_prob[letter] += score
markers_processed += 1
print('Letra Atual Correta-: %s ' % current_letter)
print("Letra provavel--: %s" % "".join([
i[0] for i in sorted(
letter_prob.items(), key=lambda x: x[1], reverse=True)
]).replace(current_letter, " '%s' " % current_letter))
print('Letras Corretas----: %s' % TRUE_LABELS)
# discovered = BuildDiscoveredString(endresult)
# print('Letras Encontradas-: %s' % discovered)
print('Letras Encontradas-: %s' % "".join(endresult))
# calculate the current accuracy
if len(endresult) > 0:
acc = np.count_nonzero(
np.array(endresult) == np.array(
list(TRUE_LABELS.lower()[:len(endresult)]))) / len(
endresult)
print('Acertividade Atual : %d' % (acc * 100))
if len(endresult) == len(TRUE_LABELS) - 1:
break
# logger.debug('Resultado : %s' % result)
timeValue = 1000 * (time.time() - t0)
print('Tempo consumido por ciclo : %d' % timeValue)
acc = np.count_nonzero(
np.array(endresult) == np.array(
list(TRUE_LABELS.lower()[:len(endresult)]))) / len(endresult)
print("Acertividade Final : %d" % (acc * 100))
amp.stop()
def online_erp(fs, n_channels, subsample):
logger.debug('Running Online ERP with {fs}Hz, and {channels}channels'.format(fs=fs, channels=n_channels))
target_fs = 100
# blocklen in ms
blocklen = 1000 * 1 / target_fs
# blocksize given the original fs and blocklen
blocksize = fs * (blocklen / 1000)
MRK_DEF = {'target': 'm'}
SEG_IVAL = [0, 700]
JUMPING_MEANS_IVALS = [150, 220], [200, 260], [310, 360], [550, 660]
RING_BUFFER_CAP = 1000
cfy = [0, 0]
fs_n = fs / 2
b_l, a_l = proc.signal.butter(5, [30 / fs_n], btype='low')
b_h, a_h = proc.signal.butter(5, [.4 / fs_n], btype='high')
zi_l = proc.lfilter_zi(b_l, a_l, n_channels)
zi_h = proc.lfilter_zi(b_h, a_h, n_channels)
ax_channels = np.array([str(i) for i in range(n_channels)])
names = ['time', 'channel']
units = ['ms', '#']
blockbuf = BlockBuffer(blocksize)
ringbuf = RingBuffer(RING_BUFFER_CAP)
times = []
# time since the last data was acquired
t_last = time.time()
# time since the last marker
t_last_marker = time.time()
# time since the experiment started
t_start = time.time()
full_iterations = 0
while full_iterations < 500:
t0 = time.time()
dt = time.time() - t_last
samples = int(dt * fs)
if samples == 0:
continue
t_last = time.time()
# get data
data = np.random.random((samples, n_channels))
ax_times = np.linspace(0, 1000 * (samples / fs), samples, endpoint=False)
if t_last_marker + .01 < time.time():
t_last_marker = time.time()
markers = [[ax_times[-1], 'm']]
else:
markers = []
cnt = Data(data, axes=[ax_times, ax_channels], names=names, units=units)
cnt.fs = fs
cnt.markers = markers
# blockbuffer
blockbuf.append(cnt)
cnt = blockbuf.get()
if not cnt:
continue
# filter
cnt, zi_l = proc.lfilter(cnt, b_l, a_l, zi=zi_l)
cnt, zi_h = proc.lfilter(cnt, b_h, a_h, zi=zi_h)
# subsample
if subsample:
cnt = proc.subsample(cnt, target_fs)
newsamples = cnt.data.shape[0]
# ringbuffer
ringbuf.append(cnt)
cnt = ringbuf.get()
# epoch
epo = proc.segment_dat(cnt, MRK_DEF, SEG_IVAL, newsamples=newsamples)
if not epo:
continue
# feature vectors
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
rv = proc.create_feature_vectors(fv)
# classification
proc.lda_apply(fv, cfy)
# don't measure in the first second, where the ringbuffer is not
# full yet.
if time.time() - t_start < (RING_BUFFER_CAP / 1000):
continue
dt = time.time() - t0
times.append(dt)
full_iterations += 1
return np.array(times)
def online_experiment(amp, cfy):
amp_fs = amp.get_sampling_frequency()
amp_channels = amp.get_channels()
#buf = BlockBuffer(4)
rb = RingBuffer(5000)
fn = amp_fs / 2
b_low, a_low = proc.signal.butter(5, [30 / fn], btype='low')
b_high, a_high = proc.signal.butter(5, [.4 / fn], btype='high')
zi_low = proc.lfilter_zi(b_low, a_low, len(amp_channels))
zi_high = proc.lfilter_zi(b_high, a_high, len(amp_channels))
amp.start()
markers_processed = 0
current_letter_idx = 0
current_letter = TRUE_LABELS[current_letter_idx].lower()
letter_prob = {i : 0 for i in 'abcdefghijklmnopqrstuvwxyz123456789_'}
endresult = []
t0 = time.time()
while True:
t0 = time.time()
# get fresh data from the amp
data, markers = amp.get_data()
if len(data) == 0:
continue
# we should rather wait for a specific end-of-experiment marker
if len(data) == 0:
break
# convert to cnt
cnt = io.convert_mushu_data(data, markers, amp_fs, amp_channels)
## enter the block buffer
#buf.append(cnt)
#cnt = buf.get()
#if not cnt:
# continue
# band-pass and subsample
cnt, zi_low = proc.lfilter(cnt, b_low, a_low, zi=zi_low)
cnt, zi_high = proc.lfilter(cnt, b_high, a_high, zi=zi_high)
cnt = proc.subsample(cnt, 60)
newsamples = cnt.data.shape[0]
# enter the ringbuffer
rb.append(cnt)
cnt = rb.get()
# segment
epo = proc.segment_dat(cnt, MARKER_DEF_TEST, SEG_IVAL, newsamples=newsamples)
if not epo:
continue
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
logger.debug(markers_processed)
lda_out = proc.lda_apply(fv, cfy)
markers = [fv.class_names[cls_idx] for cls_idx in fv.axes[0]]
result = zip(markers, lda_out)
for s, score in result:
if markers_processed == 180:
endresult.append(sorted(letter_prob.items(), key=lambda x: x[1])[-1][0])
letter_prob = {i : 0 for i in 'abcdefghijklmnopqrstuvwxyz123456789_'}
markers_processed = 0
current_letter_idx += 1
current_letter = TRUE_LABELS[current_letter_idx].lower()
for letter in s:
letter_prob[letter] += score
markers_processed += 1
logger.debug("".join([i[0] for i in sorted(letter_prob.items(), key=lambda x: x[1], reverse=True)]).replace(current_letter, " %s " % current_letter))
logger.debug(TRUE_LABELS)
logger.debug("".join(endresult))
# calculate the current accuracy
if len(endresult) > 0:
acc = np.count_nonzero(np.array(endresult) == np.array(list(TRUE_LABELS.lower()[:len(endresult)]))) / len(endresult)
print "Current accuracy:", acc * 100
if len(endresult) == len(TRUE_LABELS):
break
#logger.debug("Result: %s" % result)
print 1000 * (time.time() - t0)
acc = np.count_nonzero(np.array(endresult) == np.array(list(TRUE_LABELS.lower()[:len(endresult)]))) / len(endresult)
print "Accuracy:", acc * 100
amp.stop()
def preprocess(data, filt=None):
dat = data.copy()
fs_n = 250 # sample rate is 250 for us
b, a = proc.signal.butter(5, [13 / fs_n], btype='low')
dat = proc.filtfilt(dat, b, a)
b, a = proc.signal.butter(5, [9 / fs_n], btype='high')
dat = proc.filtfilt(dat, b, a)
dat = proc.subsample(dat, 50)
if filt is None:
filt, pattern, _ = proc.calculate_csp(dat)
plot_csp_pattern(pattern)
dat = proc.apply_csp(dat, filt)
dat = proc.variance(dat)
dat = proc.logarithm(dat)
return dat, filt
fv_train, filt = preprocess(dat_train)
fv_test, _ = preprocess(dat_test, filt)
cfy = proc.lda_train(fv_train)
result = proc.lda_apply(fv_test, cfy)
result = (np.sign(result) + 1) / 2
print 'LDA Accuracy %.2f%%' % ((result == true_labels).sum() / len(result))
plt.show()
test_data_i = proc.select_epochs(train_data, rs[1])
train_data_i = proc.select_epochs(train_data, rs[0])
#expected = test_data_i.axes[0]
expected = train_data_i.axes[0]
# creating a CSP filter, preprocessing train data
fv_train, filt = preprocess(train_data_i)
# training LDA
cfy = proc.lda_train(fv_train)
# preprocess test data
#fv_test, _ = preprocess(test_data_i, filt)
# predicting result of the test data
result = proc.lda_apply(fv_train, cfy)
result = (np.sign(result) + 1) / 2
fpr, tpr, thresholds = metrics.roc_curve(expected, result, pos_label=1)
accuracy[state] = metrics.auc(fpr, tpr)
Accuracy[j][i] = accuracy.mean()
log('LDA Accuracy on start %3i, window size %3i train data %.8f%%' % (start, window_size, Accuracy[j][i]))
#log('LDA Accuracy on start %3i, window size %3i train data %.8f%%' % (start, window_size, accuracy))
try:
data = go.Data([go.Contour(z=Accuracy, x=starts, y=sizes)])
#plot_url = py.plot(data, filename='prediction-roc-accuracy-8', fileopt='overwrite', auto_open=False)
except BaseException as e:
print 'error occurred when trying to load data from .mat: ' + e.message
dat_train, dat_test=load_graz('dataset_BCIcomp1.mat')
labels=scio.loadmat('labels_data_set_iii.mat')
'''print type(labels)
print labels.shape'''
y_test=labels['y_test']
y_test[y_test == 2] = 0
print "true labels\n"
print y_test.swapaxes(1,0)
#dat_test=graz_data['x_test']
fv_train, filt = preprocess(dat_train)
fv_test, _ = preprocess(dat_test, filt)
cfy= proc.lda_train(fv_train)
result=proc.lda_apply(fv_test,cfy)
result = (np.sign(result) + 1) / 2
print "generated labels\n"
print result
#print y_test.shape
#print result.shape
sum=0.0
for i in range(len(result)):
if result[i]==y_test[i]:
sum=sum+1
})
# train the lda
print "before training"
cfy = proc.lda_train(fv_train)
print "after training"
# load the testing set
dat = load_bcicomp3_ds2(testing_set)
fv_test, epo_test = preprocessing(dat, MARKER_DEF_TEST,
jumping_means_ivals)
# predict
print "-----"
lda_out_prob = proc.lda_apply(fv_test, cfy)
print lda_out_prob.shape
lda_out_prob_2 = lstm_model.predict(epo_test.data)[:, 1]
print lda_out_prob.shape
# unscramble the order of stimuli
unscramble_idx = fv_test.stimulus_code.reshape(100, 15, 12).argsort()
static_idx = np.indices(unscramble_idx.shape)
lda_out_prob = lda_out_prob.reshape(100, 15, 12)
lda_out_prob = lda_out_prob[static_idx[0], static_idx[1], unscramble_idx]
#lda_out_prob = lda_out_prob[:, :5, :]
# destil the result of the 15 runs
#lda_out_prob = lda_out_prob.prod(axis=1)
lda_out_prob = lda_out_prob.sum(axis=1)
dat = load_bcicomp3_ds2(training_set)
print "after loading "
fv_train, epo[subject] = preprocessing(dat, MARKER_DEF_TRAIN, jumping_means_ivals)
# train the lda
print "before training"
cfy = proc.lda_train(fv_train)
print "after training"
# load the testing set
dat = load_bcicomp3_ds2(testing_set)
fv_test, _ = preprocessing(dat, MARKER_DEF_TEST, jumping_means_ivals)
# predict
lda_out_prob = proc.lda_apply(fv_test, cfy)
# unscramble the order of stimuli
unscramble_idx = fv_test.stimulus_code.reshape(100, 15, 12).argsort()
static_idx = np.indices(unscramble_idx.shape)
lda_out_prob = lda_out_prob.reshape(100, 15, 12)
lda_out_prob = lda_out_prob[static_idx[0], static_idx[1], unscramble_idx]
#lda_out_prob = lda_out_prob[:, :5, :]
# destil the result of the 15 runs
#lda_out_prob = lda_out_prob.prod(axis=1)
lda_out_prob = lda_out_prob.sum(axis=1)
#
lda_out_prob = lda_out_prob.argsort()
def run_pair(self, epo_train, epo_test, bp_nr, fold_nr, pair_nr):
class_pair = self.class_pairs[pair_nr]
self.print_class_pair(class_pair)
### Run Training
epo_train_pair = select_classes(epo_train, class_pair)
epo_test_pair = select_classes(epo_test, class_pair)
if self.ival_optimizer is not None:
best_segment_ival = self.ival_optimizer.optimize(epo_train_pair)
log.info("Ival {:.0f}ms - {:.0f}ms".format(*best_segment_ival))
epo_train_pair = select_ival(epo_train_pair, best_segment_ival)
epo_test_pair = select_ival(epo_test_pair, best_segment_ival)
epo_train = select_ival(epo_train, best_segment_ival)
epo_test = select_ival(epo_test, best_segment_ival)
self.train_labels[fold_nr][pair_nr] = epo_train_pair.axes[0]
self.test_labels[fold_nr][pair_nr] = epo_test_pair.axes[0]
## Calculate CSP
filters, patterns, variances = calculate_csp(epo_train_pair)
## Apply csp, calculate features
if self.n_filters is not None:
# take topmost and bottommost filters, e.g.
# for n_filters=3 0,1,2,-3,-2,-1
columns = range(0, self.n_filters) + \
range(-self.n_filters, 0)
else: # take all possible filters
columns = range(len(filters))
train_feature = apply_csp_var_log(epo_train_pair, filters, columns)
## Calculate LDA
clf = lda_train_scaled(train_feature, shrink=True)
assert not np.any(np.isnan(clf[0]))
assert not np.isnan(clf[1])
## Apply LDA to train
train_out = lda_apply(train_feature, clf)
correct_train = train_feature.axes[0] == class_pair[1]
predicted_train = train_out >= 0
train_accuracy = (sum(correct_train == predicted_train) /
float(len(predicted_train)))
### Feature Computation and LDA Application for test
test_feature = apply_csp_var_log(epo_test_pair, filters, columns)
test_out = lda_apply(test_feature, clf)
correct_test = test_feature.axes[0] == class_pair[1]
predicted_test = test_out >= 0
test_accuracy = (sum(correct_test == predicted_test) /
float(len(predicted_test)))
### Feature Computations for full fold (for later multiclass)
train_feature_full_fold = apply_csp_var_log(epo_train, filters,
columns)
test_feature_full_fold = apply_csp_var_log(epo_test, filters, columns)
### Store results
# only store used patterns filters variances
# to save memory space on disk
self.store_results(bp_nr, fold_nr, pair_nr, filters[:, columns],
patterns[:, columns], variances[columns],
train_feature, test_feature,
train_feature_full_fold, test_feature_full_fold,
clf, train_accuracy, test_accuracy)
if self.ival_optimizer is not None:
self.best_ival[bp_nr, fold_nr, pair_nr] = best_segment_ival
self.print_results(bp_nr, fold_nr, pair_nr)
def online_experiment(amp, clf):
amp_fs = amp.get_sampling_frequency()
amp_channels = amp.get_channels()
buf = BlockBuffer(4)
rb = RingBuffer(5000)
fn = amp.get_sampling_frequency() / 2
b_low, a_low = proc.signal.butter(16, [30 / fn], btype='low')
b_high, a_high = proc.signal.butter(5, [.4 / fn], btype='high')
zi_low = proc.lfilter_zi(b_low, a_low, len(amp_channels))
zi_high = proc.lfilter_zi(b_high, a_high, len(amp_channels))
amp.start()
markers_processed = 0
current_letter_idx = 0
current_letter = TRUE_LABELS[current_letter_idx].lower()
letter_prob = {i: 0 for i in 'abcdefghijklmnopqrstuvwxyz123456789_'}
endresult = []
while True:
# turn on for 'real time'
#time.sleep(0.01)
# get fresh data from the amp
data, markers = amp.get_data()
# we should rather wait for a specific end-of-experiment marker
if len(data) == 0:
break
# convert to cnt
cnt = io.convert_mushu_data(data, markers, amp_fs, amp_channels)
# enter the block buffer
buf.append(cnt)
cnt = buf.get()
if not cnt:
continue
# band-pass and subsample
cnt, zi_low = proc.lfilter(cnt, b_low, a_low, zi=zi_low)
cnt, zi_high = proc.lfilter(cnt, b_high, a_high, zi=zi_high)
cnt = proc.subsample(cnt, 60)
newsamples = cnt.data.shape[0]
# enter the ringbuffer
rb.append(cnt)
cnt = rb.get()
# segment
epo = proc.segment_dat(cnt,
MARKER_DEF_TEST,
SEG_IVAL,
newsamples=newsamples)
if not epo:
continue
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
logger.debug(markers_processed)
lda_out = proc.lda_apply(fv, clf)
markers = [fv.class_names[cls_idx] for cls_idx in fv.axes[0]]
result = zip(markers, lda_out)
for s, score in result:
if markers_processed == 180:
endresult.append(
sorted(letter_prob.items(), key=lambda x: x[1])[-1][0])
letter_prob = {
i: 0
for i in 'abcdefghijklmnopqrstuvwxyz123456789_'
}
markers_processed = 0
current_letter_idx += 1
current_letter = TRUE_LABELS[current_letter_idx].lower()
for letter in s:
letter_prob[letter] += score
markers_processed += 1
logger.debug("".join([
i[0] for i in sorted(
letter_prob.items(), key=lambda x: x[1], reverse=True)
]).replace(current_letter, " %s " % current_letter))
logger.debug(TRUE_LABELS)
logger.debug("".join(endresult))
# calculate the current accuracy
if len(endresult) > 0:
acc = np.count_nonzero(
np.array(endresult) == np.array(
list(TRUE_LABELS.lower()[:len(endresult)]))) / len(
endresult)
print "Current accuracy:", acc * 100
if len(endresult) == len(TRUE_LABELS):
break
#logger.debug("Result: %s" % result)
acc = np.count_nonzero(
np.array(endresult) == np.array(
list(TRUE_LABELS.lower()[:len(endresult)]))) / len(endresult)
print "Accuracy:", acc * 100
amp.stop()
def run_pair(self, epo_train, epo_test, bp_nr, fold_nr, pair_nr):
class_pair = self.class_pairs[pair_nr]
self.print_class_pair(class_pair)
### Run Training
epo_train_pair = select_classes(epo_train, class_pair)
epo_test_pair = select_classes(epo_test, class_pair)
if self.ival_optimizer is not None:
best_segment_ival = self.ival_optimizer.optimize(epo_train_pair)
log.info("Ival {:.0f}ms - {:.0f}ms".format(*best_segment_ival))
epo_train_pair = select_ival(epo_train_pair, best_segment_ival)
epo_test_pair = select_ival(epo_test_pair, best_segment_ival)
epo_train = select_ival(epo_train, best_segment_ival)
epo_test = select_ival(epo_test, best_segment_ival)
self.train_labels[fold_nr][pair_nr] = epo_train_pair.axes[0]
self.test_labels[fold_nr][pair_nr] = epo_test_pair.axes[0]
## Calculate CSP
filters, patterns, variances = calculate_csp(epo_train_pair)
## Apply csp, calculate features
if self.n_filters is not None:
# take topmost and bottommost filters, e.g.
# for n_filters=3 0,1,2,-3,-2,-1
columns = range(0, self.n_filters) + range(-self.n_filters, 0)
else: # take all possible filters
columns = range(len(filters))
train_feature = apply_csp_var_log(epo_train_pair, filters, columns)
## Calculate LDA
clf = lda_train_scaled(train_feature, shrink=True)
assert not np.any(np.isnan(clf[0]))
assert not np.isnan(clf[1])
## Apply LDA to train
train_out = lda_apply(train_feature, clf)
correct_train = train_feature.axes[0] == class_pair[1]
predicted_train = train_out >= 0
train_accuracy = sum(correct_train == predicted_train) / float(len(predicted_train))
### Feature Computation and LDA Application for test
test_feature = apply_csp_var_log(epo_test_pair, filters, columns)
test_out = lda_apply(test_feature, clf)
correct_test = test_feature.axes[0] == class_pair[1]
predicted_test = test_out >= 0
test_accuracy = sum(correct_test == predicted_test) / float(len(predicted_test))
### Feature Computations for full fold (for later multiclass)
train_feature_full_fold = apply_csp_var_log(epo_train, filters, columns)
test_feature_full_fold = apply_csp_var_log(epo_test, filters, columns)
### Store results
# only store used patterns filters variances
# to save memory space on disk
self.store_results(
bp_nr,
fold_nr,
pair_nr,
filters[:, columns],
patterns[:, columns],
variances[columns],
train_feature,
test_feature,
train_feature_full_fold,
test_feature_full_fold,
clf,
train_accuracy,
test_accuracy,
)
if self.ival_optimizer is not None:
self.best_ival[bp_nr, fold_nr, pair_nr] = best_segment_ival
self.print_results(bp_nr, fold_nr, pair_nr)
