def test_external_indegrees():
"""
Test settings for external indegrees.
"""
M0 = create_default_network()
K0 = M0.K_matrix
conn_params = {'fac_nu_ext_5E': 2.,
'fac_nu_ext_6E': 2.}
network_params = {'connection_params': conn_params}
M = MultiAreaModel(network_params)
mask = create_mask(M.structure, target_pops=['5E'], source_pops=[])
assert(np.allclose(M.K_matrix[mask], conn_params['fac_nu_ext_5E'] * K0[mask]))
mask = create_mask(M.structure, target_pops=['6E'], source_pops=[])
assert(np.allclose(M.K_matrix[mask], conn_params['fac_nu_ext_6E'] * K0[mask]))
conn_params = {'fac_nu_ext_TH': 2.}
network_params.update({'connection_params': conn_params})
M = MultiAreaModel(network_params)
mask = create_mask(M.structure,
target_areas=['TH'],
target_pops=['23E', '5E'],
source_pops=[])
assert(np.allclose(M.K_matrix[mask], conn_params['fac_nu_ext_TH'] * K0[mask]))
def test_syn_weights():
"""
Test different options for synaptic weights.
"""
M0 = create_default_network()
W0 = M0.W_matrix
conn_params = {'PSP_e': 0.3,
'PSP_e_23_4': 0.6}
network_params = {'connection_params': conn_params}
M = MultiAreaModel(network_params)
mask = create_mask(M.structure,
source_pops=['23E', '4E', '5E', '6E'],
external=False)
assert(np.allclose(M.W_matrix[mask], conn_params['PSP_e'] / 0.15 * W0[mask]))
conn_params = {'cc_weights_factor': 2.,
'cc_weights_I_factor': 2.}
network_params.update({'connection_params': conn_params})
M = MultiAreaModel(network_params)
mask = create_mask(M.structure,
source_pops=['23E', '5E', '6E'],
target_pops=['23E', '4E', '5E', '6E'],
cortico_cortical=True)
assert(np.allclose(M.W_matrix[mask], conn_params['cc_weights_factor'] * W0[mask]))
mask = create_mask(M.structure,
source_pops=['23E', '5E', '6E'],
target_pops=['23I', '4I', '5I', '6I'],
cortico_cortical=True)
assert(np.allclose(M.W_matrix[mask], conn_params['cc_weights_factor'] *
conn_params['cc_weights_I_factor'] * W0[mask]))
def integrate(f5, M_base):
mask5 = create_mask(M_base.structure,
target_pops=['5E'],
source_areas=[],
external=True)
mask6 = create_mask(M_base.structure,
target_pops=['6E'],
source_areas=[],
external=True)
f6 = 10 / 3. * f5 - 7 / 3.
conn_params = copy.deepcopy(M_base.params['connection_params'])
conn_params.update({'fac_nu_ext_5E': f5, 'fac_nu_ext_6E': f6})
M = copy.deepcopy(M_base)
M.K_matrix[mask5] *= f5
M.K_matrix[mask6] *= f6
p, r = M.theory.integrate_siegert()
return r
def test_average_indegree():
"""
Test different average indegrees.
"""
for av_indegree in [av_indegree_Cragg,
np.mean([av_indegree_Cragg, av_indegree_OKusky]),
av_indegree_OKusky]:
conn_params = {'av_indegree_V1': av_indegree}
network_params = {'connection_params': conn_params}
M = MultiAreaModel(network_params)
area = 'V1'
mask = create_mask(M.structure, target_areas=[area])
x = np.sum(M.syn_matrix[mask].reshape((8, 255)))
K_average = x / M.N[area]['total']
print(K_average)
assert(np.allclose(K_average, conn_params['av_indegree_V1']))
def test_hom_poisson_stat_mf():
network_params = {'connection_params': {'replace_cc': 'hom_poisson_stat'}}
theory_params = {}
M = MultiAreaModel(network_params, theory=True, theory_spec=theory_params)
p, r = M.theory.integrate_siegert()
mu, sigma = M.theory.replace_cc_input()
# Test for V1
mask = create_mask(M.structure,
target_areas=['V1'],
cortico_cortical=True,
external=False)
x = np.sum(
(M.J_matrix[mask].reshape((8, -1)) * M.K_matrix[mask].reshape(
(8, -1)) * M.params['input_params']['rate_ext'] *
M.params['neuron_params']['single_neuron_dict']['tau_m'] * 1e-3),
axis=1)
assert (np.allclose(x, mu[:8]))
lateral_path_pairs = []
FF_path_lengths = []
FB_path_lengths = []
lateral_path_lengths = []
FF_paths = []
FB_paths = []
lateral_paths = []
for target_area in area_list:
for source_area in area_list:
indices = create_mask(M.structure,
target_pops=M.structure[target_area],
source_pops=M.structure[source_area],
target_areas=[target_area],
source_areas=[source_area],
complete_area_list=area_list,
external=False)
pM = path_length_matrix[indices[:, :-1]]
pM = pM.reshape(
(len(M.structure[target_area]), len(M.structure[source_area])))
imin = np.unravel_index(np.argmin(pM), pM.shape)
pair = (M.structure[source_area][imin[1]],
M.structure[target_area][imin[0]])
source_pop = area_population_list(M.structure, source_area)[imin[1]]
target_pop = area_population_list(M.structure, target_area)[imin[0]]
if (target_area != source_area
and len(paths[source_pop][target_pop]) > 0
and source_area in SLN_completed[target_area]):
rate_time_series[source_area][source_pop] = dat
fn = os.path.join(load_path,
'rate_time_series_full_Parameters.json')
with open(fn, 'r') as f:
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
t = pl.FixedLocator([-0.1, -0.05, 0, 0.05, 0.1])
pl.colorbar(im, ticks=t)
"""
Panel C
"""
zoom = []
for a1, area1 in enumerate(['FEF', '46']):
for p1, pop1 in enumerate(M_base.structure[area1]):
zoom.append((area1, pop1))
dev_zoom = np.zeros((16, 16))
for ii in range(16):
area1, pop1 = zoom[ii]
mask2 = create_mask(M_base.structure,
target_areas=[area1],
target_pops=[pop1])
for jj in range(16):
area2, pop2 = zoom[jj]
mask = create_mask(M_base.structure,
target_areas=[area1],
source_areas=[area2],
target_pops=[pop1],
source_pops=[pop2],
external=False)
dev_zoom[ii][jj] = (K_prime1[mask[:, :-1]] - K_default[mask[:, :-1]]
) / np.sum(K_default[mask2[:, :-1]])
ax = panel_factory.new_panel(0, 1, 'C', label_position=-0.25)
ax.yaxis.set_ticks_position('none')
ax.xaxis.set_ticks_position('none')
"""
ax = axes['A']
ax.yaxis.set_ticks_position('none')
ax.xaxis.set_ticks_position('none')
zoom = []
for a1, area1 in enumerate(['V4', 'CITv']):
for p1, pop1 in enumerate(M_base.structure[area1]):
zoom.append((area1, pop1))
dev = K_prime4 - K_default
dev_zoom = np.zeros((16, 16))
for ii in range(16):
area1, pop1 = zoom[ii]
mask2 = create_mask(M_base.structure,
target_areas=[area1],
target_pops=[pop1])[:, :-1]
for jj in range(16):
area2, pop2 = zoom[jj]
mask = create_mask(M_base.structure,
target_areas=[area1],
source_areas=[area2],
target_pops=[pop1],
source_pops=[pop2])[:, :-1]
dev_zoom[ii][jj] = dev[mask] / np.sum(K_default[mask2])
clim = max(abs(np.min(dev_zoom)), abs(np.max(dev_zoom)))
clim = 0.06
im = ax.pcolormesh(dev_zoom[::-1], cmap=cmap, vmin=-clim, vmax=clim)
tick_labels = population_labels + population_labels
for pop in M.structure[area]:
num_vector[index] = M.N[area][pop]
index += 1
for i in range(254):
Npre[i] = num_vector
Npost[:, i] = num_vector
C = 1. - (1. - 1. / (Npre * Npost))**(M.K_matrix[:, :-1] * Npost)
Nsyn = M.K_matrix[:, :-1] * Npost
outdegree = Nsyn / Npre
indegree = M.K_matrix[:, :-1]
plot_areas = ['V1', 'V2']
mask = create_mask(M.structure,
target_areas=plot_areas,
source_areas=plot_areas,
extern=False)[:, :-1]
vmask = create_vector_mask(M.structure, areas=plot_areas)
new_size = np.where(vmask)[0].size
Nsyn_plot = Nsyn[mask].reshape((new_size, new_size))
C_plot = C[mask].reshape((new_size, new_size))
indegree_plot = indegree[mask].reshape((new_size, new_size))
outdegree_plot = outdegree[mask].reshape((new_size, new_size))
t_index = 0
ticks = []
ticks_r = []
for area in plot_areas:
ticks.append(t_index + 0.5 * len(M.structure[area]))
ticks_r.append(new_size - (t_index + 0.5 * len(M.structure[area])))
ax.set_xlabel('Count', size=10)
if axlabel == 'B2':
ax.set_ylabel('Target layer', size=10)
ax.yaxis.set_label_coords(-0.15, 0.5)
# Resulting patterns in the connectivity matrix
M = MultiAreaModel({})
FF_conns = []
FB_conns = []
lateral_conns = []
for target_area in area_list:
for source_area in area_list:
mask = create_mask(M.structure,
target_areas=[target_area],
source_areas=[source_area],
external=False)
if (np.sum(M.K_matrix[mask]) > 0 and source_area != target_area
and source_area in SLN_Data[target_area]):
m = M.K_matrix[mask] / np.sum(M.K_matrix[mask])
if m.size == 64:
m = m.reshape((8, 8))
elif m.size == 48:
if target_area == 'TH':
m = m.reshape((6, 8))
m = np.insert(m, 2, np.zeros((2, 8), dtype=float), axis=0)
elif source_area == 'TH':
m = m.reshape((8, 6))
m = np.insert(m, 2, np.zeros((2, 8), dtype=float), axis=1)
if SLN_Data[target_area][source_area] < 0.35:
FB_conns.append(m)