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)