def do_run(nNeurons):
p.setup(timestep=0.1, min_delay=1.0, max_delay=7.5)
p.set_number_of_neurons_per_core(p.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()
synapse_type = p.StaticSynapse(weight=weight_to_spike,
delay=injection_delay)
projections.append(
p.Projection(populations[0],
populations[1],
connector,
synapse_type=synapse_type))
connector = p.AllToAllConnector()
projections.append(
p.Projection(populations[1],
populations[2],
connector,
synapse_type=synapse_type))
populations[2].record("v")
populations[2].record("spikes")
p.run(100)
neo = populations[2].get_data(["v", "spikes"])
v = neo_convertor.convert_data(neo, name="v")
spikes = neo_convertor.convert_spikes(neo)
p.end()
return (v, spikes)
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_one_run():
n_source = 2000
n_target = 16
n_neurons = 1
n_boards = math.ceil((n_source + n_target) / 16 / 48)
sim.setup(timestep=1.0, n_boards_required=n_boards)
try:
machine = sim.get_machine()
except ConfigurationException as oops:
if "Failure to detect machine " in str(oops):
raise SkipTest(
"You Need at least {} boards to run this test".format(
n_boards)) from oops
raise oops
target_x, target_y = find_good_chip(machine, n_target)
print(machine)
print(target_x, target_y)
sources = []
for s in range(n_source):
sources.append(
sim.Population(n_neurons,
sim.IF_curr_exp(),
label="source_{}".format(s),
additional_parameters={
"splitter":
SplitterAbstractPopulationVertexSlice()
}))
targets = []
for t in range(n_target):
pop = sim.Population(n_neurons,
sim.IF_curr_exp(),
label="target_{}".format(t),
additional_parameters={
"splitter":
SplitterAbstractPopulationVertexSlice()
})
pop.add_placement_constraint(x=target_x, y=target_y)
targets.append(pop)
for s in range(n_source):
for t in range(n_target):
sim.Projection(sources[s],
targets[t],
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1),
receptor_type="excitatory")
if t > 1 and s % t == 0:
sim.Projection(sources[s],
targets[t],
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5,
delay=1),
receptor_type="inhibitory")
sim.run(1)
sim.end()
def __init__(self, dvs_input, sim_t, w_kc2kc=0):
self.w_kc2kc = w_kc2kc
self.sim_t = sim_t
self.pn_neuron_idx = range(0, nb_pn, nb_pn / 5)
self.kc_neuron_idx = range(0, nb_kc, nb_kc / 10)
self.spike_source = sim.Population(
nb_pn, sim.SpikeSourceArray(spike_times=dvs_input), label="DVS")
self.pns = sim.Population(nb_pn, model(**cell_params), label="PN")
self.kcs = sim.Population(nb_kc, model(**cell_params), label="KC")
self.kcs_a = sim.Population(nb_kc, model(**cell_params), label="KC_A")
self.ens = sim.Population(nb_en, model(**cell_params), label="EN")
self.ens_a = sim.Population(nb_en, model(**cell_params), label="EN_A")
self.dvs2pn = sim.Projection(self.spike_source,
self.pns,
sim.OneToOneConnector(),
sim.StaticSynapse(weight=0.3, delay=1.0),
receptor_type='excitatory')
self.pn2kc = sim.Projection(self.pns,
self.kcs,
sim.FixedTotalNumberConnector(nb_pn2kc *
nb_kc),
sim.StaticSynapse(weight=0.3, delay=1.0),
receptor_type='excitatory')
self.pn2kc_a = sim.Projection(self.pns,
self.kcs_a,
sim.FixedTotalNumberConnector(nb_pn2kc *
nb_kc),
sim.StaticSynapse(weight=0.3, delay=1.0),
receptor_type='excitatory')
self.kc2en = sim.Projection(self.kcs,
self.ens,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.15, delay=1.0),
receptor_type='excitatory')
self.kc_a2en_a = sim.Projection(self.kcs_a,
self.ens_a,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.15,
delay=1.0),
receptor_type='excitatory')
self.kc_a2kc_a = sim.Projection(self.kcs,
self.kcs_a,
sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.1,
delay=1.0),
receptor_type='excitatory')
self.ens.record(['v', 'spikes'])
self.ens_a.record(['v', 'spikes'])
def do_run(self):
sim.setup(timestep=1.0, n_boards_required=1)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100)
machine = globals_variables.get_simulator().machine
input1 = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input1")
input2 = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input2")
pop_1 = sim.Population(5, sim.IF_curr_exp(), label="pop_1")
pop_2 = sim.Population(5, sim.IF_curr_exp(), label="pop_2")
sim.Projection(input1,
pop_1,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
sim.Projection(input2,
pop_2,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
# Make sure there is stuff at the cores specified in the cfg file
input1.set_constraint(ChipAndCoreConstraint(0, 0, 1))
input2.set_constraint(ChipAndCoreConstraint(0, 0, 3))
# While there must be a chip 0,0 chip 1,1 could be missing
if machine.is_chip_at(1, 1):
pop_1.set_constraint(ChipAndCoreConstraint(1, 1, 1))
# Make sure there is stuff at a core not specified in the cfg file
pop_2.set_constraint(ChipAndCoreConstraint(0, 0, 2))
sim.run(500)
provenance_files = self.get_app_iobuf_files()
sim.end()
self.assertIn("iobuf_for_chip_0_0_processor_id_1.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_2.txt",
provenance_files)
self.assertIn("iobuf_for_chip_0_0_processor_id_3.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_4.txt",
provenance_files)
if machine.is_chip_at(1, 1):
self.assertIn("iobuf_for_chip_1_1_processor_id_1.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_1_1_processor_id_2.txt",
provenance_files)
def do_run(self):
sim.setup(timestep=1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100)
input = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
pop_1 = sim.Population(200, sim.IF_curr_exp(), label="pop_1")
sim.Projection(input,
pop_1,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=18))
sim.run(500)
provenance_files = self.get_provenance_files()
sim.end()
# extract_iobuf_from_cores = 0,0,1
self.assertIn("iobuf_for_chip_0_0_processor_id_1.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_2.txt",
provenance_files)
self.assertIn("iobuf_for_chip_0_0_processor_id_3.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_4.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_5.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_6.txt",
provenance_files)
self.assertIn("iobuf_for_chip_1_1_processor_id_1.txt",
provenance_files)
def multiple_connectors(self):
n_destinations = 5
sim.setup(1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 2)
input_pop = sim.Population(
SOURCES,
sim.SpikeSourceArray(spike_times=[[0], [20], [40], [60], [80]]),
label="input_pop")
destination = sim.Population(n_destinations,
sim.IF_curr_exp(tau_syn_E=1,
tau_refrac=0,
tau_m=1),
label="destination")
synapse_type = sim.StaticSynapse(weight=5, delay=1)
sim.Projection(input_pop,
destination,
sim.OneToOneConnector(),
synapse_type=synapse_type)
sim.Projection(input_pop,
destination,
sim.AllToAllConnector(),
synapse_type=synapse_type)
destination.record("v")
sim.run(100)
neo = destination.get_data(["v"])
v = neo.segments[0].filter(name="v")[0] # pylint: disable=no-member
counts = self.calc_spikes_received(v)
for i, count in enumerate(counts):
for j in range(n_destinations):
if i == j:
self.assertEqual(count[j], 2)
else:
self.assertEqual(count[j], 1)
sim.end()
def record_v(self):
sim.setup(timestep=1)
simtime = 100
input = sim.Population(1, sim.SpikeSourceArray(spike_times=[0, 30]),
label="input")
pop = sim.Population(32, sim.IF_curr_exp(), label="pop")
sim.Projection(input, pop, sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
pop.record("v")
sim.run(simtime)
neo = pop.get_data("all")
pop.write_data(pickle_path, "all")
io = PickleIO(filename=pickle_path)
saved = io.read()[0]
neo_compare.compare_blocks(neo, saved)
assert len(neo.segments[0].spiketrains) == 0
assert len(neo.segments[0].filter(name="v")) > 0
assert len(neo.segments[0].filter(name="gsyn_exc")) == 0
v_neo = pop.get_data("v")
pop.write_data(pickle_path, "v")
io = PickleIO(filename=pickle_path)
v_saved = io.read()[0]
neo_compare.compare_blocks(v_neo, v_saved)
neo_compare.compare_blocks(v_neo, neo)
with self.assertRaises(ConfigurationException):
pop.get_data("spikes")
with self.assertRaises(ConfigurationException):
pop.get_data("gsyn_exc")
with self.assertRaises(ConfigurationException):
pop.write_data(pickle_path, "spikes")
with self.assertRaises(ConfigurationException):
pop.write_data(pickle_path, "gsyn_exc")
def test_thrtytwo(self):
sim.setup(timestep=1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100)
pop_1 = sim.Population(40, sim.IF_curr_exp(), label="pop_1")
input = sim.Population(1, sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(input, pop_1, sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
pop_1.record(["spikes", "v"], indexes=range(32))
simtime = 10
sim.run(simtime)
neo = pop_1.get_data(variables=["spikes", "v"])
spikes = neo.segments[0].spiketrains
# Include all the spiketrains as there is no outside index
self.assertEqual(40, len(spikes))
for i in range(32):
self.assertEqual(1, len(spikes[i]))
for i in range(32, 40):
self.assertEqual(0, len(spikes[i]))
v = neo.segments[0].filter(name='v')[0]
self.assertEqual(32, len(v.channel_index.index))
self.assertEqual(32, len(v[0]))
sim.end()
def test_props(self):
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
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}
source = p.Population(1, p.IF_curr_exp, cell_params_lif, label='pop_1')
dest = p.Population(1, p.IF_curr_exp, cell_params_lif, label='pop_2')
connector = p.AllToAllConnector()
synapse_type = p.StaticSynapse(weight=0, delay=1)
test_label = "BLAH!"
proj = p.Projection(
presynaptic_population=source,
postsynaptic_population=dest,
connector=connector, synapse_type=synapse_type, label="BLAH!")
proj_label = proj.label
proj_source = proj.pre
proj_dest = proj.post
self.assertEqual(source, proj_source)
self.assertEqual(dest, proj_dest)
self.assertEqual(test_label, proj_label)
def do_run(self):
sim.setup(timestep=1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100)
input = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
pop_1 = sim.Population(200, sim.IF_curr_exp(), label="pop_1")
sim.Projection(input,
pop_1,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=18))
sim.run(500)
provenance_files = self.get_provenance_files()
sim.end()
# assuming placements as expected
xmls = { # extract_iobuf_from_binary_types = IF_curr_exp.aplx
"0_0_5_pop_1_0_99.xml", "0_0_6_pop_1_100_199.xml",
}
if xmls < set(provenance_files):
# extract_iobuf_from_cores = None
self.assertNotIn("iobuf_for_chip_0_0_processor_id_2.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_3.txt",
provenance_files)
self.assertNotIn("iobuf_for_chip_0_0_processor_id_4.txt",
provenance_files)
self.assertIn("iobuf_for_chip_0_0_processor_id_5.txt",
provenance_files)
self.assertIn("iobuf_for_chip_0_0_processor_id_6.txt",
provenance_files)
else:
raise SkipTest("Unexpected placements {}".format(provenance_files))
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 run_script():
n_neurons = 500
simtime = SIMTIME
sim.setup(timestep=1)
pop_1 = sim.Population(n_neurons, sim.IF_curr_exp(), label="pop_1")
input1 = sim.Population(1, sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(input1, pop_1, sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
input2 = sim.Population(n_neurons, sim.SpikeSourcePoisson(
rate=100.0, seed=1), label="Stim_Exc")
sim.Projection(input2, pop_1, sim.OneToOneConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
pop_1.record(['spikes', 'v', 'gsyn_exc', 'gsyn_inh'])
sim.run(simtime)
neo = pop_1.get_data()
spikes = neo.segments[0].spiketrains
v = neo.segments[0].filter(name='v')[0]
exc = neo.segments[0].filter(name='gsyn_exc')[0]
inh = neo.segments[0].filter(name='gsyn_inh')[0]
sim.end()
return spikes, v, exc, inh
def test_placement_constraint(self):
"""
test the get_placements call.
"""
sim.setup(timestep=1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 50)
pop_1 = sim.Population(200, sim.IF_curr_exp(), label="pop_1")
pop_1.add_placement_constraint(x=1, y=1)
input = sim.Population(1,
sim.SpikeSourceArray(spike_times=[0]),
label="input")
sim.Projection(input,
pop_1,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
simtime = 10
sim.run(simtime)
placements = self.get_placements("pop_1")
sim.end()
self.assertGreater(len(placements), 0)
for [x, y, _] in placements:
self.assertEqual("1", x)
self.assertEqual("1", y)
def do_run():
p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
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()
populations.append(
p.Population(sources, p.IF_curr_exp, cell_params_lif, label='pop_1'))
populations.append(
p.Population(targets, p.IF_curr_exp, cell_params_lif, label='pop_2'))
connectors = p.AllToAllConnector()
synapse_type = p.StaticSynapse(weight=weight_to_spike, delay=delay)
projections.append(
p.Projection(populations[0],
populations[1],
connectors,
synapse_type=synapse_type))
# before
pre_delays_array = projections[0].get(attribute_names=["delay"],
format="nparray")
pre_delays_list = projections[0].get(attribute_names=["delay"],
format="list")
pre_weights_array = projections[0].get(attribute_names=["weight"],
format="array")
pre_weights_list = projections[0].get(attribute_names=["weight"],
format="list")
p.run(100)
# after
post_delays_array = projections[0].get(attribute_names=["delay"],
format="nparray")
post_delays_list = projections[0].get(attribute_names=["delay"],
format="list")
post_weights_array = projections[0].get(attribute_names=["weight"],
format="array")
post_weights_list = projections[0].get(attribute_names=["weight"],
format="list")
p.end()
return (pre_delays_array, pre_delays_list, pre_weights_array,
pre_weights_list, post_delays_array, post_delays_list,
post_weights_array, post_weights_list)
def do_run(self):
sim.setup(timestep=1.0)
model = sim.IF_curr_exp
cell_params_input = {
'cm': 0.25,
'i_offset': 1.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
}
cell_params_output = {
'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
}
pre_size = 2
post_size = 3
simtime = 200
pre_pop = sim.Population(pre_size, model(**cell_params_input))
post_pop = sim.Population(post_size, model(**cell_params_output))
wiring = sim.AllToAllConnector()
static_synapse = sim.StaticSynapse(weight=2.5, delay=100.0)
sim.Projection(pre_pop,
post_pop,
wiring,
receptor_type='excitatory',
synapse_type=static_synapse)
# record post-pop spikes to check activation
post_pop.record(['spikes'])
# run simulation
sim.run(simtime)
# get data
neo_post_spikes = post_pop.get_data(['spikes'])
# end simulation
sim.end()
# Check there are spikes
length = len(neo_post_spikes.segments[0].spiketrains[0])
self.assertGreater(length, 0)
def do_run():
p.setup(timestep=1.0)
cellparams = {"spike_times": [0]}
input_pop = p.Population(1, p.SpikeSourceArray(**cellparams),
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(**cell_params_lif),
label="pop")
connections = list()
connections.append(p.Projection(input_pop, pop,
p.AllToAllConnector(),
p.StaticSynapse(weight=[0.3, 1.0],
delay=[1, 17])))
connections.append(p.Projection(input_pop, pop,
p.AllToAllConnector(),
p.StaticSynapse(weight=[0.3, 1.0],
delay=[2, 15])))
connections.append(p.Projection(input_pop, pop,
p.AllToAllConnector(),
p.StaticSynapse(weight=[0.7, 0.3],
delay=[3, 33])))
pre_weights = list()
pre_delays = list()
for connection in connections:
pre_weights.append(connection.get('weight', 'list'))
pre_delays.append(connection.get('delay', 'list'))
p.run(100)
post_weights = list()
post_delays = list()
for connection in connections:
post_weights.append(connection.get('weight', 'list'))
post_delays.append(connection.get('delay', 'list'))
p.end()
return (pre_weights, pre_delays, post_weights, post_delays)
def check_other_connect(self, sources, destinations):
sim.setup(1.0)
pop1 = sim.Population(sources, sim.IF_curr_exp(), label="pop1")
pop2 = sim.Population(destinations, sim.IF_curr_exp(), label="pop2")
synapse_type = sim.StaticSynapse(weight=5, delay=1)
projection = sim.Projection(
pop1, pop2, sim.AllToAllConnector(), synapse_type=synapse_type)
sim.run(1)
self.check_weights(projection, sources, destinations)
sim.end()
def add_pop(self, x, y, n_neurons, input):
pop = sim.Population(n_neurons,
sim.IF_curr_exp(),
label="pop_{}_{}".format(x, y))
pop.add_placement_constraint(x=x, y=y)
sim.Projection(input,
pop,
sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
pop.record("all")
return pop
def using_population_views(self):
sim.setup(timestep=1.0)
input = sim.Population(4, sim.SpikeSourceArray([0]), label="input")
pop = sim.Population(4, sim.IF_curr_exp(), label="pop")
conn = sim.Projection(input[1:3], pop[2:4], sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.5, delay=2))
sim.run(1)
weights = conn.get(['weight', 'delay'], 'list')
sim.end()
target = [(1, 2, 0.5, 2.), (1, 3, 0.5, 2.), (2, 2, 0.5, 2.),
(2, 3, 0.5, 2.)]
self.assertEqual(weights.tolist(), target)
def run_forever_not_recorded():
sim.setup(1.0)
stim = sim.Population(1, sim.SpikeSourcePoisson(rate=10.0))
pop = sim.Population(255, sim.IF_curr_exp(tau_syn_E=1.0), label="pop")
sim.Projection(
stim, pop, sim.AllToAllConnector(), sim.StaticSynapse(weight=20.0))
conn = DatabaseConnection(
start_resume_callback_function=start_callback,
stop_pause_callback_function=stop_callback, local_port=None)
SpynnakerExternalDevicePluginManager.add_database_socket_address(
conn.local_ip_address, conn.local_port, None)
sim.external_devices.run_forever()
sim.end()
def get_before_run(self):
sim.setup(1.0)
pop1 = sim.Population(3, sim.IF_curr_exp(), label="pop1")
pop2 = sim.Population(3, sim.IF_curr_exp(), label="pop2")
synapse_type = sim.StaticSynapse(weight=5, delay=1)
projection = sim.Projection(
pop1, pop2, sim.AllToAllConnector(),
synapse_type=synapse_type)
weights = projection.get(["weight"], "list")
sim.run(0)
length = len(weights)
self.assertEqual(9, length)
sim.end()
def testReset_add(self):
sim.setup(timestep=1.0)
sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 1)
input = sim.Population(
1, sim.SpikeSourceArray(spike_times=[0]), label="input")
pop_1 = sim.Population(2, sim.IF_curr_exp(), label="pop_1")
sim.Projection(input, pop_1, sim.AllToAllConnector(),
synapse_type=sim.StaticSynapse(weight=5, delay=1))
sim.run(10)
sim.Population(2, sim.IF_curr_exp(), label="pop_2")
with self.assertRaises(NotImplementedError):
sim.run(10)
def run_network(timestep, steps_per_timestep):
p.setup(timestep, max_delay=1.0)
pre = p.Population(1, p.SpikeSourceArray(range(0, 100, 10)))
post = p.Population(1, p.IF_cond_exp(), additional_parameters={
"n_steps_per_timestep": steps_per_timestep})
post.record(["v", "spikes"])
p.Projection(pre, post, p.AllToAllConnector(),
p.StaticSynapse(weight=0.13))
p.run(100)
v = post.get_data("v").segments[0].filter(name='v')[0]
spikes = post.get_data("spikes").segments[0].spiketrains
p.end()
return v, spikes
def using_static_synapse_singles(self):
sim.setup(timestep=1.0)
input = sim.Population(2, sim.SpikeSourceArray([0]), label="input")
pop = sim.Population(2, sim.IF_curr_exp(), label="pop")
conn = sim.Projection(input, pop, sim.AllToAllConnector(),
sim.StaticSynapse(weight=0.7, delay=3))
sim.run(1)
weights = conn.get(['weight', 'delay'], 'list')
sim.end()
target = [(0, 0, 0.7, 3), (0, 1, 3, 33), (1, 0, 0.4, 12),
(1, 1, 0.5, 21)]
for i in range(2):
for j in range(2):
self.assertAlmostEqual(weights[i][j], target[i][j], places=3)
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 create_edge():
if projection_type == "all_to_all" and isinstance(
nodes[edge["output"]["id"]], pynn.Population):
assert (edge['projection_target']['kind'] == 'static'
) # only support static connectivity for now
target = edge['projection_target']['effect']
projection = pynn.Projection(nodes[edge["input"]["id"]],
nodes[edge["output"]["id"]],
method=pynn.AllToAllConnector(),
target=target)
weight = edge["projection_type"]["weight"]
if edge['projection_target']['effect'] == 'inhibitory' and weight > 0:
weight = weight * -1
projection.setWeights(weight)
else:
print "not yet supported"
def structural_eliminate_to_empty():
p.setup(1.0)
stim = p.Population(9, p.SpikeSourceArray(range(10)), label="stim")
# These populations should experience elimination
pop = p.Population(9, p.IF_curr_exp(), label="pop")
# Make a full list
# Elimination with random selection (0 probability formation)
proj = p.Projection(
stim, pop, p.AllToAllConnector(),
p.StructuralMechanismStatic(
partner_selection=p.RandomSelection(),
formation=p.DistanceDependentFormation([3, 3], 0.0),
elimination=p.RandomByWeightElimination(4.0, 1.0, 1.0),
f_rew=1000,
initial_weight=4.0,
initial_delay=3.0,
s_max=9,
seed=0,
weight=0.0,
delay=1.0))
pop.record("rewiring")
p.run(1000)
# Get the final connections
conns = list(proj.get(["weight", "delay"], "list"))
rewiring = pop.get_data("rewiring")
formation_events = rewiring.segments[0].events[0]
elimination_events = rewiring.segments[0].events[1]
num_forms = len(formation_events.times)
num_elims = len(elimination_events.times)
first_elim = elimination_events.labels[0]
p.end()
# These should have no connections since all should be eliminated
assert (len(conns) == 0)
assert (num_elims == 81)
assert (num_forms == 0)
assert (first_elim == "7_5_elimination")
def do_run(self):
sim.setup(timestep=1.0)
input_pop = sim.Population(1,
sim.SpikeSourceArray(range(
0, run_time, 100)),
label="input")
test_pop = sim.Population(1, MyFullNeuron(), label="my_full_neuron")
test_pop.record(['spikes', 'v'])
sim.Projection(input_pop,
test_pop,
sim.AllToAllConnector(),
receptor_type='excitatory',
synapse_type=sim.StaticSynapse(weight=2.0))
sim.run(run_time)
neo = test_pop.get_data('all')
sim.end()
self.check_results(neo, [501])
def 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(p.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("spikes")
p.run(5000)
spike_array_spikes = populations[1].spinnaker_get_data("spikes")
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()
