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):
sim.setup()
sim.Population(3, sim.SpikeSourceArray,
{"spike_times": [1.0, 2.0, 3.0]})
p2 = sim.Population(3, sim.SpikeSourceArray,
{"spike_times": [[10.0], [20.0], [30.0]]})
p3 = sim.Population(4, sim.IF_cond_exp, {})
sim.Projection(
p2, p3,
sim.FromListConnector([(0, 0, 0.1, 1.0), (1, 1, 0.1, 1.0),
(2, 2, 0.1, 1.0)]))
sim.run(100.0)
sim.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 inhibit_along_eyesight(network_topology):
for population_ids in network_topology:
# generate population id pairs from all populations lying along the projection axis
pairs = filter(
lambda x: x[0] != x[1],
it.product(population_ids[population_ids >= 0], repeat=2))
logger.debug(
"Generated inhibitory connection list for populations {}".
format(pairs))
for presynaptic, postsynaptic in pairs:
pyNN.Projection(
presynaptic_population=self._network['collectors']
[presynaptic],
postsynaptic_population=self._network['collectors']
[postsynaptic],
connector=pyNN.OneToOneConnector(
weights=self.params['synapse']['wCCi'],
delays=self.params['synapse']['dCCi']),
target='inhibitory')
def test_recording_poisson_spikes_rate_0(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
n_neurons = 256 # 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()
populations.append(
p.Population(n_neurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(n_neurons,
p.SpikeSourcePoisson, {'rate': 0},
label='inputSpikes_1'))
projections.append(
p.Projection(populations[1], populations[0],
p.OneToOneConnector()))
populations[1].record()
p.run(5000)
spikes = populations[1].getSpikes()
print spikes
p.end()
def depress_cores(self, w_range=[-2.0, -1.5], d_range=[2.0, 2.0]):
"""Connect depressing noise sources to variables populations.
args:
w_range: range for the random distribution of synaptic weights in the form [w_min, w_max].
d_range: range for the random distribution of synaptic delays in the form [d_min, d_max].
"""
print msg, 'connecting Poisson noise sources to neural populations for dissipation'
delays = RandomDistribution('uniform', d_range)
weights = RandomDistribution('uniform', w_range)
for depressor in range(self.d_populations):
for variable in range(self.variables_number):
if variable not in self.clues[0]:
synapses = p.Projection(
self.diss_pops[depressor][variable],
self.var_pops[variable],
p.OneToOneConnector(weights=weights, delays=delays),
target='inhibitory')
self.diss_conns.append(synapses)
self.diss_times += self.disss
def _apply_ordering_constraint(self):
"""
Implement the proposed by Christoph ordering constraint of inhibiting possible *mirror* matches.
For example: | |a|b|c| - | |1|2|3| --> (a,3), (b,2), (c,1) could be sometimes prevented if (b,2)
would inhibit (a,1) and (c,3) event types. These lie on the flipped diagonal of each population id.
Returns:
In-place method
"""
logger.info(
"Applying the ordering constraint on the temporal coincidence network."
)
# get all flipped diagonal population groups
all_mirrored_diags = [
self._network_topology[::-1, :].diagonal(i)
for i in xrange(-self.max_disparity - 1, self.max_disparity + 2)
]
valid_mirrored_diags = [
group for group in [d[d >= 0] for d in all_mirrored_diags]
if len(group) > 1
]
for mirrored_diag in valid_mirrored_diags:
for presynaptic, postsynaptic in pairs_of_neighbours(
mirrored_diag,
window_size=self.params['topology']['radius_ordering'] +
1):
pyNN.Projection(
presynaptic_population=self._network['collectors']
[presynaptic],
postsynaptic_population=self._network['collectors']
[postsynaptic],
connector=pyNN.OneToOneConnector(
weights=self.params['synapse']['wCCo'],
delays=self.params['synapse']['dCCo']),
target='inhibitory')
logger.debug(
"Applying the ordering constraint on the temporal coincidence network completed."
)
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
def do_run():
# this test ensures there is too much dtcm used up, thus crashes during
# initisation
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
input = p.Population(1024, p.SpikeSourcePoisson, {'rate': 10}, "input")
relay_on = p.Population(1024, p.IF_curr_exp, {}, "input")
t_rule_LGN = p.SpikePairRule(tau_plus=17, tau_minus=34)
w_rule_LGN = p.AdditiveWeightDependence(w_min=0.0,
w_max=0.3,
A_plus=0.01,
A_minus=0.0085)
stdp_model_LGN = p.STDPMechanism(timing_dependence=t_rule_LGN,
weight_dependence=w_rule_LGN)
s_d_LGN = p.SynapseDynamics(slow=stdp_model_LGN)
p.Projection(input,
relay_on,
p.OneToOneConnector(weights=1),
synapse_dynamics=s_d_LGN,
target='excitatory')
p.run(1000)
p.end()
def run_multiple_stdp_mechs_on_same_neuron(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
nNeurons = 200 # number of neurons in each population
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 = 2.0
delay = 1
connections = list()
for i in range(0, nNeurons):
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike,
delay)
connections.append(singleConnection)
# Plastic Connection between pre_pop and post_pop
stdp_model1 = p.STDPMechanism(
timing_dependence=p.SpikePairRule(tau_plus=16.7, tau_minus=33.7),
weight_dependence=p.AdditiveWeightDependence(w_min=0.0,
w_max=1.0,
A_plus=0.005,
A_minus=0.005),
)
# Plastic Connection between pre_pop and post_pop
stdp_model2 = p.STDPMechanism(
timing_dependence=p.SpikePairRule(tau_plus=16.7, tau_minus=33.7),
weight_dependence=p.AdditiveWeightDependence(w_min=0.0,
w_max=1.0,
A_plus=0.005,
A_minus=0.005),
)
# Plastic Connection between pre_pop and post_pop
stdp_model3 = p.STDPMechanism(
timing_dependence=p.SpikePairRule(tau_plus=16.7, tau_minus=33.7),
weight_dependence=p.MultiplicativeWeightDependence(w_min=0.0,
w_max=1.0,
A_plus=0.005,
A_minus=0.005),
)
injectionConnection = [(0, 0, weight_to_spike, 1)]
spikeArray1 = {'spike_times': [[0]]}
spikeArray2 = {'spike_times': [[25]]}
spikeArray3 = {'spike_times': [[50]]}
spikeArray4 = {'spike_times': [[75]]}
spikeArray5 = {'spike_times': [[100]]}
spikeArray6 = {'spike_times': [[125]]}
spikeArray7 = {'spike_times': [[150]]}
spikeArray8 = {'spike_times': [[175]]}
populations.append(
p.Population(nNeurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray1,
label='inputSpikes_1'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray2,
label='inputSpikes_2'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray3,
label='inputSpikes_3'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray4,
label='inputSpikes_4'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray5,
label='inputSpikes_5'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray6,
label='inputSpikes_6'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray7,
label='inputSpikes_7'))
populations.append(
p.Population(1,
p.SpikeSourceArray,
spikeArray8,
label='inputSpikes_8'))
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(connections)))
pop = p.Projection(populations[1], populations[0],
p.FromListConnector(injectionConnection))
projections.append(pop)
synapse_dynamics = p.SynapseDynamics(slow=stdp_model1)
pop = p.Projection(populations[2],
populations[0],
p.FromListConnector(injectionConnection),
synapse_dynamics=synapse_dynamics)
projections.append(pop)
# This is expected to raise a SynapticConfigurationException
synapse_dynamics = p.SynapseDynamics(slow=stdp_model2)
pop = p.Projection(populations[3],
populations[0],
p.FromListConnector(injectionConnection),
synapse_dynamics=synapse_dynamics)
projections.append(pop)
synapse_dynamics = p.SynapseDynamics(slow=stdp_model3)
pop = p.Projection(populations[4],
populations[0],
p.FromListConnector(injectionConnection),
synapse_dynamics=synapse_dynamics)
projections.append(pop)
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))
if test_exc:
target = sim.Population(num_exc, cell, exc_params, label='Target (EXC)')
else:
target = sim.Population(num_exc, cell, inh_params, label='Target (INH)')
source.record()
target.record()
target.record_v()
########################################################################
# P R O J E C T I O N S
########################################################################
src_to_tgt = sim.Projection(source,
target,
sim.OneToOneConnector(weights=w2s,
generate_on_machine=True),
target='excitatory')
########################################################################
# R U N S I M U L A T I O N
########################################################################
sim.run(sim_time)
spikes = {
'target': target.getSpikes(compatible_output=True),
'source': source.getSpikes(compatible_output=True),
}
voltage = target.get_v()
sim.end()
f_peak=f_peak)
source_pop = sim.Population(N_layer,
sim.SpikeSourcePoisson, {
'rate': rates.ravel(),
'start': 0,
'duration': simtime
},
label="Poisson spike source")
ff_prob_conn = [(i, j, g_max, args.delay) for i in range(N_layer)
for j in range(N_layer) if np.random.rand() < .05]
ff_projection = sim.Projection(
source_pop,
target_pop,
# sim.FixedProbabilityConnector(p_connect=.1, weights=g_max),
sim.FromListConnector(ff_prob_conn),
synapse_dynamics=sim.SynapseDynamics(slow=structure_model_w_stdp),
label="plastic_ff_projection")
if args.record_source:
source_pop.record()
target_pop.record()
# Run simulation
pre_spikes = []
post_spikes = []
pre_weights = []
post_weights = []
# },
# label="Variable-rate Poisson spike source # " +
# str(number))
# )
# Neuron populations
target_column.append(
sim.Population(N_layer,
model,
cell_params,
label="TARGET_POP # " + str(number)))
ff_connections.append(
sim.Projection(source_column[0],
target_column[number],
sim.FromListConnector(init_ff_connections),
synapse_dynamics=sim.SynapseDynamics(
slow=structure_model_w_stdp),
label="plastic_ff_projection"))
if args.case != CASE_CORR_NO_REW:
lat_connections.append(
sim.Projection(target_column[number],
target_column[number],
sim.FromListConnector(init_lat_connections),
synapse_dynamics=sim.SynapseDynamics(
slow=structure_model_w_stdp),
label="plastic_lat_projection",
target="inhibitory"
if args.lateral_inhibition else "excitatory"))
else:
# Testing mode is activated.
def do_run(
self, n_neurons, time_step=1, max_delay=144.0,
input_class=SpikeSourceArray, spike_times=None, rate=None,
start_time=None, duration=None, spike_times_list=None,
placement_constraint=None, weight_to_spike=2.0, delay=17,
neurons_per_core=10, cell_class=IF_curr_exp, constraint=None,
cell_params=CELL_PARAMS_LIF, run_times=None, reset=False,
extract_between_runs=True, set_between_runs=None, new_pop=False,
record_input_spikes=False, record=True, get_spikes=None,
spike_path=None, record_v=True, get_v=None, v_path=None,
record_gsyn=True, get_gsyn=None, gsyn_path=None,
use_spike_connections=True, use_wrap_around_connections=True,
get_weights=False, get_delays=False,
end_before_print=False, randomise_v_init=False):
"""
:param n_neurons: Number of Neurons in chain
:type n_neurons: int
:param time_step: time step value to be used in p.setup
:type time_step: float
:param max_delay: max_delay value to be used in p.setup
:type max_delay: float
:param rate: the rate of the SSP to fire at
:type rate: float
:param start_time: the start time for the SSP
:type start_time: float
:param duration: the length of time for the SSP to fire for
:type duration: float
:param input_class: the class for inputs spikes (SSA or SSP)
:type input_class: SpikeSourceArray, SpikeSourcePoisson
:param spike_times: times the SSA sends in spikes
:type spike_times: matrix of int times the SSA sends in spikes
:param spike_times_list: list of times the SSA sends in spikes
- must be the same length as run times
- If set the spike_time parameter is ignored
:type spike_times_list: list of matrix of
int times the SSA sends in spikes
:param placement_constraint: x, y and p values to add a
placement_constraint to population[0]
:type (int, int, int)
:type weight_to_spike: float
:param delay: time delay in the single connectors in the spike chain
:type delay: float
:param neurons_per_core: Number of neurons per core.
If set to None no set_number_of_neurons_per_core call will be made
:type neurons_per_core: int or None
:param constraint: A Constraint to be place on populations[0]
:type constraint: AbstractConstraint
:param cell_class: class to be used for the main population
Not used by any test at the moment
:type cell_class: AbstractPopulationVertex
:param cell_params: values for the main population
Not used by any test at the moment
Note: the values must match what is expected by the cellclass
:type cell_params: dict
:param run_times: times for each run.
A zero will skip run but trigger reset and get date ext as set
:type run_times: list of int
:param reset: if True will call reset after each run except the last
:type reset: bool
:param extract_between_runs: If True reads V, gysn and spikes
between each run.
:type extract_between_runs: bool
:param set_between_runs set instuctions to be carried out between runs.
Should be a list of tuples.
First element of each tuple is 0 or 1
0 for main population
1 for input polulation
Second element a String for name of peroperty to change
Third element the new value
:type set_between_runs: List[(int, String, any)]
:param new_pop: If True will add a new population before the second run
:type new_pop: bool
:param record_input_spikes: check for recording input spikes
:type record_input_spikes: bool
:param record: If True will aks for spikes to be recorded
:type record: bool
:param get_spikes: If set overrides the normal behaviour
of getting spikes if and only if record is True.
If left None the value of record is used.
:type get_spikes: bool
:param spike_path: The path to print(write) the last spike data too
:type spike_path: str or None
:param record_v: If True will aks for voltage to be recorded
:type record_v: bool
:param get_v: If set overrides the normal behaviour
of getting v if and only if record_v is True.
If left None the value of record_v is used.
:type get_v: bool
:param v_path: The path to print(write) the last v data too
:type v_path: str or None
:param record_gsyn: If True will aks for gsyn to be recorded
:type record_gsyn: bool
:param get_gsyn: If set overrides the normal behaviour
of getting gsyn if and only if record_gsyn is True.
If left None the value of record_gsyn is used.
:type get_v: bool
:param gsyn_path: The path to print(write) the last gsyn data too
:type gsyn_path: str or None
:param get_weights: If True weights will be gotten
:type get_weights: bool
:param get_delays: If True delays will be gotten
:type get_delays: bool
:param end_before_print: If True will call end() before running the \
optional print commands.
Note: end will always be called twice even if no print path
provided
WARNING: This is expected to cause an Exception \
if spike_path, v_path or gsyn_path provided
:type end_before_print: bool
:param randomise_v_init: randomises the v_init of the output pop.
:type randomise_v_init: bool
:param use_spike_connections: Will put the spike connections in
:type use_spike_connections: bool
:param use_wrap_around_connections: Will also put in a connector from
the last spike neuron back to the first
Note: Has no effect if use_spike_connections == False
:type use_wrap_around_connections: bool
"""
self._recorded_v = []
self._recorded_spikes = []
self._recorded_gsyn = []
self._input_spikes_recorded = []
self._weights = []
self._delays = []
if run_times is None:
run_times = [1000]
if set_between_runs is None:
set_between_runs = []
if len(set_between_runs) > 0 and len(run_times) != 2:
raise Exception("set_between_runs requires exactly 2 run times")
if spike_times is None:
spike_times = [[0]]
if get_spikes is None:
get_spikes = record
if get_v is None:
get_v = record_v
if get_gsyn is None:
get_gsyn = record_gsyn
p.setup(timestep=time_step, min_delay=1.0, max_delay=max_delay)
if neurons_per_core is not None:
p.set_number_of_neurons_per_core("IF_curr_exp", neurons_per_core)
populations = list()
projections = list()
loop_connections = list()
if use_wrap_around_connections:
for i in range(0, n_neurons):
single_connection = \
(i, ((i + 1) % n_neurons), weight_to_spike, delay)
loop_connections.append(single_connection)
else:
for i in range(0, n_neurons - 1):
single_connection = (i, i + 1, weight_to_spike, delay)
loop_connections.append(single_connection)
injection_connection = [(0, 0, weight_to_spike, 1)]
run_count = 0
if spike_times_list is None:
spike_array = {'spike_times': spike_times}
else:
spike_array = {'spike_times': spike_times_list[run_count]}
populations.append(p.Population(
n_neurons, cell_class, cell_params, label='pop_1'))
if placement_constraint is not None:
if len(placement_constraint) == 2:
(x, y) = placement_constraint
populations[0].add_placement_constraint(x=x, y=y)
else:
(x, y, proc) = placement_constraint
populations[0].add_placement_constraint(x=x, y=y, p=proc)
if randomise_v_init:
rng = p.NumpyRNG(seed=28375)
v_init = p.RandomDistribution('uniform', [-60, -40], rng)
populations[0].randomInit(v_init)
if constraint is not None:
populations[0].set_constraint(constraint)
if input_class == SpikeSourceArray:
populations.append(p.Population(
1, input_class, spike_array, label='inputSSA_1'))
else:
populations.append(p.Population(
1, input_class,
{'rate': rate, 'start': start_time, 'duration': duration},
label='inputSSP_1'))
# handle projections
if use_spike_connections:
projections.append(p.Projection(populations[0], populations[0],
p.FromListConnector(loop_connections)))
projections.append(p.Projection(populations[1], populations[0],
p.FromListConnector(injection_connection)))
# handle recording
if record or spike_path is not None:
populations[0].record()
if record_v or v_path is not None:
populations[0].record_v()
if record_gsyn or gsyn_path is not None:
populations[0].record_gsyn()
if record_input_spikes:
populations[1].record()
results = ()
for runtime in run_times[:-1]:
# This looks strange but is to allow getting data before run
if runtime > 0:
p.run(runtime)
run_count += 1
if extract_between_runs:
self._get_data(
populations[0], populations[1], get_spikes, get_v,
get_gsyn, record_input_spikes)
if get_weights:
self._weights.append(projections[0].getWeights())
if get_delays:
self._delays.append(projections[0].getDelays())
if new_pop:
populations.append(
p.Population(n_neurons, cell_class, cell_params,
label='pop_2'))
injection_connection = [(n_neurons - 1, 0, weight_to_spike, 1)]
new_projection = p.Projection(
populations[0], populations[2],
p.FromListConnector(injection_connection))
projections.append(new_projection)
if spike_times_list is not None:
populations[1].tset("spike_times", spike_times_list[run_count])
for (pop, name, value) in set_between_runs:
if pop == 0:
populations[0].set(name, value)
else:
populations[1].set(name, value)
if reset:
p.reset()
p.run(run_times[-1])
self._get_data(
populations[0], populations[1], get_spikes, get_v, get_gsyn,
record_input_spikes)
if get_weights:
self._weights.append(projections[0].getWeights())
if get_delays:
self._delays.append(projections[0].getDelays())
if end_before_print:
if v_path is not None or spike_path is not None or \
gsyn_path is not None:
print "NOTICE! end is being called before print.. commands " \
"which could cause an exception"
p.end()
if v_path is not None:
populations[0].print_v(v_path)
if spike_path is not None:
populations[0].printSpikes(spike_path)
if gsyn_path is not None:
populations[0].print_gsyn(gsyn_path)
p.end()
return results
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])
payload_as_time_stamps=False,
use_payload_prefix=False)
# populations.append(Population(nNeurons,
# IF_curr_exp, cell_params_lif,
# label='pop_%d' % i))
pop_external = p.Population(nNeurons,
p.external_devices.SpikeInjector,
cell_params_ext_dev,
label='Babel_Dummy')
populations.append(
p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_%d' % 1))
projections.append(
p.Projection(pop_external, populations[1],
p.OneToOneConnector(weights=weight_to_spike, delays=10)))
# populations[0].record_v()
# at the moment is only possible to observe one population per core
populations[1].record_v()
for pop in populations:
pop.record(to_file=False) # sends spike to the Monitoring application
# populations[i].record_variable('rate', save_to='eth')
# sends spike to the Monitoring application
p.run(10000)
# retrieving spike results and plotting...
lateral_inhibition=args.lateral_inhibition,
random_partner=args.random_partner,
p_elim_dep=p_elim_dep,
p_elim_pot=p_elim_pot,
sigma_form_forward=sigma_form_forward,
sigma_form_lateral=sigma_form_lateral,
p_form_forward=p_form_forward,
p_form_lateral=p_form_lateral)
elif case == CASE_CORR_NO_REW:
structure_model_w_stdp = stdp_model
# structure_model_w_stdp = sim.StructuralMechanism(weight=g_max, s_max=s_max)
ff_projection = sim.Projection(
source_pop,
target_pop,
sim.FromListConnector(init_ff_connections),
synapse_dynamics=sim.SynapseDynamics(slow=structure_model_w_stdp),
label="plastic_ff_projection")
lat_projection = sim.Projection(
target_pop,
target_pop,
sim.FromListConnector(init_lat_connections),
synapse_dynamics=sim.SynapseDynamics(slow=structure_model_w_stdp),
label="plastic_lat_projection",
target="inhibitory" if args.lateral_inhibition else "excitatory")
# +-------------------------------------------------------------------+
# | Simulation and results |
# +-------------------------------------------------------------------+
def do_run(nNeurons):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
p.set_number_of_neurons_per_core("IF_curr_exp", nNeurons / 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
}
p.set_number_of_neurons_per_core("IF_cond_exp", nNeurons / 2)
cell_params_cond = {
'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,
'e_rev_E': 0.,
'e_rev_I': -80.
}
p.set_number_of_neurons_per_core("IZK_curr_exp", 100)
cell_params_izk = {
'a': 0.02,
'b': 0.2,
'c': -65,
'd': 8,
'v_init': -75,
'u_init': 0,
'tau_syn_E': 2,
'tau_syn_I': 2,
'i_offset': 0
}
populations = list()
projections = list()
current_weight_to_spike = 2.0
cond_weight_to_spike = 0.035
delay = 17
# different strangths of connection
curr_injection_connection = [(0, 0, current_weight_to_spike, delay)]
cond_injection_connection = [(0, 0, cond_weight_to_spike, delay)]
izk_injection_connection = [(0, 0, current_weight_to_spike, delay)]
sinkConnection = [(0, 0, 0, 1)]
# spike time
spikeArray = {'spike_times': [[0]]}
# curr set up
populations.append(
p.Population(nNeurons,
p.IF_cond_exp,
cell_params_cond,
label='pop_cond'))
# cond setup
populations.append(
p.Population(nNeurons,
p.IF_curr_exp,
cell_params_lif,
label='pop_curr'))
# izk setup
populations.append(
p.Population(nNeurons,
p.IZK_curr_exp,
cell_params_izk,
label='izk pop'))
# sink pop for spikes to go to (otherwise they are not recorded as firing)
populations.append(
p.Population(nNeurons,
p.IF_curr_exp,
cell_params_lif,
label='sink_pop'))
populations.append(
p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpike'))
pop = p.Projection(populations[4], populations[0],
p.FromListConnector(cond_injection_connection))
projections.append(pop)
pop = p.Projection(populations[4], populations[1],
p.FromListConnector(curr_injection_connection))
projections.append(pop)
pop = p.Projection(populations[4], populations[2],
p.FromListConnector(izk_injection_connection))
projections.append(pop)
projections.append(
p.Projection(populations[2], populations[3],
p.FromListConnector(sinkConnection)))
projections.append(
p.Projection(populations[1], populations[3],
p.FromListConnector(sinkConnection)))
projections.append(
p.Projection(populations[0], populations[3],
p.FromListConnector(sinkConnection)))
# record stuff for cond
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
# record stuff for curr
populations[1].record_v()
populations[1].record_gsyn()
populations[1].record()
# record stuff for izk
populations[2].record_v()
populations[2].record_gsyn()
populations[2].record()
p.run(500)
# get cond
cond_v = populations[0].get_v(compatible_output=True)
cond_gsyn = populations[0].get_gsyn(compatible_output=True)
cond_spikes = populations[0].getSpikes(compatible_output=True)
# get curr
curr_v = populations[1].get_v(compatible_output=True)
curr_gsyn = populations[1].get_gsyn(compatible_output=True)
curr_spikes = populations[1].getSpikes(compatible_output=True)
# get izk
izk_v = populations[2].get_v(compatible_output=True)
izk_gsyn = populations[2].get_gsyn(compatible_output=True)
izk_spikes = populations[2].getSpikes(compatible_output=True)
p.end()
return (cond_v, cond_gsyn, cond_spikes, curr_v, curr_gsyn, curr_spikes,
izk_v, izk_gsyn, izk_spikes)
delays.append(float(delay))
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay)
connections.append(singleConnection)
injectionConnection = [(0, 0, weight_to_spike, 1)]
spikeArray = {'spike_times': [[0]]}
populations.append(
p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1'))
populations.append(
p.Population(1, p.SpikeSourceArray, spikeArray, label='inputSpikes_1'))
# populations[0].set_mapping_constraint({"x": 1, "y": 0})
projections.append(
p.Projection(populations[0], populations[0],
p.FromListConnector(connections)))
projections.append(
p.Projection(populations[1], populations[0],
p.FromListConnector(injectionConnection)))
populations[0].record()
p.external_devices.activate_live_output_for(populations[0])
populations[0].set_constraint(p.ChipAndCoreConstraint(0, 0, 2))
populations[1].set_constraint(p.ChipAndCoreConstraint(0, 0, 3))
run_time = 1000
print "Running for {} ms".format(run_time)
p.run(run_time)
v = None
gsyn = None
def _apply_continuity_constraint(self):
"""
Implement the David Marr's continuity constraint which encourages the spiking of disparity sensitive neurons
which lie in the same disparity map. This is backed by the assumption that physical object are coherent
and disparity does not change by much (if at all).
Returns:
In-place method
"""
logger.info(
"Applying the continuity constraint on the temporal coincidence network."
)
logger.warning(
"The current implementation supports only cross-like connection patterns, "
"i.e. a neuron will excite only neurons to the left, right, top and bottom. "
)
if self.params['topology']['radius_continuity'] > self.retina_n_cols:
new_radius = 1
logger.warning(
"Radius of excitation is too big. Setting radius to {}".format(
new_radius))
self.params['topology']['radius_continuity'] = new_radius
logger.debug("Same-disparity population ids: {}".format(
list(self._same_disparity_populations)))
# iterate over population or neural ids and construct pairs from neighbouring units
for population_ids in self._same_disparity_populations:
for presynaptic, postsynaptic in pairs_of_neighbours(
population_ids,
window_size=self.params['topology']['radius_continuity'] +
1,
add_reciprocal=True):
pyNN.Projection(
presynaptic_population=self._network['collectors']
[presynaptic],
postsynaptic_population=self._network['collectors']
[postsynaptic],
connector=pyNN.OneToOneConnector(
weights=self.params['synapse']['wCCe'],
delays=self.params['synapse']['dCCe']),
target='excitatory')
# construct vertical connections within each neural population
within_population_neuron_pairs = pairs_of_neighbours(
range(self.retina_n_rows),
window_size=self.params['topology']['radius_continuity'] + 1,
add_reciprocal=True)
logger.debug("Within-population neuron pairs: {}".format(
within_population_neuron_pairs))
connection_list = [(src, dst, self.params['synapse']['wCCe'],
self.params['synapse']['dCCe'])
for src, dst in within_population_neuron_pairs]
if len(self._network['collectors']) > 1 and len(connection_list) > 0:
for population in self._network['collectors']:
pyNN.Projection(
presynaptic_population=population,
postsynaptic_population=population,
connector=pyNN.FromListConnector(connection_list),
target='excitatory')
logger.debug(
"Applying the continuity constraint on the temporal coincidence network completed."
)
def test_va_benchmark(self):
try:
simulator_name = 'spiNNaker'
timer = Timer()
# === Define parameters =========================================
rngseed = 98766987
parallel_safe = True
n = 1500 # number of cells
# number of excitatory cells:number of inhibitory cells
r_ei = 4.0
pconn = 0.02 # connection probability
dt = 0.1 # (ms) simulation timestep
tstop = 200 # (ms) simulaton duration
delay = 1
# Cell parameters
area = 20000. # (µm²)
tau_m = 20. # (ms)
cm = 1. # (µF/cm²)
g_leak = 5e-5 # (S/cm²)
e_leak = -49. # (mV)
v_thresh = -50. # (mV)
v_reset = -60. # (mV)
t_refrac = 5. # (ms) (clamped at v_reset)
# (mV) 'mean' membrane potential, for calculating CUBA weights
v_mean = -60.
tau_exc = 5. # (ms)
tau_inh = 10. # (ms)
# (nS) #Those weights should be similar to the COBA weights
g_exc = 0.27
# (nS) # but the delpolarising drift should be taken into account
g_inh = 4.5
e_rev_exc = 0. # (mV)
e_rev_inh = -80. # (mV)
# === Calculate derived parameters ===============================
area *= 1e-8 # convert to cm²
cm *= area * 1000 # convert to nF
r_m = 1e-6 / (g_leak * area) # membrane resistance in MΩ
assert tau_m == cm * r_m # just to check
# number of excitatory cells
n_exc = int(round((n * r_ei / (1 + r_ei))))
n_inh = n - n_exc # number of inhibitory cells
print n_exc, n_inh
celltype = p.IF_curr_exp
# (nA) weight of excitatory synapses
w_exc = 1e-3 * g_exc * (e_rev_exc - v_mean)
w_inh = 1e-3 * g_inh * (e_rev_inh - v_mean) # (nA)
assert w_exc > 0
assert w_inh < 0
# === Build the network ==========================================
p.setup(timestep=dt, min_delay=delay, max_delay=delay)
if simulator_name == 'spiNNaker':
# this will set 100 neurons per core
p.set_number_of_neurons_per_core('IF_curr_exp', 100)
# this will set 50 neurons per core
p.set_number_of_neurons_per_core('IF_cond_exp', 50)
node_id = 1
np = 1
host_name = socket.gethostname()
print "Host #%d is on %s" % (np, host_name)
cell_params = {
'tau_m': tau_m,
'tau_syn_E': tau_exc,
'tau_syn_I': tau_inh,
'v_rest': e_leak,
'v_reset': v_reset,
'v_thresh': v_thresh,
'cm': cm,
'tau_refrac': t_refrac,
'i_offset': 0
}
print cell_params
timer.start()
print "%s Creating cell populations..." % node_id
exc_cells = p.Population(n_exc,
celltype,
cell_params,
label="Excitatory_Cells")
inh_cells = p.Population(n_inh,
celltype,
cell_params,
label="Inhibitory_Cells")
p.NativeRNG(12345)
print "%s Initialising membrane potential to random values..." \
% node_id
rng = NumpyRNG(seed=rngseed, parallel_safe=parallel_safe)
uniform_distr = RandomDistribution('uniform', [v_reset, v_thresh],
rng=rng)
exc_cells.initialize('v', uniform_distr)
inh_cells.initialize('v', uniform_distr)
print "%s Connecting populations..." % node_id
exc_conn = p.FixedProbabilityConnector(pconn,
weights=w_exc,
delays=delay)
inh_conn = p.FixedProbabilityConnector(pconn,
weights=w_inh,
delays=delay)
connections = dict()
connections['e2e'] = p.Projection(exc_cells,
exc_cells,
exc_conn,
target='excitatory',
rng=rng)
connections['e2i'] = p.Projection(exc_cells,
inh_cells,
exc_conn,
target='excitatory',
rng=rng)
connections['i2e'] = p.Projection(inh_cells,
exc_cells,
inh_conn,
target='inhibitory',
rng=rng)
connections['i2i'] = p.Projection(inh_cells,
inh_cells,
inh_conn,
target='inhibitory',
rng=rng)
# === Setup recording ==============================
print "%s Setting up recording..." % node_id
exc_cells.record()
# === Run simulation ================================
print "%d Running simulation..." % node_id
print "timings: number of neurons:", n
print "timings: number of synapses:", n * n * pconn
p.run(tstop)
exc_spikes = exc_cells.getSpikes()
print len(exc_spikes)
current_file_path = os.path.dirname(os.path.abspath(__file__))
current_file_path = os.path.join(current_file_path, "spikes.data")
exc_cells.printSpikes(current_file_path)
pre_recorded_spikes = p.utility_calls.read_spikes_from_file(
current_file_path, 0, n_exc, 0, tstop)
for spike_element, read_element in zip(exc_spikes,
pre_recorded_spikes):
self.assertEqual(round(spike_element[0], 1),
round(read_element[0], 1))
self.assertEqual(round(spike_element[1], 1),
round(read_element[1], 1))
p.end()
# System intentional overload so may error
except SpinnmanTimeoutException as ex:
raise SkipTest(ex)
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)
oct_pop = sim.Population(oct_pop_size,
sim.IF_curr_exp,
D_stellate_parameters,
label="D_stellate_pop")
#create connectivity list for AN-->D_stellate_pop projections TODO:change this weight to depend on fan_in_d
an_oct_weight = 4 #100/fan_in_oct#0.3
an_oct_conns = []
for i in range(oct_pop_size):
for j in range(fan_in_oct):
an_index = i * fan_in_oct + j #i+j#
an_oct_conns.append((an_index, i, an_oct_weight, 1.))
#setup projection
an_d_proj = sim.Projection(AN_pop,
oct_pop,
sim.FromListConnector(an_oct_conns),
target="excitatory")
oct_pop.record('spikes')
oct_pop.record_v()
#AN_pop.record('spikes')
T_stellate_parameters_IZH = {
'a': 0.02, #Izhikevich
'b': 0.2,
'c': -65,
'd': 10,
# 'v_init': -75,
# 'u_init': 0,
'tau_syn_E': 3,
#'tau_syn_I': 10,
def apply_constraints(self,
kind="inhibitory",
w_range=[-0.2, -0.0],
d_range=[2.0, 2.0],
random_cons=False,
pAF=0.5):
"""Map constraints list to inhibitory or excitatory connections between neural populations.
The clues_inhibition class variable determines whether clues should receive inhibitory connections or not.
args:
kind: whether constraints are inhibitory or excitatory.
w_range: range for the random distribution of synaptic weights in the form [w_min, w_max].
d_range: range for the random distribution of synaptic delays in the form [d_min, d_max].
random_cons: whether constraints are randomly choosen to be inhibitory or excitatory with probability pAF.
pAF: probability of inhibitory connections, as a probability it should be between 0.0 and 1.0. It only works
when random_cons is True.
"""
delays = RandomDistribution('uniform', d_range)
weights = RandomDistribution('uniform', w_range) # 1.8 2.0 spin_system
if 'weight' in self.constraints[0]:
print msg, '''creating constraints between CSP variables with specified weights and randomly distributed
delays'''
else:
print msg, '''creating constraints between CSP variables with random and uniformelly distributed delays
and weights'''
for constraint in self.constraints:
source = constraint['source']
target = constraint['target']
if random_cons:
kind = np.random.choice(['inhibitory', 'excitatory'],
p=[pAF, 1 - pAF])
#TODO find a way of reducing the next two conditionals, they're equal except for conditioning on target...
#TODO ... being a clue.
if self.clues_inhibition:
connections = []
for n in range(self.size):
for m in range(self.size):
if 'weight' in constraint:
weight = constraint['weight']
else:
weight = weights.next()
connections.append(
(m, n, weight if m // self.core_size == n //
self.core_size else 0.0, delays.next()))
synapses = p.Projection(self.var_pops[source],
self.var_pops[target],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
if self.directed == False:
synapses = p.Projection(self.var_pops[target],
self.var_pops[source],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
elif target not in self.clues[0]:
connections = []
for n in range(self.size):
for m in range(self.size):
if 'weight' in constraint:
weight = constraint['weight']
else:
weight = weights.next()
connections.append(
(m, n, weight if m // self.core_size == n //
self.core_size else 0.0, delays.next()))
synapses = p.Projection(self.var_pops[source],
self.var_pops[target],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
if self.directed == False:
synapses = p.Projection(self.var_pops[target],
self.var_pops[source],
p.FromListConnector(connections,
safe=True),
target=kind)
self.constraint_conns.append(synapses)
def do_run():
# SpiNNaker setup
p.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)
# +-------------------------------------------------------------------+
# | General Parameters |
# +-------------------------------------------------------------------+
# Population parameters
model = p.IF_curr_exp
# model = sim.IF_cond_exp
"""
cell_params = {'i_offset' : .1, 'tau_refrac' : 3.0, 'v_rest' : -65.0,
'v_thresh' : -51.0, 'tau_syn_E' : 2.0,
'tau_syn_I': 5.0, 'v_reset' : -70.0}
"""
cell_params = {
'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
}
# Other simulation parameters
e_rate = 200
in_rate = 350
n_stim_test = 5
n_stim_pairing = 10
dur_stim = 20
pop_size = 40
ISI = 150.
start_test_pre_pairing = 200.
start_pairing = 1500.
start_test_post_pairing = 700.
simtime = start_pairing + start_test_post_pairing + \
ISI * (n_stim_pairing + n_stim_test) + 550. # let's make it 5000
# Initialisations of the different types of populations
IAddPre = []
IAddPost = []
# +-------------------------------------------------------------------+
# | Creation of neuron populations |
# +-------------------------------------------------------------------+
# Neuron populations
pre_pop = p.Population(pop_size, model, cell_params)
post_pop = p.Population(pop_size, model, cell_params)
# Test of the effect of activity of the pre_pop population on the post_pop
# population prior to the "pairing" protocol : only pre_pop is stimulated
for i in range(n_stim_test):
IAddPre.append(
p.Population(
pop_size, p.SpikeSourcePoisson, {
'rate': in_rate,
'start': start_test_pre_pairing + ISI * (i),
'duration': dur_stim
}))
# Pairing protocol : pre_pop and post_pop are stimulated with a 10 ms
# difference
for i in range(n_stim_pairing):
IAddPre.append(
p.Population(
pop_size, p.SpikeSourcePoisson, {
'rate': in_rate,
'start': start_pairing + ISI * (i),
'duration': dur_stim
}))
IAddPost.append(
p.Population(
pop_size, p.SpikeSourcePoisson, {
'rate': in_rate,
'start': start_pairing + ISI * (i) + 10.,
'duration': dur_stim
}))
# Test post pairing : only pre_pop is stimulated
# (and should trigger activity in Post)
for i in range(n_stim_test):
start = start_pairing + ISI * n_stim_pairing + \
start_test_post_pairing + ISI * i
IAddPre.append(
p.Population(pop_size, p.SpikeSourcePoisson, {
'rate': in_rate,
'start': start,
'duration': dur_stim
}))
# Noise inputs
INoisePre = p.Population(pop_size,
p.SpikeSourcePoisson, {
'rate': e_rate,
'start': 0,
'duration': simtime
},
label="expoisson")
params = {'rate': e_rate, 'start': 0, 'duration': simtime}
INoisePost = p.Population(pop_size,
p.SpikeSourcePoisson,
params,
label="expoisson")
# +-------------------------------------------------------------------+
# | Creation of connections |
# +-------------------------------------------------------------------+
# Connection parameters
JEE = 3.
# Connection type between noise poisson generator and
# excitatory populations
ee_connector = p.OneToOneConnector(weights=JEE * 0.05)
# Noise projections
p.Projection(INoisePre, pre_pop, ee_connector, target='excitatory')
p.Projection(INoisePost, post_pop, ee_connector, target='excitatory')
# Additional Inputs projections
for i in range(len(IAddPre)):
p.Projection(IAddPre[i], pre_pop, ee_connector, target='excitatory')
for i in range(len(IAddPost)):
p.Projection(IAddPost[i], post_pop, ee_connector, target='excitatory')
# Plastic Connections between pre_pop and post_pop
timing_dependence = p.SpikePairRule(tau_plus=20., tau_minus=50.0)
weight_dependence = p.AdditiveWeightDependence(w_min=0,
w_max=0.9,
A_plus=0.02,
A_minus=0.02)
stdp_model = p.STDPMechanism(timing_dependence=timing_dependence,
weight_dependence=weight_dependence)
plastic_projection = \
p.Projection(pre_pop, post_pop,
p.FixedProbabilityConnector(p_connect=0.5),
synapse_dynamics=p.SynapseDynamics(slow=stdp_model)
)
# +-------------------------------------------------------------------+
# | Simulation and results |
# +-------------------------------------------------------------------+
# Record neurons' potentials
pre_pop.record_v()
post_pop.record_v()
# Record spikes
pre_pop.record()
post_pop.record()
# Run simulation
p.run(simtime)
weights = plastic_projection.getWeights()
pre_spikes = pre_pop.getSpikes(compatible_output=True)
post_spikes = post_pop.getSpikes(compatible_output=True)
p.end()
return (weights, pre_spikes, post_spikes)
[i[2] for i in v_for_neuron])
p.setup(time_step)
input_pop = p.Population(1,
p.SpikeSourceArray, {"spike_times": spike_times},
label="input")
my_model_pop = p.Population(1,
MyModelCurrExp, {
"my_parameter": -70.0,
"i_offset": i_offset,
},
label="my_model_pop")
p.Projection(input_pop, my_model_pop, p.OneToOneConnector(weights=weight))
my_model_my_synapse_type_pop = p.Population(
1,
MyModelCurrMySynapseType, {
"my_parameter": -70.0,
"i_offset": i_offset,
"my_ex_synapse_parameter": 0.5
},
label="my_model_my_synapse_type_pop")
p.Projection(input_pop, my_model_my_synapse_type_pop,
p.OneToOneConnector(weights=weight))
my_model_my_additional_input_pop = p.Population(
1,
MyModelCurrExpMyAdditionalInput, {
# # FPGA Retina - Up Polarity
# retina_pop = p.Population(
# None, q.ExternalFPGARetinaDevice, get_updated_params({
# 'retina_key': 0x5,
# 'mode': q.ExternalFPGARetinaDevice.MODE_128,
# 'polarity': q.ExternalFPGARetinaDevice.UP_POLARITY}),
# label='External retina')
# FPGA Retina - Down Polarity
retina_pop = p.Population(
None,
p.external_devices.ExternalFPGARetinaDevice,
get_updated_params({
'retina_key':
0x5,
'mode':
p.external_devices.ExternalFPGARetinaDevice.MODE_128,
'polarity':
p.external_devices.ExternalFPGARetinaDevice.DOWN_POLARITY
}),
label='External retina')
population = p.Population(1024, p.IF_curr_exp, {}, label='pop_1')
p.Projection(
retina_pop, population,
p.FromListConnector(retina_lib.subSamplerConnector2D(128, 32, 2.0, 1)))
# q.activate_live_output_for(population)
p.run(100)
p.end()
def do_run(nNeurons):
p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0)
p.set_number_of_neurons_per_core("IF_curr_exp", 100)
cm = list()
i_off = list()
tau_m = list()
tau_re = list()
tau_syn_e = list()
tau_syn_i = list()
v_reset = list()
v_rest = list()
v_thresh = list()
cell_params_lif = {'cm': cm, 'i_offset': i_off, 'tau_m': tau_m,
'tau_refrac': tau_re, 'tau_syn_E': tau_syn_e,
'tau_syn_I': tau_syn_i, 'v_reset': v_reset,
'v_rest': v_rest, 'v_thresh': v_thresh}
for atom in range(0, nNeurons):
cm.append(0.25)
i_off.append(0.0)
tau_m.append(10.0)
tau_re.append(2.0)
tau_syn_e.append(0.5)
tau_syn_i.append(0.5)
v_reset.append(-65.0)
v_rest.append(-65.0)
v_thresh.append(-64.4)
gbar_na_distr = RandomDistribution('normal', (20.0, 2.0),
rng=NumpyRNG(seed=85524))
cell_params_lif = {'cm': cm, 'i_offset': i_off, 'tau_m': tau_m,
'tau_refrac': tau_re, 'tau_syn_E': tau_syn_e,
'tau_syn_I': tau_syn_i, 'v_reset': v_reset,
'v_rest': v_rest, 'v_thresh': v_thresh}
populations = list()
projections = list()
weight_to_spike = 2
delay = 1
connections = list()
for i in range(0, nNeurons):
singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay)
connections.append(singleConnection)
injectionConnection = [(0, 0, weight_to_spike, delay)]
spikeArray = {'spike_times': [[0]]}
populations.append(p.Population(nNeurons, p.IF_curr_exp, cell_params_lif,
label='pop_1'))
populations.append(p.Population(1, p.SpikeSourceArray, spikeArray,
label='inputSpikes_1'))
populations[0].set({'cm': 0.25})
populations[0].set('cm', cm)
populations[0].set({'tau_m': tau_m, 'v_thresh': v_thresh})
populations[0].set('i_offset', gbar_na_distr)
populations[0].set('i_offset', i_off)
projections.append(p.Projection(populations[0], populations[0],
p.FromListConnector(connections)))
projections.append(p.Projection(populations[1], populations[0],
p.FromListConnector(injectionConnection)))
populations[0].record_v()
populations[0].record_gsyn()
populations[0].record()
p.run(100)
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)
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))
# Run simulation
