def train(filename):
cnt = io.load_bcicomp3_ds2(filename)
fs_n = cnt.fs / 2
b, a = proc.signal.butter(5, [38 / fs_n], btype='low')
cnt = proc.lfilter(cnt, b, a)
b, a = proc.signal.butter(5, [.1 / fs_n], btype='high')
cnt = proc.lfilter(cnt, b, a)
cnt = proc.subsample(cnt, 60)
epo = proc.segment_dat(cnt, MARKER_DEF_TRAIN, SEG_IVAL)
# from wyrm import plot
# logger.debug('Ploting channels...')
# plot.plot_spatio_temporal_r2_values(proc.sort_channels(epo))
# print JUMPING_MEANS_IVALS
# plot.plt.show()
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
cfy = proc.lda_train(fv)
return cfy
def train(filename_):
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.lfilter(cnt, b, a)
b, a = proc.signal.butter(5, [LOWER_CUT / fs_n], btype='high')
cnt = proc.lfilter(cnt, b, a)
print("Filtragem aplicada em [{} Hz ~ {} Hz]".format(LOWER_CUT, HIGH_CUT))
cnt = proc.subsample(cnt, SUBSAMPLING)
print("Sub-amostragem em {} Hz".format(SUBSAMPLING))
epo = proc.segment_dat(cnt, MARKER_DEF_TRAIN, SEG_IVAL)
print("Dados segmentados em intervalos de [{} ~ {}]".format(
SEG_IVAL[0], SEG_IVAL[1]))
fv = proc.jumping_means(epo, JUMPING_MEANS_INTERVALS)
fv = proc.create_feature_vectors(fv)
print("Iniciando treinamento da LDA...")
cfy = proc.lda_train(fv)
print("Treinamento concluido!")
return cfy
def train(filename):
dat = io.load_bcicomp3_ds2(filename)
fs_n = dat.fs / 2
b, a = proc.signal.butter(16, [30 / fs_n], btype='low')
dat = proc.lfilter(dat, b, a)
b, a = proc.signal.butter(5, [.4 / fs_n], btype='high')
dat = proc.lfilter(dat, b, a)
dat = proc.subsample(dat, 60)
epo = proc.segment_dat(dat, MARKER_DEF_TRAIN, SEG_IVAL)
#from wyrm import plot
#plot.plot_spatio_temporal_r2_values(proc.sort_channels(epo))
#print JUMPING_MEANS_IVALS
#plot.plt.show()
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
clf = proc.lda_train(fv)
return clf
def train(filename):
cnt = io.load_bcicomp3_ds2(filename)
fs_n = cnt.fs / 2
b, a = proc.signal.butter(5, [30 / fs_n], btype='low')
cnt = proc.lfilter(cnt, b, a)
b, a = proc.signal.butter(5, [.4 / fs_n], btype='high')
cnt = proc.lfilter(cnt, b, a)
cnt = proc.subsample(cnt, 60)
epo = proc.segment_dat(cnt, MARKER_DEF_TRAIN, SEG_IVAL)
#from wyrm import plot
#plot.plot_spatio_temporal_r2_values(proc.sort_channels(epo))
#print JUMPING_MEANS_IVALS
#plot.plt.show()
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
cfy = proc.lda_train(fv)
return cfy
def preprocessing_simple(dat, MRK_DEF, *args, **kwargs):
"""Simple preprocessing that reaches 97% accuracy.
"""
fs_n = dat.fs / 2
b, a = proc.signal.butter(5, [10 / fs_n], btype='low')
dat = proc.filtfilt(dat, b, a)
dat = proc.subsample(dat, 20)
epo = proc.segment_dat(dat, MRK_DEF, SEG_IVAL)
fv = proc.create_feature_vectors(epo)
return fv, epo
def preprocessing_simple(dat, MRK_DEF, *args, **kwargs):
"""Simple preprocessing that reaches 97% accuracy.
"""
fs_n = dat.fs / 2
b, a = proc.signal.butter(5, [10 / fs_n], btype='low')
dat = proc.filtfilt(dat, b, a)
dat = proc.subsample(dat, 20)
epo = proc.segment_dat(dat, MRK_DEF, SEG_IVAL)
fv = proc.create_feature_vectors(epo)
return fv, epo
def test_subsample_with_epo(self):
"""subsample must work with epoched data."""
data = np.array([self.dat.data, self.dat.data, self.dat.data])
axes = [np.arange(3), self.dat.axes[0], self.dat.axes[1]]
names = ['class', 'time', 'channel']
units = ['#', 'ms', '#']
dat = self.dat.copy(data=data, axes=axes, names=names, units=units)
dat = subsample(dat, 10)
self.assertEqual(dat.fs, 10)
self.assertEqual(dat.data.ndim, 3)
self.assertEqual(len(dat.axes[1]), dat.data.shape[1])
self.assertEqual(dat.data.shape[1], self.dat.data.shape[0] / 10)
def test_subsample_with_epo(self):
"""subsample must work with epoched data."""
data = np.array([self.dat.data, self.dat.data, self.dat.data])
axes = [np.arange(3), self.dat.axes[0], self.dat.axes[1]]
names = ['class', 'time', 'channel']
units = ['#', 'ms', '#']
dat = self.dat.copy(data=data, axes=axes, names=names, units=units)
dat = subsample(dat, 10)
self.assertEqual(dat.fs, 10)
self.assertEqual(dat.data.ndim, 3)
self.assertEqual(len(dat.axes[1]), dat.data.shape[1])
self.assertEqual(dat.data.shape[1], self.dat.data.shape[0] / 10)
def preprocessing(dat, MRK_DEF, JUMPING_MEANS_IVALS):
dat = proc.sort_channels(dat)
fs_n = dat.fs / 2
b, a = proc.signal.butter(5, [30 / fs_n], btype='low')
dat = proc.lfilter(dat, b, a)
b, a = proc.signal.butter(5, [.4 / fs_n], btype='high')
dat = proc.lfilter(dat, b, a)
dat = proc.subsample(dat, 60)
epo = proc.segment_dat(dat, MRK_DEF, SEG_IVAL)
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
return fv, epo
def preprocessing(dat, MRK_DEF, JUMPING_MEANS_IVALS):
dat = proc.sort_channels(dat)
fs_n = dat.fs / 2
b, a = proc.signal.butter(5, [30 / fs_n], btype='low')
dat = proc.lfilter(dat, b, a)
b, a = proc.signal.butter(5, [.4 / fs_n], btype='high')
dat = proc.lfilter(dat, b, a)
dat = proc.subsample(dat, 60)
epo = proc.segment_dat(dat, MRK_DEF, SEG_IVAL)
fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
fv = proc.create_feature_vectors(fv)
return fv, epo
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 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
def preprocess(data, filt=None):
dat = data.copy()
fs_n = dat.fs / 2
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
def test_subsampling(self):
"""Subsampling to 10Hz."""
dat = subsample(self.dat, 10)
# check if the new fs is correct
self.assertEqual(dat.fs, 10.)
# check if data and axes have the same length
self.assertEqual(len(dat.axes[-1]), dat.data.shape[-1])
# no channels must have been deleted
np.testing.assert_array_equal(self.dat.axes[-1], dat.axes[-1])
self.assertEqual(self.dat.data.shape[-1], dat.data.shape[-1])
# markers must not have been modified
self.assertEqual(self.dat.markers, dat.markers)
# no marker must have been deleted
self.assertEqual(len(self.dat.markers), len(dat.markers))
# check the actual data
# after subsampling, data should look like:
# [[0, 1, 2, 3, 4, 5]
# [50, 51, 52, 53, 54, 55]
# [...]]
# so the first column of the resampled data should be all
# multiples of 50.
zeros = dat.data[:, 0] % 50
self.assertFalse(np.any(zeros))
def test_subsampling(self):
"""Subsampling to 10Hz."""
dat = subsample(self.dat, 10)
# check if the new fs is correct
self.assertEqual(dat.fs, 10.)
# check if data and axes have the same length
self.assertEqual(len(dat.axes[-1]), dat.data.shape[-1])
# no channels must have been deleted
np.testing.assert_array_equal(self.dat.axes[-1], dat.axes[-1])
self.assertEqual(self.dat.data.shape[-1], dat.data.shape[-1])
# markers must not have been modified
self.assertEqual(self.dat.markers, dat.markers)
# no marker must have been deleted
self.assertEqual(len(self.dat.markers), len(dat.markers))
# check the actual data
# after subsampling, data should look like:
# [[0, 1, 2, 3, 4, 5]
# [50, 51, 52, 53, 54, 55]
# [...]]
# so the first column of the resampled data should be all
# multiples of 50.
zeros = dat.data[:, 0] % 50
self.assertFalse(np.any(zeros))
def preprocess(dat,filt=None):
'''fs_n = dat.fs / 2
b, a = proc.signal.butter(5, [13 / fs_n], btype='low')
dat = proc.lfilter(dat, b, a)
b, a = proc.signal.butter(5, [8 / fs_n], btype='high')
dat = proc.lfilter(dat, b, a)
print dat'''
dat = proc.subsample(dat, 64)
#epo = proc.segment_dat(dat, MRK_DEF, SEG_IVAL)
#fv = proc.jumping_means(epo, JUMPING_MEANS_IVALS)
#fv = proc.create_feature_vectors(dat)
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
def test_has_fs_check(self):
"""subsample must raise an exception if .fs attribute is not found."""
with self.assertRaises(AssertionError):
del(self.dat.fs)
subsample(self.dat, 10)
def test_subsample_copy(self):
"""Subsample must not modify argument."""
cpy = self.dat.copy()
subsample(self.dat, 10)
self.assertEqual(cpy, self.dat)
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 test_subsample_swapaxes(self):
"""subsample must work with nonstandard timeaxis."""
dat = subsample(swapaxes(self.dat, 0, 1), 10, timeaxis=1)
dat = swapaxes(dat, 0, 1)
dat2 = subsample(self.dat, 10)
self.assertEqual(dat, dat2)
def test_subsample_copy(self):
"""Subsample must not modify argument."""
cpy = self.dat.copy()
subsample(self.dat, 10)
self.assertEqual(cpy, self.dat)
def test_axes_and_data_have_same_len_check(self):
"""subsample must raise an error if the timeaxis and data have not the same lengh."""
with self.assertRaises(AssertionError):
self.dat.axes[-2] = self.dat.axes[-2][1:]
subsample(self.dat, 10)
def test_has_fs_check(self):
"""subsample must raise an exception if .fs attribute is not found."""
with self.assertRaises(AssertionError):
del (self.dat.fs)
subsample(self.dat, 10)
def test_whole_number_divisor_check(self):
"""Freq must be a whole number divisor of dat.fs"""
with self.assertRaises(AssertionError):
subsample(self.dat, 33)
with self.assertRaises(AssertionError):
subsample(self.dat, 101)
def test_axes_and_data_have_same_len_check(self):
"""subsample must raise an error if the timeaxis and data have not the same lengh."""
with self.assertRaises(AssertionError):
self.dat.axes[-2] = self.dat.axes[-2][1:]
subsample(self.dat, 10)
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 test_subsample_swapaxes(self):
"""subsample must work with nonstandard timeaxis."""
dat = subsample(swapaxes(self.dat, 0, 1), 10, timeaxis=1)
dat = swapaxes(dat, 0, 1)
dat2 = subsample(self.dat, 10)
self.assertEqual(dat, dat2)
def test_whole_number_divisor_check(self):
"""Freq must be a whole number divisor of dat.fs"""
with self.assertRaises(AssertionError):
subsample(self.dat, 33)
with self.assertRaises(AssertionError):
subsample(self.dat, 101)
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 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()