def test_save_and_load(self):
import pysthal
from pyhalco_common import Enum
import pyhalco_hicann_v2 as Coordinate
from pyhalbe import HICANN
wafer = pysthal.Wafer(Coordinate.Wafer(3))
hicann1 = wafer[Coordinate.HICANNOnWafer(Enum(30))]
for row in Coordinate.iter_all(Coordinate.SynapseRowOnHICANN):
d_pattern = numpy.random.randint(0, 16, 256)
d_pattern[d_pattern[0] + 23] = 15
hicann1.synapses[row].decoders[:] = [
HICANN.SynapseDecoder(int(ii)) for ii in d_pattern
]
w_pattern = numpy.random.randint(0, 16, 256)
w_pattern[w_pattern[0] + 23] = 15
hicann1.synapses[row].weights[:] = [
HICANN.SynapseWeight(int(ii)) for ii in w_pattern
]
wafer2 = pysthal.Wafer(Coordinate.Wafer(0))
hicann2 = wafer2[Coordinate.HICANNOnWafer(Enum(42))]
self.assertNotEqual(str(wafer.status()), str(wafer2.status()))
for row in Coordinate.iter_all(Coordinate.SynapseRowOnHICANN):
d1 = hicann1.synapses[row].decoders
d2 = hicann2.synapses[row].decoders
self.assertNotEqual(d1, d2)
w1 = hicann1.synapses[row].weights
w2 = hicann2.synapses[row].weights
self.assertNotEqual(w1, w2)
with tempfile.NamedTemporaryFile() as f:
wafer.dump(f.name, True)
wafer2.load(f.name)
self.assertEqual(wafer.size(), wafer2.size())
hicann1 = wafer[Coordinate.HICANNOnWafer(Enum(30))]
hicann2 = wafer2[Coordinate.HICANNOnWafer(Enum(30))]
self.assertEqual(hicann1.index(), hicann2.index())
self.assertEqual(str(wafer.status()), str(wafer2.status()))
for row in Coordinate.iter_all(Coordinate.SynapseRowOnHICANN):
d1 = hicann1.synapses[row].decoders
d2 = hicann2.synapses[row].decoders
self.assertEqual(d1, d2)
w1 = hicann1.synapses[row].weights
w2 = hicann2.synapses[row].weights
self.assertEqual(w1, w2)
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)
def test_synapse_access(self):
import pysthal
import numpy
import pyhalco_common
import pyhalco_hicann_v2
from pyhalbe import HICANN
d_patterns = {}
w_patterns = {}
hicann = pysthal.HICANN()
for row in pyhalco_common.iter_all(
pyhalco_hicann_v2.SynapseRowOnHICANN):
d_pattern = numpy.random.randint(0, 16, 256)
d_patterns[row] = d_pattern
hicann.synapses[row].decoders[:] = [
HICANN.SynapseDecoder(int(ii)) for ii in d_pattern
]
w_pattern = [
HICANN.SynapseWeight(int(ii))
for ii in numpy.random.randint(0, 16, 256)
]
w_patterns[row] = w_pattern
hicann.synapses[row].weights[:] = w_pattern
for drv in pyhalco_common.iter_all(
pyhalco_hicann_v2.SynapseDriverOnHICANN):
double_row = hicann.synapses.getDecoderDoubleRow(drv)
for x in (pyhalco_common.top, pyhalco_common.bottom):
row = pyhalco_hicann_v2.SynapseRowOnHICANN(drv, x)
data = numpy.array([int(ii) for ii in double_row[x.value()]])
if not numpy.all(data == d_patterns[row]):
err = "Missmatch in decoder values: {!s} != {!s} in {!s}".format(
data, d_patterns[row], row)
self.fail(err)
for syn in pyhalco_common.iter_all(pyhalco_hicann_v2.SynapseOnHICANN):
hicann.synapses[syn]
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 =========================== ###
sim.setup(timestep=1.0, min_delay=1.0, marocco=marocco, marocco_runtime=runtime)
e_rev = 92 # mV
# e_rev = 500.0 #mV
base_params = {
# 'cm': 0.1, # nF
# 'v_reset': -70., # mV
# 'v_rest': -65., # mV
# 'v_thresh': -55., # mV
# 'tau_m': 20., # ms
# 'tau_refrac': 1., # ms
# 'tau_syn_E': 5.0, # ms