def compute_spikes_covariance(self,
binned_spikes_trains,
binsize=None,
num_bins=None,
**kwargs):
"""A method to compute the covariances
among the spikes' trains of a set of elephant.conversion.BinnedSpikeTrain,
using the lephant.spike_train_correlation.covariance method.
- binned_spikes_trains: an elephant.conversion.BinnedSpikeTrain instance, or a
sequence (array, list, tuple) of Spikes Trains or of spikes' times arrays
- binsize: the size (float, in ms) of the bin to be used. Default=None.
- num_bins: the number (integer > 0) of bins to be used. Default=None.
If none of binsize or num_bins if given, a bin size equal to the sampling period is used.
Returns:
- a dictionary of the following key-value pair(s):
"covariance": correlation_coefficient array
"binned_spikes_trains": the elephant.conversion.BinnedSpikeTrain instance used for the computation
"""
binned_spikes_trains = self._assert_binned_spikes_trains(
binned_spikes_trains, binsize, num_bins)
from elephant.spike_train_correlation import covariance
return {
self._get_comput_res_type(): covariance(binned_spikes_trains,
**kwargs),
self.binned_spikes_trains_name: binned_spikes_trains
}
def test_covariance_binned(self):
'''
Test covariance between two binned spike trains.
'''
# Calculate clipped and unclipped
res_clipped = sc.covariance(
self.binned_st, binary=True)
res_unclipped = sc.covariance(
self.binned_st, binary=False)
# Check dimensions
self.assertEqual(len(res_clipped), 2)
self.assertEqual(len(res_unclipped), 2)
# Check result unclipped against result calculated from scratch for
# the off-diagonal element
mat = self.binned_st.to_array()
mean_0 = np.mean(mat[0])
mean_1 = np.mean(mat[1])
target_from_scratch = \
np.dot(mat[0] - mean_0, mat[1] - mean_1) / (len(mat[0]) - 1)
# Check result unclipped against result calculated by numpy.corrcoef
target_numpy = np.cov(mat)
self.assertAlmostEqual(target_from_scratch, target_numpy[0][1])
self.assertAlmostEqual(res_unclipped[0][1], target_from_scratch)
self.assertAlmostEqual(res_unclipped[1][0], target_from_scratch)
# Check result clipped against result calculated from scratch for
# the off-diagonal elemant
mat = self.binned_st.to_bool_array()
mean_0 = np.mean(mat[0])
mean_1 = np.mean(mat[1])
target_from_scratch = \
np.dot(mat[0] - mean_0, mat[1] - mean_1) / (len(mat[0]) - 1)
# Check result unclipped against result calculated by numpy.corrcoef
target_numpy = np.cov(mat)
self.assertAlmostEqual(target_from_scratch, target_numpy[0][1])
self.assertAlmostEqual(res_clipped[0][1], target_from_scratch)
self.assertAlmostEqual(res_clipped[1][0], target_from_scratch)
def test_covariance_binned(self):
'''
Test covariance between two binned spike trains.
'''
# Calculate clipped and unclipped
res_clipped = sc.covariance(
self.binned_st, binary=True)
res_unclipped = sc.covariance(
self.binned_st, binary=False)
# Check dimensions
self.assertEqual(len(res_clipped), 2)
self.assertEqual(len(res_unclipped), 2)
# Check result unclipped against result calculated from scratch for
# the off-diagonal element
mat = self.binned_st.to_array()
mean_0 = np.mean(mat[0])
mean_1 = np.mean(mat[1])
target_from_scratch = \
np.dot(mat[0] - mean_0, mat[1] - mean_1) / (len(mat[0]) - 1)
# Check result unclipped against result calculated by numpy.corrcoef
target_numpy = np.cov(mat)
self.assertAlmostEqual(target_from_scratch, target_numpy[0][1])
self.assertAlmostEqual(res_unclipped[0][1], target_from_scratch)
self.assertAlmostEqual(res_unclipped[1][0], target_from_scratch)
# Check result clipped against result calculated from scratch for
# the off-diagonal elemant
mat = self.binned_st.to_bool_array()
mean_0 = np.mean(mat[0])
mean_1 = np.mean(mat[1])
target_from_scratch = \
np.dot(mat[0] - mean_0, mat[1] - mean_1) / (len(mat[0]) - 1)
# Check result unclipped against result calculated by numpy.corrcoef
target_numpy = np.cov(mat)
self.assertAlmostEqual(target_from_scratch, target_numpy[0][1])
self.assertAlmostEqual(res_clipped[0][1], target_from_scratch)
self.assertAlmostEqual(res_clipped[1][0], target_from_scratch)
def test_covariance_binned_short_input(self):
'''
Test if input list of only one binned spike train yields correct result
that matches numpy.cov (covariance with itself)
'''
# Calculate correlation
binned_st = conv.BinnedSpikeTrain(self.st_0,
t_start=0 * pq.ms,
t_stop=50. * pq.ms,
binsize=1 * pq.ms)
result = sc.covariance(binned_st, binary=True, fast=False)
# Check result unclipped against result calculated by numpy.corrcoef
mat = binned_st.to_bool_array()
target = np.cov(mat)
# Check result and dimensionality of result
self.assertEqual(result.ndim, target.ndim)
assert_array_almost_equal(result, target)
assert_array_almost_equal(
target, sc.covariance(binned_st, binary=True, fast=True))
def produce_covariances(self,
spiketrain_list=None,
binary=False,
**kwargs):
"""
Calculates the covariances between all pairs of spike trains.
Parameters
----------
spiketrain_list : list of neo.SpikeTrain (default None)
If no list is passed the function tries to access the class
parameter 'spiketrains'.
binary: bool (default False)
Parameter is passed to
elephant.spike_train_correlation.covariance()
kwargs:
Passed to elephant.conversion.BinnedSpikeTrain()
Returns : list of floats
list of covariances of length = (N^2 - N)/2 where N is the number
of spike trains.
-------
"""
try:
def robust_BinnedSpikeTrain(spiketrains,
binsize=2 * ms,
num_bins=None,
t_start=None,
t_stop=None,
**add_args):
return BinnedSpikeTrain(spiketrains,
binsize=binsize,
num_bins=num_bins,
t_start=t_start,
t_stop=t_stop)
if spiketrain_list is None:
# assuming the class has the property 'spiketrains' and it
# contains a list of neo.Spiketrains
binned_sts = robust_BinnedSpikeTrain(self.spiketrains,
**kwargs)
else:
binned_sts = robust_BinnedSpikeTrain(spiketrain_list, **kwargs)
cov_matrix = covariance(binned_sts, binary=binary)
idx = triu_indices(len(cov_matrix), 1)
return cov_matrix[idx]
except:
self.unimplemented()
def test_covariance_binned_same_spiketrains(self):
'''
Test if the covariation between two identical binned spike
trains evaluates to the expected 2x2 matrix.
'''
# Calculate correlation
binned_st = conv.BinnedSpikeTrain(
[self.st_0, self.st_0], t_start=0 * pq.ms, t_stop=50. * pq.ms,
binsize=1 * pq.ms)
target = sc.covariance(binned_st)
# Check dimensions
self.assertEqual(len(target), 2)
# Check result
assert_array_equal(target[0][0], target[1][1])
def test_covariance_binned_same_spiketrains(self):
'''
Test if the covariation between two identical binned spike
trains evaluates to the expected 2x2 matrix.
'''
# Calculate correlation
binned_st = conv.BinnedSpikeTrain(
[self.st_0, self.st_0], t_start=0 * pq.ms, t_stop=50. * pq.ms,
binsize=1 * pq.ms)
target = sc.covariance(binned_st)
# Check dimensions
self.assertEqual(len(target), 2)
# Check result
assert_array_equal(target[0][0], target[1][1])
def test_covariance_binned_short_input(self):
'''
Test if input list of only one binned spike train yields correct result
that matches numpy.cov (covariance with itself)
'''
# Calculate correlation
binned_st = conv.BinnedSpikeTrain(
self.st_0, t_start=0 * pq.ms, t_stop=50. * pq.ms,
binsize=1 * pq.ms)
target = sc.covariance(binned_st)
# Check result unclipped against result calculated by numpy.corrcoef
mat = binned_st.to_bool_array()
target_numpy = np.cov(mat)
# Check result and dimensionality of result
self.assertEqual(target.ndim, target_numpy.ndim)
self.assertAlmostEqual(target, target_numpy)
def test_covariance_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, num_bins=10)
assert_array_almost_equal(sc.covariance(binned_st, fast=False),
sc.covariance(binned_st, fast=True))
