def create_C2_populations(spiketrains):
C2_populations = [sim.Population(1,
sim.SpikeSourceArray(spike_times=[spiketrains[prot]]),
label=str(prot))\
for prot in range(len(spiketrains))]
compound_C2_population = C2_populations[0]
for pop in C2_populations[1:]:
compound_C2_population += pop
return (C2_populations, compound_C2_population)
weights[i][j] = round(weight_to_spike * \
(1 / (sig * np.sqrt(2 * np.pi)) * \
(np.exp(-np.power(dist[i][j] - mu, 2.) \
/ (2 * np.power(sig, 2.))))), 2)
cann_connector.append((i, j, weights[i][j]))#, delay_cann2cann))
print("Weight matrix:\n", weights)
spike_times = [1000., 2000.]
cann_pop = sim.Population(n, sim.IF_cond_alpha(**cell_params),
label = "cann_pop")
inhib_pop = sim.Population(1, sim.IF_cond_alpha(**cell_params),
label = "inhib_pop")
spike_source = sim.Population(1, sim.SpikeSourceArray(
spike_times = spike_times))
spike_2_conn = sim.Projection(spike_source, cann_pop[spiky:spiky+1], sim.AllToAllConnector(),
sim.StaticSynapse(weight = 0.002, delay = 0.1))
cann_2_cann = sim.Projection(cann_pop, cann_pop, sim.FromListConnector(cann_connector, column_names=["weight"]),
sim.StaticSynapse(weight = 0.0001, delay = 75))
cann_2_inh = sim.Projection(cann_pop, inhib_pop, sim.AllToAllConnector(),
sim.StaticSynapse(weight = 0.02, delay = 0.1),
receptor_type = "excitatory")
inh_2_cann = sim.Projection(inhib_pop, cann_pop, sim.AllToAllConnector(),
sim.StaticSynapse(weight = 0.2, delay = 0.1),
receptor_type = "inhibitory")
'v_thresh': v_th,
'v_reset': 0.0,
'v_rest': 0.0,
'e_rev_E': 10.0,
'e_rev_I': -10.0,
'i_offset': 0.0,
'cm': 0.1,
'tau_m': 0.8325,
'tau_syn_E': tau_syn,
'tau_syn_I': tau_syn,
'tau_refrac': 0.0
}
cellvalues = {'gsyn_exc': 0.0, 'v': 0.0, 'gsyn_inh': 0.0}
input_celltype = sim.SpikeSourceArray(spike_times=spike_times)
fc_celltype = sim.IF_cond_exp(**cellparams)
input_pop = sim.Population(34 * 34 * 2, input_celltype)
fc0 = sim.Population(w1.shape[0], fc_celltype)
fc0.initialize(**cellvalues)
fc0.set(v_thresh=vth0)
fc1 = sim.Population(w1.shape[0], fc_celltype)
fc1.initialize(**cellvalues)
fc1.set(v_thresh=vth1)
#fc1.set(i_offset=b1)
fc2 = sim.Population(10, fc_celltype)
fc2.initialize(**cellvalues)
fc2.set(v_thresh=vth2)
# variables names and values
n_neurons = 10
sim_time = 6000.0
# Build the network
sim.setup()
# spike source
#generate_spike_times = [[0], [500], [1000], [1500], [2000], [2500], [3000],
# [3500], [4000], [4500]] #, [5000]]
#spike_source = sim.Population(n_neurons,
# sim.SpikeSourceArray(
# spike_times = generate_spike_times))
spike_source = sim.Population(
n_neurons, sim.SpikeSourceArray(spike_times=[0, 1000, 3000]))
# populations and projections
layer_1 = sim.Population(n_neurons, sim.IF_curr_alpha(), label="layer_1")
'''
layer_2 = sim.Population(n_neurons, sim.IF_curr_alpha(),
label = "layer_2")
'''
proj_src_2_l1 = sim.Projection(spike_source, layer_1, sim.OneToOneConnector())
'''
proj_l1_2_l2 = sim.Projection(layer_1, layer_2,
sim.OneToOneConnector())
'''
sim.run(sim_time)
layer_1.record(('spikes', 'v'))
args.s2_prototype_cells)
print('Create C1 layers')
t1 = time.clock()
dumpfile = open(args.c1_dumpfile, 'rb')
ddict = pickle.load(dumpfile)
layer_collection['C1'] = {}
for size, layers_as_dicts in ddict.items():
layer_list = []
for layer_as_dict in layers_as_dicts:
n, m = layer_as_dict['shape']
spiketrains = layer_as_dict['segment'].spiketrains
dimensionless_sts = [[s for s in st] for st in spiketrains]
new_layer = nw.Layer(
sim.Population(n * m,
sim.SpikeSourceArray(spike_times=dimensionless_sts),
label=layer_as_dict['label']), (n, m))
layer_list.append(new_layer)
layer_collection['C1'][size] = layer_list
print('C1 creation took {} s'.format(time.clock() - t1))
print('Creating S2 layers')
t1 = time.clock()
layer_collection['S2'] = nw.create_S2_layers(layer_collection['C1'],
args.feature_size,
args.s2_prototype_cells,
refrac_s2=6)
print('S2 creation took {} s'.format(time.clock() - t1))
#for layers in layer_collection['C1'].values():
# for layer in layers:
#occurrence = re.search('\d+\.\d+blank', validation_dumpfile_name)
if occurrence is not None:
blanktime = float(occurrence.group()[:-5])
print('Create C1 layers')
t1 = time.clock()
training_ddict = pickle.load(open(args.training_c1_dumpfile, 'rb'))
validation_ddict = pickle.load(open(args.validation_c1_dumpfile, 'rb'))
layer_collection['C1'] = {}
for size, layers_as_dicts in training_ddict.items():
layer_list = []
for layer_as_dict in layers_as_dicts:
n, m = layer_as_dict['shape']
new_layer = nw.Layer(
sim.Population(n * m,
sim.SpikeSourceArray(),
label=layer_as_dict['label']), (n, m))
layer_list.append(new_layer)
layer_collection['C1'][size] = layer_list
print('C1 creation took {} s'.format(time.clock() - t1))
t1 = time.clock()
print('Creating S2 layers and reading the epoch weights')
epoch_weights_list = pickle.load(open(args.weights_from, 'rb'))
epoch = epoch_weights_list[-1][0]
weights_dict_list = epoch_weights_list[-1][1]
f_s = int(np.sqrt(list(weights_dict_list[0].values())[0].shape[0]))
s2_prototype_cells = len(weights_dict_list)
layer_collection['S2'] = nw.create_S2_layers(layer_collection['C1'],
f_s,
s2_prototype_cells,
refrac_s2=.1,
'v_reset': 0.0,
'v_rest': 0.0,
'e_rev_E': 10.0,
'e_rev_I': -10.0,
'i_offset': 0.0,
'cm': 0.001,
'tau_m': 0.8325,
'tau_syn_E': 0.01,
'tau_syn_I': 0.01,
'tau_refrac': 0.0
}
cellvalues = {'v': 0.0}
fc_celltype = sim.IF_cond_exp(**cellparams)
input_celltype = sim.SpikeSourceArray()
input_pop = sim.Population(34 * 34 * 2, input_celltype)
pops = [input_pop]
for layer in range(len(weights)):
inh_synapses = []
exc_synapses = []
for i in range(weights[layer].shape[1]):
for j in range(weights[layer].shape[0]):
if float(weights[layer][j, i]) < 0.0:
inh_synapses.append([i, j, -1.0 * weights[layer][j, i], delay])
else:
exc_synapses.append([i, j, weights[layer][j, i], delay])
pops.append(sim.Population(weights[layer].shape[0], fc_celltype))
hd_cann_pop = sim.Population(n, sim.IF_cond_alpha(**cell_params),
label = "hd_cann_pop")
inhib_pop = sim.Population(1, sim.IF_cond_alpha(**cell_params),
label = "inhib_pop")
#pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(),
label = "pos_rot_conj")
#neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(),
label = "neg_rot_conj")
hd_spike_src = sim.Population(1, sim.SpikeSourceArray(
spike_times = spike_times))
#spike_source_2 = sim.Population(1, sim.SpikeSourceArray(
# spike_times = spike_time_for_id_2))
#spike_source_3 = sim.Population(1, sim.SpikeSourceArray(
# spike_times = spike_time_for_id_3))
#spike_source_4 = sim.Population(1, sim.SpikeSourceArray(
# spike_times = spike_time_for_id_4))
#spike_source_9 = sim.Population(1, sim.SpikeSourceArray(
# spike_times = spike_time_for_id_9))
pos_spike_src = sim.Population(1, sim.SpikeSourceArray(
#spike_times = pos_spike_times))
spike_times = spike_input))
neg_spike_src = sim.Population(1, sim.SpikeSourceArray(
spike_times = neg_spike_times))
spikes_i = make_spikes(70,72,3)
# %%COBA
ge_vec, gi_vec, u_vec, s_vec = LIF_COBA(spikes_e=spikes_e, w=0.016)
# %%CUBA
I_vec, u_vec, s_vec = LIF_CUBA(spikes=spikes_e)
# %% PyNN CUBA
# Setup
sim.setup(timestep=0.1, min_delay=0.1, max_delay=10.0)
IF_sim = sim.Population(1, sim.IF_curr_exp(), label="IF_curr_exp")
IF_sim.record('v')
spike_times = np.arange(50,100,10)
spike_input = sim.Population(1,sim.SpikeSourceArray(spike_times=spike_times),label="Input spikes")
# Connections
w = 1
connections = sim.Projection(spike_input, IF_sim,
connector=sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=w,delay=0.1),
receptor_type="excitatory")
# Running simulation in MS
IF_sim.record('v')
sim.run(100.0)
# Data
v_data = IF_sim.get_data()
data = IF_sim.get_data().segments[0]
'v_reset': -70.0, # (mV)
'v_thresh': -60.0, # (mV)
'cm': 0.5
}
sim.setup()
neuron1 = sim.Population(n, sim.IF_cond_alpha(**cell_params), label="neuron1")
neuron2 = sim.Population(n, sim.IF_cond_alpha(**cell_params), label="neuron2")
generate_spike_times = [
0., 1020., 1040., 1060., 1080., 1100., 1120., 1140., 1160., 2000.
]
spike_source = sim.Population(
n, sim.SpikeSourceArray(spike_times=generate_spike_times))
conn = sim.Projection(spike_source, neuron1, sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.002, delay=1.))
n2n_conn = sim.Projection(neuron1, neuron2, sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=1.))
spike_source.record('spikes')
neuron1.record(('v', 'spikes'))
neuron2.record(('v', 'spikes'))
sim.run(5000.0)
#print neuron1.get_spike_counts()
from pyNN.utility.plotting import Figure, Panel
hd_cann_pop = sim.Population(n,
sim.IF_cond_alpha(**cell_params),
label="hd_cann_pop")
inhib_pop = sim.Population(1,
sim.IF_cond_alpha(**cell_params),
label="inhib_pop")
#pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(), label="pos_rot_conj")
#neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(), label="neg_rot_conj")
spike_source_1 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_1))
spike_source_2 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_2))
spike_source_3 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_3))
spike_source_4 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_4))
spike_source_9 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_9))
pos_spike_src = sim.Population(
1,
sim.SpikeSourceArray(
#spike_times = pos_spike_times))
spike_times=spikes_50))
neg_spike_src = sim.Population(
x1, dummy = positions_off[Ncells_lgn]
dummy, y1 = positions_off[1]
dx = x1 - x0
dy = y1 - y0
lx = x_end - x0
ly = y_end - y0
lgn_structure_off = space.Grid2D(aspect_ratio=1,
x0=x0,
y0=y0,
dx=dx,
dy=dy,
z=0)
# Spikes for LGN populations
lgn_spikes_on_model_0 = simulator.SpikeSourceArray(
spike_times=spike_times_on_0)
lgn_spikes_off_model_0 = simulator.SpikeSourceArray(
spike_times=spike_times_off_0)
lgn_spikes_on_model_1 = simulator.SpikeSourceArray(
spike_times=spike_times_on_1)
lgn_spikes_off_model_1 = simulator.SpikeSourceArray(
spike_times=spike_times_off_1)
lgn_spikes_on_model_2 = simulator.SpikeSourceArray(
spike_times=spike_times_on_2)
lgn_spikes_off_model_2 = simulator.SpikeSourceArray(
spike_times=spike_times_off_2)
lgn_spikes_on_model_3 = simulator.SpikeSourceArray(
spike_times=spike_times_on_3)
label="hd_cann_pop")
inhib_pop = sim.Population(n,
sim.IF_cond_alpha(**cell_params),
label="inhib_pop")
#pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(), label="pos_rot_conj")
#neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(), label="neg_rot_conj")
# Spike Sources
hd_spike_src = sim.Population(1,
sim.SpikeSourceArray(spike_times=hd_spike_times))
pos_spike_src = sim.Population(
1, sim.SpikeSourceArray(spike_times=pos_spike_times))
neg_spike_src = sim.Population(
1, sim.SpikeSourceArray(spike_times=neg_spike_times))
# Connections between spike sources and ppopulation
spike_2_hd = sim.Projection(hd_spike_src, hd_cann_pop[3:4],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
pos_spikes = sim.Projection(pos_spike_src, pos_rot_conj,
sim.AllToAllConnector(),
cann_connector.append((i, j, weights[i][j])) #, delay_cann2cann))
print("Weight matrix:\n", weights)
spike_time_for_id_3 = [1000.]
spike_time_for_id_6 = [3000., 3010., 3020.]
cann_pop = sim.Population(n,
sim.IF_cond_alpha(**cell_params),
label="cann_pop")
inhib_pop = sim.Population(1,
sim.IF_cond_alpha(**cell_params),
label="inhib_pop")
spike_source_3 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_3))
spike_source_6 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_6))
spike_2_conn_for_3 = sim.Projection(spike_source_3, cann_pop[3:4],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
spike_2_conn_for_6 = sim.Projection(spike_source_6, cann_pop[6:7],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
cann_2_cann = sim.Projection(
cann_pop, cann_pop,
sim.FromListConnector(cann_connector, column_names=["weight"]),
sim.StaticSynapse(weight=0.0001, delay=75))
spike_time_for_id_2 = [500., 505., 510., 515.]
spike_time_for_id_3 = [1200., 1205., 1210., 1215.]
spike_time_for_id_4 = [2000., 2005., 2010., 2015.]
spike_time_for_id_9 = [3000., 3005., 3010., 3015.]
#[3000., 3003., 3005., 3008., 3010., 3013., 3015., 3017., 3020.]
cann_pop = sim.Population(n,
sim.IF_cond_alpha(**cell_params),
label="cann_pop")
inhib_pop = sim.Population(1,
sim.IF_cond_alpha(**cell_params),
label="inhib_pop")
spike_source_1 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_1))
spike_source_2 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_2))
spike_source_3 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_3))
spike_source_4 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_4))
spike_source_9 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_9))
spike_2_conn_for_1 = sim.Projection(spike_source_1, cann_pop[1:2],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
spike_2_conn_for_2 = sim.Projection(spike_source_2, cann_pop[2:3],
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.002, delay=0.1))
spikes_off.append(cPickle.load(f2))
f2.close()
# Now we construct the functions that will pass the spikes to the cell model
def spike_times(simulator, layer, spikes_file):
return [simulator.Sequence(x) for x in spikes_file[layer]]
# Cells models for the LGN spikes (SpikeSourceArray)
lgn_spikes_on_models = []
lgn_spikes_off_models = []
for layer in xrange(N_lgn_layers):
model = simulator.SpikeSourceArray(
spike_times=spike_times(simulator, layer, spikes_on))
lgn_spikes_on_models.append(model)
model = simulator.SpikeSourceArray(
spike_times=spike_times(simulator, layer, spikes_off))
lgn_spikes_off_models.append(model)
# LGN Popluations
lgn_on_populations = []
lgn_off_populations = []
for layer in xrange(N_lgn_layers):
population = simulator.Population(Ncell_lgn,
lgn_spikes_on_models[layer],
label='LGN_on_layer_' + str(layer))
lgn_on_populations.append(population)
hd_cann_pop = sim.Population(n,
sim.IF_cond_alpha(**cell_params),
label="hd_cann_pop")
inhib_pop = sim.Population(1,
sim.IF_cond_alpha(**cell_params),
label="inhib_pop")
#pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
pos_rot_conj = sim.Population(n, sim.IF_cond_alpha(), label="pos_rot_conj")
#neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(**cell_params),
neg_rot_conj = sim.Population(n, sim.IF_cond_alpha(), label="neg_rot_conj")
spike_source_1 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_1))
spike_source_2 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_2))
spike_source_3 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_3))
spike_source_4 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_4))
spike_source_9 = sim.Population(
1, sim.SpikeSourceArray(spike_times=spike_time_for_id_9))
pos_spike_src = sim.Population(
1, sim.SpikeSourceArray(spike_times=pos_spike_times))
neg_spike_src = sim.Population(1, sim.SpikeSourceArray(spike_times=spikes_50))
#spike_2_conn_for_1 = sim.Projection(spike_source_1, hd_cann_pop[1:2], sim.OneToOneConnector(),
# sim.StaticSynapse(weight = 0.002, delay = 0.1))
