def do_run():
p.setup(timestep=1.0)
input_pop = p.Population(1,
p.SpikeSourceArray,
cellparams={"spike_times": [0]},
label="input")
cell_params_lif = {
'cm': 0.25, # nF
'i_offset': 0.0,
'tau_m': 20.0,
'tau_refrac': 2.0,
'tau_syn_E': 5.0,
'tau_syn_I': 5.0,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -50.0
}
pop = p.Population(2,
p.IF_curr_exp,
cellparams=cell_params_lif,
label="pop")
connections = list()
connections.append(
p.Projection(input_pop, pop,
p.AllToAllConnector(weights=[0.3, 1.0], delays=[1, 17])))
connections.append(
p.Projection(input_pop, pop,
p.AllToAllConnector(weights=[1.0, 0.7], delays=[2, 15])))
connections.append(
p.Projection(input_pop, pop,
p.AllToAllConnector(weights=[0.7, 0.3], delays=[3, 33])))
pre_weights = list()
pre_delays = list()
for connection in connections:
pre_weights.append(connection.getWeights())
pre_delays.append(connection.getDelays())
p.run(100)
post_weights = list()
post_delays = list()
for connection in connections:
post_weights.append(connection.getWeights())
post_delays.append(connection.getDelays())
p.end()
return (pre_weights, pre_delays, post_weights, post_delays)
def do_run(nNeurons):
p.setup(timestep=0.1, min_delay=1.0, max_delay=7.5)
p.set_number_of_neurons_per_core("IF_curr_exp", 100)
cell_params_lif = {
'cm': 0.25,
'i_offset': 0.0,
'tau_m': 10.0,
'tau_refrac': 2.0,
'tau_syn_E': 0.5,
'tau_syn_I': 0.5,
'v_reset': -65.0,
'v_rest': -65.0,
'v_thresh': -64.4
}
populations = list()
projections = list()
weight_to_spike = 0.5
injection_delay = 2
spikeArray = {'spike_times': [[0, 10, 20, 30]]}
populations.append(
p.Population(1, p.SpikeSourceArray, spikeArray, label='pop_0'))
populations.append(
p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1'))
populations.append(
p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_2'))
connector = p.AllToAllConnector(weights=weight_to_spike,
delays=injection_delay)
projections.append(p.Projection(populations[0], populations[1], connector))
connector = p.AllToAllConnector(weights=weight_to_spike,
delays=injection_delay)
projections.append(p.Projection(populations[1], populations[2], connector))
populations[2].record_v()
populations[2].record()
p.run(100)
v = populations[2].get_v(compatible_output=True)
spikes = populations[2].getSpikes(compatible_output=True)
p.end()
return (v, spikes)
def do_run():
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 900 # number of neurons in each population
cell_params_lif = {
'cm': 0.25, # nF
'i_offset': 0.0,
'tau_m': 20.0,
'tau_refrac': 2.0,
'tau_syn_E': 5.0,
'tau_syn_I': 5.0,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -50.0
}
populations = list()
projections = list()
weight_to_spike = 2.0
delay = 1
populations.append(
p.Population(n_neurons, p.IF_curr_exp, cell_params_lif, label='pop_1'))
populations.append(
p.Population(n_neurons, p.IF_curr_exp, cell_params_lif, label='pop_2'))
connectors = p.AllToAllConnector(weights=weight_to_spike, delays=delay)
projections.append(p.Projection(populations[0], populations[1],
connectors))
delays = []
weights = []
# before
delays.append(projections[0].getDelays())
weights.append(projections[0].getWeights())
p.run(100)
# after
delays.append(projections[0].getDelays())
weights.append(projections[0].getWeights())
p.end()
return (delays, weights)
def test_recording_1_element(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 200 # number of neurons in each population
p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)
cell_params_lif = {
'cm': 0.25,
'i_offset': 0.0,
'tau_m': 20.0,
'tau_refrac': 2.0,
'tau_syn_E': 5.0,
'tau_syn_I': 5.0,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -50.0
}
populations = list()
projections = list()
spike_array = {'spike_times': [[0]]}
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spike_array,
label='inputSpikes_1'))
projections.append(
p.Projection(populations[1], populations[0],
p.AllToAllConnector()))
populations[1].record()
p.run(5000)
spike_array_spikes = populations[1].getSpikes()
boxed_array = numpy.zeros(shape=(0, 2))
boxed_array = numpy.append(boxed_array, [[0, 0]], axis=0)
numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
p.end()
def test_run(self):
with LogCapture() as l:
p.setup()
p1 = p.Population(1, p.IF_curr_exp, {})
p2 = p.Population(1, p.IF_curr_exp, {})
proj = p.Projection(p1, p2, p.AllToAllConnector())
p.run(500)
proj.getWeights()
p.run(500)
proj.getWeights()
p.end()
self.assert_logs_messages(l.records, "Getting weights", 'INFO', 2)
def do_run(nNeurons):
cell_params_lif = {
'cm': 0.25, # nF
'i_offset': 0.0,
'tau_m': 10.0,
'tau_refrac': 2.0,
'tau_syn_E': 2.5,
'tau_syn_I': 2.5,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -55.4
}
spike_list = {'spike_times': [float(x) for x in range(0, 599, 50)]}
p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0)
p.set_number_of_neurons_per_core("SpikeSourceArray", 100) # FAILS
populations = list()
projections = list()
populations.append(
p.Population(nNeurons, p.SpikeSourceArray, spike_list, label='input'))
populations.append(
p.Population(1, p.IF_curr_exp, cell_params_lif, label='pop_1'))
projections.append(
p.Projection(populations[0], populations[1], p.AllToAllConnector()))
populations[0].record()
p.run(1000)
spikes = populations[0].getSpikes(compatible_output=True)
p.end()
return spikes
min_increment=1,
max_increment=max_increment_in)
#setup projections
an_t_proj = sim.Projection(AN_pop,
T_stellate_pop,
sim.FromListConnector(an_t_stellate_conns),
target="excitatory")
#t_t_proj_ex = sim.Projection(T_stellate_pop,T_stellate_pop,sim.FromListConnector(t_t_stellate_conns_ex),target="excitatory")
#t_t_proj_in = sim.Projection(T_stellate_pop,T_stellate_pop,sim.FromListConnector(t_t_stellate_conns_in),target="inhibitory")
#t_t_proj = sim.Projection(T_stellate_pop,T_stellate_pop,sim.DistanceDependentProbabilityConnector(d_expression="d<10"),target="excitatory")
#d_t_proj = sim.Projection(D_stellate_pop,T_stellate_pop,sim.FromListConnector(d_t_stellate_conns),target="inhibitory")
#d_t_proj = sim.Projection(D_stellate_pop,T_stellate_pop,sim.AllToAllConnector(weights=0.2,delays=1.0),target="inhibitory")
d_t_proj = sim.Projection(oct_pop,
T_stellate_pop,
sim.AllToAllConnector(weights=8., delays=1.0),
target="inhibitory")
#d_t_proj = sim.Projection(D_stellate_pop,T_stellate_pop,sim.AllToAllConnector(weights=8.,delays=1.0),target="inhibitory")
#Create primary like CN neuron population
Primary_like_parameters = {
#'tau_refrac': 0.8,
#'tau_syn_E': 0.25,
'tau_syn_E': 1.2,
'tau_syn_I': 0.1,
#'tau_m': 0.33
'tau_m': 1.
}
Primary_like_pop_size = AN_pop_size #-fan_in_t+1
Primary_like_pop = sim.Population(Primary_like_pop_size,
sim.IF_curr_exp,
def do_run(nNeurons, neurons_per_core):
p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0)
p.set_number_of_neurons_per_core("IF_curr_exp", neurons_per_core)
nPopulations = 62
cell_params_lif = {
'cm': 0.25,
'i_offset': 0.0,
'tau_m': 20.0,
'tau_refrac': 2.0,
'tau_syn_E': 5.0,
'tau_syn_I': 5.0,
'v_reset': -70.0,
'v_rest': -65.0,
'v_thresh': -50.0
}
populations = list()
projections = list()
weight_to_spike = 1.5
delay = 5
for i in range(0, nPopulations):
populations.append(
p.Population(nNeurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_' + str(i)))
# print "++++++++++++++++"
# print "Added population %s" % (i)
# print "o-o-o-o-o-o-o-o-"
for i in range(0, nPopulations):
projections.append(
p.Projection(populations[i],
populations[(i + 1) % nPopulations],
p.OneToOneConnector(weight_to_spike, delay),
label="Projection from pop {} to pop "
"{}".format(i, (i + 1) % nPopulations)))
# print "++++++++++++++++++++++++++++++++++++++++++++++++++++"
# print "Added projection from population %s to population %s" \
# % (i, (i + 1) % nPopulations)
# print "----------------------------------------------------"
# pp(projections)
spikeArray = {'spike_times': [[0]]}
populations.append(
p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1'))
projections.append(
p.Projection(populations[-1], populations[0],
p.AllToAllConnector(weight_to_spike, delay)))
for i in range(0, nPopulations):
populations[i].record_v()
populations[i].record_gsyn()
populations[i].record()
p.run(1500)
v = None
gsyn = None
spikes = None
''''
weights = projections[0].getWeights()
delays = projections[0].getDelays()
'''
v = populations[0].get_v(compatible_output=True)
gsyn = populations[0].get_gsyn(compatible_output=True)
spikes = populations[0].getSpikes(compatible_output=True)
p.end()
return (v, gsyn, spikes)
output = 100
p.setup(timestep=1.0)
p.set_number_of_neurons_per_core(p.IF_cond_exp, 100)
poisson_rate = {'rate': 15}
tracker = SummaryTracker()
tracker.print_diff()
input_pop = p.Population(input_size, p.IF_cond_exp, {}, label='input')
hidden_pop = p.Population(hidden_size, p.IF_cond_exp, {}, label='hidden')
output_pop = p.Population(output, p.IF_cond_exp, {}, label='output')
breakout = p.Population(1, spinn_breakout.Breakout, {}, label="breakout")
print "after populations"
tracker.print_diff()
a = p.Projection(input_pop, hidden_pop, p.AllToAllConnector(weights=0.5))
print "after i->h"
tracker.print_diff()
a = p.Projection(breakout, hidden_pop, p.AllToAllConnector(weights=0.5))
print "after b->h"
tracker.print_diff()
b = p.Projection(input_pop, output_pop, p.AllToAllConnector(weights=2))
print "after i->o"
tracker.print_diff()
c = p.Projection(hidden_pop, output_pop, p.AllToAllConnector(weights=2))
print "after h->o"
tracker.print_diff()
d = p.Projection(input_pop, input_pop, p.AllToAllConnector(weights=2))
print "after i->i"
tracker.print_diff()
a = p.Projection(input_pop, hidden_pop, p.AllToAllConnector(weights=2))
# Plastic Connection between pre_pop and post_pop
stdp_model = sim.STDPMechanism(
timing_dependence = TimingDependenceCerebellum(tau=tau, peak_time=peak_time),
weight_dependence = sim.AdditiveWeightDependence(w_min=1.0, w_max=15.0, A_plus=0.5, A_minus=0.01)
)
#stdp_model = sim.STDPMechanism(
# timing_dependence = sim.SpikePairRule(tau_plus=tau, tau_minus=tau),
# weight_dependence = sim.AdditiveWeightDependence(w_min=1.0, w_max=15.0, A_plus=0.1, A_minus=0.1)
#)
# Connections between spike sources and neuron populations
####### SET HERE THE PARALLEL FIBER-PURKINJE CELL LEARNING RULE
ee_connector = sim.AllToAllConnector(weights=1.0)
projection_pf = sim.Projection(pre_stim, population, ee_connector,
synapse_dynamics=sim.SynapseDynamics(slow=stdp_model),
target='excitatory')
proj2 = sim.Projection(pre_stim, population2, ee_connector,target='excitatory')
# SET HERE THE TEACHING SIGNAL PROJECTION
ee_connector = sim.OneToOneConnector(weights=0.0)
proj_teaching = sim.Projection(teaching_stim, population, ee_connector, target='supervision')
#proj_dummy = sim.Projection(dummy_stim,population,sim.OneToOneConnector(weights=1000.1), target='inhibitory')
#IPython.embed()
print("Simulating for %us" % (sim_time / 1000))
breakout_pop = p.Population(1, spinn_breakout.Breakout, {}, label="breakout")
ex.activate_live_output_for(breakout_pop, host="0.0.0.0", port=UDP_PORT1)
ex.activate_live_output_for(breakout_pop, host="0.0.0.0", port=UDP_PORT2)
# Create spike injector to send random spikes to the paddle
spike_array = [[0, 2, 4, 6, 8, 10], [1, 3, 5, 7, 9, 11]]
# Connect key spike injector to breakout population
# array_input = p.Population(2, p.SpikeSourceArray(spike_times=spike_array), label="input_connect")
# poisson = p.SpikeSourcePoisson(rate=20)
rate = {'rate': 2} #, 'duration': 10000000}
spike_input = p.Population(2,
p.SpikeSourcePoisson,
rate,
label="input_connect")
p.Projection(spike_input, breakout_pop, p.AllToAllConnector(weights=2))
# key_input_connection = SpynnakerLiveSpikesConnection(send_labels=["input_connect"])
# Create visualiser
# visualiser = Visualiser(
# UDP_PORT, None,
# x_res=X_RESOLUTION, y_res=Y_RESOLUTION,
# x_bits=X_BITS, y_bits=Y_BITS)
running = True
t = threading.Thread(target=thread_visualiser, args=(UDP_PORT1))
r = threading.Thread(target=thread_visualiser, args=(UDP_PORT1))
result = [0 for i in range(2)]
# t = ThreadPool(processes=2)
# r = ThreadPool(processes=2)
# result = t.apply_async(thread_visualiser, [UDP_PORT1])
def run_sim(num_pre, num_post, spike_times, run_time, weight=5.6, delay=40., gom=False,
conn_type='one2one', use_stdp=False, mad=False, prob=0.5):
model = p.IF_curr_exp
p.setup( timestep = 1.0, min_delay = 1.0, max_delay = 144.0 )
# if num_pre <= 10:
# p.set_number_of_neurons_per_core(model, 4)
# p.set_number_of_neurons_per_core(p.SpikeSourceArray, 5)
# elif 10 < num_pre <= 50:
# p.set_number_of_neurons_per_core(model, 20)
# p.set_number_of_neurons_per_core(p.SpikeSourceArray, 21)
# elif 50 < num_pre <= 100:
# p.set_number_of_neurons_per_core(model, 50)
# p.set_number_of_neurons_per_core(p.SpikeSourceArray, 51)
# else:
if use_stdp:
p.set_number_of_neurons_per_core(model, 150)
p.set_number_of_neurons_per_core(p.SpikeSourceArray, 2000)
cell_params_lif = { 'cm' : 1.0, # nF
'i_offset' : 0.00,
'tau_m' : 10.0,
'tau_refrac': 4.0,
'tau_syn_E' : 1.0,
'tau_syn_I' : 1.0,
'v_reset' : -70.0,
'v_rest' : -65.0,
'v_thresh' : -60.0
}
cell_params_pos = {
'spike_times': spike_times,
}
w2s = weight
dly = delay
rng = NumpyRNG( seed = 1 )
if use_stdp:
td = p.SpikePairRule(tau_minus=1., tau_plus=1.)
wd = p.AdditiveWeightDependence(w_min=0, w_max=20., A_plus=0.0, A_minus=0.0)
stdp = p.STDPMechanism(timing_dependence=td, weight_dependence=wd)
syn_dyn = p.SynapseDynamics(slow=stdp)
else:
syn_dyn = None
sink = p.Population( num_post, model, cell_params_lif, label='sink')
# sink1 = p.Population( nNeuronsPost, model, cell_params_lif, label='sink1')
source0 = p.Population( num_pre, p.SpikeSourceArray, cell_params_pos,
label='source_0')
# source1 = p.Population( nNeurons, p.SpikeSourceArray, cell_params_pos,
# label='source_1')
if conn_type == 'one2one':
conn = p.OneToOneConnector(weights=w2s, delays=dly, generate_on_machine=gom)
elif conn_type == 'all2all':
conn = p.AllToAllConnector(weights=w2s, delays=dly, generate_on_machine=gom)
elif conn_type == 'fixed_prob':
conn = p.FixedProbabilityConnector(prob, weights=w2s, delays=dly,
generate_on_machine=gom)
else:
raise Exception("Not a valid connector for test")
proj = p.Projection( source0, sink, conn, target='excitatory',
synapse_dynamics=syn_dyn,
label=' source 0 to sink - EXC - delayed')
# sink.record_v()
# sink.record_gsyn()
sink.record()
print("Running for {} ms".format(run_time))
t0 = time.time()
p.run(run_time)
time_to_run = time.time() - t0
v = None
gsyn = None
spikes = None
# v = np.array(sink.get_v(compatible_output=True))
# gsyn = sink.get_gsyn(compatible_output=True)
spikes = sink.getSpikes(compatible_output=True)
w = proj.getWeights(format='array')
p.end()
return v, gsyn, spikes, w, time_to_run
def test_agent(weight):
# Setup pyNN simulation
weight = weight / 100.
weight = weight * -1
print "da weight = ", weight
p.setup(timestep=1.0)
p.set_number_of_neurons_per_core(p.IF_cond_exp, 100)
receive_pop_size = 1
hidden_pop_size = 1
output_size = 1
# Create input population and connect break out to it
receive_on_pop = p.Population(receive_pop_size,
p.IF_cond_exp, {},
label="receive_pop")
# Create output population and remaining population
output_pop = p.Population(output_size,
p.IF_cond_exp, {},
label="output_pop")
hidden_node_pop = p.Population(hidden_pop_size,
p.IF_cond_exp, {},
label="hidden_pop")
hidden_node_pop.record()
receive_on_pop.record()
output_pop.record()
spikes_in = p.Population(1,
p.SpikeSourceArray, {'spike_times': [100]},
label='spike')
p.Projection(output_pop, receive_on_pop,
p.AllToAllConnector(weights=weight))
p.Projection(receive_on_pop, hidden_node_pop,
p.AllToAllConnector(weights=weight))
p.Projection(hidden_node_pop, output_pop,
p.AllToAllConnector(weights=weight))
p.Projection(spikes_in, receive_on_pop,
p.AllToAllConnector(weights=weight))
runtime = 1000
p.run(runtime)
pylab.figure()
spikes_on = receive_on_pop.getSpikes()
ax = pylab.subplot(1, 3, 1) #4, 1)
pylab.plot([i[1] for i in spikes_on], [i[0] for i in spikes_on], "r.")
pylab.xlabel("Time (ms)")
pylab.ylabel("neuron ID")
pylab.axis([0, runtime, -1, receive_pop_size + 1])
# pylab.show()
# pylab.figure()
spikes_on = hidden_node_pop.getSpikes()
ax = pylab.subplot(1, 3, 2) #4, 1)
pylab.plot([i[1] for i in spikes_on], [i[0] for i in spikes_on], "r.")
pylab.xlabel("Time (ms)")
pylab.ylabel("neuron ID")
pylab.axis([0, runtime, -1, hidden_pop_size + 1])
# pylab.show()
# pylab.figure()
spikes_on = output_pop.getSpikes()
ax = pylab.subplot(1, 3, 3) #4, 1)
pylab.plot([i[1] for i in spikes_on], [i[0] for i in spikes_on], "r.")
pylab.xlabel("Time (ms)")
pylab.ylabel("neuron ID")
pylab.axis([0, runtime, -1, output_size + 1])
pylab.show()
# End simulation
p.end()
# print(in_list,out_list)
proj_MoF_GrC.append(
sim.Projection(inpop, GrC_layer_pop[0], sim.FromListConnector(
connlist))) # Connect MoF current and set populations to GrC layer
## MoF to DCN
proj_MoF_DCN = []
scaled_weight_MoF_DCN = raw_weight_MoF_DCN / len(MoF_layer_pop)
for inpop in MoF_layer_pop:
for outpop in DCN_layer_pop:
proj_MoF_DCN.append(
sim.Projection(inpop,
outpop,
sim.AllToAllConnector(weights=scaled_weight_MoF_DCN,
delays=1.),
target="excitatory",
label="proj_" + inpop.label + "_" + outpop.label))
## PuC to DCN
proj_PuC_DCN = []
repeat_par = n_PuC / n_DCN # Should be 2, such that 2 PuC are mappend to 1 DCN
target_list = np.repeat(
range(n_PuC),
repeat_par).tolist() # Create target list by mapping 2 PuC to the same DCN
source_list = range(n_DCN)
#connlist_PuC_DCN=zip(source_list,target_list,[raw_weight_PuC_DCN]*n_PuC,[1.0]*n_DCN)
connlist_PuC_DCN = zip(source_list, target_list, [raw_weight_PuC_DCN] * n_PuC,
list(np.random.randint(0, 10, n_DCN)))
for inpop, outpop in zip(PuC_layer_pop, DCN_layer_pop):
