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_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_has_outbound_mergers(self): import pyhalbe import pysthal from pyhalco_common import Enum import pyhalco_hicann_v2 as C wafer_c = C.Wafer(33) gbitlink_c = C.GbitLinkOnHICANN(Enum(0)) fpga_on_wafer_c = C.FPGAOnWafer(Enum(0)) fpga_c = C.FPGAGlobal(fpga_on_wafer_c, wafer_c) hicann_cs = [ C.HICANNGlobal(h, wafer_c) for h in fpga_c.toHICANNOnWafer() ] hicann_c = hicann_cs[0] hicann_on_dnc_c = hicann_c.toHICANNOnWafer().toHICANNOnDNC() dnc_on_fpga_c = hicann_c.toDNCOnFPGA() w = pysthal.Wafer() h = w[hicann_c.toHICANNOnWafer()] f = w[fpga_on_wafer_c] self.assertFalse(f.hasOutboundMergers()) f[dnc_on_fpga_c][hicann_on_dnc_c].layer1[ gbitlink_c] = pyhalbe.HICANN.GbitLink.Direction.TO_DNC self.assertTrue(f.hasOutboundMergers())
def __init__(self, *args, **kwargs): super(Test_Pyhwdb, self).__init__(*args, **kwargs) if IS_PYPLUSPLUS: self.WAFER_COORD = coord.Wafer(10) self.WAFER_SETUP_TYPE = coord.SetupType.BSSWafer self.WAFER_MACU_IP = coord.IPv4.from_string("192.168.10.120") self.FPGA_COORD = coord.FPGAOnWafer(0) self.FPGA_HIGHSPEED = True self.FPGA_IP = coord.IPv4.from_string("192.168.10.1") if IS_PYPLUSPLUS: self.RETICLE_COORD = coord.DNCOnWafer(coord.common.Enum(0)) self.RETICLE_TO_BE_POWERED = False self.HICANN_COORD = coord.HICANNOnWafer(coord.common.Enum(144)) self.HICANN_VERSION = 4 self.HICANN_LABEL = "bla" self.ADC_COORD = "B123456" self.ADC_MODE = "LOAD_CALIBRATION" self.ADC_CHAN = coord.ChannelOnADC(0) self.ADC_TRIGGER = coord.TriggerOnADC(1) self.ADC_IP = coord.IPv4.from_string("192.168.10.120") if IS_PYPLUSPLUS: self.ADC_PORT = coord.TCPPort(10101) self.DLS_SETUP_ID = "07_20" self.HXCUBE_ID = 9
def test_numpy_policies(self): import numpy import pysthal import pyhalco_hicann_v2 from pyhalbe import HICANN w = pysthal.Wafer(pyhalco_hicann_v2.Wafer()) h = w[pyhalco_hicann_v2.HICANNOnWafer()] addrs = numpy.array(numpy.random.randint(64, size=100), dtype=numpy.ushort) times = numpy.cumsum(numpy.random.poisson(10.0, size=100)) * 1.e-6 in_spikes = pysthal.Vector_Spike() for addr, t in zip(addrs, times): in_spikes.append(pysthal.Spike(HICANN.L1Address(addr), t)) link = pyhalco_hicann_v2.GbitLinkOnHICANN(3) h.sendSpikes(link, in_spikes) h.sortSpikes() x = h.sentSpikes(link) times_t, addrs_t = x.T numpy.testing.assert_allclose(times, times_t, rtol=0.0, atol=1.0 / 250e6) numpy.testing.assert_array_equal( addrs, numpy.array(addrs_t, dtype=numpy.ushort))
def test_dnc_copy(self): import copy wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNGlobal(C.HICANNOnWafer(Enum(297)), wafer_c) h = w[h_c.toHICANNOnWafer()] d = w[h_c.toFPGAOnWafer()][h_c.toDNCOnFPGA()] d2 = copy.deepcopy(d) self.assertEqual(d, d2) # change something to ensure that it's not a mere pointer copy h2 = w[C.HICANNOnWafer(Enum(298))] self.assertNotEqual(d, d2)
def test_dnc_pickle(self): import pickle wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNGlobal(C.HICANNOnWafer(Enum(297)), wafer_c) h = w[h_c.toHICANNOnWafer()] d = w[h_c.toFPGAOnWafer()][h_c.toDNCOnFPGA()] d_str = pickle.dumps(d) d2 = pickle.loads(d_str) self.assertEqual(d, d2) # change something to ensure that it's not a mere pointer copy h2 = w[C.HICANNOnWafer(Enum(298))] self.assertNotEqual(d, d2)
def test_wafer_copy(self): import copy wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNOnWafer(Enum(297)) h = w[h_c] self.assertTrue(h.has_wafer()) w2 = copy.deepcopy(w) self.assertEqual(w, w2) h2 = w2[h_c] self.assertTrue(h2.has_wafer()) # change something to ensure that it's not a mere pointer copy h.set_neuron_size(2) self.assertNotEqual(w, w2)
def test_wafer_pickle(self): import pickle wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNOnWafer(Enum(297)) h = w[h_c] self.assertTrue(h.has_wafer()) w_str = pickle.dumps(w) w2 = pickle.loads(w_str) self.assertEqual(w, w2) h2 = w2[h_c] self.assertTrue(h2.has_wafer()) # change something to ensure that it's not a mere pointer copy h.set_neuron_size(2) self.assertNotEqual(w, w2)
def test_common_FPGA_config(self): import pysthal import pyhalco_hicann_v2 w = pysthal.Wafer(pyhalco_hicann_v2.Wafer()) s1 = w.commonFPGASettings() s2 = w.commonFPGASettings() s1.setPLL(200.0e6) self.assertEqual(s1.getPLL(), s2.getPLL()) s3 = w.commonFPGASettings() self.assertEqual(s1.getPLL(), s3.getPLL()) for pll in (100.0e6, 150.0e6, 200.0e6, 250.0e6): s1.setPLL(pll) for pll in (53.0e6, 32.0e6, 430.e6, 170.e6): self.assertRaises(ValueError, s1.setPLL, pll)
def test_wafer_dumpnload(self): import tempfile wafer_c = C.Wafer(33) w = pysthal.Wafer(wafer_c) h_c = C.HICANNOnWafer(Enum(297)) h = w[h_c] with tempfile.NamedTemporaryFile() as f: w.dump(f.name, True) w2 = pysthal.Wafer(wafer_c) w2.load(f.name) self.assertEqual(w, w2) h2 = w2[h_c] self.assertTrue(h2.has_wafer()) # change something to ensure that it's not a mere pointer copy h.set_neuron_size(2) self.assertNotEqual(w, w2)
def setUp(self): super(TestMultiHICANN, self).setUp() pylogging.set_loglevel(pylogging.get("Default"), pylogging.LogLevel.ERROR) pylogging.set_loglevel(pylogging.get("sthal"), pylogging.LogLevel.INFO) if None in (self.WAFER, self.HICANN): return self.wafer_c = Coord.Wafer(self.WAFER) self.w = pysthal.Wafer(self.wafer_c) self.h1 = self.w[Coord.HICANNOnWafer(Enum(324))] self.h2 = self.w[Coord.HICANNOnWafer(Enum(120))] self.addCleanup(self.w.disconnect)
def test_custom_db(self): db = pyhwdb.database() wafer = pyhwdb.WaferEntry() wafer.setup_type = coord.SetupType.BSSWafer wafer_coord = coord.Wafer(10) db.add_wafer_entry(wafer_coord, wafer) fpga = pyhwdb.FPGAEntry() fpga_coord = coord.FPGAGlobal(coord.FPGAOnWafer(0), wafer_coord) db.add_fpga_entry(fpga_coord, fpga) licenses, tres = generate_license_strings(db) # licenses is generated from set -> order not guaranteed self.assertTrue(licenses == "Licenses=W10F0,W10T8" or licenses == "Licenses=W10T8,W10F0") self.assertTrue( tres == "AccountingStorageTRES=License/W10F0,License/W10T8" or tres == "AccountingStorageTRES=License/W10T8,License/W10F0") try: tmpdirname = tempfile.mkdtemp() lic_tmp_file = os.path.join(tmpdirname, str(uuid.uuid4())) tres_tmp_file = os.path.join(tmpdirname, str(uuid.uuid4())) create_license_files(db, lic_tmp_file, tres_tmp_file) with open(lic_tmp_file, "r") as file: content = file.read() self.assertTrue( any(lic in content for lic in ["Licenses=W10F0,W10T8", "Licenses=W10T8,W10F0"])) with open(tres_tmp_file, "r") as file: content = file.read() self.assertTrue( any(tres in content for tres in [ "AccountingStorageTRES=License/W10F0,License/W10T8", "AccountingStorageTRES=License/W10T8,License/W10F0" ])) finally: shutil.rmtree(tmpdirname)
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)
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) parser.add_argument('--defects_path', type=str) parser.add_argument('--wafer', '-w', type=int, default=24) 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{}_wafer{}".format(args.N, args.K, args.L, 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 = 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('--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) parser.add_argument('--defects_path', type=str) parser.add_argument('--wafer', '-w', type=int, default=24) args = parser.parse_args() taskname = "num_layers{}_neurons_per_layer{}_conn_prob{}_wafer{}".format( args.num_layers, args.neurons_per_layer, args.conn_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 = 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) parser.add_argument('--defects_path', type=str) parser.add_argument('--wafer', '-w', type=int, default=24) 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{}_wafer{}".format(args.N, args.Nhidden, 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 = 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)
import os import numpy as np import pyhalbe import pysthal from pyhalco_common import Enum, iter_all import pyhalco_hicann_v2 as Coordinate # Set up shortcuts HICANN = pyhalbe.HICANN # Choose coordinates NRN = 0 wafer_c = Coordinate.Wafer(0) hicann_c = Coordinate.HICANNOnWafer(Enum(84)) neuron_c = Coordinate.NeuronOnHICANN(Enum(NRN)) import argparse parser = argparse.ArgumentParser() parser.add_argument("in_addr", type=int) parser.add_argument("vertical", type=str, choices=["top", "bottom"]) args = parser.parse_args() bg_addr = pyhalbe.HICANN.L1Address(0) in_addr_int = args.in_addr in_addr = pyhalbe.HICANN.L1Address(in_addr_int) # Get wafer and HICANN wafer = pysthal.Wafer(wafer_c)
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('--kbiasneurons', '-b', type=int, default=1) parser.add_argument('--nbiasneurons', '-nb', type=int, default=1) parser.add_argument('--nsources', '-n', type=int, default=500) 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=24) parser.add_argument('--name', type=str, default='ising_network') parser.add_argument('--defects_path', type=str) args = parser.parse_args() taskname = "l{}_d{}_nb{}_b{}_n{}_k{}_p{}_w{}".format( args.linearsize, args.dimension, args.nbiasneurons, args.kbiasneurons, args.nsources, args.ksources, args.duplicates, args.wafer) 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.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 = IsingNetwork(marocco, linearsize=args.linearsize, dimension=args.dimension, nbiasneurons=args.nbiasneurons, kbiasneurons=args.kbiasneurons, 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 setUp(self): if 'nose' in list(sys.modules.keys()): # ugly hack to support nose-based execution... self.FPGA_IP = '0.0.0.0' self.PMU_IP = '0.0.0.0' self.HICANN = 0 self.DNC = 1 self.FPGA = 0 self.LOGLEVEL = 2 self.ON_WAFER = False self.WAFER = 0 import pyhalco_hicann_v2 as Coordinate from pyhalbe import Handle, HICANN, FPGA, Debug # The module pyhalbe.apicheck wraps pyhalbe for hardware-less # apichecks. It will be enabled only if the environment variable # PYHALBE_API_CHECK is set to true. The attribute "enabled" will be set # accordingly. KHS. import pyhalbe_apicheck as apicheck from pyhalco_common import Enum highspeed = True arq = True hicann_num = 1 fpga_ip = Coordinate.IPv4.from_string(self.FPGA_IP) pmu_ip = Coordinate.IPv4.from_string(self.pmu_IP) if self.LOGLEVEL >= 0: Debug.change_loglevel(self.LOGLEVEL) self.dnc = Coordinate.DNCOnFPGA(Enum(self.DNC)) self.hicann = Coordinate.HICANNOnDNC(Enum(self.HICANN)) self.f = Coordinate.FPGAGlobal(Enum(self.FPGA), Coordinate.Wafer(Enum(self.WAFER))) self.fpga = Handle.createFPGAHw(self.f, fpga_ip, self.dnc, self.ON_WAFER, hicann_num, pmu_ip) self.addCleanup(Handle.freeFPGAHw, self.fpga) self.h = self.fpga.get(self.dnc, self.hicann) if self.ON_WAFER: self.h0 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(0))) self.h1 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(1))) self.h2 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(2))) self.h3 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(3))) self.h4 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(4))) self.h5 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(5))) self.h6 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(6))) self.h7 = self.fpga.get(self.dnc, Coordinate.HICANNOnDNC(Enum(7))) self.apicheck = apicheck.enabled() if apicheck.enabled(): # equals PYHALBE_API_CHECK # With hardware access disabled pyhalbe functions return anything # but the expected, i.e. all unittest assertions naturally fail. # I.e. for a functional API check they have to be disabled. KHS. apicheck.monkeyPatch( self, 'assert' ) # disables all functions in self that start with "assert" # ECM says: this should be part of the tests... automatic resets during construction isn't very "standalone" # OR it is necessary and in this case it should be a member function and documented somehow. # FPGA reset FPGA.reset(self.fpga) HICANN.init(self.h, False) if self.ON_WAFER: HICANN.init(self.h0, False) HICANN.init(self.h1, False) HICANN.init(self.h2, False) HICANN.init(self.h3, False) HICANN.init(self.h4, False) HICANN.init(self.h5, False) HICANN.init(self.h6, False) HICANN.init(self.h7, False)
def run_experiment(self, marocco, n_stim, rate, poisson=True, shuffle=False): """ runs experiment with `n_stim` SpikeSources, firing at `rate` Hz, all connected to 1 neuron. returns a result dictionary, with keys `hicanns` and `fpgas`, each containing used FPGA/HICANN coords and number of sources mapped per FPGA/HICANN. further params: poisson - if True, use SpikeSourcePoisson, else use SpikeSourceArrays with regular firing shuffle - if True, the spike times used for SpikeSourceArray are shuffled, i.e. they are not sorted. Only valid if poisson=True) """ sim_duration = 200. marocco.persist = os.path.join(self.temporary_directory, "results.bin") pynn.setup(marocco=marocco) exc_pop = pynn.Population(1, pynn.IF_cond_exp, {}) # place target onto a hicann in the center of reticle and at the border of the wafer # such that hicanns from the same reticle are used with preference (1 reticle -> same fpga) marocco.manual_placement.on_hicann( exc_pop, C.HICANNOnWafer(pyhalco_common.Enum(1))) if poisson: pop_stim = pynn.Population(n_stim, pynn.SpikeSourcePoisson, { 'rate': rate, 'duration': sim_duration }) else: pop_stim = pynn.Population(n_stim, pynn.SpikeSourceArray) for i in range(n_stim): isi = 1.e3 / rate spike_times = np.arange((i + 1) * 1. / n_stim * isi, sim_duration, isi) if shuffle: np.random.shuffle(spike_times) pop_stim[i:i + 1].set('spike_times', spike_times.tolist()) a2a = pynn.AllToAllConnector(weights=0.001, delays=2.) pynn.Projection(pop_stim, exc_pop, a2a, target='excitatory') pynn.run(sim_duration) results = Marocco.from_file(marocco.persist) hicanns = {} # count number of stimuli mapped on Hicann fpgas = {} # count number of stimuli mapped on fpga for idx in range(len(pop_stim)): items = list(results.placement.find(pop_stim[idx])) # stim nrns are only placed once per wafer self.assertEqual(1, len(items)) address = items[0].address() hicann_str = str(address.toHICANNOnWafer()) hicanns[hicann_str] = hicanns.get(hicann_str, 0) + 1 hicann_global = C.HICANNGlobal(address.toHICANNOnWafer(), C.Wafer()) fpga_str = str(hicann_global.toFPGAGlobal()) fpgas[fpga_str] = fpgas.get(fpga_str, 0) + 1 pynn.end() return dict(hicanns=hicanns, fpgas=fpgas)
#!/usr/bin/env python import sys import argparse import pylogging from halbe_convert_coordinate import add_coordinate from pyhalco_common import Enum import pyhalco_hicann_v2 as C WAFER = C.Wafer() def f_wafer(coord): global WAFER WAFER = coord return [] def f_fpga(coord): gcoord = C.FPGAGlobal(coord, WAFER) result = [] for dnc_f in C.iter_all(C.DNCOnFPGA): dnc = dnc_f.toDNCOnWafer(gcoord) result += hicanns_on_dnc(dnc) return result def f_dnc(dnc): gdnc = C.DNCGlobal(dnc, WAFER) return hicanns_on_dnc(gdnc)
#!/usr/bin/env python import pyhalco_hicann_v2 as C from pyredman.load import load backend = load.HicannWithBackend("./", C.HICANNGlobal()) backend.save() backend = load.WaferWithBackend("./", C.Wafer()) backend.save()
type=int, default=125, help="Used Pll frequency (in MHz)") parser.add_argument('-zs', '--zero-synapses', action='store_true', dest='zero_syn', help="set synapse values to zero") parser.add_argument('-z', '--zero-floating-gate', action='store_true', dest='zero_fg', help="set floating gate values to zero") args = parser.parse_args() wafer_c = C.Wafer(args.wafer) hicann_c = C.HICANNOnWafer(Enum(args.hicann)) fpga_c = hicann_c.toFPGAOnWafer() dnc_c = fpga_c.toDNCOnWafer() wafer = pysthal.Wafer(wafer_c) wafer.drop_defects() fpga = wafer[fpga_c] pll_frequency = args.pll * 1e6 fpga.commonFPGASettings().setPLL(pll_frequency) fpga.commonFPGASettings().setSynapseArrayReset(args.zero_syn) hicann = wafer[hicann_c] if args.zero_fg: set_floating_gate_to_zero(hicann)
#!/usr/bin/env python """ Tool to print nice informations about coodinates usage example: ./convert_coordinate.py --hicann 0 --hicann 5,5 --reticle 1 """ import argparse import sys import pyhalco_hicann_v2 as Coordinate import pylogging from pyhalco_common import X, Y, Enum, iter_all WAFER = Coordinate.Wafer(10) # Show some new wafer as default def add_coordinate(parser, arg_name, CoordinateType, formatter): if hasattr(CoordinateType, "x_type") and hasattr(CoordinateType, "y_type"): def parse_arg(arg): tmp = arg.split(",") if len(tmp) == 1: coord = CoordinateType(Enum(int(tmp[0]))) elif len(tmp) == 2: x, y = tmp coord = CoordinateType(X(int(x)), Y(int(y))) else: raise argparse.ArgumentTypeError( "Please provide {0} <x,y> or {0} <enum>".format( arg_name)) return formatter(coord) metavar = '<enum>|<x>,<y>' else: