def connect_anisotropic(self, conn_type):
"""
conn_type = ['ee', 'ei', 'ie', 'ii']
"""
if self.pc_id == 0:
print 'Connect anisotropic %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
n_src_cells_per_neuron = int(round(self.params['p_%s' % conn_type] * n_src))
(delay_min, delay_max) = self.params['delay_range']
local_connlist = np.zeros((n_src_cells_per_neuron * len(tgt_cells), 4))
for i_, tgt in enumerate(tgt_cells):
if self.params['conn_conf'] == 'direction-based':
p, latency = CC.get_p_conn_direction_based(tp_src, tp_tgt[tgt, :], self.params['w_sigma_x'], self.params['w_sigma_v'], self.params['connectivity_radius'])
elif self.params['conn_conf'] == 'motion-based':
p, latency = CC.get_p_conn_motion_based(tp_src, tp_tgt[tgt, :], self.params['w_sigma_x'], self.params['w_sigma_v'], self.params['connectivity_radius'])
elif self.params['conn_conf'] == 'orientation-direction':
p, latency = CC.get_p_conn_direction_and_orientation_based(tp_src, tp_tgt[tgt, :], self.params['w_sigma_x'], self.params['w_sigma_v'], self.params['w_sigma_theta'], self.params['connectivity_radius'])
else:
print '\n\nERROR! Wrong connection configutation conn_conf parameter provided\nShould be direction-based, motion-based or orientation-direction\n'
exit(1)
if conn_type[0] == conn_type[1]:
p[tgt], latency[tgt] = 0., 0.
# random delays? --> np.permutate(latency) or latency[sources] * self.params['delay_scale'] * np.rand
sorted_indices = np.argsort(p)
if conn_type[0] == 'e':
sources = sorted_indices[-n_src_cells_per_neuron:]
else: # source = inhibitory
if conn_type[0] == conn_type[1]:
sources = sorted_indices[1:n_src_cells_per_neuron+1] # shift indices to avoid self-connection, because p_ii = .0
else:
sources = sorted_indices[:n_src_cells_per_neuron]
eta = 1e-12
w = (self.params['w_tgt_in_per_cell_%s' % conn_type] / (p[sources].sum() + eta)) * p[sources]
w_ = np.minimum(np.maximum(w, self.params['w_thresh_min']), self.params['w_thresh_max'])
delays = np.minimum(np.maximum(latency[sources] * self.params['delay_scale'], delay_min), delay_max) # map the delay into the valid range
conn_list = np.array((sources, tgt * np.ones(n_src_cells_per_neuron), w_, delays))
local_connlist[i_ * n_src_cells_per_neuron : (i_ + 1) * n_src_cells_per_neuron, :] = conn_list.transpose()
connector = FromListConnector(conn_list.transpose())
if self.params['with_short_term_depression']:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
self.projections[conn_type].append(prj)
if self.debug_connectivity:
if self.pc_id == 0:
print 'DEBUG writing to file:', conn_list_fn
np.savetxt(conn_list_fn, local_connlist, fmt='%d\t%d\t%.4e\t%.4e')
def create_connectivity(self, conn_type):
"""
This function (re-) creates the network connectivity.
"""
# distribute the cell ids among involved processes
(n_src, n_tgt, self.tp_src, self.tp_tgt) = utils.resolve_src_tgt_with_tp(conn_type, self.params)
print 'Connect anisotropic %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
gid_tgt_min, gid_tgt_max = utils.distribute_n(n_tgt, self.n_proc, self.pc_id)
print 'Process %d deals with target GIDS %d - %d' % (self.pc_id, gid_tgt_min, gid_tgt_max)
gid_src_min, gid_src_max = utils.distribute_n(n_src, self.n_proc, self.pc_id)
print 'Process %d deals with source GIDS %d - %d' % (self.pc_id, gid_src_min, gid_src_max)
n_my_tgts = gid_tgt_max - gid_tgt_min
# data structure for connection storage
self.target_adj_list = [ [] for i in xrange(n_my_tgts)]
n_src_cells_per_neuron = int(round(self.params['p_%s' % conn_type] * n_src))
# compute all pairwise connection probabilities
for i_, tgt in enumerate(range(gid_tgt_min, gid_tgt_max)):
if (i_ % 20) == 0:
print '%.2f percent complete' % (i_ / float(n_my_tgts) * 100.)
p = np.zeros(n_src)
latency = np.zeros(n_src)
for src in xrange(n_src):
if conn_type[0] == conn_type[1]: # no self-connection
if (src != tgt):
p[src], latency[src] = CC.get_p_conn(self.tp_src[src, :], self.tp_tgt[tgt, :], params['w_sigma_x'], params['w_sigma_v'], params['connectivity_radius'])
else: # different populations --> same indices mean different cells, no check for src != tgt
p[src], latency[src] = CC.get_p_conn(self.tp_src[src, :], self.tp_tgt[tgt, :], params['w_sigma_x'], params['w_sigma_v'], params['connectivity_radius'])
# sort connection probabilities and select remaining connections
sorted_indices = np.argsort(p)
if conn_type[0] == 'e':
sources = sorted_indices[-n_src_cells_per_neuron:]
else:
if conn_type == 'ii':
sources = sorted_indices[1:n_src_cells_per_neuron+1] # shift indices to avoid self-connection, because p_ii = .0
else:
sources = sorted_indices[:n_src_cells_per_neuron]
w = (self.params['w_tgt_in_per_cell_%s' % conn_type] / p[sources].sum()) * p[sources]
for i in xrange(len(sources)):
if w[i] > self.params['w_thresh_connection']:
delay = min(max(latency[sources[i]] * self.params['delay_scale'], self.params['delay_range'][0]), self.params['delay_range'][1]) # map the delay into the valid range
# create adjacency list for all local cells and store connection in class container
self.target_adj_list[i_].append(sources[i])
# communicate the resulting target_adj_list to the root process
self.send_list_to_root(self.target_adj_list)
def connect_anisotropic(self, conn_type):
"""
"""
if self.pc_id == 0:
print 'Connect anisotropic %s - %s' % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if self.debug_connectivity:
conn_list_fn = self.params['conn_list_%s_fn_base' % conn_type] + '%d.dat' % (self.pc_id)
conn_file = open(conn_list_fn, 'w')
output = ''
n_src_cells_per_neuron = int(round(self.params['p_%s' % conn_type] * n_src))
(delay_min, delay_max) = self.params['delay_range']
for tgt in tgt_cells:
p = np.zeros(n_src)
latency = np.zeros(n_src)
for src in xrange(n_src):
if conn_type[0] == conn_type[1]: # no self-connection
if (src != tgt):
p[src], latency[src] = CC.get_p_conn(tp_src[src, :], tp_tgt[tgt, :], params['w_sigma_x'], params['w_sigma_v']) # print 'debug pc_id src tgt ', self.pc_id, src, tgt#, int(ID) < self.params['n_exc']
else: # different populations --> same indices mean different cells, no check for src != tgt
p[src], latency[src] = CC.get_p_conn(tp_src[src, :], tp_tgt[tgt, :], params['w_sigma_x'], params['w_sigma_v']) # print 'debug pc_id src tgt ', self.pc_id, src, tgt#, int(ID) < self.params['n_exc']
sorted_indices = np.argsort(p)
if conn_type[0] == 'e':
sources = sorted_indices[-n_src_cells_per_neuron:]
else:
if conn_type == 'ii':
sources = sorted_indices[1:n_src_cells_per_neuron+1] # shift indices to avoid self-connection, because p_ii = .0
else:
sources = sorted_indices[:n_src_cells_per_neuron]
w = (self.params['w_tgt_in_per_cell_%s' % conn_type] / p[sources].sum()) * p[sources]
for i in xrange(len(sources)):
if w[i] > self.params['w_thresh_connection']:
# w[i] = max(self.params['w_min'], min(w[i], self.params['w_max']))
delay = min(max(latency[sources[i]] * self.params['t_stimulus'], delay_min), delay_max) # map the delay into the valid range
# print 'debug ', delay , ' latency', latency[sources[i]]
# delay = min(max(latency[sources[i]] * self.params['delay_scale'], delay_min), delay_max) # map the delay into the valid range
connect(src_pop[sources[i]], tgt_pop[tgt], w[i], delay=delay, synapse_type=syn_type)
if self.debug_connectivity:
output += '%d\t%d\t%.2e\t%.2e\n' % (sources[i], tgt, w[i], delay) # output += '%d\t%d\t%.2e\t%.2e\t%.2e\n' % (sources[i], tgt, w[i], latency[sources[i]], p[sources[i]])
if self.debug_connectivity:
if self.pc_id == 0:
print 'DEBUG writing to file:', conn_list_fn
conn_file.write(output)
conn_file.close()
def prepare_connections(self, input_fn=None):
if self.params['connectivity'] == 'precomputed':
print "Proc %d computes initial weights ... " % self.pc_id
tuning_prop = np.loadtxt(self.params['tuning_prop_means_fn'])
CC.compute_weights_from_tuning_prop(tuning_prop, self.params, self.comm)
elif self.pc_id == 0 and self.params['connectivity'] == 'random':
print "Proc %d shuffles pre-computed weights ... " % self.pc_id
output_fn = self.params['random_weight_list_fn'] + '0.dat'
CC.compute_random_weight_list(input_fn, output_fn, self.params)
if self.comm != None:
print 'Pid %d at Barrier in prepare_connections' % self.pc_id
sys.stdout.flush()
self.comm.Barrier()
def connect_ee_random(self):
"""
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
# C O N N E C T E X C - E X C R A N D O M #
# # # # # # # # # # # # # # # # # # # # # # # # # # # #
"""
if self.pc_id == 0:
print "Drawing random connections"
sigma_x, sigma_v = self.params["w_sigma_x"], self.params["w_sigma_v"]
(delay_min, delay_max) = self.params["delay_range"]
if self.debug_connectivity:
conn_list_fn = self.params["conn_list_ee_fn_base"] + "%d.dat" % (self.pc_id)
conn_file = open(conn_list_fn, "w")
output = ""
for tgt in self.local_idx_exc:
p = np.zeros(self.params["n_exc"], dtype="float32")
latency = np.zeros(self.params["n_exc"], dtype="float32")
for src in xrange(self.params["n_exc"]):
if src != tgt:
p[src], latency[src] = CC.get_p_conn(
self.tuning_prop_exc[src, :],
self.tuning_prop_exc[tgt, :],
sigma_x,
sigma_v,
params["connectivity_radius"],
) # print 'debug pc_id src tgt ', self.pc_id, src, tgt#, int(ID) < self.params['n_exc']
sources = random.sample(xrange(self.params["n_exc"]), int(self.params["n_src_cells_per_neuron"]))
idx = p[sources] > 0
non_zero_idx = np.nonzero(idx)[0]
p_ = p[sources][non_zero_idx]
l_ = latency[sources][non_zero_idx] * self.params["delay_scale"]
w = utils.linear_transformation(p_, self.params["w_min"], self.params["w_max"])
for i in xrange(len(p_)):
# w[i] = max(self.params['w_min'], min(w[i], self.params['w_max']))
delay = min(max(l_[i], delay_min), delay_max) # map the delay into the valid range
connect(self.exc_pop[non_zero_idx[i]], self.exc_pop[tgt], w[i], delay=delay, synapse_type="excitatory")
if self.debug_connectivity:
output += "%d\t%d\t%.2e\t%.2e\n" % (
non_zero_idx[i],
tgt,
w[i],
delay,
) # output += '%d\t%d\t%.2e\t%.2e\t%.2e\n' % (sources[i], tgt, w[i], latency[sources[i]], p[sources[i]])
if self.debug_connectivity:
if self.pc_id == 0:
print "DEBUG writing to file:", conn_list_fn
conn_file.write(output)
conn_file.close()
def connect_anisotropic(self, conn_type):
"""
conn_type = ['ee', 'ei', 'ie', 'ii']
"""
if self.pc_id == 0:
print "Connect anisotropic %s - %s" % (conn_type[0].capitalize(), conn_type[1].capitalize())
(n_src, n_tgt, src_pop, tgt_pop, tp_src, tp_tgt, tgt_cells, syn_type) = self.resolve_src_tgt(conn_type)
if self.debug_connectivity:
conn_list_fn = self.params["conn_list_%s_fn_base" % conn_type] + "%d.dat" % (self.pc_id)
n_src_cells_per_neuron = int(round(self.params["p_%s" % conn_type] * n_src))
(delay_min, delay_max) = self.params["delay_range"]
local_connlist = np.zeros((n_src_cells_per_neuron * len(tgt_cells), 4))
for i_, tgt in enumerate(tgt_cells):
if self.params["direction_based_conn"]:
p, latency = CC.get_p_conn_vec_xpred(
tp_src,
tp_tgt[tgt, :],
self.params["w_sigma_x"],
self.params["w_sigma_v"],
self.params["connectivity_radius"],
)
else:
p, latency = CC.get_p_conn_vec(
tp_src,
tp_tgt[tgt, :],
self.params["w_sigma_x"],
self.params["w_sigma_v"],
self.params["connectivity_radius"],
self.params["maximal_latency"],
)
if conn_type[0] == conn_type[1]:
p[tgt], latency[tgt] = 0.0, 0.0
# random delays? --> np.permutate(latency) or latency[sources] * self.params['delay_scale'] * np.rand
sorted_indices = np.argsort(p)
if conn_type[0] == "e":
sources = sorted_indices[-n_src_cells_per_neuron:]
else: # source = inhibitory
if conn_type[0] == conn_type[1]:
sources = sorted_indices[
1 : n_src_cells_per_neuron + 1
] # shift indices to avoid self-connection, because p_ii = .0
else:
sources = sorted_indices[:n_src_cells_per_neuron]
# eta = 1e-9
eta = 0
w = (self.params["w_tgt_in_per_cell_%s" % conn_type] / (p[sources].sum() + eta)) * p[sources]
# print 'debug p', i_, tgt, p[sources]
# print 'debug sources', i_, tgt, sources
# print 'debug w', i_, tgt, w
delays = np.minimum(
np.maximum(latency[sources] * self.params["delay_scale"], delay_min), delay_max
) # map the delay into the valid range
conn_list = np.array((sources, tgt * np.ones(n_src_cells_per_neuron), w, delays))
local_connlist[i_ * n_src_cells_per_neuron : (i_ + 1) * n_src_cells_per_neuron, :] = conn_list.transpose()
connector = FromListConnector(conn_list.transpose())
if self.params["with_short_term_depression"]:
prj = Projection(
src_pop, tgt_pop, connector, target=syn_type, synapse_dynamics=self.short_term_depression
)
else:
prj = Projection(src_pop, tgt_pop, connector, target=syn_type)
self.projections[conn_type].append(prj)
if self.debug_connectivity:
if self.pc_id == 0:
print "DEBUG writing to file:", conn_list_fn
np.savetxt(conn_list_fn, local_connlist, fmt="%d\t%d\t%.4e\t%.4e")
else: # run a simulation with parameters as set in simulation_parameters
GP = simulation_parameters.global_parameters()
GP.write_parameters_to_file() # write_parameters_to_file MUST be called before every simulation
params = GP.params
# TODO: update VisualInputParameters and possibly remove it completely
# decide whether to load the default parameters or to take parameters from a file
VIP = VisualInputParameters.VisualInputParameters()
VIP.update_values(params)
vi_params = VIP.params
VI = VisualInput.VisualInput(vi_params) # pass parameters to the VisualInput module
MT = MotionPrediction.MotionPrediction(params)
BG = BasalGanglia.BasalGanglia(params)
CC = CreateConnections.CreateConnections(params)
CC.connect_mt_to_bg(MT, BG)
for iteration in xrange(params['n_iterations']):
# integrate the real world trajectory and the eye direction and compute spike trains from that
stim = VI.compute_input(params['t_iteration'], BG.get_eye_direction())
MT.compute_state(stim) # run the network for some time
BG.move_eye(MT.current_state)
# """
# First the stimulus is computed for a certain time
# """
# stimulus = VI.compute_input(params['t_integrate'])
import numpy as np
import CreateConnections as CC
import utils
import simulation_parameters
ps = simulation_parameters.parameter_storage()
params = ps.params
tp = np.loadtxt(params['tuning_prop_means_fn'])
tgt_gid = 0
srcs = [1, 2, 3, 4, 5, 6, 7, 8]
tp_src = tp[srcs, :]
tp_tgt = tp[tgt_gid, :]
#d_ij = utils.torus_distance2D_vec(tp_src[:, 0], tp_tgt[0] * np.ones(n_src), tp_src[:, 1], tp_tgt[1] * np.ones(n_src), w=np.ones(n_src), h=np.ones(n_src))
print 'tp_src', tp_src
print 'tp_tgt', tp_tgt
#print 'd_ij', d_ij
w_sigma_x, w_sigma_v = .1, .1
v_src = np.array((tp_src[:, 2], tp_src[:, 3]))
v_src = v_src.transpose()
print 'v_src', v_src.shape
p, l = CC.get_p_conn_vec(tp[srcs, :], tp[tgt_gid, :], w_sigma_x, w_sigma_v)
print 'p', p
print 'l', l
for src in xrange(len(srcs)):
p_, l_ = CC.get_p_conn(tp_src[src, :], tp_tgt, w_sigma_x, w_sigma_v)
print 'src p l', src, p_, p[src], l_, l[src]
#print p
mans_set = set(mans)
good_gids = set(indices)
print mans_set.intersection(good_gids)
# sort them according to their x-pos
x_sorted_indices = np.argsort(tp[indices, 0])
sorted_gids = indices[x_sorted_indices]
print '\nConnection probabilities between the cells with \'good\' tuning properies:'
conn_probs = []
latencies = []
for i in xrange(n):
src = sorted_gids[i]
for tgt in sorted_gids:
p, latency = CC.get_p_conn(tp[src, :], tp[tgt, :], sigma_x, sigma_v)
conn_probs.append(p)
latencies.append(latency)
# print "p(%d, %d):\t %.3e\tlatency: %.3e\t" % (src, tgt, p, latency)
# print '\n'
conn_probs = np.array(conn_probs)
latencies = np.array(latencies)
print "Average connection probability between neurons with \'good\' tuning_prop", np.mean(conn_probs), '\t std:', np.std(conn_probs)
print "Min max and median connection probability between neurons with \'good\' tuning_prop", np.min(conn_probs), np.max(conn_probs), np.median(conn_probs)
print "Average latencies between neurons with \'good\' tuning_prop", np.mean(latencies), '\t std:', np.std(latencies)
print "Min and max latencies between neurons with \'good\' tuning_prop", np.min(latencies), np.max(latencies)
print "\nCompare to cells connected via strong weights"
all_weights = conn_mat.flatten()
sorted_weight_indices = list(all_weights.argsort())
connect(ssa, exc_pop[tgt], params['w_input_exc'], synapse_type='excitatory')
# connect cells
# for src, src_gid in enumerate(gids):
# if src_gid != tgt_gid:
# p, latency = CC.get_p_conn(tuning_prop[src_gid, :], tuning_prop[tgt_gid, :], params['w_sigma_x'], params['w_sigma_v'])
# print 'p', p
# p = np.array([1e-6, p])
# w = utils.linear_transformation(p, params['w_min'], params['w_max'])
# w = w[1]
# print "src tgt w", src_gid, tgt_gid, w
# delay = min(max(latency * params['delay_scale'], delay_min), delay_max) # map the delay into the valid range
# connect(exc_pop[src], exc_pop[tgt], w, delay=delay, synapse_type='excitatory')
#delay = 30
p, latency = CC.get_p_conn(tuning_prop[gids[1], :], tuning_prop[gids[0], :], params['w_sigma_x'], params['w_sigma_v'])
delay = latency * params['t_stimulus'] * 0.4
#delay = min(max(latency * params['delay_scale'], delay_min), delay_max) # map the delay into the valid range
print 'latency %.3e\tdelay %.2e' % (latency, delay)
delay = 1
w = 0.5e-2
connect(exc_pop[1], exc_pop[0], w, delay=delay, synapse_type='excitatory')
exc_pop.record()
exc_pop.record_v()
run(params['t_sim'])
folder_name = 'BarcelonaData/'
exc_pop.printSpikes(folder_name + 'spikes.ras')
print 'n_cells=%d\tn_exc=%d\tn_inh=%d' % (params['n_cells'], params['n_exc'], params['n_inh'])
print 'w_sigma_x, v', params['w_sigma_x'], params['w_sigma_v']
try:
from mpi4py import MPI
USE_MPI = True
comm = MPI.COMM_WORLD
pc_id, n_proc = comm.rank, comm.size
print "USE_MPI:", USE_MPI, 'pc_id, n_proc:', pc_id, n_proc
except:
USE_MPI = False
pc_id, n_proc, comm = 0, 1, None
print "MPI not used"
#try:
tuning_prop = np.loadtxt(params['tuning_prop_means_fn'])
#except:
# print 'File with tuning properties missing: %s\nPlease run: \nmpirun -np [N] python prepare_tuning_prop.py\nOR\npython prepare_tuning_prop.py' % params['tuning_prop_means_fn']
# exit(1)
import CreateConnections as CC
#try:
CC.compute_weights_convergence_constrained(tuning_prop, params, comm)
#except:
# print 'File with tuning properties contains wrong number of cells %s\nPlease re-run: \nmpirun -np [N] python prepare_tuning_prop.py\nOR\npython prepare_tuning_prop.py' % params['tuning_prop_means_fn']
# exit(1)
output_fn = params['conn_list_ee_conv_constr_fn_base'] + 'merged.dat'
if pc_id == 0:
print 'Merged connections file:', output_fn
utils.merge_files('%spid*.dat' % params['conn_list_ee_conv_constr_fn_base'], output_fn)
tp = np.loadtxt(params['tuning_prop_means_fn']) # spatial distribution of inhibitory cells hexgrid_pos = utils.set_hexgrid_positions(params, params['N_RF_X_INH'], params['N_RF_Y_INH']) output_fn = params['inh_cell_pos_fn'] print 'debug hexgrid pos shape', hexgrid_pos.shape print 'printing inh cell positions to:', output_fn np.savetxt(output_fn, hexgrid_pos) # for each exc cell calculate the predicted position of the dot from the cell's tuning prop predicted_positions = utils.get_predicted_stim_pos(tp) # x_predicted = x + v [a.u.] print "Predicted positions: ", params['predicted_positions_fn'] np.savetxt(params['predicted_positions_fn'], predicted_positions) # calculate the ring of excitatory source cells for each target inhibitory cell src_pos = predicted_positions tgt_pos = hexgrid_pos import CreateConnections as CC n_ei_per_cell = int(round(params['p_ei'] * params['n_exc'])) print 'Each inh cell receives input from %d exc cells (p_ei = %.3f)' % (n_ei_per_cell, params['p_ei']) output_indices, output_distances = CC.get_exc_inh_connections(src_pos, tgt_pos, tp, n=n_ei_per_cell) output_fn1 = params['exc_inh_adjacency_list_fn'] output_fn2 = params['exc_inh_distances_fn'] print 'saving exc-inh connections', output_fn1 print 'saving exc-inh distances ', output_fn2 np.savetxt(output_fn1, output_indices) np.savetxt(output_fn2, output_distances) # TODO: convert #self.params['exc_inh_weights_fn'] = '%sexc_to_inh_indices.dat' % (self.params['connections_folder']) # same format as exc_inh_distances_fn, containing the exc - inh weights
