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 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 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 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_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 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_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()