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:
def invoke_gen_func(self, rate, **kwargs):
return stg.gen_homogeneous_poisson(rate, **kwargs)
