def set_digital_weights(in_mtx, projections, total_in, total_out, bss_runtime, digital_w=15):
n_per_out = total_out // len(projections[0])
original_decoders = {}
for i, prjs in enumerate(projections):
for j, p in enumerate(prjs):
rtime_res = bss_runtime.results()
synapses = rtime_res.synapse_routing.synapses()
proj_items = synapses.find(p)
for _item in proj_items:
syn = _item.hardware_synapse()
pre = _item.source_neuron().neuron_index()
post = _item.target_neuron().neuron_index()
post += j * n_per_out
w = in_mtx[pre, post]
proxy = runtime.wafer()[syn.toHICANNOnWafer()].synapses[syn]
if syn not in original_decoders:
original_decoders[syn] = copy.copy(proxy.decoder)
if np.isnan(w):
proxy.weight = HICANN.SynapseWeight(0)
### SETTING SYNAPSE TO DISABLED DECODER, DISABLING SYNAPSE
proxy.decoder = SYNAPSE_DECODER_DISABLED_SYNAPSE
elif w <= 0.0:
proxy.weight = HICANN.SynapseWeight(0)
proxy.decoder = original_decoders[syn]
else:
proxy.weight = HICANN.SynapseWeight(digital_w)
proxy.decoder = original_decoders[syn]
def set_digital_weights(weights, projection, bss_runtime, digital_w=15):
total_in, total_out = weights.shape
original_decoders = {}
rtime_res = bss_runtime.results()
synapses = rtime_res.synapse_routing.synapses()
proj_items = synapses.find(projection)
for _item in proj_items:
syn = _item.hardware_synapse()
pre = _item.source_neuron().neuron_index()
post = _item.target_neuron().neuron_index()
w = weights[pre, post]
proxy = bss_runtime.wafer()[syn.toHICANNOnWafer()].synapses[syn]
if syn not in original_decoders:
original_decoders[syn] = copy.copy(proxy.decoder)
if np.isnan(w):
proxy.weight = HICANN.SynapseWeight(0)
### SETTING SYNAPSE TO DISABLED DECODER, DISABLING SYNAPSE
proxy.decoder = SYNAPSE_DECODER_DISABLED_SYNAPSE
elif w <= 0.0:
proxy.weight = HICANN.SynapseWeight(0)
proxy.decoder = original_decoders[syn]
else:
proxy.weight = HICANN.SynapseWeight(digital_w)
proxy.decoder = original_decoders[syn]
def set_digital_weights(self,
digital_weight=15,
zero_all=False,
blacklists={}):
runtime = self.BSS_runtime
original_decoders = {}
for k in sorted(self._projections.keys()):
proj = self._projections[k]
if proj._digital_weights_ is None:
continue
dw_sum = 0
to = self.get_target_pop_name(k)
fr = self.get_source_pop_name(k)
[raw_fr, raw_to] = k.split(' to ')
min_w, max_w = proj.w_min, proj.w_max
rtime_res = runtime.results()
synapses = rtime_res.synapse_routing.synapses()
proj_items = synapses.find(proj)
digital_w = digital_weight if proj._digital_weights_ is None \
else proj._digital_weights_
fr_black = blacklists.get(raw_fr, {})
to_black = blacklists.get(raw_to, {})
for proj_item in proj_items:
synapse = proj_item.hardware_synapse()
pre = proj_item.source_neuron().neuron_index()
post = proj_item.target_neuron().neuron_index()
thr = (min_w + max_w) / 2.0
mw = proj.__weight_matrix[pre, post]
if np.isnan(mw):
dw = 0.0
else:
if mw < thr or zero_all or \
pre in fr_black or post in to_black:
dw = 0.0
else:
dw = digital_w
dw_sum += int(dw > 0)
proxy = runtime.wafer()[
synapse.toHICANNOnWafer()].synapses[synapse]
if synapse not in original_decoders:
original_decoders[synapse] = copy.copy(proxy.decoder)
if dw > 0:
proxy.weight = HICANN.SynapseWeight(dw)
proxy.decoder = original_decoders[synapse]
else:
print("++--++ DISABLE_SYNAPSE --++--")
print("pre, post, mw = {}, {}, {}".format(pre, post, mw))
proxy.weight = HICANN.SynapseWeight(0)
proxy.decoder = self.SYNAPSE_DECODER_DISABLED_SYNAPSE
print("--++-- END OF DISABLE_SYNAPSE ++--++")
def zero_digital_weights(projections,
total_in,
total_out,
bss_runtime,
digital_w=15):
n_per_out = total_out // len(projections[0])
in_mtx = np.zeros((total_in, total_out))
for i, prjs in enumerate(projections):
for j, p in enumerate(prjs):
c0 = j * n_per_out
c1 = c0 + n_per_out
in_mtx[i, c0:c1] = p.getWeights(format='array')
out_mtx = in_mtx.copy()
whr = np.where(~np.isnan(out_mtx))
zeros = np.where(np.random.uniform(0.0, 1.0, size=whr[0].shape) <= 1.0)
rows, cols = whr[0][zeros], whr[1][zeros]
out_mtx[rows, cols] = 0
original_decoders = {}
for i, prjs in enumerate(projections):
for j, p in enumerate(prjs):
rtime_res = bss_runtime.results()
synapses = rtime_res.synapse_routing.synapses()
proj_items = synapses.find(p)
for _item in proj_items:
syn = _item.hardware_synapse()
pre = _item.source_neuron().neuron_index()
post = _item.target_neuron().neuron_index()
post += j * n_per_out
w = out_mtx[pre, post]
proxy = runtime.wafer()[syn.toHICANNOnWafer()].synapses[syn]
if syn not in original_decoders:
original_decoders[syn] = copy.copy(proxy.decoder)
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
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 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]
for block in iter_all(FGBlockOnHICANN):
fgs.setShared(block, HICANN.shared_parameter.V_dllres, 275)
fgs.setShared(block, HICANN.shared_parameter.V_ccas, 800)
# call at least once
set_sthal_params(runtime.wafer(), gmax=1023, gmax_div=2)
# ——— configure hardware ——————————————————————————————————————————————————————
for proj in projections:
proj_items = runtime.results().synapse_routing.synapses().find(proj)
for proj_item in proj_items:
synapse = proj_item.hardware_synapse()
proxy = runtime.wafer()[synapse.toHICANNOnWafer()].synapses[synapse]
proxy.weight = HICANN.SynapseWeight(15)
marocco.skip_mapping = True
marocco.backend = PyMarocco.Hardware
fgs = runtime.wafer()[hicann].floating_gates
calibrated_E_l_DACs = {}
for neuron in pop:
for item in runtime.results().placement.find(neuron):
for denmem in item.logical_neuron():
calibrated_E_l_DACs[denmem] = fgs.getNeuron(denmem, HICANN.E_l)
for n, delta_E_l_DAC in enumerate([-200, -100, 0, 100, 200]):
wafer[hicann].synapses[driver][row].set_gmax_div(
C.left, gmax_div)
wafer[hicann].synapses[driver][row].set_gmax_div(
C.right, gmax_div)
set_sthal_params(runtime.wafer(), gmax=1023, gmax_div=1)
# ——— configure hardware ——————————————————————————————————————————————————————
marocco.skip_mapping = True
marocco.backend = PyMarocco.Hardware
# Full configuration during first step
marocco.hicann_configurator = PyMarocco.HICANNv4Configurator
for digital_weight in [5, 10, 15]:
logger.info("running measurement with digital weight {}".format(digital_weight))
for proj in projections:
proj_item, = runtime.results().synapse_routing.synapses().find(proj)
synapse = proj_item.hardware_synapse()
proxy = runtime.wafer()[synapse.toHICANNOnWafer()].synapses[synapse]
proxy.weight = HICANN.SynapseWeight(digital_weight)
pynn.run(duration)
np.savetxt("membrane_w{}.txt".format(digital_weight), pop.get_v())
np.savetxt("spikes_w{}.txt".format(digital_weight), pop.getSpikes())
pynn.reset()
# only change digital parameters from now on
marocco.hicann_configurator = PyMarocco.NoResetNoFGConfigurator