def poisson_step_rate(t_start=0 * s,
t_stop=100 * s,
rate1=5 * Hz,
rate2=10 * Hz,
n_samples=1000,
min_len=1000):
"""
Returns a poisson process with step rate given by `rate1` and `rate2`
"""
# TODO: give different start stop for 2nd spiketrain
minimum = np.inf
sts = []
for i in range(n_samples):
spikes1 = homogeneous_poisson_process(rate1, t_start, t_stop)
s1_start, s1_stop = spikes1.t_start, spikes1.t_stop
spikes2 = homogeneous_poisson_process(rate2,
t_start=spikes1[-1],
t_stop=2 * s1_stop,
as_array=True)
s_concat = np.concatenate((spikes1.magnitude, spikes2))
sts.append(s_concat)
if len(s_concat) < minimum:
minimum = len(s_concat)
sts = np.array([st[:minimum] for st in sts])
return sts
def test_low_rates(self):
spiketrain = stgen.homogeneous_poisson_process(0 * Hz,
t_stop=1000 * ms)
self.assertEqual(spiketrain.size, 0)
# not really a test, just making sure that all code paths are covered
for i in range(10):
spiketrain = stgen.homogeneous_poisson_process(1 * Hz,
t_stop=1000 * ms)
def test_spike_contrast_trace(self):
np.random.seed(15)
spike_train_1 = stgen.homogeneous_poisson_process(rate=20 * Hz,
t_stop=1000. * ms)
spike_train_2 = stgen.homogeneous_poisson_process(rate=20 * Hz,
t_stop=1000. * ms)
synchrony, trace = spc.spike_contrast([spike_train_1, spike_train_2],
return_trace=True)
self.assertEqual(synchrony, max(trace.synchrony))
self.assertEqual(len(trace.contrast), len(trace.active_spiketrains))
self.assertEqual(len(trace.active_spiketrains), len(trace.synchrony))
def test_zero_refractory_period(self):
rate = 10 * pq.Hz
t_stop = 20 * pq.s
np.random.seed(27)
sp1 = stgen.homogeneous_poisson_process(rate, t_stop=t_stop,
as_array=True)
np.random.seed(27)
sp2 = stgen.homogeneous_poisson_process(rate, t_stop=t_stop,
refractory_period=0 * pq.ms,
as_array=True)
assert_array_almost_equal(sp1, sp2)
def test_spike_contrast_non_overlapping_spiketrains(self):
np.random.seed(15)
spike_train_1 = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_start=0. * ms,
t_stop=10000. * ms)
spike_train_2 = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_start=5000. * ms,
t_stop=10000. * ms)
spiketrains = [spike_train_1, spike_train_2]
synchrony = spike_contrast(spiketrains, t_stop=5000 * ms)
# the synchrony of non-overlapping spiketrains must be zero
self.assertEqual(synchrony, 0.)
def test_low_rates(self):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
"""
Catch RuntimeWarning: divide by zero encountered in true_divide
mean_interval = 1 / rate.magnitude, when rate == 0 Hz.
"""
spiketrain = stgen.homogeneous_poisson_process(0 * Hz,
t_stop=1000 * ms)
self.assertEqual(spiketrain.size, 0)
# not really a test, just making sure that all code paths are covered
spiketrain = stgen.homogeneous_poisson_process(1 * Hz,
t_stop=1000 * ms)
def setUp(self):
self.st00 = SpikeTrain([], units='ms', t_stop=1000.0)
self.st01 = SpikeTrain([1], units='ms', t_stop=1000.0)
self.st02 = SpikeTrain([2], units='ms', t_stop=1000.0)
self.st03 = SpikeTrain([2.9], units='ms', t_stop=1000.0)
self.st04 = SpikeTrain([3.1], units='ms', t_stop=1000.0)
self.st05 = SpikeTrain([5], units='ms', t_stop=1000.0)
self.st06 = SpikeTrain([500], units='ms', t_stop=1000.0)
self.st07 = SpikeTrain([12, 32], units='ms', t_stop=1000.0)
self.st08 = SpikeTrain([32, 52], units='ms', t_stop=1000.0)
self.st09 = SpikeTrain([42], units='ms', t_stop=1000.0)
self.st10 = SpikeTrain([18, 60], units='ms', t_stop=1000.0)
self.st11 = SpikeTrain([10, 20, 30, 40], units='ms', t_stop=1000.0)
self.st12 = SpikeTrain([40, 30, 20, 10], units='ms', t_stop=1000.0)
self.st13 = SpikeTrain([15, 25, 35, 45], units='ms', t_stop=1000.0)
self.st14 = SpikeTrain([10, 20, 30, 40, 50], units='ms', t_stop=1000.0)
self.st15 = SpikeTrain([0.01, 0.02, 0.03, 0.04, 0.05],
units='s',
t_stop=1000.0)
self.st16 = SpikeTrain([12, 16, 28, 30, 42], units='ms', t_stop=1000.0)
self.st21 = stg.homogeneous_poisson_process(50 * Hz, 0 * ms, 1000 * ms)
self.st22 = stg.homogeneous_poisson_process(40 * Hz, 0 * ms, 1000 * ms)
self.st23 = stg.homogeneous_poisson_process(30 * Hz, 0 * ms, 1000 * ms)
self.rd_st_list = [self.st21, self.st22, self.st23]
self.st31 = SpikeTrain([12.0], units='ms', t_stop=1000.0)
self.st32 = SpikeTrain([12.0, 12.0], units='ms', t_stop=1000.0)
self.st33 = SpikeTrain([20.0], units='ms', t_stop=1000.0)
self.st34 = SpikeTrain([20.0, 20.0], units='ms', t_stop=1000.0)
self.array1 = np.arange(1, 10)
self.array2 = np.arange(1.2, 10)
self.qarray1 = self.array1 * Hz
self.qarray2 = self.array2 * Hz
self.tau0 = 0.0 * ms
self.q0 = np.inf / ms
self.tau1 = 0.000000001 * ms
self.q1 = 1.0 / self.tau1
self.tau2 = 1.0 * ms
self.q2 = 1.0 / self.tau2
self.tau3 = 10.0 * ms
self.q3 = 1.0 / self.tau3
self.tau4 = 100.0 * ms
self.q4 = 1.0 / self.tau4
self.tau5 = 1000000000.0 * ms
self.q5 = 1.0 / self.tau5
self.tau6 = np.inf * ms
self.q6 = 0.0 / ms
self.tau7 = 0.01 * s
self.q7 = 1.0 / self.tau7
self.t = np.linspace(0, 200, 20000001) * ms
def test_spike_contrast_double_duration(self):
np.random.seed(19)
spike_train_1 = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_start=0. * ms,
t_stop=10000. * ms)
spike_train_2 = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_start=0. * ms,
t_stop=10000. * ms)
spike_train_3 = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_start=0. * ms,
t_stop=10000. * ms)
spike_trains = [spike_train_1, spike_train_2, spike_train_3]
synchrony = spike_contrast(spike_trains, t_stop=20000 * ms)
self.assertEqual(synchrony, 0.5)
def get_default_corrcoef_matrix():
# set random seed explicitly, which is used in homogeneous_poisson_process,
# to avoid using different seeds for creating target and result image
np.random.seed(0)
spike_train_1 = homogeneous_poisson_process(rate=10.0 * Hz,
t_start=0.0 * s,
t_stop=10.0 * s)
spike_train_2 = homogeneous_poisson_process(rate=10.0 * Hz,
t_start=0.0 * s,
t_stop=10.0 * s)
# the binsize of 0.1s is rather large so we might expect non-zero
# cross-correlation
corrcoef_matrix = stcorr.corrcoef(
BinnedSpikeTrain([spike_train_1, spike_train_2], binsize=0.1 * s))
return corrcoef_matrix
def test_spike_contrast_trace(self):
np.random.seed(15)
spike_train_1 = stgen.homogeneous_poisson_process(rate=20 * Hz,
t_stop=1000. * ms)
spike_train_2 = stgen.homogeneous_poisson_process(rate=20 * Hz,
t_stop=1000. * ms)
synchrony, trace = spike_contrast([spike_train_1, spike_train_2],
return_trace=True)
self.assertEqual(synchrony, max(trace.synchrony))
self.assertEqual(len(trace.contrast), len(trace.active_spiketrains))
self.assertEqual(len(trace.active_spiketrains), len(trace.synchrony))
self.assertEqual(len(trace.bin_size), len(trace.synchrony))
self.assertIsInstance(trace.bin_size, pq.Quantity)
self.assertEqual(trace.bin_size[0], 500 * pq.ms)
self.assertAlmostEqual(trace.bin_size[-1], 10.1377798 * pq.ms)
def setUp(self):
self.st00 = SpikeTrain([], units='ms', t_stop=1000.0)
self.st01 = SpikeTrain([1], units='ms', t_stop=1000.0)
self.st02 = SpikeTrain([2], units='ms', t_stop=1000.0)
self.st03 = SpikeTrain([2.9], units='ms', t_stop=1000.0)
self.st04 = SpikeTrain([3.1], units='ms', t_stop=1000.0)
self.st05 = SpikeTrain([5], units='ms', t_stop=1000.0)
self.st06 = SpikeTrain([500], units='ms', t_stop=1000.0)
self.st07 = SpikeTrain([12, 32], units='ms', t_stop=1000.0)
self.st08 = SpikeTrain([32, 52], units='ms', t_stop=1000.0)
self.st09 = SpikeTrain([42], units='ms', t_stop=1000.0)
self.st10 = SpikeTrain([18, 60], units='ms', t_stop=1000.0)
self.st11 = SpikeTrain([10, 20, 30, 40], units='ms', t_stop=1000.0)
self.st12 = SpikeTrain([40, 30, 20, 10], units='ms', t_stop=1000.0)
self.st13 = SpikeTrain([15, 25, 35, 45], units='ms', t_stop=1000.0)
self.st14 = SpikeTrain([10, 20, 30, 40, 50], units='ms', t_stop=1000.0)
self.st15 = SpikeTrain([0.01, 0.02, 0.03, 0.04, 0.05],
units='s', t_stop=1000.0)
self.st16 = SpikeTrain([12, 16, 28, 30, 42], units='ms', t_stop=1000.0)
self.st21 = stg.homogeneous_poisson_process(50*Hz, 0*ms, 1000*ms)
self.st22 = stg.homogeneous_poisson_process(40*Hz, 0*ms, 1000*ms)
self.st23 = stg.homogeneous_poisson_process(30*Hz, 0*ms, 1000*ms)
self.rd_st_list = [self.st21, self.st22, self.st23]
self.st31 = SpikeTrain([12.0], units='ms', t_stop=1000.0)
self.st32 = SpikeTrain([12.0, 12.0], units='ms', t_stop=1000.0)
self.st33 = SpikeTrain([20.0], units='ms', t_stop=1000.0)
self.st34 = SpikeTrain([20.0, 20.0], units='ms', t_stop=1000.0)
self.array1 = np.arange(1, 10)
self.array2 = np.arange(1.2, 10)
self.qarray1 = self.array1 * Hz
self.qarray2 = self.array2 * Hz
self.tau0 = 0.0 * ms
self.q0 = np.inf / ms
self.tau1 = 0.000000001 * ms
self.q1 = 1.0 / self.tau1
self.tau2 = 1.0 * ms
self.q2 = 1.0 / self.tau2
self.tau3 = 10.0 * ms
self.q3 = 1.0 / self.tau3
self.tau4 = 100.0 * ms
self.q4 = 1.0 / self.tau4
self.tau5 = 1000000000.0 * ms
self.q5 = 1.0 / self.tau5
self.tau6 = np.inf * ms
self.q6 = 0.0 / ms
self.tau7 = 0.01 * s
self.q7 = 1.0 / self.tau7
self.t = np.linspace(0, 200, 20000001) * ms
def test_statistics(self):
# This is a statistical test that has a non-zero chance of failure
# during normal operation. Thus, we set the random seed to a value that
# creates a realization passing the test.
np.random.seed(seed=12345)
for rate in [123.0*Hz, 0.123*kHz]:
for t_stop in [2345*ms, 2.345*second]:
spiketrain = stgen.homogeneous_poisson_process(rate, t_stop=t_stop)
intervals = isi(spiketrain)
expected_spike_count = int((rate * t_stop).simplified)
self.assertLess(pdiff(expected_spike_count, spiketrain.size), 0.2) # should fail about 1 time in 1000
expected_mean_isi = (1/rate)
self.assertLess(pdiff(expected_mean_isi, intervals.mean()), 0.2)
expected_first_spike = 0*ms
self.assertLess(spiketrain[0] - expected_first_spike, 7*expected_mean_isi)
expected_last_spike = t_stop
self.assertLess(expected_last_spike - spiketrain[-1], 7*expected_mean_isi)
# Kolmogorov-Smirnov test
D, p = kstest(intervals.rescale(t_stop.units),
"expon",
args=(0, expected_mean_isi.rescale(t_stop.units)), # args are (loc, scale)
alternative='two-sided')
self.assertGreater(p, 0.001)
self.assertLess(D, 0.12)
def hom_poiss(rate):
"""Generate a homogeneous spike train with average frequency given by rate
parameter.
"""
rate = rate * pq.Hz
spike_trains = []
for x in range(400):
curr_train = stg.homogeneous_poisson_process(rate, 0.01 * pq.s,
0.51 * pq.s)
# We have to make sure that there is sufficient space between spikes.
# If there is not, we move the next spike by 0.1ms
spike_trains.append(curr_train)
array_like = np.array([
np.around(np.array(x.times) * 1000, decimals=1) for x in spike_trains
])
for arr_idx in range(array_like.shape[0]):
bad_idc = np.argwhere(np.diff(array_like[arr_idx]) < 0.1).flatten()
bad_idc = bad_idc + 1
while bad_idc.any():
for bad_idx in bad_idc:
array_like[arr_idx][
bad_idx] = array_like[arr_idx][bad_idx] + 0.1
bad_idc = np.argwhere(np.diff(array_like[arr_idx]) < 0.1).flatten()
bad_idc = bad_idc + 1
return array_like
def test_to_spike_trains(self):
np.random.seed(1)
bst1 = cv.BinnedSpikeTrain(
spiketrains=[self.spiketrain_a, self.spiketrain_b],
bin_size=self.bin_size)
spiketrains = [
homogeneous_poisson_process(rate=10 * pq.Hz,
t_start=-1 * pq.s,
t_stop=10 * pq.s)
]
bst2 = cv.BinnedSpikeTrain(spiketrains=spiketrains,
bin_size=300 * pq.ms)
for bst in (bst1, bst2):
for spikes in ("random", "left", "center"):
spiketrains_gen = bst.to_spike_trains(spikes=spikes,
annotate_bins=True)
for st, indices in zip(spiketrains_gen, bst.spike_indices):
# check sorted
self.assertTrue((np.diff(st.magnitude) > 0).all())
assert_array_equal(st.array_annotations['bins'], indices)
self.assertEqual(st.annotations['bin_size'], bst.bin_size)
self.assertEqual(st.t_start, bst.t_start)
self.assertEqual(st.t_stop, bst.t_stop)
bst_same = cv.BinnedSpikeTrain(spiketrains_gen,
bin_size=bst.bin_size)
self.assertEqual(bst_same, bst)
# invalid mode
self.assertRaises(ValueError, bst.to_spike_trains, spikes='right')
def test_compare_with_as_array(self):
rate = 10 * pq.Hz
t_stop = 10 * pq.s
for refractory_period in (None, 3 * pq.ms):
np.random.seed(27)
spiketrain = stgen.homogeneous_poisson_process(
rate=rate, t_stop=t_stop, refractory_period=refractory_period)
self.assertIsInstance(spiketrain, neo.SpikeTrain)
np.random.seed(27)
spiketrain_array = stgen.homogeneous_poisson_process(
rate=rate, t_stop=t_stop, refractory_period=refractory_period,
as_array=True)
# don't check with isinstance: Quantity is a subclass of np.ndarray
self.assertTrue(isinstance(spiketrain_array, np.ndarray))
assert_array_almost_equal(spiketrain.times.magnitude,
spiketrain_array)
def generate_stp(occ, xi, t_stop, delays, rate):
'''
Generate a spatio-temporal-pattern (STP). One pattern consists in a
repeated sequence of spikes with fixed inter spikes intervals (delays).
The starting time of the repetitions of the pattern are randomly generated.
'''
# Generating all the first spikes of the repetitions
s1 = np.arange(0, t_stop.magnitude, t_stop.magnitude / occ)
# Using matrix algebra to add all the delays
s1_matr = (s1 * np.ones([xi - 1, occ])).T
delays_matr = np.ones([occ, 1]) * delays.rescale(
t_stop.units).magnitude.reshape([1, xi - 1])
ss = s1_matr + delays_matr
# Stacking the first and successive spikes
stp = np.hstack((s1.reshape(occ, 1), ss))
# Generating the background noise
noise = [
list(stg.homogeneous_poisson_process(rate, t_stop=t_stop).magnitude)
for i in range(xi)
]
# Transofm in to neo SpikeTrain
stp = [
neo.core.SpikeTrain((sorted(noise[i] + list(t))) * t_stop.units,
t_stop) for i, t in enumerate(stp.T)
]
return stp
def test_probability_matrix_symmetric(self):
np.random.seed(1)
kernel_width = 9 * pq.ms
rate = 50 * pq.Hz
n_spiketrains = 50
spiketrains = []
spiketrains_copy = []
for _ in range(n_spiketrains):
st = homogeneous_poisson_process(rate, t_stop=100 * pq.ms)
spiketrains.append(st)
spiketrains_copy.append(st.copy())
asset_obj = asset.ASSET(spiketrains, bin_size=self.bin_size)
asset_obj_symmetric = asset.ASSET(spiketrains,
spiketrains_j=spiketrains_copy,
bin_size=self.bin_size)
imat = asset_obj.intersection_matrix()
pmat = asset_obj.probability_matrix_analytical(
kernel_width=kernel_width)
imat_symm = asset_obj_symmetric.intersection_matrix()
pmat_symm = asset_obj_symmetric.probability_matrix_analytical(
kernel_width=kernel_width)
assert_array_almost_equal(pmat, pmat_symm)
assert_array_almost_equal(imat, imat_symm)
assert_array_almost_equal(asset_obj.x_edges,
asset_obj_symmetric.x_edges)
assert_array_almost_equal(asset_obj.y_edges,
asset_obj_symmetric.y_edges)
def make_test_spike_map(pos_fields,
box_size,
bin_size,
rate,
n_step=10**6,
step_size=.01):
from elephant.spike_train_generation import homogeneous_poisson_process
from scipy.interpolate import interp1d
def infield(pos, pos_fields, sigma=.1):
dist = np.sqrt(np.sum((pos - pos_fields)**2, axis=1))
if any(dist <= sigma):
return True
else:
return False
t = np.linspace(0, n_step * step_size / 1.5, n_step) # s / max_speed
trajectory = random_walk(box_size, step_size, n_step)
x, y = trajectory.T
st = homogeneous_poisson_process(rate=rate / pq.s,
t_start=0 * pq.s,
t_stop=t[-1] * pq.s).magnitude
spike_pos = np.array([interp1d(t, x)(st), interp1d(t, y)(st)])
spikes = [
times for times, pos in zip(st, spike_pos.T)
if infield(pos, pos_fields)
]
return np.array(x), np.array(y), np.array(t), np.array(spikes)
def test_statistics(self):
# There is a statistical test and has a non-zero chance of failure during normal operation.
# Re-run the test to see if the error persists.
for rate in [123.0*Hz, 0.123*kHz]:
for t_stop in [2345*ms, 2.345*second]:
spiketrain = stgen.homogeneous_poisson_process(rate, t_stop=t_stop)
intervals = isi(spiketrain)
expected_spike_count = int((rate * t_stop).simplified)
self.assertLess(pdiff(expected_spike_count, spiketrain.size), 0.2) # should fail about 1 time in 1000
expected_mean_isi = (1/rate)
self.assertLess(pdiff(expected_mean_isi, intervals.mean()), 0.2)
expected_first_spike = 0*ms
self.assertLess(spiketrain[0] - expected_first_spike, 7*expected_mean_isi)
expected_last_spike = t_stop
self.assertLess(expected_last_spike - spiketrain[-1], 7*expected_mean_isi)
# Kolmogorov-Smirnov test
D, p = kstest(intervals.rescale(t_stop.units),
"expon",
args=(0, expected_mean_isi.rescale(t_stop.units)), # args are (loc, scale)
alternative='two-sided')
self.assertGreater(p, 0.001)
self.assertLess(D, 0.12)
def test_corrcoef_fast_mode(self):
np.random.seed(27)
st = homogeneous_poisson_process(rate=10 * pq.Hz, t_stop=10 * pq.s)
binned_st = conv.BinnedSpikeTrain(st, n_bins=10)
assert_array_almost_equal(
sc.correlation_coefficient(binned_st, fast=False),
sc.correlation_coefficient(binned_st, fast=True))
def test_small_kernel_sigma(self):
# Test that the instantaneous rate is overestimated when
# kernel.sigma << sampling_period and center_kernel is True.
# The setup is set to match the issue 288.
np.random.seed(9)
sampling_period = 200 * pq.ms
sigma = 5 * pq.ms
rate_expected = 10 * pq.Hz
spiketrain = homogeneous_poisson_process(rate_expected,
t_start=0 * pq.s,
t_stop=10 * pq.s)
kernel_types = tuple(
kern_cls for kern_cls in kernels.__dict__.values()
if isinstance(kern_cls, type) and issubclass(
kern_cls, kernels.Kernel) and kern_cls is not kernels.Kernel
and kern_cls is not kernels.SymmetricKernel)
for kern_cls, invert in itertools.product(kernel_types, (False, True)):
kernel = kern_cls(sigma=sigma, invert=invert)
with self.subTest(kernel=kernel):
rate = statistics.instantaneous_rate(
spiketrain,
sampling_period=sampling_period,
kernel=kernel,
center_kernel=True)
self.assertGreater(rate.mean(), rate_expected)
def LIF_ASC(we, wi, rateE, rateI):
e_spike_train = np.asarray([
homogeneous_poisson_process(rate=rateE * Hz,
t_start=0.0 * s,
t_stop=1.0 * s,
as_array=True) for i in range(1)
]) #poisson_spike_trains(rate_e, T, 0)
i_spike_train = np.asarray([
homogeneous_poisson_process(rate=rateI * Hz,
t_start=0.0 * s,
t_stop=1.0 * s,
as_array=True) for i in range(1)
]) #poisson_spike_trains(rate_i, T, 0)
e_spike_train[:] = np.round_(e_spike_train[:] / dt)
i_spike_train[:] = np.round_(i_spike_train[:] / dt)
spikes = []
for i in range(1, len(time)):
dI = np.multiply(-1 * k, I[i - 1])
I[i, :] = I[i - 1, :] + dI * dt
dg_e = -g_e[i - 1] / tau_e
g_e[i] = g_e[i - 1] + dg_e * dt
dg_i = -g_i[i - 1] / tau_i
g_i[i] = g_i[i - 1] + dg_i * dt
dV = 1 / C * (np.sum(I[i - 1, :]) - G * (V[i - 1] - e_L) -
(g_e[i - 1] * (V[i - 1])) - (g_i[i - 1] *
(V[i - 1] - e_L)))
V[i] = V[i - 1] + dV * dt
# Check for a spike and update voltage etc.
if V[i] > Theta_Inf + e_L:
I[i, :] = R * I[i - 1, :] + deltaI
V[i] = V_r
spikes.append(i * dt)
# check if time has passed a synapse event time.
if np.isin(i, e_spike_train):
g_e[i] = g_e[i - 1] + we
if np.isin(i, i_spike_train):
g_i[i] = g_i[i - 1] + wi
return np.asarray(spikes)
def test_spike_contrast_same_signal(self):
np.random.seed(21)
spike_train = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_start=0. * ms,
t_stop=10000. * ms)
spike_trains = [spike_train, spike_train]
synchrony = spike_contrast(spike_trains, min_bin=1 * ms)
self.assertEqual(synchrony, 1.0)
def test_nondecrease_spike_times(self):
for refractory_period in (None, 3 * pq.ms):
np.random.seed(27)
spiketrain = stgen.homogeneous_poisson_process(
rate=10 * pq.Hz, t_stop=1000 * pq.s,
refractory_period=refractory_period)
diffs = np.diff(spiketrain.times)
self.assertTrue((diffs >= 0).all())
def test_buffer_overrun(self):
np.random.seed(6085) # this seed should produce a buffer overrun
t_stop=1000*ms
rate = 10*Hz
spiketrain = stgen.homogeneous_poisson_process(rate, t_stop=t_stop)
expected_last_spike = t_stop
expected_mean_isi = (1/rate).rescale(ms)
self.assertLess(expected_last_spike - spiketrain[-1], 4*expected_mean_isi)
def generate_poisson_spike_train(rate, tstop, tstart=0., as_array=True):
from elephant.spike_train_generation import homogeneous_poisson_process
from quantities import ms, Hz
return homogeneous_poisson_process(rate * Hz,
t_start=tstart * ms,
t_stop=tstop * ms,
as_array=as_array)
def test_buffer_overrun(self):
np.random.seed(6085) # this seed should produce a buffer overrun
t_stop=1000*ms
rate = 10*Hz
spiketrain = stgen.homogeneous_poisson_process(rate, t_stop=t_stop)
expected_last_spike = t_stop
expected_mean_isi = (1/rate).rescale(ms)
self.assertLess(expected_last_spike - spiketrain[-1], 4*expected_mean_isi)
def test_joint_isi_dithering_output(self):
spiketrain = stg.homogeneous_poisson_process(
rate=100. * pq.Hz,
refractory_period=3 * pq.ms,
t_stop=0.1 * pq.s)
surrogate_train = surr.JointISI(spiketrain).dithering()[0]
ground_truth = [0.005571, 0.018363, 0.026825, 0.036336, 0.045193,
0.05146, 0.058489, 0.078053]
assert_array_almost_equal(surrogate_train.magnitude, ground_truth)
def test_mean_firing_rate_typical_use_case(self):
np.random.seed(92)
st = homogeneous_poisson_process(rate=100 * pq.Hz, t_stop=100 * pq.s)
rate1 = statistics.mean_firing_rate(st)
rate2 = statistics.mean_firing_rate(st,
t_start=st.t_start,
t_stop=st.t_stop)
self.assertEqual(rate1.units, rate2.units)
self.assertAlmostEqual(rate1.item(), rate2.item())
def setUp(self):
def gen_gamma_spike_train(k, theta, t_max):
x = []
for i in range(int(3 * t_max / (k * theta))):
x.append(np.random.gamma(k, theta))
s = np.cumsum(x)
return s[s < t_max]
def gen_test_data(rates, durs, shapes=(1, 1, 1, 1)):
s = gen_gamma_spike_train(shapes[0], 1. / rates[0], durs[0])
for i in range(1, 4):
s_i = gen_gamma_spike_train(shapes[i], 1. / rates[i], durs[i])
s = np.concatenate([s, s_i + np.sum(durs[:i])])
return s
self.n_iters = 10
self.bin_size = 20 * pq.ms
# generate data1
rates_a = (2, 10, 2, 2)
rates_b = (2, 2, 10, 2)
durs = (2.5, 2.5, 2.5, 2.5)
np.random.seed(0)
n_trials = 100
self.data0 = []
for trial in range(n_trials):
n1 = neo.SpikeTrain(gen_test_data(rates_a, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
n2 = neo.SpikeTrain(gen_test_data(rates_a, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
n3 = neo.SpikeTrain(gen_test_data(rates_b, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
n4 = neo.SpikeTrain(gen_test_data(rates_b, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
n5 = neo.SpikeTrain(gen_test_data(rates_a, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
n6 = neo.SpikeTrain(gen_test_data(rates_a, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
n7 = neo.SpikeTrain(gen_test_data(rates_b, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
n8 = neo.SpikeTrain(gen_test_data(rates_b, durs), units=1 * pq.s,
t_start=0 * pq.s, t_stop=10 * pq.s)
self.data0.append([n1, n2, n3, n4, n5, n6, n7, n8])
self.x_dim = 4
self.data1 = self.data0[:20]
# generate data2
np.random.seed(27)
self.data2 = []
n_trials = 10
n_channels = 20
for trial in range(n_trials):
rates = np.random.randint(low=1, high=100, size=n_channels)
spike_times = [homogeneous_poisson_process(rate=rate * pq.Hz)
for rate in rates]
self.data2.append(spike_times)
def test_joint_isi_dithering_format(self):
rate = 100. * pq.Hz
t_stop = 1. * pq.s
spiketrain = stg.homogeneous_poisson_process(rate, t_stop=t_stop)
n_surrogates = 2
dither = 10 * pq.ms
# Test fast version
joint_isi_instance = surr.JointISI(spiketrain, dither=dither)
surrogate_trains = joint_isi_instance.dithering(
n_surrogates=n_surrogates)
self.assertIsInstance(surrogate_trains, list)
self.assertEqual(len(surrogate_trains), n_surrogates)
self.assertEqual(joint_isi_instance.method, 'fast')
for surrogate_train in surrogate_trains:
self.assertIsInstance(surrogate_train, neo.SpikeTrain)
self.assertEqual(surrogate_train.units, spiketrain.units)
self.assertEqual(surrogate_train.t_start, spiketrain.t_start)
self.assertEqual(surrogate_train.t_stop, spiketrain.t_stop)
self.assertEqual(len(surrogate_train), len(spiketrain))
# Test window_version
joint_isi_instance = surr.JointISI(spiketrain,
method='window',
dither=2 * dither,
num_bins=50)
surrogate_trains = joint_isi_instance.dithering(
n_surrogates=n_surrogates)
self.assertIsInstance(surrogate_trains, list)
self.assertEqual(len(surrogate_trains), n_surrogates)
self.assertEqual(joint_isi_instance.method, 'window')
for surrogate_train in surrogate_trains:
self.assertIsInstance(surrogate_train, neo.SpikeTrain)
self.assertEqual(surrogate_train.units, spiketrain.units)
self.assertEqual(surrogate_train.t_start, spiketrain.t_start)
self.assertEqual(surrogate_train.t_stop, spiketrain.t_stop)
self.assertEqual(len(surrogate_train), len(spiketrain))
# Test surrogate methods wrapper
surrogate_trains = surr.surrogates(spiketrain,
n=n_surrogates,
surr_method='joint_isi_dithering')
self.assertIsInstance(surrogate_trains, list)
self.assertEqual(len(surrogate_trains), n_surrogates)
for surrogate_train in surrogate_trains:
self.assertIsInstance(surrogate_train, neo.SpikeTrain)
self.assertEqual(surrogate_train.units, spiketrain.units)
self.assertEqual(surrogate_train.t_start, spiketrain.t_start)
self.assertEqual(surrogate_train.t_stop, spiketrain.t_stop)
self.assertEqual(len(surrogate_train), len(spiketrain))
def test_t_start_and_t_stop(self):
rate = 10 * pq.Hz
t_start = 17 * pq.ms
t_stop = 2 * pq.s
for refractory_period in (None, 3 * pq.ms):
spiketrain = stgen.homogeneous_poisson_process(
rate=rate, t_start=t_start, t_stop=t_stop,
refractory_period=refractory_period)
self.assertEqual(spiketrain.t_start, t_start)
self.assertEqual(spiketrain.t_stop, t_stop)
def test_t_start_agnostic(self):
np.random.seed(15)
t_stop = 10 * second
spike_train_1 = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_stop=t_stop)
spike_train_2 = stgen.homogeneous_poisson_process(rate=10 * Hz,
t_stop=t_stop)
spiketrains = [spike_train_1, spike_train_2]
synchrony_target = spike_contrast(spiketrains)
# a check for developer: test meaningful result
assert synchrony_target > 0
t_shift = 20 * second
spiketrains_shifted = [
neo.SpikeTrain(st.times + t_shift,
t_start=t_shift,
t_stop=t_stop + t_shift) for st in spiketrains
]
synchrony = spike_contrast(spiketrains_shifted)
self.assertAlmostEqual(synchrony, synchrony_target)
def test_low_rates(self):
spiketrain = stgen.homogeneous_poisson_process(0*Hz, t_stop=1000*ms)
self.assertEqual(spiketrain.size, 0)
# not really a test, just making sure that all code paths are covered
for i in range(10):
spiketrain = stgen.homogeneous_poisson_process(1*Hz, t_stop=1000*ms)