def compute_my_pijs(conns, output_fn, tau_dict, input_fn_base):
"""
conns = list of connections, i.e. tuples: (src, tgt)
"""
dt = 1
print 'pc_id computes pijs for %d connections' % (len(conns))
my_traces_pre = {}
my_traces_post = {}
p_ij_string = '#pre_id\tpost_id\tpij[-1]\tw_ij[-1]\tbias\n'
for i in xrange(len(conns)):
if (i % 500) == 0:
print "Pc %d conn: \t%d - %d; \t%d / %d\t%.4f percent complete" % (pc_id, conns[i][0], conns[i][1], i, len(conns), i * 100./len(conns))
pre_id = conns[i][0]
post_id = conns[i][1]
if my_traces_pre.has_key(pre_id):
(zi, pi) = my_traces_pre[pre_id]
else:
pre_trace = np.loadtxt(input_fn_base + str(pre_id) + '.dat')
zi, ei, pi = Bcpnn.compute_traces(pre_trace, tau_dict['tau_zi'], tau_dict['tau_ei'], tau_dict['tau_pi'], eps=dt/tau_dict['tau_pi'])
my_traces_pre[pre_id] = (zi, pi)
if my_traces_post.has_key(post_id):
(zj, pj) = my_traces_post[post_id]
else:
post_trace = np.loadtxt(input_fn_base + str(post_id) + '.dat')
zj, ej, pj = Bcpnn.compute_traces(post_trace, tau_dict['tau_zj'], tau_dict['tau_ej'], tau_dict['tau_pj'], eps=dt/tau_dict['tau_pj']) # actually should be eps=dt/tau_dict['tau_pi']
my_traces_post[post_id] = (zj, pj)
pij, w_ij, bias = Bcpnn.compute_pij(zi, zj, pi, pj, tau_dict['tau_eij'], tau_dict['tau_pij'])
p_ij_string += '%d\t%d\t%.8e\t%.8e\t%.8e\n' % (pre_id, post_id, pij, w_ij, bias)
if comm != None:
comm.barrier()
print 'Writing p_ij output to:', output_fn
f = file(output_fn, 'w')
f.write(p_ij_string)
f.close()
if comm != None:
comm.barrier()
if n_proc > 1 and pc_id == 0:
tmp_fn = params['bcpnntrace_folder'] + 'all_pij.dat'
cat_cmd = 'cat %s* > %s' % (params['bcpnntrace_folder'] + 'pij_', tmp_fn)
print cat_cmd
os.system(cat_cmd)
return my_traces_pre, my_traces_post
def compute_pre_post_traces(conns, verbose=True):
bcpnn_trace_len = params['t_stimulus'] / params['dt_rate']
trace_len = params['t_stimulus'] / params['dt_rate']
for i in xrange(len(conns)):
#for i in xrange(100):
print "Pc %d conn: \t%d - %d; \t%d / %d\t%.4f percent complete" % (pc_id, conns[i][0], conns[i][1], i + 1, len(conns), i * 100./len(conns))
pre_id = conns[i][0]
post_id = conns[i][1]
pre_trace = np.loadtxt(params['input_rate_fn_base'] + str(pre_id) + '.dat')
post_trace = np.loadtxt(params['input_rate_fn_base'] + str(post_id) + '.dat')
# pre_trace = np.zeros(bcpnn_trace_len)
# d = np.loadtxt(params['input_rate_fn_base'] + str(pre_id) + '.dat')
# pre_trace[:trace_len] = d
# post_trace = np.zeros(bcpnn_trace_len)
# d = np.loadtxt(params['input_rate_fn_base'] + str(post_id) + '.dat')
# post_trace[:trace_len] = d
# post_trace[trace_len:] = 0.
# post_trace.resize(bcpnn_trace_len)
# compute
wij, bias, pi, pj, pij, ei, ej, eij, zi, zj = Bcpnn.get_spiking_weight_and_bias(pre_trace, post_trace, get_traces=True, \
tau_dict=tau_dict, f_max=1000.)
weight_fn = params['weights_fn_base'] + '%d_%d.dat' % (pre_id, post_id)
if verbose:
print 'Saving to ', weight_fn
np.savetxt(weight_fn, wij)
output_fn = params['bias_fn_base'] + "%d.dat" % (post_id)
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, bias)
output_fn = params['ztrace_fn_base'] + "%d.dat" % pre_id
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, zi)
output_fn = params['ztrace_fn_base'] + "%d.dat" % post_id
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, zj)
output_fn = params['etrace_fn_base'] + "%d.dat" % pre_id
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, ei)
output_fn = params['etrace_fn_base'] + "%d.dat" % post_id
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, ej)
output_fn = params['etrace_fn_base'] + "%d_%d.dat" % (pre_id, post_id)
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, eij)
output_fn = params['ptrace_fn_base'] + "%d.dat" % pre_id
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, pi)
output_fn = params['ptrace_fn_base'] + "%d.dat" % post_id
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, pj)
output_fn = params['ptrace_fn_base'] + "%d_%d.dat" % (pre_id, post_id)
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, pij)
output_fn = params['weights_fn_base'] + "%d_%d.dat" % (pre_id, post_id)
if verbose:
print 'Saving to ', output_fn
np.savetxt(output_fn, wij)
text += 'tau_zj = %d\n' % tau_dict['tau_zj']
text += 'tau_e = %d\n' % tau_dict['tau_ei']
text += 'tau_p = %d\n' % tau_dict['tau_pi']
text += 'x_stim(t) = (%.1f, %.1f) + (%.1f, %.1f) * t\n'% (mp[0], mp[1], mp[2], mp[3])
import plot_bcpnn_traces as trace_plotter
output_fig_fn = params['figures_folder'] + 'bcpnn_trace_%d_%d_%d.png' % (tau_dict['tau_zi'], tau_dict['tau_ei'], tau_dict['tau_pi'])
times.append(time.time())
t_comp = times[-1] - times[0]
print 'Computation time: %d sec = %.1f min' % (t_comp, t_comp / 60.)
# seperate computation of traces and weights
pre_trace = np.loadtxt(params['input_rate_fn_base'] + '%d.dat' % my_conns[0][0])
post_trace = np.loadtxt(params['input_rate_fn_base'] + '%d.dat' % my_conns[0][1])
dt = 1.
zi = np.zeros(pre_trace.size)
zi, ei, pi = Bcpnn.compute_traces(pre_trace, tau_dict['tau_zi'], tau_dict['tau_ei'], tau_dict['tau_pi'], eps=dt/tau_dict['tau_pi'])
pre_id = my_conns[0][0]
post_id = my_conns[0][1]
# print the seperately computed traces
np.savetxt('debug_zi_trace_%d.dat' % pre_id, zi)
np.savetxt('debug_ei_trace_%d.dat' % pre_id, ei)
np.savetxt('debug_pi_trace_%d.dat' % pre_id, pi)
zj, ej, pj = Bcpnn.compute_traces(post_trace, tau_dict['tau_zj'], tau_dict['tau_ej'], tau_dict['tau_pj'], eps=dt/tau_dict['tau_pj'])
np.savetxt('debug_zj_trace_%d.dat' % post_id, zj)
np.savetxt('debug_ej_trace_%d.dat' % post_id, ej)
np.savetxt('debug_pj_trace_%d.dat' % post_id, pj)
pij, w_ij, bias = Bcpnn.compute_pij(zi, zj, pi, pj, tau_dict['tau_eij'], tau_dict['tau_pij'])
print 'debug w_ij', pre_id, post_id, w_ij
w_ij_trace, bias, pij, eij = Bcpnn.compute_pij(zi, zj, pi, pj, tau_dict['tau_eij'], tau_dict['tau_pij'], get_traces=True)
def compute_my_pijs(self):
pre_traces_computed = np.zeros(params['n_exc'], dtype=np.bool)
post_traces_computed = np.zeros(params['n_exc'], dtype=np.bool)
tau_dict = self.params['tau_dict']
zi_traces = self.initial_value * np.ones((self.n_time_steps, self.pre_ids.size), dtype=np.double)
zj_traces = self.initial_value * np.ones((self.n_time_steps, self.post_ids.size), dtype=np.double)
ei_traces = self.initial_value * np.ones((self.n_time_steps, self.pre_ids.size), dtype=np.double)
ej_traces = self.initial_value * np.ones((self.n_time_steps, self.post_ids.size), dtype=np.double)
pi_traces = self.initial_value * np.ones((self.n_time_steps, self.pre_ids.size), dtype=np.double)
pj_traces = self.initial_value * np.ones((self.n_time_steps, self.post_ids.size), dtype=np.double)
eij_trace = self.initial_value ** 2 * np.ones(self.n_time_steps, dtype=np.double)
pij_trace = self.initial_value ** 2 * np.ones(self.n_time_steps, dtype=np.double)
wij_trace = np.zeros(self.n_time_steps, dtype=np.double)
bias_trace = np.log(self.initial_value) * np.ones(self.n_time_steps, dtype=np.double)
input_fn_base = self.training_input_folder + self.params['abstract_input_fn_base']
self.my_wijs = np.zeros((self.my_conns[:, 0].size, 4), dtype=np.double) # array for wij and pij
self.my_bias = np.zeros((self.post_ids.size, 2), dtype=np.double) # array for wij and pij
bias_idx = 0
for i in xrange(self.my_conns[:, 0].size):
if (i % 1000) == 0:
print "Pc %d conn: \t%d / %d\t%.4f percent complete; Stimulus iteration: %d" % (pc_id, i, self.my_conns[:, 0].size, i * 100./self.my_conns[:, 0].size, self.iteration)
pre_id = self.my_conns[i, 0]
post_id = self.my_conns[i, 1]
if pre_traces_computed[pre_id]:
idx = self.gid_idx_map_pre[pre_id]
(zi, ei, pi) = zi_traces[:, idx], ei_traces[:, idx], pi_traces[:, idx]
else:
pre_trace = np.loadtxt(input_fn_base + str(pre_id) + '.dat')
idx = self.gid_idx_map_pre[pre_id]
zi_traces[0, idx] = self.zi_init[pre_id]
ei_traces[0, idx] = self.ei_init[pre_id]
pi_traces[0, idx] = self.pi_init[pre_id]
Bcpnn.compute_traces_new(pre_trace, zi_traces[:, idx], ei_traces[:, idx], pi_traces[:, idx], \
tau_dict['tau_zi'], tau_dict['tau_ei'], tau_dict['tau_pi'], \
dt=self.params['dt_rate'], eps=self.eps)
pre_traces_computed[pre_id] = True
self.zi_init[pre_id] = zi_traces[-1, idx]
self.ei_init[pre_id] = ei_traces[-1, idx]
self.pi_init[pre_id] = pi_traces[-1, idx]
if post_traces_computed[post_id]:
idx = self.gid_idx_map_post[post_id]
(zj, ej, pj) = zj_traces[:, idx], ej_traces[:, idx], pj_traces[:, idx]
else:
post_trace = np.loadtxt(input_fn_base + str(post_id) + '.dat')
idx = self.gid_idx_map_post[post_id]
zj_traces[0, idx] = self.zj_init[post_id]
ej_traces[0, idx] = self.ej_init[post_id]
pj_traces[0, idx] = self.pj_init[post_id]
Bcpnn.compute_traces_new(post_trace, zj_traces[:, idx], ej_traces[:, idx], pj_traces[:, idx], \
tau_dict['tau_zj'], tau_dict['tau_ej'], tau_dict['tau_pj'], \
dt=self.params['dt_rate'], eps=self.eps)
post_traces_computed[post_id] = True
self.zj_init[post_id] = zj_traces[-1, idx]
self.ej_init[post_id] = ej_traces[-1, idx]
self.pj_init[post_id] = pj_traces[-1, idx]
self.my_bias[bias_idx, :] = post_id, np.log(pj_traces[-1, idx])
bias_idx += 1
idx_pre = self.gid_idx_map_pre[pre_id]
idx_post = self.gid_idx_map_post[post_id]
eij_trace[0] = self.eij_init[pre_id, post_id]
pij_trace[0] = self.pij_init[pre_id, post_id]
wij_trace[0] = self.wij_init[pre_id, post_id]
bias_trace[0] = self.bias_init[post_id]
if ((pre_id, post_id) in self.my_selected_conns):
# write selected traces to files
# print 'Proc %d prints BCPNN pre-traces for cell %d:' % (self.pc_id, pre_id)
idx = self.gid_idx_map_pre[pre_id]
np.savetxt(self.params['bcpnntrace_folder'] + 'zi_%d_%d.dat' % (self.iteration, pre_id), zi_traces[:, idx])
np.savetxt(self.params['bcpnntrace_folder'] + 'ei_%d_%d.dat' % (self.iteration, pre_id), ei_traces[:, idx])
np.savetxt(self.params['bcpnntrace_folder'] + 'pi_%d_%d.dat' % (self.iteration, pre_id), pi_traces[:, idx])
# print 'Proc %d prints BCPNN post-traces for cell %d:' % (self.pc_id, post_id)
idx = self.gid_idx_map_post[post_id]
np.savetxt(self.params['bcpnntrace_folder'] + 'zj_%d_%d.dat' % (self.iteration, post_id), zj_traces[:, idx])
np.savetxt(self.params['bcpnntrace_folder'] + 'ej_%d_%d.dat' % (self.iteration, post_id), ej_traces[:, idx])
np.savetxt(self.params['bcpnntrace_folder'] + 'pj_%d_%d.dat' % (self.iteration, post_id), pj_traces[:, idx])
wij, bias, pij, eij = Bcpnn.compute_pij_new(zi_traces[:, idx_pre], zj_traces[:, idx_post], pi_traces[:, idx_pre], pj_traces[:, idx_post], \
eij_trace, pij_trace, wij_trace, bias_trace, \
tau_dict['tau_eij'], tau_dict['tau_pij'], get_traces=True, dt=self.params['dt_rate'])
np.savetxt(self.params['bcpnntrace_folder'] + 'wij_%d_%d_%d.dat' % (self.iteration, pre_id, post_id), wij)
np.savetxt(self.params['bcpnntrace_folder'] + 'bias_%d_%d_%d.dat' % (self.iteration, pre_id, post_id), bias)
np.savetxt(self.params['bcpnntrace_folder'] + 'eij_%d_%d_%d.dat' % (self.iteration, pre_id, post_id), eij)
np.savetxt(self.params['bcpnntrace_folder'] + 'pij_%d_%d_%d.dat' % (self.iteration, pre_id, post_id), pij)
else:
Bcpnn.compute_pij_new(zi_traces[:, idx_pre], zj_traces[:, idx_post], pi_traces[:, idx_pre], pj_traces[:, idx_post], \
eij_trace, pij_trace, wij_trace, bias_trace, \
tau_dict['tau_eij'], tau_dict['tau_pij'], dt=self.params['dt_rate'])
# update the nr.0 value for the next stimulus
self.eij_init[pre_id, post_id] = eij_trace[-1]
self.pij_init[pre_id, post_id] = pij_trace[-1]
self.wij_init[pre_id, post_id] = wij_trace[-1]
self.bias_init[post_id] = bias_trace[-1]
self.my_wijs[i, :] = pre_id, post_id, wij_trace[-1], pij_trace[-1]
# store wijs and bias in the tmp folder
np.savetxt(self.params['tmp_folder'] + 'wij_%d_%d.dat' % (self.iteration, self.pc_id), self.my_wijs)
np.savetxt(self.params['tmp_folder'] + 'bias_%d_%d.dat' % (self.iteration, self.pc_id), self.my_bias)
if self.comm != None:
self.comm.barrier()
import os import sys import simulation_parameters import Bcpnn import numpy as np from mpi4py import MPI comm = MPI.COMM_WORLD pc_id, n_proc = comm.rank, comm.size sim_cnt = int(sys.argv[1]) network_params = simulation_parameters.parameter_storage() # network_params class containing the simulation parameters params = network_params.load_params() # params stores cell numbers, etc as a dictionary conn_list = np.loadtxt(params['conn_list_ee_fn_base'] + str(sim_cnt) + '.dat') params = network_params.load_params() # params stores cell numbers, etc as a dictionary Bcpnn.bcpnn_offline_noColumns(params, conn_list, sim_cnt, True, comm)
d = np.loadtxt(params["input_rate_fn_base"] + str(pre_id) + ".dat")
print "debug", trace_len, d.size, bcpnn_trace_len
pre_trace[:trace_len] = d
post_trace = np.zeros(bcpnn_trace_len)
d = np.loadtxt(params["input_rate_fn_base"] + str(post_id) + ".dat")
post_trace[:trace_len] = d
post_trace[trace_len:] = 0.0
post_trace.resize(bcpnn_trace_len)
for i in xrange(5):
tau_z = 10
tau_e = 100
tau_p = 500 + 500 * i
# compute
wij, bias, pi, pj, pij, ei, ej, eij, zi, zj = Bcpnn.get_spiking_weight_and_bias(
pre_trace, post_trace, get_traces=True, tau_z=tau_z, tau_e=tau_e, tau_p=tau_p, f_max=1000.0
)
weight_fn = params["weights_fn_base"] + "%d_%d.dat" % (pre_id, post_id)
print "Saving to ", weight_fn
np.savetxt(weight_fn, wij)
output_fn = params["bias_fn_base"] + "%d_%d.dat" % (pre_id, post_id)
np.savetxt(output_fn, bias)
output_fn = params["ztrace_fn_base"] + "%d.dat" % pre_id
np.savetxt(output_fn, zi)
output_fn = params["ztrace_fn_base"] + "%d.dat" % post_id
np.savetxt(output_fn, zj)
output_fn = params["etrace_fn_base"] + "%d.dat" % pre_id
np.savetxt(output_fn, ei)
output_fn = params["etrace_fn_base"] + "%d.dat" % post_id
