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 _test_integration_subtest(self, spiketrains, spiketrains_y,
indices_pmat, index_proba, expected_sses):
# define parameters
random.seed(1)
kernel_width = 9 * pq.ms
surrogate_dt = 9 * pq.ms
alpha = 0.9
filter_shape = (5, 1)
nr_largest = 3
max_distance = 3
min_neighbors = 3
stretch = 5
n_surr = 20
def _get_rates(_spiketrains):
kernel_sigma = kernel_width / 2. / np.sqrt(3.)
kernel = kernels.RectangularKernel(sigma=kernel_sigma)
rates = [
statistics.instantaneous_rate(st,
kernel=kernel,
sampling_period=1 * pq.ms)
for st in _spiketrains
]
return rates
asset_obj = asset.ASSET(spiketrains,
spiketrains_y,
bin_size=self.bin_size)
# calculate the intersection matrix
imat = asset_obj.intersection_matrix()
# calculate probability matrix analytical
pmat = asset_obj.probability_matrix_analytical(
imat, kernel_width=kernel_width)
# check if pmat is the same when rates are provided
pmat_as_rates = asset_obj.probability_matrix_analytical(
imat,
firing_rates_x=_get_rates(spiketrains),
firing_rates_y=_get_rates(spiketrains_y))
assert_array_almost_equal(pmat, pmat_as_rates)
# calculate probability matrix montecarlo
pmat_montecarlo = asset_obj.probability_matrix_montecarlo(
n_surrogates=n_surr,
imat=imat,
surrogate_dt=surrogate_dt,
surrogate_method='dither_spikes')
# test probability matrices
assert_array_equal(np.where(pmat > alpha), indices_pmat)
assert_array_equal(np.where(pmat_montecarlo > alpha), indices_pmat)
# calculate joint probability matrix
jmat = asset_obj.joint_probability_matrix(pmat,
filter_shape=filter_shape,
n_largest=nr_largest)
# test joint probability matrix
assert_array_equal(np.where(jmat > 0.98), index_proba['high'])
assert_array_equal(np.where(jmat > 0.9), index_proba['medium'])
assert_array_equal(np.where(jmat > 0.8), index_proba['low'])
# test if all other entries are zeros
mask_zeros = np.ones(jmat.shape, bool)
mask_zeros[index_proba['low']] = False
self.assertTrue(np.all(jmat[mask_zeros] == 0))
# calculate mask matrix and cluster matrix
mmat = asset_obj.mask_matrices([pmat, jmat], [alpha, alpha])
cmat = asset_obj.cluster_matrix_entries(mmat,
max_distance=max_distance,
min_neighbors=min_neighbors,
stretch=stretch)
# extract sses and test them
sses = asset_obj.extract_synchronous_events(cmat)
self.assertDictEqual(sses, expected_sses)
def test_intersection_matrix(self):
st1 = neo.SpikeTrain([1, 2, 4] * pq.ms, t_stop=6 * pq.ms)
st2 = neo.SpikeTrain([1, 3, 4] * pq.ms, t_stop=6 * pq.ms)
st3 = neo.SpikeTrain([2, 5] * pq.ms,
t_start=1 * pq.ms,
t_stop=6 * pq.ms)
bin_size = 1 * pq.ms
asset_obj_same_t_start_stop = asset.ASSET([st1, st2],
bin_size=bin_size,
t_stop_i=5 * pq.ms,
t_stop_j=5 * pq.ms)
# Check that the routine works for correct input...
# ...same t_start, t_stop on both time axes
imat_1_2 = asset_obj_same_t_start_stop.intersection_matrix()
trueimat_1_2 = np.array([[0., 0., 0., 0., 0.], [0., 2., 1., 1., 2.],
[0., 1., 1., 0., 1.], [0., 1., 0., 1., 1.],
[0., 2., 1., 1., 2.]])
assert_array_equal(asset_obj_same_t_start_stop.x_edges,
np.arange(6) * pq.ms) # correct bins
assert_array_equal(asset_obj_same_t_start_stop.y_edges,
np.arange(6) * pq.ms) # correct bins
assert_array_equal(imat_1_2, trueimat_1_2) # correct matrix
# ...different t_start, t_stop on the two time axes
asset_obj_different_t_start_stop = asset.ASSET(
[st1, st2],
spiketrains_j=[st + 6 * pq.ms for st in [st1, st2]],
bin_size=bin_size,
t_start_j=6 * pq.ms,
t_stop_i=5 * pq.ms,
t_stop_j=11 * pq.ms)
imat_1_2 = asset_obj_different_t_start_stop.intersection_matrix()
assert_array_equal(asset_obj_different_t_start_stop.x_edges,
np.arange(6) * pq.ms) # correct bins
assert_array_equal(asset_obj_different_t_start_stop.y_edges,
np.arange(6, 12) * pq.ms)
self.assertTrue(np.all(imat_1_2 == trueimat_1_2)) # correct matrix
# test with norm=1
imat_1_2 = asset_obj_same_t_start_stop.intersection_matrix(
normalization='intersection')
trueimat_1_2 = np.array([[0., 0., 0., 0., 0.], [0., 1., 1., 1., 1.],
[0., 1., 1., 0., 1.], [0., 1., 0., 1., 1.],
[0., 1., 1., 1., 1.]])
assert_array_equal(imat_1_2, trueimat_1_2)
# test with norm=2
imat_1_2 = asset_obj_same_t_start_stop.intersection_matrix(
normalization='mean')
sq = np.sqrt(2) / 2.
trueimat_1_2 = np.array([[0., 0., 0., 0., 0.], [0., 1., sq, sq, 1.],
[0., sq, 1., 0., sq], [0., sq, 0., 1., sq],
[0., 1., sq, sq, 1.]])
assert_array_almost_equal(imat_1_2, trueimat_1_2)
# test with norm=3
imat_1_2 = asset_obj_same_t_start_stop.intersection_matrix(
normalization='union')
trueimat_1_2 = np.array([[0., 0., 0., 0., 0.], [0., 1., .5, .5, 1.],
[0., .5, 1., 0., .5], [0., .5, 0., 1., .5],
[0., 1., .5, .5, 1.]])
assert_array_almost_equal(imat_1_2, trueimat_1_2)
# Check that errors are raised correctly...
# ...for partially overlapping time intervals
self.assertRaises(ValueError,
asset.ASSET,
spiketrains_i=[st1, st2],
bin_size=bin_size,
t_start_j=1 * pq.ms)
# ...for different SpikeTrain's t_starts
self.assertRaises(ValueError,
asset.ASSET,
spiketrains_i=[st1, st3],
bin_size=bin_size)
# ...for different SpikeTrain's t_stops
self.assertRaises(ValueError,
asset.ASSET,
spiketrains_i=[st1, st2],
bin_size=bin_size,
t_stop_j=5 * pq.ms)