Python pyNN.setup函数代码示例

 def test_invalid_max_delay(self):
     """
     tests that with invalid user input the max delay raises correctly
     :return:
     """
     with self.assertRaises(ConfigurationException):
         p.setup(1, max_delay=100000)

    def build_network(self, dynamics, cell_params):
        """
        Function to build the basic network - dynamics should be a PyNN
         synapse dynamics object
:param dynamics: 
:return:
        """
        # SpiNNaker setup
        model = sim.IF_curr_exp
        sim.setup(timestep=0.1, min_delay=1.0, max_delay=10.0)

        # Create excitatory and inhibitory populations of neurons
        ex_pop = sim.Population(NUM_EXCITATORY, model, cell_params)
        in_pop = sim.Population(NUM_EXCITATORY / 4, model, cell_params)

        # Record excitatory spikes
        ex_pop.record()

        # Make excitatory->inhibitory projections
        sim.Projection(ex_pop, in_pop, sim.FixedProbabilityConnector(
            0.02, weights=0.03), target='excitatory')
        sim.Projection(ex_pop, ex_pop, sim.FixedProbabilityConnector(
            0.02, weights=0.03), target='excitatory')

        # Make inhibitory->inhibitory projections
        sim.Projection(in_pop, in_pop, sim.FixedProbabilityConnector(
            0.02, weights=-0.3), target='inhibitory')

        # Make inhibitory->excitatory projections
        ie_projection = sim.Projection(
            in_pop, ex_pop, sim.FixedProbabilityConnector(0.02, weights=0),
            target='inhibitory', synapse_dynamics=dynamics)

        return ex_pop, ie_projection

 def test_invalid_min_delay_1_millisecond_timestep(self):
     """
      tests if with invalid user min, the min raises exefpetiosn
     :return:
     """
     with self.assertRaises(ConfigurationException):
         p.setup(1, min_delay=0.1)

 def test_valid_max_delay_0_1_millisecond_timestep(self):
     """
     tests if with valid user min, the min is set correctly
     :return:
     """
     p.setup(0.1, max_delay=0.4)
     max_delay = p.get_max_delay()
     self.assertEqual(max_delay, 0.4)

 def test_max_delay_no_user_input_1_millisecond_timestep(self):
     """
     Tests that with no user input, the max delay is correct
     :return:
     """
     p.setup(1)
     max_delay = p.get_max_delay()
     self.assertEqual(max_delay, 144)

 def test_get_min_delay_0_1_milisecond_timestep(self):
     """
     tests if with no user min, the min is set to 1 timestep in millisencsd
     :return:
     """
     p.setup(0.1)
     min_delay = p.get_min_delay()
     self.assertEqual(min_delay, 0.1)

    def test_script(self):
        """
        test that tests the printing of v from a pre determined recording
        :return:
        """
        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 128 * 128  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_cond_exp", 256)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0,
                           'e_rev_E': 0.,
                           'e_rev_I': -80.
                           }

        populations = list()
        projections = list()

        weight_to_spike = 0.035
        delay = 17

        spikes = read_spikefile('test.spikes', n_neurons)
        print spikes
        spike_array = {'spike_times': spikes}

        populations.append(p.Population(
            n_neurons, p.SpikeSourceArray, spike_array, label='inputSpikes_1'))
        populations.append(p.Population(
            n_neurons, p.IF_cond_exp, cell_params_lif, label='pop_1'))
        projections.append(p.Projection(
            populations[0], populations[1], p.OneToOneConnector(
                weights=weight_to_spike, delays=delay)))
        populations[1].record()

        p.run(1000)

        spikes = populations[1].getSpikes(compatible_output=True)

        if spikes is not None:
            print spikes
            pylab.figure()
            pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".")
            pylab.xlabel('Time/ms')
            pylab.ylabel('spikes')
            pylab.title('spikes')
            pylab.show()
        else:
            print "No spikes received"

        p.end()

    def test_recording_numerious_element_over_limit(self):
        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 2000  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        boxed_array = numpy.zeros(shape=(0, 2))
        spike_array = list()
        for neuron_id in range(0, n_neurons):
            spike_array.append(list())
            for random_time in range(0, 200000):
                random_time2 = random.randint(0, 50000)
                boxed_array = numpy.append(
                    boxed_array, [[neuron_id, random_time2]], axis=0)
                spike_array[neuron_id].append(random_time)
        spike_array_params = {'spike_times': spike_array}
        populations.append(p.Population(n_neurons, p.IF_curr_exp,
                                        cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(n_neurons, p.SpikeSourceArray,
                                        spike_array_params,
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[1], populations[0],
                           p.OneToOneConnector()))

        populations[1].record()

        p.run(50000)

        spike_array_spikes = populations[1].getSpikes()
        boxed_array = boxed_array[numpy.lexsort((boxed_array[:, 1],
                                                 boxed_array[:, 0]))]
        numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)
        p.end()

 def test_initial_setup(self):
     import spynnaker.pyNN as pynn
     self.assertEqual(pynn.setup(timestep=1, min_delay=1, max_delay=15.0),
                      None)
     self.assertEqual(conf.config.getint("Machine", "machineTimeStep"),
                      1 * 1000)
     self.assertEqual(pynn.get_min_delay(), 1)
     self.assertEqual(pynn.get_max_delay(), 15.0)

def main():
    # setup timestep of simulation and minimum and maximum synaptic delays
    Frontend.setup(timestep=simulationTimestep, min_delay=minSynapseDelay, max_delay=maxSynapseDelay, threads=4)

    # create a spike sources
    retinaLeft = createSpikeSource("RetL")
    retinaRight = createSpikeSource("RetR")
    
    # create network and attach the spike sources 
    network, (liveConnectionNetwork, liveConnectionRetinas) = createCooperativeNetwork(retinaLeft=retinaLeft, retinaRight=retinaRight)

    # non-blocking run for time in milliseconds
    print "Simulation started..."
    Frontend.run(simulationTime)                                          
    print "Simulation ended."
    
    # plot results  
    #
#     plotExperiment(retinaLeft, retinaRight, network)
    # finalise program and simulation
    Frontend.end()

    def test_recording_1_element(self):
        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 200  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        spike_array = {'spike_times': [[0]]}
        populations.append(p.Population(n_neurons, p.IF_curr_exp,
                                        cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(1, p.SpikeSourceArray, spike_array,
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[0], populations[0],
                           p.OneToOneConnector()))

        populations[1].record()

        p.run(5000)

        spike_array_spikes = populations[1].getSpikes()
        boxed_array = numpy.zeros(shape=(0, 2))
        boxed_array = numpy.append(boxed_array, [[0, 0]], axis=0)
        numpy.testing.assert_array_equal(spike_array_spikes, boxed_array)

        p.end()

def build_network(dynamics):
    # SpiNNaker setup
    sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)

    # Create excitatory and inhibitory populations of neurons
    ex_pop = sim.Population(NUM_EXCITATORY, model, cell_params)
    in_pop = sim.Population(NUM_EXCITATORY / 4, model, cell_params)
    
    # Record excitatory spikes
    ex_pop.record()
    
    # Make excitatory->inhibitory projections
    sim.Projection(ex_pop, in_pop, sim.FixedProbabilityConnector(0.02, weights=0.03), target='excitatory')
    sim.Projection(ex_pop, ex_pop, sim.FixedProbabilityConnector(0.02, weights=0.03), target='excitatory')

    # Make inhibitory->inhibitory projections
    sim.Projection(in_pop, in_pop, sim.FixedProbabilityConnector(0.02, weights=-0.3), target='inhibitory')
    
    # Make inhibitory->excitatory projections
    ie_projection = sim.Projection(in_pop, ex_pop, sim.FixedProbabilityConnector(0.02, weights=0), target='inhibitory', synapse_dynamics = dynamics)

    return ex_pop, ie_projection

    def simulate(self, spinnaker, input_spike_times):

        # Cell parameters
        cell_params = {
            'tau_m': 20.0,
            'v_rest': -60.0,
            'v_reset': -60.0,
            'v_thresh': -40.0,
            'tau_syn_E': 2.0,
            'tau_syn_I': 2.0,
            'tau_refrac': 2.0,
            'cm': 0.25,
            'i_offset': 0.0,
        }

        rng = p.NumpyRNG(seed=28375)
        v_init = p.RandomDistribution('uniform', [-60, -40], rng)

        p.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)

        pop = p.Population(1, p.IF_curr_exp, cell_params, label='population')
        pop.randomInit(v_init)
        pop.record()
        pop.record_v()

        noise = p.Population(1, p.SpikeSourceArray,
                             {"spike_times": input_spike_times})

        p.Projection(noise, pop, p.OneToOneConnector(weights=0.4, delays=1),
                     target='excitatory')

        # Simulate
        p.run(self.simtime)

        pop_voltages = pop.get_v(compatible_output=True)
        pop_spikes = pop.getSpikes(compatible_output=True)

        p.end()
        return pop_voltages, pop_spikes

    def test_recording_poisson_spikes_rate_0(self):

        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 256  # number of neurons in each population
        p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2)

        cell_params_lif = {'cm': 0.25,
                           'i_offset': 0.0,
                           'tau_m': 20.0,
                           'tau_refrac': 2.0,
                           'tau_syn_E': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0
                           }

        populations = list()
        projections = list()

        populations.append(p.Population(n_neurons, p.IF_curr_exp,
                                        cell_params_lif,
                           label='pop_1'))
        populations.append(p.Population(n_neurons, p.SpikeSourcePoisson,
                                        {'rate': 0},
                           label='inputSpikes_1'))

        projections.append(p.Projection(populations[1], populations[0],
                           p.OneToOneConnector()))

        populations[1].record()

        p.run(5000)

        spikes = populations[1].getSpikes()
        print spikes

        p.end()

import spynnaker.pyNN as FrontEnd
import spynnaker_external_devices_plugin.pyNN as ExternalDevices

import pylab

FrontEnd.setup(timestep=1.0)

nNeurons = 100
run_time = 10000

cell_params_lif = {
    "cm": 0.25,  # nF
    "i_offset": 0.0,
    "tau_m": 20.0,
    "tau_refrac": 2.0,
    "tau_syn_E": 5.0,
    "tau_syn_I": 5.0,
    "v_reset": -70.0,
    "v_rest": -65.0,
    "v_thresh": -50.0,
}

cell_params_spike_injector_new = {"virtual_key": 0x70800, "port": 12345}

populations = list()
projections = list()

weight_to_spike = 2.0

populations.append(FrontEnd.Population(nNeurons, FrontEnd.IF_curr_exp, cell_params_lif, label="pop_1"))
populations.append(