def test_cad_msip(self):
# collecting cad output
output_msip = cad.cell_assembly_detection(binned_spiketrain=self.msip,
max_lag=self.max_lag)
elements_msip = []
occ_msip = []
lags_msip = []
for out in output_msip:
elements_msip.append(out['neurons'])
occ_msip.append(out['times'])
lags_msip.append(list(out['lags']))
elements_msip = sorted(elements_msip, key=lambda d: len(d))
occ_msip = sorted(occ_msip, key=lambda d: len(d))
lags_msip = sorted(lags_msip, key=lambda d: len(d))
elements_msip = [sorted(e) for e in elements_msip]
# check neurons in the patterns
assert_array_equal(elements_msip, self.elements_msip)
# check the occurrences time of the patters
assert_array_equal(occ_msip[0], self.occ_msip[0])
assert_array_equal(occ_msip[1], self.occ_msip[1])
assert_array_equal(occ_msip[2], self.occ_msip[2])
lags_msip = [sorted(e) for e in lags_msip]
# check the lags
assert_array_equal(lags_msip, self.lags_msip)
def test_cad_msip(self):
# collecting cad output
output_msip = cad.cell_assembly_detection(binned_spiketrain=self.msip,
max_lag=self.max_lag)
for i, out in enumerate(output_msip):
assert_array_equal(out['times'], self.occ_msip[i] * self.bin_size)
assert_array_equal(
sorted(out['lags']) * pq.s, self.lags_msip[i] * self.bin_size)
assert_array_equal(sorted(out['neurons']), self.elements_msip[i])
def test_cad_single_sip(self):
# collecting cad output
output_single = cad.cell_assembly_detection(
binned_spiketrain=self.bin_patt1, max_lag=self.max_lag)
# check neurons in the pattern
assert_array_equal(sorted(output_single[0]['neurons']), self.elements1)
# check the occurrences time of the patter
assert_array_equal(output_single[0]['times'], self.occ1)
# check the lags
assert_array_equal(sorted(output_single[0]['lags']), self.output_lags1)
import matplotlib.pyplot as plt
import elephant.conversion as conv
import elephant.spike_train_generation
import quantities as pq
import numpy as np
import elephant.cell_assembly_detection as cad
np.random.seed(30)
# Generate correlated data and bin it with a binsize of 10ms
sts = elephant.spike_train_generation.cpp(rate=15 * pq.Hz,
A=[0] + [0.95] + [0] * 4 + [0.05],
t_stop=10 * pq.s)
binsize = 10 * pq.ms
spM = conv.BinnedSpikeTrain(sts, binsize=binsize)
# Call of the method
patterns = cad.cell_assembly_detection(spM, maxlag=2)[0]
# plotting
plt.figure()
for neu in patterns['neurons']:
if neu == 0:
plt.plot(patterns['times'] * binsize, [neu] * len(patterns['times']),
'ro',
label='pattern')
else:
plt.plot(patterns['times'] * binsize, [neu] * len(patterns['times']),
'ro')
# Raster plot of the data
for st_idx, st in enumerate(sts):
if st_idx == 0:
plt.plot(st.rescale(pq.ms), [st_idx] * len(st), 'k.', label='spikes')
else:
plt.plot(st.rescale(pq.ms), [st_idx] * len(st), 'k.')