Exemple #1
0
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
Exemple #3
0
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
Exemple #4
0
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
Exemple #5
0
 def test_jumping_means_with_cnt(self):
     """jumping_means must work with cnt argument."""
     data = self.dat.data[1]
     axes = self.dat.axes[1:]
     names = self.dat.names[1:]
     units = self.dat.units[1:]
     dat = self.dat.copy(data=data, axes=axes, names=names, units=units)
     dat = jumping_means(dat, [[0, 1000], [1000, 2000]])
     self.assertEqual(dat.data[0, 0], 1)
     self.assertEqual(dat.data[1, 0], 2)
 def test_jumping_means_with_cnt(self):
     """jumping_means must work with cnt argument."""
     data = self.dat.data[1]
     axes = self.dat.axes[1:]
     names = self.dat.names[1:]
     units = self.dat.units[1:]
     dat = self.dat.copy(data=data, axes=axes, names=names, units=units)
     dat = jumping_means(dat, [[0, 1000], [1000, 2000]])
     self.assertEqual(dat.data[0, 0], 1)
     self.assertEqual(dat.data[1, 0], 2)
Exemple #7
0
 def test_jumping_means(self):
     """Jumping means."""
     # with several ivals
     dat = jumping_means(self.dat, [[0, 1000], [1000, 2000], [2000, 3000]])
     newshape = list(self.dat.data.shape)
     newshape[1] = 3
     self.assertEqual(list(dat.data.shape), newshape)
     # first epo (0)
     self.assertEqual(dat.data[0, 0, 0], 0)
     self.assertEqual(dat.data[0, 1, 0], 0)
     self.assertEqual(dat.data[0, 2, 0], 0)
     # second epo (1)
     self.assertEqual(dat.data[1, 0, 0], 1)
     self.assertEqual(dat.data[1, 1, 0], 2)
     self.assertEqual(dat.data[1, 2, 0], 3)
     # third epo (2)
     self.assertEqual(dat.data[2, 0, 0], 2)
     self.assertEqual(dat.data[2, 1, 0], 4)
     self.assertEqual(dat.data[2, 2, 0], 6)
     # fourth epo (0)
     self.assertEqual(dat.data[3, 0, 0], 0)
     self.assertEqual(dat.data[3, 1, 0], 0)
     self.assertEqual(dat.data[3, 2, 0], 0)
     # with one ival
     dat = jumping_means(self.dat, [[0, 1000]])
     newshape = list(self.dat.data.shape)
     newshape[1] = 1
     self.assertEqual(list(dat.data.shape), newshape)
     # first epo (0)
     self.assertEqual(dat.data[0, 0, 0], 0)
     # second epo (1)
     self.assertEqual(dat.data[1, 0, 0], 1)
     # third epo (2)
     self.assertEqual(dat.data[2, 0, 0], 2)
     # fourth epo (0)
     self.assertEqual(dat.data[3, 0, 0], 0)
Exemple #8
0
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 test_jumping_means(self):
     """Jumping means."""
     # with several ivals
     dat = jumping_means(self.dat, [[0, 1000], [1000, 2000], [2000, 3000]])
     newshape = list(self.dat.data.shape)
     newshape[1] = 3
     self.assertEqual(list(dat.data.shape), newshape)
     # first epo (0)
     self.assertEqual(dat.data[0, 0, 0], 0)
     self.assertEqual(dat.data[0, 1, 0], 0)
     self.assertEqual(dat.data[0, 2, 0], 0)
     # second epo (1)
     self.assertEqual(dat.data[1, 0, 0], 1)
     self.assertEqual(dat.data[1, 1, 0], 2)
     self.assertEqual(dat.data[1, 2, 0], 3)
     # third epo (2)
     self.assertEqual(dat.data[2, 0, 0], 2)
     self.assertEqual(dat.data[2, 1, 0], 4)
     self.assertEqual(dat.data[2, 2, 0], 6)
     # fourth epo (0)
     self.assertEqual(dat.data[3, 0, 0], 0)
     self.assertEqual(dat.data[3, 1, 0], 0)
     self.assertEqual(dat.data[3, 2, 0], 0)
     # with one ival
     dat = jumping_means(self.dat, [[0, 1000]])
     newshape = list(self.dat.data.shape)
     newshape[1] = 1
     self.assertEqual(list(dat.data.shape), newshape)
     # first epo (0)
     self.assertEqual(dat.data[0, 0, 0], 0)
     # second epo (1)
     self.assertEqual(dat.data[1, 0, 0], 1)
     # third epo (2)
     self.assertEqual(dat.data[2, 0, 0], 2)
     # fourth epo (0)
     self.assertEqual(dat.data[3, 0, 0], 0)
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))
Exemple #12
0
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()
Exemple #13
0
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)
Exemple #14
0
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()
Exemple #15
0
 def test_jumping_means_swapaxes(self):
     """jumping means must work with nonstandard timeaxis."""
     dat = jumping_means(swapaxes(self.dat, 1, 2), [[0, 1000]], timeaxis=2)
     dat = swapaxes(dat, 1, 2)
     dat2 = jumping_means(self.dat, [[0, 1000]])
     self.assertEqual(dat, dat2)
Exemple #16
0
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_jumping_means_copy(self):
     """jumping means must not modify argument."""
     cpy = self.dat.copy()
     jumping_means(self.dat, [[0, 1000]])
     self.assertEqual(self.dat, cpy)
 def test_jumping_means_swapaxes(self):
     """jumping means must work with nonstandard timeaxis."""
     dat = jumping_means(swapaxes(self.dat, 1, 2), [[0, 1000]], timeaxis=2)
     dat = swapaxes(dat, 1, 2)
     dat2 = jumping_means(self.dat, [[0, 1000]])
     self.assertEqual(dat, dat2)
Exemple #19
0
 def test_jumping_means_copy(self):
     """jumping means must not modify argument."""
     cpy = self.dat.copy()
     jumping_means(self.dat, [[0, 1000]])
     self.assertEqual(self.dat, cpy)
Exemple #20
0
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()