def setup_logger():
"""
Has to be called separately in every process.
"""
import argparse
from pysthal.command_line_util import init_logger
import pylogging
logger = pylogging.get(__name__)
init_logger(
"DEBUG",
[
(__name__, "TRACE"),
("halbe.fgwriter", "INFO"),
("hicann-system", "INFO"),
("Default", "INFO"), # unset logger name, mostly hicann-system
])
parser = argparse.ArgumentParser()
parser.add_argument("--output-dir", default=".")
args, _ = parser.parse_known_args()
pylogging.append_to_file(os.path.join(args.output_dir, LOGFILE))
return logger
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):
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 setup_logger():
"""
Has to be called separately in every process.
"""
import argparse
from pysthal.command_line_util import init_logger
import pylogging
logger = pylogging.get(__name__)
init_logger("DEBUG", [
(__name__, "TRACE"),
("halbe.fgwriter", "INFO"),
("hicann-system", "INFO"),
("Default", "INFO"), # unset logger name, mostly hicann-system
])
parser = argparse.ArgumentParser()
parser.add_argument("--output-dir", default=".")
args, _ = parser.parse_known_args()
pylogging.append_to_file(os.path.join(args.output_dir, LOGFILE))
return logger
Test for issue #3086
Based on code sniplet in issue #3086
"""
import unittest
from pysthal.command_line_util import init_logger
import pyhmf as pynn
from pymarocco import PyMarocco
from pymarocco.coordinates import LogicalNeuron
from pyhalco_common import X, Y, Enum
import pyhalco_hicann_v2 as C
init_logger("TRACE", [])
class issue3086(unittest.TestCase):
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)),
import os
from pyhalbe import HICANN
import pyhalbe.Coordinate as C
from pymarocco import PyMarocco, Defects
from pymarocco.runtime import Runtime
from pymarocco.coordinates import LogicalNeuron
from pymarocco.results import Marocco
from pymarocco import Defects
import pysthal
from pysthal.command_line_util import init_logger
import pyhmf as sim
init_logger("WARN", [
("guidebook", "INFO"),
("marocco", "INFO"),
("Calibtic", "INFO"),
("sthal", "INFO")
])
def _BSS_set_hicann_sthal_params(_wafer, _hicann, gmax, gmax_div=1):
fgs = _wafer[_hicann].floating_gates
# set parameters influencing the synaptic strength
for block in C.iter_all(C.FGBlockOnHICANN):
fgs.setShared(block, HICANN.shared_parameter.V_gmax0, gmax)
fgs.setShared(block, HICANN.shared_parameter.V_gmax1, gmax)
fgs.setShared(block, HICANN.shared_parameter.V_gmax2, gmax)
fgs.setShared(block, HICANN.shared_parameter.V_gmax3, gmax)
for driver in C.iter_all(C.SynapseDriverOnHICANN):
#!/usr/bin/env python
import argparse
from datetime import datetime
import json
import pyhmf as pynn
import pymarocco
from pysthal.command_line_util import init_logger
init_logger("WARN", [])
class rbmNetwork(object):
def __init__(self, Nvisible, Nhidden, marocco,
model=pynn.EIF_cond_exp_isfa_ista):
self.Nvisible = Nvisible
self.Nhidden = Nhidden
self.model = model
self.marocco = marocco
pynn.setup(marocco=self.marocco)
def build(self):
# Set the neurons
self.neuronsVisible = pynn.Population(self.Nvisible, self.model)
self.neuronsHidden = pynn.Population(self.Nhidden, self.model)
# in the fully connected rbm each neuron from the visible layer
# projects to each neuron of the hidden layer (and vice versa)
import numpy as np
from pyhalbe import HICANN
import pyhalbe.Coordinate as C
from pysthal.command_line_util import init_logger
import pysthal
import pyhmf as pynn
from pymarocco import PyMarocco, Defects
from pymarocco.runtime import Runtime
from pymarocco.coordinates import LogicalNeuron
from pymarocco.results import Marocco
init_logger("WARN", [
("guidebook", "DEBUG"),
("marocco", "DEBUG"),
("Calibtic", "DEBUG"),
("sthal", "INFO")
])
import pylogging
logger = pylogging.get("guidebook")
neuron_parameters = {
'cm': 0.2,
'v_reset': -70.,
'v_rest': -20.,
'v_thresh': -10,
'e_rev_I': -100.,
'e_rev_E': 60.,
'tau_m': 20.,
'tau_refrac': 0.1,
#!/usr/bin/env python
import argparse
from datetime import datetime
import json
import numpy as np
import pyhmf as pynn
import pyhalco_hicann_v2 as C
from pymarocco import PyMarocco
from pymarocco import Defects
from pysthal.command_line_util import init_logger
init_logger("ERROR", [])
import params as par
import pylogging
logger = pylogging.get("column-benchmark")
# At the moment only the deflaut placement strategy is tested. Can be added later to test different strategy
from pymarocco_runtime import ClusterByPopulationConnectivity as placer_pop
from pymarocco_runtime import ClusterByNeuronConnectivity as placer_neuron_cluster
from pymarocco_runtime import byNeuronBlockEnumAndPopulationIDasc as placer_enum_IDasc
class CorticalNetwork(object):
def __init__(self, marocco, scale, k_scale, seed):
# total connection counter
self.totalConnections = 0
def main(self, *was_args, **was_kwargs):
import argparse
init_logger('INFO')
parser = argparse.ArgumentParser(description='SthalHWTest: %s' %
self.__name__)
add_default_coordinate_options(parser)
parser.add_argument('--v4',
action='store_true',
default=False,
help="Run tests for HICANNv4")
parser.add_argument('--hwdb',
type=str,
default=None,
help="full path to hardware database")
parser.add_argument('--xml-output-dir',
type=str,
default=None,
help='create xml reports')
parser.add_argument('--skip-expensive',
action='store_true',
help=expensive.__doc__)
add_logger_options(parser)
args, argv = parser.parse_known_args()
argv.insert(0, sys.argv[0])
settings = pysthal.Settings.get()
if args.hwdb:
settings.yaml_hardware_database_path = args.hwdb
print("using non-default hardware database {}".format(args.hwdb))
self.HICANN = args.hicann
self.WAFER = args.wafer
self.SKIP_EXPENSIVE = args.skip_expensive
if args.v4:
self.PREOUT_DRIVERS = (SynapseDriverOnHICANN(Enum(109)),
SynapseDriverOnHICANN(Enum(114)))
self.PREOUT_OUTPUT = DNCMergerOnHICANN(6)
self.PREOUT_LINK = GbitLinkOnHICANN(6)
# Coordinates not available on HICANN v4
self.COORDINATE_BLACKLIST = (
SynapseDriverOnHICANN(Enum(110)),
SynapseDriverOnHICANN(Enum(111)),
SynapseDriverOnHICANN(Enum(112)),
SynapseDriverOnHICANN(Enum(113)),
SynapseRowOnHICANN(220),
SynapseRowOnHICANN(221),
SynapseRowOnHICANN(222),
SynapseRowOnHICANN(223),
SynapseRowOnHICANN(224),
SynapseRowOnHICANN(225),
SynapseRowOnHICANN(226),
SynapseRowOnHICANN(227),
)
self.HICANN_VERSION = 4
else:
self.PREOUT_DRIVERS = (SynapseDriverOnHICANN(Enum(111)),
SynapseDriverOnHICANN(Enum(112)))
self.PREOUT_OUTPUT = DNCMergerOnHICANN(7)
self.PREOUT_LINK = GbitLinkOnHICANN(7)
self.COORDINATE_BLACKLIST = tuple()
self.HICANN_VERSION = 2
test_runner = None
if args.xml_output_dir:
from xmlrunner import XMLTestRunner
test_runner = XMLTestRunner(output=args.xml_output_dir)
unittest.main(argv=argv,
testRunner=test_runner,
*was_args,
**was_kwargs)
def main(cls, *was_args, **was_kwargs):
import argparse
from pysthal.command_line_util import add_fpga_coordinate_options
from pysthal.command_line_util import parse_hicann
from pysthal.command_line_util import add_logger_options
from pysthal.command_line_util import folder
from pysthal.command_line_util import init_logger
init_logger('INFO')
parser = argparse.ArgumentParser(description='SthalHWTest: %s' %
cls.__name__)
add_fpga_coordinate_options(parser)
parser.add_argument(
'--hicann',
action='store',
required=False,
type=parse_hicann,
metavar='<enum>|<x>,<y>',
dest='hicann',
help="specify the HICANN on the wafer system to use")
parser.add_argument('--hwdb',
type=str,
default=None,
help="full path to hardware database")
parser.add_argument('--data-output-dir',
type=folder,
default=None,
help="Store outputs in this folder")
parser.add_argument(
'--replot',
action='store_true',
help='do not execute any test, just recreate the plot')
add_logger_options(parser)
args, argv = parser.parse_known_args()
argv.insert(0, sys.argv[0])
if args.hwdb:
settings = pysthal.Settings.get()
settings.yaml_hardware_database_path = args.hwdb
print("using non-default hardware database {}".format(args.hwdb))
if args.data_output_dir:
output_dir = os.path.join(
args.data_output_dir,
'wafer{}_dnc{:0>2}'.format(int(args.wafer),
int(args.dnc.toEnum())))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
else:
output_dir = None
cls.WAFER = args.wafer
cls.DNC = args.dnc
if args.hicann:
cls.hicanns = [args.hicann]
cls.DNC = Coordinate.DNCOnWafer((cls.hicanns[0].toDNCOnWafer()))
else:
cls.hicanns = [
hicann_on_dnc.toHICANNOnWafer(cls.DNC) for hicann_on_dnc in
Coordinate.iter_all(Coordinate.HICANNOnDNC)
]
cls.DATA_FOLDER = output_dir
if args.replot:
load_and_generate_plot(output_dir, args.wafer, args.dnc)
return
test_runner = None
if output_dir:
from xmlrunner import XMLTestRunner
test_runner = XMLTestRunner(output=output_dir)
cls.runner_outsuffix = test_runner.outsuffix
unittest.main(argv=argv,
testRunner=test_runner,
*was_args,
**was_kwargs)
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
}
