Example #1
0
def test_feature_with_lda_selection():
    dataio = DataIO(dirname='test_catalogueconstructor')
    cc = CatalogueConstructor(dataio=dataio)
    print(cc)

    selection = np.in1d(cc.all_peaks['cluster_label'], [1, 2, 3, 4])
    print(np.sum(selection), '/', cc.all_peaks.size)

    cc.extract_some_features(method='global_lda', selection=selection)
    print(cc.some_features.shape)
    print(cc.some_features)
Example #2
0
def test_pruningshears():

    dirname = 'test_cluster'

    dataio = DataIO(dirname=dirname)
    print(dataio)
    cc = CatalogueConstructor(dataio=dataio)

    cc.extract_some_features(method='pca_by_channel')
    #~ print(dataio)
    #~ print(cc)

    t0 = time.perf_counter()
    cc.find_clusters(method='pruningshears', print_debug=True)
    t1 = time.perf_counter()
    print('cluster', t1 - t0)
Example #3
0
def test_catalogue_constructor():
    if os.path.exists('test_catalogueconstructor'):
        shutil.rmtree('test_catalogueconstructor')

    dataio = DataIO(dirname='test_catalogueconstructor')
    localdir, filenames, params = download_dataset(name='olfactory_bulb')
    #~ localdir, filenames, params = download_dataset(name='locust')
    dataio.set_data_source(type='RawData', filenames=filenames, **params)

    channels = range(14)
    #~ channels=list(range(4))
    dataio.add_one_channel_group(channels=channels, chan_grp=0)

    cc = CatalogueConstructor(dataio=dataio)

    for memory_mode in ['ram', 'memmap']:
        for mode in ['dense', 'sparse']:

            print('*' * 5)
            print('memory_mode', memory_mode, 'mode', mode)

            if mode == 'dense':
                peak_engine = 'numpy'
                peak_method = 'global'
                adjacency_radius_um = None
            elif mode == 'sparse':
                peak_engine = 'numpy'
                peak_method = 'geometrical'
                adjacency_radius_um = 450.

            cc.set_global_params(
                chunksize=1024,
                memory_mode=memory_mode,
                mode=mode,
                n_jobs=1,
                #~ adjacency_radius_um=adjacency_radius_um,
            )

            cc.set_preprocessor_params(
                #signal preprocessor
                highpass_freq=300,
                lowpass_freq=5000.,
                common_ref_removal=False,
                smooth_size=0,
                lostfront_chunksize=None)

            cc.set_peak_detector_params(
                #peak detector
                method=peak_method,
                engine=peak_engine,
                peak_sign='-',
                relative_threshold=7,
                peak_span_ms=0.5,
                adjacency_radius_um=adjacency_radius_um,
            )

            t1 = time.perf_counter()
            cc.estimate_signals_noise(seg_num=0, duration=10.)
            t2 = time.perf_counter()
            print('estimate_signals_noise', t2 - t1)

            t1 = time.perf_counter()
            cc.run_signalprocessor(duration=10., detect_peak=True)
            t2 = time.perf_counter()
            print('run_signalprocessor_loop', t2 - t1)

            for seg_num in range(dataio.nb_segment):
                mask = cc.all_peaks['segment'] == seg_num
                print('seg_num', seg_num, 'nb peak', np.sum(mask))

            # redetect peak
            cc.re_detect_peak(method=peak_method,
                              engine=peak_engine,
                              peak_sign='-',
                              relative_threshold=5,
                              peak_span_ms=0.7,
                              adjacency_radius_um=adjacency_radius_um)
            for seg_num in range(dataio.nb_segment):
                mask = cc.all_peaks['segment'] == seg_num
                print('seg_num', seg_num, 'nb peak', np.sum(mask))

            cc.set_waveform_extractor_params(n_left=-25, n_right=40)

            t1 = time.perf_counter()
            cc.clean_peaks(alien_value_threshold=100,
                           mode='extremum_amplitude')
            t2 = time.perf_counter()
            print('clean_peaks extremum_amplitude', t2 - t1)

            t1 = time.perf_counter()
            cc.clean_peaks(alien_value_threshold=100, mode='full_waveform')
            t2 = time.perf_counter()
            print('clean_peaks full_waveforms', t2 - t1)

            t1 = time.perf_counter()
            cc.sample_some_peaks(mode='rand', nb_max=5000)
            t2 = time.perf_counter()
            print('sample_some_peaks', t2 - t1)

            print(cc)

            #extract_some_noise
            t1 = time.perf_counter()
            cc.extract_some_noise(nb_snippet=400)
            t2 = time.perf_counter()
            print('extract_some_noise', t2 - t1)

            if mode == 'dense':
                # PCA
                t1 = time.perf_counter()
                cc.extract_some_features(method='global_pca', n_components=12)
                t2 = time.perf_counter()
                print('project pca', t2 - t1)

                # cluster
                t1 = time.perf_counter()
                cc.find_clusters(method='kmeans', n_clusters=11)
                t2 = time.perf_counter()
                print('find_clusters', t2 - t1)

            elif mode == 'sparse':

                # PCA
                t1 = time.perf_counter()
                cc.extract_some_features(method='pca_by_channel',
                                         n_components_by_channel=3)
                t2 = time.perf_counter()
                print('project pca', t2 - t1)

                # cluster
                t1 = time.perf_counter()
                cc.find_clusters(method='pruningshears')
                t2 = time.perf_counter()
                print('find_clusters', t2 - t1)

            print(cc)

        t1 = time.perf_counter()
        cc.auto_split_cluster()
        t2 = time.perf_counter()
        print('auto_split_cluster', t2 - t1)

        t1 = time.perf_counter()
        cc.trash_not_aligned()
        t2 = time.perf_counter()
        print('trash_not_aligned', t2 - t1)

        t1 = time.perf_counter()
        cc.auto_merge_cluster()
        t2 = time.perf_counter()
        print('auto_merge_cluster', t2 - t1)

        t1 = time.perf_counter()
        cc.trash_low_extremum()
        t2 = time.perf_counter()
        print('trash_low_extremum', t2 - t1)

        t1 = time.perf_counter()
        cc.trash_small_cluster()
        t2 = time.perf_counter()
        print('trash_small_cluster', t2 - t1)