def gen_single_trial(interval_length, rates): """ Generates a single spike train with intervals of length `interval_length` and the firing rates given in `rates`. """ return stools.st_concatenate([stg.gen_homogeneous_poisson( rate, t_start=i * interval_length, t_stop=(i + 1) * interval_length) for i, rate in enumerate(rates)])
def gen_trains(rates, length, num_per_rate): logger.info("Generating spike trains") trains_by_rate = [] for rate in rates: trains_by_rate.append([stg.gen_homogeneous_poisson( rate, t_stop=length) for i in xrange(num_per_rate)]) return tuple(trains_by_rate)
def __init__(self, spike_count_range, train_count_range, firing_rate=50 * pq.Hz): self.spike_count_range = spike_count_range self.train_count_range = train_count_range self.num_trains_per_spike_count = sp.amax(train_count_range) self.trains = [ [ stg.gen_homogeneous_poisson(firing_rate, max_spikes=num_spikes) for i in xrange(self.num_trains_per_spike_count) ] for num_spikes in spike_count_range ]
def gen_single_trial(interval_lengths, rates): """ Generates a single spike train with intervals of length `interval_lengths` and the firing rates given in `rates`. """ boundaries = sp.ones(len(interval_lengths) + 1) * pq.s boundaries[1:] = [l.rescale(boundaries.units) for l in interval_lengths] rates = rates[sp.nonzero(boundaries[1:])] boundaries = boundaries[sp.nonzero(boundaries)] boundaries[0] = 0.0 * pq.s boundaries = sp.cumsum(boundaries) return stools.st_concatenate([stg.gen_homogeneous_poisson( rate, t_start=boundaries[i], t_stop=boundaries[i + 1]) for i, rate in enumerate(rates)])
def generate_spike_trains(n_observations, n_cells, rate, tstop): sutils_units = {} pymuvr_observations = [] for unit in range(n_cells): sutils_units[unit] = [] for ob in range(n_observations): sutils_units[unit].append(stg.gen_homogeneous_poisson(rate * pq.Hz, t_stop=tstop * pq.s)) # observation 1 is identical to observation 0 for all the cells. for unit in range(n_cells): sutils_units[unit][1] = sutils_units[unit][0] for ob in range(n_observations): pymuvr_observations.append([]) for unit in range(n_cells): pymuvr_observations[ob].append(sutils_units[unit][ob].tolist()) return sutils_units, pymuvr_observations
def generate_spike_trains(n_observations, n_cells, rate, tstop): sutils_units = {} pymuvr_observations = [] for unit in range(n_cells): sutils_units[unit] = [] for ob in range(n_observations): sutils_units[unit].append( stg.gen_homogeneous_poisson(rate * pq.Hz, t_stop=tstop * pq.s)) # observation 1 is identical to observation 0 for all the cells. for unit in range(n_cells): sutils_units[unit][1] = sutils_units[unit][0] for ob in range(n_observations): pymuvr_observations.append([]) for unit in range(n_cells): pymuvr_observations[ob].append(sutils_units[unit][ob].tolist()) return sutils_units, pymuvr_observations
def setUp(self): self.n_observations = 10 self.n_cells = 20 self.rate = 30 self.tstop = 2 self.cos = np.linspace(0, 1, 5) self.tau = np.linspace(0.006, 0.018, 3) self.sutils_units = {} self.pymuvr_observations = [] for unit in range(self.n_cells): self.sutils_units[unit] = [] for ob in range(self.n_observations): self.sutils_units[unit].append(stg.gen_homogeneous_poisson(self.rate * pq.Hz, t_stop=self.tstop * pq.s)) # observation 1 is identical to observation 0 for all the cells. for unit in range(self.n_cells): self.sutils_units[unit][1] = self.sutils_units[unit][0] for ob in range(self.n_observations): self.pymuvr_observations.append([]) for unit in range(self.n_cells): self.pymuvr_observations[ob].append(self.sutils_units[unit][ob].tolist())
def setUp(self): self.n_observations = 10 self.n_cells = 5 self.rate = 30 self.tstop = 1 self.cos = np.linspace(0, 1, 5) self.tau = np.linspace(0.0001, 0.018, 3) self.sutils_units = {} self.pymuvr_observations = [] for unit in range(self.n_cells): self.sutils_units[unit] = [] for ob in range(self.n_observations): self.sutils_units[unit].append(stg.gen_homogeneous_poisson(self.rate * pq.Hz, t_stop=self.tstop * pq.s)) # observation 1 is identical to observation 0 for all the cells. for unit in range(self.n_cells): self.sutils_units[unit][1] = self.sutils_units[unit][0] for ob in range(self.n_observations): self.pymuvr_observations.append([]) for unit in range(self.n_cells): self.pymuvr_observations[ob].append(self.sutils_units[unit][ob].tolist())
def invoke_gen_func(self, rate, **kwargs): return stg.gen_homogeneous_poisson(rate, **kwargs)
"the -d option.") parser.add_argument( '--output', '-o', type=str, nargs=1, help="Output file for the profiling information.") args = parser.parse_args() if args.list_metrics: print_available_metrics() sys.exit(0) try: with open(args.data[0], 'r') as f: trains = pickle.load(f) print "Loaded stored trains." except: trains = [stg.gen_homogeneous_poisson(50.0 * pq.Hz, t_stop=4.0 * pq.s) for i in xrange(6)] if args.data is not None: with open(args.data[0], 'w') as f: pickle.dump(trains, f) print "Stored trains." if args.output is None: dummy, out_file = tempfile.mkstemp() else: out_file = args.output[0] cProfile.run('profile_metrics(trains, args.metrics)', out_file) print_summary(out_file) if args.output is None: