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_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 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
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)
### ====================== NETWORK CONSTRUCTION =========================== ###
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
# Set the neuron model class
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
# Set the neuron model class
duration = 1500.0
stimulus_exc = pynn.Population(1, pynn.SpikeSourceArray,
{'spike_times': exc_spike_times})
stimulus_inh = pynn.Population(1, pynn.SpikeSourceArray,
{'spike_times': inh_spike_times})
projections = [
pynn.Projection(stimulus_exc, pop, connector, target='excitatory'),
pynn.Projection(stimulus_inh, pop, connector, target='inhibitory'),
]
# ——— run mapping —————————————————————————————————————————————————————————————
marocco.skip_mapping = False
marocco.backend = PyMarocco.Without
pynn.reset()
pynn.run(duration)
# ——— change low-level parameters before configuring hardware —————————————————
def set_sthal_params(wafer, gmax, gmax_div):
"""
synaptic strength:
gmax: 0 - 1023, strongest: 1023
gmax_div: 2 - 30, strongest: 2
"""
# for all HICANNs in use
connector = pynn.AllToAllConnector(weights=1)
duration = 1500.0
# initialize without spike times
stimulus_exc = pynn.Population(1, pynn.SpikeSourceArray, {'spike_times': []})
stimulus_neuron = stimulus_exc[0]
projections = [
pynn.Projection(stimulus_exc, pop, connector, target='excitatory'),
]
# ——— run mapping —————————————————————————————————————————————————————————————
marocco.skip_mapping = False
marocco.backend = PyMarocco.None
pynn.reset()
pynn.run(duration)
# ——— change low-level parameters before configuring hardware —————————————————
def set_sthal_params(wafer, gmax, gmax_div):
"""
synaptic strength:
gmax: 0 - 1023, strongest: 1023
gmax_div: 1 - 15, strongest: 1
"""
# for all HICANNs in use
for hicann in wafer.getAllocatedHicannCoordinates():
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.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
###################
# PYNN (==pyhmf) #
###################
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)
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()
h276.drivers().disable(SynapseDriverOnHICANN(C.Enum(6)))
h276.drivers().disable(SynapseDriverOnHICANN(C.Enum(20)))
h276.drivers().disable(SynapseDriverOnHICANN(C.Enum(102)))
h276.drivers().disable(SynapseDriverOnHICANN(C.Enum(104)))
marocco.defects.inject(HICANNGlobal(Enum(276)), h276)
import numpy as np
import pyhmf as pynn
from pymarocco import PyMarocco
import Coordinate as C
from pysthal.command_line_util import init_logger
init_logger("ERROR", [('sthal', 'INFO')])
marocco = PyMarocco()
marocco.default_wafer = C.Wafer(30)
marocco.calib_path = "/wang/data/calibration/brainscales/wip"
marocco.defects.path = marocco.calib_path
marocco.backend = PyMarocco.Hardware
marocco.persist = "exercise_01.xml.gz"
marocco.checkl1locking = PyMarocco.CheckButIgnore
marocco.verification = PyMarocco.Skip
pynn.setup(marocco=marocco)
neuron_parameters = {
'cm': 0.2, # nF
'v_reset': -30, # mV
'v_rest': -20, # mV
'v_thresh': -16, # mV
'e_rev_I': -40, # mV
'e_rev_E': 0, # mV
'tau_m': 10, # ms
'tau_refrac': 1, # ms
'tau_syn_E': 5, # ms
'tau_syn_I': 5, # ms
}
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)