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 test_lfilter_copy(self):
"""lfilter must not modify argument."""
cpy = self.dat.copy()
fn = self.dat.fs / 2
b, a = butter(4, [6 / fn, 8 / fn], btype='band')
lfilter(self.dat, b, a)
self.assertEqual(cpy, self.dat)
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 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 test_lfilter_copy(self):
"""lfilter must not modify argument."""
cpy = self.dat.copy()
fn = self.dat.fs / 2
b, a = butter(4, [6 / fn, 8 / fn], btype='band')
lfilter(self.dat, b, a)
self.assertEqual(cpy, self.dat)
def test_lfilter_swapaxes(self):
"""lfilter must work with nonstandard timeaxis."""
fn = self.dat.fs / 2
b, a = butter(4, [6 / fn, 8 / fn], btype='band')
dat = lfilter(swapaxes(self.dat, 0, 1), b, a, timeaxis=1)
dat = swapaxes(dat, 0, 1)
dat2 = lfilter(self.dat, b, a)
self.assertEqual(dat, dat2)
def test_lfilter_swapaxes(self):
"""lfilter must work with nonstandard timeaxis."""
fn = self.dat.fs / 2
b, a = butter(4, [6 / fn, 8 / fn], btype='band')
dat = lfilter(swapaxes(self.dat, 0, 1), b, a, timeaxis=1)
dat = swapaxes(dat, 0, 1)
dat2 = lfilter(self.dat, b, a)
self.assertEqual(dat, dat2)
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 highpass_cnt(cnt, low_cut_off_hz, filt_order=3):
if low_cut_off_hz is None:
return cnt.copy()
b,a = scipy.signal.butter(filt_order, low_cut_off_hz/(cnt.fs/2.0),btype='highpass')
assert filter_is_stable(a)
cnt_highpassed = lfilter(cnt,b,a)
return cnt_highpassed
def bandstop_cnt(cnt, low_cut_hz, high_cut_hz, filt_order=3):
nyq_freq = 0.5 * cnt.fs
low = low_cut_hz / nyq_freq
high = high_cut_hz / nyq_freq
b, a = scipy.signal.butter(filt_order, [low, high], btype='bandstop')
assert filter_is_stable(a)
cnt_bandpassed = lfilter(cnt,b,a)
return cnt_bandpassed
def bandstop_cnt(cnt, low_cut_hz, high_cut_hz, filt_order=3):
nyq_freq = 0.5 * cnt.fs
low = low_cut_hz / nyq_freq
high = high_cut_hz / nyq_freq
b, a = scipy.signal.butter(filt_order, [low, high], btype='bandstop')
assert filter_is_stable(a)
cnt_bandpassed = lfilter(cnt, b, a)
return cnt_bandpassed
def highpass_cnt(cnt, low_cut_off_hz, filt_order=3):
if (low_cut_off_hz is None) or (low_cut_off_hz == 0):
log.info("Not doing any highpass, since low 0 or None")
return cnt.copy()
b, a = scipy.signal.butter(filt_order,
low_cut_off_hz / (cnt.fs / 2.0),
btype='highpass')
assert filter_is_stable(a)
cnt_highpassed = lfilter(cnt, b, a)
return cnt_highpassed
def lowpass_cnt(cnt, high_cut_off_hz, filt_order=3):
if (high_cut_off_hz is None) or (high_cut_off_hz == cnt.fs):
log.info(
"Not doing any lowpass, since ince high cut hz is None or current fs"
)
return cnt.copy()
b, a = scipy.signal.butter(filt_order,
high_cut_off_hz / (cnt.fs / 2.0),
btype='lowpass')
assert filter_is_stable(a)
cnt_lowpassed = lfilter(cnt, b, a)
return cnt_lowpassed
def test_bandpass(self):
"""Band pass filtering."""
# bandpass around the middle frequency
fn = self.dat.fs / 2
b, a = butter(4, [6 / fn, 8 / fn], btype='band')
ans = lfilter(self.dat, b, a)
# check if the desired band is not damped
dat = spectrum(ans)
mask = dat.axes[0] == 7
self.assertTrue((dat.data[mask] > 6.5).all())
# check if the outer freqs are damped close to zero
mask = (dat.axes[0] <= 6) & (dat.axes[0] > 8)
self.assertTrue((dat.data[mask] < .5).all())
def test_bandpass(self):
"""Band pass filtering."""
# bandpass around the middle frequency
fn = self.dat.fs / 2
b, a = butter(4, [6 / fn, 8 / fn], btype='band')
ans = lfilter(self.dat, b, a)
# check if the desired band is not damped
dat = spectrum(ans)
mask = dat.axes[0] == 7
self.assertTrue((dat.data[mask] > 6.5).all())
# check if the outer freqs are damped close to zero
mask = (dat.axes[0] <= 6) & (dat.axes[0] > 8)
self.assertTrue((dat.data[mask] < .5).all())
def bandpass_cnt(cnt, low_cut_hz, high_cut_hz, filt_order=3):
"""Bandpass cnt signal using butterworth filter.
Uses lowpass in case low cut hz is exactly zero."""
if (low_cut_hz == 0 or low_cut_hz == None) and (
high_cut_hz == None):
log.info("Not doing any bandpass, since low 0 or None and "
"high None")
return cnt.copy()
if low_cut_hz == 0 or low_cut_hz == None:
log.info("Using lowpass filter since low cut hz is 0 or None")
return lowpass_cnt(cnt, high_cut_hz, filt_order=filt_order)
if high_cut_hz == None:
log.info("Using highpass filter since high cut hz is None")
return highpass_cnt(cnt, low_cut_hz, filt_order=filt_order)
nyq_freq = 0.5 * cnt.fs
low = low_cut_hz / nyq_freq
high = high_cut_hz / nyq_freq
b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass')
assert filter_is_stable(a), "Filter should be stable..."
cnt_bandpassed = lfilter(cnt,b,a)
return cnt_bandpassed
def bandpass_cnt(cnt, low_cut_hz, high_cut_hz, filt_order=3):
"""Bandpass cnt signal using butterworth filter.
Uses lowpass in case low cut hz is exactly zero."""
if (low_cut_hz == 0 or low_cut_hz is None) and (high_cut_hz == None
or high_cut_hz == cnt.fs):
log.info("Not doing any bandpass, since low 0 or None and "
"high None or current fs")
return cnt.copy()
if low_cut_hz == 0 or low_cut_hz == None:
log.info("Using lowpass filter since low cut hz is 0 or None")
return lowpass_cnt(cnt, high_cut_hz, filt_order=filt_order)
if high_cut_hz == None or high_cut_hz == cnt.fs:
log.info(
"Using highpass filter since high cut hz is None or current fs")
return highpass_cnt(cnt, low_cut_hz, filt_order=filt_order)
nyq_freq = 0.5 * cnt.fs
low = low_cut_hz / nyq_freq
high = high_cut_hz / nyq_freq
b, a = scipy.signal.butter(filt_order, [low, high], btype='bandpass')
assert filter_is_stable(a), "Filter should be stable..."
cnt_bandpassed = lfilter(cnt, b, a)
return cnt_bandpassed
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()
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 lowpass_cnt(cnt, high_cut_off_hz, filt_order=3):
b,a = scipy.signal.butter(filt_order, high_cut_off_hz/(cnt.fs/2.0),
btype='lowpass')
assert filter_is_stable(a)
cnt_lowpassed = lfilter(cnt,b,a)
return cnt_lowpassed
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)