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 setUp(self):
super(MaroccoFixture, self).setUp()
self.marocco = PyMarocco()
self.marocco.backend = PyMarocco.Without
self.marocco.calib_backend = PyMarocco.CalibBackend.Default
self.marocco.defects.backend = Defects.Backend.Without
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
sim.setup(marocco=self.marocco)
def setUp(self):
super(MaroccoFixture, self).setUp()
self.marocco = PyMarocco()
self.marocco.backend = PyMarocco.None
self.marocco.calib_backend = PyMarocco.CalibBackend.Default
self.marocco.defects.backend = Defects.Backend.None
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
self.marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(
False)
sim.setup(marocco=self.marocco)
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_popview_combinations(self, view_number):
# tests all possible combinations of mask lengths for different number of PopulationViews
import pylogging
from pymarocco import PyMarocco, Defects
from pymarocco.results import Marocco
pop_size = 5
hicanns = [C.HICANNOnWafer(Enum(180 + view)) for view in range(view_number)]
# generate possible mask lengths for Population Views
pool = tuple(i for i in range(1, pop_size - view_number + 2))
# generate all possible mask lengths for each PopulationView for a given total number of neurons
# [[lengths_of_Popviews],number_of_used_neurons]
view_lengths = [([], 0)]
for _ in range(view_number):
view_lengths = [(x+[y], csum+y) for x, csum in view_lengths for y in pool if csum <= pop_size - y]
neurons = list(range(pop_size))
for length in view_lengths:
marocco = PyMarocco()
marocco.backend = PyMarocco.Without
marocco.persist = "results.bin"
marocco.defects.backend = Defects.Backend.Without
neuron_size = 4
marocco.neuron_placement.default_neuron_size(neuron_size)
pynn.setup(marocco=marocco)
pop = pynn.Population(pop_size, pynn.IF_cond_exp, {})
pop_views = []
index = 0
for view in range(view_number):
# generate PopulationViews with all possible mask lengths
# no permutations of neurons are tested
pop_views.append(pynn.PopulationView(pop,neurons[index:index+length[0][view]]))
marocco.manual_placement.on_hicann(pop_views[view],hicanns[view])
index += length[0][view]
pynn.run(0)
pynn.end()
results = Marocco.from_file(marocco.persist)
for view in range(view_number):
for nrn in pop_views[view]:
placement_item, = results.placement.find(nrn)
logical_neuron = placement_item.logical_neuron()
for denmem in logical_neuron:
self.assertEqual(hicanns[view], denmem.toHICANNOnWafer())
def run():
results = []
for num_pops in [1, 10, 25, 50, 100, 200, 300, 400]:
for pop_size in [1, 16, 32, 64, 96]:
marocco = PyMarocco()
result = build_network(num_pops, pop_size, marocco)
results.append(result)
logging.info(results[-1])
return numpy.array(results)
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()
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()
def setup(self, timestep=1.0, min_delay=1.0, per_sim_params={}, **kwargs):
setup_args = {'timestep': timestep, 'min_delay': min_delay}
self._extra_config = per_sim_params
if self.sim_name == BSS: #do extra setup for BrainScaleS
wafer = per_sim_params.get("wafer", None)
marocco = per_sim_params.get("marocco", PyMarocco())
if wafer is not None:
sys.stdout.write("Specifying Wafer %d\n\n" % wafer)
sys.stdout.flush()
per_sim_params.pop('wafer')
self.BSS_wafer = C.Wafer(int(wafer))
marocco.default_wafer = self.BSS_wafer
self._wafer = WAL(wafer_id=wafer)
runtime = Runtime(marocco.default_wafer)
setup_args['marocco_runtime'] = runtime
self.BSS_runtime = runtime
calib_path = per_sim_params.get(
"calib_path", "/wang/data/calibration/brainscales/wip")
# "/wang/data/calibration/brainscales/current")
marocco.calib_path = calib_path
marocco.defects.path = marocco.calib_path
# marocco.verification = PyMarocco.Skip
# marocco.checkl1locking = PyMarocco.SkipCheck
marocco.continue_despite_synapse_loss = True
per_sim_params.pop('calib_path', None)
setup_args['marocco'] = marocco
self.marocco = marocco
self.SYNAPSE_DECODER_DISABLED_SYNAPSE = HICANN.SynapseDecoder(1)
for k in per_sim_params:
setup_args[k] = per_sim_params[k]
self._setup_args = setup_args
self._sim.setup(**setup_args)
# sys.exit(0)
if self.sim_name == BSS:
self._BSS_set_sthal_params(gmax=1023, gmax_div=1)
class MaroccoFixture(unittest.TestCase):
def setUp(self):
super(MaroccoFixture, self).setUp()
self.marocco = PyMarocco()
self.marocco.backend = PyMarocco.Without
self.marocco.calib_backend = PyMarocco.CalibBackend.Default
self.marocco.defects.backend = Defects.Backend.Without
self.marocco.merger_routing.strategy(
self.marocco.merger_routing.minimize_number_of_sending_repeaters)
sim.setup(marocco=self.marocco)
def tearDown(self):
super(MaroccoFixture, self).tearDown()
# sim.reset() only needed for multiple run() in the same session
sim.end()
def stats(self):
return self.marocco.getStats()
def test_defaultNeuronSize(self):
"""tests whether whether only the supported neuron sizes are allowed"""
marocco = PyMarocco()
p = marocco.neuron_placement
# has to be larger than zero
self.assertRaises(OverflowError, p.default_neuron_size, -1)
self.assertRaises(ValueError, p.default_neuron_size, 0)
for s in range(1, 65):
if (s % 2 == 0):
p.default_neuron_size(s)
self.assertEqual(s, p.default_neuron_size())
else:
self.assertRaises(ValueError, p.default_neuron_size, s)
# not larger than 64
self.assertRaises(ValueError, p.default_neuron_size, 65)
self.assertRaises(ValueError, p.default_neuron_size, 68)
def setup_marocco(wafer=37):
"""Setup hardwarm mapping on a wafer. Defaults to 37"""
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
marocco.neuron_placement.minimize_number_of_sending_repeaters(False)
marocco.merger_routing.strategy(marocco.merger_routing.one_to_one)
marocco.bkg_gen_isi = 125
marocco.pll_freq = 125e6
marocco.backend = PyMarocco.Hardware
marocco.calib_backend = PyMarocco.XML
marocco.defects.path = marocco.calib_path = "/wang/data/calibration/brainscales/default-2017-09-26-1"
marocco.defects.backend = Defects.XML
marocco.default_wafer = C.Wafer(int(os.environ.get("WAFER", wafer)))
marocco.param_trafo.use_big_capacitors = True
marocco.input_placement.consider_firing_rate(True)
marocco.input_placement.bandwidth_utilization(0.8)
return marocco
def test(self):
marocco = PyMarocco()
useOne = HICANNOnWafer(Enum(276))
useTwo = HICANNOnWafer(Enum(277))
use = [useOne, useTwo]
use_tpl = tuple(use)
# place a population to a single HICANN (scalar parameter)
pop = pynn.Population(10, pynn.IF_cond_exp, {})
marocco.manual_placement.on_hicann(pop, useOne)
# place a population onto multiple HICANNs
# using a Python list()
pop = pynn.Population(10, pynn.IF_cond_exp, {})
marocco.manual_placement.on_hicann(pop, use)
# place a population onto multiple HICANNs
# using a Python tuple()
pop = pynn.Population(10, pynn.IF_cond_exp, {})
marocco.manual_placement.on_hicann(pop, use_tpl)
def test_addWithNeuronSize(self):
"""tests manual placement with custom neuron size"""
marocco = PyMarocco()
useOne = HICANNOnWafer(Enum(276))
useTwo = HICANNOnWafer(Enum(277))
use = [useOne, useTwo]
# place a population to a single HICANN (scalar parameter)
pop = pynn.Population(10, pynn.IF_cond_exp, {})
marocco.manual_placement.on_hicann(pop, useOne, 8)
# place a population onto multiple HICANNs
pop = pynn.Population(10, pynn.IF_cond_exp, {})
marocco.manual_placement.on_hicann(pop, use, 4)
# only set the neuron size for the population, but no HICANN.
marocco.manual_placement.with_size(pop, 12)
self.assertRaises(ValueError, marocco.manual_placement.with_size, pop,
1)
pylogging.set_loglevel(pylogging.get("Default"), pylogging.LogLevel.INFO)
pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.DEBUG)
pylogging.set_loglevel(pylogging.get("sthal.HICANNConfigurator.Time"), pylogging.LogLevel.DEBUG)
h = pyredman.Hicann()
def initBackend(fname):
lib = pyredman.loadLibrary(fname)
backend = pyredman.loadBackend(lib)
if not backend:
raise Exception('unable to load %s' % fname)
return backend
neuron_size = 4
marocco = PyMarocco()
marocco.placement.setDefaultNeuronSize(neuron_size)
marocco.placement.use_output_buffer7_for_dnc_input_and_bg_hack = True
marocco.placement.minSPL1 = False
if simulator_name == "ess":
marocco.backend = PyMarocco.ESS
marocco.calib_backend = PyMarocco.Default
else:
marocco.backend = PyMarocco.Hardware
marocco.calib_backend = PyMarocco.XML
marocco.calib_path = "/wang/data/calibration/wafer_0"
marocco.roqt = "demo.roqt"
marocco.bio_graph = "demo.dot"
h276 = pyredman.Hicann()
if np.isnan(w) or w <= 0.0:
proxy.weight = HICANN.SynapseWeight(0)
### SETTING SYNAPSE TO DISABLED DECODER, DISABLING SYNAPSE
proxy.decoder = SYNAPSE_DECODER_DISABLED_SYNAPSE
else:
proxy.weight = HICANN.SynapseWeight(digital_w)
proxy.decoder = original_decoders[syn]
return out_mtx
############################################################################
############################################################################
############################################################################
wafer = int(os.environ.get("WAFER", 33))
marocco = PyMarocco()
marocco.backend = PyMarocco.Hardware
marocco.default_wafer = C.Wafer(wafer)
runtime = Runtime(marocco.default_wafer)
# calib_path = "/wang/data/calibration/brainscales/WIP-2018-09-18"
# marocco.calib_path = calib_path
# marocco.defects.path = marocco.calib_path
marocco.verification = PyMarocco.Skip
marocco.checkl1locking = PyMarocco.SkipCheck
marocco.continue_despite_synapse_loss = True
SYNAPSE_DECODER_DISABLED_SYNAPSE = HICANN.SynapseDecoder(1)
import pyhmf as pynn
#import pyNN.nest as pynn
from pymarocco import PyMarocco, Defects
import pylogging
import Coordinate as C
import pysthal
# configure logging
pylogging.reset()
pylogging.default_config(level=pylogging.LogLevel.INFO,
fname="logfile.txt",
dual=False)
# Mapping config
marocco = PyMarocco()
marocco.backend = PyMarocco.ESS # choose Executable System Specification instead of real hardware
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.defects.backend = Defects.Backend.None
marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(False)
marocco.hicann_configurator = pysthal.HICANNConfigurator()
marocco.experiment_time_offset = 5.e-7 # can be low for ESS, as no repeater locking required
marocco.neuron_placement.default_neuron_size(4) # default number of hardware neuron circuits per pyNN neuron
marocco.persist = "nmpm1_adex_neuron_ess.bin"
marocco.param_trafo.use_big_capacitors = False
# set-up the simulator
pynn.setup(marocco=marocco)
neuron_count = 1 # size of the Population we will create
logger = pylogging.get("guidebook")
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
'tau_syn_I': 5.,
}
marocco = PyMarocco()
marocco.default_wafer = C.Wafer(int(os.environ.get("WAFER", 33)))
runtime = Runtime(marocco.default_wafer)
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
pop = pynn.Population(1, pynn.IF_cond_exp, neuron_parameters)
pop.record()
pop.record_v()
hicann = C.HICANNOnWafer(C.Enum(297))
marocco.manual_placement.on_hicann(pop, hicann)
connector = pynn.AllToAllConnector(weights=1)
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()
#!/usr/bin/env python
import pyhmf as pynn
import Coordinate as C
from pymarocco import PyMarocco, Defects
from pymarocco.results import Marocco
import pylogging
for domain in ["Calibtic", "marocco"]:
pylogging.set_loglevel(pylogging.get(domain), pylogging.LogLevel.INFO)
marocco = PyMarocco()
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.defects.backend = Defects.Backend.None
marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(False)
marocco.persist = "results.xml.gz"
pynn.setup(marocco = marocco)
pop = pynn.Population(1, pynn.IF_cond_exp)
marocco.manual_placement.on_hicann(pop, C.HICANNOnWafer(C.X(5), C.Y(5)), 4)
pynn.run(10)
pynn.end()
results = Marocco.from_file(marocco.persist)
for neuron in pop:
for item in results.placement.find(neuron):
for denmem in item.logical_neuron():
print denmem
import os
import numpy as np
import pyhmf as pynn
from pymarocco import PyMarocco
from pymarocco.runtime import Runtime
from pymarocco.results import Marocco
from pyhalco_common import Enum
from pyhalco_hicann_v2 import HICANNOnWafer, Wafer
import pysthal
from pysthal.command_line_util import init_logger
init_logger("WARN", [("guidebook", "DEBUG"), ("marocco", "DEBUG"),
("Calibtic", "DEBUG"), ("sthal", "INFO")])
marocco = PyMarocco()
runtime = Runtime(Wafer(int(os.environ.get("WAFER", 22))))
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
logger = pylogging.get("guidebook")
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
'tau_syn_I': 5.,
}
marocco = PyMarocco()
marocco.default_wafer = C.Wafer(int(os.environ.get("WAFER", 33)))
runtime = Runtime(marocco.default_wafer)
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
pop = pynn.Population(1, pynn.IF_cond_exp, neuron_parameters)
pop.record()
pop.record_v()
hicann = C.HICANNOnWafer(C.Enum(297))
marocco.manual_placement.on_hicann(pop, hicann)
connector = pynn.AllToAllConnector(weights=1)
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)
logger = pylogging.get("guidebook")
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
'tau_syn_I': 5.,
}
marocco = PyMarocco()
marocco.default_wafer = C.Wafer(int(os.environ.get("WAFER", 33)))
runtime = Runtime(marocco.default_wafer)
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
pop = pynn.Population(1, pynn.IF_cond_exp, neuron_parameters)
pop.record()
pop.record_v()
hicann = C.HICANNOnWafer(C.Enum(297))
marocco.manual_placement.on_hicann(pop, hicann)
connector = pynn.AllToAllConnector(weights=1)
def test(self):
import pyhmf as sim
from pymarocco import PyMarocco
marocco = PyMarocco()
sim.setup(marocco=marocco)
#!/usr/bin/env python
import pyhmf as pynn
import Coordinate as C
from pymarocco import PyMarocco
from pymarocco.results import Marocco
import pylogging
for domain in ["Calibtic", "marocco"]:
pylogging.set_loglevel(pylogging.get(domain), pylogging.LogLevel.INFO)
marocco = PyMarocco()
marocco.persist = "results.bin"
pynn.setup(marocco=marocco)
pop = pynn.Population(1, pynn.IF_cond_exp)
marocco.manual_placement.on_hicann(pop, C.HICANNOnWafer(C.X(5), C.Y(5)), 4)
pynn.run(10)
pynn.end()
results = Marocco.from_file(marocco.persist)
for neuron in pop:
for item in results.placement.find(neuron):
for denmem in item.logical_neuron():
print denmem
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)
logger = pylogging.get("guidebook")
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
'tau_syn_I': 5.,
}
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
marocco.neuron_placement.minimize_number_of_sending_repeaters(False)
marocco.merger_routing.strategy(marocco.merger_routing.one_to_one)
marocco.bkg_gen_isi = 125
marocco.pll_freq = 125e6
marocco.backend = PyMarocco.Hardware
marocco.calib_backend = PyMarocco.XML
marocco.defects.path = marocco.calib_path = "/wang/data/calibration/ITL_2016"
marocco.defects.backend = Defects.XML
marocco.default_wafer = C.Wafer(33)
marocco.param_trafo.use_big_capacitors = True
marocco.input_placement.consider_firing_rate(True)
marocco.input_placement.bandwidth_utilization(0.8)
logger = pylogging.get("guidebook")
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
'tau_syn_I': 5.,
}
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
marocco.neuron_placement.minimize_number_of_sending_repeaters(False)
marocco.merger_routing.strategy(marocco.merger_routing.one_to_one)
marocco.bkg_gen_isi = 125
marocco.pll_freq = 125e6
marocco.backend = PyMarocco.Hardware
marocco.calib_backend = PyMarocco.XML
marocco.defects.path = marocco.calib_path = "/wang/data/calibration/brainscales/default-2017-09-26-1"
marocco.defects.backend = Defects.XML
marocco.default_wafer = C.Wafer(int(os.environ.get("WAFER", 33)))
marocco.param_trafo.use_big_capacitors = True
marocco.input_placement.consider_firing_rate(True)
marocco.input_placement.bandwidth_utilization(0.8)
logger = pylogging.get("guidebook")
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
'tau_syn_I': 5.,
}
marocco = PyMarocco()
marocco.default_wafer = Wafer(int(os.environ.get("WAFER", 33)))
runtime = Runtime(marocco.default_wafer)
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
pop = pynn.Population(1, pynn.IF_cond_exp, neuron_parameters)
pop.record()
pop.record_v()
hicann = HICANNOnWafer(Enum(297))
marocco.manual_placement.on_hicann(pop, hicann)
connector = pynn.AllToAllConnector(weights=1)
the default calibration.
"""
import pyhmf as pynn
#import pyNN.nest as pynn
from pymarocco import PyMarocco
import pylogging
# configure logging
pylogging.reset()
pylogging.default_config(level=pylogging.LogLevel.INFO,
fname="logfile.txt",
dual=False)
# Mapping config
marocco = PyMarocco()
marocco.backend = PyMarocco.ESS # choose Executable System Specification instead of real hardware
marocco.experiment_time_offset = 5.e-7 # can be low for ESS, as no repeater locking required
marocco.neuron_placement.default_neuron_size(
4) # default number of hardware neuron circuits per pyNN neuron
# set-up the simulator
pynn.setup(marocco=marocco)
neuron_count = 1 # size of the Population we will create
# Set the neuron model class
neuron_model = pynn.EIF_cond_exp_isfa_ista # an Adaptive Exponential I&F Neuron
neuron_parameters = {
'a': 4.0, # adaptation variable a in nS
"""
import pyhmf as pynn
#import pyNN.nest as pynn
from pymarocco import PyMarocco, Defects
import pylogging
import pysthal
# configure logging
pylogging.reset()
pylogging.default_config(level=pylogging.LogLevel.INFO,
fname="logfile.txt",
dual=False)
# Mapping config
marocco = PyMarocco()
marocco.backend = PyMarocco.ESS # choose Executable System Specification instead of real hardware
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.defects.backend = Defects.Backend.None
marocco.hicann_configurator = pysthal.HICANNConfigurator()
marocco.experiment_time_offset = 5.e-7 # can be low for ESS, as no repeater locking required
marocco.neuron_placement.default_neuron_size(
4) # default number of hardware neuron circuits per pyNN neuron
marocco.persist = "nmpm1_adex_neuron_ess.bin"
marocco.param_trafo.use_big_capacitors = False
# set-up the simulator
pynn.setup(marocco=marocco)
neuron_count = 1 # size of the Population we will create
def main():
parser = argparse.ArgumentParser()
# scale factor of the whole network compared to the original one
parser.add_argument('--scale', default=0.01, type=float)
# size of one neueron in hw neurons
parser.add_argument('--n_size', default=4, type=int)
parser.add_argument('--k_scale', type=float) # scale of connections
# wafer defects that should be considered in the mapping
parser.add_argument('--wafer', '-w', type=int, default=24)
# specific path where the defect parts of the wafer are saved
# if nothing specified, current defects of the given wafer are used
parser.add_argument('--defects_path', type=str)
parser.add_argument('--ignore_blacklisting',
type=str2bool,
nargs='?',
default=False,
const=True)
parser.add_argument('--name', type=str,
default='cortical_column_network') # name
parser.add_argument('--placer', type=str, default='byNeuron')
parser.add_argument('--seed', default=0, type=int)
args = parser.parse_args()
# k_scale is set to "scale" by deflaut
if not args.k_scale:
args.k_scale = args.scale
taskname = "scale{}_k-scale{}_nsize{}_wafer{}_ignoreBlacklsiting{}".format(
args.scale, args.k_scale, args.n_size, args.wafer,
args.ignore_blacklisting)
marocco = PyMarocco()
marocco.neuron_placement.default_neuron_size(args.n_size)
if (args.ignore_blacklisting):
marocco.defects.backend = Defects.Backend.Without
else:
marocco.defects.backend = Defects.Backend.XML
marocco.skip_mapping = False
marocco.backend = PyMarocco.Without
marocco.continue_despite_synapse_loss = True
marocco.default_wafer = C.Wafer(args.wafer) # give wafer args
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.calib_path = "/wang/data/calibration/brainscales/default"
if args.defects_path:
marocco.defects.path = args.defects_path
else:
marocco.defects.path = "/wang/data/commissioning/BSS-1/rackplace/" + str(
args.wafer) + "/derived_plus_calib_blacklisting/current"
# c 4189 no specification
#taskname += "_c4189_"
# strategy
marocco.merger_routing.strategy( # is now default
marocco.merger_routing.minimize_as_possible)
#taskname += "_minimAsPoss"
'''
# placement strategy
user_strat = placer()
taskname += "_placer"
'''
if args.placer == "byNeuron":
user_strat = placer_neuron_cluster() # cluster by neurons
taskname += "_byNeuron"
marocco.neuron_placement.default_placement_strategy(user_strat)
if args.placer == "byEnum":
user_strat = placer_enum_IDasc() # cluster by neurons
taskname += "_byEnum"
marocco.neuron_placement.default_placement_strategy(user_strat)
if args.placer == "constrained":
# needed for 5720 with patch set 36(best results) or ps 50
from pymarocco_runtime import ConstrainedNeuronClusterer as placer_neuron_resizer
user_strat = placer_neuron_resizer()
taskname += "_constrained"
marocco.neuron_placement.default_placement_strategy(user_strat)
# give marocco the format of the results file
taskname += str(datetime.now())
marocco.persist = "results_{}_{}.xml.gz".format(args.name, taskname)
start = datetime.now()
r = CorticalNetwork(marocco,
scale=args.scale,
k_scale=args.k_scale,
seed=args.seed)
r.build()
mid = datetime.now()
try:
r.run()
totsynapses = marocco.stats.getSynapses()
totneurons = marocco.stats.getNumNeurons()
lostsynapses = marocco.stats.getSynapseLoss()
lostsynapsesl1 = marocco.stats.getSynapseLossAfterL1Routing()
perPopulation = r.getLoss(marocco)
print("Losses: ", lostsynapses, " of ", totsynapses, " L1Loss:",
lostsynapsesl1, " Relative:", lostsynapses / float(totsynapses))
except RuntimeError as err:
# couldn't place all populations
totsynapses = 1
totneurons = 1
lostsynapses = 1
lostsynapsesl1 = 1
logger.error(err)
end = datetime.now()
print("time:", end - start)
result = {
"model":
args.name,
"task":
taskname,
"scale":
args.scale,
"k_scale":
args.k_scale,
"n_size":
args.n_size,
"wafer":
args.wafer,
"ignore_blacklisting":
args.ignore_blacklisting,
"timestamp":
datetime.now().isoformat(),
"placer":
args.placer,
"perPopulation":
perPopulation,
"results": [{
"type": "performance",
"name": "setup_time",
"value": (end - mid).total_seconds(),
"units": "s",
"measure": "time"
}, {
"type": "performance",
"name": "total_time",
"value": (end - start).total_seconds(),
"units": "s",
"measure": "time"
}, {
"type": "performance",
"name": "synapses",
"value": totsynapses
}, {
"type": "performance",
"name": "neurons",
"value": totneurons
}, {
"type": "performance",
"name": "synapse_loss",
"value": lostsynapses
}, {
"type": "performance",
"name": "synapse_loss_after_l1",
"value": lostsynapsesl1
}]
}
with open("{}_{}_results.json".format(result["model"], result["task"]),
'w') as outfile:
json.dump(result, outfile)
pylogging.set_loglevel(pylogging.get("Default"), pylogging.LogLevel.INFO)
pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.DEBUG)
pylogging.set_loglevel(pylogging.get("control"), pylogging.LogLevel.DEBUG)
pylogging.set_loglevel(pylogging.get("sthal.HICANNConfigurator.Time"),
pylogging.LogLevel.DEBUG)
pylogging.set_loglevel(pylogging.get("sthal.HICANNConfigurator"),
pylogging.LogLevel.DEBUG)
pylogging.set_loglevel(pylogging.get("Calibtic"), pylogging.LogLevel.DEBUG)
pylogging.set_loglevel(pylogging.get("halbe"), pylogging.LogLevel.INFO)
pylogging.set_loglevel(pylogging.get("hicann-system"), pylogging.LogLevel.INFO)
####################
# MAROCCO SETTINGS #
####################
marocco = PyMarocco()
marocco.placement.setDefaultNeuronSize(4)
marocco.placement.use_output_buffer7_for_dnc_input_and_bg_hack = True
marocco.placement.minSPL1 = False
marocco.backend = PyMarocco.None # .ESS, .Hardware
marocco.calib_backend = PyMarocco.XML
marocco.calib_path = args.calib_path
marocco.param_trafo.use_big_capacitors = False
marocco.roqt = "demo.roqt"
marocco.bio_graph = "demo.dot"
marocco.wafer_cfg = "wafer.dat"
# Set voltages in mV
marocco.param_trafo.alpha_v = 1.0
marocco.param_trafo.shift_v = 0.0
import pyhmf as pynn
from pymarocco import PyMarocco
from pymarocco.runtime import Runtime
from pymarocco.results import Marocco
import Coordinate as C
import pysthal
from pysthal.command_line_util import init_logger
init_logger("WARN", [
("guidebook", "DEBUG"),
("marocco", "DEBUG"),
("Calibtic", "DEBUG"),
("sthal", "INFO")
])
marocco = PyMarocco()
runtime = Runtime(C.Wafer(int(os.environ.get("WAFER", 22))))
pynn.setup(marocco=marocco, marocco_runtime=runtime)
# ——— set up network ——————————————————————————————————————————————————————————
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
'tau_syn_E': 5.,
