def test_get_denmems(self):
pop_size = 2
for neuron_size in [4, 8, 12, 16, 32]:
self.marocco.neuron_placement.default_neuron_size(neuron_size)
pynn.setup(marocco=self.marocco)
target = pynn.Population(pop_size, pynn.IF_cond_exp, {})
populations = [target]
for i in range(3):
p1 = pynn.Population(pop_size, pynn.SpikeSourceArray,
{'spike_times': [1.]})
p2 = pynn.Population(pop_size, pynn.IF_cond_exp, {})
pynn.Projection(p1, target,
pynn.OneToOneConnector(weights=0.004))
pynn.Projection(p2, target,
pynn.OneToOneConnector(weights=0.004))
populations.append(p2)
pynn.run(0)
pynn.end()
mapstats = self.marocco.getStats()
results = Marocco.from_file(self.marocco.persist)
for pop in populations:
for nrn in range(pop_size):
for item in results.placement.find(pop[nrn]):
self.assertFalse(item.logical_neuron().is_external())
self.assertEqual(neuron_size,
item.logical_neuron().size())
def test(self):
wafer = 99999 # a wafer for which no redman data is availale
hicann = 82
neuron_number = 12
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
marocco.backend = PyMarocco.Without
marocco.default_wafer = C.Wafer(wafer)
used_hicann = C.HICANNGlobal(C.HICANNOnWafer(Enum(hicann)),
C.Wafer(wafer))
used_hicann # prevent pep8 warning of unused variable
pynn.setup(marocco=marocco)
pop = pynn.Population(1, pynn.IF_cond_exp)
topleft = C.NeuronOnWafer(C.NeuronOnHICANN(X(neuron_number), Y(0)),
C.HICANNOnWafer(Enum(hicann)))
logical_neuron = LogicalNeuron.rectangular(topleft, size=4)
marocco.manual_placement.on_neuron(pop, logical_neuron)
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
def test_Constructor(self):
import numpy
import pymarocco
marocco = pymarocco.PyMarocco()
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
pynn.setup(marocco=marocco)
N = 10
model = pynn.IF_cond_exp
selector = numpy.array(
[random.choice([True, False]) for x in range(0, N)])
pop = pynn.Population(N, model)
pv = pynn.PopulationView(pop, selector)
self.assertEqual(len(pv), len(numpy.where(selector == True)[0]))
# now a selection with wrong size is given
wrong_selector = numpy.array(
[random.choice([True, False]) for x in range(0, 2 * N)])
with self.assertRaises(RuntimeError):
pv = pynn.PopulationView(pop, wrong_selector)
pynn.run(100)
def build_network(num_pops, pop_size, marocco):
from pymarocco import PyMarocco
import pyhmf as pynn
logging.info("num_pops: %d, pop_size: %d, total size: %d" %
(num_pops, pop_size, num_pops * pop_size))
pynn.setup(marocco=marocco)
pops = [
pynn.Population(pop_size, pynn.EIF_cond_exp_isfa_ista)
for x in range(num_pops)
]
for idx, pop in enumerate(pops):
connector = pynn.AllToAllConnector(allow_self_connections=True,
weights=1.)
# build ring like network topology
pynn.Projection(pop,
pops[(idx + 1) % len(pops)],
connector,
target='excitatory')
# add poisson stimulus
source = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 2})
pynn.Projection(source, pop, connector, target='excitatory')
pynn.run(1)
pynn.end()
stats = marocco.getStats()
loss = float(stats.getSynapseLoss()) / stats.getSynapses()
return (num_pops, pop_size, loss)
def test_popview_on_neuron(self):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(4, pynn.IF_cond_exp, {})
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
neuron_block_1 = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(2))
logical_neuron = (LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(3), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(3), Y(1)), 2)
.done())
logical_neuron_1 = (LogicalNeuron.on(neuron_block_1)
.add(C.NeuronOnNeuronBlock(X(4), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(4), Y(1)), 2)
.done())
popview = pynn.PopulationView(pop,[0])
popview_1 = pynn.PopulationView(pop,[2])
popview_auto_placement= pynn.PopulationView(pop,[1,3])
self.marocco.manual_placement.on_neuron(popview, logical_neuron)
self.marocco.manual_placement.on_neuron(popview_1, logical_neuron_1)
pynn.run(0)
pynn.end()
results = self.load_results()
placement_item, = results.placement.find(popview[0])
self.assertEqual(logical_neuron, placement_item.logical_neuron())
placement_item, = results.placement.find(popview_1[0])
self.assertEqual(logical_neuron_1, placement_item.logical_neuron())
for nrn in popview_auto_placement:
placement_item, = results.placement.find(nrn)
self.assertIsNotNone(placement_item.logical_neuron())
def test_on_neuron_block(self, size):
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
pop = pynn.Population(size, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_neuron_block(pop, neuron_block)
if neuron_size * size > C.NeuronOnNeuronBlock.enum_type.size:
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
return
pynn.run(0)
pynn.end()
results = self.load_results()
for nrn in pop:
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertEqual(neuron_size, logical_neuron.size())
for denmem in logical_neuron:
self.assertEqual(neuron_block, denmem.toNeuronBlockOnWafer())
def test_popview_on_hicann(self, size):
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
hicann = C.HICANNOnWafer(Enum(122))
hicann_1 = C.HICANNOnWafer(Enum(123))
hicann_2 = C.HICANNOnWafer(Enum(124))
hicann_3 = C.HICANNOnWafer(Enum(125))
pop = pynn.Population(size, pynn.IF_cond_exp, {})
pop_1 = pynn.Population(size, pynn.IF_cond_exp, {})
pop_view = pynn.PopulationView(pop,list(range(0,size,2)))
pop_view_1 = pynn.PopulationView(pop,list(range(1,size,2)))
pop_1_view = pynn.PopulationView(pop_1,list(range(1,size//2)))
pop_1_view_1 = pynn.PopulationView(pop_1,list(range(size-2,size//2,-1)))
pop_auto_placement = pynn.PopulationView(pop_1,[0,size//2,size-1])
self.marocco.manual_placement.on_hicann(pop_view, hicann)
self.marocco.manual_placement.on_hicann(pop_view_1, hicann_1)
self.marocco.manual_placement.on_hicann(pop_1_view, hicann_2)
self.marocco.manual_placement.on_hicann(pop_1_view_1, hicann_3)
if neuron_size * size//2 > C.NeuronOnHICANN.enum_type.size:
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
return
pynn.run(0)
pynn.end()
results = self.load_results()
for nrn in pop_view:
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
for denmem in logical_neuron:
self.assertEqual(hicann, denmem.toHICANNOnWafer())
for nrn in pop_view_1:
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
for denmem in logical_neuron:
self.assertEqual(hicann_1, denmem.toHICANNOnWafer())
for nrn in pop_1_view:
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
for denmem in logical_neuron:
self.assertEqual(hicann_2, denmem.toHICANNOnWafer())
for nrn in pop_1_view_1:
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
for denmem in logical_neuron:
self.assertEqual(hicann_3, denmem.toHICANNOnWafer())
for nrn in pop_auto_placement:
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
for denmem in logical_neuron:
self.assertIsNotNone(denmem.toHICANNOnWafer())
def test_with_size(self):
pynn.setup(marocco=self.marocco)
default_size = 4
self.marocco.neuron_placement.default_neuron_size(default_size)
sizes = {}
pop = pynn.Population(1, pynn.IF_cond_exp, {})
sizes[pop] = default_size
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.with_size(pop, 2)
sizes[pop] = 2
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.with_size(pop, 6)
sizes[pop] = 6
pynn.run(0)
pynn.end()
results = self.load_results()
for pop, size in sizes.items():
placement_item, = results.placement.find(pop[0])
logical_neuron = placement_item.logical_neuron()
self.assertEqual(size, logical_neuron.size())
def test_no_disabled_synapses(self):
sim.run(10)
synapses = self.synapses
stats = self.stats()
self.assertEqual(synapses, stats.getSynapses())
self.assertEqual(synapses, stats.getSynapsesSet())
def test(self):
import pyhmf as pynn
from pymarocco import PyMarocco
import pylogging, pyhalbe
pyhalbe.Debug.change_loglevel(2)
pylogging.set_loglevel(pylogging.get("marocco"),
pylogging.LogLevel.TRACE)
pylogging.set_loglevel(pylogging.get("sthal"),
pylogging.LogLevel.DEBUG)
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
pynn.setup(marocco=marocco)
neuron1 = pynn.Population(1, pynn.IF_cond_exp)
inh = pynn.Population(1, pynn.SpikeSourceArray, {'spike_times': [0]})
exc = pynn.Population(1, pynn.SpikeSourceArray, {'spike_times': [0]})
exc_2 = pynn.Population(1, pynn.SpikeSourceArray, {'spike_times': [0]})
exc_3 = pynn.Population(1, pynn.SpikeSourceArray, {'spike_times': [0]})
c_exc = pynn.FixedProbabilityConnector(p_connect=1.0, weights=1)
proj1 = pynn.Projection(inh, neuron1, c_exc, target='excitatory')
proj2 = pynn.Projection(exc, neuron1, c_exc, target='excitatory')
proj3 = pynn.Projection(exc_2, neuron1, c_exc, target='excitatory')
proj4 = pynn.Projection(exc_3, neuron1, c_exc, target='inhibitory')
pynn.run(10000)
pynn.end()
def test_on_neurons(self, pop_size):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(pop_size, pynn.IF_cond_exp, {})
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
logical_neurons = [
(LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(3), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(3), Y(1)), 2)
.done()),
(LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(11), Y(0)), 2)
.add(C.NeuronOnNeuronBlock(X(11), Y(1)), 2)
.done()),
]
self.marocco.manual_placement.on_neuron(pop, logical_neurons)
if pop_size != len(logical_neurons):
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
return
pynn.run(0)
pynn.end()
results = self.load_results()
for nrn, logical_neuron in zip(pop, logical_neurons):
placement_item, = results.placement.find(nrn)
self.assertEqual(logical_neuron, placement_item.logical_neuron())
def random_network(self):
pynn.setup(marocco=self.marocco)
NUM_POPS = random.randint(10, 100)
POP_SIZE = random.randint(1, 100)
PROJ_PROB = 0.2
pops = [ pynn.Population(POP_SIZE, pynn.EIF_cond_exp_isfa_ista) for x in
range(NUM_POPS) ]
connector = pynn.AllToAllConnector(
allow_self_connections=True,
weights=1.)
for src in pops:
for trg in pops:
target_type = 'inhibitory' if random.random() < 0.2 else 'excitatory'
if random.random() < PROJ_PROB:
pynn.Projection(src, trg, connector, target=target_type)
pynn.run(1)
pynn.end()
stats = self.marocco.getStats()
print("python synapse loss: ", stats.getSynapseLoss())
def test_hw_merging_spl1_should_merge_some(self):
"""
some DNCs shall be merged, but not all, because of syndriver
requirements on each NB. 2 neurons will be placed (same HICANN).
A fully connected network is built.
This results in 8*2 = 16 synapses being routed to each neuron.
With neuron size 4 and chain length 3 -> 12 synapses can be realised
on each neuron. As a result at maximum 12 synapses shall be on the
same L1Route. The merger tries to merge them and will fail, then spit
it and merge 8 to each merger [3,5].
The result is a better L1 utilisation compared to one-to-one mapping,
2 instead of 8 routes, while staying within hardware constrains,
compared to merge all (16 synapses requiring 4 drivers, 1 driver will
be lost).
"""
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_as_possible)
# restrict to 3 driver, so that this test is hardware agnostic
self.marocco.synapse_routing.driver_chain_length(3)
hicann = C.HICANNOnWafer(Enum(123))
pops = []
# All but the first neuron block are occupied.
for nb in range(C.NeuronBlockOnHICANN.end):
pop = pynn.Population(2, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_neuron_block(
pop, C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(nb), hicann))
pops.append(pop)
for p in pops:
for other_p in pops:
pynn.Projection(p, other_p, pynn.AllToAllConnector(weights=1.))
pynn.run(0)
pynn.end()
merged_dncs = [3, 3, 3, 3, 5, 5, 5, 5]
results = self.load_results()
for pop in pops:
nrn = pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertEqual(neuron_size, logical_neuron.size())
for denmem in logical_neuron:
self.assertEqual(hicann, denmem.toHICANNOnWafer())
address = placement_item.address()
# some DNCs shall be merged.
dnc = C.DNCMergerOnHICANN(merged_dncs[pop.euter_id()])
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
def test_min_spl1_should_allow_external_input_on_same_chip(self):
"""
Even when the rightmost neuron block / DNC merger is not reserved for external input, it
should be possible to place external input on the same chip.
"""
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
# Do not reserve rightmost neuron block / DNC merger for external input.
self.marocco.neuron_placement.restrict_rightmost_neuron_blocks(False)
hicann = C.HICANNOnWafer(C.Enum(123))
pops = []
# All but the first neuron block are occupied.
for nb in range(1, C.NeuronBlockOnHICANN.end):
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_neuron_block(
pop, C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(nb), hicann))
pops.append(pop)
in_pop = pynn.Population(1, pynn.SpikeSourceArray, {})
self.marocco.manual_placement.on_hicann(in_pop, hicann)
pynn.run(0)
pynn.end()
results = self.load_results()
for pop in pops:
nrn = pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertEqual(neuron_size, logical_neuron.size())
for denmem in logical_neuron:
self.assertEqual(hicann, denmem.toHICANNOnWafer())
address = placement_item.address()
# All used neuron blocks should be connected to a single DNC merger.
dnc = C.DNCMergerOnHICANN(3)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
nrn = in_pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertTrue(logical_neuron.is_external())
address = placement_item.address()
# External input should be on the leftmost DNC merger, since all other
# mergers do not have direct access to a background generator.
dnc = C.DNCMergerOnHICANN(0)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
def test_L1_detour_at_side_switch_usage(self):
"""
[155]
191
[223] 224 225 x226x {227}
test detour and predecessor settings at the edge of a wafer
"""
pylogging.set_loglevel(pylogging.get("marocco"),
pylogging.LogLevel.TRACE)
pylogging.set_loglevel(pylogging.get("Calibtic"),
pylogging.LogLevel.ERROR)
self.marocco.persist = '' # or add test suite TestWithRuntime?
runtime = Runtime(self.marocco.default_wafer)
pynn.setup(marocco=self.marocco, marocco_runtime=runtime)
settings = pysthal.Settings.get()
settings.synapse_switches.max_switches_per_column_per_side = 1
settings.crossbar_switches.max_switches_per_row = 1
source = pynn.Population(1, pynn.IF_cond_exp, {})
target1 = pynn.Population(1, pynn.IF_cond_exp, {})
target2 = pynn.Population(1, pynn.IF_cond_exp, {})
proj = pynn.Projection(
source, target1, pynn.AllToAllConnector(weights=1.))
proj = pynn.Projection(
source, target2, pynn.AllToAllConnector(weights=1.))
source_hicann = C.HICANNOnWafer(Enum(227))
target1_hicann = C.HICANNOnWafer(Enum(155))
target2_hicann = C.HICANNOnWafer(Enum(225))
self.marocco.manual_placement.on_hicann(source, source_hicann)
self.marocco.manual_placement.on_hicann(target1, target1_hicann)
self.marocco.manual_placement.on_hicann(target2, target2_hicann)
disabled_hicanns = [226, 263]
wafer = self.marocco.default_wafer
self.marocco.defects.set(pyredman.Wafer(runtime.wafer().index()))
for hicann in C.iter_all(C.HICANNOnWafer):
if hicann.toEnum().value() in disabled_hicanns:
self.marocco.defects.wafer().hicanns().disable(C.HICANNGlobal(hicann, wafer))
continue
pynn.run(0)
pynn.end()
for hicann in runtime.wafer().getAllocatedHicannCoordinates():
h = runtime.wafer()[hicann]
print(hicann, h.check())
self.assertEqual(h.check(), "")
def test_projections(self):
pynn.setup(marocco=self.marocco)
target = pynn.Population(1, pynn.IF_cond_exp, {})
pop_a = pynn.Population(2, pynn.SpikeSourceArray,
{'spike_times': [1.]})
pop_b = pynn.Population(1, pynn.SpikeSourceArray,
{'spike_times': [2.]})
pop_ab = pynn.Assembly()
pop_ab += pop_a
pop_ab += pop_b
con = pynn.AllToAllConnector(weights=0.004)
proj_a = pynn.Projection(pop_a, target, con)
proj_b = pynn.Projection(pop_b, target, con)
proj_ab = pynn.Projection(pop_ab, target, con)
pynn.run(0)
pynn.end()
results = self.load_results()
synapses = results.synapse_routing.synapses()
items_a = synapses.find(proj_a)
self.assertEqual(2, len(items_a))
items_b = synapses.find(proj_b)
self.assertEqual(1, len(items_b))
items_ab = synapses.find(proj_ab)
self.assertEqual(3, len(items_ab))
def to_hw_synapses(items):
hw_synapses = set()
for item in items:
synapse = item.hardware_synapse()
if synapse:
hw_synapses.add(synapse)
return hw_synapses
hw_a = to_hw_synapses(items_a)
hw_b = to_hw_synapses(items_b)
hw_ab = to_hw_synapses(items_ab)
self.assertTrue(hw_a.isdisjoint(hw_b))
self.assertTrue(hw_a.isdisjoint(hw_ab))
self.assertTrue(hw_b.isdisjoint(hw_ab))
for source_neuron in pop_a:
items = synapses.find(proj_ab, source_neuron, target[0])
self.assertEqual(1, len(items))
self.assertTrue(hw_ab.issuperset(to_hw_synapses(items)))
for source_neuron in pop_b:
items = synapses.find(proj_ab, source_neuron, target[0])
self.assertEqual(1, len(items))
self.assertTrue(hw_ab.issuperset(to_hw_synapses(items)))
def test_issue1565(self):
# although there is only 1 synapse column per neuron (of size 2), a 2nd synapse is used
self.marocco.neuron_placement.default_neuron_size(2)
con = pynn.FixedProbabilityConnector(p_connect=1.0, weights=0.004)
pynn.setup(marocco=self.marocco)
pop1 = pynn.Population(10, pynn.IF_cond_exp, {})
ipu1 = pynn.Population(2, pynn.SpikeSourceArray, {'spike_times': []})
pro1 = pynn.Projection(ipu1, pop1, con, target='excitatory')
pynn.run(0)
def test_disable_all(self, name):
self.inject_disabled_component(name, iter_all(resources[name]))
sim.run(10)
# Assert complete loss of synapses
synapses = self.synapses
stats = self.stats()
self.assertEqual(synapses, stats.getSynapses())
self.assertEqual(synapses, stats.getSynapseLoss())
def test_min_spl1_is_nongreedy_when_pops_are_placed_to_nbs(self, nbs):
"""
See above. Instead of a single population placed to the HICANN, populations are placed to
specific neuron blocks.
"""
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
self.marocco.neuron_placement.restrict_rightmost_neuron_blocks(True)
hicann = C.HICANNOnWafer(C.Enum(123))
pops = []
for nb in nbs:
pop = pynn.Population(1, pynn.IF_cond_exp, {})
self.marocco.manual_placement.on_neuron_block(
pop, C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(nb), hicann))
pops.append(pop)
in_pop = pynn.Population(1, pynn.SpikeSourceArray, {})
self.marocco.manual_placement.on_hicann(in_pop, hicann)
pynn.run(0)
pynn.end()
results = self.load_results()
for pop in pops:
nrn = pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertEqual(neuron_size, logical_neuron.size())
for denmem in logical_neuron:
self.assertEqual(hicann, denmem.toHICANNOnWafer())
address = placement_item.address()
# All used neuron blocks should still be connected to a single DNC merger.
dnc = C.DNCMergerOnHICANN(3)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
nrn = in_pop[0]
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
self.assertTrue(logical_neuron.is_external())
address = placement_item.address()
# External input should be on the rightmost DNC merger since that is tried first.
dnc = C.DNCMergerOnHICANN(7)
self.assertEqual(hicann, address.toHICANNOnWafer())
self.assertEqual(dnc, address.toDNCMergerOnHICANN())
self.assertEqual(C.DNCMergerOnWafer(dnc, hicann),
address.toDNCMergerOnWafer())
def test_TwoNeuron(self):
if True:
pynn.setup(marocco=self.marocco)
# create neuron with v_rest below v_thresh
source = pynn.Population(1, pynn.EIF_cond_exp_isfa_ista, {
'v_rest': -50.,
'v_thresh': -60.,
'v_reset': -70.6,
})
N = 8 # number of target populations
p = [
pynn.Population(1, pynn.EIF_cond_exp_isfa_ista)
for i in range(N)
]
# place source on HICANN 0
source_hicann = self.chip(0)
self.marocco.manual_placement.on_hicann(source, source_hicann)
# place targets on all HICANNs on same reticle but random neurons
nrns = self.shuffle(255)
for ii, pop in enumerate(p):
hicann = HICANNGlobal(X(int(source_hicann.x()) + ii % 4),
Y(int(source_hicann.y()) + ii // 4))
self.marocco.manual_placement.on_hicann(pop, hicann)
print(pop, hicann)
connector = pynn.AllToAllConnector(allow_self_connections=True,
weights=1.)
store = []
# connect source to targets
for trg in p:
proj = pynn.Projection(source,
trg,
connector,
target='excitatory')
weights = copy.deepcopy(proj.getWeights())
store.append((proj, weights))
# start simulation
pynn.run(10) # in ms
pynn.end()
# make sure we have no synapse loss
self.assertEqual(0, self.marocco.stats.getSynapseLoss())
# assert weights are the same (at least as long as we don't send be
# the transformed digital weights)
for proj, weights in store:
self.assertEqual(self.marocco.stats.getWeights(proj), weights)
def ESS_available():
try:
marocco = pymarocco.PyMarocco()
marocco.backend = pymarocco.PyMarocco.ESS
pynn.setup(marocco=marocco)
pynn.run(1.)
return True
except RuntimeError as err:
if str(err) == "ESS not available (compile with ESS)":
return False
else:
raise err
def test_file_format(self, extension):
self.marocco.persist = (os.path.splitext(self.marocco.persist)[0] +
extension)
pynn.setup(marocco=self.marocco)
target = pynn.Population(1, pynn.IF_cond_exp, {})
pynn.run(0)
pynn.end()
results = self.load_results()
self.assertEqual(1, len(list(results.placement)))
def test_external_sources_projections(self, params):
nprojections = params[0]
nsources = params[1]
print((nprojections, nsources))
"""
An external sources has multiple projections
so it should be split if it wuld not be of size 1
so unfortunately the users would need to live with that.
"""
pylogging.set_loglevel(pylogging.get("marocco"),
pylogging.LogLevel.TRACE)
pylogging.set_loglevel(pylogging.get("Calibtic"),
pylogging.LogLevel.ERROR)
pynn.setup(marocco=self.marocco)
self.marocco.neuron_placement.default_neuron_size(4)
# ensure a limited synapse driver chain length.
self.marocco.synapse_routing.driver_chain_length(3)
# we expect synapse loss, but we dont care, as the source cant be split.
# we want this tests not to throw exceptions.
self.marocco.continue_despite_synapse_loss = True
target = pynn.Population(1, pynn.IF_cond_exp, {})
hicann = C.HICANNOnWafer(Enum(100))
self.marocco.manual_placement.on_hicann(target, hicann)
exsource = pynn.Population(nsources, pynn.SpikeSourcePoisson,
{'rate': 1.})
for i in range(nprojections):
proj = pynn.Projection(exsource, target,
pynn.AllToAllConnector(weights=1.))
# access to proj so flake8 keeps silent
proj.size
pynn.run(0)
pynn.end()
results = self.load_results()
synapses = results.synapse_routing.synapses()
placement = results.placement
for dnc in C.iter_all(C.DNCMergerOnWafer):
PonDNC = placement.find(dnc) # PopulationOnDNC
if PonDNC:
## if driver requirements exceeded, only one source should be
## placed on the DNC, but synapse loss is still expected
if (nprojections > 4): # this number is just guessed
self.assertTrue(len(PonDNC) <= 1)
else:
self.assertTrue(len(PonDNC) <= 12)
def test_loss_in_wafer_routing(self, mode):
h0 = HICANNGlobal(HICANNOnWafer(Enum(0)), Wafer(33))
h1 = HICANNGlobal(HICANNOnWafer(Enum(1)), Wafer(33))
# disable all horizontal buses on h0
hicann = pyredman.Hicann()
for hbus in iter_all(HLineOnHICANN):
hicann.hbuses().disable(hbus)
self.marocco.defects.set(pyredman.Wafer())
self.marocco.defects.wafer().inject(h0, hicann)
pynn.setup(marocco=self.marocco)
n1 = 100
n2 = 100
p1 = pynn.Population(n1, pynn.EIF_cond_exp_isfa_ista)
p2 = pynn.Population(n2, pynn.EIF_cond_exp_isfa_ista)
self.marocco.manual_placement.on_hicann(p1, h0)
self.marocco.manual_placement.on_hicann(p2, h1)
n_post = 10
if mode == "Population":
src = p1
tgt = p2
exp_loss = len(src) * n_post
elif mode == "PopulationView":
src = p1[n1 // 2:n1]
tgt = p2[n2 // 2:n2]
exp_loss = len(src) * n_post
elif mode == "Assembly":
src = pynn.Assembly(p1, p2)
tgt = p2
exp_loss = len(p1) * n_post
conn = pynn.FixedNumberPostConnector(n_post,
allow_self_connections=True,
weights=1.)
proj = pynn.Projection(src, tgt, conn, target='excitatory')
pynn.run(100)
pynn.end()
# check stats
self.assertEqual(exp_loss,
self.marocco.stats.getSynapseLossAfterL1Routing())
self.assertEqual(exp_loss, self.marocco.stats.getSynapseLoss())
# check weight matrices
orig_weights = proj.getWeights(format="array")
mapped_weights = self.marocco.stats.getWeights(proj)
lost_syns = np.logical_and(np.isfinite(orig_weights),
np.isnan(mapped_weights))
self.assertEqual(exp_loss, np.count_nonzero(lost_syns))
def big_network(self):
pynn.setup(marocco=self.marocco)
synapses = 0
numberOfPopulations = random.randint(100, 150)
logging.debug("number of populations: %d" % (numberOfPopulations))
#print "numPops: %d" % (numberOfPopulations)
# FIXME: spuouriously fails, why?
#pops = [ Population(random.randint(50, 85), EIF_cond_exp_isfa_ista) for x in
#range(numberOfPopulations) ]
pops = [
pynn.Population(80, pynn.EIF_cond_exp_isfa_ista)
for x in range(numberOfPopulations)
]
for idx, pop in enumerate(pops):
connectorE = pynn.FixedProbabilityConnector(
p_connect=0.20, allow_self_connections=True, weights=1.)
connectorI = pynn.FixedProbabilityConnector(
p_connect=0.10, allow_self_connections=True, weights=1.)
# build ring like network topology
proj = pynn.Projection(pop,
pops[(idx + 1) % len(pops)],
connectorE,
target='excitatory')
synapses += np.count_nonzero(proj.getWeights())
proj = pynn.Projection(pop,
pops[(idx + 1) % len(pops)],
connectorI,
target='inhibitory')
synapses += np.count_nonzero(proj.getWeights())
# add poisson stimulus
source = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 2})
proj = pynn.Projection(source,
pop,
connectorE,
target='excitatory')
synapses += np.count_nonzero(proj.getWeights())
pynn.run(100)
pynn.end()
logging.debug("synapses counted in python: %d", synapses)
return synapses
def test_issue1681(self):
con = pynn.FixedProbabilityConnector(p_connect=1.0, weights=0.004)
pynn.setup(marocco=self.marocco)
pop1 = pynn.Population(10, pynn.IF_cond_exp, {})
ipu1 = pynn.Population(1, pynn.SpikeSourceArray, {'spike_times': []})
pro1 = pynn.Projection(ipu1, pop1, con, target='excitatory')
# Issue 1681 "IndexError after mapping ends" is triggered by adding a
# population after a projection:
# Expected Output: NO ERROR
# Actual Output: "IndexError: vector::_M_range_check" (i.e. abnormal termination)
pop2 = pynn.Population(10, pynn.IF_cond_exp, {})
pynn.run(0)
def test_on_neuron_wrong_shape(self):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(1, pynn.IF_cond_exp, {})
neuron_block = C.NeuronBlockOnWafer(C.NeuronBlockOnHICANN(3))
logical_neuron = (LogicalNeuron.on(neuron_block)
.add(C.NeuronOnNeuronBlock(X(2), Y(0)), 4)
.add(C.NeuronOnNeuronBlock(X(3), Y(1)), 2)
.done())
self.marocco.manual_placement.on_neuron(pop, logical_neuron)
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
def test_on_rectangular_neuron(self):
pynn.setup(marocco=self.marocco)
pop = pynn.Population(1, pynn.IF_cond_exp, {})
topleft = C.NeuronOnWafer(C.NeuronOnHICANN(X(2), Y(0)))
logical_neuron = LogicalNeuron.rectangular(topleft, size=4)
self.marocco.manual_placement.on_neuron(pop, logical_neuron)
pynn.run(0)
pynn.end()
results = self.load_results()
placement_item, = results.placement.find(pop[0])
self.assertEqual(logical_neuron, placement_item.logical_neuron())
def test_same_popview_on_hicann(self, size):
pynn.setup(marocco=self.marocco)
neuron_size = 4
self.marocco.neuron_placement.default_neuron_size(neuron_size)
hicann = C.HICANNOnWafer(Enum(123))
hicann_1 = C.HICANNOnWafer(Enum(122))
pop = pynn.Population(size, pynn.IF_cond_exp, {})
pop_view = pynn.PopulationView(pop,[0])
pop_view_1 = pynn.PopulationView(pop,[0])
self.marocco.manual_placement.on_hicann(pop_view, hicann)
self.marocco.manual_placement.on_hicann(pop_view_1, hicann_1)
with self.assertRaises(RuntimeError):
pynn.run(0)
pynn.end()
def test_mini_network(self):
pynn.setup(marocco=self.marocco)
numNeurons = 1000
numPopulations = 42
numNeuronsPerPopulation = numNeurons/numPopulations
pops = []
for p in xrange(numPopulations):
pops.append(pynn.Population(numNeuronsPerPopulation, pynn.IF_cond_exp, {}))
pynn.run(0)
pynn.end()
self.assertEqual(numPopulations*numNeuronsPerPopulation, self.marocco.getStats().getNumNeurons())
map(self.helper_test_mapping, pops)
def main():
"""
create small network with synapse loss. The synapse loss happens due to a
maximum syndriver chain length of 5 and only 4 denmems per neuron. After
mapping, the synapse loss per projection is evaluated and plotted for one
projection. The sum of lost synapses per projection is compared to the
overall synapse loss returnd by the mapping stats.
"""
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
marocco.synapse_routing.driver_chain_length(5)
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(False)
pynn.setup(marocco=marocco)
neuron = pynn.Population(50, pynn.IF_cond_exp)
source = pynn.Population(50, pynn.SpikeSourcePoisson, {'rate' : 2})
connector = pynn.FixedProbabilityConnector(
allow_self_connections=True,
p_connect=0.5,
weights=0.00425)
proj_stim = pynn.Projection(source, neuron, connector, target="excitatory")
proj_rec = pynn.Projection(neuron, neuron, connector, target="excitatory")
pynn.run(1)
print marocco.stats
total_syns = 0
lost_syns = 0
for proj in [proj_stim, proj_rec]:
l,t = projectionwise_synapse_loss(proj, marocco)
total_syns += t
lost_syns += l
assert total_syns == marocco.stats.getSynapses()
assert lost_syns == marocco.stats.getSynapseLoss()
plot_projectionwise_synapse_loss(proj_stim, marocco)
pynn.end()
# A spike source array with spike times given in a list
spktimes = [10., 50., 65., 89., 233., 245.,255.,345.,444.4]
spike_source = pynn.Population(1, pynn.SpikeSourceArray, {'spike_times':spktimes})
# Connect the Spike source to our neuron
pynn.Projection(spike_source, N1, pynn.OneToOneConnector(weights=0.0138445), target='excitatory')
# record the membrane voltage of all neurons of the population
N1.record_v()
# record the spikes of all neurons of the population
N1.record()
# run the simulation for 500 ms
duration = 500.
pynn.run(duration)
# After the simulation, we get Spikes
spike_times = N1.getSpikes()
for pair in spike_times:
print "Neuron ", int(pair[0]), " spiked at ", pair[1]
# Plot voltage
do_plot = False
if do_plot:
import pylab
v = N1.get_v()[:,1:3] # strip ID
pylab.plot(v[:,0], v[:,1])
pylab.xlabel("Time [ms]")
pylab.ylabel("Voltage [mV]")
def run_mapping(calib_dir, output_dir, wafer, hicann, skip_neurons, params):
"""
:type hicann: HICANNOnWafer
:param params: dictionary containing neuron parameters
:param skip_neurons: number of non-functional dummy neurons to insert
"""
from pymarocco import PyMarocco
from pymarocco.results import Marocco
from pymarocco.coordinates import BioNeuron
import pyhmf as pynn
import pysthal
logger = setup_logger()
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(
utils.get_nested(params, "neuron.size", default=4))
marocco.neuron_placement.restrict_rightmost_neuron_blocks(True)
marocco.neuron_placement.minimize_number_of_sending_repeaters(False)
marocco.backend = PyMarocco.None
marocco.calib_backend = PyMarocco.XML
marocco.calib_path = calib_dir
marocco.param_trafo.use_big_capacitors = False
marocco.persist = os.path.join(output_dir, "marocco.xml.gz")
marocco.wafer_cfg = os.path.join(output_dir, "wafer_cfg.bin")
marocco.default_wafer = wafer
# FIXME: remove?
marocco.param_trafo.alpha_v = 1000.0
marocco.param_trafo.shift_v = 0.0
pynn.setup(marocco=marocco)
synaptic_input = {}
for input_type, input_params in params["synaptic_input"].iteritems():
if not utils.get_nested(input_params, "enabled", default=True):
logger.info(
"skipping disabled {!r} synaptic input".format(input_type))
continue
spike_times = utils.get_nested(
input_params, "spike_times", default=None)
if spike_times:
start = spike_times["start"]
stop = spike_times["stop"]
step = spike_times["step"]
spike_times = np.arange(start, stop, step)
input_pop_model = pynn.SpikeSourceArray
input_pop_params = {"spike_times": spike_times}
else:
raise NotImplementedError(
"unknown config for {!r} synaptic input".format(input_type))
logger.info(
("{!r} synaptic input will come from "
"{} with parameters {!r}").format(
input_type, input_pop_model.__name__, input_pop_params))
synaptic_input[input_type] = pynn.Population(
1, input_pop_model, input_pop_params)
neuron_params = utils.get_nested(params, "neuron.parameters")
neuron_model = getattr(pynn, utils.get_nested(
params, "neuron.model", default="IF_cond_exp"))
logger.info(
"target population is {} neuron with parameters {!r}".format(
neuron_model.__name__, neuron_params))
# Force marocco to give us a different neuron by inserting
# `Neuron_Number - 1` dummy neurons.
populations = []
for ii in range(0, skip_neurons + 1):
populations.append(pynn.Population(
1, neuron_model, neuron_params))
marocco.manual_placement.on_hicann(populations[-1], hicann)
target_pop = populations[-1]
for input_type, input_pop in synaptic_input.iteritems():
multiplicity = utils.get_nested(
params, "synaptic_input", input_type, "multiplicity",
default=1)
assert multiplicity >= 1
weight = utils.get_nested(
params, "synaptic_input", input_type, "weight")
con = pynn.AllToAllConnector(weights=weight)
logger.info(
("connecting {!r} synaptic input "
"to target population with weight {} "
"via {} projections").format(
input_type, weight, multiplicity))
for _ in xrange(multiplicity):
pynn.Projection(input_pop, target_pop, con, target=input_type)
pynn.run(params["duration"])
pynn.end()
wafer_cfg = pysthal.Wafer()
wafer_cfg.load(marocco.wafer_cfg)
results = Marocco.from_file(marocco.persist)
return (BioNeuron(target_pop[0]), results, wafer_cfg)
