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
Пример #2
0
 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)
Пример #3
0
 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)
Пример #4
0
 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)
Пример #5
0
 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)
Пример #6
0
 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_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()
Пример #8
0
    def test_recording_numerious_element(self):
        p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
        n_neurons = 20  # 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, 20):
                random_time2 = random.randint(0, 5000)
                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(5000)

        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 __init__(self,
              simulation_time=1000,
              simulation_time_step=0.2,
              n_chips_required=48 * 6,
              threads_count=4):
     self.simulation_time = simulation_time
     self.time_step = simulation_time_step
     # setup timestep of simulation and minimum and maximum synaptic delays
     ps.setup(timestep=simulation_time_step,
              min_delay=simulation_time_step,
              max_delay=10 * simulation_time_step,
              n_chips_required=n_chips_required,
              threads=threads_count)
Пример #10
0
    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()
Пример #11
0
 def test_initial_setup(self):
     import spynnaker.pyNN as pynn
     self.assertEqual(pynn.setup(timestep=1, min_delay=1, max_delay=15.0),
                      0)
     self.assertEqual(conf.config.getint("Machine", "machineTimeStep"),
                      1 * 1000)
     self.assertEqual(pynn.get_min_delay(), 1)
     self.assertEqual(pynn.get_max_delay(), 15.0)
Пример #12
0
    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[1], populations[0],
                         p.AllToAllConnector()))

        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()
Пример #13
0
 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)
Пример #14
0
    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=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
Пример #15
0
    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()
Пример #16
0
    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
Пример #17
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()
Пример #18
0
    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 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 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 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()
Пример #22
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 = createCooperativeNetwork(retinaLeft=retinaLeft, retinaRight=retinaRight)
    
    # run simulation for time in milliseconds
    print "Simulation started..."
    Frontend.run(simulationTime)   
    
#     print network[0][1].label
#     spikeList = network[0][1].getSpikes()
#     print spikeList
    # finalise program and simulation
    Frontend.end()
    print "Simulation ended."
    
    from NetworkVisualiser import logFile
    logFile.close()
Пример #23
0
 def start_sim(self,sim_time):
     #simulation setup
     self.simtime = sim_time
     sim.setup(timestep=self.setup_cond["timestep"], min_delay=self.setup_cond["min_delay"], max_delay=self.setup_cond["max_delay"])
     #initialise the neuron population
     spikeArrayOn = {'spike_times': self.in_spike}
     pre_pop = sim.Population(self.pre_pop_size, sim.SpikeSourceArray,
                     spikeArrayOn, label='inputSpikes_On')
     post_pop= sim.Population(self.post_pop_size,sim.IF_curr_exp,
                      self.cell_params_lif, label='post_1')
     stdp_model = sim.STDPMechanism(timing_dependence=sim.SpikePairRule(tau_plus= self.stdp_param["tau_plus"],
                                                 tau_minus= self.stdp_param["tau_minus"],
                                                 nearest=True),
                                     weight_dependence=sim.MultiplicativeWeightDependence(w_min= self.stdp_param["w_min"],
                                                            w_max= self.stdp_param["w_max"],
                                                            A_plus= self.stdp_param["A_plus"],
                                                            A_minus= self.stdp_param["A_minus"]))
     #initialise connectiviity of neurons
     #exitatory connection between pre-synaptic and post-synaptic neuron population                                                              
     if(self.inhibitory_spike_mode):
         connectionsOn  = sim.Projection(pre_pop, post_pop, sim.AllToAllConnector(weights = self.I_syn_weight,delays=1,
                                         allow_self_connections=False),
                                         target='inhibitory')
     else: 
         if(self.STDP_mode):
             if(self.allsameweight):
                 connectionsOn = sim.Projection(pre_pop, post_pop, 
                                            sim.AllToAllConnector(weights = self.E_syn_weight,delays=1),
                                             synapse_dynamics=sim.SynapseDynamics(slow=stdp_model),target='excitatory')
             else:
                 connectionsOn = sim.Projection(pre_pop, post_pop, 
                                            sim.FromListConnector(self.conn_list),
                                             synapse_dynamics=sim.SynapseDynamics(slow=stdp_model),target='excitatory')
         else:
             if(self.allsameweight):
                 connectionsOn  = sim.Projection(pre_pop, post_pop, sim.AllToAllConnector(weights = self.E_syn_weight,delays=1),
                                                                      target='excitatory')
             else:
                 connectionsOn  = sim.Projection(pre_pop, post_pop, sim.FromListConnector(self.conn_list),
                                                                      target='excitatory')
             #sim.Projection.setWeights(self.E_syn_weight)
     
     #inhibitory between the neurons post-synaptic neuron population
     connection_I  = sim.Projection(post_pop, post_pop, sim.AllToAllConnector(weights = self.I_syn_weight,delays=1,
                                                          allow_self_connections=False),
                                                          target='inhibitory')
     pre_pop.record()                                                     
     post_pop.record()
     post_pop.record_v()
     sim.run(self.simtime)
     self.pre_spikes = pre_pop.getSpikes(compatible_output=True)
     self.post_spikes = post_pop.getSpikes(compatible_output=True)
     self.post_spikes_v = post_pop.get_v(compatible_output=True)
     self.trained_weights = connectionsOn.getWeights(format='array')
     sim.end()
     #print self.conn_list
     #print self.trained_weights
     '''scipy.io.savemat('trained_weight.mat',{'initial_weight':self.init_weights,
                                            'trained_weight':self.trained_weights
                                    })'''
     scipy.io.savemat('trained_weight0.mat',{'trained_weight':self.trained_weights
                                    })
    def test_get_voltage(self):
        """
        test that tests the getting of v from a pre determined recording
        :return:
        """
        p.setup(timestep=1, min_delay=1.0, max_delay=14.40)
        n_neurons = 200  # number of neurons in each population
        runtime = 500
        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()

        weight_to_spike = 2.0
        delay = 1.7

        loop_connections = list()
        for i in range(0, n_neurons):
            single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
                                 delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        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.FromListConnector(loop_connections)))
        projections.append(
            p.Projection(populations[1], populations[0],
                         p.FromListConnector(injection_connection)))

        populations[0].record_v()
        populations[0].record_gsyn()
        populations[0].record()

        p.run(runtime)

        v = populations[0].get_v(compatible_output=True)

        current_file_path = os.path.dirname(os.path.abspath(__file__))
        current_file_path = os.path.join(current_file_path, "v.data")
        pre_recorded_data = p.utility_calls.read_in_data_from_file(
            current_file_path, 0, n_neurons, 0, runtime)

        p.end()

        for spike_element, read_element in zip(v, pre_recorded_data):
            self.assertEqual(round(spike_element[0], 1),
                             round(read_element[0], 1))
            self.assertEqual(round(spike_element[1], 1),
                             round(read_element[1], 1))
            self.assertEqual(round(spike_element[2], 1),
                             round(read_element[2], 1))
Пример #25
0
def estimate_kb(cell_params_lif):
    cell_para = copy.deepcopy(cell_params_lif)
    random.seed(0)
    p.setup(timestep=1.0, min_delay=1.0, max_delay=16.0)
    run_s = 10.
    runtime = 1000. * run_s
    max_rate = 1000.
    ee_connector = p.OneToOneConnector(weights=1.0, delays=2.0)

    pop_list = []
    pop_output = []
    pop_source = []
    x = np.arange(0., 1.01, 0.1)
    count = 0
    trail = 10

    for i in x:
        for j in range(trail):  #trails for average
            pop_output.append(p.Population(1, p.IF_curr_exp, cell_para))
            poisson_spikes = poisson_generator(i * max_rate, 0, runtime)
            pop_source.append(
                p.Population(1, p.SpikeSourceArray,
                             {'spike_times': poisson_spikes}))
            p.Projection(pop_source[count],
                         pop_output[count],
                         ee_connector,
                         target='excitatory')
            pop_output[count].record()
            count += 1

    count = 0
    for i in x:
        cell_para['i_offset'] = i
        pop_list.append(p.Population(1, p.IF_curr_exp, cell_para))
        pop_list[count].record()
        count += 1
    pop_list[count - 1].record_v()

    p.run(runtime)

    rate_I = np.zeros(count)
    rate_P = np.zeros(count)
    rate_P_max = np.zeros(count)
    rate_P_min = np.ones(count) * 1000.
    for i in range(count):
        spikes = pop_list[i].getSpikes(compatible_output=True)
        rate_I[i] = len(spikes) / run_s
        for j in range(trail):
            spikes = pop_output[i * trail +
                                j].getSpikes(compatible_output=True)
            spike_num = len(spikes) / run_s
            rate_P[i] += spike_num
            if spike_num > rate_P_max[i]:
                rate_P_max[i] = spike_num
            if spike_num < rate_P_min[i]:
                rate_P_min[i] = spike_num
        rate_P[i] /= trail
    '''
    #plot_spikes(spikes, 'Current = 10. mA')
    plt.plot(x, rate_I, label='current',)
    plt.plot(x, rate_P, label='Poisson input')
    plt.fill_between(x, rate_P_min, rate_P_max, facecolor = 'green', alpha=0.3)
    '''
    x0 = np.where(rate_P > 1.)[0][0]
    x1 = 4
    k = (rate_P[x1] - rate_P[x0]) / (x[x1] - x[x0])
    '''
    plt.plot(x, k*(x-x[x0])+rate_P[x0], label='linear')
    plt.legend(loc='upper left', shadow=True)
    plt.grid('on')
    plt.show()
    '''
    p.end()
    return k, x[x0], rate_P[x0]
Пример #26
0
import unittest
from spynnaker.pyNN.models.neuron.builds.if_curr_dual_exp import IFCurrDualExp
import spynnaker.pyNN as pyNN

if not pyNN:
    pyNN.setup(1, 1, 15)


class TestIFCurrDualExpModel(unittest.TestCase):
    def test_new_if_curr_dual_exp_model(self):
        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_E2': 5.0,
                           'tau_syn_I': 5.0,
                           'v_reset': -70.0,
                           'v_rest': -65.0,
                           'v_thresh': -50.0}
        n_neurons = 10
        if_curr_dual_exp = IFCurrDualExp(
            n_neurons, 1000, 1.0, **cell_params_lif)
        self.assertEqual(if_curr_dual_exp.model_name, "IF_curr_dual_exp")
        self.assertEqual(len(if_curr_dual_exp.get_parameters()), 10)
        self.assertEqual(if_curr_dual_exp._v_thresh,
                         cell_params_lif['v_thresh'])
        self.assertEqual(if_curr_dual_exp._v_reset, cell_params_lif['v_reset'])
        self.assertEqual(if_curr_dual_exp._v_rest, cell_params_lif['v_rest'])
        self.assertEqual(if_curr_dual_exp._tau_m, cell_params_lif['tau_m'])
        self.assertEqual(if_curr_dual_exp._tau_refrac,
Пример #27
0
    def test_from_file_connector(self):
        # create files as needed for tests
        #  From_File_Generator.create_files()

        pop_size = 32

        min_weight = 0.1
        max_weight = 5.0
        rng_weights = p.NumpyRNG(seed=369121518)
        weight_dependence_n = \
            p.RandomDistribution(
                distribution='uniform',
                parameters=[1.0 + min_weight, 1.0 + max_weight],
                rng=rng_weights)
        weight_dependence_e = \
            p.RandomDistribution(distribution='uniform',
                                 parameters=[min_weight, max_weight],
                                 rng=rng_weights)

        file_num_i_p2 = 2
        file_num_p1_p2 = 2
        runtime = 10000.0
        stim_start = 0.0
        stim_rate = 10
        pops_to_observe = ['mapped_pop_1', 'mapped_pop_2']

        # Simulation Setup
        p.setup(timestep=1.0, min_delay=1.0, max_delay=11.0)

        # Neural Parameters
        tau_m = 24.0    # (ms)
        cm = 1
        v_rest = -65.0     # (mV)
        v_thresh = -45.0     # (mV)
        v_reset = -65.0     # (mV)
        t_refrac = 3.0       # (ms) (clamped at v_reset)
        tau_syn_exc = 3.0
        tau_syn_inh = tau_syn_exc * 3

        # cell_params will be passed to the constructor of the Population Object

        cell_params = {'tau_m': tau_m,
                       'cm': cm,
                       'v_init': v_reset,
                       'v_rest': v_rest,
                       'v_reset': v_reset,
                       'v_thresh': v_thresh,
                       'tau_syn_E': tau_syn_exc,
                       'tau_syn_I': tau_syn_inh,
                       'tau_refrac': t_refrac,
                       'i_offset': 0}

        observed_pop_list = []
        inputs = p.Population(pop_size, p.SpikeSourcePoisson,
                              {'duration': runtime, 'start': stim_start,
                               'rate': stim_rate},
                              label="inputs")

        if 'inputs' in pops_to_observe:
            inputs.record()
            observed_pop_list.append(inputs)

        mapped_pop_1 = p.Population(pop_size, p.IF_curr_exp, cell_params,
                                    label="mapped_pop_1")
        if 'mapped_pop_1' in pops_to_observe:
            mapped_pop_1.record()
            observed_pop_list.append(mapped_pop_1)

        pop_inhibit = p.Population(pop_size, p.IF_curr_exp, cell_params,
                                   label="pop_inhibit")

        if 'pop_inhibit' in pops_to_observe:
            pop_inhibit.record()
            observed_pop_list.append(pop_inhibit)

        mapped_pop_2 = p.Population(pop_size, p.IF_curr_exp, cell_params,
                                    label="mapped_pop_2")
        if 'mapped_pop_2' in pops_to_observe:
            mapped_pop_2.record()
            observed_pop_list.append(mapped_pop_2)

        p.Projection(inputs, mapped_pop_1,
                     p.OneToOneConnector(weights=weight_dependence_n,
                                         delays=1.0),
                     target='excitatory')

        p.Projection(mapped_pop_1, pop_inhibit,
                     p.OneToOneConnector(
                         weights=weight_dependence_e, delays=1.0),
                     target='excitatory')

        p.Projection(pop_inhibit, mapped_pop_2,
                     p.FromFileConnector(conn_file="List_I_p2_form_%d.txt"
                                         % file_num_i_p2),
                     target='inhibitory')

        p.Projection(mapped_pop_1, mapped_pop_2,
                     p.FromFileConnector(conn_file="List_I_p2_form_%d.txt"
                                                   % file_num_p1_p2),
                     target='excitatory')

        #  From_File_Generator.remove_files()

        p.run(runtime)

        for pop in observed_pop_list:
            data = numpy.asarray(pop.getSpikes())
            current_file_path = os.path.dirname(os.path.abspath(__file__))
            current_pop_file_path = os.path.join(current_file_path,
                                                 "{}.data".format(pop.label))
            #  pop.printSpikes(current_pop_file_path)
            pre_recorded_data = p.utility_calls.read_spikes_from_file(
                current_pop_file_path, 0, pop_size, 0, runtime)

            for spike_element, read_element in zip(data, pre_recorded_data):
                    self.assertEqual(round(spike_element[0], 1),
                                     round(read_element[0], 1))
                    self.assertEqual(round(spike_element[1], 1),
                                     round(read_element[1], 1))
threads = 1
rngseed = 98766987
parallel_safe = True

ts = 0.1  # simulation timestep in ms
simulation_time = 2000  # ms

n_input_neurons = 4
n_readout_neurons = 2  #
n_reservoir_neurons = 59
exc_rate = 0.8  # 80% of reservoir neurons are excitatory

n_reservoir_exc = int(np.ceil(n_reservoir_neurons * exc_rate))
n_reservoir_inh = n_reservoir_neurons - n_reservoir_exc

pynn.setup(timestep=ts, min_delay=ts, max_delay=2.0 * ts)

pynn.set_number_of_neurons_per_core('IF_curr_exp',
                                    100)  # this will set 100 neurons per core

#======================================================
#===
#===        Define Neural Populations
#===
#======================================================

############# Reservoir #################

# set up the reservoir population
celltype = pynn.IZK_cond_exp()
cell_params = {}
    def test_get_spikes(self):
        """
        test for get spikes
        :return:
        """
        p.setup(timestep=1, min_delay=1.0, max_delay=14.40)
        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()

        weight_to_spike = 2.0
        delay = 1.7

        loop_connections = list()
        for i in range(0, n_neurons):
            single_connection = (i, ((i + 1) % n_neurons), weight_to_spike, delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        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.FromListConnector(loop_connections)))
        projections.append(p.Projection(populations[1], populations[0],
                           p.FromListConnector(injection_connection)))

        populations[0].record_v()
        populations[0].record_gsyn()
        populations[0].record()

        p.run(500)

        spikes = populations[0].getSpikes(compatible_output=True)
        pre_recorded_spikes = [
            [0, 3.5], [1, 6.7], [2, 9.9], [3, 13.1], [4, 16.3],
            [5, 19.5], [6, 22.7], [7, 25.9], [8, 29.1],
            [9, 32.3], [10, 35.5], [11, 38.7], [12, 41.9],
            [13, 45.1], [14, 48.3], [15, 51.5], [16, 54.7],
            [17, 57.9], [18, 61.1], [19, 64.3], [20, 67.5],
            [21, 70.7], [22, 73.9], [23, 77.1], [24, 80.3],
            [25, 83.5], [26, 86.7], [27, 89.9], [28, 93.1],
            [29, 96.3], [30, 99.5], [31, 102.7], [32, 105.9],
            [33, 109.1], [34, 112.3], [35, 115.5], [36, 118.7],
            [37, 121.9], [38, 125.1], [39, 128.3], [40, 131.5],
            [41, 134.7], [42, 137.9], [43, 141.1], [44, 144.3],
            [45, 147.5], [46, 150.7], [47, 153.9], [48, 157.1],
            [49, 160.3], [50, 163.5], [51, 166.7], [52, 169.9],
            [53, 173.1], [54, 176.3], [55, 179.5], [56, 182.7],
            [57, 185.9], [58, 189.1], [59, 192.3], [60, 195.5]]

        p.end()

        for spike_element, read_element in zip(spikes, pre_recorded_spikes):
            self.assertEqual(round(spike_element[0], 1),
                             round(read_element[0], 1))
            self.assertEqual(round(spike_element[1], 1),
                             round(read_element[1], 1))
    def test_something(self):
        #!/usr/bin/python
        import pylab

        import spynnaker.pyNN as p


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


        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
                             }

        populations = list()
        projections = list()

        weight_to_spike = 2.0
        delay = 17

        loop_connections = list()
        for i in range(0, nNeurons):
            single_connection = (i, ((i + 1) % nNeurons),
                                 weight_to_spike, delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        spike_array = {'spike_times': [[0]]}
        populations.append(p.Population(nNeurons, 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.FromListConnector(loop_connections)))
        projections.append(
            p.Projection(populations[1], populations[0],
                         p.FromListConnector(injection_connection)))

        populations[0].record_v()
        #populations[0].record_gsyn()
        #populations[0].record(visualiser_mode=p.VISUALISER_MODES.RASTER)

        p.run(5000)

        v = None
        gsyn = None
        spikes = None

        v = populations[0].get_v(compatible_output=True)

        #assert(v == )


        #gsyn = populations[0].get_gsyn(compatible_output=True)
        #spikes = populations[0].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"

        # Make some graphs

        if v is not None:
            ticks = len(v) / nNeurons
            pylab.figure()
            pylab.xlabel('Time/ms')
            pylab.ylabel('v')
            pylab.title('v')
            for pos in range(0, nNeurons, 20):
                v_for_neuron = v[pos * ticks : (pos + 1) * ticks]
                pylab.plot([i[1] for i in v_for_neuron],
                        [i[2] for i in v_for_neuron])
            pylab.show()

        if gsyn is not None:
            ticks = len(gsyn) / nNeurons
            pylab.figure()
            pylab.xlabel('Time/ms')
            pylab.ylabel('gsyn')
            pylab.title('gsyn')
            for pos in range(0, nNeurons, 20):
                gsyn_for_neuron = gsyn[pos * ticks : (pos + 1) * ticks]
                pylab.plot([i[1] for i in gsyn_for_neuron],
                        [i[2] for i in gsyn_for_neuron])
            pylab.show()

        p.end(stop_on_board=True)
Пример #31
0
import spinnman.messages.eieio.eieio_type as eieio_type

import numpy

import pylab

# host_IP = '192.169.110.2' # when Spinn-3 is connected
# host_IP = '192.168.1.2' # when Spinn-5 is connected

# Base code from:
# http://spinnakermanchester.github.io/2015.005.Arbitrary/workshop_material/

simulation_timestep = 0.2

sim.setup(timestep=simulation_timestep,
          min_delay=simulation_timestep,
          max_delay=simulation_timestep * 144)

# Generate the connections matrix inside the Liquid (Liquid->Liquid) - according to Maass2002
#
print "Liquid->Liquid connections..."

Number_of_neurons_lsm = numpy.load("Number_of_neurons_lsm.npy")

#
# These are the cell (neuron) parameters according to Maass 2002
#
cell_params_lsm = {
    'cm': 30,  # Capacitance of the membrane 
    # =>>>> MAASS PAPER DOESN'T MENTION THIS PARAMETER DIRECTLY
    #       but the paper mentions a INPUT RESISTANCE OF 1MEGA Ohms and tau_m=RC=30ms, so cm=30nF
"""
Synfirechain-like example
"""
import spynnaker.pyNN as p
import pylab

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

runtime = 1000
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()

weight_to_spike = 2.0
delay = 17

loopConnections = list()
for i in range(0, nNeurons):
    def __init__(self):

        # initial call to set up the front end (pynn requirement)
        Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)

        use_c_visualiser = True
        use_spike_injector = True

        # neurons per population and the length of runtime in ms for the
        # simulation, as well as the expected weight each spike will contain
        self.n_neurons = 100

        # set up gui
        p = None
        if use_spike_injector:
            from multiprocessing import Process
            from multiprocessing import Event
            ready = Event()
            p = Process(target=GUI, args=[self.n_neurons, ready])
            p.start()
            ready.wait()

        # different runtimes for demostration purposes
        run_time = None
        if not use_c_visualiser and not use_spike_injector:
            run_time = 1000
        elif use_c_visualiser and not use_spike_injector:
            run_time = 10000
        elif use_c_visualiser and use_spike_injector:
            run_time = 100000
        elif not use_c_visualiser and use_spike_injector:
            run_time = 10000

        weight_to_spike = 2.0

        # neural parameters of the IF_curr model used to respond to injected
        # spikes.
        # (cell params for a synfire chain)
        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
                           }

        ##################################
        # Parameters for the injector population.  This is the minimal set of
        # parameters required, which is for a set of spikes where the key is
        # not important.  Note that a virtual key *will* be assigned to the
        # population, and that spikes sent which do not match this virtual key
        # will be dropped; however, if spikes are sent using 16-bit keys, they
        # will automatically be made to match the virtual key.  The virtual
        # key assigned can be obtained from the database.
        ##################################
        cell_params_spike_injector = {

            # The port on which the spiNNaker machine should listen for
            # packets. Packets to be injected should be sent to this port on
            # the spiNNaker machine
            'port': 12345
        }

        ##################################
        # Parameters for the injector population.  Note that each injector
        # needs to be given a different port.  The virtual key is assigned
        # here, rather than being allocated later.  As with the above, spikes
        # injected need to match this key, and this will be done automatically
        # with 16-bit keys.
        ##################################
        cell_params_spike_injector_with_key = {

            # The port on which the spiNNaker machine should listen for
            # packets. Packets to be injected should be sent to this port on
            # the spiNNaker machine
            'port': 12346,

            # This is the base key to be used for the injection, which is used
            # to allow the keys to be routed around the spiNNaker machine.
            # This assignment means that 32-bit keys must have the high-order
            # 16-bit set to 0x7; This will automatically be prepended to
            # 16-bit keys.
            'virtual_key': 0x70000
        }

        # create synfire populations (if cur exp)
        pop_forward = Frontend.Population(
            self.n_neurons, Frontend.IF_curr_exp,
            cell_params_lif, label='pop_forward')
        pop_backward = Frontend.Population(
            self.n_neurons, Frontend.IF_curr_exp,
            cell_params_lif, label='pop_backward')

        # Create injection populations
        injector_forward = None
        injector_backward = None
        if use_spike_injector:
            injector_forward = Frontend.Population(
                self.n_neurons, ExternalDevices.SpikeInjector,
                cell_params_spike_injector_with_key,
                label='spike_injector_forward')
            injector_backward = Frontend.Population(
                self.n_neurons, ExternalDevices.SpikeInjector,
                cell_params_spike_injector, label='spike_injector_backward')
        else:
            spike_times = []
            for _ in range(0, self.n_neurons):
                spike_times.append([])
            spike_times[0] = [0]
            spike_times[20] = [(run_time / 100) * 20]
            spike_times[40] = [(run_time / 100) * 40]
            spike_times[60] = [(run_time / 100) * 60]
            spike_times[80] = [(run_time / 100) * 80]
            cell_params_forward = {'spike_times': spike_times}
            spike_times_backwards = []
            for _ in range(0, self.n_neurons):
                spike_times_backwards.append([])
            spike_times_backwards[0] = [(run_time / 100) * 80]
            spike_times_backwards[20] = [(run_time / 100) * 60]
            spike_times_backwards[40] = [(run_time / 100) * 40]
            spike_times_backwards[60] = [(run_time / 100) * 20]
            spike_times_backwards[80] = [0]
            cell_params_backward = {'spike_times': spike_times_backwards}
            injector_forward = Frontend.Population(
                self.n_neurons, Frontend.SpikeSourceArray,
                cell_params_forward,
                label='spike_injector_forward')
            injector_backward = Frontend.Population(
                self.n_neurons, Frontend.SpikeSourceArray,
                cell_params_backward, label='spike_injector_backward')

        # Create a connection from the injector into the populations
        Frontend.Projection(
            injector_forward, pop_forward,
            Frontend.OneToOneConnector(weights=weight_to_spike))
        Frontend.Projection(
            injector_backward, pop_backward,
            Frontend.OneToOneConnector(weights=weight_to_spike))

        # Synfire chain connections where each neuron is connected to its next
        # neuron
        # NOTE: there is no recurrent connection so that each chain stops once
        # it reaches the end
        loop_forward = list()
        loop_backward = list()
        for i in range(0, self.n_neurons - 1):
            loop_forward.append((i, (i + 1) %
                                 self.n_neurons, weight_to_spike, 3))
            loop_backward.append(((i + 1) %
                                  self.n_neurons, i, weight_to_spike, 3))
        Frontend.Projection(pop_forward, pop_forward,
                            Frontend.FromListConnector(loop_forward))
        Frontend.Projection(pop_backward, pop_backward,
                            Frontend.FromListConnector(loop_backward))

        # record spikes from the synfire chains so that we can read off valid
        # results in a safe way afterwards, and verify the behavior
        pop_forward.record()
        pop_backward.record()

        # Activate the sending of live spikes
        ExternalDevices.activate_live_output_for(
            pop_forward, database_notify_host="localhost",
            database_notify_port_num=19996)
        ExternalDevices.activate_live_output_for(
            pop_backward, database_notify_host="localhost",
            database_notify_port_num=19996)

        if not use_c_visualiser:
            # if not using the c visualiser, then a new spynnaker live spikes
            # connection is created to define that there are python code which
            # receives the outputted spikes.
            live_spikes_connection_receive = SpynnakerLiveSpikesConnection(
                receive_labels=["pop_forward", "pop_backward"],
                local_port=19999, send_labels=None)

            # Set up callbacks to occur when spikes are received
            live_spikes_connection_receive.add_receive_callback(
                "pop_forward", receive_spikes)
            live_spikes_connection_receive.add_receive_callback(
                "pop_backward", receive_spikes)
        # Run the simulation on spiNNaker
        Frontend.run(run_time)

        # Retrieve spikes from the synfire chain population
        spikes_forward = pop_forward.getSpikes()
        spikes_backward = pop_backward.getSpikes()

        # If there are spikes, plot using matplotlib
        if len(spikes_forward) != 0 or len(spikes_backward) != 0:
            pylab.figure()
            if len(spikes_forward) != 0:
                pylab.plot([i[1] for i in spikes_forward],
                           [i[0] for i in spikes_forward], "b.")
            if len(spikes_backward) != 0:
                pylab.plot([i[1] for i in spikes_backward],
                           [i[0] for i in spikes_backward], "r.")
            pylab.ylabel('neuron id')
            pylab.xlabel('Time/ms')
            pylab.title('spikes')
            pylab.show()
        else:
            print "No spikes received"

        # Clear data structures on spiNNaker to leave the machine in a clean
        # state for future executions
        Frontend.end()
        if use_spike_injector:
            p.join()
    def test_print_spikes(self):
        machine_time_step = 0.1

        p.setup(timestep=machine_time_step, min_delay=1.0, max_delay=14.40)
        n_neurons = 20  # 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()

        weight_to_spike = 2.0
        delay = 1.7

        loop_connections = list()
        for i in range(0, n_neurons):
            single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
                                 delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        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.FromListConnector(loop_connections)))
        projections.append(p.Projection(populations[1], populations[0],
                           p.FromListConnector(injection_connection)))

        populations[0].record_v()
        populations[0].record_gsyn()
        populations[0].record()

        p.run(500)

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

        current_file_path = os.path.dirname(os.path.abspath(__file__))
        current_file_path = os.path.join(current_file_path, "spikes.data")
        spike_file = populations[0].printSpikes(current_file_path)

        spike_reader = p.utility_calls.read_spikes_from_file(
            current_file_path, min_atom=0, max_atom=n_neurons,
            min_time=0, max_time=500)
        read_in_spikes = spike_reader.spike_times
        p.end()
        os.remove(current_file_path)

        for spike_element, read_element in zip(spikes, read_in_spikes):
            self.assertEqual(round(spike_element[0], 1),
                             round(read_element[0], 1))
            self.assertEqual(round(spike_element[1], 1),
                             round(read_element[1], 1))
Пример #35
0
import numpy
import pylab

from pprint import pprint


delay        = 1.0
sim_length   = 100
num_neurons  = 100
spike_weight = 2.0
delay        = 17

p.setup( 
        timestep=1.0, 
        min_delay=1.0,
        max_delay=100.0,
        debug=True
        )

cell_params = {'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
                   }

cell_params_spike_injector_with_prefix = {
Пример #36
0
# imports of both spynnaker and external device plugin.
import spynnaker.pyNN as Frontend
import spynnaker_external_devices_plugin.pyNN as ExternalDevices

# plotter in python
import pylab
import time
import random
from threading import Condition

# boolean allowing users to use python or c vis
using_c_vis = False

# initial call to set up the front end (pynn requirement)
Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)

# neurons per population and the length of runtime in ms for the simulation,
# as well as the expected weight each spike will contain
n_neurons = 100
run_time = 8000
weight_to_spike = 2.0

# neural parameters of the ifcur model used to respond to injected spikes.
# (cell params for a synfire chain)
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,
Пример #37
0
    def test_script(self):
        """
        test that tests the printing of v from a pre determined recording
        :return:
        """
        p.setup(timestep=0.1, min_delay=1.0, max_delay=14.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 = 1.7

        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(100)

        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()
Пример #38
0
# Set the run time of the execution
run_time = 3300

# Set the time step of the simulation in milliseconds
time_step = 1.0

# Set the number of neurons to simulate
n_fibers = 100

# Set the i_offset current
i_offset = 1.0

# Set the weight of input spikes
weight = 1.0

p.setup(time_step)

# spindle population
spindle_pop = p.Population(n_fibers * 2,
                           MuscleSpindle, {
                               "primary": [1] * n_fibers + [0] * n_fibers,
                               "v_thresh": 100.0,
                               "receive_port": 12345
                           },
                           label="spindle_pop")

spindle_pop.record()

# dynamic fusimotor drive
gamma_dyn = p.Population(1, p.SpikeSourcePoisson, {'rate': 70.0})
p.Projection(gamma_dyn,
Пример #39
0
model = cer.IFCurrExpSupervision
cell_params = {
    'cm': 0.25,  # nF
    'i_offset': 0.0,
    'tau_m': 10.0,
    'tau_refrac': 2.0,
    'tau_syn_E': 2.5,
    'tau_syn_I': 2.5,
    'v_reset': -70.0,
    'v_rest': -65.0,
    'v_thresh': -55.4
}

# SpiNNaker setup
ts = 0.5  # does not work at 0.4, 0.6, 0.8, why??
sim.setup(timestep=ts, min_delay=ts, max_delay=15 * ts)

sim_time = 2000.
pre_stim = []

spike_times = []
for t in pylab.arange(0, teaching_time, 2.):
    print t
    spike_times.append([t, sim_time - ts])

print spike_times, len(spike_times)
pre_stim = sim.Population(len(spike_times), sim.SpikeSourceArray,
                          {'spike_times': spike_times})

teaching_stim = sim.Population(1, sim.SpikeSourceArray,
                               {'spike_times': [teaching_time]})
Пример #40
0
"""
Synfirechain-like example
"""
#!/usr/bin/python
import spynnaker.pyNN as p
#import pyNN.nest as p
import numpy, pylab

p.setup(timestep=1, min_delay=1, max_delay=15)

nNeurons = 1 # number of neurons in each population
nSources = 1 # Number of Poisson sources

neuron_parameters = {'cm'        : 0.25, # nF
                     'i_offset'  : 2,
                     'tau_m'     : 10.0,
                     'tau_refrac': 2.0,
                     'tau_syn_E' : 0.5,
                     'tau_syn_I' : 0.5,
                     'v_reset'   : -65.0,
                     'v_rest'    : -65.0,
                     'v_thresh'  : -50.0}

populations = list()
projections = list()

poisson_params = {'rate': 100, 'start':0, 'duration' : 100000000}
poisson_params2 = {'rate': 10, 'start':0, 'duration' : 100000000}
populations.append(p.Population(nNeurons, p.IF_curr_exp, neuron_parameters, label='pop_1'))
populations.append(p.Population(nNeurons, p.IF_curr_exp, neuron_parameters, label='pop_2'))
populations[1].set_constraint(p.PlacerChipAndCoreConstraint(x=1,y=0))#{"x": 1, "y": 0})
Пример #41
0
# imports of both spynnaker and external device plugin.
import spynnaker.pyNN as Frontend
import spynnaker_external_devices_plugin.pyNN as ExternalDevices
from spynnaker_external_devices_plugin.pyNN.connections.spynnaker_live_spikes_connection import SpynnakerLiveSpikesConnection

from threading import Thread
import time
# plotter in python
import pylab
# initial call to set up the front end (pynn requirement)
Frontend.setup(timestep=0.2, min_delay=0.2, max_delay=2.0)
# neurons per population and the length of runtime in ms for the simulation,
# as well as the expected weight each spike will contain
# n_neurons = 100
run_time = 3000
# weight_to_spike = 2.0
# neural parameters of the ifcur model used to respond to injected spikes.
# (cell params for a synfire chain)
cell_params_inh = {'tau_m': 2.07, 'tau_refrac': 2.0,'tau_syn_E': 2.0, 'tau_syn_I': 2.0, 'v_reset': -84.0}
cell_params_col = {'tau_m': 2.07, 'tau_refrac': 2.0,'tau_syn_E': 2.0, 'tau_syn_I': 2.0, 'v_reset': -90.0}
# create synfire populations (if cur exp)
collector = Frontend.Population(1, Frontend.IF_curr_exp, cell_params_col, label='collector')
inh_left = Frontend.Population(1, Frontend.IF_curr_exp, cell_params_inh, label='inh_left')
inh_right = Frontend.Population(1, Frontend.IF_curr_exp, cell_params_inh, label='inh_right')
# Create injection populations

ret_left = Frontend.Population(1, ExternalDevices.SpikeInjector,{'port':12345}, label='ret_left')
# rets = []
# for x in range(0, 13):
#     rets.append(Frontend.Population(1, ExternalDevices.SpikeInjector,{'port':13400+x,}, label='ret_left_'.format(x)))
ret_right = Frontend.Population(1, ExternalDevices.SpikeInjector,{'port':12346}, label='ret_right')
Пример #42
0
import spynnaker.pyNN as sim

sim.setup(timestep=1.0, min_delay=1.0, max_delay=1.0)

simtime = 1000

pg_pop1 = sim.Population(2, sim.SpikeSourcePoisson,
                         {'rate': 10.0, 'start':0,
                          'duration':simtime}, label="pg_pop1")
pg_pop2 = sim.Population(2, sim.SpikeSourcePoisson,
                         {'rate': 10.0, 'start':0,
                          'duration':simtime}, label="pg_pop2")

pg_pop1.record()
pg_pop2.record()

sim.run(simtime)

spikes1 = pg_pop1.getSpikes(compatible_output=True)
spikes2 = pg_pop2.getSpikes(compatible_output=True)

print spikes1
print spikes2

sim.end()
Пример #43
0
def run_test(w_list, cell_para, spike_source_data):
    #Du.set_trace()
    pop_list = []
    p.setup(timestep=1.0, min_delay=1.0, max_delay=3.0)
    #input poisson layer
    input_size = w_list[0].shape[0]
    #print w_list[0].shape[0]
    #print w_list[1].shape[0]

    list = []
    for j in range(input_size):
        list.append(spike_source_data[j])
    pop_in = p.Population(input_size, p.SpikeSourceArray,
                          {'spike_times': list})

    pop_list.append(pop_in)

    #for j in range(input_size):
    #pop_in[j].spike_times = spike_source_data[j]

    #pop_in = p.Population(input_size, p.SpikeSourceArray, {'spike_times' : []})
    #for j in range(input_size):
    #    pop_in[j].spike_times = spike_source_data[j]
    #pop_list.append(pop_in)

    #count =0
    #print w_list[0].shape[0]
    for w in w_list:
        input_size = w.shape[0]
        #count = count+1
        #print count
        output_size = w.shape[1]
        #pos_w = np.copy(w)
        #pos_w[pos_w < 0] = 0
        #neg_w = np.copy(w)
        #neg_w[neg_w > 0] = 0
        conn_list_exci = []
        conn_list_inhi = []
        #k_size=in_size-out_size+1
        for x_ind in range(input_size):
            for y_ind in range(output_size):
                weights = w[x_ind][y_ind]
                #for i in range(w.shape[1]):
                if weights > 0:
                    conn_list_exci.append((x_ind, y_ind, weights, 1.))
                elif weights < 0:
                    conn_list_inhi.append((x_ind, y_ind, weights, 1.))
        #print output_size
        pop_out = p.Population(output_size, p.IF_curr_exp, cell_para)
        if len(conn_list_exci) > 0:
            p.Projection(pop_in,
                         pop_out,
                         p.FromListConnector(conn_list_exci),
                         target='excitatory')
        if len(conn_list_inhi) > 0:
            p.Projection(pop_in,
                         pop_out,
                         p.FromListConnector(conn_list_inhi),
                         target='inhibitory')
        #p.Projection(pop_in, pop_out, p.AllToAllConnector(weights = pos_w), target='excitatory')
        #p.Projection(pop_in, pop_out, p.AllToAllConnector(weights = neg_w), target='inhibitory')
        pop_list.append(pop_out)
        pop_in = pop_out

    pop_out.record()
    run_time = np.ceil(np.max(spike_source_data)[0] / 1000.) * 1000
    #print run_time
    p.run(run_time)
    spikes = pop_out.getSpikes(compatible_output=True)
    return spikes
# imports of both spynnaker and external device plugin.
import spynnaker.pyNN as Frontend
import spynnaker_external_devices_plugin.pyNN as ExternalDevices
from spynnaker_external_devices_plugin.pyNN.connections\
    .spynnaker_live_spikes_connection import SpynnakerLiveSpikesConnection
# plotter in python
import pylab
# initial call to set up the front end (pynn requirement)
Frontend.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
# neurons per population and the length of runtime in ms for the simulation,
# as well as the expected weight each spike will contain
n_neurons = 100
run_time = 8000
weight_to_spike = 2.0
# neural parameters of the ifcur model used to respond to injected spikes.
# (cell params for a synfire chain)
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}
# create synfire populations (if cur exp)
pop_forward = Frontend.Population(n_neurons, Frontend.IF_curr_exp,
                                  cell_params_lif, label='pop_forward')
# Create injection populations
injector_forward = Frontend.Population(
    n_neurons, ExternalDevices.SpikeInjector,
    {'port':12365}, label='spike_injector_forward')
# Create a connection from the injector into the populations
Frontend.Projection(injector_forward, pop_forward,
                    Frontend.OneToOneConnector(weights=weight_to_spike))
# Synfire chain connections where each neuron is connected to its next neuron
# NOTE: there is no recurrent connection so that each chain stops once it
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(
Пример #46
0
"""
Synfirechain-like example
"""
#!/usr/bin/python
import spynnaker.pyNN as p
#import pyNN.nest as p
import numpy, pylab

p.setup(timestep=1, min_delay=1, max_delay=15)

nNeurons = 1  # number of neurons in each population
nSources = 1  # Number of Poisson sources

neuron_parameters = {
    'cm': 0.25,  # nF
    'i_offset': 2,
    'tau_m': 10.0,
    'tau_refrac': 2.0,
    'tau_syn_E': 0.5,
    'tau_syn_I': 0.5,
    'v_reset': -65.0,
    'v_rest': -65.0,
    'v_thresh': -50.0
}

populations = list()
projections = list()

poisson_params = {'rate': 100, 'start': 0, 'duration': 100000000}
poisson_params2 = {'rate': 10, 'start': 0, 'duration': 100000000}
populations.append(
Пример #47
0
$ python IF_cond_exp.py <simulator>

where <simulator> is 'neuron', 'nest', etc

Andrew Davison, UNIC, CNRS
May 2006

$Id: IF_cond_exp.py 917 2011-01-31 15:23:34Z apdavison $
"""

from pyNN.utility import get_script_args
from pyNN.errors import RecordingError

import spynnaker.pyNN as p

p.setup(timestep=1.0, min_delay=1.0, max_delay=10.0, db_name='if_cond.sqlite')

cell_params = {
    'i_offset': .1,
    'tau_refrac': 3.0,
    'v_rest': -65.0,
    'v_thresh': -51.0,
    'tau_syn_E': 2.0,
    'tau_syn_I': 5.0,
    'v_reset': -70.0
}

ifcell = p.Population(1, p.IF_curr_exp, cell_params, label='IF_curr_exp')

spike_sourceE = p.Population(
    1,
    def test_get_voltage(self):
        """
        test that tests the getting of v from a pre determined recording
        :return:
        """
        p.setup(timestep=0.1, min_delay=1.0, max_delay=14.40)
        n_neurons = 200  # number of neurons in each population
        runtime = 500
        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()

        weight_to_spike = 2.0
        delay = 1.7

        loop_connections = list()
        for i in range(0, n_neurons):
            single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
                                 delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        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.FromListConnector(loop_connections)))
        projections.append(p.Projection(populations[1], populations[0],
                           p.FromListConnector(injection_connection)))

        populations[0].record_v()
        populations[0].record_gsyn()
        populations[0].record()

        p.run(runtime)

        v = populations[0].get_v(compatible_output=True)

        current_file_path = os.path.dirname(os.path.abspath(__file__))
        current_file_path = os.path.join(current_file_path, "v.data")
        pre_recorded_data = p.utility_calls.read_in_data_from_file(
            current_file_path, 0, n_neurons, 0, runtime)

        p.end()

        for spike_element, read_element in zip(v, pre_recorded_data):
            self.assertEqual(round(spike_element[0], 1),
                             round(read_element[0], 1))
            self.assertEqual(round(spike_element[1], 1),
                             round(read_element[1], 1))
            self.assertEqual(round(spike_element[2], 1),
                             round(read_element[2], 1))
    def test_inhibitory_connector_memory(self):
        p.setup(timestep=0.1, min_delay=1, max_delay=10.0)
        weight_to_spike = 10
        delay = 1
        cell_params_lif = {
            'cm': 0.25,
            'i_offset': 0.0,
            'tau_m': 20.0,
            'tau_refrac': 1.0,
            'tau_syn_E': 5.0,
            'tau_syn_I': 8.0,
            'v_reset': -70.0,
            'v_rest': -65.0,
            'v_thresh': -50.0
        }
        spike_array = {'spike_times': [0]}
        mem_access = {'spike_times': [10]}

        p_initial_spike = p.Population(1,
                                       p.SpikeSourceArray,
                                       spike_array,
                                       label="Initial spike pop")
        p_mem = p.Population(1, p.IF_curr_exp, cell_params_lif, label="Memory")
        p_out = p.Population(1, p.IF_curr_exp, cell_params_lif, label="Output")
        p_bridge = p.Population(1,
                                p.IF_curr_exp,
                                cell_params_lif,
                                label="Bridge")
        p_inhibitor = p.Population(1,
                                   p.IF_curr_exp,
                                   cell_params_lif,
                                   label="Inhibitor")
        p_access = p.Population(1,
                                p.SpikeSourceArray,
                                mem_access,
                                label="Access memory spike pop")

        p_out.record()
        p_mem.record()
        p_inhibitor.record()
        p_initial_spike.record()
        p_access.record()

        pr_initial_spike1 = p.Projection(
            p_initial_spike, p_mem,
            p.OneToOneConnector(weight_to_spike, delay))
        pr_initial_spike2 = p.Projection(
            p_initial_spike, p_inhibitor,
            p.OneToOneConnector(weight_to_spike, delay))

        pr_mem_access = p.Projection(p_access,
                                     p_inhibitor,
                                     p.OneToOneConnector(
                                         weight_to_spike, delay),
                                     target='inhibitory')

        pr_inhibitor_self = p.Projection(
            p_inhibitor, p_inhibitor,
            p.OneToOneConnector(weight_to_spike, delay))
        pr_inhibitor_bridge = p.Projection(p_inhibitor,
                                           p_bridge,
                                           p.OneToOneConnector(
                                               weight_to_spike, delay),
                                           target='inhibitory')

        pr_mem_self = p.Projection(p_mem, p_mem,
                                   p.OneToOneConnector(weight_to_spike, delay))
        pr_mem_bridge = p.Projection(
            p_mem, p_bridge, p.OneToOneConnector(weight_to_spike, delay))

        pr_bridge_output = p.Projection(
            p_bridge, p_out, p.OneToOneConnector(weight_to_spike, delay))

        pr_bridge_inhibitor = p.Projection(
            p_bridge, p_inhibitor, p.OneToOneConnector(weight_to_spike, delay))

        p_mem.record_v()
        p_mem.record_gsyn()
        p_mem.record()
        p.run(30)

        v = None
        gsyn = None
        spikes = None

        v = p_mem.get_v(compatible_output=True)
        gsyn = p_mem.get_gsyn(compatible_output=True)
        spikes = p_mem.getSpikes(compatible_output=True)

        if spikes != 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"

        # Make some graphs
        ticks = len(v) / 1

        if v != None:
            pylab.figure()
            pylab.xlabel('Time/ms')
            pylab.ylabel('v')
            pylab.title('v')
            for pos in range(0, 1, 20):
                v_for_neuron = v[pos * ticks:(pos + 1) * ticks]
                pylab.plot([i[1] for i in v_for_neuron],
                           [i[2] for i in v_for_neuron])
            pylab.show()

        if gsyn != None:
            pylab.figure()
            pylab.xlabel('Time/ms')
            pylab.ylabel('gsyn')
            pylab.title('gsyn')
            for pos in range(0, 1, 20):
                gsyn_for_neuron = gsyn[pos * ticks:(pos + 1) * ticks]
                pylab.plot([i[1] for i in gsyn_for_neuron],
                           [i[2] for i in gsyn_for_neuron])
            pylab.show()

        p.end()
"""
Synfirechain-like example
"""
#!/usr/bin/python
import spynnaker.pyNN as p
import numpy, pylab

p.setup(timestep=0.1, min_delay=1.0, max_delay=7.5)
p.set_number_of_neurons_per_core("IF_curr_exp", 100)

nNeurons = 3  # number of neurons in each population

input_cell_params = {
    'cm': 0.25,  # nF
    'i_offset': 5.0,
    'tau_m': 10.0,
    'tau_refrac': 2.0,
    'tau_syn_E': 0.5,
    'tau_syn_I': 0.5,
    'v_reset': -65.0,
    'v_rest': -65.0,
    'v_thresh': -64.4
}
'''
cell_params_lif   = {'cm'        : 0.25, # nF
                     'i_offset'  : 0.0,
                     'tau_m'     : 10.0,
                     'tau_refrac': 2.0,
                     'tau_syn_E' : 0.5,
                     'tau_syn_I' : 0.5,
                     'v_reset'   : -65.0,
    def test_get_spikes(self):
        """
        test for get spikes
        :return:
        """
        p.setup(timestep=0.1, min_delay=1.0, max_delay=14.40)
        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()

        weight_to_spike = 2.0
        delay = 1.7

        loop_connections = list()
        for i in range(0, n_neurons):
            single_connection = (i, ((i + 1) % n_neurons), weight_to_spike,
                                 delay)
            loop_connections.append(single_connection)

        injection_connection = [(0, 0, weight_to_spike, 1)]
        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.FromListConnector(loop_connections)))
        projections.append(
            p.Projection(populations[1], populations[0],
                         p.FromListConnector(injection_connection)))

        populations[0].record_v()
        populations[0].record_gsyn()
        populations[0].record()

        p.run(500)

        spikes = populations[0].getSpikes(compatible_output=True)
        pre_recorded_spikes = [[0, 3.5], [1, 6.7], [2, 9.9], [3, 13.1],
                               [4, 16.3], [5, 19.5], [6, 22.7], [7, 25.9],
                               [8, 29.1], [9, 32.3], [10, 35.5], [11, 38.7],
                               [12, 41.9], [13, 45.1], [14, 48.3], [15, 51.5],
                               [16, 54.7], [17, 57.9], [18, 61.1], [19, 64.3],
                               [20, 67.5], [21, 70.7], [22, 73.9], [23, 77.1],
                               [24, 80.3], [25, 83.5], [26, 86.7], [27, 89.9],
                               [28, 93.1], [29, 96.3], [30, 99.5], [31, 102.7],
                               [32, 105.9], [33, 109.1], [34, 112.3],
                               [35, 115.5], [36, 118.7], [37, 121.9],
                               [38, 125.1], [39, 128.3], [40, 131.5],
                               [41, 134.7], [42, 137.9], [43, 141.1],
                               [44, 144.3], [45, 147.5], [46, 150.7],
                               [47, 153.9], [48, 157.1], [49, 160.3],
                               [50, 163.5], [51, 166.7], [52, 169.9],
                               [53, 173.1], [54, 176.3], [55, 179.5],
                               [56, 182.7], [57, 185.9], [58, 189.1],
                               [59, 192.3], [60, 195.5]]

        p.end()

        for spike_element, read_element in zip(spikes, pre_recorded_spikes):
            self.assertEqual(round(spike_element[0], 1),
                             round(read_element[0], 1))
            self.assertEqual(round(spike_element[1], 1),
                             round(read_element[1], 1))
Пример #52
0
"""
Synfirechain-like example
"""
import spynnaker.pyNN as p
import pylab

p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
nNeurons = 200  # number of neurons in each population
p.set_number_of_neurons_per_core("IF_curr_exp", nNeurons / 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()

weight_to_spike = 2.0
delay = 17

loopConnections = list()
for i in range(0, nNeurons):
    singleConnection = (i, ((i + 1) % nNeurons), weight_to_spike, delay)
Пример #53
0
    return build_list(connected_indices)


def Plot_WeightDistribution(weight, bin_num, title):
    hist, bins = np.histogram(weight, bins=bin_num)
    center = (bins[:-1] + bins[1:]) / 2
    width = (bins[1] - bins[0]) * 0.7
    plt.bar(center, hist, align='center', width=width)
    plt.xlabel('Weight')
    plt.title(title)
    plt.show()


#Plot_WeightDistribution(weights_import,200,'trained weight')

sim.setup(timestep=1, min_delay=1, max_delay=144)
synapses_to_spike = 1
delay = 2
prepop_size = 256
postpop_size = 40
animation_time = 200
episode = 200
order = np.array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3])
test_order = np.array([0, 1, 2, 3])
simtime = len(test_order) * animation_time


def concatenate_time(time, iter):
    temp_time = []
    spike_time = []
    for kk in range(0, iter):
Пример #54
0
def main():
    minutes = 0
    seconds = 30
    milliseconds = 0
    run_time = minutes*60*1000 + seconds*1000 + milliseconds

    weight_to_spike = 4.

    model = sim.IF_curr_exp
    cell_params = {'cm'        : 0.25, # nF
                    'i_offset'  : 0.0,
                    'tau_m'     : 10.0,
                    'tau_refrac': 2.0,
                    'tau_syn_E' : 2.5,
                    'tau_syn_I' : 2.5,
                    'v_reset'   : -70.0,
                    'v_rest'    : -65.0,
                    'v_thresh'  : -55.4
                    }
    # Available resolutions
    # 16, 32, 64, 128
    mode = ExternalDvsEmulatorDevice.MODE_64
    cam_res = int(mode)
    cam_fps = 90
    frames_per_saccade = cam_fps/3 - 1
    polarity = ExternalDvsEmulatorDevice.MERGED_POLARITY
    output_type = ExternalDvsEmulatorDevice.OUTPUT_TIME
    history_weight = 1.0
    behaviour = VirtualCam.BEHAVE_ATTENTION
    vcam = VirtualCam("./mnist", behaviour=behaviour, fps=cam_fps, 
                      resolution=cam_res, frames_per_saccade=frames_per_saccade)
                      
    cam_params = {'mode': mode,
                  'polarity': polarity,
                  'threshold': 12,
                  'adaptive_threshold': False,
                  'fps': cam_fps,
                  'inhibition': False,
                  'output_type': output_type,
                  'save_spikes': "./spikes_from_cam.pickle",
                  'history_weight': history_weight,
                  #'device_id': 0, # for an OpenCV webcam device
                  #'device_id': 'path/to/video/file', # to encode pre-recorded video
                  'device_id': vcam,
                 }
    if polarity == ExternalDvsEmulatorDevice.MERGED_POLARITY:
        num_neurons = 2*(cam_res**2)
    else:
        num_neurons = cam_res**2
      
    sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)

    target = sim.Population(num_neurons, model, cell_params)

    stimulation = sim.Population(num_neurons, DvsEmulatorDevice, cam_params,
                                 label="Webcam population")

    connector = sim.OneToOneConnector(weights=weight_to_spike)

    projection = sim.Projection(stimulation, target, connector)

    target.record()
        
    sim.run(run_time)

    
    spikes = target.getSpikes(compatible_output=True)

    sim.end()
    #stimulation._vertex.stop()
    
    
    print ("Raster plot of the spikes that Spinnaker echoed back")
    fig = pylab.figure()
    
    spike_times = [spike_time for (neuron_id, spike_time) in spikes]
    spike_ids   = [neuron_id  for (neuron_id, spike_time) in spikes]
    
    pylab.plot(spike_times, spike_ids, ".", markerfacecolor="None",
               markeredgecolor="Blue", markersize=3)
    
    pylab.show()
import spynnaker.pyNN as spynn
import spynnaker_external_devices_plugin.pyNN as ExternalDevices
import sys
import pylab

spynn.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)

print sys.argv

numArgumentsProvided = len(sys.argv) - 1

if numArgumentsProvided == 7:
    spikeInjectionPort1 = int(sys.argv[1])
    spikeInjectionPopLabel1 = sys.argv[2]
    nNeurons1 = int(sys.argv[3])
    spikeInjectionPort2 = int(sys.argv[4])
    spikeInjectionPopLabel2 = sys.argv[5]
    nNeurons2 = int(sys.argv[6])
    runTimeMs = int(sys.argv[7])
else:
    print 'usage: ', sys.argv[
        0], ' <spikeInjectionPort1> <spikeInjectionPopLabel1> <nNeurons1> <spikeInjectionPort2> <spikeInjectionPopLabel2> <nNeurons2> <runTimeMs>'
    sys.exit(0)

#nNeurons = 784 # * 8; #MNIST 28 x 28 pixels , 8 neurons each
#runTimeMs = 1000

cell_params_lif = {
    'cm': 0.25,  # nF
    'i_offset': 0.0,
    'tau_m': 20.0,
Пример #56
0
#!/usr/bin/env python
import unittest
from spynnaker.pyNN.exceptions import ConfigurationException
import spynnaker.pyNN as pyNN
from pprint import pprint as pp
if pyNN._spinnaker is None:
    pyNN.setup(timestep=1, min_delay=1, max_delay=10.0)
nNeurons = 10
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}
spike_array = {'spike_times': [0]}


class TestingFromListConnector(unittest.TestCase):
    def test_generate_synapse_list_simulated_all_to_all(self):
        number_of_neurons = 5
        first_population = pyNN.Population(number_of_neurons, pyNN.IF_curr_exp,
                                           cell_params_lif, label="One pop")
        weight = 2
        delay = 1
        connection_list = list()
        for i in range(5):
            for j in range(5):
                connection_list.append((i, j, weight, delay))
Пример #57
0
# Population parameters
model = sim.IF_curr_exp
cell_params = {
    'cm': 0.25,  # nF
    'i_offset': 0.0,
    'tau_m': 10.0,
    'tau_refrac': 2.0,
    'tau_syn_E': 2.5,
    'tau_syn_I': 2.5,
    'v_reset': -70.0,
    'v_rest': -65.0,
    'v_thresh': -55.4
}

# SpiNNaker setup
sim.setup(timestep=1.0, min_delay=1.0, max_delay=10.0)

# Sweep times and frequencies
projections = []
sim_time = 0
for t in delta_t:
    projections.append([])
    for f in frequencies:
        # Neuron populations
        pre_pop = sim.Population(1, model, cell_params)
        post_pop = sim.Population(1, model, cell_params)

        # Stimulating populations
        pre_times = generate_fixed_frequency_test_data(f, start_time - 1,
                                                       num_pairs + 1)
        post_times = generate_fixed_frequency_test_data(