def test_script(self): """ test that tests the printing of v from a pre determined recording :return: """ p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) n_neurons = 128 * 128 # number of neurons in each population p.set_number_of_neurons_per_core("IF_cond_exp", 256) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0, 'e_rev_E': 0., 'e_rev_I': -80. } populations = list() projections = list() weight_to_spike = 0.035 delay = 17 spikes = read_spikefile('test.spikes', n_neurons) print spikes spike_array = {'spike_times': spikes} populations.append(p.Population( n_neurons, p.SpikeSourceArray, spike_array, label='inputSpikes_1')) populations.append(p.Population( n_neurons, p.IF_cond_exp, cell_params_lif, label='pop_1')) projections.append(p.Projection( populations[0], populations[1], p.OneToOneConnector( weights=weight_to_spike, delays=delay))) populations[1].record() p.run(1000) spikes = populations[1].getSpikes(compatible_output=True) if spikes is not None: print spikes pylab.figure() pylab.plot([i[1] for i in spikes], [i[0] for i in spikes], ".") pylab.xlabel('Time/ms') pylab.ylabel('spikes') pylab.title('spikes') pylab.show() else: print "No spikes received" p.end()
def test_recording_numerious_element(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 test_recording_numerious_element_over_limit(self): p.setup(timestep=1.0, min_delay=1.0, max_delay=144.0) n_neurons = 2000 # number of neurons in each population p.set_number_of_neurons_per_core("IF_curr_exp", n_neurons / 2) cell_params_lif = {'cm': 0.25, 'i_offset': 0.0, 'tau_m': 20.0, 'tau_refrac': 2.0, 'tau_syn_E': 5.0, 'tau_syn_I': 5.0, 'v_reset': -70.0, 'v_rest': -65.0, 'v_thresh': -50.0 } populations = list() projections = list() boxed_array = numpy.zeros(shape=(0, 2)) spike_array = list() for neuron_id in range(0, n_neurons): spike_array.append(list()) for random_time in range(0, 200000): random_time2 = random.randint(0, 50000) boxed_array = numpy.append( boxed_array, [[neuron_id, random_time2]], axis=0) spike_array[neuron_id].append(random_time) spike_array_params = {'spike_times': spike_array} populations.append(p.Population(n_neurons, p.IF_curr_exp, cell_params_lif, label='pop_1')) populations.append(p.Population(n_neurons, p.SpikeSourceArray, spike_array_params, label='inputSpikes_1')) projections.append(p.Projection(populations[1], populations[0], p.OneToOneConnector())) populations[1].record() p.run(50000) spike_array_spikes = populations[1].getSpikes() boxed_array = boxed_array[numpy.lexsort((boxed_array[:, 1], boxed_array[:, 0]))] numpy.testing.assert_array_equal(spike_array_spikes, boxed_array) p.end()
def test_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()
def test_get_weights(self): # Population parameters cell_params = { 'cm': 0.2, # nF 'i_offset': 0.2, 'tau_m': 20.0, 'tau_refrac': 5.0, 'tau_syn_E': 5.0, 'tau_syn_I': 10.0, 'v_reset': -60.0, 'v_rest': -60.0, 'v_thresh': -50.0 } # Reduce number of neurons to simulate on each core sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 10) # Build inhibitory plasticity model stdp_model = sim.STDPMechanism( timing_dependence=sim.SpikePairRule(tau_plus=20.0, tau_minus=12.7, nearest=True), weight_dependence=sim.AdditiveWeightDependence(w_min=0.0, w_max=1.0, A_plus=0.05), mad=True) # Build plastic network plastic_ex_pop, plastic_ie_projection =\ self.build_network(sim.SynapseDynamics(slow=stdp_model), cell_params) # Run simulation sim.run(1000) # Get plastic spikes and save to disk plastic_spikes = plastic_ex_pop.getSpikes(compatible_output=True) #numpy.save("plastic_spikes.npy", plastic_spikes) plastic_weights = plastic_ie_projection.getWeights(format="array") # mean_weight = numpy.average(plastic_weights) # End simulation on SpiNNaker sim.end()
def test_get_weights(self): # Population parameters cell_params = { 'cm': 0.2, # nF 'i_offset': 0.2, 'tau_m': 20.0, 'tau_refrac': 5.0, 'tau_syn_E': 5.0, 'tau_syn_I': 10.0, 'v_reset': -60.0, 'v_rest': -60.0, 'v_thresh': -50.0 } # Reduce number of neurons to simulate on each core sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100) # Build inhibitory plasticity model stdp_model = sim.STDPMechanism( timing_dependence=sim.SpikePairRule( tau_plus=20.0, tau_minus=12.7, nearest=True), weight_dependence=sim.AdditiveWeightDependence( w_min=0.0, w_max=1.0, A_plus=0.05), mad=True ) # Build plastic network plastic_ex_pop, plastic_ie_projection =\ self.build_network(sim.SynapseDynamics(slow=stdp_model), cell_params) # Run simulation sim.run(10000) # Get plastic spikes and save to disk plastic_spikes = plastic_ex_pop.getSpikes(compatible_output=True) #numpy.save("plastic_spikes.npy", plastic_spikes) plastic_weights = plastic_ie_projection.getWeights(format="array") # mean_weight = numpy.average(plastic_weights) # End simulation on SpiNNaker sim.end()
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()
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 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()
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)
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))
'v_rest' : -65.0, 'v_thresh' : -55.4 } # Other simulation parameters e_rate = 200 in_rate = 350 n_stim_test = 5 n_stim_pairing = 10 dur_stim = 20 pop_size = 40 sim.set_number_of_neurons_per_core(model, 10) ISI = 150. start_test_pre_pairing = 200. start_pairing = 1500. start_test_post_pairing = 700. simtime = start_pairing + start_test_post_pairing + ISI*(n_stim_pairing + n_stim_test ) + 550. # let's make it 5000 # Initialisations of the different types of populations IAddPre = [] IAddPost = [] # +-------------------------------------------------------------------+ # | Creation of neuron populations | # +-------------------------------------------------------------------+
""" 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)
spike_list = {'spike_times': [float(x) for x in range(0, 599, 50)]} #p.setup(timestep=1.0, min_delay = 1.0, max_delay = 32.0) p.setup(timestep=1.0, min_delay=1.0, max_delay=32.0) #p.set_number_of_neurons_per_core("SpikeSourceArray", 256) #FAILS #nNeurons = (256*3)-2 # number of neurons in each population #FAIL #p.set_number_of_neurons_per_core("SpikeSourceArray", 6) # works #nNeurons = 18 # number of neurons in each population # works #p.set_number_of_neurons_per_core("SpikeSourceArray", 200) #FAILS #nNeurons = (600) # number of neurons in each population #FAIL #p.set_number_of_neurons_per_core("SpikeSourceArray", 150) #FAILS #nNeurons = (600) # number of neurons in each population #FAIL #p.set_number_of_neurons_per_core("SpikeSourceArray", 100) #FAILS #nNeurons = (600) # number of neurons in each population #FAIL p.set_number_of_neurons_per_core("SpikeSourceArray", 100) #FAILS nNeurons = (600) # number of neurons in each population #FAIL populations = list() projections = list() populations.append( p.Population(nNeurons, p.SpikeSourceArray, spike_list, label='input')) populations.append( p.Population(1, p.IF_curr_exp, cell_params_lif, label='pop_1')) projections.append( p.Projection(populations[0], populations[1], p.AllToAllConnector())) populations[0].record() p.run(1000)
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 = {} exc_cells = Population(n_reservoir_exc, pynn.IF_curr_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_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()
spike_list = {'spike_times': [float(x) for x in range(0, 599, 50)]} #p.setup(timestep=1.0, min_delay = 1.0, max_delay = 32.0) p.setup(timestep=1.0, min_delay = 1.0, max_delay = 32.0) #p.set_number_of_neurons_per_core("SpikeSourceArray", 256) #FAILS #nNeurons = (256*3)-2 # number of neurons in each population #FAIL #p.set_number_of_neurons_per_core("SpikeSourceArray", 6) # works #nNeurons = 18 # number of neurons in each population # works #p.set_number_of_neurons_per_core("SpikeSourceArray", 200) #FAILS #nNeurons = (600) # number of neurons in each population #FAIL #p.set_number_of_neurons_per_core("SpikeSourceArray", 150) #FAILS #nNeurons = (600) # number of neurons in each population #FAIL #p.set_number_of_neurons_per_core("SpikeSourceArray", 100) #FAILS #nNeurons = (600) # number of neurons in each population #FAIL p.set_number_of_neurons_per_core("SpikeSourceArray", 100) #FAILS nNeurons = (600) # number of neurons in each population #FAIL populations = list() projections = list() populations.append(p.Population(nNeurons, p.SpikeSourceArray, spike_list, label='input')) populations.append(p.Population(1, p.IF_curr_exp, cell_params_lif, label='pop_1')) projections.append(p.Projection(populations[0], populations[1], p.AllToAllConnector())) populations[0].record() p.run(1000) spikes = populations[0].getSpikes(compatible_output=True)
""" Synfirechain-like example """ import spynnaker.pyNN as p import pylab from fake_if_curr import FakeIFCurrExp 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(FakeIFCurrExp, 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):
'tau_m' : 20.0, 'tau_refrac': 5.0, 'tau_syn_E' : 5.0, 'tau_syn_I' : 10.0, 'v_reset' : -60.0, 'v_rest' : -60.0, 'v_thresh' : -50.0 } # How large should the population of excitatory neurons be? # (Number of inhibitory neurons is proportional to this) NUM_EXCITATORY = 2000 # Reduce number of neurons to simulate on each core sim.set_number_of_neurons_per_core(sim.IF_curr_exp, 100) # Function to build the basic network - dynamics should be a PyNN synapse dynamics object 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')
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))
""" Synfirechain-like example """ import spynnaker.pyNN as p import pylab from fake_if_curr import FakeIFCurrExp 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(FakeIFCurrExp, 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):
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)
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_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))
""" Synfirechain-like example """ #!/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", 10) 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 = 1
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))
""" 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):
"v_rest": -65.0, "v_thresh": -55.4, } # Other simulation parameters e_rate = 200 in_rate = 350 n_stim_test = 5 n_stim_pairing = 10 dur_stim = 20 pop_size = 40 sim.set_number_of_neurons_per_core(model, 10) ISI = 150.0 start_test_pre_pairing = 200.0 start_pairing = 1500.0 start_test_post_pairing = 700.0 simtime = start_pairing + start_test_post_pairing + ISI * (n_stim_pairing + n_stim_test) + 550.0 # let's make it 5000 # Initialisations of the different types of populations IAddPre = [] IAddPost = [] # +-------------------------------------------------------------------+ # | Creation of neuron populations | # +-------------------------------------------------------------------+