def test_compound_crossspec(self):
# use less neurons (0.2*self.N) for full matrix (memory error!)
Nloc = int(0.2 * self.N)
Nloceff = int(0.2 * self.Neff)
# population a
sp_a = cthlp.create_poisson_spiketrains(self.rate, self.T, Nloceff)
sp_a_ids, sp_a_srt = cthlp.sort_gdf_by_id(sp_a, 0, Nloc)
bins_a, bsp_a = cthlp.instantaneous_spike_count(
sp_a_srt, self.tbin, tmin=0., tmax=self.T)
bsp_a = cthlp.centralize(bsp_a, time=True)
# population b
sp_b = cthlp.create_poisson_spiketrains(self.rate, self.T, Nloceff)
sp_b_ids, sp_b_srt = cthlp.sort_gdf_by_id(sp_b, 0, Nloc)
bins_b, bsp_b = cthlp.instantaneous_spike_count(
sp_b_srt, self.tbin, tmin=0., tmax=self.T)
bsp_b = cthlp.centralize(bsp_b, time=True)
freq_a, power_a = ctana.compound_powerspec(bsp_a, self.tbin)
freq_b, power_b = ctana.compound_powerspec(bsp_b, self.tbin)
freq_cross, cross = ctana.compound_crossspec([bsp_a, bsp_b], self.tbin)
self.assertTrue(abs(np.sum(power_a - cross[0, 0])) < 1e-10)
self.assertTrue(abs(np.sum(power_b - cross[1, 1])) < 1e-10)
freq_cross_alt, cross_alt = ctana.crossspec(
np.array([np.sum(bsp_a, axis=0), np.sum(bsp_b, axis=0)]),
self.tbin)
self.assertTrue(abs(np.sum(cross_alt[0, 1] - cross[0, 1])) < 1e-12)
self.assertTrue(abs(np.sum(cross_alt[1, 0] - cross[1, 0])) < 1e-12)
def test_crossspec(self):
# use less neurons (0.2*self.N) for full matrix (memory error!)
Nloc = int(0.2 * self.N)
Nloceff = int(0.2 * self.Neff)
sp = cthlp.create_poisson_spiketrains(self.rate, self.T, Nloceff)
sp_ids, sp_srt = cthlp.sort_gdf_by_id(sp, 0, Nloc)
bins, bsp = cthlp.instantaneous_spike_count(sp_srt, self.tbin)
bsp = cthlp.centralize(bsp, time=True)
freq_power, power = ctana.powerspec(bsp, self.tbin)
freq_cross, cross = ctana.crossspec(bsp, self.tbin)
self.assertEqual(len(freq_power), len(freq_cross))
self.assertEqual(np.min(freq_power), np.min(freq_cross))
self.assertEqual(np.max(freq_power), np.max(freq_cross))
for i in xrange(Nloc):
for j in xrange(Nloc):
if i != j:
# poisson trains are uncorrelated
self.assertTrue(abs(np.mean(cross[i, j])) < 1e0)
else:
# compare with auto spectra
self.assertTrue(
abs(np.mean(cross[i, i] - power[i])) < 1e-12)
sp = cthlp.create_poisson_spiketrains(self.rate, self.T, self.N)
sp_ids, sp_srt = cthlp.sort_gdf_by_id(sp)
bins, bsp = cthlp.instantaneous_spike_count(sp_srt, self.tbin)
bsp = cthlp.centralize(bsp, time=True)
freq_cross, cross = ctana.crossspec(bsp, self.tbin, units=True)
self.assertTrue(abs(np.mean(cross)) < 1e-2)
freq_cross, cross = ctana.crossspec(
bsp, self.tbin, Df=self.Df, units=True)
self.assertTrue(self.Df <= freq_cross[1])
def test_centralize(self):
v1 = np.random.normal(-50, 2, int(self.T * 1e1))
v2 = np.random.normal(-30, 2, int(self.T * 1e1))
v_cen_time = cthlp.centralize([v1, v2], time=True)
for v in v_cen_time:
self.assertTrue(abs(np.mean(v)) < 1e-12)
v_cen_units = cthlp.centralize([v1, v2], units=True)
for v in v_cen_units.T:
self.assertTrue(abs(np.mean(v)) < 1e-12)
v_cen_timeunits = cthlp.centralize([v1, v2], time=True, units=True)
self.assertTrue(abs(np.mean(v_cen_timeunits)) < 1e-12)
def test_compound_powerspec(self):
sp = cthlp.create_poisson_spiketrains(self.rate, self.T, self.Neff)
sp_ids, sp_srt = cthlp.sort_gdf_by_id(sp, 0, self.N)
bins, bsp = cthlp.instantaneous_spike_count(sp_srt, self.tbin)
bsp = cthlp.centralize(bsp, time=True)
freq_alt, power_alt = ctana.powerspec(
[np.sum(bsp, axis=0)], self.tbin, Df=self.Df)
freq, power = ctana.compound_powerspec(bsp, self.tbin, Df=self.Df)
self.assertEqual(len(freq_alt), len(freq)) # frequencies
self.assertEqual(len(power_alt[0]), len(power)) # same number of bins
# same spectra
self.assertTrue(abs(np.sum(power_alt[0] - power)) < 1e-16)
def test_powerspec(self):
sp = cthlp.create_poisson_spiketrains(self.rate, self.T, self.Neff)
sp_ids, sp_srt = cthlp.sort_gdf_by_id(sp, 0, self.N)
bins, bsp = cthlp.instantaneous_spike_count(sp_srt, self.tbin)
freq, power = ctana.powerspec(bsp, self.tbin)
for i in range(self.N):
# power(0) == 1./T*integral(s(t))**2 == 1./T*sum(s_binned)**2
self.assertTrue(
abs(power[i][0] - 1. / self.T * 1e3 *
(np.sum(bsp[i]))**2) < 1e-15)
bsp = cthlp.centralize(bsp, time=True)
freq, power = ctana.powerspec(bsp, self.tbin)
for i in range(self.N):
# power(0) == 0
self.assertTrue(abs(power[i][0]) < 1e-15)
auto = np.array([np.fft.ifft(x) for x in power])
for i in range(self.N):
if np.sum(power[i]) > 0.:
# power == rate (flat spectrum for poisson with power == rate)
self.assertTrue(
abs(np.mean(power[i]) - self.rate) < self.rate * 2e-1)
# auto(t) = rate*delta(t)-(offset due to centralizing)
self.assertTrue(abs(auto[i][0] - self.rate) < self.rate * 2e-1)
# integral(auto(t)) == 0 (due to centralizing, delta is
# canceled by offset)
self.assertTrue(abs(np.sum(auto[i])) < 1e-11)
freq, power = ctana.powerspec(bsp, self.tbin, Df=self.Df)
# smallest frequency is larger than size of smoothing window
self.assertTrue(self.Df <= freq[1])
freq_units, power_units = ctana.powerspec(bsp,
self.tbin,
Df=self.Df,
units=True)
# power_units should equal population averaged power spectrum
self.assertTrue(
abs(np.sum(power_units - np.mean(power, axis=0))) < 1e-10)
rate_time_series['Parameters'] = json.load(f)
tmin, tmax = (500., T)
imax = int(tmax - rate_time_series['Parameters']['t_min'])
imin = int(tmin - rate_time_series['Parameters']['t_min'])
# Order of vector auto-regressive model
# As potentially Granger-causal populations, we only consider source
# population with an indegree > 1
mask = create_mask(M.structure, target_pops=[pop], target_areas=[area], external=False)[:, :-1]
pairs = indices_to_population(M.structure, np.where(K[mask] > 1.))
# Build a list of the time series of all source pairs onto the target pair
all_rates = [ch.centralize(rate_time_series[area][pop][imin:imax], units=True)]
target_index = 0
source_pairs = [target_pair]
for pair in pairs:
source_area = pair.split('-')[0]
source_pop = pair.split('-')[1]
if (source_area, source_pop) != target_pair:
all_rates.append(ch.centralize(rate_time_series[source_area][source_pop][imin:imax],
units=True))
source_pairs.append((source_area, source_pop))
# Fit VAR with all rates
dat = np.vstack(all_rates)
dat = dat.transpose()
model = VAR(dat)
# Order of auto-regressive regression model
imax = int(tmax - rate_time_series['Parameters']['t_min'])
imin = int(tmin - rate_time_series['Parameters']['t_min'])
# Order of vector auto-regressive model
# As potentially Granger-causal populations, we only consider source
# population with an indegree > 1
mask = create_mask(M.structure,
target_pops=[pop],
target_areas=[area],
external=False)[:, :-1]
pairs = indices_to_population(M.structure, np.where(K[mask] > 1.))
# Build a list of the time series of all source pairs onto the target pair
all_rates = [
ch.centralize(rate_time_series[area][pop][imin:imax], units=True)
]
target_index = 0
source_pairs = [target_pair]
for pair in pairs:
source_area = pair.split('-')[0]
source_pop = pair.split('-')[1]
if (source_area, source_pop) != target_pair:
all_rates.append(
ch.centralize(
rate_time_series[source_area][source_pop][imin:imax],
units=True))
source_pairs.append((source_area, source_pop))
# Fit VAR with all rates
dat = np.vstack(all_rates)
fn2 = os.path.join(load_path,
'rate_time_series_full_{}.npy'.format(area2))
rate_time_series2 = np.load(fn2)
fn = os.path.join(load_path,
'rate_time_series_full_Parameters.json')
with open(fn, 'r') as f:
params = json.load(f)
i_min = int(500. - params['t_min'])
i_max = int(T - params['t_min'])
rates = [rate_time_series1[i_min:i_max],
rate_time_series2[i_min:i_max]]
dat = [ch.centralize(rates[0], units=True),
ch.centralize(rates[1], units=True)]
freq, crossspec = corr.crossspec(dat, 1.)
t, cross = corr.crosscorrfunc(freq, crossspec)
sigma = 2.
time_range = np.arange(-5., 5.)
kernel = 1 / (np.sqrt(2.0 * np.pi) * sigma) * np.exp(-(time_range ** 2 / (2 * sigma ** 2)))
cross_conv = np.zeros_like(cross)
cross_conv[0][0] = np.convolve(kernel, cross[0][0], mode='same')
cross_conv[0][1] = np.convolve(kernel, cross[0][1], mode='same')
cross_conv[1][0] = np.convolve(kernel, cross[1][0], mode='same')
cross_conv[1][1] = np.convolve(kernel, cross[1][1], mode='same')
cross = cross_conv
fp = '_'.join(('cross_correlation',
Compute the functional connectivity between all areas of a given
simulation based on their time series of spiking rates or their
estimated BOLD signal.
"""
data_path = sys.argv[1]
label = sys.argv[2]
method = sys.argv[3]
load_path = os.path.join(data_path, label, 'Analysis', method)
save_path = os.path.join(data_path, label, 'Analysis')
"""
Create MultiAreaModel instance to have access to data structures
"""
M = MultiAreaModel({})
time_series = []
for area in M.area_list:
fn = os.path.join(load_path, '{}_{}.npy'.format(method, area))
si = np.load(fn)
if method == 'bold_signal': # Cut off the long initial transient of the BOLD signal
si = si[5000:]
time_series.append(ch.centralize(si, units=True))
D = pdist(time_series, metric='correlation')
correlation_matrix = 1. - squareform(D)
np.save(
os.path.join(save_path, 'functional_connectivity_{}.npy'.format(method)),
correlation_matrix)