Beispiel #1
0
def test():
    '''mapping of bio index to hardware index should work for networks
    where not all neurons are recorded'''
    pynn.setup()

    if mappingOffset > 0:
        dummy = pynn.Population(mappingOffset, pynn.IF_facets_hardware1)

    neuronList = []
    for i in range(noNeurons):
        neuronList.append(pynn.Population(1, pynn.IF_facets_hardware1))
        neuronList[-1].record()
        dummy = pynn.Population(1, pynn.IF_facets_hardware1)

    stim = pynn.Population(1, pynn.SpikeSourcePoisson)
    for neuron in neuronList:
        pynn.Projection(stim, neuron,
                        pynn.AllToAllConnector(weights=pynn.minExcWeight()))

    pynn.run(1000.0)
    pynn.end()

    f = open('spikeyconfig.out')
    for line in f:
        for i in range(mappingOffset + 2 * noNeurons):
            if line.find('w ' + str(192 + i)) >= 0:
                weight = int(line.split(' ')[256 + 2 - 1])
                print 192 + i, weight
                assert (weight == shouldPatternWeights[i]
                        ), 'results do not fit expectation'
    f.close()
def run(lowThreshold):
    runtime = 1000.0
    pynn.setup()

    # set STDP params for low threshold  -> fails when vcthigh-vctlow < 0.04
    if lowThreshold:
        pynn.hardware.hwa.setSTDPParams(0.0, default.tpcsec,
                                        default.tpcorperiod, 1.0, 1.0, 1.0,
                                        0.98, 2.5)
    else:
        pynn.hardware.hwa.setSTDPParams(0.0, default.tpcsec,
                                        default.tpcorperiod, 1.0, 1.0, 1.0,
                                        0.85, 2.5)

    neuron = pynn.Population(1, pynn.IF_facets_hardware1)
    spikeArray = pynn.Population(1, pynn.SpikeSourceArray)

    stdp_model = pynn.STDPMechanism(
        timing_dependence=pynn.SpikePairRule(),
        weight_dependence=pynn.AdditiveWeightDependence())

    prj = pynn.Projection(
        spikeArray,
        neuron,
        method=pynn.AllToAllConnector(weights=pynn.minExcWeight() * 0),
        target='excitatory',
        synapse_dynamics=pynn.SynapseDynamics(slow=stdp_model))

    pynn.run(runtime)
    pynn.end()
Beispiel #3
0
def test_spikey5_allneurons():
    '''
    Tests mapping and firing of all 384 neurons.
    '''
    runtime = 1000.0
    stimRate = 10.0
    weight = 7

    pynn.setup()

    neurons = pynn.Population(384, pynn.IF_facets_hardware1)
    stim = pynn.Population(10, pynn.SpikeSourcePoisson, {
        'start': 0,
        'duration': runtime,
        'rate': stimRate
    })

    prj = pynn.Projection(
        stim,
        neurons,
        method=pynn.AllToAllConnector(weights=pynn.minExcWeight() * weight),
        target='excitatory')

    pynn.run(runtime)

    spikes = neurons.getSpikes()
    print 'spikes from', len(np.unique(spikes)), 'different neurons'
    # TODO: check for spikes from all neurons

    pynn.end()
def emulation(seed, connType=0, returnValue=None):
    numberNeurons = 192
    noInputs = 15

    pynn.setup()

    rngPrj = pynn.random.NumpyRNG(seed=seed,
                                  parallel_safe=True)  # this may not work?!
    neurons = pynn.Population(numberNeurons, pynn.IF_facets_hardware1)
    connector = None
    if connType == 0:
        connector = pynn.FixedNumberPreConnector(noInputs,
                                                 weights=pynn.minExcWeight())
    elif connType == 1:
        connector = pynn.FixedNumberPostConnector(noInputs,
                                                  weights=pynn.minExcWeight())
    elif connType == 2:
        connector = pynn.FixedProbabilityConnector(float(noInputs) /
                                                   numberNeurons,
                                                   weights=pynn.minExcWeight())
    else:
        assert False, 'invalid connector type'

    prj = pynn.Projection(neurons,
                          neurons,
                          method=connector,
                          target='inhibitory',
                          rng=rngPrj)

    connList = []
    for conn in prj.connections():
        connList.append(conn)

    assert len(connList) > 0, 'no connections'
    assert len(connList) < numberNeurons * \
        (numberNeurons - 1), 'all-to-all connection'

    pynn.run(1.0)

    pynn.end()

    if returnValue != None:
        returnValue = connList
    else:
        return connList
Beispiel #5
0
 def build(rateIn):
     global neurons, stim
     poissonParams = {'start': 0, 'duration': runtime, 'rate': rateIn}
     stim = pynn.Population(32, pynn.SpikeSourcePoisson, poissonParams)
     neurons = pynn.Population(numNeurons, pynn.IF_facets_hardware1)
     pynn.Projection(stim,
                     neurons,
                     pynn.AllToAllConnector(weights=pynn.minExcWeight() *
                                            5.0),
                     target='excitatory')
     neurons.record()
Beispiel #6
0
def compareSpikesToMembrane(duration):
    """
    Tests the precise timing of digital spikes and spikes extracted from the membrane potential.
    The neuron is stimulated with Poisson spike sources.
    """
    np.random.seed(int(time.time()))
    neuronNo = np.random.random_integers(0, 191)
    print 'Using neuron number', neuronNo

    poissonParams = {'start': 100.0, 'duration': duration -
                     100.0, 'rate': 30.0}  # offset of 100 ms to get all spikes
    weightExc = 4  # digital hardware value
    weightInh = 15  # digital hardware value
    freqLimit = 1.0  # 1/s
    meanLimit = 0.2  # ms
    stdLimit = 0.2  # ms

    import pyNN.hardware.spikey as pynn

    pynn.setup(mappingOffset=neuronNo)

    stimExc = pynn.Population(64, pynn.SpikeSourcePoisson, poissonParams)
    stimInh = pynn.Population(192, pynn.SpikeSourcePoisson, poissonParams)
    neuron = pynn.Population(1, pynn.IF_facets_hardware1)
    prj = pynn.Projection(stimExc, neuron, pynn.AllToAllConnector(
        weights=weightExc * pynn.minExcWeight()), target='excitatory')
    prj = pynn.Projection(stimInh, neuron, pynn.AllToAllConnector(
        weights=weightInh * pynn.minInhWeight()), target='inhibitory')

    neuron.record()
    pynn.record_v(neuron[0], '')

    pynn.run(duration)

    spikes = neuron.getSpikes()[:, 1]
    membrane = pynn.membraneOutput
    memTime = pynn.timeMembraneOutput
    spikesMem, deriv, thresh = spikesFromMem(memTime, membrane)

    pynn.end()

    #plot(memTime, membrane, spikes, spikesMem, deriv, thresh)

    print 'Spikes and spikes on membrane:', len(spikes), '/', len(spikesMem)
    assert len(spikes) / duration * 1e3 >= freqLimit, 'Too less spikes.'
    assert len(spikes) == len(spikesMem), 'Spikes do not match membrane.'
    spikesDiff = spikesMem - spikes
    spikesDiffMean = np.mean(spikesDiff)
    spikesDiffStd = np.std(spikesDiff)
    print 'Offset between spikes and membrane:', spikesDiffMean, '+-', spikesDiffStd
    assert spikesDiffMean < meanLimit, 'Spike and membrane have too large offset.'
    assert spikesDiffStd < stdLimit, 'Time axes of spikes and membrane are different.'
Beispiel #7
0
def emulate():
    # pynn.setup(useUsbAdc=True)
    pynn.setup()
    stimI = pynn.Population(40, pynn.SpikeSourcePoisson, {
        'start': 0,
        'duration': runtime,
        'rate': rate
    })
    stimE = pynn.Population(20, pynn.SpikeSourcePoisson, {
        'start': 0,
        'duration': runtime,
        'rate': rate
    })
    neuron = pynn.Population(192, pynn.IF_facets_hardware1)
    prjI = pynn.Projection(stimI,
                           neuron,
                           pynn.AllToAllConnector(weights=weight *
                                                  pynn.minInhWeight()),
                           target='inhibitory')
    prjE = pynn.Projection(stimE,
                           neuron,
                           pynn.AllToAllConnector(weights=weight *
                                                  pynn.minExcWeight()),
                           target='excitatory')
    stimI.record()
    stimE.record()
    neuron.record()
    pynn.record_v(neuron[0], '')

    pynn.run(runtime)
    spikesInI = stimI.getSpikes()
    spikesInE = stimE.getSpikes()
    spikes = neuron.getSpikes()
    mem = pynn.membraneOutput

    print 'spikes out', len(spikes)
    print 'spikes in', len(spikesInI), len(spikesInE)
    print 'mem data points', len(mem)

    pynn.end()
Beispiel #8
0
import pyNN.hardware.spikey as pynn
import numpy as np

runtime = 500.0  # ms
noPops = 9  # chain length
popSize = {'exc': 10, 'inh': 10}  # size of each chain link
# connection probabilities
probExcExc = 1.0
probExcInh = 1.0
probInhExc = 1.0

pynn.setup()

# define weights in digital hardware values
weightStimExcExc = 10 * pynn.minExcWeight()
weightStimExcInh = 10 * pynn.minExcWeight()
weightExcExc = 5 * pynn.minExcWeight()
weightExcInh = 10 * pynn.minExcWeight()
weightInhExc = 7 * pynn.minInhWeight()

# kick starter
stimSpikes = np.array([100.0])
stimExc = pynn.Population(popSize['exc'], pynn.SpikeSourceArray,
                          {'spike_times': stimSpikes})

# create neuron populations
popCollector = {'exc': [], 'inh': []}
for synType in ['exc', 'inh']:
    for popIndex in range(noPops):
        pop = pynn.Population(popSize[synType], pynn.IF_facets_hardware1)
Beispiel #9
0
if row >= noStim:
    if row > noStim:
        dummy = pynn.Population(row - noStim, pynn.SpikeSourceArray)
    spikeSourcePlastic = pynn.Population(1, pynn.SpikeSourceArray,
                                         {'spike_times': stimulusPlastic})
assert (spikeSourceStim != None)
assert (spikeSourcePlastic != None)

# configure STDP
stdp_model = pynn.STDPMechanism(
    timing_dependence=pynn.SpikePairRule(),
    weight_dependence=pynn.AdditiveWeightDependence())
# connect stimulus
pynn.Projection(spikeSourceStim,
                neuron,
                method=pynn.AllToAllConnector(weights=pynn.minExcWeight() *
                                              weightStim),
                target='excitatory')
# create plastic synapse
prj = pynn.Projection(
    spikeSourcePlastic,
    neuron,
    method=pynn.AllToAllConnector(weights=pynn.minExcWeight() * weightPlastic),
    target='excitatory',
    synapse_dynamics=pynn.SynapseDynamics(slow=stdp_model))

neuron.record()

## custom correlation flags:
## 0: no weight change
## 1: one (or multiple) weight changes triggered by pre-post spike pairs
Beispiel #10
0
if row >= noStim:
    if row > noStim:
        dummy = pynn.Population(row - noStim, pynn.SpikeSourceArray)
    spikeSourcePlastic = pynn.Population(1, pynn.SpikeSourceArray, {"spike_times": stimulusPlastic})
assert spikeSourceStim != None
assert spikeSourcePlastic != None

# configure STDP
stdp_model = pynn.STDPMechanism(
    timing_dependence=pynn.SpikePairRule(), weight_dependence=pynn.AdditiveWeightDependence()
)
# connect stimulus
pynn.Projection(
    spikeSourceStim,
    neuron,
    method=pynn.AllToAllConnector(weights=pynn.minExcWeight() * weightStim),
    target="excitatory",
)
# create plastic synapse
prj = pynn.Projection(
    spikeSourcePlastic,
    neuron,
    method=pynn.AllToAllConnector(weights=pynn.minExcWeight() * weightPlastic),
    target="excitatory",
    synapse_dynamics=pynn.SynapseDynamics(slow=stdp_model),
)

neuron.record()

## custom correlation flags:
## 0: no weight change
Beispiel #11
0
neuronIndex        = 42          # choose neuron on chip in range(384)
synapseDriverIndex = 42          # choose synapse driver in range(256)

pynn.setup(mappingOffset=neuronIndex, calibSynDrivers=False) #turn off calibration of synapse line drivers

##build network
neurons = pynn.Population(1, pynn.IF_facets_hardware1)
pynn.record_v(neurons[0], '')
#allocate dummy synapse drivers sending no spikes
if synapseDriverIndex > 0:
    stimuliDummy = pynn.Population(synapseDriverIndex, pynn.SpikeSourceArray, {'spike_times': []})
    prj = pynn.Projection(stimuliDummy, neurons, pynn.AllToAllConnector(weights=0), target='excitatory')
#allocate synapse driver and configure spike times
stimProp = {'spike_times': np.arange(durationInterval, runtime - durationInterval, durationInterval)}
stimuli = pynn.Population(1, pynn.SpikeSourceArray, stimProp)
prj = pynn.Projection(stimuli, neurons, pynn.AllToAllConnector(weights=weight * pynn.minExcWeight()), target='excitatory')

#modify properties of synapse driver
print 'Range of calibration factors of drvifall for excitatory connections', prj.getDrvifallFactorsRange('exc')
prj.setDrvifallFactors([0.8])
#prj.setDrvioutFactors([1.0])

##run network
pynn.run(runtime)
mem = pynn.membraneOutput
time = pynn.timeMembraneOutput
pynn.end()

##calculate spike-triggered average of membrane potential
timeNorm = time - time[0]
#number of data points per interval
Beispiel #12
0
pynn.setup(
    calibTauMem=False)  #turn off calibration of membrane time constant tau_mem

#build network
stimuli = pynn.Population(noStims, pynn.SpikeSourcePoisson, {
    'start': 0,
    'duration': runtime,
    'rate': rateStim
})
neurons = pynn.Population(noNeurons, pynn.IF_facets_hardware1)
pynn.Projection(stimuli,
                neurons,
                pynn.FixedNumberPreConnector(noInputs,
                                             weights=weight *
                                             pynn.minExcWeight()),
                target='excitatory')
neurons.record()

#sweep over g_leak values, emulate network and record spikes
for gLeakValue in gLeakList:
    neurons.set({'g_leak': gLeakValue})
    pynn.run(runtime)
    resultCollector.append([
        gLeakValue,
        old_div(float(len(neurons.getSpikes())) / noNeurons, runtime) * 1e3
    ])
pynn.end()

#plot results
resultCollector = np.array(resultCollector)
Beispiel #13
0
    def runTest(self):
        import numpy as np

        column = 4
        row = 4
        n = 20  # number of spike pairs
        deltaTList = [-1.0, 1.0]  # ms
        deltaTLimit = 0.3  # allowed deviation
        delay = 2.9  # ms (between stimulus and post)
        # at beginning in ms (should be larger than max deltaT)
        experimentOffset = 100.0
        deltaTPairs = 100.0  # time between pre-post-pairs in ms

        noStimulators = 3
        weightStimulator = 15  # weight for stimulator neurons
        weightMeasure = 0  # weight for measured neuron
        procCorrOffset = 100.0  # time after experiment until correlations are processed in ms

        for deltaT in deltaTList:
            stimulus = np.arange(experimentOffset,
                                 (n - 0.5) * deltaTPairs + experimentOffset,
                                 deltaTPairs)
            self.assertTrue(len(stimulus) == n)
            stimulusMeasure = stimulus + delay - deltaT

            import pyNN.hardware.spikey as pynn
            import hwconfig_default_s1v2 as default

            pynn.setup()

            if column > 0:
                pynn.Population(column, pynn.IF_facets_hardware1)
            # stimulated neuron
            neuron = pynn.Population(1, pynn.IF_facets_hardware1)

            spikeSourceStim = None
            spikeSourceMeasure = None
            # stimulators above measured synapse
            if row < noStimulators:
                if row > 0:
                    dummy = pynn.Population(row, pynn.SpikeSourceArray)
                spikeSourceMeasure = pynn.Population(
                    1, pynn.SpikeSourceArray, {'spike_times': stimulusMeasure})

            spikeSourceStim = pynn.Population(noStimulators,
                                              pynn.SpikeSourceArray,
                                              {'spike_times': stimulus})

            # stimulators below measured synapse
            if row >= noStimulators:
                if row > noStimulators:
                    dummy = pynn.Population(row - noStimulators,
                                            pynn.SpikeSourceArray)
                spikeSourceMeasure = pynn.Population(
                    1, pynn.SpikeSourceArray, {'spike_times': stimulusMeasure})

            # connect and record
            stdp_model = pynn.STDPMechanism(
                timing_dependence=pynn.SpikePairRule(),
                weight_dependence=pynn.AdditiveWeightDependence())
            pynn.Projection(
                spikeSourceStim,
                neuron,
                method=pynn.AllToAllConnector(weights=pynn.minExcWeight() *
                                              weightStimulator),
                target='excitatory')
            prj = pynn.Projection(
                spikeSourceMeasure,
                neuron,
                method=pynn.AllToAllConnector(weights=pynn.minExcWeight() *
                                              weightMeasure),
                target='excitatory',
                synapse_dynamics=pynn.SynapseDynamics(slow=stdp_model))
            neuron.record()

            #######
            # RUN #
            #######
            # correlation flags:
            # 0: no weight change
            # 1: causal weight change
            # 2: anti-causal weight change
            pynn.hardware.hwa.setLUT(
                [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                [2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

            lastInputSpike = np.max(np.concatenate(
                (stimulus, stimulusMeasure)))
            runtime = lastInputSpike + procCorrOffset
            pynn.hardware.hwa.autoSTDPFrequency = runtime
            print 'runtime: ' + str(runtime) + '; last input spike: ' + str(
                lastInputSpike) + '; STDP readout: ' + str(runtime)
            pynn.run(runtime)

            # get flag and spikes
            corrFlag = (
                np.array(prj.getWeightsHW(readHW=True, format='list')) /
                pynn.minExcWeight())[0]
            spikes = neuron.getSpikes()[:, 1]
            print 'stimulus:', stimulus
            print 'measure:', stimulusMeasure
            print 'post:', spikes
            self.assertTrue(
                len(stimulusMeasure) == len(spikes), 'No proper spiking!')
            print 'correlation flag: ' + str(corrFlag)
            print 'deltaT (is / should / limit):', np.mean(
                spikes - stimulusMeasure), '/', deltaT, '/', deltaTLimit
            self.assertTrue(
                abs(np.mean(spikes - stimulusMeasure) - deltaT) <= deltaTLimit,
                'No precise spiking!')
            if deltaT > 0:  # causal
                self.assertTrue(corrFlag == 1, 'Wrong correlation flag!')
            else:  # anti-causal
                self.assertTrue(corrFlag == 2, 'Wrong correlation flag!')

            pynn.end()
Beispiel #14
0
    def runTest(self):
        with_figure = False
        import numpy
        import pyNN.hardware.spikey as pynn
        if with_figure:
            import pylab

        # some test parameters
        weight = 12.0  # in units of pyn.minExcWeight

        neuron_params = {
            'g_leak': 1.0,  # nS
            'tau_syn_E': 5.0,  # ms
            'tau_syn_I': 5.0,  # ms
            'v_reset': -100.0,  # mV
            'e_rev_I': -100.0,  # mV,
            'v_rest': -65.0,  # mV
            'v_thresh': -63.0  # mV
        }

        stim_offset = 100.0  # ms
        stim_isi = 500.0  # ms
        stim_num = 10  # Number of external input spikes
        stim_weight = 8.0  # in units of pyn.minExcWeight
        stim_pop_size = 10  # size of stimulating population

        # set up the test network where pre_neuron and pst_neuron are on different
        # blocks
        #======================================================================
        #                    pre_neuron ==> pst_neuron
        #
        # stim ==> sil_neuron
        #======================================================================
        # there shouldn't be a connection between sil_neuron and pst_neuron
        neuron_order = range(0, 384, 1)
        if with_figure:
            pynn.setup(neuronPermutation=neuron_order, useUsbAdc=True)
        else:
            pynn.setup(neuronPermutation=neuron_order)

        # create the populations
        pre_neuron = pynn.Population(1, pynn.IF_facets_hardware1)
        sil_neuron = pynn.Population(1, pynn.IF_facets_hardware1)
        pst_neuron = pynn.Population(1, pynn.IF_facets_hardware1)
        if with_figure:
            pynn.record_v(pst_neuron[0], '')

        # create the connection
        pre_pst_con = pynn.AllToAllConnector(weights=weight *
                                             pynn.minExcWeight())
        pre_pst_prj = pynn.Projection(pre_neuron, pst_neuron, pre_pst_con)

        # create the external stimulus
        stim_times = numpy.arange(stim_offset, stim_num * stim_isi, stim_isi)
        stim_pop = pynn.Population(stim_pop_size, pynn.SpikeSourceArray,
                                   {'spike_times': stim_times})

        # connect the external simulus
        stim_con = pynn.AllToAllConnector(weights=stim_weight *
                                          pynn.minExcWeight())
        stim_prj = pynn.Projection(stim_pop, sil_neuron, stim_con)

        # record spikes of all involved neurons
        pre_neuron.record()
        pst_neuron.record()
        sil_neuron.record()

        # run the emulation
        pynn.run(stim_offset + ((stim_num + 1) * stim_isi))

        if with_figure:
            pylab.figure()
            pylab.plot(pynn.timeMembraneOutput, pynn.membraneOutput)
            pylab.show()

        # let's see what we've got, accept up to 1 ghost spike
        assert (len(pre_neuron.getSpikes()) < 2)
        assert (len(pst_neuron.getSpikes()) < 2)
        assert (len(sil_neuron.getSpikes()) >= 10)
        assert (len(sil_neuron.getSpikes()) < 12)
Beispiel #15
0
    def runTest(self):
        with_figure = False
        import numpy
        import pyNN.hardware.spikey as pynn
        if with_figure:
            import pylab

        # some test parameters
        neuron_param = {
            'g_leak': 1.0,  # nS
            'tau_syn_E': 5.0,  # ms
            'tau_syn_I': 5.0,  # ms
            'v_reset': -100.0,  # mV
            'e_rev_I': -100.0,  # mV,
            'v_rest': -65.0,  # mV
            'v_thresh': -62.0  # mV
        }
        stim_offset = 100.0  # ms
        stim_isi = 500.0  # ms
        stim_num = 10  # Number of external input spikes
        stim_weight = 8.0  # in units of pyn.minExcWeight
        stim_pop_size = 10  # size of stimulating population
        duration = stim_offset + ((stim_num + 1) * stim_isi)

        # neuron order: {0, 2, ..., 190, 1, 3, ..., 191, 192, 193, .., 383}
        neuron_order = range(0, 191, 2) + range(1, 192, 2) + range(192, 384, 1)
        if with_figure:
            pynn.setup(neuronPermutation=neuron_order, useUsbAdc=True)
        else:
            pynn.setup(neuronPermutation=neuron_order)

        # create first population with an even hardware neuron index
        fst_population = pynn.Population(48, pynn.IF_facets_hardware1,
                                         neuron_param)
        # create second population with an even hardware neuron index
        snd_population = pynn.Population(48, pynn.IF_facets_hardware1,
                                         neuron_param)
        if with_figure:
            pynn.record_v(fst_population[0], '')

        # create the external stimulus
        stim_times = numpy.arange(stim_offset, stim_num * stim_isi, stim_isi)
        stim_pop = pynn.Population(stim_pop_size, pynn.SpikeSourceArray,
                                   {'spike_times': stim_times})

        # connect the external simulus
        stim_con = pynn.AllToAllConnector(weights=stim_weight *
                                          pynn.minExcWeight())
        stim_prj_fst = pynn.Projection(stim_pop, fst_population, stim_con)
        stim_prj_snd = pynn.Projection(stim_pop, snd_population, stim_con)

        # record spikes of all involved neurons
        fst_population.record()
        snd_population.record()

        # run the emulation
        pynn.run(duration)

        # get the spike data
        pre_change_spikes_fst = fst_population.getSpikes()
        pre_change_spikes_snd = snd_population.getSpikes()
        if with_figure:
            plotVoltageAndSpikes(pylab,
                                 pynn.timeMembraneOutput,
                                 pynn.membraneOutput,
                                 pre_change_spikes_fst,
                                 pre_change_spikes_snd,
                                 nrn_idx_lim=[0, 96])

        # change the configuration for the first group
        # desired behaviour: change the configuration for all even neurons
        # "set" should be stronger than "previous setting in even/uneven group"
        pynn.set(fst_population[0], pynn.IF_facets_hardware1,
                 {'v_thresh': 0.0})

        # run the emulation
        pynn.run(duration)

        # get the spike data
        lidx_change_spikes_fst = fst_population.getSpikes()
        lidx_change_spikes_snd = snd_population.getSpikes()
        if with_figure:
            plotVoltageAndSpikes(pylab,
                                 pynn.timeMembraneOutput,
                                 pynn.membraneOutput,
                                 lidx_change_spikes_fst,
                                 lidx_change_spikes_snd,
                                 nrn_idx_lim=[0, 96])

        pre_spikes_count_fst = float(len(pre_change_spikes_fst[:, 0]))
        pre_spikes_count_snd = float(len(pre_change_spikes_snd[:, 0]))
        lidx_spikes_count_fst = float(len(lidx_change_spikes_fst[:, 0]))
        lidx_spikes_count_snd = float(len(lidx_change_spikes_snd[:, 0]))
        # let's see what we've got
        assert (pre_spikes_count_fst > 0)
        assert (pre_spikes_count_snd > 0)
        assert (lidx_spikes_count_fst / pre_spikes_count_fst < 0.01)
        assert (lidx_spikes_count_snd / pre_spikes_count_snd < 0.01)
Beispiel #16
0
}

HiddenNeuronParams = InputNeuronParams
OutNeuronParams = InputNeuronParams

i1spkt = concatenate((arange(1000., 2000., 100.), arange(3000., 4000., 100.)))
i2spkt = concatenate((arange(2000., 3000., 100.), arange(3000., 4000., 100.)))

####################################################################
# procedural experiment description
####################################################################

# necessary setup
sim.setup()

we = sim.minExcWeight()  #
wi = sim.minInhWeight()  #

# set up network

# I want another neuron, so I need to build some dummy neurons, because
sim.Population(193, sim.IF_facets_hardware1, InputNeuronParams)

# create & record neurons
labels = ['i1', 'i2', 'y1', 'y2', 'h1', 'h2', 'o']
popsize = 1
skipsize = 2
populations = {}
parrotsE = {}
parrotsI = {}
Beispiel #17
0
#stpParams = {'U': 1.4, 'tau_rec': 1.8, 'tau_facil': 0.0}

runtime = 1000.0

pynn.setup(mappingOffset=column)

neuron = pynn.Population(1, pynn.IF_facets_hardware1)
dummy = pynn.Population(row, pynn.SpikeSourceArray, stimParams)
stimulus = pynn.Population(1, pynn.SpikeSourceArray, stimParams)

# enable and configure STP
stp_model = pynn.TsodyksMarkramMechanism(**stpParams)
pynn.Projection(
    stimulus,
    neuron,
    method=pynn.AllToAllConnector(weights=weight * pynn.minExcWeight()),
    target='excitatory',
    synapse_dynamics=pynn.SynapseDynamics(
        fast=stp_model)  #hier auskommentieren
)

pynn.record_v(neuron[0], '')

pynn.run(runtime)

membrane = np.array(zip(pynn.timeMembraneOutput, pynn.membraneOutput))

pynn.end()

# plot
import matplotlib.pyplot as plt
noStims   = 64                 # number of stimuli generated on the host computer
noNeurons = 32                 # number of hardware neurons
noInputs  = 16                 # number for stimuli connected to each neuron
weight    = 7.0                # synaptic weight in digital values
rateStim  = 10.0               # rate of each stimulus in 1/s
runtime   = 10 * 1000.0        # runtime in biological time domain in ms
gLeakList = np.arange(2,251,8) # hardware range with calibTauMem turned off: [2,250] micro siemens

resultCollector = []

pynn.setup(calibTauMem=False) #turn off calibration of membrane time constant tau_mem

#build network
stimuli = pynn.Population(noStims, pynn.SpikeSourcePoisson, {'start': 0, 'duration': runtime, 'rate': rateStim})
neurons = pynn.Population(noNeurons, pynn.IF_facets_hardware1)
pynn.Projection(stimuli, neurons, pynn.FixedNumberPreConnector(noInputs, weights=weight * pynn.minExcWeight()), target='excitatory')
neurons.record()

#sweep over g_leak values, emulate network and record spikes
for gLeakValue in gLeakList:
    neurons.set({'g_leak': gLeakValue})
    pynn.run(runtime)
    resultCollector.append([gLeakValue, float(len(neurons.getSpikes())) / noNeurons / runtime * 1e3])
pynn.end()

#plot results
resultCollector = np.array(resultCollector)
plt.figure()
plt.plot(resultCollector[:,0], resultCollector[:,1])
plt.xlim(0, np.max(gLeakList))
plt.ylim(0, np.max(resultCollector[:,1]) * 1.05)
    def emulate(self, driverIndexExc, driverIndexInh=None, drvirise=None, drvifallExc=None, drvifallInh=None, drvioutExc=None, drvioutInh=None, filename=None, calibSynDrivers=False):
        '''Run emulations on hardware.'''
        assert self.stimParams != None, 'specifiy stimulus first'
        pynn.setup(calibTauMem=True,
                   calibSynDrivers=calibSynDrivers,
                   calibVthresh=False,
                   calibIcb=False,
                   workStationName=self.workstation,
                   writeConfigToFile=False)

        #create neuron
        self.neuronList.sort()
        neuronCollector = []
        currentIndex = 0
        for neuronIndex in self.neuronList:
            if neuronIndex > currentIndex: #insert dummy neurons if neuronList not continuous
                dummyPopSize = neuronIndex - currentIndex
                dummy = pynn.Population(dummyPopSize, pynn.IF_facets_hardware1, self.neuronParams)
                currentIndex += dummyPopSize
                self.logger.debug('inserted ' + str(dummyPopSize) + ' dummy neurons')
            if neuronIndex == currentIndex:
                neuron = pynn.Population(1, pynn.IF_facets_hardware1, self.neuronParams)
                currentIndex += 1
                neuron.record()
                neuronCollector.append(neuron)
            else:
                raise Exception('Could not create all neurons')

        #create input and connect to neuron
        synDrivers = [[driverIndexExc, 'excitatory'], [driverIndexInh, 'inhibitory']]
        synDrivers.sort()

        currentIndex = 0
        for synDriver in synDrivers:
            toInsertIndex = synDriver[0]
            targetType = synDriver[1]
            if toInsertIndex == None:
                self.logger.debug('skipping ' + targetType + ' stimulation')
                continue
            if toInsertIndex > currentIndex:
                dummyPopSize = toInsertIndex - currentIndex
                dummy = pynn.Population(dummyPopSize, pynn.SpikeSourcePoisson)
                currentIndex += dummyPopSize
                self.logger.debug('inserted ' + str(dummyPopSize) + ' dummy synapse drivers')
            stim = pynn.Population(1, pynn.SpikeSourcePoisson, self.stimParams[targetType])
            self.logger.debug('inserted 1 stimulus of type ' + targetType + ' with rate ' + str(self.stimParams[targetType]['rate']))

            if targetType == 'excitatory':
                hardwareWeightTemp = self.hardwareWeight * pynn.minExcWeight()
            elif targetType == 'inhibitory':
                hardwareWeightTemp = self.hardwareWeight * pynn.minInhWeight()
            else:
                raise Exception('Synapse type not supported!')

            for neuron in neuronCollector:
                pynn.Projection(stim, neuron, method=pynn.AllToAllConnector(weights=hardwareWeightTemp), target=targetType)
            currentIndex += 1

        #set custom parameters
        if drvirise != None:
            pynn.hardware.hwa.drvirise = drvirise
        else:
            pynn.hardware.hwa.drvirise = default.drvirise
        if drvifallExc != None:
            pynn.hardware.hwa.drvifall_base['exc'] = drvifallExc
        else:
            pynn.hardware.hwa.drvifall_base['exc'] = default.drvifall_base['exc']
        if drvifallInh != None:
            pynn.hardware.hwa.drvifall_base['inh'] = drvifallInh
        else:
            pynn.hardware.hwa.drvifall_base['inh'] = default.drvifall_base['inh']
        if drvioutExc != None:
            pynn.hardware.hwa.drviout_base['exc'] = drvioutExc
        else:
            pynn.hardware.hwa.drviout_base['exc'] = default.drviout_base['exc']
        if drvioutInh != None:
            pynn.hardware.hwa.drviout_base['inh'] = drvioutInh
        else:
            pynn.hardware.hwa.drviout_base['inh'] = default.drviout_base['inh']

        #run
        pynn.run(self.runtime)
        #temperature = pynn.hardware.hwa.getTemperature()
        #self.logger.debug('temperature ' + str(temperature) + ' degree Celsius')

        #obtain firing rate
        spikes = None
        neuronCount = 0
        for neuron in neuronCollector:
            spikesNeuron = neuron.getSpikes()
            neuronCount += neuron.size
            if spikes == None:
                spikes = spikesNeuron
            else:
                spikes = np.concatenate((spikes, spikesNeuron))
        if len(spikes) > 0:
            spikes = spikes[spikes[:,1] > self.cutfirst]
            if len(spikes) > 0:
                spikes = spikes[spikes[:,1] <= self.runtime]
        if filename != None:
            np.savetxt(os.path.join(self.folder, filename), spikes)
        spikesPerNeuron = float(len(spikes)) / neuronCount
        pynn.end()
        rate =  spikesPerNeuron * 1e3 / (self.runtime - self.cutfirst)

        return rate
Beispiel #20
0
"""

# for plotting without X-server
import matplotlib as mpl

mpl.use("Agg")

import pyNN.hardware.spikey as pynn
import numpy as np

pynn.setup()

# set resting potential over spiking threshold
runtime = 1000.0  # ms
popSize = 192
weight = 7.0 * pynn.minExcWeight()
neuronParams = {"v_rest": -40.0}

neurons = pynn.Population(popSize, pynn.IF_facets_hardware1, neuronParams)
pynn.Projection(neurons, neurons, pynn.FixedNumberPreConnector(15, weights=weight), target="inhibitory")
neurons.record()

pynn.run(runtime)

spikes = neurons.getSpikes()

pynn.end()

# visualize
print "mean firing rate:", round(len(spikes) / runtime / popSize * 1000.0, 1), "1/s"
Beispiel #21
0
def route(connection):
    """
    Connect synapse driver to each neuron individually and stimulate.
    Check other neurons for spontaneous activity.
    To take care of "ghost spikes", one neuron in each 64-block of neurons is stimulated.
    """

    synDriverIndex, neuronIndexBlock = connection
    print 'testing route:', synDriverIndex, '->', neuronIndexBlock

    neuronParam = copy.copy(pynn.IF_facets_hardware1.default_parameters)
    neuronParam['v_thresh'] = neuronParam['v_rest'] + 10.0
    neuronParam['g_leak'] = 40.0  # TODO: to avoid warnings of tau_mem calib

    # one neuron in each block of 64 neurons is stimulated
    pynn.setup()
    chipVersion = pynn.getChipVersion()
    noNeuronBlocks = 6
    if chipVersion == 4:
        noNeuronBlocks = 3  # use only one half of chip

    # create stimulus
    if synDriverIndex > 0:
        stimDummy = pynn.Population(synDriverIndex, pynn.SpikeSourceArray)
    stim = pynn.Population(1, pynn.SpikeSourcePoisson, {
        'start': 0,
        'duration': runtime,
        'rate': stimRate
    })

    # create neurons
    neuronList = []
    dummyNeuronsList = []

    if neuronIndexBlock > 0:
        dummyNeurons = pynn.Population(neuronIndexBlock,
                                       pynn.IF_facets_hardware1, neuronParam)
        dummyNeurons.record()
        dummyNeuronsList.append(dummyNeurons)
    for neuronBlock in range(noNeuronBlocks):
        neuron = pynn.Population(1, pynn.IF_facets_hardware1, neuronParam)
        neuron.record()
        neuronList.append(neuron)
        if neuronBlock < noNeuronBlocks - 1:
            dummyNeurons = pynn.Population(63, pynn.IF_facets_hardware1,
                                           neuronParam)
            dummyNeurons.record()
            dummyNeuronsList.append(dummyNeurons)
    if neuronIndexBlock < 63:
        dummyNeurons = pynn.Population(63 - neuronIndexBlock,
                                       pynn.IF_facets_hardware1, neuronParam)
        dummyNeurons.record()
        dummyNeuronsList.append(dummyNeurons)

    # connect stimulus to neurons
    for neuron in neuronList:
        pynn.Projection(stim,
                        neuron,
                        method=pynn.AllToAllConnector(weights=weight *
                                                      pynn.minExcWeight()),
                        target='excitatory')

    pynn.run(runtime)

    def getRate(spikes):
        return len(spikes) / runtime * 1e3

    rateList = []
    rateDummyList = []
    for neuronIndex, neuron in enumerate(neuronList):
        neuronIndexGlobal = neuronIndex * 64 + neuronIndexBlock
        spikes = neuron.getSpikes()
        if len(spikes) > 0:
            assert (neuronIndexGlobal == np.squeeze(np.unique(
                spikes[:, 0]))).all()
        rate = getRate(spikes)
        rateList.append([neuronIndexGlobal, rate])

    for dummyNeurons in dummyNeuronsList:
        rateDummyList.append(getRate(dummyNeurons.getSpikes()))

    print 'rate neurons:', rateList
    print 'rate dummy neurons', rateDummyList

    pynn.end()

    # evaluate firing rates
    def addFail():
        if not connection in failList:
            failList.append(connection)

    def didFire(rate):
        addFail()
        return 'Neurons did fire with rate ' + str(round(
            rate, 2)) + ' although not connected and stimulated.'

    def didNotFire(neuronIndexGlobal, rate):
        addFail()
        return 'Neuron ' + str(
            neuronIndexGlobal) + ' did fire with too low rate ' + str(
                round(rate, 2)) + ' although connected and stimulated.'

    for neuronIndexGlobal, rate in rateList:
        if rate < limitActive:
            print didNotFire(neuronIndexGlobal, rate)

    for rate in rateDummyList:
        if rate > limitSilence:
            print didFire(rate)

    # save data for collecting statistics
    with open(filename, 'a') as myfile:
        myfile.write(
            '%i %i %i\n' %
            (synDriverIndex, neuronIndexBlock, int(connection in failList)))
Beispiel #22
0
arXiv:1411.7916 [q-bio.NC].
'''

# for plotting without X-server
import matplotlib as mpl
mpl.use('Agg')

import pyNN.hardware.spikey as pynn
import numpy as np

pynn.setup()

# set resting potential over spiking threshold
runtime = 1000.0  #ms
popSize = 192
weight = 7.0 * pynn.minExcWeight()
neuronParams = {'v_rest': -40.0}

neurons = pynn.Population(popSize, pynn.IF_facets_hardware1, neuronParams)
pynn.Projection(neurons,
                neurons,
                pynn.FixedNumberPreConnector(15, weights=weight),
                target='inhibitory')
neurons.record()

pynn.run(runtime)

spikes = neurons.getSpikes()

pynn.end()
Beispiel #23
0
weight = 15.0
stimParams = {'spike_times': np.concatenate((np.arange(100.0, 401.0, 50.0), [700.0]))}
stpParams = {'U': 0.4, 'tau_rec': 100.0}
runtime = 1000.0

pynn.setup(mappingOffset=column)

neuron = pynn.Population(1, pynn.IF_facets_hardware1)
dummy = pynn.Population(row, pynn.SpikeSourceArray, stimParams)
stimulus = pynn.Population(1, pynn.SpikeSourceArray, stimParams)

# enable and configure STP
stp_model = pynn.TsodyksMarkramMechanism(**stpParams)
pynn.Projection(stimulus, neuron,
                method=pynn.AllToAllConnector(weights=weight * pynn.minExcWeight()),
                target='excitatory',
                synapse_dynamics=pynn.SynapseDynamics(fast=stp_model))

pynn.record_v(neuron[0], '')

pynn.run(runtime)

membrane = np.array(zip(pynn.timeMembraneOutput, pynn.membraneOutput))

pynn.end()

# plot
import matplotlib.pyplot as plt
plt.plot(membrane[:,0], membrane[:,1])
plt.xlabel('time (ms)')
Beispiel #24
0
    def runTest(self):
        with_figure = False
        import numpy
        import pyNN.hardware.spikey as pynn
        if with_figure:
            import pylab

        # some test parameters
        neuron_param_even = {
            'g_leak': 1.0,  # nS
            'tau_syn_E': 5.0,  # ms
            'tau_syn_I': 5.0,  # ms
            'v_reset': -100.0,  # mV
            'e_rev_I': -100.0,  # mV,
            'v_rest': -65.0,  # mV
            'v_thresh': -62.0  # mV
        }
        neuron_param_uneven = {
            'g_leak': 1.0,  # nS
            'tau_syn_E': 5.0,  # ms
            'tau_syn_I': 5.0,  # ms
            'v_reset': -100.0,  # mV
            'e_rev_I': -100.0,  # mV,
            'v_rest': -65.0,  # mV
            'v_thresh': 0.0  # mV
        }
        stim_offset = 100.0  # ms
        stim_isi = 500.0  # ms
        stim_num = 10  # Number of external input spikes
        stim_weight = 8.0  # in units of pyn.minExcWeight
        stim_pop_size = 10  # size of stimulating population
        duration = stim_offset + ((stim_num + 1) * stim_isi)

        # neuron order: {0, 2, ..., 190, 1, 3, ..., 191, 192, 193, ... 343}
        neuron_order = range(0, 191, 2) + range(1, 192, 2) + range(192, 384, 1)
        if with_figure:
            pynn.setup(neuronPermutation=neuron_order, useUsbAdc=True)
        else:
            pynn.setup(neuronPermutation=neuron_order)

        # create the population with an even hardware neuron index
        even_population = pynn.Population(96, pynn.IF_facets_hardware1,
                                          neuron_param_even)
        # create the population with an uneven hardware neuron index
        uneven_population = pynn.Population(96, pynn.IF_facets_hardware1,
                                            neuron_param_uneven)
        if with_figure:
            pynn.record_v(even_population[0], '')

        # create the external stimulus
        stim_times = numpy.arange(stim_offset, stim_num * stim_isi, stim_isi)
        stim_pop = pynn.Population(stim_pop_size, pynn.SpikeSourceArray,
                                   {'spike_times': stim_times})

        # connect the external simulus
        stim_con = pynn.AllToAllConnector(weights=stim_weight *
                                          pynn.minExcWeight())
        stim_prj_even = pynn.Projection(stim_pop, even_population, stim_con)
        stim_prj_uneven = pynn.Projection(stim_pop, uneven_population,
                                          stim_con)

        # record spikes of all involved neurons
        even_population.record()
        uneven_population.record()

        # run the emulation
        pynn.run(duration)

        # get the spike data
        pre_swap_spikes_even = even_population.getSpikes()
        pre_swap_spikes_uneven = uneven_population.getSpikes()
        if with_figure:
            plotVoltageAndSpikes(pylab, pynn.timeMembraneOutput,
                                 pynn.membraneOutput, pre_swap_spikes_even,
                                 pre_swap_spikes_uneven)

        # swap the configurations
        pynn.set(even_population[0], pynn.IF_facets_hardware1,
                 {'v_thresh': 0.0})
        pynn.set(uneven_population[0], pynn.IF_facets_hardware1,
                 {'v_thresh': -62.0})

        # run the emulation
        pynn.run(duration)

        # get the spike data
        pst_swap_spikes_even = even_population.getSpikes()
        pst_swap_spikes_uneven = uneven_population.getSpikes()
        if with_figure:
            plotVoltageAndSpikes(pylab, pynn.timeMembraneOutput,
                                 pynn.membraneOutput, pst_swap_spikes_even,
                                 pst_swap_spikes_uneven)

        pre_spikes_count_even = float(len(pre_swap_spikes_even[:, 0]))
        pre_spikes_count_uneven = float(len(pre_swap_spikes_uneven[:, 0]))
        pst_spikes_count_even = float(len(pst_swap_spikes_even[:, 0]))
        pst_spikes_count_uneven = float(len(pst_swap_spikes_uneven[:, 0]))
        # let's see what we've got
        assert (pre_spikes_count_even > 0)
        assert (pst_spikes_count_uneven > 0)
        assert (pre_spikes_count_uneven / pre_spikes_count_even < 0.01)
        assert (pst_spikes_count_even / pst_spikes_count_uneven < 0.01)
        assert (pre_spikes_count_uneven / pst_spikes_count_uneven < 0.01)
        assert (pst_spikes_count_even / pre_spikes_count_even < 0.01)
import pyNN.hardware.spikey as pynn
import numpy as np

runtime = 500.0 # ms
noPops = 9 # chain length
popSize = {'exc': 10, 'inh': 10} # size of each chain link
# connection probabilities
probExcExc = 1.0
probExcInh = 1.0
probInhExc = 1.0

pynn.setup()

# define weights in digital hardware values
weightStimExcExc = 10 * pynn.minExcWeight()
weightStimExcInh = 10 * pynn.minExcWeight()
weightExcExc = 5 * pynn.minExcWeight()
weightExcInh = 10 * pynn.minExcWeight()
weightInhExc = 7 * pynn.minInhWeight()

# kick starter
stimSpikes = np.array([100.0])
stimExc = pynn.Population(popSize['exc'], pynn.SpikeSourceArray, {'spike_times': stimSpikes})

# create neuron populations
popCollector = {'exc': [], 'inh': []}
for synType in ['exc', 'inh']:
    for popIndex in range(noPops):
        pop = pynn.Population(popSize[synType], pynn.IF_facets_hardware1)
        pop.record()
Beispiel #26
0
runtime = 500.0  # ms
noPops = 15  # chain length #9
popSize = {'exc': 6, 'inh': 6}  # size of each chain link #exc 10, inh 10
# connection probabilities
probExcExc = 1.0
probExcInh = 1.0
probInhExc = 1.0

# refractory period of neurons can be tuned for optimal synfire chain bahavior
neuronParams = {'tau_refrac': 10.0}

pynn.setup()

# define weights in digital hardware values
# --> these should be tuned first to obtain synfire chain behavior!
weightStimExcExc = 12 * pynn.minExcWeight()  # 12
weightStimExcInh = 12 * pynn.minExcWeight()  # 12
weightExcExc = 13 * pynn.minExcWeight()  # 8
weightExcInh = 14 * pynn.minExcWeight()  # 10
weightInhExc = 9 * pynn.minInhWeight()  # 7

# kick starter input pulse(s)
#stimSpikes = np.array([100.0])

# to have several kick starter pulses, use (don't forget to reduce to first entry for closed chain):
stimSpikes = np.array([100.0, 200.0, 300.0])

stimExc = pynn.Population(popSize['exc'], pynn.SpikeSourceArray,
                          {'spike_times': stimSpikes})

# create neuron populations
Beispiel #27
0
neuronIndex        = 42          # choose neuron on chip in range(384)
synapseDriverIndex = 42          # choose synapse driver in range(256)

pynn.setup(mappingOffset=neuronIndex, calibSynDrivers=False) #turn off calibration of synapse line drivers

##build network
neurons = pynn.Population(1, pynn.IF_facets_hardware1)
pynn.record_v(neurons[0], '')
#allocate dummy synapse drivers sending no spikes
if synapseDriverIndex > 0:
    stimuliDummy = pynn.Population(synapseDriverIndex, pynn.SpikeSourceArray, {'spike_times': []})
    prj = pynn.Projection(stimuliDummy, neurons, pynn.AllToAllConnector(weights=0), target='excitatory')
#allocate synapse driver and configure spike times
stimProp = {'spike_times': np.arange(durationInterval, runtime - durationInterval, durationInterval)}
stimuli = pynn.Population(1, pynn.SpikeSourceArray, stimProp)
prj = pynn.Projection(stimuli, neurons, pynn.AllToAllConnector(weights=weight * pynn.minExcWeight()), target='excitatory')

#modify properties of synapse driver
print('Range of calibration factors of drvifall for excitatory connections', prj.getDrvifallFactorsRange('exc'))
prj.setDrvifallFactors([0.8])
#prj.setDrvioutFactors([1.0])

##run network
pynn.run(runtime)
mem = pynn.membraneOutput
time = pynn.timeMembraneOutput
pynn.end()

##calculate spike-triggered average of membrane potential
timeNorm = time - time[0]
#number of data points per interval