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 default_marocco():
marocco = pymarocco.PyMarocco()
marocco.neuron_placement.default_neuron_size(4)
marocco.synapse_routing.driver_chain_length(C.SynapseDriverOnQuadrant.size)
marocco.experiment.speedup(10000.)
marocco.defects.backend = pymarocco.Defects.Backend.Without
return marocco
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--prob', default=0.1, type=float)
parser.add_argument('--N', default=5000, type=int)
args = parser.parse_args()
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
start = datetime.now()
r = RandomNetwork(args.N, args.prob, marocco)
r.build()
mid = datetime.now()
r.run()
end = datetime.now()
result = {
"model" : "random_network",
"task" : "N{}_p{}".format(args.N, args.prob),
"timestamp" : datetime.now().isoformat(),
"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" : marocco.stats.getSynapses()
},
{"type" : "performance",
"name" : "neurons",
"value" : marocco.stats.getNumNeurons()
},
{"type" : "performance",
"name" : "synapse_loss",
"value" : marocco.stats.getSynapseLoss()
},
{"type" : "performance",
"name" : "synapse_loss_after_l1",
"value" : marocco.stats.getSynapseLossAfterL1Routing()
}
]
}
with open("random_N{}_p{}_results.json".format(args.N, args.prob), 'w') as outfile:
json.dump(result, outfile)
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 setUp(self):
init_logger("INFO", [
("marocco", "DEBUG"),
])
self.log = pylogging.get(__name__)
self.temporary_directory = tempfile.mkdtemp(prefix="marocco-test-")
self.marocco = pymarocco.PyMarocco()
self.marocco.backend = pymarocco.PyMarocco.Without
self.marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
self.marocco.defects.backend = pymarocco.Defects.Backend.Without
self.marocco.persist = os.path.join(self.temporary_directory,
"results.bin")
def setUp(self):
pylogging.reset()
pylogging.default_config(pylogging.LogLevel.ERROR)
pylogging.set_loglevel(
pylogging.get("marocco"), pylogging.LogLevel.INFO)
self.log = pylogging.get(__name__)
self.temporary_directory = tempfile.mkdtemp(prefix="marocco-test-")
self.marocco = pymarocco.PyMarocco()
self.marocco.backend = pymarocco.PyMarocco.None
self.marocco.persist = os.path.join(
self.temporary_directory, "results.bin")
self.marocco.neuron_placement.default_neuron_size(4)
def setUp(self):
init_logger("INFO", [
("marocco", "DEBUG"),
])
self.log = pylogging.get(__name__)
self.temporary_directory = tempfile.mkdtemp(prefix="marocco-test-")
self.marocco = pymarocco.PyMarocco()
self.marocco.backend = pymarocco.PyMarocco.None
self.marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
self.marocco.defects.backend = pymarocco.Defects.Backend.None
self.marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(
False)
self.marocco.persist = os.path.join(self.temporary_directory,
"results.bin")
def test_Addition(self):
import pymarocco
marocco = pymarocco.PyMarocco()
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
pynn.setup(marocco=marocco)
p1 = pynn.Population(100, pynn.IF_cond_exp)
p2 = pynn.Population(100, pynn.IF_cond_exp)
p = p1 + p2
self.assertEqual(len(p), len(p1) + len(p2))
pynn.run(1000)
def setUp(self):
pylogging.reset()
pylogging.default_config(pylogging.LogLevel.ERROR)
pylogging.set_loglevel(pylogging.get("marocco"),
pylogging.LogLevel.INFO)
self.log = pylogging.get(__name__)
self.temporary_directory = tempfile.mkdtemp(prefix="marocco-test-")
self.marocco = pymarocco.PyMarocco()
self.marocco.backend = pymarocco.PyMarocco.Without
self.marocco.persist = os.path.join(self.temporary_directory,
"results.bin")
self.marocco.neuron_placement.default_neuron_size(4)
self.marocco.continue_despite_synapse_loss = True
self.marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
self.marocco.defects.backend = pymarocco.Defects.Backend.Without
def ESS_available():
try:
import pymarocco
marocco = pymarocco.PyMarocco()
marocco.backend = pymarocco.PyMarocco.ESS
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.defects.backend = pymarocco.Defects.Backend.Without
marocco.hicann_configurator = pysthal.HICANNConfigurator()
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_FromListConnector(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
pop = pynn.Population(N, model)
connlist = [(0, 1, 0.1, 0.1), (0, 2, 0.1, 0.1), (0, 3, 0.1, 0.1)]
connector_e = pynn.FromListConnector(connlist)
proj_e = pynn.Projection(pop, pop, connector_e, target='excitatory')
pynn.run(100)
def test_Constructor(self):
import pymarocco
marocco = pymarocco.PyMarocco()
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
pynn.setup(marocco=marocco)
NPOP = 100
popus = [
pynn.Population(random.randint(10, 100), pynn.IF_cond_exp)
for x in range(0, NPOP)
]
a = pynn.Assembly(*popus)
size = sum([len(p) for p in popus])
self.assertEqual(len(a), size)
pynn.run(1000)
def runTest(self):
pylogging.reset()
pylogging.default_config(pylogging.LogLevel.INFO)
marocco = pymarocco.PyMarocco()
marocco.neuron_placement.default_neuron_size(8)
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.defects.backend = pymarocco.Defects.Backend.Without
marocco.hicann_configurator = pysthal.HICANNConfigurator()
marocco.continue_despite_synapse_loss = True
marocco.backend = pymarocco.PyMarocco.ESS
marocco.experiment_time_offset = 5e-7
n_exc = 100 # Number of excitatory neurons per group
sim_duration = 200.
pp_start = 50. # start = center of pulse-packet
weight_exc = 0.002 # uS weight for excitatory to excitatory connections
# (double than in reference paper)
pynn.setup(
max_delay=20.,
marocco=marocco,
)
# v_thresh close to v_rest to make sure there are some spikes
neuron_params = {
'v_rest': -65.,
'v_thresh': -62.5,
}
exc_pop = pynn.Population(n_exc, pynn.IF_cond_exp, neuron_params)
exc_pop.record()
pop_stim = pynn.Population(n_exc, pynn.SpikeSourceArray,
{'spike_times': [pp_start]})
conn = pynn.FixedNumberPreConnector(60, weights=weight_exc, delays=20.)
pynn.Projection(pop_stim, exc_pop, conn, target='excitatory')
pynn.run(sim_duration)
pynn.end()
def ESS_available():
try:
import pymarocco
marocco = pymarocco.PyMarocco()
marocco.backend = pymarocco.PyMarocco.ESS
marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(
False)
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.defects.backend = pymarocco.Defects.Backend.None
marocco.hicann_configurator = pymarocco.PyMarocco.HICANNConfigurator
pynn.setup(marocco=marocco)
pynn.run(1.)
return True
except RuntimeError as err:
if err.message == "ESS not available (compile with ESS)":
return False
else:
raise err
def test_cell_ids(self):
"""
tests that [Population,PopulationView,Assembly].getSpikes() uses the
expected cell ids, cf. issue #1955
"""
import pymarocco
marocco = pymarocco.PyMarocco()
marocco.backend = pymarocco.PyMarocco.ESS
marocco.experiment_time_offset = 5.e-7
marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(
False)
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.defects.backend = pymarocco.Defects.Backend.None
marocco.hicann_configurator = pymarocco.PyMarocco.HICANNConfigurator
setup_params = dict()
if pynn.__name__ == "pyhmf":
setup_params['marocco'] = marocco
pynn.setup(**setup_params)
# dummy target population
p_dummy = pynn.Population(10, pynn.IF_cond_exp)
# 1st Input Population
p1 = pynn.Population(10, pynn.SpikeSourceArray)
input_spikes1 = np.arange(1, 11., 1.).reshape(10, 1)
for n, spikes in enumerate(input_spikes1):
p1[n:n + 1].set('spike_times', spikes.tolist())
# 2nd Input Population
p2 = pynn.Population(10, pynn.SpikeSourceArray)
input_spikes2 = np.arange(11., 21., 1.).reshape(10, 1)
for n, spikes in enumerate(input_spikes2):
p2[n:n + 1].set('spike_times', spikes.tolist())
p1.record()
p2.record()
# dummy connections otherwise input populations are not mapped.
pynn.Projection(p1, p_dummy, pynn.OneToOneConnector())
pynn.Projection(p2, p_dummy, pynn.OneToOneConnector())
pynn.run(25.)
# check that cell ids refer to the index in the Population.
s_p1 = p1.getSpikes()
s_p1 = s_p1[np.argsort(s_p1[:, 1])] # sort by time
self.assertTrue(np.array_equal(range(10), s_p1[:, 0]))
s_p2 = p2.getSpikes()
s_p2 = s_p2[np.argsort(s_p2[:, 1])] # sort by time
self.assertTrue(np.array_equal(range(10), s_p2[:, 0]))
# for PopulationViews we also expect the index in the parent Population
self.assertEqual(set(p2[0:1].getSpikes()[:, 0]), set(range(1)))
self.assertEqual(set(p2[1:3].getSpikes()[:, 0]), set(range(1, 3)))
# In Assemblies, the cell id is equal to an offset given by the sum of
# the Population sizes of the previous items (Population or
# PopulationView), plus the index within in the Population.
a = pynn.Assembly(p2[0:5], p1)
s_a = a.getSpikes()
# when sorted, ids should be: range(10,20) + range(5)
s_a = s_a[np.argsort(s_a[:, 1])] # sort by time
self.assertTrue(np.array_equal(range(10, 20) + range(5), s_a[:, 0]))
def setUp(self, backend=pymarocco.PyMarocco.Without):
self.marocco = pymarocco.PyMarocco()
self.marocco.backend = backend
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--linearsize', '-l', default=5, type=int)
parser.add_argument('--dimension', '-d', type=int, default=2)
parser.add_argument('--nbiasneurons', '-b', type=int, default=1)
parser.add_argument('--nsources', '-n', type=int, default=20)
parser.add_argument('--ksources', '-k', type=int, default=5)
parser.add_argument('--sourcerate', '-r', type=float, default=20.)
parser.add_argument('--duplicates', '-p', type=int, default=1)
parser.add_argument('--wafer', '-w', type=int, default=33)
parser.add_argument('--shuffle_switches',
dest='shuffle_switches',
type=lambda x: bool(distutils.util.strtobool(x)),
default='false')
parser.add_argument('--name', type=str, default='ising_network')
args = parser.parse_args()
taskname = "l{}_d{}_b{}_n{}_k{}_p{}_w{}_s{}".format(
args.linearsize, args.dimension, args.nbiasneurons, args.nsources,
args.ksources, args.duplicates, args.wafer, args.shuffle_switches)
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.default_wafer = C.Wafer(args.wafer)
marocco.calib_path = "/wang/data/calibration/brainscales/default"
marocco.defects_path = "/wang/data/calibration/brainscales/default"
marocco.l1_routing.shuffle_switches(args.shuffle_switches)
marocco.persist = "results_{}_{}.xml.gz".format(args.name, taskname)
start = datetime.now()
r = IsingNetwork(marocco,
linearsize=args.linearsize,
dimension=args.dimension,
nbiasneurons=args.nbiasneurons,
nsources=args.nsources,
ksources=args.ksources,
sourcerate=args.sourcerate,
duplicates=args.duplicates)
r.build()
mid = datetime.now()
try:
r.run()
totsynapses = marocco.stats.getSynapses()
totneurons = marocco.stats.getNumNeurons()
lostsynapses = marocco.stats.getSynapseLoss()
lostsynapsesl1 = marocco.stats.getSynapseLossAfterL1Routing()
except RuntimeError:
# couldn't place all populations
totsynapses = 1
totneurons = 1
lostsynapses = 1
lostsynapsesl1 = 1
end = datetime.now()
result = {
"model":
args.name,
"task":
taskname,
"timestamp":
datetime.now().isoformat(),
"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)
def test_basic(self):
"""
tests whether synapses with short term plasticity are routed correctly.
Build a minimal network with 1 neuron and 3 spike sources each
connecting to with a different STP setting (depression, facilitation,
static) to the neuron.
Then check that the 3 synapses are routed via 3 different synaspe
drivers and that STP mode of the synapse drivers is as expected.
"""
marocco = pymarocco.PyMarocco()
marocco.backend = pymarocco.PyMarocco.None
marocco.neuron_placement.default_neuron_size(4)
marocco.wafer_cfg = os.path.join(self.temporary_directory, "wafer.bin")
marocco.persist = os.path.join(self.temporary_directory, "results.bin")
used_hicann = HICANNGlobal(Enum(0))
pynn.setup(marocco=marocco)
p1 = pynn.Population(1, pynn.IF_cond_exp)
# place to a certain HICANN to be able to extract config data afterwards
marocco.manual_placement.on_hicann(p1, used_hicann)
s1 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s2 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s3 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
depression = pynn.SynapseDynamics(fast=pynn.TsodyksMarkramMechanism(
U=0.4, tau_rec=200., tau_facil=0.))
facilitation = pynn.SynapseDynamics(fast=pynn.TsodyksMarkramMechanism(
U=0.4, tau_rec=0., tau_facil=200.))
static = None
prj1 = pynn.Projection(s1,
p1,
pynn.OneToOneConnector(weights=0.05),
synapse_dynamics=depression,
target="excitatory")
prj2 = pynn.Projection(s2,
p1,
pynn.OneToOneConnector(weights=0.05),
synapse_dynamics=facilitation,
target="excitatory")
prj3 = pynn.Projection(s3,
p1,
pynn.OneToOneConnector(weights=0.05),
synapse_dynamics=static,
target="excitatory")
p1.record()
pynn.run(1.)
h = debug_config.load_hicann_cfg(marocco.wafer_cfg, used_hicann)
# There should be 3 active drivers with 3 different STP modes
drivers = {}
num_active_drivers = 0
for driver in iter_all(SynapseDriverOnHICANN):
drv_cfg = h.synapses[driver]
if drv_cfg.is_enabled():
num_active_drivers += 1
if drv_cfg.is_stf():
drivers['facilitation'] = driver
elif drv_cfg.is_std():
drivers['depression'] = driver
else:
drivers['static'] = driver
self.assertEqual(num_active_drivers, 3)
self.assertEqual(len(drivers), 3)
results = Marocco.from_file(marocco.persist)
# check that synapses are on the drivers with the correct mode
for src, mode in [(s1, 'depression'), (s2, 'facilitation'),
(s3, 'static')]:
items = list(results.placement.find(src[0]))
self.assertEqual(1, len(items))
item = items[0]
addr = item.address().toL1Address()
syns = debug_config.find_synapses(h.synapses, drivers[mode], addr)
self.assertEqual(len(syns),
1) # the addr of the source should be found once
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--prob', default=0.1, type=float)
parser.add_argument('--N', default=5000, type=int)
parser.add_argument('--name', default="random_network", type=str)
parser.add_argument('--defects_path', type=str)
parser.add_argument('--wafer', '-w', type=int, default=24)
args = parser.parse_args()
taskname = "N{}_p{}_wafer{}".format(args.N, args.prob, args.wafer)
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.calib_path = "/wang/data/calibration/brainscales/default"
marocco.default_wafer = C.Wafer(args.wafer)
marocco.defects.backend = Defects.Backend.XML
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"
marocco.persist = "results_{}_{}.xml.gz".format(args.name, taskname)
start = datetime.now()
r = RandomNetwork(args.N, args.prob, marocco)
r.build()
mid = datetime.now()
try:
r.run()
totsynapses = marocco.stats.getSynapses()
totneurons = marocco.stats.getNumNeurons()
lostsynapses = marocco.stats.getSynapseLoss()
lostsynapsesl1 = marocco.stats.getSynapseLossAfterL1Routing()
except RuntimeError:
# couldn't place all populations
totsynapses = 1
totneurons = 1
lostsynapses = 1
lostsynapsesl1 = 1
end = datetime.now()
result = {
"model": args.name,
"task": taskname,
"timestamp": datetime.now().isoformat(),
"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)
def setUp(self, backend=pymarocco.PyMarocco.None):
self.marocco = pymarocco.PyMarocco()
self.marocco.backend = backend
def test_basic(self):
"""
tests the routing and parameter trafo of a IF_multicond_exp neuron
with 4 different synaptic input settings.
For 4 synaptic targets and hardware neuron size 4, the mapping of
synapse types is as follows:
Denmem: | 0 | 1 |
Synapse Type: |0 1|2 3| (left and right input)
Build a minimal network with 1 neuron and 4 spike sources each
connecting to different synaptic target on the neuron. Then check that
the configuration of the synapse driver and synapses is as expected.
Furthermore, check that the different parameters for e_rev and tau_syn
are correctly transformed by getting the FG values (qualitatively).
"""
marocco = pymarocco.PyMarocco()
marocco.backend = pymarocco.PyMarocco.Without
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.defects.backend = pymarocco.Defects.Backend.Without
marocco.neuron_placement.default_neuron_size(4)
marocco.wafer_cfg = os.path.join(self.temporary_directory, "wafer.bin")
marocco.persist = os.path.join(self.temporary_directory, "results.bin")
used_hicann = HICANNGlobal(Enum(0))
pynn.setup(marocco=marocco)
p1 = pynn.Population(1, pynn.IF_multicond_exp)
# we use 4 different time constants and reversal potentials
p1.set('e_rev', [0., -10, -80, -100])
p1.set('tau_syn', [2, 3, 4, 5])
# place to a certain HICANN to be able to extract config data afterwards
topleft = NeuronOnWafer(NeuronOnHICANN(X(0), Y(0)), used_hicann)
logical_neuron = LogicalNeuron.rectangular(topleft, size=4)
marocco.manual_placement.on_neuron(p1, logical_neuron)
s1 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s2 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s3 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
s4 = pynn.Population(1, pynn.SpikeSourcePoisson, {'rate': 5.})
prj1 = pynn.Projection(s1,
p1,
pynn.OneToOneConnector(weights=0.01),
target="0")
prj2 = pynn.Projection(s2,
p1,
pynn.OneToOneConnector(weights=0.01),
target="1")
prj3 = pynn.Projection(s3,
p1,
pynn.OneToOneConnector(weights=0.01),
target="2")
prj4 = pynn.Projection(s4,
p1,
pynn.OneToOneConnector(weights=0.01),
target="3")
p1.record()
pynn.run(1.)
h = debug_config.load_hicann_cfg(marocco.wafer_cfg, used_hicann)
# routing config
active_drivers = []
driver_c = None
for driver in iter_all(SynapseDriverOnHICANN):
drv_cfg = h.synapses[driver]
if drv_cfg.is_enabled():
active_drivers.append(drv_cfg)
driver_c = driver
assert len(active_drivers) == 1
act_drv = active_drivers[0]
# two different synaptic input sides are used on the synapse driver
syn_input_top = debug_config.get_syn_in_side(
act_drv[RowOnSynapseDriver(top)])
syn_input_bot = debug_config.get_syn_in_side(
act_drv[RowOnSynapseDriver(bottom)])
self.assertNotEqual(syn_input_top, syn_input_bot)
# assumed column and input side:
exptected_mapping = [(s1, SynapseColumnOnHICANN(0), left),
(s2, SynapseColumnOnHICANN(0), right),
(s3, SynapseColumnOnHICANN(1), left),
(s4, SynapseColumnOnHICANN(1), right)]
results = Marocco.from_file(marocco.persist)
for (src, col, side) in exptected_mapping:
items = list(results.placement.find(src[0]))
self.assertEqual(1, len(items))
item = items[0]
addr = item.address().toL1Address()
syns = debug_config.find_synapses(h.synapses, driver_c, addr)
self.assertEqual(1, len(syns))
syn = syns[0]
# check synapse column
self.assertEqual(syn.toSynapseColumnOnHICANN(), col)
# check synaptic input side
row_addr = syn.toSynapseRowOnHICANN()
self.assertEqual(
debug_config.get_syn_in_side(
act_drv[row_addr.toRowOnSynapseDriver()]), side)
# FG values
nrn_left = NeuronOnHICANN(X(0), Y(0))
nrn_right = NeuronOnHICANN(X(1), Y(0))
fgs = h.floating_gates
# e_rev params are montonic decreasing
E1 = fgs.getNeuron(nrn_left, nrn_param.E_synx)
E2 = fgs.getNeuron(nrn_left, nrn_param.E_syni)
E3 = fgs.getNeuron(nrn_right, nrn_param.E_synx)
E4 = fgs.getNeuron(nrn_right, nrn_param.E_syni)
E = [E1, E2, E3, E4]
for k, l in zip(E, E[1:]):
self.assertGreater(k, l)
# tau_syn params are montonic increasing
T1 = fgs.getNeuron(nrn_left, nrn_param.V_syntcx)
T2 = fgs.getNeuron(nrn_left, nrn_param.V_syntci)
T3 = fgs.getNeuron(nrn_right, nrn_param.V_syntcx)
T4 = fgs.getNeuron(nrn_right, nrn_param.V_syntci)
T = [T1, T2, T3, T4]
# HICANN V4: The lower the DAC-Value, the higher the time constant
for k, l in zip(T, T[1:]):
self.assertGreater(k, l)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--N',
default=10,
type=int,
help='Edge size of the visible layer. \
The number of neurons in the visible\
layer is hence NxN')
parser.add_argument('--K',
default=8,
type=int,
help='Edge size of the local receptive fields.\
K has to be larger than N.')
parser.add_argument('--L',
default=10,
type=int,
help='Number of neurons in the label layer.')
parser.add_argument('--name', default="fullyVisibleBm_network", type=str)
args = parser.parse_args()
# The edge size of the visible layer has to be larger or equal
# than the edge size of the receptive fields
if args.N < args.K:
sys.exit('The edge size of the visible layer {0}'
' has to be larger than the edge size {1}'
' of the local receptive '
' fields!'.format(args.N, args.K))
taskname = "N{}_K{}_L{}".format(args.N, args.K, args.L)
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.calib_path = "/wang/data/calibration/brainscales/default"
marocco.defects_path = "/wang/data/calibration/brainscales/default"
marocco.persist = "results_{}_{}.xml.gz".format(args.name, taskname)
start = datetime.now()
r = rbmLocalReceptiveFieldsNetwork(args.N, args.K, args.L, marocco)
r.build()
mid = datetime.now()
try:
r.run()
totsynapses = marocco.stats.getSynapses()
totneurons = marocco.stats.getNumNeurons()
lostsynapses = marocco.stats.getSynapseLoss()
lostsynapsesl1 = marocco.stats.getSynapseLossAfterL1Routing()
except RuntimeError:
# couldn't place all populations
totsynapses = 1
totneurons = 1
lostsynapses = 1
lostsynapsesl1 = 1
end = datetime.now()
result = {
"model":
args.name,
"task":
taskname,
"timestamp":
datetime.now().isoformat(),
"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)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--K', default=20, type=int)
parser.add_argument('--N', default=500, type=int)
parser.add_argument('--name', default="random_network", type=str)
args = parser.parse_args()
taskname = "N{}_K{}".format(args.N, args.K)
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.calib_path = "/wang/data/calibration/brainscales/default"
marocco.defects_path = "/wang/data/calibration/brainscales/default"
marocco.persist = "results_{}_{}.xml.gz".format(args.name, taskname)
start = datetime.now()
r = pfeilsNoiseNetwork(args.N, args.K, marocco)
r.build()
mid = datetime.now()
try:
r.run()
totsynapses = marocco.stats.getSynapses()
totneurons = marocco.stats.getNumNeurons()
lostsynapses = marocco.stats.getSynapseLoss()
lostsynapsesl1 = marocco.stats.getSynapseLossAfterL1Routing()
except RuntimeError:
# couldn't place all populations
totsynapses = 1
totneurons = 1
lostsynapses = 1
lostsynapsesl1 = 1
end = datetime.now()
result = {
"model":
args.name,
"task":
taskname,
"timestamp":
datetime.now().isoformat(),
"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)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--num_layers', default=2, type=int)
parser.add_argument('--conn_prob', default=1., type=float)
parser.add_argument('--neurons_per_layer', default=200, type=int)
parser.add_argument('--name',
default="feedforward_layered_network",
type=str)
args = parser.parse_args()
taskname = "num_layers{}_neurons_per_layer{}_conn_prob{}".format(
args.num_layers, args.neurons_per_layer, args.conn_prob)
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.calib_path = "/wang/data/calibration/brainscales/default"
marocco.defects_path = "/wang/data/calibration/brainscales/default"
marocco.persist = "results_{}_{}.xml.gz".format(args.name, taskname)
start = datetime.now()
r = FeedforwardNetwork(args.num_layers, args.conn_prob,
args.neurons_per_layer, marocco)
r.build()
mid = datetime.now()
try:
r.run()
totsynapses = marocco.stats.getSynapses()
totneurons = marocco.stats.getNumNeurons()
lostsynapses = marocco.stats.getSynapseLoss()
lostsynapsesl1 = marocco.stats.getSynapseLossAfterL1Routing()
except RuntimeError:
# couldn't place all populations
totsynapses = 1
totneurons = 1
lostsynapses = 1
lostsynapsesl1 = 1
end = datetime.now()
result = {
"model":
args.name,
"task":
taskname,
"timestamp":
datetime.now().isoformat(),
"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)
print(
"{}\n{}\nSynapses lost: {}; L1 synapses lost: {}; relative synapse lost: {}"
.format(sys.argv, taskname, lostsynapses, lostsynapsesl1,
float(lostsynapses) / totsynapses))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--N', default=5000, type=int,
help='The number of the neurons in the visible layer')
parser.add_argument('--Nhidden', default=0, type=int,
help='The number of the neurons in the hidden layer. '
'If 0 or not specified then the number of hidden '
'neurons equals the number of visible neurons.')
parser.add_argument('--name', default="fullyVisibleBm_network", type=str)
args = parser.parse_args()
# If the number of hidden neurons is not specified then it should be equal
# to the number of visibel neurons
if args.Nhidden == 0:
args.Nhidden = args.N
taskname = "Nvisible{}_Nhidden{}".format(args.N, args.Nhidden)
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
marocco.calib_path = "/wang/data/calibration/brainscales/default"
marocco.defects_path = "/wang/data/calibration/brainscales/default"
marocco.persist = "results_{}_{}.xml.gz".format(args.name, taskname)
start = datetime.now()
r = rbmNetwork(args.N, args.Nhidden, marocco)
r.build()
mid = datetime.now()
try:
r.run()
totsynapses = marocco.stats.getSynapses()
totneurons = marocco.stats.getNumNeurons()
lostsynapses = marocco.stats.getSynapseLoss()
lostsynapsesl1 = marocco.stats.getSynapseLossAfterL1Routing()
except RuntimeError:
# couldn't place all populations
totsynapses = 1
totneurons = 1
lostsynapses = 1
lostsynapsesl1 = 1
end = datetime.now()
result = {
"model": args.name,
"task": taskname,
"timestamp": datetime.now().isoformat(),
"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)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--num_layers', default=2, type=int)
parser.add_argument('--conn_prob', default = 1., type=float)
parser.add_argument('--neurons_per_layer', default = 200, type=int)
args = parser.parse_args()
marocco = pymarocco.PyMarocco()
marocco.continue_despite_synapse_loss = True
marocco.calib_backend = pymarocco.PyMarocco.CalibBackend.Default
start = datetime.now()
r = LayeredFeedforwardNetwork(args.num_layers, args.conn_prob, args.neurons_per_layer, marocco)
r.build()
mid = datetime.now()
r.run()
end = datetime.now()
result = {
"model" : "random_network",
"num_layers": args.num_layers,
"syn_loss": float(marocco.stats.getSynapseLoss())/marocco.stats.getSynapses(),
"conn_prob": args.conn_prob,
"neurons_per_layer": args.neurons_per_layer,
"task" : "num_layers{}_conn_prob{}_neurons_per_layer{}".format(args.num_layers,\
args.conn_prob, args.neurons_per_layer),
"timestamp" : datetime.now().isoformat(),
"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" : marocco.stats.getSynapses()
},
{"type" : "performance",
"name" : "neurons",
"value" : marocco.stats.getNumNeurons()
},
{"type" : "performance",
"name" : "synapse_loss",
"value" : marocco.stats.getSynapseLoss()
},
{"type" : "performance",
"name" : "synapse_loss_after_l1",
"value" : marocco.stats.getSynapseLossAfterL1Routing()
}
]
}
with open("feedforward_layered_num_layers{}_conn_prob{}neurons_per_layer{}_results.json".format(args.num_layers,\
args.conn_prob, args.neurons_per_layer), 'w') as outfile:
json.dump(result, outfile)