def do_run(self):
sim.setup(timestep=1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, neurons_per_core)
input_spikes = list(range(0, simtime - 50, 10))
input = sim.Population(1,
sim.SpikeSourceArray(spike_times=input_spikes),
label="input")
pop_1 = sim.Population(n_neurons, sim.IF_curr_exp(), label="pop_1")
sim.Projection(input,
pop_1,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
pop_1.record(["spikes", "v", "gsyn_exc"])
sim.run(simtime)
sim.reset()
pop_2 = sim.Population(n_neurons, sim.IF_curr_exp(), label="pop_2")
pop_2.record(["spikes", "v", "gsyn_exc"])
sim.Projection(input,
pop_2,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
sim.run(simtime)
self.check_data(pop_1, len(input_spikes), simtime, [0, 1])
self.check_data(pop_2, len(input_spikes), simtime, [1])
sim.end()
def do_run():
sim.setup(timestep=1)
pop_1 = sim.Population(1, sim.IF_curr_exp, {}, label="pop_1")
inp = sim.Population(
1, sim.SpikeSourceArray, {'spike_times': [[0]]}, label="input")
sim.Projection(
pop_1, pop_1, sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5.0, delay=1),
receptor_type="excitatory", source=None, space=None)
pop_1.record("spikes")
sim.run(20)
first_spikes = pop_1.spinnaker_get_data("spikes")
sim.Projection(
inp, pop_1, sim.FromListConnector([[0, 0, 5, 5]]),
synapse_type=sim.StaticSynapse(weight=5.0, delay=1),
receptor_type="excitatory", source=None,
space=None)
sim.reset()
sim.run(20)
second_spikes = pop_1.spinnaker_get_data("spikes")
return first_spikes, second_spikes
def do_run():
p.setup(timestep=1, min_delay=1, max_delay=15)
spiker = p.Population(1,
p.SpikeSourceArray(spike_times=[[0]]),
label='inputSSA_1')
if_pop = p.Population(2, p.IF_cond_exp(), label='pop_1')
if_pop.record("spikes")
if_pop.record("v")
p.Projection(spiker,
if_pop,
p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=5.0, delay=1),
receptor_type="excitatory",
source=None,
space=None)
p.run(30)
all1 = if_pop.get_data(["spikes", "v"])
p.reset()
p.run(30)
all2 = if_pop.get_data(["spikes", "v"])
p.end()
return (all1, all2)
def reset_set_with_v_set(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp, {}, label="pop")
inp = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(inp,
pop,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5))
pop.set(i_offset=1.0)
pop.set(tau_syn_E=1)
pop.initialize(v=-60)
pop.record(["v"])
sim.run(5)
v1 = pop.spinnaker_get_data('v')
try:
self.check_from_60(v1)
raise AssertionError("Unexpected after 60 voltage")
except AssertionError:
pass # That should have failed
pop.set(tau_syn_E=1)
sim.reset()
inp.set(spike_times=[100])
sim.run(5)
v2 = pop.spinnaker_get_data('v')
try:
self.check_from_65(v2)
except AssertionError:
self.known_issue(
"https://github.com/SpiNNakerManchester/sPyNNaker/issues/599")
sim.end()
def do_run(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp(i_offset=5.0), label="pop")
pop.record("spikes")
pop_2 = sim.Population(1, sim.IF_curr_exp(), label="pop_2")
proj = sim.Projection(
pop, pop_2, sim.AllToAllConnector(),
sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(),
weight_dependence=sim.AdditiveWeightDependence(),
weight=sim.RandomDistribution("uniform", low=0.3, high=0.7)))
proj_2 = sim.Projection(
pop, pop_2, sim.OneToOneConnector(),
sim.STDPMechanism(
timing_dependence=sim.SpikePairRule(),
weight_dependence=sim.AdditiveWeightDependence(),
weight=sim.RandomDistribution("uniform", low=0.3, high=0.7)))
sim.run(100)
weights_1_1 = proj.get("weight", "list")
weights_1_2 = proj_2.get("weight", "list")
spikes_1 = pop.get_data("spikes").segments[0].spiketrains
sim.reset()
sim.run(100)
weights_2_1 = proj.get("weight", "list")
weights_2_2 = proj_2.get("weight", "list")
spikes_2 = pop.get_data("spikes").segments[1].spiketrains
sim.end()
assert(numpy.array_equal(weights_1_1, weights_2_1))
assert(numpy.array_equal(weights_1_2, weights_2_2))
assert(numpy.array_equal(spikes_1, spikes_2))
def forward(self, input, timesteps=None):
# if timesteps not specified, set to default simulation time
if timesteps is None:
timesteps = self.simulation_time
# first reset the network
if self.backend == 'nest' or self.backend == 'pynn':
nest_sim.reset()
elif self.backend == 'spinnaker':
spin_sim.reset()
# set input generators to correct current
if self.add_bias_as_observation:
bias = torch.ones(1, dtype=torch.float)
input = torch.cat((input, bias), dim=0)
# set offsets to correct current
# save the original offsets/biases
bias = []
for i in range(0, len(self.layers[0])):
if self.backend == 'pynn' or self.backend == 'spinnaker':
offset = self.layers[0][i:i+1].get('i_offset')[0]
bias.append(offset)
# add the inputs multiplied by their respective weights to the constant input of the
# first hidden layer
for j in range(0, len(input)):
offset += input[j].detach().item()*self.weights[0][j][i].detach().item()
self.layers[0][i:i+1].set(i_offset=offset)
elif self.backend == 'nest':
offset = self.layers[0][i:i+1].get('I_e')
bias.append(offset)
# add the inputs multiplied by their respective weights to the constant input of the
# first hidden layer
for j in range(0, len(input)):
offset += input[j].detach().item()*self.weights[0][j][i].detach().item()
self.layers[0][i:i + 1].set(I_e=offset)
# simulate
if self.backend == 'nest' or self.backend == 'pynn':
nest_sim.run(timesteps)
elif self.backend == 'spinnaker':
spin_sim.run(timesteps)
potentials = self.layers[-1].get_data().segments[-1].analogsignals[0][-1]
# restore original bias in the offset
for i in range(0, len(self.layers[0])):
if self.backend == 'pynn' or self.backend == 'spinnaker':
self.layers[0][i:i + 1].set(i_offset=bias[i])
elif self.backend == 'nest':
self.layers[0][i:i + 1].set(I_e=bias[i])
# return torch tensor to be compatible with other agents
return torch.tensor(potentials,dtype=torch.float)
def with_reset(self):
p.setup(1.0)
inp = p.Population(100, p.SpikeSourcePoisson(rate=100), label="input")
inp.record("spikes")
p.run(100)
spikes1 = inp.spinnaker_get_data('spikes')
p.reset()
inp.set(rate=10)
p.run(100)
spikes2 = inp.spinnaker_get_data('spikes')
p.end()
assert len(spikes1) > len(spikes2) * 5
def __run_sim(self, run_times, populations, projections, run_count,
spike_times_list, extract_between_runs, get_spikes, record_7,
get_v, record_v_7, get_gsyn_exc, record_gsyn_exc_7,
get_gsyn_inh, record_gsyn_inh_7, record_input_spikes,
record_input_spikes_7, get_all, get_weights, get_delays,
new_pop, n_neurons, cell_class, cell_params, weight_to_spike,
set_between_runs, reset):
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,
record_7, get_v, record_v_7, get_gsyn_exc,
record_gsyn_exc_7, get_gsyn_inh,
record_gsyn_inh_7, record_input_spikes,
record_input_spikes_7, get_all)
self._get_weight_delay(projections[0], get_weights, get_delays)
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),
p.StaticSynapse(weight=weight_to_spike, delay=1))
projections.append(new_projection)
if spike_times_list is not None:
populations[1].set(spike_times=spike_times_list[run_count])
for (pop, name, value) in set_between_runs:
new_values = {name: value}
populations[pop].set(**new_values)
if reset:
p.reset()
p.run(run_times[-1])
self._default_report_folder = \
p.globals_variables.get_simulator()._report_default_directory
return results
def change_nothing(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp, {}, label="pop")
pop.set(i_offset=1.0)
pop.set(tau_syn_E=1)
pop.record(["v"])
sim.run(5)
v1 = pop.spinnaker_get_data('v')
self.check_from_65(v1)
sim.reset()
sim.run(5)
v2 = pop.spinnaker_get_data('v')
self.check_from_65(v2)
sim.end()
def variable_rate_reset():
""" Test the ways of changing rates and ensure that they don't change the\
results
"""
p.setup(1.0)
pop = p.Population(100,
p.extra_models.SpikeSourcePoissonVariable(
rates=[1, 10, 100], starts=[0, 1000, 2000]),
additional_parameters={"seed": 0})
pop_2 = p.Population(100,
p.SpikeSourcePoisson(rate=1),
additional_parameters={
"seed": 0,
"max_rate": 100
})
pop.record("spikes")
pop_2.record("spikes")
p.run(1000)
spikes_pop_2_1 = pop_2.get_data("spikes")
nump = [s.magnitude for s in spikes_pop_2_1.segments[0].spiketrains]
numpy.savetxt("spikesp2_1.txt", nump[0])
pop_2.set(rate=10)
p.run(1000)
spikes_pop_2_2 = pop_2.get_data("spikes")
nump = [s.magnitude for s in spikes_pop_2_2.segments[0].spiketrains]
numpy.savetxt("spikesp2_2.txt", nump[0])
pop_2.set(rate=100)
p.run(1000)
p.reset()
p.run(3000)
spikes_pop = pop.get_data("spikes")
spikes_pop_2 = pop_2.get_data("spikes")
p.end()
spikes_1 = [s.magnitude for s in spikes_pop.segments[0].spiketrains]
spikes_2 = [s.magnitude for s in spikes_pop.segments[1].spiketrains]
spikes_p_2 = [s.magnitude for s in spikes_pop_2.segments[0].spiketrains]
print(spikes_1)
numpy.savetxt("spikes1.txt", spikes_1[0])
print(spikes_2)
numpy.savetxt("spikes2.txt", spikes_2[0])
print(spikes_p_2)
numpy.savetxt("spikesp2.txt", spikes_p_2[0])
for s1, s2, s3 in zip(spikes_1, spikes_2, spikes_p_2):
assert (numpy.array_equal(s1, s2))
assert (numpy.array_equal(s2, s3))
def do_run(split, seed=None):
p.setup(1.0)
if split:
p.set_number_of_neurons_per_core(p.SpikeSourcePoisson, 27)
p.set_number_of_neurons_per_core(p.IF_curr_exp, 22)
inp = p.Population(100,
p.SpikeSourcePoisson(rate=100, seed=seed),
label="input")
pop = p.Population(100, p.IF_curr_exp, {}, label="pop")
p.Projection(inp,
pop,
p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=5))
pop.record("spikes")
inp.record("spikes")
p.run(100)
inp.set(rate=10)
# pop.set("cm", 0.25)
pop.set(tau_syn_E=1)
p.run(100)
pop_spikes1 = pop.spinnaker_get_data('spikes')
inp_spikes1 = inp.spinnaker_get_data('spikes')
p.reset()
inp.set(rate=0)
pop.set(i_offset=1.0)
vs = p.RandomDistribution("uniform", [-65.0, -55.0],
rng=NumpyRNG(seed=seed))
pop.initialize(v=vs)
p.run(100)
pop_spikes2 = pop.spinnaker_get_data('spikes')
inp_spikes2 = inp.spinnaker_get_data('spikes')
p.end()
return (pop_spikes1, inp_spikes1, pop_spikes2, inp_spikes2)
def do_run(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp, {}, label="pop")
pop.set(i_offset=1.0)
pop.record(["v"])
initial1 = -64.0
initial2 = -62.0
initial3 = -63.0
initial4 = -61.0
runtime = 10
pop.initialize(v=initial1)
sim.run(runtime)
sim.reset()
pop.initialize(v=initial2)
sim.run(runtime)
sim.reset()
pop.initialize(v=initial3)
pop.set(i_offset=2.0)
sim.run(runtime)
try:
pop.initialize(v=initial4) # this should throw an exception
except Exception:
pass
pop.set(i_offset=2.5)
sim.run(runtime)
v = pop.get_data('v')
sim.end()
# test values at start of each run() call above
self.assertEqual(v.segments[0].filter(name='v')[0][0], initial1)
self.assertEqual(v.segments[1].filter(name='v')[0][0], initial2)
self.assertEqual(v.segments[2].filter(name='v')[0][0], initial3)
self.assertNotEqual(v.segments[2].filter(name='v')[0][runtime],
initial4)
# test the lengths of each segment are correct
self.assertEqual(len(v.segments[0].filter(name='v')[0]), runtime)
self.assertEqual(len(v.segments[0].filter(name='v')[0]),
len(v.segments[1].filter(name='v')[0]))
self.assertEqual(len(v.segments[2].filter(name='v')[0]), 2 * runtime)
def do_run(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=1.0)
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,
'e_rev_E': 0.,
'e_rev_I': -80.
}
# setup test population
if_pop = p.Population(1, p.IF_cond_exp, cell_params)
# setup spike sources
spike_times = [20., 40., 60.]
exc_pop = p.Population(1, p.SpikeSourceArray,
{'spike_times': spike_times})
inh_pop = p.Population(1, p.SpikeSourceArray,
{'spike_times': [120, 140, 160]})
# setup excitatory and inhibitory connections
listcon = p.FromListConnector([(0, 0, 0.05, 1.0)])
p.Projection(exc_pop, if_pop, listcon, receptor_type='excitatory')
p.Projection(inh_pop, if_pop, listcon, receptor_type='inhibitory')
# setup recorder
if_pop.record(["v"])
p.run(100)
p.reset()
if_pop.initialize(v=-65)
exc_pop.set(spike_times=[])
inh_pop.set(spike_times=spike_times)
p.run(100)
# read out voltage and plot
neo = if_pop.get_data("all")
p.end()
v = neo_convertor.convert_data(neo, "v", run=0)
v2 = neo_convertor.convert_data(neo, "v", run=1)
self.assertGreater(v[22][2], v[21][2])
self.assertGreater(v[42][2], v[41][2])
self.assertGreater(v[62][2], v[61][2])
self.assertLess(v2[22][2], v2[21][2])
self.assertLess(v2[42][2], v2[41][2])
self.assertLess(v2[62][2], v2[61][2])
def do_run():
p.setup(1.0)
inp = p.Population(100,
p.SpikeSourcePoisson(rate=2, seed=417),
label="input")
inp.record("spikes")
p.run(100)
p.reset()
inp.set(rate=30)
p.run(100)
p.end()
def do_run(self):
sim.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
prov_path = globals_variables.get_simulator()._app_provenance_file_path
pop = sim.Population(10, sim.IF_curr_exp(), label='pop_1')
sim.run(50)
graph_mapper = globals_variables.get_simulator()._graph_mapper
placements = globals_variables.get_simulator()._placements
machine_verts = list(graph_mapper.get_machine_vertices(pop._vertex))
placement = placements.get_placement_of_vertex(machine_verts[0])
size1 = self.check_size(prov_path, placement)
sim.run(50)
size2 = self.check_size(prov_path, placement)
self.assertGreater(size2, size1)
sim.run(50)
size3 = self.check_size(prov_path, placement)
self.assertGreater(size3, size2)
# Soft reset so same provenance
sim.reset()
sim.run(50)
size4 = self.check_size(prov_path, placement)
self.assertGreater(size4, size3)
sim.run(50)
size5 = self.check_size(prov_path, placement)
self.assertGreater(size5, size4)
# hard reset so new provenance
sim.reset()
sim.Population(10, sim.IF_curr_exp(), label='pop_1')
sim.run(50)
prov_patha = \
globals_variables.get_simulator()._app_provenance_file_path
self.assertNotEqual(prov_path, prov_patha)
size6 = self.check_size(prov_patha, placement)
# Should write the same thing again
self.assertEqual(size1, size6)
sim.end()
# Should not add anything on end.
size7 = self.check_size(prov_path, placement)
self.assertEqual(size5, size7)
size8 = self.check_size(prov_patha, placement)
self.assertEqual(size8, size6)
def do_run():
p.setup(1.0)
inp = p.Population(100,
p.SpikeSourcePoisson(rate=2),
label="input",
additional_parameters={"seed": 417})
inp.record("spikes")
p.run(100)
p.reset()
inp.set(rate=30)
p.run(100)
p.end()
def change_pre_reset(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp, {}, label="pop")
pop.set(i_offset=1.0)
pop.set(tau_syn_E=1)
pop.record(["v"])
sim.run(5)
v1 = pop.spinnaker_get_data('v')
self.check_from_65(v1)
pop.set(tau_syn_E=1)
sim.reset()
sim.run(5)
v2 = pop.spinnaker_get_data('v')
try:
self.check_from_65(v2)
except AssertionError:
self.known_issue(
"https://github.com/SpiNNakerManchester/sPyNNaker/issues/599")
sim.end()
def structural_formation_to_full_with_reset():
p.setup(1.0)
stim = p.Population(4, p.SpikeSourceArray(range(10)), label="stim")
# These populations should experience formation
pop = p.Population(4, p.IF_curr_exp(), label="pop")
# Formation with random selection (0 probability elimination), setting
# with_replacement=False means an all-to-all connection will be the result
proj = p.Projection(
stim, pop, p.FromListConnector([]), p.StructuralMechanismStatic(
partner_selection=p.LastNeuronSelection(),
formation=p.DistanceDependentFormation([2, 2], 1.0),
elimination=p.RandomByWeightElimination(4.0, 0, 0),
f_rew=1000, initial_weight=4.0, initial_delay=3.0,
s_max=4, seed=0, weight=0.0, delay=1.0, with_replacement=False))
pop.record("rewiring")
p.run(1000)
p.Population(4, p.IF_curr_exp(), label="pop2")
p.reset()
p.run(1000)
# Get the final connections
conns = proj.get(["weight", "delay"], "list")
rewiring = pop.get_data("rewiring")
formation_events = rewiring.segments[0].events[0]
formation_events2 = rewiring.segments[1].events[0]
num_forms = len(formation_events.times)
num_forms2 = len(formation_events2.times)
first_f = formation_events.labels[0]
first_f2 = formation_events2.labels[0]
p.end()
return conns, num_forms, num_forms2, first_f, first_f2
def do_run_with_reset(self):
sim.setup(timestep=1.0)
runtime = 500
n_neurons = 10
spikegap = 50
spike_times = list(n for n in range(0, runtime, spikegap))
pop_src = sim.Population(n_neurons,
sim.SpikeSourceArray(spike_times),
label="src")
pop_lif = sim.Population(n_neurons, sim.IF_curr_exp(), label="lif")
weight = 5
delay = 5
# define the projection
sim.Projection(pop_src,
pop_lif,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=weight, delay=delay),
receptor_type="excitatory")
pop_lif.record("all")
sim.run(runtime // 2)
# add another population to ensure a hard reset
sim.Population(n_neurons, sim.IF_curr_exp(), label="lif2")
sim.reset()
sim.run(runtime // 2)
pps = pop_lif.get_data()
totalpackets = sum(
pps.segments[0].filter(name='packets-per-timestep')[0]) + sum(
pps.segments[1].filter(name='packets-per-timestep')[0])
assert (totalpackets == n_neurons * (runtime // spikegap))
sim.end()
def no_change_v(self):
sim.setup(1.0)
pop = sim.Population(1, sim.IF_curr_exp, {}, label="pop")
inp = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(inp,
pop,
sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5))
pop.set(i_offset=1.0)
pop.set(tau_syn_E=1)
pop.record(["v"])
sim.run(5)
sim.reset()
inp.set(spike_times=[100])
sim.run(5)
v2 = pop.spinnaker_get_data('v')
self.check_from_65(v2)
sim.end()
def do_run(self):
sim.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
prov_path = globals_variables.get_simulator()._provenance_file_path
sim.Population(10, sim.IF_curr_exp(), label='pop_1')
sim.run(50)
size1 = self.check_size(prov_path)
sim.run(50)
size2 = self.check_size(prov_path)
self.assertGreater(size2, size1)
sim.run(50)
size3 = self.check_size(prov_path)
self.assertGreater(size3, size2)
# Soft reset so same provenance
sim.reset()
sim.run(50)
size4 = self.check_size(prov_path)
self.assertGreater(size4, size3)
sim.run(50)
size5 = self.check_size(prov_path)
self.assertGreater(size5, size4)
# hard reset so new provenance
sim.reset()
sim.Population(10, sim.IF_curr_exp(), label='pop_1')
sim.run(50)
prov_patha = globals_variables.get_simulator()._provenance_file_path
self.assertNotEqual(prov_path, prov_patha)
size6 = self.check_size(prov_patha)
# Should write the same thing again
self.assertEqual(size1, size6)
sim.end()
# Should not add anything on end.
size7 = self.check_size(prov_path)
self.assertEqual(size5, size7)
size8 = self.check_size(prov_patha)
self.assertEqual(size8, size6)
def do_run():
p.setup(timestep=1, min_delay=1)
spiker = p.Population(1,
p.SpikeSourceArray(spike_times=[[5, 25]]),
label='inputSSA')
if_pop = p.Population(1, p.IF_cond_exp(), label='pop')
if_pop.record("spikes")
if_pop.record("v")
runtime = 30
# Create projection with delay such that the second spike occurs after
# the run has finished
weight = 5.0
delay = 7
p.Projection(spiker,
if_pop,
p.OneToOneConnector(),
synapse_type=p.StaticSynapse(weight=weight, delay=delay),
receptor_type="excitatory",
source=None,
space=None)
p.run(runtime)
all1 = if_pop.get_data(["spikes", "v"])
# Reset (to time=0) and run again
p.reset()
p.run(runtime)
all2 = if_pop.get_data(["spikes", "v"])
p.end()
return (all1, all2)
def do_run(self):
sim.setup(timestep=1.0, n_boards_required=2)
sim.Population(3, sim.IF_curr_exp(), label="pop_1")
machine1 = sim.get_machine()
id1 = id(machine1)
sim.run(1)
machine2 = sim.get_machine()
id2 = id(machine2)
self.assertEqual(id1, id2)
sim.run(2)
machine3 = sim.get_machine()
id3 = id(machine3)
self.assertEqual(id1, id3)
sim.reset() # soft
sim.run(3)
machine4 = sim.get_machine()
id4 = id(machine4)
self.assertEqual(id1, id4)
sim.reset() # hard due to get_machine
machine5 = sim.get_machine()
id5 = id(machine5)
self.assertNotEqual(id1, id5)
sim.run(3)
machine6 = sim.get_machine()
id6 = id(machine6)
self.assertEqual(id5, id6)
sim.reset() # Hhard due to new pop
sim.Population(3, sim.IF_curr_exp(), label="pop_2")
sim.run(3)
machine7 = sim.get_machine()
id7 = id(machine7)
self.assertNotEqual(id1, id7)
self.assertNotEqual(id5, id7)
sim.reset() # soft
sim.run(3)
machine8 = sim.get_machine()
id8 = id(machine8)
self.assertEqual(id7, id8)
sim.end()
def projection_with_reset(self):
p.setup(1.0)
inp = p.Population(1, p.IF_curr_exp(), label="input")
layer = p.Population(1, p.IF_curr_exp(), label="layer")
output = p.Population(1, p.IF_curr_exp(), label="output")
p.Projection(inp, layer, p.AllToAllConnector(),
p.StaticSynapse(weight=5, delay=2))
p.run(100)
layer_to_output = p.Projection(layer, output, p.AllToAllConnector(),
p.StaticSynapse(weight=4, delay=10))
p.reset()
p.run(100)
weights_delays_out = layer_to_output.get(["weight", "delay"], "list")
p.end()
assert weights_delays_out[0][2] == 4.0
def set_initialize_between_runs(self):
runtime1 = 5
runtime2 = 5
runtime3 = 5
p.setup(timestep=1.0)
pop = p.Population(3, p.IF_curr_exp())
pop.record(['v'])
self.assertEquals([-65, -65, -65], pop.initial_values["v"])
pop.initialize(v=-64)
self.assertEquals([-64, -64, -64], pop.initial_values["v"])
p.run(runtime1)
self.assertEquals([-64, -64, -64], pop.initial_values["v"])
pop.initialize(v=-62)
self.assertEquals([-62, -62, -62], pop.initial_values["v"])
p.run(runtime2)
self.assertEquals([-62, -62, -62], pop.initial_values["v"])
id_mixin = pop[1]
id_mixin.initialize(v=-60)
# v on not changed is now the current state not initial value
self.assertNotEqual(-60, pop.initial_values["v"][0])
self.assertNotEqual(-62, pop.initial_values["v"][0])
self.assertEquals(-60, pop.initial_values["v"][1])
self.assertNotEqual(-60, pop.initial_values["v"][2])
self.assertNotEqual(-62, pop.initial_values["v"][2])
p.run(runtime3)
p.reset()
self.assertEquals([-64, -64, -64], pop.initial_values["v"])
pop.initialize(isyn_exc=-0.1)
self.assertEquals([-64, -64, -64], pop.initial_values["v"])
p.run(runtime1)
self.assertEquals([-64, -64, -64], pop.initial_values["v"])
view = pop[0:2]
view.initialize(v=-63)
self.assertEquals(-63, pop.initial_values["v"][0])
self.assertEquals(-63, pop.initial_values["v"][1])
# v on not changed is now the current state not initial value
self.assertNotEqual(-63, pop.initial_values["v"][2])
self.assertNotEqual(-64, pop.initial_values["v"][2])
p.run(runtime2)
neo = pop.get_data('v')
p.end()
v0 = neo.segments[0].filter(name='v')[0]
self.assertListEqual(list(v0[0]), [-64, -64, -64])
self.assertListEqual(list(v0[runtime1]), [-62.0, -62, -62])
assert v0[runtime1 + runtime2][0] != -62.0
assert v0[runtime1 + runtime2][0] != -60.0
assert v0[runtime1 + runtime2][1] == -60.0
assert v0[runtime1 + runtime2][2] != -62.0
assert v0[runtime1 + runtime2][2] != -60.0
v1 = neo.segments[1].filter(name='v')[0]
self.assertListEqual(list(v1[0]), [-64.0, -64, -64])
assert v1[runtime1][0] == -63.0
assert v1[runtime1][1] == -63.0
assert v1[runtime1][2] != -63.0
assert v1[runtime1][2] != -64.0
# wrongly classified.
guesses[undecided] = -1
print('guesses ' + str(guesses))
# Get classification error of current batch, for each time step.
top1err = guesses != np.broadcast_to(truth, guesses.shape)
top1 = not top1err[-1]
results[batch_idx] = np.array(
[np.argmax(y_test[batch_idx]), guesses[-1],
int(top1)])
print('...done: ' + str(batch_idx + 1) + '/' + str(num_to_test))
log = 'ClassID: ' + str(
results[batch_idx][0]) + ', top-1: ' + str(top1) + '\n'
print(log)
f.write(log)
sim.reset()
#print ('v_thresh: ' + str(layers[1].get('v_thresh')))
acc1 = results.sum(axis=0)[2] / num_to_test
acc_log = 'top-1 acc: ' + str(acc1 * 100) + '%'
print(acc_log)
np.savez(layers_path + '/results_mnist_nest.npz', results)
f.write(acc_log)
#save_confusion_matrix(results,layers_path)
f.close()
sim.end()
def spinn_net():
np.random.seed(272727)
global output_labels
global input_labels
p.setup(timestep=1.0, min_delay=1, max_delay=60)
p.set_number_of_neurons_per_core(p.IF_cond_exp, 64)
n_pop_labels = []
n_pop_list = []
n_proj_list = []
spike_source_list = []
if offset != 0:
for i in range(2):
del output_labels[0]
for i in range(2):
del input_labels[0]
for i in range(no_neuron_pops):
#set up the input as a live spike source
if i < 2:
n_pop_labels.append("Input_pop{}".format(i))
input_labels.append("Input_pop{}".format(i))
n_pop_list.append(
p.Population(pop_sizes[i], p.SpikeSourcePoisson(rate=poisson_rate),
label=n_pop_labels[i]))
n_pop_list[i].record(["spikes"])
p.external_devices.add_poisson_live_rate_control(
n_pop_list[i], database_notify_port_num=(160+offset))
#set up output pop
elif i < 4:
n_pop_labels.append("Output_pop{}".format(i))
output_labels.append("Output_pop{}".format(i))
n_pop_list.append(p.Population(pop_sizes[i], p.IF_cond_exp(),
label=n_pop_labels[i]))
p.external_devices.activate_live_output_for(
n_pop_list[i], database_notify_port_num=(180+offset),
port=(17000+offset))
spike_source_list.append(p.Population(pop_sizes[i], p.SpikeSourcePoisson(rate=0.0),
label="source ".format(n_pop_labels[i])))
n_pop_list[i].record(["spikes", "v"])
#set up all other populations
else:
n_pop_labels.append("neuron{}".format(i))
n_pop_list.append(p.Population(pop_sizes[i], p.IF_cond_exp(),
label=n_pop_labels[i]))
spike_source_list.append(p.Population(pop_sizes[i], p.SpikeSourcePoisson(rate=0.0),
label="source ".format(n_pop_labels[i])))
n_pop_list[i].record(["spikes", "v"])
poisson_control = p.external_devices.SpynnakerPoissonControlConnection(
poisson_labels=input_labels, local_port=(160+offset))
poisson_control.add_start_callback(n_pop_list[0].label, from_list_poisson)
# poisson_control.add_start_callback(n_pop_list[1].label, poisson_setting)
# poisson_control.add_start_callback(n_pop_list[0].label, poisson_threading)
live_connection = p.external_devices.SpynnakerLiveSpikesConnection(
receive_labels=output_labels, local_port=(180+offset))
live_connection.add_receive_callback(n_pop_labels[2], receive_spikes)
live_connection.add_receive_callback(n_pop_labels[3], receive_spikes)
# weight_mu = 0.015
# weight_sdtev = 0.05
# delay_mu = 40
# delay_sdtev = 5
for i in range(no_neuron_pops):
np.random.seed(272727)
weights = RandomDistribution("normal_clipped", mu=weight_mu[i],
sigma=weight_stdev[i], low=0, high=np.inf)
delays = RandomDistribution("normal_clipped", mu=delay_mu[i],
sigma=delay_stdev[i], low=1, high=55)
synapse = p.StaticSynapse(weight=weights, delay=delays)
for j in range(2, no_neuron_pops):
print "\npop = {}({}) connecting to {}".format(i,pop_sizes[i],j)
if connect_prob_ex[i][j-2] > 1e-10:
print "ex = {}\tin = {}".format(connect_prob_ex[i][j-2], connect_prob_in[i][j-2])
print "\tweight mu = {}\t stdev = {}".format(weight_mu[i], weight_stdev[i])
print "\tdelay mu = {}\t stdev = {}".format(delay_mu[i], delay_stdev[i])
n_proj_list.append(
p.Projection(n_pop_list[i], n_pop_list[j],
p.FixedProbabilityConnector(connect_prob_ex[i][j-2]),#p.OneToOneConnector(),#
synapse, receptor_type="excitatory"))
n_proj_list.append(
p.Projection(n_pop_list[i], n_pop_list[j],
p.FixedProbabilityConnector(connect_prob_in[i][j-2]),#p.OneToOneConnector(),#
synapse, receptor_type="inhibitory"))
# n_proj_list.append(p.Projection(n_pop_list[i], n_pop_list[j],
# p.FixedProbabilityConnector(1),
# synapse, receptor_type="inhibitory"))
run = 0
p.run(duration/timeScaleFactor)
print "finished 1st"
run = 1
p.reset()
p.run(duration/timeScaleFactor)
total_v = list()
spikes = list()
v = list()
spikes.append(n_pop_list[0].get_data("spikes"))
spikes.append(n_pop_list[1].get_data("spikes"))
for j in range(2,no_neuron_pops):
spikes.append(n_pop_list[j].get_data("spikes"))
v.append(n_pop_list[j].get_data("v"))
Figure(
# raster plot of the presynaptic neuron spike times
Panel(spikes[0].segments[0].spiketrains,
yticks=True, markersize=2, xlim=(0, duration)),
Panel(spikes[1].segments[0].spiketrains,
yticks=True, markersize=2, xlim=(0, duration)),
Panel(spikes[2].segments[0].spiketrains,
yticks=True, markersize=2, xlim=(0, duration)),
Panel(spikes[3].segments[0].spiketrains,
yticks=True, markersize=2, xlim=(0, duration)),
# Panel(spikes[4].segments[0].spiketrains,
# yticks=True, markersize=2, xlim=(0, duration)),
# Panel(spikes[no_neuron_pops-2].segments[0].spiketrains,
# yticks=True, markersize=2, xlim=(0, duration)),
# Panel(spikes[no_neuron_pops-1].segments[0].spiketrains,
# yticks=True, markersize=2, xlim=(0, duration)),
title="Raster plot",
annotations="Simulated with {}".format(p.name())
)
plt.show()
Figure(
#membrane voltage plots
Panel(v[0].segments[0].filter(name='v')[0],
ylabel="Membrane potential (mV)", yticks=True, xlim=(0, duration)),
Panel(v[1].segments[0].filter(name='v')[0],
ylabel="Membrane potential (mV)", yticks=True, xlim=(0, duration)),
Panel(v[2].segments[0].filter(name='v')[0],
ylabel="Membrane potential (mV)", yticks=True, xlim=(0, duration)),
Panel(v[3].segments[0].filter(name='v')[0],
ylabel="Membrane potential (mV)", yticks=True, xlim=(0, duration)),
# Panel(v[4].segments[0].filter(name='v')[0],
# ylabel="Membrane potential (mV)", yticks=True, xlim=(0, duration)),
# Panel(v[no_neuron_pops-4].segments[0].filter(name='v')[0],
# ylabel="Membrane potential (mV)", yticks=True, xlim=(0, duration)),
# Panel(v[no_neuron_pops-3].segments[0].filter(name='v')[0],
# ylabel="Membrane potential (mV)", yticks=True, xlim=(0, duration)),
title="Membrane voltage plot",
)
plt.show()
# p.reset()
p.end()
poisson_control.close()
live_connection.close()
print "finished run"
