def launch(task, filename, nb_cpu, nb_gpu, use_gpu, output=None, benchmark=None, extension='', sim_same_elec=None): from circus.shared.parser import CircusParser params = CircusParser(filename) if task not in ['filtering', 'benchmarking']: params.get_data_file() module = importlib.import_module('circus.' + task) if task == 'benchmarking': module.main(params, nb_cpu, nb_gpu, use_gpu, output, benchmark, sim_same_elec) elif task in ['converting', 'merging']: module.main(params, nb_cpu, nb_gpu, use_gpu, extension) else: module.main(params, nb_cpu, nb_gpu, use_gpu)
class TestConverting(unittest.TestCase): def setUp(self): self.all_spikes = None self.max_chunk = '100' dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'fitting.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'fitting', 1) mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name) self.parser.write('fitting', 'max_chunk', '10') mpi_launch('fitting', self.file_name, 2, 0, 'False') else: self.parser = CircusParser(self.file_name) def test_converting_some(self): self.parser.write('converting', 'export_pcs', 'some') mpi_launch('converting', self.file_name, 1, 0, 'False') self.parser.write('converting', 'export_pcs', 'prompt') def test_converting_all(self): self.parser.write('converting', 'export_pcs', 'all') mpi_launch('converting', self.file_name, 2, 0, 'False') self.parser.write('converting', 'export_pcs', 'prompt')
def main(argv=None): if argv is None: argv = sys.argv[1:] header = get_colored_header() header += '''Utility to split results obtained when using N streams into N individual results files, one per stream ''' parser = argparse.ArgumentParser( description=header, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('datafile', help='data file') parser.add_argument('-e', '--extension', help='extension to consider for slicing results', default='') if len(argv) == 0: parser.print_help() sys.exit() args = parser.parse_args(argv) filename = os.path.abspath(args.datafile) extension = args.extension if extension != '': extension = '-' + extension params = CircusParser(filename) if os.path.exists(params.logfile): os.remove(params.logfile) _ = init_logging(params.logfile) logger = logging.getLogger(__name__) file_out_suff = params.get('data', 'file_out_suff') if params.get('data', 'stream_mode') in ['None', 'none']: print_and_log(['No streams in the datafile!'], 'error', logger) sys.exit(1) data_file = params.get_data_file() result = circus.shared.files.get_results(params, extension=extension) times = [] for source in data_file._sources: times += [[source.t_start, source.t_stop]] sub_results = slice_result(result, times) for count, result in enumerate(sub_results): keys = ['spiketimes', 'amplitudes'] mydata = h5py.File(file_out_suff + '.result%s_%d.hdf5' % (extension, count), 'w', libver='earliest') for key in keys: mydata.create_group(key) for temp in result[key].keys(): tmp_path = '%s/%s' % (key, temp) mydata.create_dataset(tmp_path, data=result[key][temp]) mydata.close()
def setUp(self): self.all_spikes = None self.max_chunk = '100' dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'fitting.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'fitting') mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name)
def setUp(self): self.all_matches = None self.all_templates = None dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'smart_search.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'smart-search', 1) mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name) self.parser.write('clustering', 'max_elts', '2000')
def setUp(self): dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'whitening.dat') self.source_dataset = get_dataset(self) self.whitening = None if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'fitting', 1) self.params = CircusParser(self.file_name) self.params.write('clustering', 'max_elts', '1000') self.params.write('whitening', 'spatial', 'True') self.params.write('clustering', 'temporal', 'False')
def setUp(self): dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'drifts.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'drifts', 1) mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name)
class TestSmartSearch(unittest.TestCase): def setUp(self): self.all_matches = None self.all_templates = None dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'smart_search.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'smart-search', 1) mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name) self.parser.write('clustering', 'max_elts', '2000') #def tearDown(self): # data_path = '.'.join(self.file_name.split('.')[:-1]) # shutil.rmtree(data_path) def test_smart_search_on(self): self.parser.write('clustering', 'smart_search', 'True') mpi_launch('clustering', self.file_name, 2, 0, 'False') self.parser.write('clustering', 'smart_search', 'False') res = get_performance(self.file_name, 'smart_search_on') def test_smart_search_off(self): mpi_launch('clustering', self.file_name, 2, 0, 'False') res = get_performance(self.file_name, 'smart_search_off')
class TestValidating(unittest.TestCase): def setUp(self): self.all_spikes = None self.max_chunk = '100' dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'fitting.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'fitting', 1) mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name) self.length = self.parser.get_data_file().duration def test_validating(self): #mpi_launch('fitting', self.file_name, 2, 0, 'False') a, b = os.path.splitext(os.path.basename(self.file_name)) file_name, ext = os.path.splitext(self.file_name) file_out = os.path.join(os.path.abspath(file_name), a) result_name = os.path.join(file_name, 'injected') spikes = {} result = h5py.File(os.path.join(result_name, '%s.result.hdf5' % a)) for key in result.get('spiketimes').keys(): spikes[key] = result.get('spiketimes/%s' % key)[:] juxta_file = file_out + '.juxta.dat' f = numpy.memmap(juxta_file, shape=(self.length, 1), dtype=self.parser.get('validating', 'juxta_dtype'), mode='w+') f[spikes['temp_9']] = 100 del f mpi_launch('validating', self.file_name, 2, 0, 'False')
class TestWhitening(unittest.TestCase): def setUp(self): dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'whitening.dat') self.source_dataset = get_dataset(self) self.whitening = None if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'fitting', 1) self.params = CircusParser(self.file_name) self.params.write('clustering', 'max_elts', '1000') self.params.write('whitening', 'spatial', 'True') self.params.write('clustering', 'temporal', 'False') def test_whitening_one_CPU(self): mpi_launch('whitening', self.file_name, 1, 0, 'False') res = get_performance(self.file_name, 'one_CPU') if self.whitening is None: self.whitening = res assert ((res['spatial'] - self.whitening['spatial'])**2).mean() < 0.1 def test_whitening_two_CPU(self): mpi_launch('whitening', self.file_name, 2, 0, 'False') res = get_performance(self.file_name, 'two_CPU') if self.whitening is None: self.whitening = res assert ((res['spatial'] - self.whitening['spatial'])**2).mean() < 0.1 def test_whitening_safety_time(self): self.params.write('clustering', 'safety_time', '5') mpi_launch('whitening', self.file_name, 1, 0, 'False') self.params.write('clustering', 'safety_time', 'auto') res = get_performance(self.file_name, 'safety_time') if self.whitening is None: self.whitening = res assert ((res['spatial'] - self.whitening['spatial'])**2).mean() < 0.1
class TestGarbage(unittest.TestCase): def setUp(self): self.all_spikes = None self.max_chunk = '100' dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'fitting.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'fitting') mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name) def test_collect_all(self): self.parser.write('fitting', 'max_chunk', self.max_chunk) self.parser.write('fitting', 'collect_all', 'True') mpi_launch('fitting', self.file_name, 1, 0, 'False') self.parser.write('fitting', 'max_chunk', 'inf') self.parser.write('fitting', 'collect_all', 'False') ctruth, cspikes, cgarbage = get_performance(self.file_name) assert cgarbage < cspikes
"""Inspect basis waveforms.""" import argparse import h5py import matplotlib.pyplot as plt import numpy as np import os from circus.shared.parser import CircusParser # Parse arguments. parser = argparse.ArgumentParser(description="Inspect basis waveforms.") parser.add_argument('datafile', help="data file") args = parser.parse_args() # Load parameters. params = CircusParser(args.datafile) _ = params.get_data_file() sampling_rate = params.rate file_out_suff = params.get('data', 'file_out_suff') nb_channels = params.getint('data', 'N_e') nb_time_steps = params.getint('detection', 'N_t') # Load basis waveforms. basis_path = "{}.basis.hdf5".format(file_out_suff) if not os.path.isfile(basis_path): raise FileNotFoundError(basis_path) with h5py.File(basis_path, mode='r', libver='earliest') as basis_file: if 'proj' not in basis_file: raise RuntimeError( "No projection matrix found in {}.".format(basis_path)) projection_matrix = basis_file['proj'][:]
def main(params, nb_cpu, nb_gpu, use_gpu, file_name, benchmark, sim_same_elec): """ Useful tool to create synthetic datasets for benchmarking. Arguments --------- benchmark : {'fitting', 'clustering', 'synchrony', 'pca-validation', 'smart-search', 'drifts'} """ if sim_same_elec is None: sim_same_elec = 0.8 logger = init_logging(params.logfile) logger = logging.getLogger('circus.benchmarking') numpy.random.seed(265) file_name = os.path.abspath(file_name) data_path = os.path.dirname(file_name) data_suff, ext = os.path.splitext(os.path.basename(file_name)) file_out, ext = os.path.splitext(file_name) if ext == '': ext = '.dat' file_name += ext if ext != '.dat': if comm.rank == 0: print_and_log(['Benchmarking produces raw files: select a .dat extension'], 'error', logger) sys.exit(0) if benchmark not in ['fitting', 'clustering', 'synchrony', 'smart-search', 'drifts']: if comm.rank == 0: print_and_log(['Benchmark need to be in [fitting, clustering, synchrony, smart-search, drifts]'], 'error', logger) sys.exit(0) # The extension `.p` or `.pkl` or `.pickle` seems more appropriate than `.pic`. # see: http://stackoverflow.com/questions/4530111/python-saving-objects-and-using-pickle-extension-of-filename # see: https://wiki.python.org/moin/UsingPickle def write_benchmark(filename, benchmark, cells, rates, amplitudes, sampling, probe, trends=None): """Save benchmark parameters in a file to remember them.""" import cPickle to_write = {'benchmark' : benchmark} to_write['cells'] = cells to_write['rates'] = rates to_write['probe'] = probe to_write['amplitudes'] = amplitudes to_write['sampling'] = sampling if benchmark == 'drifts': to_write['drifts'] = trends cPickle.dump(to_write, open(filename + '.pic', 'w')) # Retrieve some key parameters. templates = io.load_data(params, 'templates') N_tm = templates.shape[1] // 2 trends = None # Normalize some variables. if benchmark == 'fitting': nb_insert = 25 n_cells = numpy.random.random_integers(0, N_tm - 1, nb_insert) rate = nb_insert * [10] amplitude = numpy.linspace(0.5, 5, nb_insert) if benchmark == 'clustering': n_point = 5 n_cells = numpy.random.random_integers(0, N_tm - 1, n_point ** 2) x, y = numpy.mgrid[0:n_point, 0:n_point] rate = numpy.linspace(0.5, 20, n_point)[x.flatten()] amplitude = numpy.linspace(0.5, 5, n_point)[y.flatten()] if benchmark == 'synchrony': nb_insert = 5 corrcoef = 0.2 n_cells = nb_insert * [numpy.random.random_integers(0, N_tm - 1, 1)[0]] rate = 10. / corrcoef amplitude = 2 if benchmark == 'pca-validation': nb_insert = 10 n_cells = numpy.random.random_integers(0, N_tm - 1, nb_insert) rate_min = 0.5 rate_max = 20.0 rate = rate_min + (rate_max - rate_min) * numpy.random.random_sample(nb_insert) amplitude_min = 0.5 amplitude_max = 5.0 amplitude = amplitude_min + (amplitude_max - amplitude_min) * numpy.random.random_sample(nb_insert) if benchmark == 'smart-search': nb_insert = 10 n_cells = nb_insert*[numpy.random.random_integers(0, templates.shape[1]//2-1, 1)[0]] rate = 1 + 5*numpy.arange(nb_insert) amplitude = 2 if benchmark == 'drifts': n_point = 5 n_cells = numpy.random.random_integers(0, templates.shape[1]//2-1, n_point**2) x, y = numpy.mgrid[0:n_point,0:n_point] rate = 5*numpy.ones(n_point)[x.flatten()] amplitude = numpy.linspace(0.5, 5, n_point)[y.flatten()] trends = numpy.random.randn(n_point**2) # Delete the output directory tree if this output directory exists. if comm.rank == 0: if os.path.exists(file_out): shutil.rmtree(file_out) # Check and normalize some variables. if n_cells is None: n_cells = 1 cells = [numpy.random.permutation(numpy.arange(n_cells))[0]] elif not numpy.iterable(n_cells): cells = [n_cells] n_cells = 1 else: cells = n_cells n_cells = len(cells) if numpy.iterable(rate): assert len(rate) == len(cells), "Should have the same number of rates and cells" else: rate = [rate] * len(cells) if numpy.iterable(amplitude): assert len(amplitude) == len(cells), "Should have the same number of amplitudes and cells" else: amplitude = [amplitude] * len(cells) # Retrieve some additional key parameters. #params = detect_memory(params) data_file = params.get_data_file(source=True) N_e = params.getint('data', 'N_e') N_total = params.nb_channels hdf5_compress = params.getboolean('data', 'hdf5_compress') nodes, edges = get_nodes_and_edges(params) N_t = params.getint('detection', 'N_t') inv_nodes = numpy.zeros(N_total, dtype=numpy.int32) inv_nodes[nodes] = numpy.argsort(nodes) do_temporal_whitening = params.getboolean('whitening', 'temporal') do_spatial_whitening = params.getboolean('whitening', 'spatial') N_tm_init = templates.shape[1]//2 thresholds = io.load_data(params, 'thresholds') limits = io.load_data(params, 'limits') best_elecs = io.load_data(params, 'electrodes') norms = io.load_data(params, 'norm-templates') # Create output directory if it does not exist. if comm.rank == 0: if not os.path.exists(file_out): os.makedirs(file_out) # Save benchmark parameters in a file to remember them. if comm.rank == 0: write_benchmark(file_out, benchmark, cells, rate, amplitude, params.rate, params.get('data', 'mapping'), trends) # Synchronize all the threads/processes. comm.Barrier() if do_spatial_whitening: spatial_whitening = io.load_data(params, 'spatial_whitening') if do_temporal_whitening: temporal_whitening = io.load_data(params, 'temporal_whitening') # Retrieve some additional key parameters. chunk_size = params.getint('data', 'chunk_size') scalings = [] params.set('data', 'data_file', file_name) data_file_out = params.get_data_file(is_empty=True) data_file_out.allocate(shape=data_file.shape) # Synchronize all the threads/processes. comm.Barrier() # For each wanted synthesized cell insert a generated template in the set of # existing template. for gcount, cell_id in enumerate(cells): best_elec = best_elecs[cell_id] indices = inv_nodes[edges[nodes[best_elec]]] count = 0 new_indices = [] all_elecs = numpy.random.permutation(numpy.arange(N_e)) reference = templates[:, cell_id].toarray().reshape(N_e, N_t) # Initialize the similarity (i.e. default value). similarity = 1.0 # Find the first eligible template for the wanted synthesized cell. while len(new_indices) != len(indices) or (similarity > sim_same_elec): similarity = 0 if count == len(all_elecs): if comm.rank == 0: print_and_log(["No electrode to move template %d (max similarity is %g)" %(cell_id, similarity)], 'error', logger) sys.exit(0) else: # Get the next shuffled electrode. n_elec = all_elecs[count] if benchmark not in ['synchrony', 'smart-search']: # Process if the shuffled electrode and the nearest electrode # to the synthesized cell are not identical. local_test = n_elec != best_elec else: # Process if the shuffled electrode and the nearest electrode # to the synthesized cell are identical. local_test = n_elec == best_elec if local_test: # Shuffle the neighboring electrodes whithout modifying # the nearest electrode to the synthesized cell. new_indices = inv_nodes[edges[nodes[n_elec]]] idx = numpy.where(new_indices != best_elec)[0] new_indices[idx] = numpy.random.permutation(new_indices[idx]) if len(new_indices) == len(indices): # Shuffle the templates on the neighboring electrodes. new_temp = numpy.zeros(reference.shape, dtype=numpy.float32) new_temp[new_indices, :] = reference[indices, :] # Compute the scaling factor which normalize the # shuffled template. gmin = new_temp.min() data = numpy.where(new_temp == gmin) scaling = -thresholds[data[0][0]]/gmin for i in xrange(templates.shape[1]//2): match = templates[:, i].toarray().reshape(N_e, N_t) d = numpy.corrcoef(match.flatten(), scaling * new_temp.flatten())[0, 1] if d > similarity: similarity = d else: new_indices = [] # Go to the next shuffled electrode. count += 1 #if comm.rank == 0: # print "Template", cell_id, "is shuffled from electrode", best_elec, "to", n_elec, "(max similarity is %g)" %similarity N_tm = templates.shape[1]//2 to_insert = numpy.zeros(reference.shape, dtype=numpy.float32) to_insert[new_indices] = scaling*amplitude[gcount]*templates[:, cell_id].toarray().reshape(N_e, N_t)[indices] to_insert2 = numpy.zeros(reference.shape, dtype=numpy.float32) to_insert2[new_indices] = scaling*amplitude[gcount]*templates[:, cell_id + N_tm].toarray().reshape(N_e, N_t)[indices] ## Insert the selected template. # Retrieve the number of existing templates in the dataset. N_tm = templates.shape[1]//2 # Generate the template of the synthesized cell from the selected # template, the target amplitude and the rescaling (i.e. threshold of # the target electrode). to_insert = numpy.zeros(reference.shape, dtype=numpy.float32) to_insert[new_indices] = scaling * amplitude[gcount] * templates[:, cell_id].toarray().reshape(N_e, N_t)[indices] to_insert = to_insert.flatten() to_insert2 = numpy.zeros(reference.shape, dtype=numpy.float32) to_insert2[new_indices] = scaling * amplitude[gcount] * templates[:, cell_id + N_tm].toarray().reshape(N_e, N_t)[indices] to_insert2 = to_insert2.flatten() # Compute the norm of the generated template. mynorm = numpy.sqrt(numpy.sum(to_insert ** 2) / (N_e * N_t)) mynorm2 = numpy.sqrt(numpy.sum(to_insert2 ** 2) / (N_e * N_t)) # Insert the limits of the generated template. limits = numpy.vstack((limits, limits[cell_id])) # Insert the best electrode of the generated template. best_elecs = numpy.concatenate((best_elecs, [n_elec])) # Insert the norm of the generated template (i.e. central component and # orthogonal component). norms = numpy.insert(norms, N_tm, mynorm) norms = numpy.insert(norms, 2 * N_tm + 1, mynorm2) # Insert the scaling of the generated template. scalings += [scaling] # Retrieve the data about the existing templates. templates = templates.tocoo() xdata = templates.row ydata = templates.col zdata = templates.data # Shift by one the orthogonal components of the existing templates. idx = numpy.where(ydata >= N_tm)[0] ydata[idx] += 1 # Insert the central component of the selected template. dx = to_insert.nonzero()[0].astype(numpy.int32) xdata = numpy.concatenate((xdata, dx)) ydata = numpy.concatenate((ydata, N_tm * numpy.ones(len(dx), dtype=numpy.int32))) zdata = numpy.concatenate((zdata, to_insert[dx])) # Insert the orthogonal component of the selected template. dx = to_insert2.nonzero()[0].astype(numpy.int32) xdata = numpy.concatenate((xdata, dx)) ydata = numpy.concatenate((ydata, (2 * N_tm + 1) * numpy.ones(len(dx), dtype=numpy.int32))) zdata = numpy.concatenate((zdata, to_insert2[dx])) # Recontruct the matrix of templates. templates = scipy.sparse.csc_matrix((zdata, (xdata, ydata)), shape=(N_e * N_t, 2 * (N_tm + 1))) # Remove all the expired data. if benchmark == 'pca-validation': # Remove all the expired data. N_tm_init = 0 N_tm = templates.shape[1] / 2 limits = limits[N_tm - nb_insert:, :] best_elecs = best_elecs[N_tm - nb_insert:] norms = numpy.concatenate((norms[N_tm-nb_insert:N_tm], norms[2*N_tm-nb_insert:2*N_tm])) scalings = scalings templates = templates.tocoo() xdata = templates.row ydata = templates.col zdata = templates.data idx_cen = numpy.logical_and(N_tm - nb_insert <= ydata, ydata < N_tm) idx_cen = numpy.where(idx_cen)[0] idx_ort = numpy.logical_and(2 * N_tm - nb_insert <= ydata, ydata < 2 * N_tm) idx_ort = numpy.where(idx_ort)[0] ydata[idx_cen] = ydata[idx_cen] - (N_tm - nb_insert) ydata[idx_ort] = ydata[idx_ort] - 2 * (N_tm - nb_insert) idx = numpy.concatenate((idx_cen, idx_ort)) xdata = xdata[idx] ydata = ydata[idx] zdata = zdata[idx] templates = scipy.sparse.csc_matrix((zdata, (xdata, ydata)), shape=(N_e * N_t, 2 * nb_insert)) # Retrieve the information about the organisation of the chunks of data. nb_chunks, last_chunk_len = data_file.analyze(chunk_size) # Display informations about the generated benchmark. if comm.rank == 0: print_and_log(["Generating benchmark data [%s] with %d cells" %(benchmark, n_cells)], 'info', logger) purge(file_out, '.data') template_shift = params.getint('detection', 'template_shift') all_chunks = numpy.arange(nb_chunks) to_process = all_chunks[numpy.arange(comm.rank, nb_chunks, comm.size)] loc_nb_chunks = len(to_process) numpy.random.seed(comm.rank) to_explore = xrange(comm.rank, nb_chunks, comm.size) # Initialize the progress bar about the generation of the benchmark. if comm.rank == 0: to_explore = get_tqdm_progressbar(to_explore) # Open the file for collective I/O. #g = myfile.Open(comm, file_name, MPI.MODE_RDWR) #g.Set_view(data_offset, data_mpi, data_mpi) data_file_out.open(mode='r+') # Open the thread/process' files to collect the results. spiketimes_filename = os.path.join(file_out, data_suff + '.spiketimes-%d.data' %comm.rank) spiketimes_file = open(spiketimes_filename, 'wb') amplitude_filename = os.path.join(file_out, data_suff + '.amplitudes-%d.data' %comm.rank) amplitudes_file = open(amplitude_filename, 'wb') templates_filename = os.path.join(file_out, data_suff + '.templates-%d.data' %comm.rank) templates_file = open(templates_filename, 'wb') real_amps_filename = os.path.join(file_out, data_suff + '.real_amps-%d.data' %comm.rank) real_amps_file = open(real_amps_filename, 'wb') voltages_filename = os.path.join(file_out, data_suff + '.voltages-%d.data' %comm.rank) voltages_file = open(voltages_filename, 'wb') # For each chunk of data associate to the current thread/process generate # the new chunk of data (i.e. with considering the added synthesized cells). for count, gidx in enumerate(to_explore): #if (last_chunk_len > 0) and (gidx == (nb_chunks - 1)): # chunk_len = last_chunk_len # chunk_size = last_chunk_len // N_total result = {'spiketimes' : [], 'amplitudes' : [], 'templates' : [], 'real_amps' : [], 'voltages' : []} offset = gidx * chunk_size local_chunk, t_offset = data_file.get_data(gidx, chunk_size, nodes=nodes) if benchmark == 'pca-validation': # Clear the current data chunk. local_chunk = numpy.zeros(local_chunk.shape, dtype=local_chunk.dtype) # Handle whitening if necessary. if do_spatial_whitening: local_chunk = numpy.dot(local_chunk, spatial_whitening) if do_temporal_whitening: local_chunk = scipy.ndimage.filters.convolve1d(local_chunk, temporal_whitening, axis=0, mode='constant') if benchmark is 'synchrony': # Generate some spike indices (i.e. times) at the given rate for # 'synchrony' mode. Each synthesized cell will use a subset of this # spike times. mips = numpy.random.rand(chunk_size) < rate[0] / float(params.rate) # For each synthesized cell generate its spike indices (i.e.times) and # add them to the dataset. for idx in xrange(len(cells)): if benchmark is 'synchrony': # Choose a subset of the spike indices generated before. The # size of this subset is parameterized by the target correlation # coefficients. sidx = numpy.where(mips == True)[0] spikes = numpy.zeros(chunk_size, dtype=numpy.bool) spikes[sidx[numpy.random.rand(len(sidx)) < corrcoef]] = True else: # Generate some spike indices at the given rate. spikes = numpy.random.rand(chunk_size) < rate[idx] / float(params.rate) if benchmark == 'drifts': amplitudes = numpy.ones(len(spikes)) + trends[idx]*((spikes + offset)/(5*60*float(params.rate))) else: amplitudes = numpy.ones(len(spikes)) # Padding with `False` to avoid the insertion of partial spikes at # the edges of the signal. spikes[:N_t] = False spikes[-N_t:] = False # Find the indices of the spike samples. spikes = numpy.where(spikes == True)[0] n_template = N_tm_init + idx loc_template = templates[:, n_template].toarray().reshape(N_e, N_t) first_flat = loc_template.T.flatten() norm_flat = numpy.sum(first_flat ** 2) # For each index (i.e. spike sample location) add the spike to the # chunk of data. refractory = int(5 * 1e-3 * params.rate) t_last = - refractory for scount, spike in enumerate(spikes): if (spike - t_last) > refractory: local_chunk[spike-template_shift:spike+template_shift+1, :] += amplitudes[scount]*loc_template.T amp = numpy.dot(local_chunk[spike-template_shift:spike+template_shift+1, :].flatten(), first_flat) amp /= norm_flat result['real_amps'] += [amp] result['spiketimes'] += [spike + offset] result['amplitudes'] += [(amplitudes[scount], 0)] result['templates'] += [n_template] result['voltages'] += [local_chunk[spike, best_elecs[idx]]] t_last = spike # Write the results into the thread/process' files. spikes_to_write = numpy.array(result['spiketimes'], dtype=numpy.uint32) amplitudes_to_write = numpy.array(result['amplitudes'], dtype=numpy.float32) templates_to_write = numpy.array(result['templates'], dtype=numpy.int32) real_amps_to_write = numpy.array(result['real_amps'], dtype=numpy.float32) voltages_to_write = numpy.array(result['voltages'], dtype=numpy.float32) spiketimes_file.write(spikes_to_write.tostring()) amplitudes_file.write(amplitudes_to_write.tostring()) templates_file.write(templates_to_write.tostring()) real_amps_file.write(real_amps_to_write.tostring()) voltages_file.write(voltages_to_write.tostring()) #print count, 'spikes inserted...' #new_chunk = numpy.zeros((chunk_size, N_total), dtype=numpy.float32) #new_chunk[:, nodes] = local_chunk # Overwrite the new chunk of data using explicit offset. #new_chunk = new_chunk.flatten() #g.Write_at(gidx * chunk_len, new_chunk) data_file_out.set_data(offset, local_chunk) # Update the progress bar about the generation of the benchmark. # Close the thread/process' files. spiketimes_file.flush() os.fsync(spiketimes_file.fileno()) spiketimes_file.close() amplitudes_file.flush() os.fsync(amplitudes_file.fileno()) amplitudes_file.close() templates_file.flush() os.fsync(templates_file.fileno()) templates_file.close() real_amps_file.flush() os.fsync(real_amps_file.fileno()) real_amps_file.close() voltages_file.flush() os.fsync(voltages_file.fileno()) voltages_file.close() # Close the file for collective I/O. data_file_out.close() data_file.close() # Synchronize all the threads/processes. comm.Barrier() ## Eventually, perform all the administrative tasks. ## (i.e. files and folders management). file_params = file_out + '.params' if comm.rank == 0: # Create `injected` directory if it does not exist result_path = os.path.join(file_out, 'injected') if not os.path.exists(result_path): os.makedirs(result_path) # Copy initial configuration file from `<dataset1>.params` to `<dataset2>.params`. shutil.copy2(params.get('data', 'data_file_noext') + '.params', file_params) new_params = CircusParser(file_name) # Copy initial basis file from `<dataset1>/<dataset1>.basis.hdf5` to # `<dataset2>/injected/<dataset2>.basis.hdf5. shutil.copy2(params.get('data', 'file_out') + '.basis.hdf5', os.path.join(result_path, data_suff + '.basis.hdf5')) # Save templates into `<dataset>/<dataset>.templates.hdf5`. mydata = h5py.File(os.path.join(file_out, data_suff + '.templates.hdf5'), 'w') templates = templates.tocoo() if hdf5_compress: mydata.create_dataset('temp_x', data=templates.row, compression='gzip') mydata.create_dataset('temp_y', data=templates.col, compression='gzip') mydata.create_dataset('temp_data', data=templates.data, compression='gzip') else: mydata.create_dataset('temp_x', data=templates.row) mydata.create_dataset('temp_y', data=templates.col) mydata.create_dataset('temp_data', data=templates.data) mydata.create_dataset('temp_shape', data=numpy.array([N_e, N_t, templates.shape[1]], dtype=numpy.int32)) mydata.create_dataset('limits', data=limits) mydata.create_dataset('norms', data=norms) mydata.close() # Save electrodes into `<dataset>/<dataset>.clusters.hdf5`. mydata = h5py.File(os.path.join(file_out, data_suff + '.clusters.hdf5'), 'w') mydata.create_dataset('electrodes', data=best_elecs) mydata.close() comm.Barrier() if comm.rank == 0: # Gather data from all threads/processes. f_next, extension = os.path.splitext(file_name) file_out_bis = os.path.join(f_next, os.path.basename(f_next)) #new_params.set('data', 'file_out', file_out_bis) # Output file without suffix #new_params.set('data', 'file_out_suff', file_out_bis + params.get('data', 'suffix')) new_params.get_data_file() io.collect_data(comm.size, new_params, erase=True, with_real_amps=True, with_voltages=True, benchmark=True) # Change some flags in the configuration file. new_params.write('whitening', 'temporal', 'False') # Disable temporal filtering new_params.write('whitening', 'spatial', 'False') # Disable spatial filtering new_params.write('data', 'data_dtype', 'float32') # Set type of the data to float32 new_params.write('data', 'dtype_offset', 'auto') # Set padding for data to auto # Move results from `<dataset>/<dataset>.result.hdf5` to # `<dataset>/injected/<dataset>.result.hdf5`. shutil.move(os.path.join(file_out, data_suff + '.result.hdf5'), os.path.join(result_path, data_suff + '.result.hdf5')) # Save scalings into `<dataset>/injected/<dataset>.scalings.npy`. numpy.save(os.path.join(result_path, data_suff + '.scalings'), scalings) file_name_noext, ext = os.path.splitext(file_name) # Copy basis from `<dataset>/injected/<dataset>.basis.hdf5` to # `<dataset>/<dataset>.basis.hdf5`. shutil.copy2(os.path.join(result_path, data_suff + '.basis.hdf5'), os.path.join(file_out, data_suff + '.basis.hdf5')) if benchmark not in ['fitting', 'synchrony']: # Copy templates from `<dataset>/<dataset>.templates.hdf5` to # `<dataset>/injected/<dataset>.templates.hdf5` shutil.move(os.path.join(file_out, data_suff + '.templates.hdf5'), os.path.join(result_path, data_suff + '.templates.hdf5'))
], help="fitted snippets selection") parser.add_argument('-n', '--nb-snippets', default=10, type=int, help="number of snippets to select") args = parser.parse_args() # # Adjust extension argument. if args.extension is None: args.extension = "" else: args.extension = "-" + args.extension # Load parameters. params = CircusParser(args.datafile) _ = params.get_data_file() sampling_rate = params.rate duration = params.data_file.duration # Load spike times and amplitudes. results = load_data(params, 'results', extension=args.extension) template_key = 'temp_{}'.format(args.template_id) spike_times = results['spiketimes'][template_key][:] amplitudes = results['amplitudes'][template_key][:, 0] # Check number of spikes. nb_spikes = spike_times.size if nb_spikes == 0: warnings.warn("No fitted spikes for template {}.".format(args.template_id), category=UserWarning)
def main(argv=None): if argv is None: argv = sys.argv[1:] header = get_colored_header() parser = argparse.ArgumentParser( description=header, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('datafile', help='data file') parser.add_argument('-e', '--extension', help='extension to consider for visualization', default='') if len(argv) == 0: parser.print_help() sys.exit() args = parser.parse_args(argv) filename = os.path.abspath(args.datafile) extension = args.extension params = CircusParser(filename) if os.path.exists(params.logfile): os.remove(params.logfile) logger = init_logging(params.logfile) logger = logging.getLogger(__name__) data_file = params.get_data_file() data_dtype = data_file.data_dtype gain = data_file.gain t_start = data_file.t_start file_format = data_file.description if file_format not in supported_by_matlab: print_and_log([ "File format %s is not supported by MATLAB. Waveforms disabled" % file_format ], 'info', logger) if numpy.iterable(gain): print_and_log( ['Multiple gains are not supported, using a default value of 1'], 'info', logger) gain = 1 file_out_suff = params.get('data', 'file_out_suff') if hasattr(data_file, 'data_offset'): data_offset = data_file.data_offset else: data_offset = 0 probe = params.probe if extension != '': extension = '-' + extension def generate_matlab_mapping(probe): p = {} positions = [] nodes = [] for key in probe['channel_groups'].keys(): p.update(probe['channel_groups'][key]['geometry']) nodes += probe['channel_groups'][key]['channels'] positions += [ p[channel] for channel in probe['channel_groups'][key]['channels'] ] idx = numpy.argsort(nodes) positions = numpy.array(positions)[idx] t = tempfile.NamedTemporaryFile().name + '.hdf5' cfile = h5py.File(t, 'w') to_write = { 'positions': positions / 10., 'permutation': numpy.sort(nodes), 'nb_total': numpy.array([probe['total_nb_channels']]) } write_datasets(cfile, to_write.keys(), to_write) cfile.close() return t mapping = generate_matlab_mapping(probe) if not params.getboolean('data', 'overwrite'): filename = params.get('data', 'data_file_no_overwrite') else: filename = params.get('data', 'data_file') apply_patch_for_similarities(params, extension) gui_file = pkg_resources.resource_filename( 'circus', os.path.join('matlab_GUI', 'SortingGUI.m')) # Change to the directory of the matlab file os.chdir(os.path.abspath(os.path.dirname(gui_file))) # Use quotation marks for string arguments if file_format not in supported_by_matlab: gui_params = [ params.rate, os.path.abspath(file_out_suff), '%s.mat' % extension, mapping, 2, t_start ] is_string = [False, True, True, True, False] else: gui_params = [ params.rate, os.path.abspath(file_out_suff), '%s.mat' % extension, mapping, 2, t_start, data_dtype, data_offset, gain, filename ] is_string = [ False, True, True, True, False, False, True, False, False, True ] arguments = ', '.join([ "'%s'" % arg if s else "%s" % arg for arg, s in zip(gui_params, is_string) ]) matlab_command = 'SortingGUI(%s)' % arguments print_and_log(["Launching the MATLAB GUI..."], 'info', logger) print_and_log([matlab_command], 'debug', logger) if params.getboolean('fitting', 'collect_all'): print_and_log([ 'You can not view the unfitted spikes with the MATLAB GUI', 'Please consider using phy if you really would like to see them' ], 'info', logger) try: sys.exit( subprocess.call( ['matlab', '-nodesktop', '-nosplash', '-r', matlab_command])) except Exception: print_and_log( ["Something wrong with MATLAB. Try circus-gui-python instead?"], 'error', logger) sys.exit(1)
def get_label_for_sc_index(sc_index: int, dead_channels: list, ordered_mcs_indices: list, pad_with_zero: bool = False): return get_label_for_mcs_index(get_mcs_index(sc_index, dead_channels), ordered_mcs_indices, pad_with_zero) # CHANGE PATHS TO ANALYZE DIFFERENT FILES filtered_filepath = r'/mnt/Data/Albina/data from home/2021-06-29T12-05-34Control_slice2.h5' result_filepath = r'/mnt/Data/Albina/data from home/2021-06-29T12-05-34Control_slice2/' \ r'2021-06-29T12-05-34Control_slice2.clusters.hdf5' filter_file = h5py.File(filtered_filepath, 'r') result_file = h5py.File(result_filepath, 'r') params = CircusParser(filtered_filepath) filter_file_voltage_traces = filter_file['Data']['Recording_0'][ 'AnalogStream']['Stream_0']['ChannelData'] ch_ids = [ ch[1] for ch in filter_file['Data']['Recording_0']['AnalogStream'] ['Stream_0']['InfoChannel'] ] spike_indices = retrieve_spiketimes(result_file) sorted_spike_indices = [ np.sort(spike_indices[m]) for m in range(len(spike_indices)) ] sampling_rate = float(params.get('data', 'sampling_rate')) spiketimes = np.array(spike_indices, dtype=object) / sampling_rate sorted_spiketimes = [np.sort(spiketimes[i]) for i in range(len(spiketimes))] spike_differences = [
def set_params_spc(self, main_params, npy_file, output): ''' Set parameters file for Spyking Circus Parameters ---------- main_params : dictionary Some parameters that are useful for setting: -- 'N_t' -- 'cut_off' -- 'stream_mode' -- dead_channels ('grad_idx'/'mag_idx') -- 'cc_merge' npy_file : pathlib.PosixPath The path to the numpy data file in the CIRCUS folder output : pathlib.PosixPath The directory where the results will be saved. Different for magnetometers and gradiometers ''' from shutil import copyfile from circus.shared.parser import CircusParser self.params = CircusParser(npy_file, create_folders=False) ### data self.params.write('data','file_format','numpy') self.params.write('data','stream_mode', main_params['stream_mode']) self.params.write('data','mapping', str(output.parent / 'meg_306.prb')) self.params.write('data','output_dir',str(output)) self.params.write('data','sampling_rate','1000') ### detection self.params.write('detection','radius', '6') self.params.write('detection','N_t', str(main_params['N_t'])) #self.params.write('detection','spike_thresh', '6') self.params.write('detection','peaks','both') self.params.write('detection','alignment','False') self.params.write('detection','isolation','False') if (self.sensors == 'mag'): grad = '{ 1 : %s}'%main_params['grad_idx'] self.params.write('detection','dead_channels', grad) else: mag = '{ 1 : %s}'%main_params['mag_idx'] self.params.write('detection','dead_channels', mag) ### filtering filt_param = '{}, {}'.format(main_params['cut_off'][0], main_params['cut_off'][1]) self.params.write('filtering','cut_off',filt_param) ### whitening self.params.write('whitening','safety_time','auto') self.params.write('whitening','max_elts','10000') self.params.write('whitening','nb_elts','0.1') self.params.write('whitening','spatial','False') ### clustering self.params.write('clustering','extraction','mean-raw') self.params.write('clustering','safety_space','False') self.params.write('clustering','safety_time','1') self.params.write('clustering','max_elts','10000') self.params.write('clustering','nb_elts','0.001') self.params.write('clustering','nclus_min','0.0001') self.params.write('clustering','smart_search','False') self.params.write('clustering','sim_same_elec','1') self.params.write('clustering','sensitivity','5') self.params.write('clustering','cc_merge', str(main_params['cc_merge'])) self.params.write('clustering','dispersion','(5, 5)') self.params.write('clustering','noise_thr','0.9') #self.params.write('clustering','remove_mixture','False') self.params.write('clustering','cc_mixtures','0.1') self.params.write('clustering','make_plots','png') ### fitting self.params.write('fitting','chunk_size','60') self.params.write('fitting','amp_limits','(0.01,10)') self.params.write('fitting','amp_auto','False') self.params.write('fitting','collect_all','True') ### merging self.params.write('merging','cc_overlap','0.4') self.params.write('merging','cc_bin','200') self.params = CircusParser(npy_file, create_folders=False) copyfile(self.path_params, output / 'config.param')
def get_dataset(self): dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) filename = os.path.join(dirname, 'data') if not os.path.exists(filename): os.makedirs(filename) result = os.path.join(filename, 'data') filename = os.path.join(filename, 'data.dat') if not os.path.exists(filename): print "Generating a synthetic dataset of 4 channels, 1min at 20kHz..." sampling_rate = 20000 N_total = 4 gain = 0.5 data = (gain * numpy.random.randn(sampling_rate * N_total * 1 * 60)).astype( numpy.float32) myfile = open(filename, 'w') myfile.write(data.tostring()) myfile.close() src_path = os.path.abspath(os.path.join(dirname, 'snippet')) if not os.path.exists(result): os.makedirs(result) shutil.copy(os.path.join(src_path, 'test.basis.hdf5'), os.path.join(result, 'data.basis.hdf5')) shutil.copy(os.path.join(src_path, 'test.templates.hdf5'), os.path.join(result, 'data.templates.hdf5')) shutil.copy(os.path.join(src_path, 'test.clusters.hdf5'), os.path.join(result, 'data.clusters.hdf5')) config_file = os.path.abspath( pkg_resources.resource_filename('circus', 'config.params')) file_params = os.path.abspath(filename.replace('.dat', '.params')) if not os.path.exists(file_params): shutil.copyfile(config_file, file_params) probe_file = os.path.join(src_path, 'test.prb') parser = CircusParser(filename, mapping=probe_file) parser.write('data', 'file_format', 'raw_binary') parser.write('data', 'data_offset', '0') parser.write('data', 'data_dtype', 'float32') parser.write('data', 'sampling_rate', '20000') parser.write('whitening', 'temporal', 'False') parser.write('data', 'mapping', probe_file) parser.write('clustering', 'make_plots', 'png') parser.write('clustering', 'nb_repeats', '3') parser.write('detection', 'N_t', '3') parser.write('clustering', 'smart_search', 'False') parser.write('clustering', 'max_elts', '10000') parser.write('noedits', 'filter_done', 'True') parser.write('clustering', 'extraction', 'median-raw') a, b = os.path.splitext(os.path.basename(filename)) c, d = os.path.splitext(filename) file_out = os.path.join(os.path.abspath(c), a) return filename
help="template identifier", dest='template_id') # parser.add_argument('-s', '--size', choices=['amplitude', 'norm'], help="marker size") parser.add_argument('-c', '--color', choices=['amplitude', 'norm'], help="marker color") parser.add_argument('-n', '--nb-snippets-max', default=20, type=int, help="maximum number of snippets") args = parser.parse_args() # Load parameters. params = CircusParser(args.datafile) _ = params.get_data_file() sampling_rate = params.rate # duration = params.data_file.duration nb_time_steps = params.getint('detection', 'N_t') # Load spike times. results = load_data(params, 'results', extension='') # TODO support other extensions? results_data = dict() for key in results['spiketimes'].keys(): if key[:5] == 'temp_': template_key = key template_id = int(key[5:]) if 'spike_times' not in results_data: results_data['spike_times'] = dict()
def main(argv=None): if argv is None: argv = sys.argv[1:] header = get_colored_header() header += '''Utility to concatenate artefacts/dead times before using stream mode. Code will look for .dead and .trig files, and concatenate them automatically taking care of file offsets ''' parser = argparse.ArgumentParser( description=header, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('datafile', help='data file') # parser.add_argument('-w', '--window', help='text file with artefact window files', # default=None) if len(argv) == 0: parser.print_help() sys.exit() args = parser.parse_args(argv) # if args.window is None: # window_file = None # else: # window_file = os.path.abspath(args.window) filename = os.path.abspath(args.datafile) params = CircusParser(filename) dead_in_ms = params.getboolean('triggers', 'dead_in_ms') trig_in_ms = params.getboolean('triggers', 'trig_in_ms') if os.path.exists(params.logfile): os.remove(params.logfile) _ = init_logging(params.logfile) logger = logging.getLogger(__name__) if params.get('data', 'stream_mode') == 'multi-files': data_file = params.get_data_file(source=True, has_been_created=False) all_times_dead = numpy.zeros((0, 2), dtype=numpy.int64) all_times_trig = numpy.zeros((0, 2), dtype=numpy.int64) for f in data_file._sources: name, ext = os.path.splitext(f.file_name) dead_file = f.file_name.replace(ext, '.dead') trig_file = f.file_name.replace(ext, '.trig') if os.path.exists(dead_file): print_and_log(['Found file %s' % dead_file], 'default', logger) times = get_dead_times(dead_file, data_file.sampling_rate, dead_in_ms) if times.max() > f.duration or times.min() < 0: print_and_log([ 'Dead zones larger than duration for file %s' % f.file_name, '-> Clipping automatically' ], 'error', logger) times = numpy.minimum(times, f.duration) times = numpy.maximum(times, 0) times += f.t_start all_times_dead = numpy.vstack((all_times_dead, times)) if os.path.exists(trig_file): print_and_log(['Found file %s' % trig_file], 'default', logger) times = get_trig_times(trig_file, data_file.sampling_rate, trig_in_ms) if times[:, 1].max() > f.duration or times[:, 1].min() < 0: print_and_log([ 'Triggers larger than duration for file %s' % f.file_name ], 'error', logger) sys.exit(0) times[:, 1] += f.t_start all_times_trig = numpy.vstack((all_times_trig, times)) if len(all_times_dead) > 0: output_file = os.path.join(os.path.dirname(filename), 'dead_zones.txt') print_and_log(['Saving global artefact file in %s' % output_file], 'default', logger) if dead_in_ms: all_times_dead = all_times_dead.astype( numpy.float32) / data_file.sampling_rate numpy.savetxt(output_file, all_times_dead) if len(all_times_trig) > 0: output_file = os.path.join(os.path.dirname(filename), 'triggers.txt') print_and_log(['Saving global artefact file in %s' % output_file], 'default', logger) if trig_in_ms: all_times_trig = all_times_trig.astype( numpy.float32) / data_file.sampling_rate numpy.savetxt(output_file, all_times_trig) elif params.get('data', 'stream_mode') == 'single-file': print_and_log(['Not implemented'], 'error', logger) sys.exit(0) else: print_and_log( ['You should select a valid stream_mode such as multi-files'], 'error', logger) sys.exit(0)
base_filepath = '/home/lisa_ruth/spyking-circus/' \ '2021-06-22T15-51-27human_slices_Slice1_BL.h5' filepath = '/home/lisa_ruth/spyking-circus/2021-06-22T15-51-27human_slices_Slice1_BL/' \ '2021-06-22T15-51-27human_slices_Slice1_BL.clusters.hdf5' file = h5py.File(filepath, 'r') basefile = h5py.File(base_filepath, 'r') sampling_frequency = 1000000 / \ basefile['Data']['Recording_0']['AnalogStream']['Stream_0']['InfoChannel']['Tick'][0] duration_index = basefile['Data']['Recording_0']['AnalogStream']['Stream_0'][ 'ChannelDataTimeStamps'][0][2] duration = duration_index / sampling_frequency print(duration) params = CircusParser(base_filepath) dead_channels = params.get('detection', 'dead_channels') if len(dead_channels) > 1: dead_channels = [int(s) for s in dead_channels[5:-2].split(',')] ids = [ ch[0] for ch in basefile['Data/Recording_0/AnalogStream/Stream_0/InfoChannel'] ] labels = [ ch[4].decode('utf8') for ch in basefile['Data/Recording_0/AnalogStream/Stream_0/InfoChannel'] ] same_len_labels = [ str(label[0]) + '0' + str(label[1]) if len(label) < 3 else label for label in labels
class TestClustering(unittest.TestCase): def setUp(self): self.all_matches = None self.all_templates = None dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'clustering.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'clustering', 1) mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name) self.parser.write('clustering', 'max_elts', '1000') def test_clustering_one_CPU(self): mpi_launch('clustering', self.file_name, 1, 0, 'False') res = get_performance(self.file_name, 'one_CPU') if self.all_templates is None: self.all_templates = res[0] self.all_matches = res[1] def test_clustering_two_CPU(self): mpi_launch('clustering', self.file_name, 2, 0, 'False') res = get_performance(self.file_name, 'two_CPU') if self.all_templates is None: self.all_templates = res[0] self.all_matches = res[1] def test_clustering_pca(self): self.parser.write('clustering', 'extraction', 'median-pca') mpi_launch('clustering', self.file_name, 2, 0, 'False') self.parser.write('clustering', 'extraction', 'median-raw') res = get_performance(self.file_name, 'median-pca') if self.all_templates is None: self.all_templates = res[0] self.all_matches = res[1] def test_clustering_nb_passes(self): self.parser.write('clustering', 'nb_repeats', '1') mpi_launch('clustering', self.file_name, 2, 0, 'False') self.parser.write('clustering', 'nb_repeats', '3') res = get_performance(self.file_name, 'nb_passes') if self.all_templates is None: self.all_templates = res[0] self.all_matches = res[1] def test_clustering_sim_same_elec(self): self.parser.write('clustering', 'sim_same_elec', '5') mpi_launch('clustering', self.file_name, 2, 0, 'False') self.parser.write('clustering', 'sim_same_elec', '3') res = get_performance(self.file_name, 'sim_same_elec') if self.all_templates is None: self.all_templates = res[0] self.all_matches = res[1] def test_clustering_cc_merge(self): self.parser.write('clustering', 'cc_merge', '0.8') mpi_launch('clustering', self.file_name, 2, 0, 'False') self.parser.write('clustering', 'cc_merge', '0.95') res = get_performance(self.file_name, 'cc_merge') if self.all_templates is None: self.all_templates = res[0] self.all_matches = res[1] def test_remove_mixtures(self): self.parser.write('clustering', 'remove_mixtures', 'False') mpi_launch('clustering', self.file_name, 2, 0, 'False') self.parser.write('clustering', 'remove_mixtures', 'True') res = get_performance(self.file_name, 'cc_merge') if self.all_templates is None: self.all_templates = res[0] self.all_matches = res[1]
file_path_sc_base = r'/home/lisa_ruth/spyking-circus/' \ r'2021-02-17T15-15-06FHM3_GS967_BL6_P16_female_400ms_7psi_Slice4_Test1_rdy_4_SC.h5' file_path_sc_result = r'/home/lisa_ruth/spyking-circus/' \ r'2021-02-17T15-15-06FHM3_GS967_BL6_P16_female_400ms_7psi_Slice4_Test1_rdy_4_SC/' \ r'2021-02-17T15-15-06FHM3_GS967_BL6_P16_female_400ms_7psi_Slice4_Test1_rdy_4_SC.clusters.hdf5' base_file = h5py.File(file_path_sc_base, 'r') result_file = h5py.File(file_path_sc_result, 'r') fs = 10000. bf_vt = base_file['scaled'] time = np.arange(0, len(bf_vt[0])/fs, 1/fs) params = CircusParser(file_path_sc_base) embed() spiketimes = retrieve_spiketimes(result_file) labels = ['A5', 'A6', 'B5', 'B6'] figure, axs = plt.subplots(2, 2, figsize=(12, 9)) figure.subplots_adjust(hspace=0.5) axs = axs.flat neo_spiketrains = [] for i, ax in enumerate(axs): spike_indices = spiketimes[i] scatter_time = np.array(time[spike_indices]) neo_spiketrains.append(neo.SpikeTrain(times=scatter_time, units='sec', t_stop=300.0)) scatter_height = np.array(bf_vt[i][spike_indices]) ax.plot(time, bf_vt[i], zorder=1) ax.scatter(scatter_time, scatter_height, color='r', zorder=2)
def main(argv=None): if argv is None: argv = sys.argv[1:] header = get_colored_header() parser = argparse.ArgumentParser( description=header, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('datafile', help='data file') parser.add_argument('-e', '--extension', help='extension to consider for visualization', default='') if len(argv) == 0: parser.print_help() sys.exit() args = parser.parse_args(argv) filename = os.path.abspath(args.datafile) extension = args.extension params = CircusParser(filename) if os.path.exists(params.logfile): os.remove(params.logfile) logger = init_logging(params.logfile) logger = logging.getLogger(__name__) mytest = StrictVersion(phycontrib.__version__) >= StrictVersion("1.0.12") if not mytest: print_and_log( ['You need to update phy-contrib to the latest git version'], 'error', logger) sys.exit(1) data_file = params.get_data_file() data_dtype = data_file.data_dtype if hasattr(data_file, 'data_offset'): data_offset = data_file.data_offset else: data_offset = 0 file_format = data_file.description file_out_suff = params.get('data', 'file_out_suff') if file_format not in supported_by_phy: print_and_log([ "File format %s is not supported by phy. TraceView disabled" % file_format ], 'info', logger) if numpy.iterable(data_file.gain): print_and_log( ['Multiple gains are not supported, using a default value of 1'], 'info', logger) gain = 1 else: if data_file.gain != 1: print_and_log([ "Gain of %g is not supported by phy. Expecting a scaling mismatch" % gain ], 'info', logger) gain = data_file.gain probe = params.probe if extension != '': extension = '-' + extension output_path = params.get('data', 'file_out_suff') + extension + '.GUI' if not os.path.exists(output_path): print_and_log( ['Data should be first exported with the converting method!'], 'error', logger) else: print_and_log(["Launching the phy GUI..."], 'info', logger) gui_params = {} if file_format in supported_by_phy: gui_params['dat_path'] = params.get('data', 'data_file') else: gui_params['dat_path'] = '' gui_params['n_channels_dat'] = params.nb_channels gui_params['n_features_per_channel'] = 5 gui_params['dtype'] = data_dtype gui_params['offset'] = data_offset gui_params['sample_rate'] = params.rate gui_params['hp_filtered'] = True os.chdir(output_path) create_app() controller = TemplateController(**gui_params) gui = controller.create_gui() gui.show() run_app() gui.close() del gui
def main(argv=None): if argv is None: argv = sys.argv[1:] header = get_colored_header() header += '''Utility to launch the phy GUI and visualize the results. [data must be first converted with the converting mode] ''' parser = argparse.ArgumentParser( description=header, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('datafile', help='data file') parser.add_argument('-e', '--extension', help='extension to consider for visualization', default='') if len(argv) == 0: parser.print_help() sys.exit() args = parser.parse_args(argv) filename = os.path.abspath(args.datafile) extension = args.extension params = CircusParser(filename) if os.path.exists(params.logfile): os.remove(params.logfile) logger = init_logging(params.logfile) logger = logging.getLogger(__name__) if extension != '': extension = '-' + extension try: import traitlets except ImportError: print_and_log( ['The package traitlets required by phy is not installed'], 'error', logger) sys.exit(1) try: import click except ImportError: print_and_log(['The package click required by phy is not installed'], 'error', logger) sys.exit(1) try: import joblib except ImportError: print_and_log(['The package joblib required by phy is not installed'], 'error', logger) sys.exit(1) if HAVE_PHYCONTRIB: mytest = StrictVersion( phycontrib.__version__) >= StrictVersion("1.0.12") if not mytest: print_and_log( ['You need to update phy-contrib to the latest git version'], 'error', logger) sys.exit(1) print_and_log([ 'phy-contrib is deprecated, you should upgrade to phy 2.0 and phylib' ], 'info', logger) if HAVE_PHYLIB: try: import colorcet except ImportError: print_and_log( ['The package colorcet required by phy is not installed'], 'error', logger) sys.exit(1) try: import qtconsole except ImportError: print_and_log( ['The package qtconsole required by phy is not installed'], 'error', logger) sys.exit(1) if not test_patch_for_similarities(params, extension): print_and_log( ['You should re-export the data because of a fix in 0.6'], 'error', logger) continue_anyway = query_yes_no( Fore.WHITE + "Continue anyway (results may not be fully correct)?", default=None) if not continue_anyway: sys.exit(1) data_file = params.get_data_file() data_dtype = data_file.data_dtype if data_file.params.has_key('data_offset'): data_offset = data_file.data_offset else: data_offset = 0 file_format = data_file.description file_out_suff = params.get('data', 'file_out_suff') if file_format not in supported_by_phy: print_and_log([ "File format %s is not supported by phy. TraceView disabled" % file_format ], 'info', logger) if numpy.iterable(data_file.gain): print_and_log( ['Multiple gains are not supported, using a default value of 1'], 'info', logger) gain = 1 else: if data_file.gain != 1: print_and_log([ "Gain of %g is not supported by phy. Expecting a scaling mismatch" % data_file.gain ], 'info', logger) gain = data_file.gain probe = params.probe output_path = params.get('data', 'file_out_suff') + extension + '.GUI' if not os.path.exists(output_path): print_and_log( ['Data should be first exported with the converting method!'], 'error', logger) else: print_and_log(["Launching the phy GUI..."], 'info', logger) gui_params = {} if file_format in supported_by_phy: if not params.getboolean('data', 'overwrite'): gui_params['dat_path'] = r"%s" % params.get( 'data', 'data_file_no_overwrite') else: if params.get('data', 'stream_mode') == 'multi-files': data_file = params.get_data_file(source=True, has_been_created=False) gui_params['dat_path'] = [ r"%s" % f for f in data_file.get_file_names() ] else: gui_params['dat_path'] = r"%s" % params.get( 'data', 'data_file') else: gui_params['dat_path'] = 'giverandomname.dat' gui_params['n_channels_dat'] = params.nb_channels gui_params['n_features_per_channel'] = 5 gui_params['dtype'] = data_dtype gui_params['offset'] = data_offset gui_params['sample_rate'] = params.rate gui_params['dir_path'] = output_path gui_params['hp_filtered'] = True os.chdir(output_path) create_app() controller = TemplateController(**gui_params) gui = controller.create_gui() gui.show() run_app() gui.close() del gui
"""Inspect thresholds.""" import argparse import h5py import matplotlib.pyplot as plt import numpy as np import os from circus.shared.parser import CircusParser # Parse arguments. parser = argparse.ArgumentParser(description="Inspect threhsolds.") parser.add_argument('datafile', help="data file") args = parser.parse_args() # Load parameters. params = CircusParser(args.datafile) _ = params.get_data_file() file_out_suff = params.get('data', 'file_out_suff') nb_channels = params.getint('data', 'N_e') # Load spatial matrix. basis_path = "{}.basis.hdf5".format(file_out_suff) if not os.path.isfile(basis_path): raise FileNotFoundError(basis_path) with h5py.File(basis_path, mode='r', libver='earliest') as basis_file: if 'thresholds' not in basis_file: raise RuntimeError("No thresholds found in {}".format(basis_path)) thresholds = basis_file['thresholds'][:] assert thresholds.shape == (nb_channels, ), (thresholds.shape, nb_channels) # Plot thresholds.
from circus.shared.probes import get_nodes_and_edges from circus.shared.files import get_stas # Parse arguments. parser = argparse.ArgumentParser(description="Inspect scalar products.") parser.add_argument('datafile', help="data file") parser.add_argument('-t', '--template', default=0, type=int, help="template index", dest='template_id') args = parser.parse_args() # Load parameters. params = CircusParser(args.datafile) _ = params.get_data_file() nb_electrodes = params.nb_channels sampling_rate = params.rate # Hz duration = params.data_file.duration / sampling_rate # s nb_channels = params.getint('data', 'N_e') nb_time_steps = params.getint('detection', 'N_t') nb_snippets = params.getint('clustering', 'nb_snippets') # Load snippets. clusters_data = load_clusters_data(params, extension='') electrode = clusters_data['electrodes'][args.template_id] local_cluster = clusters_data['local_clusters'][args.template_id] assert electrode.shape == local_cluster.shape, (electrode.shape, local_cluster.shape) times = clusters_data['times'][electrode]
def main(argv=None): if argv is None: argv = sys.argv[1:] parallel_hdf5 = h5py.get_config().mpi user_path = pjoin(os.path.expanduser('~'), 'spyking-circus') tasks_list = None if not os.path.exists(user_path): os.makedirs(user_path) try: import cudamat as cmt cmt.init() HAVE_CUDA = True except Exception: HAVE_CUDA = False all_steps = [ 'whitening', 'clustering', 'fitting', 'gathering', 'extracting', 'filtering', 'converting', 'deconverting', 'benchmarking', 'merging', 'validating', 'thresholding' ] config_file = os.path.abspath(pkg_resources.resource_filename('circus', 'config.params')) header = get_colored_header() header += Fore.GREEN + 'Local CPUs : ' + Fore.CYAN + str(psutil.cpu_count()) + '\n' # header += Fore.GREEN + 'GPU detected : ' + Fore.CYAN + str(HAVE_CUDA) + '\n' header += Fore.GREEN + 'Parallel HDF5 : ' + Fore.CYAN + str(parallel_hdf5) + '\n' do_upgrade = '' if not SHARED_MEMORY: do_upgrade = Fore.WHITE + ' [please consider upgrading MPI]' header += Fore.GREEN + 'Shared memory : ' + Fore.CYAN + str(SHARED_MEMORY) + do_upgrade + '\n' header += '\n' header += Fore.GREEN + "##################################################################" header += Fore.RESET method_help = '''by default, all steps are performed, but a subset x,y can be done. Steps are: - filtering - whitening - clustering - fitting - merging [with or without a GUI for meta merging] - (extra) converting [export results to phy format] - (extra) thresholding [to get MUA activity only] - (extra) deconverting [import results from phy format] - (extra) gathering [force collection of results] - (extra) extracting [get templates from spike times] - (extra) benchmarking [with -o and -t] - (extra) validating [to compare performance with GT neurons]''' parser = argparse.ArgumentParser(description=header, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('datafile', help='data file (or a list of commands if batch mode)') parser.add_argument('-i', '--info', help='list the file formats supported by SpyKING CIRCUS', action='store_true') parser.add_argument('-m', '--method', default='filtering,whitening,clustering,fitting,merging', help=method_help) parser.add_argument('-c', '--cpu', type=int, default=max(1, int(psutil.cpu_count()/2)), help='number of CPU') # parser.add_argument('-g', '--gpu', type=int, default=0, help='number of GPU') parser.add_argument('-H', '--hostfile', help='hostfile for MPI', default=pjoin(user_path, 'circus.hosts')) parser.add_argument('-b', '--batch', help='datafile is a list of commands to launch, in a batch mode', action='store_true') parser.add_argument('-p', '--preview', help='GUI to display the first second filtered with thresholds', action='store_true') parser.add_argument('-r', '--result', help='GUI to display the results on top of raw data', action='store_true') parser.add_argument('-s', '--second', type=int, default=0, help='If preview mode, begining of the preview [in s]') parser.add_argument('-e', '--extension', help='extension to consider for merging, converting and deconverting', default='None') parser.add_argument('-o', '--output', help='output file [for generation of synthetic benchmarks]') parser.add_argument('-t', '--type', help='benchmark type', choices=['fitting', 'clustering', 'synchrony']) if len(argv) == 0: parser.print_help() sys.exit(0) args = parser.parse_args(argv) steps = args.method.split(',') for step in steps: if step not in all_steps: print_error(['The method "%s" is not recognized' % step]) sys.exit(0) # To save some typing later nb_gpu = 0 (nb_cpu, hostfile, batch, preview, result, extension, output, benchmark, info, second) = \ (args.cpu, args.hostfile, args.batch, args.preview, args.result, args.extension, args.output, args.type, args.info, args.second) filename = os.path.abspath(args.datafile) real_file = filename f_next, extens = os.path.splitext(filename) if info: if args.datafile.lower() in __supported_data_files__: filename = 'tmp' if len(__supported_data_files__[args.datafile.lower()].extension) > 0: filename += __supported_data_files__[args.datafile.lower()].extension[0] __supported_data_files__[args.datafile.lower()](filename, {}, is_empty=True)._display_requirements_() else: print_and_log([ '', 'To get info on any particular file format, do:', '>> spyking-circus file_format -i', '' ], 'default') print_and_log(list_all_file_format()) sys.exit(0) if extens == '.params': print_error(['You should launch the code on the data file!']) sys.exit(0) file_params = f_next + '.params' if not os.path.exists(file_params) and not batch: print(Fore.RED + 'The parameter file %s is not present!' % file_params) create_params = query_yes_no(Fore.WHITE + "Do you want SpyKING CIRCUS to create a parameter file?") if create_params: print(Fore.WHITE + "Creating %s" % file_params) print(Fore.WHITE + "Fill it properly before launching the code! (see documentation)") print_info(['Keep in mind that filtering is performed on site, so please', 'be sure to keep a copy of your data elsewhere']) shutil.copyfile(config_file, file_params) sys.exit(0) elif batch: tasks_list = filename if not batch: file_params = f_next + '.params' if not os.path.exists(file_params): print_and_log(["%s does not exist" % file_params], 'error') sys.exit(0) import ConfigParser as configparser parser = configparser.ConfigParser() myfile = open(file_params, 'r') lines = myfile.readlines() myfile.close() myfile = open(file_params, 'w') for l in lines: myfile.write(l.replace('\t', '')) myfile.close() parser.read(file_params) for section in CircusParser.__all_sections__: if parser.has_section(section): for (key, value) in parser.items(section): parser.set(section, key, value.split('#')[0].rstrip()) else: parser.add_section(section) try: use_output_dir = parser.get('data', 'output_dir') != '' except Exception: use_output_dir = False if use_output_dir: path = os.path.abspath(os.path.expanduser(parser.get('data', 'output_dir'))) file_out = os.path.join(path, os.path.basename(f_next)) if not os.path.exists(file_out): os.makedirs(file_out) else: file_out = f_next logfile = file_out + '.log' if os.path.exists(logfile): os.remove(logfile) logger = init_logging(logfile) params = CircusParser(filename) data_file = params.get_data_file(source=True, has_been_created=False) overwrite = params.getboolean('data', 'overwrite') file_format = params.get('data', 'file_format') if overwrite: support_parallel_write = data_file.parallel_write is_writable = data_file.is_writable else: support_parallel_write = __supported_data_files__['raw_binary'].parallel_write is_writable = __supported_data_files__['raw_binary'].is_writable if preview: print_and_log(['Preview mode, showing only seconds [%d-%d] of the recording' % (second, second+1)], 'info', logger) tmp_path_loc = os.path.join(os.path.abspath(params.get('data', 'file_out')), 'tmp') if not os.path.exists(tmp_path_loc): os.makedirs(tmp_path_loc) filename = os.path.join(tmp_path_loc, 'preview.dat') f_next, extens = os.path.splitext(filename) preview_params = f_next + '.params' shutil.copyfile(file_params, preview_params) steps = ['filtering', 'whitening'] chunk_size = int(params.rate) data_file.open() nb_chunks, _ = data_file.analyze(chunk_size) if nb_chunks <= (second + 1): print_and_log(['Recording is too short to display seconds [%d-%d]' % (second, second+1)]) sys.exit(0) local_chunk = data_file.get_snippet(int(second*params.rate), int(1.2*chunk_size)) description = data_file.get_description() data_file.close() new_params = CircusParser(filename, create_folders=False) new_params.write('data', 'chunk_size', '1') new_params.write('data', 'file_format', 'raw_binary') new_params.write('data', 'data_dtype', 'float32') new_params.write('data', 'data_offset', '0') new_params.write('data', 'dtype_offset', '0') new_params.write('data', 'stream_mode', 'None') new_params.write('data', 'overwrite', 'True') new_params.write('triggers', 'ignore_times', 'False') new_params.write('data', 'sampling_rate', str(params.rate)) new_params.write('whitening', 'safety_time', '0') new_params.write('clustering', 'safety_time', '0') new_params.write('whitening', 'chunk_size', '1') new_params.write('data', 'preview_path', params.file_params) new_params.write('data', 'output_dir', '') description['data_dtype'] = 'float32' description['dtype_offset'] = 0 description['data_offset'] = 0 description['gain'] = 1. new_params = CircusParser(filename) data_file_out = new_params.get_data_file(is_empty=True, params=description) support_parallel_write = data_file_out.parallel_write is_writable = data_file_out.is_writable data_file_out.allocate(shape=local_chunk.shape, data_dtype=numpy.float32) data_file_out.open('r+') data_file_out.set_data(0, local_chunk) data_file_out.close() if tasks_list is not None: with open(tasks_list, 'r') as f: for line in f: if len(line) > 0: subprocess.check_call(['spyking-circus'] + line.replace('\n', '').split(" ")) else: print_and_log(['Config file: %s' % (f_next + '.params')], 'debug', logger) print_and_log(['Data file : %s' % filename], 'debug', logger) print(get_colored_header()) print(Fore.GREEN + "File : " + Fore.CYAN + real_file) if preview: print(Fore.GREEN + "Steps : " + Fore.CYAN + "preview mode") elif result: print(Fore.GREEN + "Steps : " + Fore.CYAN + "result mode") else: print(Fore.GREEN + "Steps : " + Fore.CYAN + ", ".join(steps)) # print Fore.GREEN + "GPU detected : ", Fore.CYAN + str(HAVE_CUDA) print(Fore.GREEN + "Number of CPU : " + Fore.CYAN + str(nb_cpu) + "/" + str(psutil.cpu_count())) # if HAVE_CUDA: # print Fore.GREEN + "Number of GPU : ", Fore.CYAN + str(nb_gpu) print(Fore.GREEN + "Parallel HDF5 : " + Fore.CYAN + str(parallel_hdf5)) do_upgrade = '' use_shared_memory = get_shared_memory_flag(params) if not SHARED_MEMORY: do_upgrade = Fore.WHITE + ' [please consider upgrading MPI]' print(Fore.GREEN + "Shared memory : " + Fore.CYAN + str(use_shared_memory) + do_upgrade) print(Fore.GREEN + "Hostfile : " + Fore.CYAN + hostfile) print("") print(Fore.GREEN + "##################################################################") print("") print(Fore.RESET) # Launch the subtasks subtasks = [('filtering', 'mpirun'), ('whitening', 'mpirun'), ('clustering', 'mpirun'), ('fitting', 'mpirun'), ('extracting', 'mpirun'), ('gathering', 'python'), ('converting', 'mpirun'), ('deconverting', 'mpirun'), ('benchmarking', 'mpirun'), ('merging', 'mpirun'), ('validating', 'mpirun'), ('thresholding', 'mpirun')] # if HAVE_CUDA and nb_gpu > 0: # use_gpu = 'True' # else: use_gpu = 'False' time = data_stats(params) / 60.0 if preview: params = new_params if nb_cpu < psutil.cpu_count(): if use_gpu != 'True' and not result: print_and_log(['Using only %d out of %d local CPUs available (-c to change)' % (nb_cpu, psutil.cpu_count())], 'info', logger) if params.getboolean('detection', 'matched-filter') and not params.getboolean('clustering', 'smart_search'): print_and_log(['Smart Search should be activated for matched filtering'], 'info', logger) if time > 30 and not params.getboolean('clustering', 'smart_search'): print_and_log(['Smart Search should be activated for long recordings'], 'info', logger) n_edges = get_averaged_n_edges(params) if n_edges > 100 and not params.getboolean('clustering', 'compress'): print_and_log(['Template compression is highly recommended based on parameters'], 'info', logger) if not result: for subtask, command in subtasks: if subtask in steps: if command == 'python': # Directly call the launcher try: circus.launch(subtask, filename, nb_cpu, nb_gpu, use_gpu) except: print_and_log(['Step "%s" failed!' % subtask], 'error', logger) sys.exit(0) elif command == 'mpirun': # Use mpirun to make the call mpi_args = gather_mpi_arguments(hostfile, params) one_cpu = False if subtask in ['filtering', 'benchmarking'] and not is_writable: if not preview and overwrite: print_and_log(['The file format %s is read only!' % file_format, 'You should set overwite to False, to create a copy of the data.', 'However, note that if you have streams, informations on times', 'will be discarded'], 'info', logger) sys.exit(0) if subtask in ['filtering'] and not support_parallel_write and (args.cpu > 1): print_and_log(['No parallel writes for %s: only 1 node used for %s' %(file_format, subtask)], 'info', logger) nb_tasks = str(1) one_cpu = True else: if subtask != 'fitting': nb_tasks = str(args.cpu) else: # if use_gpu == 'True': # nb_tasks = str(args.gpu) # else: nb_tasks = str(args.cpu) if subtask == 'benchmarking': if (output is None) or (benchmark is None): print_and_log(["To generate synthetic datasets, you must provide output and type"], 'error', logger) sys.exit(0) mpi_args += [ '-np', nb_tasks, 'spyking-circus-subtask', subtask, filename, str(nb_cpu), str(nb_gpu), use_gpu, output, benchmark ] elif subtask in ['merging', 'converting']: mpi_args += [ '-np', nb_tasks, 'spyking-circus-subtask', subtask, filename, str(nb_cpu), str(nb_gpu), use_gpu, extension ] elif subtask in ['deconverting']: nb_tasks = str(1) nb_cpu = 1 mpi_args += [ '-np', nb_tasks, 'spyking-circus-subtask', subtask, filename, str(nb_cpu), str(nb_gpu), use_gpu, extension ] else: mpi_args += [ '-np', nb_tasks, 'spyking-circus-subtask', subtask, filename, str(nb_cpu), str(nb_gpu), use_gpu, str(one_cpu) ] print_and_log(['Launching task %s' % subtask], 'debug', logger) print_and_log(['Command: %s' % str(mpi_args)], 'debug', logger) try: subprocess.check_call(mpi_args) except subprocess.CalledProcessError as e: print_and_log(['Step "%s" failed for reason %s!' % (subtask, e)], 'error', logger) sys.exit(0) if preview or result: from circus.shared import gui import pylab try: from PyQt5.QtWidgets import QApplication except ImportError: from matplotlib.backends import qt_compat use_pyside = qt_compat.QT_API == qt_compat.QT_API_PYSIDE if use_pyside: from PySide.QtGui import QApplication else: from PyQt4.QtGui import QApplication app = QApplication([]) try: pylab.style.use('ggplot') except Exception: pass if preview: print_and_log(['Launching the preview GUI...'], 'debug', logger) mygui = gui.PreviewGUI(new_params) shutil.rmtree(tmp_path_loc) elif result: data_file = params.get_data_file() print_and_log(['Launching the result GUI...'], 'debug', logger) mygui = gui.PreviewGUI(params, show_fit=True) sys.exit(app.exec_())
def main(argv=None): if argv is None: argv = sys.argv[1:] header = get_colored_header() parser = argparse.ArgumentParser( description=header, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('datafile', help='data file') parser.add_argument('-e', '--extension', help='extension to consider for visualization', default='') if len(argv) == 0: parser.print_help() sys.exit() args = parser.parse_args(argv) filename = os.path.abspath(args.datafile) extension = args.extension params = CircusParser(filename) if os.path.exists(params.logfile): os.remove(params.logfile) logger = init_logging(params.logfile) logger = logging.getLogger(__name__) mytest = StrictVersion(phycontrib.__version__) >= StrictVersion("1.0.12") if not mytest: print_and_log( ['You need to update phy-contrib to the latest git version'], 'error', logger) sys.exit(1) if not test_patch_for_similarities(params, extension): print_and_log( ['You should re-export the data because of a fix in 0.6'], 'error', logger) continue_anyway = query_yes_no( Fore.WHITE + "Continue anyway (results may not be fully correct)?", default=None) if not continue_anyway: sys.exit(1) data_file = params.get_data_file() data_dtype = data_file.data_dtype if data_file.params.has_key('data_offset'): data_offset = data_file.data_offset else: data_offset = 0 file_format = data_file.description file_out_suff = params.get('data', 'file_out_suff') if file_format not in supported_by_phy: print_and_log([ "File format %s is not supported by phy. TraceView disabled" % file_format ], 'info', logger) if numpy.iterable(data_file.gain): print_and_log( ['Multiple gains are not supported, using a default value of 1'], 'info', logger) gain = 1 else: if data_file.gain != 1: print_and_log([ "Gain of %g is not supported by phy. Expecting a scaling mismatch" % data_file.gain ], 'info', logger) gain = data_file.gain probe = params.probe if extension != '': extension = '-' + extension output_path = params.get('data', 'file_out_suff') + extension + '.GUI' if not os.path.exists(output_path): print_and_log( ['Data should be first exported with the converting method!'], 'error', logger) else: print_and_log(["Launching the phy GUI..."], 'info', logger) gui_params = {} if file_format in supported_by_phy: if not params.getboolean('data', 'overwrite'): gui_params['dat_path'] = params.get('data', 'data_file_no_overwrite') else: if params.get('data', 'stream_mode') == 'multi-files': data_file = params.get_data_file(source=True, has_been_created=False) gui_params['dat_path'] = ' '.join( data_file.get_file_names()) else: gui_params['dat_path'] = params.get('data', 'data_file') else: gui_params['dat_path'] = 'giverandomname.dat' gui_params['n_channels_dat'] = params.nb_channels gui_params['n_features_per_channel'] = 5 gui_params['dtype'] = data_dtype gui_params['offset'] = data_offset gui_params['sample_rate'] = params.rate gui_params['dir_path'] = output_path gui_params['hp_filtered'] = True f = open(os.path.join(output_path, 'params.py'), 'w') for key, value in gui_params.items(): if key in ['dir_path', 'dat_path', 'dtype']: f.write('%s = "%s"\n' % (key, value)) else: f.write("%s = %s\n" % (key, value)) f.close() os.chdir(output_path) create_app() controller = TemplateController(**gui_params) gui = controller.create_gui() gui.show() run_app() gui.close() del gui
class TestFitting(unittest.TestCase): def setUp(self): self.all_spikes = None self.max_chunk = '100' dirname = os.path.abspath(os.path.join(os.path.dirname(__file__), '.')) self.path = os.path.join(dirname, 'synthetic') if not os.path.exists(self.path): os.makedirs(self.path) self.file_name = os.path.join(self.path, 'fitting.dat') self.source_dataset = get_dataset(self) if not os.path.exists(self.file_name): mpi_launch('benchmarking', self.source_dataset, 2, 0, 'False', self.file_name, 'fitting', 1) mpi_launch('whitening', self.file_name, 2, 0, 'False') self.parser = CircusParser(self.file_name) def test_fitting_one_CPU(self): self.parser.write('fitting', 'max_chunk', self.max_chunk) mpi_launch('fitting', self.file_name, 1, 0, 'False') self.parser.write('fitting', 'max_chunk', 'inf') res = get_performance(self.file_name, 'one_CPU') if self.all_spikes is None: self.all_spikes = res assert numpy.all(self.all_spikes == res) def test_fitting_two_CPUs(self): self.parser.write('fitting', 'max_chunk', self.max_chunk) mpi_launch('fitting', self.file_name, 2, 0, 'False') self.parser.write('fitting', 'max_chunk', 'inf') res = get_performance(self.file_name, 'two_CPU') if self.all_spikes is None: self.all_spikes = res assert numpy.all(self.all_spikes == res) def test_fitting_one_GPU(self): HAVE_CUDA = False try: import cudamat HAVE_CUDA = True except ImportError: pass if HAVE_CUDA: self.parser.write('fitting', 'max_chunk', self.max_chunk) mpi_launch('fitting', self.file_name, 1, 0, 'False') self.parser.write('fitting', 'max_chunk', 'inf') res = get_performance(self.file_name, 'one_GPU') if self.all_spikes is None: self.all_spikes = res assert numpy.all(self.all_spikes == res) def test_fitting_large_chunks(self): self.parser.write('fitting', 'chunk_size', '1') self.parser.write('fitting', 'max_chunk', str(int(self.max_chunk) // 2)) mpi_launch('fitting', self.file_name, 2, 0, 'False') self.parser.write('fitting', 'max_chunk', 'inf') self.parser.write('fitting', 'chunk_size', '0.5') res = get_performance(self.file_name, 'large_chunks') if self.all_spikes is None: self.all_spikes = res assert numpy.all(self.all_spikes == res)