def maxRuntime(runtime): '''Maximum runtime: Limited by wrap around of counter (after approx. 6600s). Can be extended to infinitly long runtimes by considering wrap around. Subtract/Add offset to in/out spike times for each wrap around.''' rate = 1.0 weight = 1.0 poissonParam = {'start': 0, 'duration': runtime, 'rate': rate} pynn.setup() stim = pynn.Population(1, pynn.SpikeSourcePoisson, poissonParam) neuron = pynn.Population(1, pynn.IF_facets_hardware1) prj = pynn.Projection(stim, neuron, pynn.AllToAllConnector(weights=pynn.minInhWeight() * weight), target='inhibitory') neuron.record() pynn.run(runtime) spikes = neuron.getSpikes() lost, sent = pynn.getInputSpikes() print 'spikes in / out', sent, len(spikes) pynn.end()
def maxSpikesIn(runtime): '''Maximum number of spikes that can be sent: Should be limited by memory size on FPGA board (256MB => 256x1024x1024x8/32x3 approx. 200e6 spikes).''' rate = 10.0 weight = 1.0 poissonParam = {'start': 0, 'duration': runtime, 'rate': rate} pynn.setup() stim = pynn.Population(256, pynn.SpikeSourcePoisson, poissonParam) neuron = pynn.Population(192, pynn.IF_facets_hardware1) prj = pynn.Projection(stim, neuron, pynn.AllToAllConnector(weights=pynn.minInhWeight() * weight), target='inhibitory') neuron.record() pynn.run(runtime) spikes = neuron.getSpikes() lost, sent = pynn.getInputSpikes() print 'spikes in / out', sent, len(spikes) pynn.end()
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.'
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()
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 popCollector = {'exc': [], 'inh': []} for synType in ['exc', 'inh']: for popIndex in range(noPops): pop = pynn.Population(popSize[synType], pynn.IF_facets_hardware1,
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 = {} # stimuli
w = 8 k = 9 pynn.setup() # set resting potential over spiking threshold runtime = 1000.0 #ms popSize = 192 # the following three parameters can be tuned for "optimal decorrelation" #w = 12.0 #k = 18 weight = w * pynn.minInhWeight() #default 4.0 numInhPerNeuron = k #default 25 neuronParams = { 'v_reset' : -80.0, # mV # default 'e_rev_I' : -80.0, # mV # default 'v_rest' : -35.0, # mV # for const-current emulation set to > v_thresh #-30.0 default 'v_thresh' : -55.0, # mV # default 'g_leak' : 20.0 # nS -> tau_mem = 0.2nF / 20nS = 10ms } neurons = pynn.Population(popSize, pynn.IF_facets_hardware1, neuronParams) # the inhibitory projection of the complete population to itself, with identical number # of presynaptic neurons. Enable after measuring the regular-firing case. pynn.Projection(neurons, neurons, pynn.FixedNumberPreConnector(numInhPerNeuron, weights=weight), target='inhibitory')
{'spike_times': []}) prj = pynn.Projection(stimuliDummy, neurons, pynn.AllToAllConnector(weights=0), target='inhibitory') #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.minInhWeight()), target='inhibitory') # modify properties of synapse driver # drvifall controls the slope of the falling edge of the PSP shape. # smaller values increase the length, thus the total charge transmitted by the synapse, thus the PSP height. print 'Range of calibration factors of drvifall for excitatory connections', prj.getDrvifallFactorsRange( 'inh') prj.setDrvifallFactors([drvifallFactors]) prj.setDrvioutFactors([drvioutFactors]) ##run network pynn.run(runtime) mem = pynn.membraneOutput time = pynn.timeMembraneOutput pynn.end()
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() popCollector[synType].append(pop) # connect stimulus pynn.Projection(stimExc, popCollector['exc'][0], pynn.FixedProbabilityConnector(p_connect=probExcExc, weights=weightStimExcExc), target='excitatory')
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() popCollector[synType].append(pop) # connect stimulus
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
def test_zero_projection(self): #====================================================================== # set up the following network and record the membrane potential of neuron0 # for three different combination of weights: # run 0: w0 = 0 | w1 = 0 # run 1: w0 = w | w1 = w # run 2: w0 = w | w1 = 0 #====================================================================== # inh weight w0 # --> neuron 0 # / # stim # \ # --> neuron 1 # inh weight w1 #====================================================================== # TODO: write test with call of connect() instead of projection as well import numpy import pyNN.hardware.spikey as pynn if self.with_figures: import pylab duration = 1000.0 # ms w = 10.0 # in units of pynn.minInhWeight stim_rate = 40.0 # Hz neuron_params = { 'g_leak': 1.0, # nS 'tau_syn_E': 5.0, # ms 'tau_syn_I': 5.0, # ms 'v_reset': -80.0, # mV 'e_rev_I': -80.0, # mV, 'v_rest': -65.0, # mV 'v_thresh': 0.0 # mV // no spiking } # call setup with enabled oscilloscope pynn.setup(useUsbAdc=True) # create the populations nrn0 = pynn.Population(1, pynn.IF_facets_hardware1) nrn1 = pynn.Population(1, pynn.IF_facets_hardware1) stim_params = {'start': 0., 'duration': duration, 'rate': stim_rate} stim = pynn.Population(1, pynn.SpikeSourcePoisson, stim_params) # record the membrane potential of neuron0 pynn.record_v(nrn0[0], '') # create the connectors w_con = pynn.AllToAllConnector(weights=w * pynn.minInhWeight()) zero_con = pynn.AllToAllConnector(weights=0.0 * pynn.minInhWeight()) # run the first time nrn0_prj = pynn.Projection(stim, nrn0, zero_con, target='inhibitory') nrn1_prj = pynn.Projection(stim, nrn1, zero_con, target='inhibitory') pynn.run(duration) u_run0 = numpy.mean(pynn.membraneOutput) du_run0 = numpy.std(pynn.membraneOutput) if self.with_figures: pylab.figure() pylab.plot(pynn.timeMembraneOutput, pynn.membraneOutput) pylab.show() # second time nrn0_prj = pynn.Projection(stim, nrn0, w_con, target='inhibitory') nrn1_prj = pynn.Projection(stim, nrn1, w_con, target='inhibitory') pynn.run(duration) u_run1 = numpy.mean(pynn.membraneOutput) du_run1 = numpy.std(pynn.membraneOutput) if self.with_figures: pylab.figure() pylab.plot(pynn.timeMembraneOutput, pynn.membraneOutput) pylab.show() # third time nrn0_prj = pynn.Projection(stim, nrn0, w_con, target='inhibitory') nrn1_prj = pynn.Projection(stim, nrn1, zero_con, target='inhibitory') pynn.run(duration) u_run2 = numpy.mean(pynn.membraneOutput) du_run2 = numpy.std(pynn.membraneOutput) if self.with_figures: pylab.figure() pylab.plot(pynn.timeMembraneOutput, pynn.membraneOutput) pylab.show() # plot and evaluate if self.with_figures: x_val = numpy.arange(1, 4, 1) y_val = [u_run0, u_run1, u_run2] y_err = [du_run0, du_run1, du_run2] pylab.figure() pylab.xlim([0, 4]) pylab.xlabel("Run") pylab.ylabel("Mean membrane voltage [mV]") pylab.errorbar(x_val, y_val, yerr=y_err, fmt='o') pylab.show() assert (((u_run0 - u_run1) / du_run0) > 0.2) assert (((u_run0 - u_run2) / du_run0) > 0.2) assert (abs((u_run2 - u_run1) / du_run0) < 0.2)