def init_logger(default_level=pylogging.LogLevel.INFO,
                defaults=tuple(),
                add_help=False):
    """Initialize logging system

    Arguments:
        default_level: default log level for the logging system
        args: list of tuples for channel default values
        add_help: [bool] print help when called with --help, set to True
                         if you don't have an own parser.

    Example:
        init_logger(args, [('sthal', 'INFO'), ('halbe', 'WARN')])
    """

    parser = argparse.ArgumentParser(description='PSP visualization tool',
                                     add_help=add_help)
    add_logger_options(parser, default_level)
    parser_args, _ = parser.parse_known_args()

    pylogging.reset()
    pylogging.default_config(
        level=parser_args.loglevel,
        fname=parser_args.logfile if parser_args.logfile else "",
        print_location=parser_args.loglocation,
        color=parser_args.logcolor,
        date_format=parser_args.logdate_format)

    for name, level in defaults:
        pylogging.set_loglevel(pylogging.get(name), to_level(level))
    for name, level in parser_args.logchannel:
        pylogging.set_loglevel(pylogging.get(name), to_level(level))
def default_test_msg(print_location, date_format):
    pylogging.reset()
    pylogging.default_config(level=pylogging.LogLevel.DEBUG,
                             print_location=print_location,
                             date_format=date_format,
                             color=True)
    l = pylogging.get("default_config")
    l.debug("time format: {}".format(date_format))
def default_test_msg(print_location, date_format):
    pylogging.reset()
    pylogging.default_config(
            level=pylogging.LogLevel.DEBUG,
            print_location=print_location,
            date_format=date_format,
            color=True)
    l = pylogging.get("default_config")
    l.debug("time format: {}".format(date_format))
示例#4
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--source-hicann',
                        required=True,
                        type=parse_hicann,
                        metavar='<enum>|<x>,<y>',
                        help='source HICANNOnWafer')
    parser.add_argument('--source-hline',
                        required=False,
                        type=int,
                        help='source HLineOnHICANN')
    parser.add_argument('--source-vline',
                        required=False,
                        type=int,
                        help='source VLineOnHICANN')
    parser.add_argument('--target-hicann',
                        required=True,
                        type=parse_hicann,
                        metavar='<enum>|<x>,<y>',
                        help='target HICANNOnWafer')
    parser.add_argument('--target-vertical',
                        action='store_true',
                        help='target should be VLineOnHICANN')
    parser.add_argument('--without-hicann',
                        default=[],
                        type=parse_hicann,
                        nargs="+",
                        metavar='<enum>|<x>,<y>',
                        help='unavailable HICANNOnWafer')
    args = parser.parse_args()

    pylogging.reset()
    pylogging.default_config(date_format='absolute')

    alone = pyalone.Alone()
    for hicann in iter_all(HICANNOnWafer):
        if hicann in args.without_hicann:
            continue
        alone.add(hicann)

    if args.source_hline is not None:
        line = HLineOnHICANN(args.source_hline)
    elif args.source_vline is not None:
        line = VLineOnHICANN(args.source_vline)
    else:
        parser.error('Please specify one of --source-hline / --source-vline')
    source = pyalone.L1BusOnWafer(args.source_hicann, line)
    target = pyalone.Target(args.target_hicann,
                            vertical if args.target_vertical else horizontal)
    routes = alone.find_routes(source, target)
    for route in routes:
        print(route)
示例#5
0
    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)
示例#6
0
    def test_default_logger(self):
        log_all = os.path.join(self.temp, 'test_default_logger_all.log')
        log_default = os.path.join(self.temp,
                                   'test_default_logger_default.log')

        logger1 = logger.get("test")

        logger.default_config(logger.LogLevel.DEBUG,
                              log_all,
                              date_format="NULL")

        # Loglevel should be ignored, because the root logger is configured
        logger_default = logger.get_old_logger(logger.LogLevel.TRACE)
        logger.append_to_file(log_default, logger_default)

        for l in (logger_default, logger1):
            logger.LOG4CXX_FATAL(l, "FATAL")
            logger.LOG4CXX_ERROR(l, "ERROR")
            logger.LOG4CXX_WARN(l, "WARN")
            logger.LOG4CXX_INFO(l, "INFO")
            logger.LOG4CXX_DEBUG(l, "DEBUG")
            logger.LOG4CXX_TRACE(l, "TRACE")

        logger.reset()
        with open(log_all) as f:
            expected = \
"""FATAL PyLogging FATAL
ERROR PyLogging ERROR
WARN  PyLogging WARN
INFO  PyLogging INFO
DEBUG PyLogging DEBUG
FATAL test FATAL
ERROR test ERROR
WARN  test WARN
INFO  test INFO
DEBUG test DEBUG
"""
            self.assertEqualLogLines(expected, f.read())

        with open(log_default) as f:
            expected = \
"""FATAL PyLogging FATAL
ERROR PyLogging ERROR
WARN  PyLogging WARN
INFO  PyLogging INFO
DEBUG PyLogging DEBUG
"""
            self.assertEqualLogLines(expected, f.read())
    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 test_default_logger(self):
        log_all = os.path.join(self.temp, 'test_default_logger_all.log')
        log_default = os.path.join(self.temp, 'test_default_logger_default.log')

        logger1 = logger.get("test")

        logger.default_config(logger.LogLevel.DEBUG, log_all,
                date_format="NULL")

        # Loglevel should be ignored, because the root logger is configured
        logger_default = logger.get_old_logger(logger.LogLevel.TRACE)
        logger.append_to_file(log_default, logger_default)

        for l in (logger_default, logger1):
            logger.LOG4CXX_FATAL(l, "FATAL")
            logger.LOG4CXX_ERROR(l, "ERROR")
            logger.LOG4CXX_WARN (l, "WARN")
            logger.LOG4CXX_INFO (l, "INFO")
            logger.LOG4CXX_DEBUG(l, "DEBUG")
            logger.LOG4CXX_TRACE(l, "TRACE")

        logger.reset()
        with open(log_all) as f:
            expected = \
"""FATAL PyLogging FATAL
ERROR PyLogging ERROR
WARN  PyLogging WARN
INFO  PyLogging INFO
DEBUG PyLogging DEBUG
FATAL test FATAL
ERROR test ERROR
WARN  test WARN
INFO  test INFO
DEBUG test DEBUG
"""
            self.assertEqualLogLines(expected, f.read())

        with open(log_default) as f:
            expected = \
"""FATAL PyLogging FATAL
ERROR PyLogging ERROR
WARN  PyLogging WARN
INFO  PyLogging INFO
DEBUG PyLogging DEBUG
"""
            self.assertEqualLogLines(expected, f.read())
    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()
    return out

def main():
    """main"""

    description = 'Shows information about HALbe coodinates'
    epilog = "example: {} --hicann 0 --hicann 5,5 --fpga 0 --power 1".format(
            sys.argv[0])

    parser = argparse.ArgumentParser(description=description, epilog=epilog)
    add_coordinate(parser, "--wafer", Coordinate.Wafer, f_wafer)
    add_coordinate(parser, "--hicann", Coordinate.HICANNOnWafer, f_hicann)
    add_coordinate(parser, "--fpga", Coordinate.FPGAOnWafer, f_fpga)
    add_coordinate(parser, "--dnc", Coordinate.DNCOnWafer, f_dnc)
    add_coordinate(parser, "--power", Coordinate.PowerCoordinate, f_reticle)
    args = parser.parse_args()

    if args.values:
        for (value, ) in args.values:
            if value:
                print(value)
    else:
        parser.print_usage()

if __name__ == '__main__':

    pylogging.reset()
    pylogging.default_config(date_format='absolute')

    main()
示例#11
0
#!/usr/bin/env python
"""
example script for extracting synapse loss after mapping
"""

from pymarocco import PyMarocco
import pyhmf as pynn
import numpy as np
import pylogging
pylogging.reset()
pylogging.default_config(level=pylogging.LogLevel.ERROR)


def projectionwise_synapse_loss(proj, marocco):
    """
    computes the synapse loss of a projection
    params:
      proj    - a pyhmf.Projection
      marocco -  the PyMarocco object after the mapping has run.

    returns: (nr of lost synapses, total synapses in projection)
    """
    orig_weights = proj.getWeights(format='array')
    mapped_weights = marocco.stats.getWeights(proj)
    syns = np.where(~np.isnan(orig_weights))
    realized_syns = np.where(~np.isnan(mapped_weights))
    orig = len(syns[0])
    realized = len(realized_syns[0])
    print "Projection-Wise Synapse Loss", proj, (orig - realized) * 100. / orig
    return orig - realized, orig
import tempfile
import unittest

import pylogging
import pyhmf as pynn
import pyhalbe
import pyhalco_common
import pyhalco_hicann_v2 as C
import numpy as np
import debug_config

import pymarocco
from pymarocco.results import Marocco

pylogging.reset()
pylogging.default_config(pylogging.LogLevel.INFO)
pylogging.set_loglevel(pylogging.get("marocco"), pylogging.LogLevel.DEBUG)


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


class TestRateDependentInputPlacement(unittest.TestCase):
    """Test input placement with consider_firing_rate=True for diverse settings"""
import unittest
import pycalibtic as cal
import pyhalbe
import pyhalco_hicann_v2
import pycellparameters as cell
import numpy as np
import pywrapstdvector

# http://stackoverflow.com/a/22726782/1350789
from contextlib import contextmanager
import tempfile
import shutil
import itertools

import pylogging
pylogging.default_config()

@contextmanager
def TemporaryDirectory():
    name = tempfile.mkdtemp()
    try:
        yield name
    finally:
        shutil.rmtree(name)

def initBackend(fname):
    lib = cal.loadLibrary(fname)
    backend = cal.loadBackend(lib)

    if not backend:
        raise Exception('unable to load %s' % fname)
示例#14
0
 def setUp(self):
     pylogging.reset()
     pylogging.default_config(pylogging.LogLevel.WARN)
示例#15
0
Example Script for simulation of an AdEx neuron on the ESS

Note: Neuron and synapse parameters are chosen to be within the parameter ranges of
the default calibration.
"""

import pyhmf as pynn
#import pyNN.nest as pynn
from pymarocco import PyMarocco, Defects
import pylogging
import pysthal

# configure logging
pylogging.reset()
pylogging.default_config(level=pylogging.LogLevel.INFO,
                         fname="logfile.txt",
                         dual=False)

# Mapping config
marocco = PyMarocco()
marocco.backend = PyMarocco.ESS  # choose Executable System Specification instead of real hardware
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.defects.backend = Defects.Backend.None
marocco.hicann_configurator = pysthal.HICANNConfigurator()
marocco.experiment_time_offset = 5.e-7  # can be low for ESS, as no repeater locking required
marocco.neuron_placement.default_neuron_size(
    4)  # default number of hardware neuron circuits per pyNN neuron
marocco.persist = "nmpm1_adex_neuron_ess.bin"
marocco.param_trafo.use_big_capacitors = False

# set-up the simulator
#!/usr/bin/env python
"""
example script for extracting synapse loss after mapping
"""

from pymarocco import PyMarocco
import pyhmf as pynn
import numpy as np
import pylogging
pylogging.reset()
pylogging.default_config(level=pylogging.LogLevel.ERROR)

def projectionwise_synapse_loss(proj, marocco):
    """
    computes the synapse loss of a projection
    params:
      proj    - a pyhmf.Projection
      marocco -  the PyMarocco object after the mapping has run.

    returns: (nr of lost synapses, total synapses in projection)
    """
    orig_weights = proj.getWeights(format='array')
    mapped_weights = marocco.stats.getWeights(proj)
    syns = np.where(~np.isnan(orig_weights))
    realized_syns = np.where(~np.isnan(mapped_weights))
    orig = len(syns[0])
    realized = len(realized_syns[0])
    print "Projection-Wise Synapse Loss", proj, (orig - realized)*100./orig
    return orig-realized, orig

def plot_projectionwise_synapse_loss(proj, marocco):
 def setUp(self):
     import pylogging
     pylogging.default_config(pylogging.LogLevel.FATAL)
示例#18
0
from _hxtorch import *
from hxtorch import nn
import pylogging as logger

logger.reset()
logger.default_config(level=logger.LogLevel.WARN)
logger.set_loglevel(logger.get("hxtorch"), logger.LogLevel.INFO)
Note: Neuron and synapse parameters are chosen to be within the parameter ranges of
the default calibration.
"""

import pyhmf as pynn
#import pyNN.nest as pynn
from pymarocco import PyMarocco, Defects
import pylogging
import Coordinate as C
import pysthal

# configure logging
pylogging.reset()
pylogging.default_config(level=pylogging.LogLevel.INFO,
        fname="logfile.txt",
        dual=False)

# Mapping config
marocco = PyMarocco()
marocco.backend = PyMarocco.ESS # choose Executable System Specification instead of real hardware
marocco.calib_backend = PyMarocco.CalibBackend.Default
marocco.defects.backend = Defects.Backend.None
marocco.neuron_placement.skip_hicanns_without_neuron_blacklisting(False)
marocco.hicann_configurator = pysthal.HICANNConfigurator()
marocco.experiment_time_offset = 5.e-7 # can be low for ESS, as no repeater locking required
marocco.neuron_placement.default_neuron_size(4) # default number of hardware neuron circuits per pyNN neuron
marocco.persist = "nmpm1_adex_neuron_ess.bin"
marocco.param_trafo.use_big_capacitors = False

# set-up the simulator
    parser.add_argument('--as_string', action='store_true')

    # No matter how long the program runs, it will always be stopped after
    # `wait` FPGA cycles. If the program finishes earlier, the PPU goes to
    # sleep mode while the FPGA still waits for this fixed amount of cycles.
    parser.add_argument(
        '--wait',
        type=int,
        default=int(1E7),
        help="Number of FPGA cycles after which the PPU is stopped")
    args = parser.parse_args()

    pylogging.reset()
    pylogging.default_config(level=pylogging.LogLevel.INFO,
                             fname="",
                             print_location=False,
                             color=True,
                             date_format='RELATIVE')

    # Load the data
    program = pydls.Ppu_program()
    program.read_from_file(args.program)

    mailbox = pydls.Mailbox()
    if args.data_in is not None:
        load_mailbox(mailbox, args.data_in)

    # Setup synram control register
    # These are magic numbers which configure the timing how the synram is
    # written.
    synram_config_reg = pydls.Synram_config_reg()
示例#21
0
import pyhaldls_v2 as hal
import pystadls_v2 as sta
import dlens_v2.halco
import pylogging as logger

logger.reset()
logger.default_config(level=logger.LogLevel.DEBUG)
def inner_loop():
    parser = argparse.ArgumentParser()
    parser.add_argument('--cal',
                        type=str,
                        default='../adv/calibration_20.json')
    parser.add_argument('--dac',
                        type=str,
                        default='../adv/dac_07_chip_20.json')
    parser.add_argument('--load_from', type=str, default='')
    parser.add_argument('--out', type=str, default='')
    parser.add_argument('--pl', type=int, choices=range(32), default=4)
    parser.add_argument('--lr',
                        type=str,
                        choices=['q', 'greedy', 'ann'],
                        default='q')
    parser.add_argument('--generation', type=int, default=-1)
    parser.add_argument('--n_batch', type=int, default=1)
    parser.add_argument('--n_iter', type=int, default=1)
    parser.add_argument('--dependent', default=False, action='store_true')
    parser.add_argument('--verbose', default=False, action='store_true')
    args = parser.parse_args()

    with open(args.cal) as f:
        calibrated_config = json.load(f)
    with open(args.dac) as f:
        dac_config = json.load(f)

    pylogging.reset()
    pylogging.default_config(level=pylogging.LogLevel.INFO,
                             fname="",
                             print_location=False,
                             color=True,
                             date_format='RELATIVE')
    logger = pylogging.get('main')

    agent = SpikingBanditAgent(logger)

    n_batch = args.n_batch

    agent_hp = agent.default_hyperparameters
    if args.lr == 'q':
        learning_rule = IncrementalLearningRule()
    elif args.lr == 'ann':
        learning_rule = ANNLearningRule()

    if args.load_from != '':
        traj = pp.Trajectory(filename=args.load_from)
        traj.v_auto_load = True
        traj.f_load(index=-1, force=True)
        pop_size = traj.parameters.pop_size
        n_iter = traj.parameters.n_iteration
        max_fitness = -100
        best_individual = None
        if args.generation == -1:
            gen_index = n_iter - 1
        else:
            gen_index = args.generation
        for j in range(pop_size):
            traj.v_idx = gen_index * pop_size + j
            # print(traj.v_idx)
            fitness = traj.results.crun.fitness
            if fitness > max_fitness:
                max_fitness = fitness
                best_individual = dict(
                    traj.parameters.individual.f_get_children())
                best_individual.pop('seed', None)
                for k, v in best_individual.items():
                    best_individual[k] = best_individual[k][traj.v_idx]
        print(best_individual)

        if args.lr == 'q':
            agent_hp = dict(
                action_inhibition=best_individual['action_inhibition'],
                stim_inhibition=best_individual['stim_inhibition'])
            lr_hp = dict(
                learning_rate=best_individual['learning_rate'],
                learning_rate_decay=best_individual['learning_rate_decay'],
                weight_prior=best_individual['weight_prior'])
            learning_rule = IncrementalLearningRule(lr_hp)
        elif args.lr == 'ann':
            lr_hp = dict(learning_rate=best_individual['learning_rate'],
                         ann_parameters=best_individual['ann_parameters'])
            agent_hp = agent.default_hyperparameters
            learning_rule = ANNLearningRule(lr_hp)
        else:
            logger.error('Learning rule {:s} not supported yet'.format(
                args.lr))
            quit()
    bps = []
    ar = []
    regrets = []
    with Connector(calibrated_config, dac_config, args.pl) as connector:
        for i in range(args.n_iter):
            bandit_probabilities = np.random.rand(n_batch, 2)
            if args.dependent:
                bandit_probabilities[:, 1] = 1. - bandit_probabilities[:, 0]
            bandit_probabilities = bandit_probabilities.reshape((-1, ))
            try:
                r = agent.play_bandit_batch(bandit_probabilities, 100, n_batch,
                                            agent_hp, learning_rule, connector)
                regrets.append(r[0])
            except:
                continue
            ar.append(r[1]['a_r'])
            bps.append(bandit_probabilities)
            logger.info('iteration made')
    print(np.mean(regrets))
    if args.verbose:
        spikes = r[1]['spikes']
        logger.info(spikes[:20, :])
        logger.info('')
        logger.info(spikes[-20:, :])
        logger.info('A total of {} spikes was received'.format(
            spikes.shape[0]))
    if args.out != '':
        with open(args.out, 'wb') as f:
            pickle.dump(dict(bandit_probabilities=bps, a_r=ar), f)
    logger.info('Finished')