コード例 #1
0
 def setUp(self):
     extra = {
         "loglevel": 0,
         "ignoreHWParameterRanges": True,
         "useSystemSim": True,
         "hardware": sim.hardwareSetup["one-hicann"],
     }
     sim.setup(**extra)
コード例 #2
0
 def setUp(self):
     if not have_hardware_brainscales:
         raise SkipTest
     extra = {
         'loglevel':0, 
         'ignoreHWParameterRanges': True, 
         'useSystemSim': True, 
         'hardware': sim.hardwareSetup['one-hicann']
         }
     sim.setup(**extra)
コード例 #3
0
 def setUp(self):
     if True:
         extra = {
             'loglevel': 0,
             'useSystemSim': True,
             'hardware': sim.hardwareSetup['one-hicann']
         }
     else:
         extra = {}
     sim.setup(**extra)
コード例 #4
0
 def setUp(self):
     if not have_hardware_brainscales:
         raise SkipTest
     extra = {
         'loglevel': 0,
         'ignoreHWParameterRanges': True,
         'useSystemSim': True,
         'hardware': sim.hardwareSetup['one-hicann']
     }
     sim.setup(**extra)
コード例 #5
0
def test_restart_loop():
    extra = {"loglevel": 0, "useSystemSim": True, "hardware": sim.hardwareSetup["one-hicann"]}
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
コード例 #6
0
def test_restart_loop():
    extra = {
        'loglevel': 0,
        'useSystemSim': True,
        'hardware': sim.hardwareSetup['one-hicann']
    }
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
コード例 #7
0
    def run_experiment(self, weight_distortion=None):
        import pyNN.hardware.brainscales as pynn
        setup_params = dict(
            useSystemSim=True,
            ignoreDatabase=True,
            ignoreHWParameterRanges=True,
            hardware=pynn.hardwareSetup["one-hicann"],
            rng_seeds=[123567],
        )

        if weight_distortion is not None:
            setup_params['ess_params'] = {
                'weightDistortion': weight_distortion
            }

        pynn.setup(**setup_params)
        num_neurons = 2
        pop = pynn.Population(num_neurons, pynn.IF_cond_exp)
        # two different input spike trains, with identical rate but shifted to avoid loss in merger tree
        spike_times1 = np.arange(100., 500, 10.)
        spike_times2 = np.arange(105., 505, 10.)
        pop_source = pynn.Population(2, pynn.SpikeSourceArray)
        pop_source.tset('spike_times', [spike_times1, spike_times2])

        weight = 0.1  # weight = pop[0].cell.getConductanceRange("weight")[1]
        conn = pynn.OneToOneConnector(weights=weight)
        proj_0 = pynn.Projection(pop_source, pop, conn)

        pop.record()
        pynn.run(600.)

        spikes = pop.getSpikes()
        spikes_nrn_0 = spikes[spikes[:, 0] == 0, 1]
        spikes_nrn_1 = spikes[spikes[:, 0] == 1, 1]

        pynn.end()
        return len(spikes_nrn_0), len(spikes_nrn_1)
コード例 #8
0
def test_restart_loop():
    if not have_hardware_brainscales:
        raise SkipTest
    extra = {'loglevel':0, 'useSystemSim': True, 'hardware': sim.hardwareSetup['one-hicann']}
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    
#def test_several_runs():
    if not have_hardware_brainscales:
        raise SkipTest
コード例 #9
0
def test_restart_loop():
    if not have_hardware_brainscales:
        raise SkipTest
    extra = {'loglevel': 0, 'useSystemSim': True, 'hardware': sim.hardwareSetup['one-hicann']}
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()
    sim.setup(**extra)
    sim.run(10.0)
    sim.end()

# def test_several_runs():
    if not have_hardware_brainscales:
        raise SkipTest
コード例 #10
0
 def test_min_delay(self):
     sim.setup(0.123, min_delay=0.246, **extra)
     self.assertEqual(sim.get_min_delay(), 0.246)
コード例 #11
0
 def test_time_step(self):
     sim.setup(0.123, min_delay=0.246, **extra)
     self.assertEqual(sim.get_time_step(), 0.123)
コード例 #12
0
 def test_reset(self):
     sim.setup(**extra)
     sim.run(100.0)
     sim.reset()
     self.assertEqual(sim.get_current_time(), 0.0)
コード例 #13
0
 def test_run(self):
     sim.setup(**extra)
     self.assertEqual(sim.run(100.0), 100.0)
コード例 #14
0
 def test_end(self):
     sim.setup(**extra)
     sim.end() # need a better test
コード例 #15
0
    def runTest(self):
        import pyNN.hardware.brainscales as pynn
        from pyNN.hardware.brainscales import mapper
        import os

        place = mapper.place()

        current_directory = os.path.dirname(os.path.realpath(__file__))
        pynn.setup(timestep=0.1,
                useSystemSim = True,
                algoinitFilename= current_directory + "/algoinit_l1_delay.pl",
                mappingStrategy="user",
                loglevel=2,
                hardware=[dict(setup="wafer", wafer_id=0,hicannIndices=[279,280])],
                hardwareNeuronSize=1,
                logfile='logfile.txt',
                speedupFactor=10000,
                rng_seeds=[123567],
                ignoreHWParameterRanges=True,
                ignoreDatabase=True,
                tempFolder="debug_l1_delay",
                )
        LIF_nrn_params = {
         'cm': 1.0,
         'e_rev_E': 0.0,
         'e_rev_I': -70.0,
         'i_offset': 0.0,
         'tau_m': 20.0,
         'tau_refrac': 5., # high value to avoid 2nd spike
         'tau_syn_E': 5.0,
         'tau_syn_I': 5.0,
         'v_reset': -65.0,
         'v_rest': -65.0,
         'v_thresh': -60.0} # low value for 1 spike

        num_pe = 8 # number of priority encoders
        pop_1 = pynn.Population(num_pe, pynn.IF_cond_exp, LIF_nrn_params)
        pop_2 = pynn.Population(num_pe, pynn.IF_cond_exp, LIF_nrn_params)
        pop_source = pynn.Population(num_pe, pynn.SpikeSourceArray)

        spike_times = [[i*10. + 10.] for i in range(num_pe)]
        pop_source.tset('spike_times',spike_times)
        weight = 0.05
        conn = pynn.OneToOneConnector(weight,0.1)
        proj_0=pynn.Projection(pop_source,pop_1, conn)
        proj_1=pynn.Projection(pop_1,pop_2, conn)
        for i in range(num_pe):
            place.to(pop_1[i], hicann=279, neuron=32*i)
            place.to(pop_2[i], hicann=279, neuron=32*i +1)
        place.commit()

        pop_1.record()
        pop_2.record()

        pynn.run(100.)

        spikes_1 = pop_1.getSpikes()
        spikes_2 = pop_2.getSpikes()
        self.assertEqual(8,len(spikes_1))
        self.assertEqual(8,len(spikes_2))

        # sort spikes by ID:
        spikes_1.sort()
        spikes_2.sort()
        # spiketimes only
        spikes_1 = spikes_1[:,(1,)]
        spikes_2 = spikes_2[:,(1,)]
        delays = spikes_2 - spikes_1

        # delay pe 1 > 0, 2, 4, 7
        self.assertTrue(delays[1] > delays[0])
        self.assertTrue(delays[1] > delays[2])
        self.assertTrue(delays[1] > delays[4])
        self.assertTrue(delays[1] > delays[7])

        # delay pe 6 > 0, 2, 4, 7
        self.assertTrue(delays[6] > delays[0])
        self.assertTrue(delays[6] > delays[2])
        self.assertTrue(delays[6] > delays[4])
        self.assertTrue(delays[6] > delays[7])

        # delay pe 5 > than everything expect 3
        self.assertTrue(delays[5] > delays[0])
        self.assertTrue(delays[5] > delays[1])
        self.assertTrue(delays[5] > delays[2])
        self.assertTrue(delays[5] > delays[4])
        self.assertTrue(delays[5] > delays[6])
        self.assertTrue(delays[5] > delays[7])

        # delay pe 3 > than everything
        self.assertTrue(delays[3] > delays[0])
        self.assertTrue(delays[3] > delays[1])
        self.assertTrue(delays[3] > delays[2])
        self.assertTrue(delays[3] > delays[4])
        self.assertTrue(delays[3] > delays[5])
        self.assertTrue(delays[3] > delays[6])
        self.assertTrue(delays[3] > delays[7])
コード例 #16
0
 def test_reset(self):
     sim.setup(**extra)
     sim.run(100.0)
     sim.reset()
     self.assertEqual(sim.get_current_time(), 0.0)
コード例 #17
0
 def test_end(self):
     sim.setup(**extra)
     sim.end()  # need a better test
コード例 #18
0
"""
Script to print tables of parameter ranges, to be included in Sphinx docs.
"""

import pyNN.hardware.brainscales as sim
sim.setup(useSystemSim=True,
          hardware=sim.hardwareSetup["one-reticle"],
          hardwareNeuronSize=1)

BIG_HW_CAP = 2.16456e-3
SMALL_HW_CAP = 164.2e-6

def print_param_table():
    print
    print "==========  =======  =======  ======="
    print "Parameter   Default  Min      Max"
    print "==========  =======  =======  ======="
    for key in sim.IF_cond_exp.default_parameters:
        print "%-10s  %-7.1f  %-7.1f  %-7.1f" % (key,  sim.IF_cond_exp.default_parameters[key],
                                                 sim.IF_cond_exp.parameter_ranges[key][0],
                                                 sim.IF_cond_exp.parameter_ranges[key][1])
    print "==========  =======  =======  ======="
    print

print "The default ranges for the :class:`IF_cond_exp` are:"

print_param_table()

print "Some configuration options can modify these ranges. With ``speedUpFactor = 1000``, the ranges for all parameters with dimension time are modified:"

sim.IF_cond_exp.scaleParameterRangesTime(1000)
コード例 #19
0
def test_sim_without_clearing():
    if not have_hardware_brainscales:
        raise SkipTest
    extra = {'loglevel':0, 'useSystemSim': True, 'hardware': sim.hardwareSetup['one-hicann']}
    sim.setup(**extra)    
コード例 #20
0
 def test_max_delay(self):
     sim.setup(max_delay=9.87, **extra)
     self.assertEqual(sim.get_max_delay(), 9.87)
コード例 #21
0
 def test_min_delay(self):
     sim.setup(0.123, min_delay=0.246, **extra)
     self.assertEqual(sim.get_min_delay(), 0.246)
コード例 #22
0
 def setUp(self):
     sim.setup(**extra)
コード例 #23
0
 def setUp(self):
     sim.setup(**extra)
コード例 #24
0
ファイル: test_populationview.py プロジェクト: Huitzilo/PyNN
 def setUp(self):
     extra = {'loglevel':0, 'useSystemSim': True, 'hardware': sim.hardwareSetup['one-hicann']}
     sim.setup(**extra)
コード例 #25
0
def test_sim_without_clearing():
    if not have_hardware_brainscales:
        raise SkipTest
    extra = {'loglevel': 0, 'useSystemSim': True, 'hardware': sim.hardwareSetup['one-hicann']}
    sim.setup(**extra)
コード例 #26
0
 def test_run(self):
     sim.setup(**extra)
     self.assertEqual(sim.run(100.0), 100.0)
コード例 #27
0
def test_sim_without_clearing():
    extra = {"loglevel": 0, "useSystemSim": True, "hardware": sim.hardwareSetup["one-hicann"]}
    sim.setup(**extra)
コード例 #28
0
 def test_time_step(self):
     sim.setup(0.123, min_delay=0.246, **extra)
     self.assertEqual(sim.get_time_step(), 0.123)
コード例 #29
0
    def runTest(self):
        import numpy

        import pyNN.hardware.brainscales as pynn

        # set-up the simulator
        pynn.setup(
            timestep=0.1,
            useSystemSim=True,
            speedupFactor=10000,
            ignoreDatabase=True,
            ignoreHWParameterRanges=True,
            hardware=pynn.hardwareSetup['one-hicann'],
        )

        # Set the neuron model class
        neuron_model = pynn.IF_cond_exp  # I&F

        neuron_parameters = {
            'cm': 0.281,  # membrane capacitance nF
            'e_rev_E': 0.0,  # excitatory reversal potential in mV
            'e_rev_I': -100.0,  # inhibitory reversal potential in mV
            'i_offset': 0.0,  # offset current
            'tau_m': 9.3667,  # membrane time constant
            'tau_refrac': 1.0,  # absolute refractory period
            'tau_syn_E': 5.0,  # excitatory synaptic time constant
            'tau_syn_I': 5.0,  # inhibitory synaptic time constant
            'v_reset': -70.6,  # reset potential in mV
            'v_rest': -70.6,  # resting potential in mV
            'v_thresh': -55.,  # spike initiaton threshold voltage in mV
        }

        # We create a Population with 1 neuron of our
        N1 = pynn.Population(size=2,
                             cellclass=neuron_model,
                             cellparams=neuron_parameters)
        N1a = N1[0:1]
        N1b = N1[1:2]
        v_shift = 5.
        # shift all voltages of 2nd neuron  by 5 mV
        N1b.set('v_rest', neuron_parameters['v_rest'] - v_shift)
        N1b.set('v_reset', neuron_parameters['v_reset'] - v_shift)
        N1b.set('v_thresh', neuron_parameters['v_thresh'] - v_shift)
        N1b.set('e_rev_E', neuron_parameters['e_rev_E'] - v_shift)
        N1b.set('e_rev_I', neuron_parameters['e_rev_I'] - v_shift)

        spiketimes = [10., 50., 110., 122.5]
        S1 = pynn.Population(1,
                             pynn.SpikeSourceArray,
                             cellparams={'spike_times': spiketimes})

        pynn.Projection(S1,
                        N1,
                        pynn.AllToAllConnector(weights=0.0123938304114),
                        target='inhibitory')  # max weight in hardware

        # record the voltage of all neurons of the population
        N1.record_v()

        # run the simulation for 200 ms
        pynn.run(150.)

        # format of get_v: [id, t, v]
        mean_v_a = N1a.get_v().transpose()[2].mean()
        mean_v_b = N1b.get_v().transpose()[2].mean()
        self.assertAlmostEqual(
            mean_v_a,
            mean_v_b + v_shift,
            places=3,
            msg=
            'The mean voltage of neuron a and b should have a difference of 5 mV'
        )
        pynn.end()
コード例 #30
0
 def test_max_delay(self):
     sim.setup(max_delay=9.87, **extra)
     self.assertEqual(sim.get_max_delay(), 9.87)
コード例 #31
0
    def runTest(self):
        import numpy
        backend = "hardware.brainscales"

        import pyNN.hardware.brainscales as pynn


        # set-up the simulator
        pynn.setup(
                timestep=0.1,
                useSystemSim=True,
                speedupFactor=8000,
                ignoreDatabase=True,
                ignoreHWParameterRanges=True,
                hardware=pynn.hardwareSetup['one-hicann'],
                )

        neuron_count = 1 # size of the Population we will create

        # Set the neuron model class
        neuron_model = pynn.EIF_cond_exp_isfa_ista # an Adaptive Exponential I&F Neuron

        neuron_parameters = {
         'a'          : 10.0,    # adaptation variable a in nS
         'b'          : 0.0805, # adaptation variable b in pA
         'cm'         : 0.281,  # membrane capacitance nF
         'delta_T'    : 2.0,    # delta_T fom Adex mod in mV, determines the sharpness of spike initiation
         'e_rev_E'    : 0.0,    # excitatory reversal potential in mV
         'e_rev_I'    : -100.0,  # inhibitory reversal potential in mV
         'i_offset'   : 0.0,    # offset current
         'tau_m'      : 9.3667, # membrane time constant
         'tau_refrac' : 8.0,    # absolute refractory period
         'tau_syn_E'  : 5.0,    # excitatory synaptic time constant
         'tau_syn_I'  : 5.0,    # inhibitory synaptic time constant
         'tau_w'      : 144.0,  # adaptation time constant
         'v_reset'    : -70.6,  # reset potential in mV
         'v_rest'     : -70.6,  # resting potential in mV
         'v_spike'    : -40.0,  # spike detection voltage in mV
         'v_thresh'   : -66.9,  # spike initiaton threshold voltage in mV
         }

        # We create a Population with 1 neuron of our 
        N1 = pynn.Population( size = 1, cellclass = neuron_model, cellparams = neuron_parameters)
        N1.initialize('v',neuron_parameters['v_rest'])

        spiketimes = numpy.arange(100.,800.,0.5)
        S1 = pynn.Population(1,pynn.SpikeSourceArray, cellparams = {'spike_times':spiketimes})

        pynn.Projection(S1,N1,pynn.OneToOneConnector(weights=0.0123938304114), target='inhibitory') # max weight in hardware


        # record the spikes of all neurons of the population
        N1.record()

        # run the simulation for 500 ms
        pynn.run(1000.)


        num_spikes = 0
        # After the simulation, we get Spikes and save the voltage trace to a file
        spike_times = N1.getSpikes()
        for pair in spike_times:
            print "Neuron ", int(pair[0]), " spiked at ", pair[1]
            num_spikes += 1

        pynn.end()

        self.assertEqual(int(num_spikes),1,'The Neuron spiked more than once, i.e. there was a rebound burst, and not a single rebound spike as it should be')