Example #1
0
 def test_multiple_connections_between_same_populations(self):
     p1 = pyNN.Population(no_neurons,
                          pyNN.IF_curr_exp,
                          cell_params_lif,
                          label="LIF Pop")
     p2 = pyNN.Population(no_neurons,
                          pyNN.IF_curr_exp,
                          cell_params_lif,
                          label="LIF Pop")
     pyNN.Projection(p1, p2, pyNN.OneToOneConnector(1, 1))
     self.assertIsInstance(
         pyNN.Projection(p1, p2, pyNN.OneToOneConnector(1, 1)), Projection,
         "Failed to create multiple connections between"
         " the same pair of populations")
Example #2
0
    def test_projection_params(self):
        populations = list()
        projection_details = list()
        populations = list()
        weight_to_spike = 2
        delay = 5
        populations.append(
            pyNN.Population(no_neurons,
                            pyNN.IF_curr_exp,
                            cell_params_lif,
                            label="LIF Pop"))
        populations.append(
            pyNN.Population(no_neurons,
                            pyNN.IF_curr_dual_exp,
                            cell_params_lif2exp,
                            label="IF_curr_dual_exp Pop"))
        populations.append(
            pyNN.Population(no_neurons,
                            pyNN.IF_cond_exp,
                            cell_params_lifexp,
                            label="IF_cond_exp Pop"))
        populations.append(
            pyNN.Population(no_neurons,
                            pyNN.IZK_curr_exp,
                            cell_params_izk,
                            label="IZK_curr_exp Pop"))

        for i in range(4):
            for j in range(4):
                projection_details.append({
                    'presyn':
                    populations[i],
                    'postsyn':
                    populations[j],
                    'connector':
                    pyNN.OneToOneConnector(weight_to_spike, delay)
                })
                projections.append(
                    pyNN.Projection(
                        populations[i], populations[j],
                        pyNN.OneToOneConnector(weight_to_spike, delay)))

        for i in range(4):
            for j in range(4):
                self.assertEqual(
                    projections[i + j]._projection_edge._pre_vertex,
                    projection_details[i + j]['presyn']._vertex)
                self.assertEqual(
                    projections[i + j]._projection_edge._post_vertex,
                    projection_details[i + j]['postsyn']._vertex)
Example #3
0
 def test_setup(self):
     global projections
     weight_to_spike = 2
     delay = 5
     populations.append(
         pyNN.Population(no_neurons,
                         pyNN.IF_curr_exp,
                         cell_params_lif,
                         label="LIF Pop"))
     populations.append(
         pyNN.Population(no_neurons,
                         pyNN.IF_curr_dual_exp,
                         cell_params_lif2exp,
                         label="IF_curr_dual_exp Pop"))
     populations.append(
         pyNN.Population(no_neurons,
                         pyNN.IF_cond_exp,
                         cell_params_lifexp,
                         label="IF_cond_exp Pop"))
     populations.append(
         pyNN.Population(no_neurons,
                         pyNN.IZK_curr_exp,
                         cell_params_izk,
                         label="IZK_curr_exp Pop"))
     populations.append(
         pyNN.Population(no_neurons,
                         pyNN.SpikeSourceArray,
                         spike_array,
                         label="SpikeSourceArray Pop"))
     populations.append(
         pyNN.Population(no_neurons,
                         pyNN.SpikeSourcePoisson,
                         spike_array_poisson,
                         label="SpikeSourcePoisson Pop"))
     for i in range(4):
         projection_details.append({
             'presyn':
             populations[0],
             'postsyn':
             populations[i],
             'connector':
             pyNN.OneToOneConnector(weight_to_spike, delay)
         })
         projections.append(
             pyNN.Projection(populations[0], populations[i],
                             pyNN.OneToOneConnector(weight_to_spike,
                                                    delay)))
Example #4
0
 def test_source_populations_as_postsynaptic(self):
     global projections
     weight_to_spike = 2
     delay = 5
     with self.assertRaises(exc.ConfigurationException):
         for i in range(4, 6):
             projections.append(
                 pyNN.Projection(
                     populations[0], populations[i],
                     pyNN.OneToOneConnector(weight_to_spike, delay)))
Example #5
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()
Example #6
0
    def test_inhibitory_connector(self):
        weight_to_spike = 2
        delay = 5
        p1 = pyNN.Population(no_neurons,
                             pyNN.IF_curr_exp,
                             cell_params_lif,
                             label="LIF Pop")
        p2 = pyNN.Population(no_neurons,
                             pyNN.IF_curr_exp,
                             cell_params_lif,
                             label="LIF Pop")

        s12_2 = pyNN.Projection(p1,
                                p2,
                                pyNN.OneToOneConnector(weight_to_spike, delay),
                                target='inhibitory')
        s21 = pyNN.Projection(p2,
                              p1,
                              pyNN.OneToOneConnector(weight_to_spike, delay),
                              target='excitatory')
 def test_connector_populations_of_different_sizes(self):
     weight = 2
     delay = 5
     p1 = pyNN.Population(10,
                          pyNN.IF_curr_exp,
                          cell_params_lif,
                          label="pop 1")
     p2 = pyNN.Population(5,
                          pyNN.IF_curr_exp,
                          cell_params_lif,
                          label="pop 2")
     with self.assertRaises(ConfigurationException):
         pyNN.Projection(p1, p2, pyNN.OneToOneConnector(weight, delay))
Example #8
0
 def test_one_to_one_connector_from_high_to_low(self):
     weight_to_spike, delay = 2, 5
     second_population = pyNN.Population(no_neurons,
                                         pyNN.IF_curr_exp,
                                         cell_params_lif,
                                         label="LIF Pop")
     different_population = pyNN.Population(
         20,
         pyNN.IF_curr_exp,
         cell_params_lif,
         label="A random sized population")
     with self.assertRaises(exc.ConfigurationException):
         pyNN.Projection(different_population, second_population,
                         pyNN.OneToOneConnector(weight_to_spike, delay))
 def test_synapse_list_generation_for_different_sized_populations(self):
     number_of_neurons = 10
     first_population = pyNN.Population(number_of_neurons,
                                        pyNN.IF_curr_exp,
                                        cell_params_lif,
                                        label="One pop")
     second_population = pyNN.Population(number_of_neurons + 5,
                                         pyNN.IF_curr_exp,
                                         cell_params_lif,
                                         label="Second pop")
     weight = 2
     delay = 1
     connection = pyNN.OneToOneConnector(weight, delay)
     with self.assertRaises(ConfigurationException):
         connection.generate_synapse_list(first_population,
                                          second_population, 1, 1.0, 0)
 def test_self_connect_population(self):
     number_of_neurons = 10
     first_population = pyNN.Population(number_of_neurons,
                                        pyNN.IF_curr_exp,
                                        cell_params_lif,
                                        label="One pop")
     weight = 2
     delay = 1
     synapse_type = 0
     connection = pyNN.OneToOneConnector(weight, delay)
     synaptic_list = connection.generate_synapse_list(
         first_population, first_population, 1, 1.0, synapse_type)
     self.assertEqual(synaptic_list.get_max_weight(), weight)
     self.assertEqual(synaptic_list.get_min_weight(), weight)
     pp(synaptic_list.get_rows())
     self.assertEqual(synaptic_list.get_n_rows(), number_of_neurons)
     self.assertEqual(synaptic_list.get_max_delay(), delay)
     self.assertEqual(synaptic_list.get_min_delay(), delay)
Example #11
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()
Example #12
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
Example #13
0
 def test_connect_two_different_populations(self):
     number_of_neurons = 10
     first_population = pyNN.Population(number_of_neurons,
                                        pyNN.IF_curr_exp,
                                        cell_params_lif,
                                        label="One pop")
     second_population = pyNN.Population(number_of_neurons,
                                         pyNN.IF_curr_exp,
                                         cell_params_lif,
                                         label="Second pop")
     weight = 2
     delay = 1
     synapse_type = first_population._vertex.get_synapse_id('excitatory')
     connection = pyNN.OneToOneConnector(weight, delay)
     synaptic_list = connection.generate_synapse_list(
         first_population, second_population, 1, 1.0, synapse_type)
     self.assertEqual(synaptic_list.get_max_weight(), weight)
     self.assertEqual(synaptic_list.get_min_weight(), weight)
     pp(synaptic_list.get_rows())
     self.assertEqual(synaptic_list.get_n_rows(), number_of_neurons)
     self.assertEqual(synaptic_list.get_max_delay(), delay)
     self.assertEqual(synaptic_list.get_min_delay(), delay)
Example #14
0
                                   cell_params_lif,
                                   label='pop_backward')

# Create injection populations
injector_forward = Frontend.Population(n_neurons,
                                       ExternalDevices.SpikeInjector,
                                       cell_params_spike_injector_with_key,
                                       label='spike_injector_forward')
injector_backward = Frontend.Population(n_neurons,
                                        ExternalDevices.SpikeInjector,
                                        cell_params_spike_injector,
                                        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, n_neurons - 1):
    loop_forward.append((i, (i + 1) % n_neurons, weight_to_spike, 3))
    loop_backward.append(((i + 1) % 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))
Example #15
0
# 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,
             spindle_pop,
             p.OneToOneConnector(weights=weight),
             target="dynamic")

# static fusimotor drive
gamma_st = p.Population(1, p.SpikeSourcePoisson, {'rate': 40.0})
p.Projection(gamma_st,
             spindle_pop,
             p.OneToOneConnector(weights=weight),
             target="static")

# database for live communication
spynnaker_external_devices = SpynnakerExternalDevicePluginManager()


def create_database():
    database_notify_port_num = conf.config.getint("Database", "notify_port")
Example #16
0
    ]})
post_stim = sim.Population(
    pop_size, sim.SpikeSourceArray, {
        'spike_times': [
            [
                i for i in range(pairing_start_time, pairing_end_time,
                                 time_between_pairs)
            ],
        ]
    })

# +-------------------------------------------------------------------+
# | Creation of connections                                           |
# +-------------------------------------------------------------------+
# Connection type between noise poisson generator and excitatory populations
ee_connector = sim.OneToOneConnector(weights=2)

sim.Projection(pre_stim, pre_pop, ee_connector, target='excitatory')
sim.Projection(post_stim, post_pop, ee_connector, target='excitatory')

# Plastic Connections between pre_pop and post_pop
stdp_model = sim.STDPMechanism(
    timing_dependence=sim.SpikePairRule(tau_plus=20.0, tau_minus=50.0),
    weight_dependence=sim.AdditiveWeightDependence(w_min=0,
                                                   w_max=1,
                                                   A_plus=0.02,
                                                   A_minus=0.02))

sim.Projection(pre_pop,
               post_pop,
               sim.OneToOneConnector(),
Example #17
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()
Example #18
0
import spynnaker.pyNN as p

p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0)
nNeurons = 100
#p.set_number_of_neurons_per_core("IF_curr_exp", nNeurons)

input = p.Population(1024, p.SpikeSourcePoisson, {'rate': 10}, "input")
relay_on = p.Population(1024, p.IF_curr_exp, {}, "input")

weight_to_spike = 2.0
delay = 17


t_rule_LGN = p.SpikePairRule (tau_plus=17, tau_minus=34)
w_rule_LGN = p.AdditiveWeightDependence (w_min=0.0, w_max=0.3, A_plus=0.01, A_minus=0.0085)
stdp_model_LGN = p.STDPMechanism (timing_dependence = t_rule_LGN, weight_dependence = w_rule_LGN)
s_d_LGN = p.SynapseDynamics(slow = stdp_model_LGN)
in_to_relay_on = p.Projection(input, relay_on, p.OneToOneConnector(weights=1),synapse_dynamics = s_d_LGN, target='excitatory')

p.run(1000)
p.end()

Example #19
0
# | Creation of neuron populations                                    |
# +-------------------------------------------------------------------+
# Neuron populations
pre_pop = p.Population(pop_size, model, cell_params)
post_pop = p.Population(pop_size, model, cell_params)


# Stimulating populations
pre_stim = p.Population(pop_size, p.SpikeSourceArray, {'spike_times': [[i for i in range(0, sim_time, time_between_pairs)],]})
post_stim = p.Population(pop_size, p.SpikeSourceArray, {'spike_times': [[i for i in range(pairing_start_time, pairing_end_time, time_between_pairs)],]})

# +-------------------------------------------------------------------+
# | Creation of connections                                           |
# +-------------------------------------------------------------------+
# Connection type between noise poisson generator and excitatory populations
ee_connector = p.OneToOneConnector(weights=2)

p.Projection(pre_stim, pre_pop, ee_connector, target='excitatory')
p.Projection(post_stim, post_pop, ee_connector, target='excitatory')

# Plastic Connections between pre_pop and post_pop
stdp_model = p.STDPMechanism(
  timing_dependence = p.SpikePairRule(tau_plus = 20.0, tau_minus = 50.0),
  weight_dependence = p.AdditiveWeightDependence(w_min = 0, w_max = 1, A_plus=0.02, A_minus = 0.02)
)

p.Projection(pre_pop, post_pop, p.OneToOneConnector(),
  synapse_dynamics = p.SynapseDynamics(slow= stdp_model)
)

# Record spikes
                       [i[2] for i in v_for_neuron])


p.setup(time_step)

input_pop = p.Population(1,
                         p.SpikeSourceArray, {"spike_times": spike_times},
                         label="input")

my_model_pop = p.Population(1,
                            MyModelCurrExp, {
                                "my_parameter": -70.0,
                                "i_offset": i_offset,
                            },
                            label="my_model_pop")
p.Projection(input_pop, my_model_pop, p.OneToOneConnector(weights=weight))

my_model_my_synapse_type_pop = p.Population(
    1,
    MyModelCurrMySynapseType, {
        "my_parameter": -70.0,
        "i_offset": i_offset,
        "my_ex_synapse_parameter": 0.5
    },
    label="my_model_my_synapse_type_pop")
p.Projection(input_pop, my_model_my_synapse_type_pop,
             p.OneToOneConnector(weights=weight))

my_model_my_additional_input_pop = p.Population(
    1,
    MyModelCurrExpMyAdditionalInput, {
Example #21
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]
Example #22
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()
pynn.setup(timestep=ts, min_delay=ts, max_delay=2.0 * ts)

pop = pynn.Population(size=n_neurons,
                      cellclass=pynn.IF_curr_exp,
                      cellparams={},
                      label='pop')

# The ROS_Spinnaker_Interface just needs to be initialised with these two Spike Source Parameters.
ros_interface = ROS_Spinnaker_Interface(
    n_neurons_source=n_neurons,  # number of neurons of the injector population
    Spike_Source_Class=SpikeSourcePoisson
)  # the transfer function ROS Input -> Spikes you want to use.

# Build your network, run the simulation and optionally record the spikes and voltages.
pynn.Projection(ros_interface, pop, pynn.OneToOneConnector(weights=5,
                                                           delays=1))

pop.record()
pop.record_v()

pynn.run(simulation_time)

spikes = pop.getSpikes()

pynn.end()

# Plot
import pylab

spike_times = [spike[1] for spike in spikes]
spike_ids = [spike[0] for spike in spikes]
Example #24
0
        post_times = generate_fixed_frequency_test_data(
            f, start_time + t, num_pairs)
        pre_stim = sim.Population(1, sim.SpikeSourceArray,
                                  {'spike_times': [
                                      pre_times,
                                  ]})
        post_stim = sim.Population(1, sim.SpikeSourceArray,
                                   {'spike_times': [
                                       post_times,
                                   ]})

        # Update simulation time
        sim_time = max(sim_time, max(max(pre_times), max(post_times)) + 100)

        # Connections between spike sources and neuron populations
        ee_connector = sim.OneToOneConnector(weights=2)
        sim.Projection(pre_stim, pre_pop, ee_connector, target='excitatory')
        sim.Projection(post_stim, post_pop, ee_connector, target='excitatory')

        # **HACK**
        param_scale = 0.5

        # Plastic Connection between pre_pop and post_pop
        # Sjostrom visual cortex min-triplet params
        stdp_model = sim.STDPMechanism(
            timing_dependence=sim.PfisterSpikeTripletRule(tau_plus=16.8,
                                                          tau_minus=33.7,
                                                          tau_x=101,
                                                          tau_y=114),
            weight_dependence=sim.AdditiveWeightDependence(
                w_min=0.0,
Example #25
0
               label="INH2INH_conn",
               target='inhibitory')

poisson_rate = 500.0
pop_poisson_exc_p = sim.Population(len(exc_neuron_idx), sim.SpikeSourcePoisson,
                                   {"rate": poisson_rate})
pop_poisson_exc_n = sim.Population(len(exc_neuron_idx), sim.SpikeSourcePoisson,
                                   {"rate": poisson_rate})
pop_poisson_inh_p = sim.Population(len(inh_neuron_idx), sim.SpikeSourcePoisson,
                                   {"rate": poisson_rate})
pop_poisson_inh_n = sim.Population(len(inh_neuron_idx), sim.SpikeSourcePoisson,
                                   {"rate": poisson_rate})

poisson_weight = 0.005
sim.Projection(pop_poisson_exc_p, pop_lsm_exc,
               sim.OneToOneConnector(weights=poisson_weight))
sim.Projection(pop_poisson_exc_n, pop_lsm_exc,
               sim.OneToOneConnector(weights=-poisson_weight))
sim.Projection(pop_poisson_inh_p, pop_lsm_inh,
               sim.OneToOneConnector(weights=poisson_weight))
sim.Projection(pop_poisson_inh_n, pop_lsm_inh,
               sim.OneToOneConnector(weights=-poisson_weight))

#
# INPUT - Setup
#

print "Liquid->Liquid connections... Input Setup"

tspk = simulation_timestep * 50  # The neurons spike after 50 time steps!
number_of_spikes = 500
    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()
Example #27
0
                                                   w_max=1.0,
                                                   A_plus=0.1,
                                                   A_minus=0.5))

# Connections between spike sources and neuron populations
####### SET HERE THE PARALLEL FIBER-PURKINJE CELL LEARNING RULE
ee_connector = sim.AllToAllConnector(weights=0.5)
projection_pf = sim.Projection(
    pre_stim,
    population,
    ee_connector,
    synapse_dynamics=sim.SynapseDynamics(slow=stdp_model),
    target='excitatory')

# SET HERE THE TEACHING SIGNAL PROJECTION
ee_connector = sim.OneToOneConnector()
proj_teaching = sim.Projection(teaching_stim,
                               population,
                               ee_connector,
                               target='supervision')

print("Simulating for %us" % (sim_time / 1000))

# Run simulation
sim.run(sim_time)

# Get weight from each projection
end_w = projection_pf.getWeights(
)  #[p.getWeights()[0] for p in projections_pf]
print end_w
                                   label=spikeInjectionPopLabel1)
populations.append(pop_spikes_in_1)
pop_spikes_in_2 = spynn.Population(nNeurons2,
                                   ExternalDevices.SpikeInjector,
                                   cell_params_spike_injector_2,
                                   label=spikeInjectionPopLabel2)
populations.append(pop_spikes_in_2)

pop_spikes_out_1.record()
#ExternalDevices.activate_live_output_for(pop_spikes_out_1)
pop_spikes_out_2.record()
#ExternalDevices.activate_live_output_for(pop_spikes_out_2)

projections.append(
    spynn.Projection(pop_spikes_in_1, pop_spikes_out_1,
                     spynn.OneToOneConnector(weights=weight_to_spike)))
projections.append(
    spynn.Projection(pop_spikes_in_2, pop_spikes_out_2,
                     spynn.OneToOneConnector(weights=weight_to_spike)))

spynn.run(runTimeMs + 1000)  #add extra second to get all downstream spikes

spikes1 = pop_spikes_out_1.getSpikes(compatible_output=True)
spikes2 = pop_spikes_out_2.getSpikes(compatible_output=True)
#For raster plot of all together, we need to convert neuron ids to be global not local to each pop
for j in spikes2:
    j[0] = j[0] + nNeurons1

totalSpikes = len(spikes1) + len(spikes1)
print 'Total spikes generated: ', totalSpikes
if totalSpikes > 0:
populations.append(
    p.Population(1, p.SpikeSourceArray, spikeArray, label='pop_0'))
#populations.append(p.Population(nNeurons, p.IF_curr_exp, input_cell_params, label='pop_0'))
populations.append(
    p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_1'))
populations.append(
    p.Population(nNeurons, p.IF_curr_exp, cell_params_lif, label='pop_2'))

#projections.append(p.Projection(populations[0], populations[1], p.OneToOneConnector(weights=weight_to_spike, delays=delay)))
projections.append(
    p.Projection(
        populations[0], populations[1],
        p.AllToAllConnector(weights=weight_to_spike, delays=injection_delay)))
projections.append(
    p.Projection(populations[1], populations[2],
                 p.OneToOneConnector(weights=weight_to_spike, delays=delay)))
#projections.append(p.Projection(populations[1], populations[0], p.FromListConnector([(0, 0, weight_to_spike, injection_delay)])))

populations[1].record_v()
populations[1].record()

p.run(100)

v = None
gsyn = None
spikes = None

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

if spikes != None:
Example #30
0
ros_interface = ROS_Spinnaker_Interface(
    Spike_Sink_Class=
    SpikeSinkSmoothing,  # the transfer function Spikes -> ROS Output you want to use.
    # You can choose from the transfer_functions module
    # or write one yourself.
    output_population=pop)  # the pynn population you wish to receive the
# live spikes from.

# Notice that ros_interface will now be None, because there is no SpikeInjector for receiver only.
# You need a different Spike Source.

# Build your network, run the simulation and optionally record the spikes and voltages.

spike_source = pynn.Population(n_neurons, pynn.SpikeSourcePoisson,
                               {'rate': 10})
pynn.Projection(spike_source, pop, pynn.OneToOneConnector(weights=5, delays=1))

pop.record()
pop.record_v()

pynn.run(simulation_time)

spikes = pop.getSpikes()

pynn.end()

# Plot
import pylab

spike_times = [spike[1] for spike in spikes]
spike_ids = [spike[0] for spike in spikes]